Rclone : synchroniser et sauvegarder vos données cloud (S3, Drive, Dropbox)

Rclone copie, synchronise et sauvegarde vos fichiers entre votre machine et plus de 70 services cloud (Google Drive, Dropbox, Amazon S3, MinIO...) ou entre deux clouds directement. C'est l'équivalent de rsync pour le cloud, en ligne de commande.

Avec rclone, vous pouvez :

Synchroniser un dossier local vers un bucket S3 ou Google Drive
Sauvegarder automatiquement vos données avec chiffrement
Migrer des fichiers entre deux providers cloud sans téléchargement local
Monter un stockage cloud comme un disque local

Installation

Rclone est distribué sous forme d'un binaire unique, sans dépendance à installer. Sur Linux, la méthode ci-dessous télécharge l'archive officielle, vérifie son empreinte avec le fichier de sommes publié par le projet, puis copie le binaire dans /usr/local/bin. Cette vérification est ce qui garantit que l'archive n'a pas été altérée entre le serveur de téléchargement et votre machine.

Téléchargez l'archive et le fichier SHA256SUMS de la version voulue, puis contrôlez l'empreinte avant d'extraire quoi que ce soit :

RCLONE_VERSION=v1.72.1
curl -fsSLO "https://downloads.rclone.org/${RCLONE_VERSION}/rclone-${RCLONE_VERSION}-linux-amd64.zip"
curl -fsSLO "https://downloads.rclone.org/${RCLONE_VERSION}/SHA256SUMS"

# Doit afficher : rclone-v1.72.1-linux-amd64.zip: OK
grep "rclone-${RCLONE_VERSION}-linux-amd64.zip" SHA256SUMS | sha256sum --check

Si la vérification échoue, arrêtez-vous : ne décompressez pas l'archive. Sinon, installez le binaire :

unzip -q "rclone-${RCLONE_VERSION}-linux-amd64.zip"
sudo install -m 0755 "rclone-${RCLONE_VERSION}-linux-amd64/rclone" /usr/local/bin/rclone

Ou via le gestionnaire de paquets (version potentiellement plus ancienne) :

# Debian/Ubuntu
sudo apt install rclone

# Fedora
sudo dnf install rclone

# Arch Linux
sudo pacman -S rclone

Avec Homebrew :

brew install rclone

Téléchargez l'archive depuis rclone.org/downloads, extrayez-la et ajoutez le dossier à votre PATH.

Ou avec winget :

winget install Rclone.Rclone

Vérifiez l'installation :

rclone version

rclone v1.72.1
- os/version: ubuntu 24.04 (64 bit)
- os/kernel: 6.8.0-90-generic (x86_64)
- os/type: linux
- os/arch: amd64
- go/version: go1.25.5
- go/linking: static
- go/tags: none

Environnement de test avec MinIO

Pour tester les commandes de ce guide, déployons rapidement MinIO (stockage S3-compatible) sur minikube. Vous pourrez ensuite remplacer l'endpoint par celui de votre provider (AWS S3, Outscale, Scaleway...).

Démarrez minikube (si ce n'est pas déjà fait) :
Fenêtre de terminal
```
minikube start
```

Déployez MinIO :

kubectl create namespace minio
kubectl run minio --image=minio/minio:latest -n minio \
  --env="MINIO_ROOT_USER=minioadmin" \
  --env="MINIO_ROOT_PASSWORD=minioadmin" \
  -- server /data --console-address ":9001"

Exposez le service :

kubectl expose pod minio -n minio --port=9000 --target-port=9000 --type=NodePort --name=minio-api

Récupérez l'URL d'accès :

minikube service minio-api -n minio --url

http://192.168.49.2:31019

Configurez rclone avec cet endpoint :

cat >> ~/.config/rclone/rclone.conf << 'EOF'
[minio]
type = s3
provider = Minio
access_key_id = minioadmin
secret_access_key = minioadmin
endpoint = http://192.168.49.2:31019
EOF

Remplacez l'URL par celle obtenue à l'étape précédente.

Testez la connexion :
Fenêtre de terminal
```
rclone lsd minio:
```

Concepts fondamentaux

Avant de configurer rclone, comprenez ces deux concepts essentiels.

Les Remotes

Un remote est un emplacement de stockage configuré dans rclone. Il peut être :

Un service cloud (Google Drive, Dropbox, Amazon S3, MinIO...)
Un serveur distant (SFTP, FTP, WebDAV)
Un stockage local (pour les tests ou le chiffrement)

Chaque remote a un nom que vous utilisez dans les commandes, suivi de : :

rclone ls mondrive:        # Liste le contenu du remote "mondrive"
rclone ls minio:mon-bucket # Liste le bucket "mon-bucket" sur le remote "minio"

Architecture source → destination

Toutes les commandes rclone suivent le pattern source → destination :

rclone copy /local/dossier remote:bucket/chemin
#           ↑ source        ↑ destination

Comparaison entre rclone sync (unidirectionnel) et rclone bisync (bidirectionnel)

Configuration

La configuration se fait via rclone config qui lance un assistant interactif.

Lancez l'assistant :
Fenêtre de terminal
```
rclone config
```
Créez un nouveau remote en tapant n (new remote)
Donnez-lui un nom (ex: minio, gdrive, dropbox)
Choisissez le type de stockage parmi la liste (ex: s3 pour S3/MinIO, drive pour Google Drive)
Répondez aux questions spécifiques au provider (credentials, région, endpoint...)
Testez la connexion :
Fenêtre de terminal
```
rclone lsd monremote:
```

Exemple : configuration MinIO/S3

Pour un stockage S3-compatible comme MinIO ou Outscale OOS :

rclone config

n) New remote
name> minio
Storage> s3
provider> Minio
env_auth> false
access_key_id> VOTRE_ACCESS_KEY
secret_access_key> VOTRE_SECRET_KEY
endpoint> http://minio.example.com:9000

Ou ajoutez directement dans ~/.config/rclone/rclone.conf :

[minio]
type = s3
provider = Minio
access_key_id = VOTRE_ACCESS_KEY
secret_access_key = VOTRE_SECRET_KEY
endpoint = http://minio.example.com:9000

Protéger les credentials

Pour éviter de stocker les mots de passe en clair, utilisez rclone obscure :

rclone obscure "mon-mot-de-passe-secret"

bXItbW90LWRlLXBhc3NlLXNlY3JldA==

Commandes de base

Ces commandes permettent d'explorer et organiser vos fichiers.

Lister le contenu

Ces quatre commandes ne renvoient pas la même chose : lsd ne montre que les répertoires (les buckets à la racine d'un remote S3), ls parcourt récursivement les fichiers, lsl ajoute la date de modification, et lsjson produit une sortie exploitable par un script.

# Lister les buckets/dossiers racine
rclone lsd minio:

# Lister tous les fichiers (récursif)
rclone ls minio:mon-bucket/

# Lister avec détails (taille, date)
rclone lsl minio:mon-bucket/

# Format JSON pour scripts
rclone lsjson minio:mon-bucket/

          -1 2026-01-23 14:39:22        -1 mon-bucket
          -1 2026-01-23 15:00:00        -1 backups

Créer des dossiers et fichiers

Sur un remote S3, rclone mkdir à la racine crée un bucket ; le nom doit donc respecter les règles de nommage du fournisseur. rclone touch crée un objet vide ou met à jour sa date s'il existe déjà.

# Créer un bucket/dossier
rclone mkdir minio:nouveau-bucket

# Créer un fichier vide (ou mettre à jour sa date)
rclone touch minio:mon-bucket/nouveau-fichier.txt

Connaître la taille

rclone size est récursif par défaut : il énumère tous les objets sous le chemin indiqué, ce qui peut prendre plusieurs minutes sur un gros bucket. L'option --max-depth 1 limite le parcours au premier niveau.

rclone size minio:mon-bucket/

Total objects: 42
Total size: 1.234 GiB (1325432678 Byte)

Commandes de transfert

Ces commandes copient, déplacent ou synchronisent vos fichiers.

Copier des fichiers

rclone copy copie les fichiers sans supprimer ceux qui n'existent plus dans la source.

# Copier un dossier local vers le cloud
rclone copy /home/user/documents/ minio:backups/documents/

# Copier entre deux clouds
rclone copy gdrive:photos/ dropbox:photos-backup/

# Copier un fichier avec un nouveau nom
rclone copyto /local/rapport.pdf minio:backups/rapport-2026.pdf

Déplacer des fichiers

rclone move copie puis supprime les fichiers source après transfert réussi.

# Archiver des logs vers S3 (supprime les locaux)
rclone move /var/log/archive/ minio:logs-archive/

# Déplacer entre clouds
rclone move dropbox:old-project/ gdrive:archives/old-project/

Synchroniser (unidirectionnel)

rclone sync rend la destination identique à la source. Les fichiers absents de la source sont supprimés de la destination.

# Synchroniser local → cloud
rclone sync /home/user/projets/ minio:projets-backup/

sync supprime les fichiers de la destination qui n'existent plus dans la source. Utilisez --dry-run pour prévisualiser :

rclone sync /source/ remote:dest/ --dry-run

Pour conserver les fichiers supprimés dans un dossier de sauvegarde :

rclone sync /source/ minio:dest/ --backup-dir minio:dest-deleted/

Synchronisation bidirectionnelle (bisync)

sync impose la source à la destination ; bisync reporte les modifications dans les deux sens en s'appuyant sur un état de référence conservé localement entre deux exécutions. C'est ce qui lui permet de distinguer un fichier ajouté d'un fichier supprimé, et c'est aussi pourquoi la toute première exécution exige une initialisation explicite.

Contrairement à sync (unidirectionnel), bisync propage les modifications des deux côtés :

# Première exécution : initialisation obligatoire
rclone bisync /local/dossier/ minio:bucket/ --resync

# Exécutions suivantes : sync bidirectionnel
rclone bisync /local/dossier/ minio:bucket/

Cas d'usage : synchroniser un dossier de travail entre votre laptop et le cloud, pour y accéder depuis plusieurs machines.

Gestion des conflits

Si le même fichier est modifié des deux côtés entre deux bisync :

# Résolution automatique : garder le plus récent
rclone bisync /local/ remote:/ --conflict-resolve newer

# Ou renommer les conflits
rclone bisync /local/ remote:/ --conflict-resolve rename

Vérification et maintenance

Une sauvegarde n'a de valeur que si elle est vérifiée, et un stockage objet ne se vide pas tout seul. Ces commandes couvrent les deux besoins : contrôler que la copie correspond bien à la source, et supprimer ce qui n'a plus lieu d'être. Les suppressions sont définitives sur la plupart des remotes.

Vérifier l'intégrité

rclone check compare les fichiers entre deux emplacements (taille et hash) :

rclone check /local/dossier/ minio:bucket/

2026/01/23 14:41:02 NOTICE: S3 bucket mon-bucket: 0 differences found
2026/01/23 14:41:02 NOTICE: S3 bucket mon-bucket: 42 matching files

Supprimer des fichiers

Les trois commandes ne portent pas sur le même périmètre : delete retire les fichiers mais laisse l'arborescence en place et respecte les filtres, purge efface le répertoire et tout son contenu sans tenir compte des filtres, et rmdirs ne s'occupe que des répertoires vides.

# Supprimer les fichiers (garde les dossiers vides)
rclone delete minio:bucket/old-data/

# Supprimer un dossier et tout son contenu
rclone purge minio:bucket/old-data/

# Supprimer uniquement les dossiers vides
rclone rmdirs minio:bucket/

Filtrage des fichiers

Contrôlez précisément quels fichiers sont traités avec les filtres.

Inclure/Exclure par motif

Point à connaître avant d'écrire votre première règle : dès qu'un --include est présent, rclone ajoute implicitement une exclusion de tout le reste. Un --include "*.jpg" seul ne copie donc que les fichiers .jpg, même sans --exclude.

# Copier uniquement les images
rclone copy /photos/ minio:photos/ --include "*.jpg" --include "*.png"

# Exclure les fichiers temporaires
rclone sync /projet/ minio:projet/ --exclude "*.tmp" --exclude ".git/**"

# Combiner inclusion et exclusion
rclone copy /data/ minio:data/ --include "*.log" --exclude "*"

Fichier de filtres

Pour des règles complexes, utilisez un fichier :

# Inclure les documents
+ *.pdf
+ *.docx
+ /important/**

# Exclure le reste
- *.tmp
- .git/**
- node_modules/**
- *

rclone sync /projet/ minio:backup/ --filter-from filters.txt

Prévisualiser avec --dry-run

Toujours tester vos filtres avant exécution :

rclone sync /source/ remote:dest/ --filter-from filters.txt --dry-run -v

Fonctionnalités avancées

Au-delà du transfert de fichiers, rclone sait exposer un remote comme un système de fichiers local ou comme un serveur. Ces deux modes transforment un stockage objet distant en ressource utilisable par des applications qui ne connaissent rien à S3, au prix d'une latence et de limites qu'il vaut mieux connaître avant de les mettre en production.

Monter un remote comme disque local

Le montage passe par FUSE et reste actif tant que le processus tourne : --daemon le détache du terminal. Sans --vfs-cache-mode, les écritures en accès aléatoire échouent, car un objet distant ne se modifie pas en place.

# Monter Google Drive sur /mnt/gdrive
rclone mount gdrive: /mnt/gdrive --daemon

# Avec cache pour de meilleures performances
rclone mount gdrive: /mnt/gdrive --vfs-cache-mode full --daemon

Servir des fichiers via HTTP/WebDAV

Ces serveurs écoutent par défaut sur 127.0.0.1:8080 et n'exigent aucune authentification. Écrire --addr :8080 comme ci-dessous les rend accessibles depuis tout le réseau : n'ajoutez cette option qu'accompagnée de --user et --pass, ou d'un fichier --htpasswd.

# Serveur HTTP simple
rclone serve http minio:bucket/ --addr :8080

# Serveur WebDAV
rclone serve webdav minio:bucket/ --addr :8080

À retenir

Remote = stockage configuré : un remote est un alias vers un service cloud. Utilisez remote:chemin dans toutes les commandes.
sync ≠ copy : copy ajoute des fichiers, sync rend la destination identique (supprime les extras), bisync synchronise dans les deux sens.
--dry-run toujours : avant tout sync ou delete, prévisualisez avec --dry-run pour éviter les mauvaises surprises.
Filtres puissants : utilisez --include, --exclude et --filter-from pour cibler précisément les fichiers.

Prochaines étapes

Chiffrement rclone Crypt Chiffrez vos données avant de les envoyer sur le cloud

Stockage Outscale OOS Utilisez rclone avec Outscale Object Storage

Sauvegardes avec restic Outil de backup incrémental compatible S3

Minikube Déployez Kubernetes en local pour vos tests

Ressources

Site officiel : rclone.org
Documentation : rclone.org/docs
GitHub : github.com/rclone/rclone
Changelog v1.72 : rclone.org/changelog