Gérer vos données cloud avec rclone

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 s’installe facilement sur Linux, macOS et Windows.

Le script officiel installe la dernière version :

curl https://rclone.org/install.sh | sudo bash

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

# 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

# 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 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)

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

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

# 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

# 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

Monter un remote comme disque local

# 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

# 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