Qu'est-ce que Rclone ?

Rclone est un outil en ligne de commande open-source permettant de gérer des fichiers sur plus de 70 services de stockage cloud. Souvent qualifié de "rsync pour le cloud", il offre des fonctionnalités avancées de synchronisation, transfert, chiffrement et montage de systèmes de fichiers distants.

Architecture Interne

Rclone fonctionne selon une architecture modulaire composée de plusieurs couches. Au cœur se trouve le Rclone Core qui gère les opérations de base. Au-dessus, trois couches principales interagissent : la VFS Layer pour le montage et le cache, la Crypt Layer pour le chiffrement côté client, et la Chunker Layer pour le découpage des gros fichiers.

Ces couches communiquent avec une Backend Abstraction qui uniformise l'accès aux différents providers : S3/R2, Google Drive, SFTP, Backblaze B2, WebDAV, et bien d'autres.

Prérequis Système

Composant	Minimum	Recommandé
RAM	512 MB	2 GB+
CPU	1 vCPU	2+ vCPU
Stockage	100 MB	1 GB (cache)
Kernel	3.10+	5.4+ (FUSE3)
OS	Ubuntu 18.04+	Ubuntu 22.04/24.04

Installation Avancée

Méthode 1 : Installation via Script Officiel (Recommandée)

# Installation avec vérification de signature
curl -fsSL https://rclone.org/install.sh | sudo bash

# Vérification de l'installation
rclone version

Méthode 2 : Installation Manuelle (Contrôle Total)

# Définir la version souhaitée
RCLONE_VERSION="v1.68.2"
ARCH="amd64"  # ou arm64 pour ARM

# Téléchargement et extraction
cd /tmp
curl -LO "https://downloads.rclone.org/${RCLONE_VERSION}/rclone-${RCLONE_VERSION}-linux-${ARCH}.zip"
unzip rclone-${RCLONE_VERSION}-linux-${ARCH}.zip
cd rclone-${RCLONE_VERSION}-linux-${ARCH}

# Installation binaire
sudo cp rclone /usr/local/bin/
sudo chmod 755 /usr/local/bin/rclone

# Installation des pages man
sudo mkdir -p /usr/local/share/man/man1
sudo cp rclone.1 /usr/local/share/man/man1/
sudo mandb

# Installation autocomplétion (Bash)
rclone completion bash | sudo tee /etc/bash_completion.d/rclone > /dev/null

# Installation autocomplétion (Zsh)
rclone completion zsh | sudo tee /usr/local/share/zsh/site-functions/_rclone > /dev/null

Méthode 3 : Compilation depuis les Sources

# Prérequis Go 1.21+
sudo apt update && sudo apt install -y golang-go git

# Clonage et compilation
git clone https://github.com/rclone/rclone.git
cd rclone
go build -ldflags "-s -w" -o rclone

# Installation
sudo mv rclone /usr/local/bin/

Installation des Dépendances FUSE

# Ubuntu/Debian
sudo apt update
sudo apt install -y fuse3 libfuse3-dev

# Activer FUSE pour les utilisateurs non-root
sudo sed -i 's/#user_allow_other/user_allow_other/' /etc/fuse.conf

Configuration Multi-Provider

Structure du Fichier de Configuration

Le fichier de configuration par défaut se trouve à ~/.config/rclone/rclone.conf. Sa structure INI supporte de multiples remotes.

# ~/.config/rclone/rclone.conf

[gdrive]
type = drive
client_id = YOUR_CLIENT_ID.apps.googleusercontent.com
client_secret = YOUR_CLIENT_SECRET
scope = drive
token = {"access_token":"...","token_type":"Bearer","refresh_token":"...","expiry":"..."}
team_drive = 

[s3-aws]
type = s3
provider = AWS
access_key_id = AKIAIOSFODNN7EXAMPLE
secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
region = eu-west-1
acl = private
storage_class = STANDARD_IA

[s3-r2]
type = s3
provider = Cloudflare
access_key_id = YOUR_R2_ACCESS_KEY
secret_access_key = YOUR_R2_SECRET_KEY
endpoint = https://YOUR_ACCOUNT_ID.r2.cloudflarestorage.com
acl = private

[b2]
type = b2
account = YOUR_APPLICATION_KEY_ID
key = YOUR_APPLICATION_KEY
hard_delete = true

[sftp-backup]
type = sftp
host = backup.example.com
user = backupuser
port = 22
key_file = ~/.ssh/backup_key
shell_type = unix
md5sum_command = md5sum
sha1sum_command = sha1sum

Configuration Interactive

# Lancer l'assistant de configuration
rclone config

# Commandes du menu interactif
# n) New remote
# d) Delete remote
# r) Rename remote
# c) Copy remote
# s) Set configuration password
# q) Quit config

Configuration Google Drive (Headless VPS)

Pour configurer Google Drive sur un VPS sans interface graphique :

# Sur votre machine locale avec navigateur
rclone authorize "drive"

# Copier le token généré, puis sur le VPS
rclone config

# Sélectionner : n (new remote)
# Name : gdrive
# Storage : drive
# client_id : (laisser vide ou utiliser le vôtre)
# client_secret : (laisser vide ou utiliser le vôtre)
# scope : drive
# service_account_file : (laisser vide)
# Edit advanced config : n
# Use auto config : n
# Coller le token obtenu sur la machine locale

Configuration avec Service Account (Google Workspace)

# Créer le répertoire pour les credentials
mkdir -p ~/.config/rclone/sa

# Placer le fichier JSON du service account
# ~/.config/rclone/sa/service-account.json

[gdrive-sa]
type = drive
scope = drive
service_account_file = /home/user/.config/rclone/sa/service-account.json
team_drive = 0ABCdefGHIjklMNOpqr

Configuration S3 Compatible (MinIO, Wasabi, etc.)

[minio]
type = s3
provider = Minio
access_key_id = minioadmin
secret_access_key = minioadmin
endpoint = http://localhost:9000
acl = private

[wasabi]
type = s3
provider = Wasabi
access_key_id = YOUR_WASABI_KEY
secret_access_key = YOUR_WASABI_SECRET
region = eu-central-1
endpoint = s3.eu-central-1.wasabisys.com

Commandes Fondamentales

Syntaxe Générale

rclone [options] subcommand <source> [<destination>] [flags]

Commandes de Base

Listing et Navigation

# Lister les remotes configurés
rclone listremotes

# Lister le contenu d'un remote
rclone ls gdrive:
rclone ls gdrive:Documents/

# Listing détaillé avec taille et date
rclone lsl gdrive:

# Listing en format JSON (pour scripting)
rclone lsjson gdrive: --recursive

# Afficher uniquement les répertoires
rclone lsd gdrive:

# Arborescence complète
rclone tree gdrive:Projects/ --level 3

# Rechercher des fichiers
rclone ls gdrive: --include "*.pdf" --recursive

Copie et Déplacement

# Copie locale vers remote
rclone copy /local/path gdrive:backup/ -P

# Copie remote vers local
rclone copy gdrive:Documents/ /local/documents/ -P

# Copie entre deux remotes (server-side si supporté)
rclone copy gdrive:source/ s3-aws:destination/ -P

# Déplacement (copie + suppression source)
rclone move /local/temp/ gdrive:archive/ -P

# Copie d'un seul fichier
rclone copyto /local/file.txt gdrive:backup/file.txt

Synchronisation

# Synchronisation unidirectionnelle (source → destination)
# ATTENTION : supprime les fichiers en destination non présents en source
rclone sync /local/data/ gdrive:data/ -P

# Synchronisation avec dry-run (simulation)
rclone sync /local/data/ gdrive:data/ --dry-run

# Synchronisation bidirectionnelle (expérimental)
rclone bisync /local/data/ gdrive:data/ --resync

Suppression

# Supprimer un fichier
rclone deletefile gdrive:path/to/file.txt

# Supprimer un répertoire et son contenu
rclone purge gdrive:old-backup/

# Supprimer uniquement les fichiers (garde la structure)
rclone delete gdrive:temp/

# Supprimer les fichiers vides
rclone rmdirs gdrive: --leave-root

Flags Essentiels

Flag	Description
`-P, --progress`	Affiche la progression
`-v, --verbose`	Mode verbeux
`-n, --dry-run`	Simulation sans modification
`--transfers N`	Nombre de transferts parallèles
`--checkers N`	Nombre de vérificateurs parallèles
`--bwlimit RATE`	Limite de bande passante
`--exclude PATTERN`	Exclure des fichiers
`--include PATTERN`	Inclure uniquement ces fichiers
`--min-size SIZE`	Taille minimale
`--max-size SIZE`	Taille maximale
`--min-age DURATION`	Âge minimum
`--max-age DURATION`	Âge maximum

Opérations Avancées

Filtrage Avancé

# Fichier de filtres
cat > /etc/rclone/filters.txt << 'EOF'
# Inclusions
+ **.pdf
+ **.docx
+ Documents/**

# Exclusions
- *.tmp
- *.log
- .git/**
- node_modules/**
- __pycache__/**
- .DS_Store
- Thumbs.db

# Exclure les fichiers de plus de 1Go
- *
EOF

# Utilisation du fichier de filtres
rclone sync /data/ gdrive:backup/ --filter-from /etc/rclone/filters.txt -P

Opérations Server-Side

# Copie server-side (évite le téléchargement local)
rclone copy gdrive:source/ gdrive:destination/ --drive-server-side-across-configs

# Vérifier si server-side est disponible
rclone backend features gdrive:

# Déduplication (Google Drive)
rclone dedupe gdrive:folder/ --dedupe-mode newest

Gestion des Gros Fichiers

# Chunked upload pour fichiers > 5GB (S3)
rclone copy largefile.tar gdrive:backup/ \
  --s3-chunk-size 100M \
  --s3-upload-concurrency 4

# Vérification d'intégrité
rclone check /local/data/ gdrive:data/ --one-way
rclone hashsum MD5 gdrive:file.zip

Opérations sur les Métadonnées

# Copier avec préservation des timestamps
rclone copy /local/ gdrive:backup/ --metadata

# Afficher les métadonnées
rclone lsjson gdrive:file.txt --metadata

# Modifier les métadonnées (backends supportés)
rclone settier gdrive:file.txt ARCHIVE

Montage FUSE et Cache

Montage de Base

# Créer le point de montage
sudo mkdir -p /mnt/gdrive
sudo chown $USER:$USER /mnt/gdrive

# Montage simple
rclone mount gdrive: /mnt/gdrive --daemon

# Montage avec options avancées
rclone mount gdrive: /mnt/gdrive \
  --daemon \
  --allow-other \
  --vfs-cache-mode full \
  --vfs-cache-max-size 10G \
  --vfs-cache-max-age 24h \
  --vfs-read-chunk-size 64M \
  --vfs-read-chunk-size-limit 1G \
  --buffer-size 256M \
  --dir-cache-time 72h \
  --poll-interval 15s \
  --log-file /var/log/rclone/gdrive.log \
  --log-level INFO

Modes de Cache VFS

Mode	Description	Usage
`off`	Pas de cache	Streaming uniquement
`minimal`	Cache en écriture uniquement	Uploads
`writes`	Cache les écritures jusqu'à upload	Édition de fichiers
`full`	Cache complet lecture/écriture	Usage intensif, applications

Configuration Cache Avancée

# Cache avec backend dédié
rclone mount gdrive: /mnt/gdrive \
  --vfs-cache-mode full \
  --cache-dir /var/cache/rclone \
  --vfs-cache-max-size 50G \
  --vfs-cache-max-age 168h \
  --vfs-write-back 5s \
  --vfs-read-ahead 128M \
  --attr-timeout 1h \
  --daemon

Service Systemd pour Montage Persistant

# Créer le fichier service
sudo tee /etc/systemd/system/rclone-gdrive.service << 'EOF'
[Unit]
Description=Rclone Mount - Google Drive
Documentation=https://rclone.org/docs/
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
User=rclone
Group=rclone
ExecStartPre=/bin/mkdir -p /mnt/gdrive
ExecStart=/usr/local/bin/rclone mount gdrive: /mnt/gdrive \
  --config /home/rclone/.config/rclone/rclone.conf \
  --allow-other \
  --vfs-cache-mode full \
  --vfs-cache-max-size 20G \
  --vfs-cache-max-age 72h \
  --vfs-read-chunk-size 32M \
  --vfs-read-chunk-size-limit 256M \
  --buffer-size 128M \
  --dir-cache-time 48h \
  --poll-interval 30s \
  --log-level INFO \
  --log-file /var/log/rclone/gdrive.log \
  --cache-dir /var/cache/rclone/gdrive
ExecStop=/bin/fusermount -uz /mnt/gdrive
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

# Créer l'utilisateur dédié
sudo useradd -r -s /usr/sbin/nologin rclone
sudo mkdir -p /var/log/rclone /var/cache/rclone
sudo chown rclone:rclone /var/log/rclone /var/cache/rclone

# Activer et démarrer le service
sudo systemctl daemon-reload
sudo systemctl enable rclone-gdrive.service
sudo systemctl start rclone-gdrive.service

# Vérifier le statut
sudo systemctl status rclone-gdrive.service

Démontage

# Démontage propre
fusermount -u /mnt/gdrive

# Démontage forcé (si bloqué)
fusermount -uz /mnt/gdrive

# Via systemd
sudo systemctl stop rclone-gdrive.service

Chiffrement et Sécurité

Configuration d'un Remote Chiffré

Le backend crypt fournit un chiffrement côté client transparent.

# Configuration via assistant
rclone config

# Sélectionner : n (new remote)
# Name : gdrive-crypt
# Storage : crypt
# remote : gdrive:encrypted/  (remote sous-jacent)
# filename_encryption : standard
# directory_name_encryption : true
# password : (généré ou choisi)
# password2 : (sel, optionnel mais recommandé)

Configuration résultante :

[gdrive-crypt]
type = crypt
remote = gdrive:encrypted/
password = ENCRYPTED_PASSWORD_HASH
password2 = ENCRYPTED_SALT_HASH
filename_encryption = standard
directory_name_encryption = true

Modes de Chiffrement des Noms

Mode	Description	Exemple
`off`	Pas de chiffrement des noms	`document.pdf`
`standard`	Chiffrement complet	`q4kp2q8fj3m2...`
`obfuscate`	Obfuscation simple	`yqkpzqFfj3m2...`

Utilisation du Remote Chiffré

# Les opérations sont transparentes
rclone copy /sensitive/data/ gdrive-crypt: -P

# Les fichiers apparaissent chiffrés côté cloud
rclone ls gdrive:encrypted/
# Output : chiffré et illisible

# Mais lisibles via le remote crypt
rclone ls gdrive-crypt:
# Output : noms originaux

Sécurisation de la Configuration

# Chiffrer le fichier de configuration
rclone config password

# La configuration utilise désormais un mot de passe
# Définir via variable d'environnement
export RCLONE_CONFIG_PASS="votre_mot_de_passe_fort"

# Ou utiliser un gestionnaire de secrets
export RCLONE_CONFIG_PASS=$(cat /run/secrets/rclone_pass)

Variables d'Environnement Sensibles

# Configuration via variables (évite le fichier config)
export RCLONE_CONFIG_GDRIVE_TYPE=drive
export RCLONE_CONFIG_GDRIVE_TOKEN='{"access_token":"..."}'

# Pour S3
export RCLONE_CONFIG_S3_TYPE=s3
export RCLONE_CONFIG_S3_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export RCLONE_CONFIG_S3_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG

Automatisation et Scripting

Script de Backup Complet

#!/usr/bin/env bash
#
# rclone-backup.sh - Script de sauvegarde automatisée
# Usage: ./rclone-backup.sh [daily|weekly|monthly]
#

set -euo pipefail
IFS=$'\n\t'

# Configuration
readonly SCRIPT_NAME=$(basename "$0")
readonly LOG_DIR="/var/log/rclone"
readonly LOG_FILE="${LOG_DIR}/backup-$(date +%Y%m%d-%H%M%S).log"
readonly LOCK_FILE="/var/run/rclone-backup.lock"
readonly CONFIG_FILE="${HOME}/.config/rclone/rclone.conf"

# Paramètres
readonly LOCAL_SOURCE="/data"
readonly REMOTE_DEST="gdrive-crypt:backups"
readonly RETENTION_DAYS=30
readonly BANDWIDTH_LIMIT="50M"
readonly MAX_TRANSFERS=4

# Couleurs
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly NC='\033[0m'

# Fonctions
log() {
    local level="$1"
    shift
    local message="$*"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo -e "${timestamp} [${level}] ${message}" | tee -a "${LOG_FILE}"
}

cleanup() {
    rm -f "${LOCK_FILE}"
    log "INFO" "Nettoyage effectué, verrou libéré"
}

check_dependencies() {
    local deps=("rclone" "flock")
    for dep in "${deps[@]}"; do
        if ! command -v "$dep" &> /dev/null; then
            log "ERROR" "Dépendance manquante: $dep"
            exit 1
        fi
    done
}

acquire_lock() {
    exec 200>"${LOCK_FILE}"
    if ! flock -n 200; then
        log "ERROR" "Une autre instance est en cours d'exécution"
        exit 1
    fi
}

perform_backup() {
    local backup_type="${1:-daily}"
    local timestamp=$(date +%Y%m%d-%H%M%S)
    local dest_path="${REMOTE_DEST}/${backup_type}/${timestamp}"
    
    log "INFO" "Démarrage backup ${backup_type} vers ${dest_path}"
    
    rclone sync "${LOCAL_SOURCE}" "${dest_path}" \
        --config "${CONFIG_FILE}" \
        --transfers "${MAX_TRANSFERS}" \
        --checkers 8 \
        --bwlimit "${BANDWIDTH_LIMIT}" \
        --log-file "${LOG_FILE}" \
        --log-level INFO \
        --stats 1m \
        --stats-log-level NOTICE \
        --exclude-from /etc/rclone/exclude.txt \
        --backup-dir "${REMOTE_DEST}/.versions/${timestamp}" \
        --suffix ".bak" \
        --fast-list \
        --retries 3 \
        --retries-sleep 10s \
        --ignore-errors
        
    local exit_code=$?
    
    if [ $exit_code -eq 0 ]; then
        log "INFO" "${GREEN}Backup ${backup_type} terminé avec succès${NC}"
    else
        log "ERROR" "${RED}Backup ${backup_type} échoué (code: ${exit_code})${NC}"
    fi
    
    return $exit_code
}

cleanup_old_backups() {
    log "INFO" "Nettoyage des backups de plus de ${RETENTION_DAYS} jours"
    
    rclone delete "${REMOTE_DEST}" \
        --config "${CONFIG_FILE}" \
        --min-age "${RETENTION_DAYS}d" \
        --rmdirs \
        --log-file "${LOG_FILE}" \
        --log-level INFO
        
    log "INFO" "Nettoyage terminé"
}

send_notification() {
    local status="$1"
    local message="$2"
    
    # Exemple avec webhook Discord/Slack
    if [ -n "${WEBHOOK_URL:-}" ]; then
        curl -s -X POST "${WEBHOOK_URL}" \
            -H "Content-Type: application/json" \
            -d "{\"content\": \"[Rclone Backup] ${status}: ${message}\"}"
    fi
}

main() {
    local backup_type="${1:-daily}"
    
    # Initialisation
    mkdir -p "${LOG_DIR}"
    trap cleanup EXIT
    
    log "INFO" "=== Démarrage ${SCRIPT_NAME} (${backup_type}) ==="
    
    check_dependencies
    acquire_lock
    
    # Exécution
    if perform_backup "${backup_type}"; then
        cleanup_old_backups
        send_notification "SUCCESS" "Backup ${backup_type} terminé"
    else
        send_notification "FAILURE" "Backup ${backup_type} échoué"
        exit 1
    fi
    
    log "INFO" "=== Fin ${SCRIPT_NAME} ==="
}

main "$@"

Configuration Cron

# Éditer la crontab
crontab -e

# Backups automatisés
# Daily à 2h00
0 2 * * * /usr/local/bin/rclone-backup.sh daily >> /var/log/rclone/cron.log 2>&1

# Weekly le dimanche à 3h00
0 3 * * 0 /usr/local/bin/rclone-backup.sh weekly >> /var/log/rclone/cron.log 2>&1

# Monthly le 1er du mois à 4h00
0 4 1 * * /usr/local/bin/rclone-backup.sh monthly >> /var/log/rclone/cron.log 2>&1

# Nettoyage du cache tous les jours à 5h00
0 5 * * * /usr/local/bin/rclone cleanup gdrive: --config /home/user/.config/rclone/rclone.conf

Timer Systemd (Alternative à Cron)

# Service
sudo tee /etc/systemd/system/rclone-backup.service << 'EOF'
[Unit]
Description=Rclone Backup Service
After=network-online.target

[Service]
Type=oneshot
User=rclone
ExecStart=/usr/local/bin/rclone-backup.sh daily
StandardOutput=journal
StandardError=journal
EOF

# Timer
sudo tee /etc/systemd/system/rclone-backup.timer << 'EOF'
[Unit]
Description=Run Rclone Backup Daily

[Timer]
OnCalendar=*-*-* 02:00:00
RandomizedDelaySec=300
Persistent=true

[Install]
WantedBy=timers.target
EOF

# Activation
sudo systemctl daemon-reload
sudo systemctl enable --now rclone-backup.timer

# Vérification
systemctl list-timers | grep rclone

Optimisation des Performances

Tuning des Transferts

# Configuration haute performance
rclone sync /source/ remote:dest/ \
  --transfers 16 \
  --checkers 32 \
  --buffer-size 512M \
  --drive-chunk-size 256M \
  --fast-list \
  --tpslimit 10 \
  --tpslimit-burst 20 \
  -P

Paramètres par Provider

Google Drive

# Optimisation Google Drive
rclone copy /data/ gdrive:backup/ \
  --drive-chunk-size 256M \
  --drive-upload-cutoff 256M \
  --drive-acknowledge-abuse \
  --drive-keep-revision-forever=false \
  --fast-list \
  -P

Amazon S3

# Optimisation S3
rclone copy /data/ s3:bucket/path/ \
  --s3-chunk-size 100M \
  --s3-upload-cutoff 200M \
  --s3-upload-concurrency 8 \
  --s3-copy-cutoff 4G \
  --fast-list \
  -P

Backblaze B2

# Optimisation B2
rclone copy /data/ b2:bucket/path/ \
  --b2-chunk-size 96M \
  --b2-upload-cutoff 200M \
  --b2-hard-delete \
  --fast-list \
  -P

Benchmarking

# Test de vitesse
rclone test makefile /tmp/rclone_test_file --size 1G

# Benchmark complet
rclone test memory remote:path/
rclone test bandwidth remote:path/ --time 30s

# Mesurer les transferts
time rclone copy /test/1GB.bin remote:test/ -P --stats 1s

Gestion de la Bande Passante

# Limite fixe
--bwlimit 10M

# Limite variable selon l'heure
--bwlimit "08:00,512K 18:00,10M 23:00,off"

# Limite séparée upload/download
--bwlimit "10M:5M"  # 10M up, 5M down

Monitoring et Logging

Configuration des Logs

# Niveaux de log
--log-level DEBUG    # Très verbeux
--log-level INFO     # Standard
--log-level NOTICE   # Important uniquement
--log-level ERROR    # Erreurs seulement

# Sortie fichier
--log-file /var/log/rclone/operation.log

# Format JSON (pour parsing)
--use-json-log

Statistiques Détaillées

# Statistiques périodiques
rclone sync /source/ remote:dest/ \
  --stats 30s \
  --stats-file-name-length 0 \
  --stats-log-level NOTICE \
  --stats-one-line \
  -P

Monitoring avec Prometheus

# Activer les métriques
rclone serve restic remote:path/ \
  --rc \
  --rc-addr :5572 \
  --rc-enable-metrics

# Endpoint Prometheus
curl http://localhost:5572/metrics

Script de Monitoring

#!/usr/bin/env bash
# rclone-health-check.sh

REMOTE="gdrive:"
LOG_FILE="/var/log/rclone/health.log"

check_remote() {
    if rclone lsd "${REMOTE}" --max-depth 1 &> /dev/null; then
        echo "$(date '+%Y-%m-%d %H:%M:%S') [OK] ${REMOTE} accessible" >> "${LOG_FILE}"
        return 0
    else
        echo "$(date '+%Y-%m-%d %H:%M:%S') [FAIL] ${REMOTE} inaccessible" >> "${LOG_FILE}"
        return 1
    fi
}

check_mount() {
    local mount_point="/mnt/gdrive"
    if mountpoint -q "${mount_point}"; then
        echo "$(date '+%Y-%m-%d %H:%M:%S') [OK] ${mount_point} monté" >> "${LOG_FILE}"
        return 0
    else
        echo "$(date '+%Y-%m-%d %H:%M:%S') [FAIL] ${mount_point} non monté" >> "${LOG_FILE}"
        return 1
    fi
}

check_remote
check_mount

Logrotate Configuration

sudo tee /etc/logrotate.d/rclone << 'EOF'
/var/log/rclone/*.log {
    daily
    missingok
    rotate 14
    compress
    delaycompress
    notifempty
    create 0640 rclone rclone
    sharedscripts
    postrotate
        systemctl reload rclone-gdrive.service > /dev/null 2>&1 || true
    endscript
}
EOF

Dépannage Expert

Problèmes Courants et Solutions

Erreur 403 - Rate Limit (Google Drive)

# Symptôme
ERROR : Failed to copy: googleapi: Error 403: User Rate Limit Exceeded

# Solutions
# 1. Réduire le parallélisme
--transfers 2 --checkers 4

# 2. Ajouter des délais
--tpslimit 2 --tpslimit-burst 0

# 3. Utiliser votre propre Client ID
# Dans rclone config, définir client_id et client_secret personnalisés

Erreur de Token Expiré

# Régénérer le token
rclone config reconnect gdrive:

# Ou manuellement
rclone authorize drive

Montage FUSE - Permission Denied

# Vérifier /etc/fuse.conf
grep user_allow_other /etc/fuse.conf

# Si commenté, décommenter
sudo sed -i 's/#user_allow_other/user_allow_other/' /etc/fuse.conf

# Utiliser --allow-other
rclone mount remote: /mnt/point --allow-other

Fichiers Manquants après Sync

# Toujours faire un dry-run d'abord
rclone sync source: dest: --dry-run

# Vérifier les exclusions
rclone ls source: --include "*.ext" -v

# Utiliser check pour comparer
rclone check source: dest: --one-way --combined report.txt

Diagnostic Avancé

# Mode debug complet
rclone copy source: dest: -vv --dump headers --dump bodies

# Tester la connexion
rclone lsd remote: --timeout 30s

# Vérifier la configuration
rclone config show remote

# Lister les backends et features
rclone backend features remote:

# Test de performance réseau
rclone test bandwidth remote: --time 30s

Récupération d'Erreurs

# Reprendre un transfert interrompu
rclone copy source: dest: \
  --retries 10 \
  --retries-sleep 30s \
  --low-level-retries 20 \
  --ignore-errors

# Traiter les fichiers en erreur séparément
rclone copy source: dest: \
  --error-on-no-transfer \
  2>&1 | tee transfer.log

# Rejouer uniquement les erreurs
grep "ERROR" transfer.log | while read line; do
    # Extraire et retraiter
done

Cas d'Usage Production

Backup Serveur Web Complet

#!/usr/bin/env bash
# backup-webserver.sh

# Variables
MYSQL_USER="backup"
MYSQL_PASS="secret"
BACKUP_DIR="/var/backups/web"
REMOTE="b2:webserver-backups"
DATE=$(date +%Y%m%d)

# Créer le répertoire de backup
mkdir -p "${BACKUP_DIR}/${DATE}"

# 1. Backup MySQL
mysqldump -u${MYSQL_USER} -p${MYSQL_PASS} --all-databases \
    | gzip > "${BACKUP_DIR}/${DATE}/mysql-all.sql.gz"

# 2. Backup fichiers web
tar -czf "${BACKUP_DIR}/${DATE}/www.tar.gz" -C /var/www .

# 3. Backup configuration
tar -czf "${BACKUP_DIR}/${DATE}/etc.tar.gz" \
    /etc/nginx /etc/php /etc/mysql /etc/letsencrypt

# 4. Upload vers cloud
rclone copy "${BACKUP_DIR}/${DATE}" "${REMOTE}/${DATE}/" \
    --transfers 4 \
    --b2-hard-delete \
    -P

# 5. Nettoyage local (garder 7 jours)
find "${BACKUP_DIR}" -type d -mtime +7 -exec rm -rf {} +

# 6. Nettoyage remote (garder 30 jours)
rclone delete "${REMOTE}" --min-age 30d --rmdirs

Synchronisation Multi-Cloud

#!/usr/bin/env bash
# multi-cloud-sync.sh - Réplication sur plusieurs providers

SOURCES=("gdrive:important" "s3:bucket/important")
DESTINATIONS=("b2:redundancy" "wasabi:redundancy")

for src in "${SOURCES[@]}"; do
    for dst in "${DESTINATIONS[@]}"; do
        echo "Syncing ${src} -> ${dst}"
        rclone sync "${src}" "${dst}" \
            --transfers 8 \
            --fast-list \
            --checksum \
            -P
    done
done

Media Server avec Rclone Mount

# Configuration pour Plex/Jellyfin
rclone mount gdrive:Media /mnt/media \
    --daemon \
    --allow-other \
    --uid $(id -u plex) \
    --gid $(id -g plex) \
    --umask 002 \
    --vfs-cache-mode full \
    --vfs-cache-max-size 100G \
    --vfs-cache-max-age 168h \
    --vfs-read-chunk-size 128M \
    --vfs-read-chunk-size-limit 1G \
    --buffer-size 512M \
    --dir-cache-time 168h \
    --poll-interval 1m \
    --log-file /var/log/rclone/media.log \
    --log-level NOTICE \
    --cache-dir /var/cache/rclone/media

Archivage avec Versioning

# Sync avec conservation des versions
rclone sync /data/ remote:current/ \
    --backup-dir remote:versions/$(date +%Y%m%d) \
    --suffix .bak \
    --suffix-keep-extension \
    -P

# Restauration d'une version
rclone copy remote:versions/20240115/file.txt.bak /restore/file.txt

Ressources et Références

Documentation Officielle

Site officiel : https://rclone.org/
Documentation : https://rclone.org/docs/
Forum : https://forum.rclone.org/
GitHub : https://github.com/rclone/rclone

Commandes Utiles Rapides

# Vérifier l'espace utilisé
rclone size remote:path/

# Nettoyer les fichiers temporaires
rclone cleanup remote:

# Monter avec interface web
rclone rcd --rc-web-gui --rc-addr :5572

# Exporter la config (sans secrets)
rclone config dump | jq 'del(..|.token?, .password?, .secret_access_key?)'

Rclone : Guide expert pour la synchronisation cloud sur VPS Linux