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 vos données, y compris chiffrées via le remote crypt de rclone (voir la documentation officielle)
• Migrer des fichiers entre deux providers cloud sans téléchargement local
• Monter un stockage cloud comme un disque local

Version actuelle

Ce guide est basé sur rclone v1.75.2 (9 octobre 2026). La commande bisync est stable depuis la v1.71, et sa documentation continue d'évoluer : vérifiez les drapeaux de conflit sur rclone.org/bisync si votre version diffère.

Ce que vous allez apprendre

• Installer rclone en vérifiant l'empreinte de l'archive avant de s'en servir.
• Déclarer un remote et le manipuler avec les commandes de base.
• Copier, synchroniser et migrer des fichiers, y compris de cloud à cloud sans passer par votre disque.
• Synchroniser dans les deux sens avec bisync, et régler les conflits avec les trois drapeaux qui s'en occupent.
• Filtrer ce qui est transféré et vérifier qu'une copie correspond bien à sa source.

Prérequis

Pour suivre les exemples, il vous faut un terminal Linux ou macOS avec les commandes curl et sha256sum (ou shasum), et Docker installé : il sert uniquement à lancer le banc de test S3 local de la section « Environnement de test avec RustFS ». Sans Docker, vous pouvez utiliser le compte S3 d'un provider à la place, en adaptant l'endpoint et les clés. Aucune connaissance préalable de rclone n'est nécessaire.

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.

Linux

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.75.2
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.75.2-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

Note

Si vous utilisez apt, la version du dépôt peut être en retard de plusieurs versions mineures. Préférez l'archive officielle vérifiée pour disposer des dernières fonctionnalités, bisync en particulier.

macOS

Avec Homebrew :

brew install rclone

Windows

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

Sortie attendue

rclone v1.75.2
- 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 RustFS

Pour tester les commandes de ce guide, déployons rapidement un stockage compatible S3 en local, avec Docker. MinIO ne publie plus d'image communautaire récupérable : au 9 octobre 2026, minio/minio sur Docker Hub et quay.io/minio/minio ne se téléchargent plus. Ce guide utilise donc RustFS, un autre stockage compatible S3. RustFS est publié en version stable (1.0.1) ; ici, il ne sert que de banc d'essai local. Vous pourrez ensuite remplacer l'endpoint par celui de votre provider (AWS S3, Outscale, Scaleway...).

1. Lancez RustFS sur le port 9000, limité à 127.0.0.1 :

   export AWS_ACCESS_KEY_ID=demo-local-access
   export AWS_SECRET_ACCESS_KEY=demo-local-secret-key
   docker run -d --name rustfs -p 127.0.0.1:9000:9000 \
     -e RUSTFS_ACCESS_KEY="$AWS_ACCESS_KEY_ID" \
     -e RUSTFS_SECRET_KEY="$AWS_SECRET_ACCESS_KEY" \
     -e RUSTFS_VOLUMES=/data \
     -v rustfs-data:/data \
     rustfs/rustfs:1.0.1@sha256:1803faef57627e2d9c2e7d89d655d712ddded5389040054987163043fecb6a3c

   Les deux valeurs demo-local-* sont des valeurs de démonstration, valables uniquement pour ce conteneur local lié à 127.0.0.1. Ne les réutilisez jamais sur un vrai stockage.

2. Déclarez le remote rclone rustfs. Avec env_auth = true, rclone lit les clés dans les variables AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY exportées à l'étape 1, donc aucune clé n'est écrite dans le fichier :

   mkdir -p ~/.config/rclone
   cat >> ~/.config/rclone/rclone.conf << 'EOF'
   [rustfs]
   type = s3
   provider = Other
   env_auth = true
   endpoint = http://127.0.0.1:9000
   EOF

3. Testez la connexion (la liste est vide tant qu'aucun bucket n'existe, et la commande rend le code 0) :

   rclone lsd rustfs:
   rclone mkdir rustfs:mon-bucket
   rclone lsd rustfs:

   Pour tout supprimer en fin de test : docker rm -fv rustfs && docker volume rm rustfs-data.

Adaptez à votre provider

Dans tous les exemples qui suivent, remplacez rustfs: par le nom de votre remote (ex: s3:, outscale:, scaleway:) et ajustez les buckets/chemins selon votre configuration.

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 rustfs:mon-bucket # Liste le bucket "mon-bucket" sur le remote "rustfs"

Architecture source → destination

Toutes les commandes rclone suivent le pattern source → destination :

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

Le schéma ci-dessous oppose sync (un seul sens) à bisync (deux sens), détaillés plus bas.

Source · SVG

Échap pour fermer, + et − pour zoomer, défilement pour se déplacer. 100 % − Ajuster + Fermer

Configuration

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

1. Lancez l'assistant :

   rclone config

2. Créez un nouveau remote en tapant n (new remote)

3. Donnez-lui un nom (ex: rustfs, gdrive, dropbox)

4. Choisissez le type de stockage parmi la liste (ex: s3 pour S3 et ses variantes compatibles, drive pour Google Drive)

5. Répondez aux questions spécifiques au provider (credentials, région, endpoint...)

6. Testez la connexion :

   rclone lsd monremote:

Exemple : configuration S3-compatible

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

rclone config

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

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

~/.config/rclone/rclone.conf

[rustfs]
type = s3
provider = Other
access_key_id = VOTRE_ACCESS_KEY
secret_access_key = VOTRE_SECRET_KEY
endpoint = http://rustfs.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"

Sortie (exemple, rclone 1.72.1)

nBBFHEkdMKWHM0ouql0QeinwJgAmJO_EFrcM42l7iSgye9AlgCka

La sortie change à chaque appel : rclone chiffre la valeur avec une clé fixe et un vecteur aléatoire, ce n'est pas un simple encodage base64. C'est un obscurcissement, pas un chiffrement : n'importe qui disposant de rclone peut retrouver la valeur avec rclone reveal.

rclone obscure ne vaut que pour les champs que rclone stocke obscurcis, comme le mot de passe d'un remote SFTP ou WebDAV. Le champ secret_access_key d'un remote S3 est écrit en clair dans rclone.conf : pour le protéger, passez par env_auth = true ou chiffrez le fichier de configuration (voir ci-dessous).

Sécurité limitée

L'obscurcissement n'est pas un chiffrement fort. Il protège des regards indiscrets mais peut être inversé. Pour une vraie sécurité, chiffrez le fichier de configuration avec rclone config encryption.

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 rustfs:

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

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

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

Exemple de sortie lsd

          -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 rustfs:nouveau-bucket

# Créer un fichier vide (ou mettre à jour sa date)
rclone touch rustfs: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 rustfs:mon-bucket/

Sortie

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/ rustfs: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 rustfs:backups/rapport-2026.pdf

Incrémental par défaut

Rclone ne copie que les fichiers nouveaux ou modifiés (comparaison par taille et date). Relancez la même commande : seuls les changements seront transférés.

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/ rustfs: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/ rustfs:projets-backup/

Attention aux suppressions

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/ rustfs:dest/ --backup-dir rustfs: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.

Nouveauté v1.71

La commande bisync est stable depuis rclone v1.71 (août 2025). Elle synchronise les changements dans les deux sens.

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

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

# Exécutions suivantes : sync bidirectionnel
rclone bisync /local/dossier/ rustfs: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

# Garder le plus récent ET conserver le perdant sous un nom suffixé
rclone bisync /local/ remote:/ \
  --conflict-resolve newer --conflict-loser num --conflict-suffix conflit

Trois drapeaux se partagent le travail, et confondre les deux premiers est l'erreur classique. --conflict-resolve décide qui gagne, et n'accepte que none (le défaut), newer, older, larger, smaller, path1 ou path2. --conflict-loser décide du sort du perdant : num le renomme avec un numéro, pathname le renomme d'après son côté, delete le supprime. --conflict-suffix choisit le suffixe, conflict par défaut.

Avec le défaut none, rclone ne tranche pas : il conserve les deux versions sous les noms fichier.conflict1 et fichier.conflict2, et vous laissez le choix à l'humain. C'est souvent le réglage le plus sage sur des documents.

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/ rustfs:bucket/

Sortie

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 rustfs:bucket/old-data/

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

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

Attention

purge est irréversible. Pas de corbeille, pas de confirmation. Utilisez --dry-run d'abord.

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/ rustfs:photos/ --include "*.jpg" --include "*.png"

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

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

Fichier de filtres

Pour des règles complexes, utilisez un fichier :

filters.txt

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

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

rclone sync /projet/ rustfs: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

Note

Sur Linux, installez fuse3. Sur macOS, installez macFUSE. Sur Windows, installez WinFsp.

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 rustfs:mon-bucket/ --addr 127.0.0.1:8080

# Serveur WebDAV, ouvert au réseau, donc protégé par un mot de passe
rclone serve webdav rustfs:mon-bucket/ --addr :8080 --user demo --pass "$MOT_DE_PASSE_WEBDAV"

Le premier serveur reste local (127.0.0.1) et n'a donc pas besoin de mot de passe. Le second écoute sur toutes les interfaces : l'authentification --user / --pass est alors indispensable, avec un mot de passe que vous définissez dans la variable MOT_DE_PASSE_WEBDAV avant de lancer la commande.

Que faire quand une commande rclone échoue ?

Les trois pannes les plus fréquentes sur le banc de test ont chacune une cause simple. Lisez le message d'erreur avant de relancer : rclone indique presque toujours le remote et l'opération en cause.

Symptôme	Cause probable	Solution
Une commande reste bloquée de longues secondes puis échoue avec no EC2 IMDS role found (ou InvalidAccessKeyId si un fichier ~/.aws/credentials existe), juste après l'ouverture d'un nouveau terminal	AWS_ACCESS_KEY_ID et AWS_SECRET_ACCESS_KEY ne sont exportées que dans le terminal de l'étape 1 : env_auth = true ne les trouve plus et rclone va chercher d'autres sources d'identifiants (fichier AWS, puis service de métadonnées EC2)	Réexportez les deux variables (mêmes valeurs demo-local-*) dans le nouveau terminal
SignatureDoesNotMatch	La clé secrète transmise ne correspond pas à celle du serveur (valeur différente, ou clé modifiée avant d'être transmise)	Vérifiez que la clé est en clair, identique des deux côtés
Une copie ou une synchronisation a supprimé ou écrasé plus que prévu	La commande a été lancée sans prévisualisation	Relancez toujours avec --dry-run d'abord, puis sans l'option une fois la liste conforme

Glissez pour voir

Quand le message n'est pas explicite, ajoutez -vv pour voir les requêtes envoyées au serveur.

À 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.
• bisync : synchronisation dans les deux sens, à initialiser avec --resync ; --conflict-resolve décide qui gagne, --conflict-loser du sort du perdant, --conflict-suffix du suffixe.
• --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

s3cmd pour le stockage objet Un client S3 en ligne de commande, plus simple que rclone pour les buckets

Ressources

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

×

📖 Voir la documentation →