Maîtriser rsync sous Linux : sync, exclusions et reprise

rsync est l’un des outils les plus utiles de la ligne de commande Linux pour copier et synchroniser des fichiers ou des dossiers. Il est apprécié parce qu’il évite de retransférer inutilement les données déjà présentes à destination, ce qui le rend pratique pour les sauvegardes, les miroirs de dossiers, les copies vers un autre serveur ou simplement l’organisation de ses fichiers.

Dans ce tutoriel orienté débutant, vous allez apprendre à utiliser rsync pas à pas pour synchroniser des fichiers et des dossiers, exclure certains éléments, simuler une opération avant exécution et reprendre un transfert interrompu. Le but n’est pas seulement de mémoriser quelques commandes, mais de comprendre la logique de l’outil afin d’éviter les erreurs fréquentes.

Le tutoriel se concentre sur des usages courants en environnement Linux, avec des exemples lisibles et réutilisables. Chaque étape explique ce que fait la commande et dans quels cas l’employer.

Prérequis

• Savoir ouvrir un terminal sous Linux.
• Connaître les bases des chemins absolus et relatifs.
• Disposer de rsync sur le système concerné.
• Avoir les droits d’accès en lecture sur la source et en écriture sur la destination.

Matériel nécessaire

• Un ordinateur sous Linux avec accès au terminal
• La commande rsync disponible
• Deux emplacements de test : un dossier source et un dossier destination

Étapes

1. 1

   Comprendre le rôle de rsync

   

   La commande rsync sert à copier et synchroniser des données entre deux emplacements. Ces emplacements peuvent être :

   • deux dossiers sur la même machine ;
   • un dossier local et un dossier distant ;
   • deux arborescences que l’on souhaite maintenir cohérentes.

   Son intérêt principal est qu’elle compare la source et la destination pour ne transférer que ce qui doit l’être. En pratique, cela en fait un outil très pratique pour répéter régulièrement une copie sans repartir de zéro à chaque fois.

   La structure générale d’une commande est la suivante :

   bash

   rsync [options] source destination

   Exemple très simple :

   bash

   rsync -av ~/Documents/ ~/Sauvegarde/Documents/

   Ici, on synchronise le contenu du dossier ~/Documents/ vers ~/Sauvegarde/Documents/.

   L’option -a est très utilisée car elle active un mode d’archivage adapté aux synchronisations de dossiers. L’option -v active un affichage verbeux pour mieux voir ce qui se passe.

2. 2

   Préparer des dossiers de test avant de manipuler des données réelles

   Avant de travailler sur des dossiers importants, il est recommandé de créer un environnement de test. Cela permet de comprendre le comportement de rsync sans risquer d’écraser ou de supprimer des fichiers utiles.

   Créez par exemple deux dossiers :

   bash

   mkdir -p ~/rsync-test/source
   mkdir -p ~/rsync-test/destination

   Ajoutez quelques fichiers dans la source :

   bash

   echo "fichier 1" > ~/rsync-test/source/a.txt
   echo "fichier 2" > ~/rsync-test/source/b.txt
   mkdir -p ~/rsync-test/source/docs
   echo "notes" > ~/rsync-test/source/docs/notes.txt

   Vous pouvez vérifier le contenu avec :

   bash

   ls -R ~/rsync-test

   Travailler ainsi permet de tester tranquillement les options comme la simulation, les exclusions ou la reprise sans toucher à vos données de production.

3. 3

   Effectuer une première synchronisation locale

   Commençons par une synchronisation de base entre deux dossiers locaux :

   bash

   rsync -av ~/rsync-test/source/ ~/rsync-test/destination/

   Cette commande copie le contenu du dossier source vers le dossier destination. Après exécution, la destination contiendra les fichiers et sous-dossiers présents dans la source.

   Vous pouvez contrôler le résultat :

   bash

   ls -R ~/rsync-test/destination

   Si vous relancez ensuite exactement la même commande, rsync ne recopie pas aveuglément tous les fichiers. C’est ce comportement qui le rend pratique pour les synchronisations répétées.

   L’option -a est une option de travail très fréquente pour conserver une copie fidèle de l’arborescence. L’option -v permet de suivre l’opération dans le terminal.

4. 4

   Bien comprendre le slash final dans les chemins

   

   Un point très important avec rsync concerne la présence ou non d’un slash final sur le chemin source.

   Comparez ces deux commandes :

   bash

   rsync -av ~/rsync-test/source/ ~/rsync-test/destination/
   rsync -av ~/rsync-test/source ~/rsync-test/destination/

   Dans le premier cas, on synchronise le contenu de source/ vers la destination. Dans le second, on copie le dossier source lui-même dans la destination.

   Cette différence paraît mineure, mais elle change le résultat final de l’arborescence. Beaucoup d’erreurs viennent de là.

   Pour apprendre sereinement, testez les deux cas sur vos dossiers d’essai et observez la structure obtenue avec :

   bash

   ls -R ~/rsync-test/destination

   Retenez cette règle pratique : avec un slash final sur la source, on vise généralement le contenu du dossier ; sans slash final, on vise souvent le dossier lui-même.

5. 5

   Simuler une synchronisation avant de l’exécuter

   

   Quand on débute, il est très prudent de lancer d’abord une simulation. Cela permet de voir ce que rsync ferait sans modifier les fichiers.

   Pour cela, utilisez l’option --dry-run :

   bash

   rsync -av --dry-run ~/rsync-test/source/ ~/rsync-test/destination/

   Cette commande affiche les actions prévues, mais n’effectue pas réellement la synchronisation.

   Le mode simulation est particulièrement utile :

   • avant une première exécution ;
   • avant d’utiliser des exclusions ;
   • avant d’ajouter des options plus sensibles ;
   • lorsqu’on n’est pas certain du sens source/destination.

   Une bonne habitude consiste à construire la commande, lancer --dry-run, relire le résultat, puis exécuter la vraie commande seulement si tout paraît cohérent.

6. 6

   Synchroniser un fichier unique

   rsync ne sert pas uniquement à synchroniser des dossiers complets. Il peut aussi copier un fichier précis.

   Exemple :

   bash

   rsync -av ~/rsync-test/source/a.txt ~/rsync-test/destination/

   Cette commande copie le fichier a.txt dans le dossier destination.

   Vous pouvez aussi choisir un autre nom de destination si le chemin fourni désigne explicitement un fichier :

   bash

   rsync -av ~/rsync-test/source/a.txt ~/rsync-test/destination/a-copie.txt

   Pour un débutant, cet usage est intéressant car il aide à comprendre que rsync travaille aussi bien sur des fichiers que sur des arborescences complètes.

7. 7

   Exclure des fichiers ou dossiers pendant la synchronisation

   Il est fréquent de vouloir synchroniser un dossier sans certains éléments : fichiers temporaires, archives, répertoires de cache ou documents inutiles à la cible. Pour cela, rsync propose l’option --exclude.

   Exemple avec exclusion d’un fichier :

   bash

   rsync -av --exclude="b.txt" ~/rsync-test/source/ ~/rsync-test/destination/

   Exemple avec exclusion d’un sous-dossier :

   bash

   rsync -av --exclude="docs/" ~/rsync-test/source/ ~/rsync-test/destination/

   Vous pouvez aussi utiliser plusieurs exclusions :

   bash

   rsync -av --exclude="b.txt" --exclude="docs/" ~/rsync-test/source/ ~/rsync-test/destination/

   Quand on manipule des exclusions, le mode simulation est particulièrement recommandé :

   bash

   rsync -av --dry-run --exclude="b.txt" --exclude="docs/" ~/rsync-test/source/ ~/rsync-test/destination/

   Le but est de vérifier que les bons éléments seront copiés et que les bons éléments seront ignorés.

   Si vous avez beaucoup d’exclusions à gérer, prenez l’habitude de les tester dans un répertoire d’essai avant de les employer sur une synchronisation réelle.

8. 8

   Reprendre un transfert interrompu

   Lorsqu’un transfert est long, il peut être interrompu pour plusieurs raisons : fermeture de session, coupure réseau, arrêt manuel ou autre incident. rsync est souvent choisi précisément parce qu’il est pratique dans ce type de scénario.

   Pour relancer une synchronisation, il suffit très souvent de rejouer la même commande :

   bash

   rsync -av ~/rsync-test/source/ ~/rsync-test/destination/

   Comme rsync compare la source et la destination, il ne repart pas comme une copie brute qui réécrirait tout sans discernement.

   Dans de nombreux cas, on utilise aussi l’option --partial pour conserver les fichiers partiellement transférés :

   bash

   rsync -av --partial ~/rsync-test/source/ ~/rsync-test/destination/

   Cette option est utile lorsqu’un transfert risque d’être interrompu et que l’on souhaite éviter de perdre complètement l’avancement déjà obtenu sur les fichiers concernés.

   Pour un usage débutant, retenez surtout cette méthode simple :

   1. lancez la synchronisation ;
   2. si elle s’interrompt, relancez la même commande ;
   3. si le contexte est instable, envisagez --partial.

   Le plus important est de tester ce comportement sur des données non critiques afin de comprendre comment votre commande réagit.

9. 9

   Synchroniser vers un hôte distant avec SSH

   rsync est très souvent utilisé à travers SSH pour envoyer ou récupérer des fichiers depuis une autre machine Linux.

   Exemple d’envoi vers une machine distante :

   bash

   rsync -av ~/rsync-test/source/ utilisateur@serveur:/home/utilisateur/sauvegarde/

   Exemple de récupération depuis une machine distante :

   bash

   rsync -av utilisateur@serveur:/home/utilisateur/sauvegarde/ ~/rsync-test/destination/

   Dans ces exemples :

   • utilisateur est le nom du compte distant ;
   • serveur désigne l’hôte distant ;
   • le chemin après les deux-points correspond au chemin sur la machine distante.

   Comme pour une synchronisation locale, vous pouvez commencer par une simulation :

   bash

   rsync -av --dry-run ~/rsync-test/source/ utilisateur@serveur:/home/utilisateur/sauvegarde/

   Cette précaution est encore plus importante à distance, car une erreur de chemin ou de sens de copie peut être plus coûteuse à corriger.

10. 10

    Ajouter des exclusions dans une synchronisation distante

    Les exclusions fonctionnent aussi lors d’un transfert via SSH. Par exemple :

    bash

    rsync -av --exclude="docs/" --exclude="b.txt" ~/rsync-test/source/ utilisateur@serveur:/home/utilisateur/sauvegarde/

    Et pour vérifier avant exécution :

    bash

    rsync -av --dry-run --exclude="docs/" --exclude="b.txt" ~/rsync-test/source/ utilisateur@serveur:/home/utilisateur/sauvegarde/

    Ce type de commande est utile quand on souhaite envoyer uniquement le nécessaire sur une machine distante, sans embarquer des fichiers secondaires.

    Pour débuter proprement, gardez les exclusions lisibles et peu nombreuses, puis enrichissez progressivement votre commande quand vous êtes sûr du résultat attendu.

11. 11

    Lire la commande comme une phrase pour éviter les erreurs

    Une bonne pratique consiste à lire mentalement chaque commande rsync comme une phrase simple :

    « Je synchronise cette source vers cette destination, avec ces options. »

    Prenons cet exemple :

    bash

    rsync -av --dry-run --exclude="docs/" ~/rsync-test/source/ ~/rsync-test/destination/

    On peut le lire ainsi :

    • rsync : j’utilise l’outil de synchronisation ;
    • -av : je veux une synchronisation de type archivage avec affichage ;
    • --dry-run : je ne lance qu’une simulation ;
    • --exclude="docs/" : j’ignore le dossier docs/ ;
    • ~/rsync-test/source/ : la source est le contenu de ce dossier ;
    • ~/rsync-test/destination/ : la destination est ce dossier.

    Cette manière de relire la commande réduit nettement les erreurs de débutant, notamment les inversions entre source et destination.

12. 12

    Construire une commande type pour un usage courant

    À ce stade, vous pouvez construire une commande simple et sûre pour un usage courant. Par exemple, pour synchroniser un dossier vers une sauvegarde locale, en excluant certains éléments et en vérifiant d’abord le résultat :

    bash

    rsync -av --dry-run --partial --exclude="docs/" ~/rsync-test/source/ ~/rsync-test/destination/

    Quand la simulation vous convient, retirez --dry-run :

    bash

    rsync -av --partial --exclude="docs/" ~/rsync-test/source/ ~/rsync-test/destination/

    Cette approche est pédagogique parce qu’elle combine plusieurs bonnes habitudes :

    • visualiser ce qui va se passer ;
    • maîtriser les exclusions ;
    • prévoir une reprise plus confortable en cas d’interruption ;
    • garder une commande lisible.

    Pour un débutant, une commande simple bien comprise vaut mieux qu’une commande très chargée mal maîtrisée.

13. 13

    Vérifier le résultat après synchronisation

    Après toute synchronisation importante, il est conseillé de vérifier rapidement le résultat. Cela peut se faire avec des commandes très simples.

    Par exemple, pour lister l’arborescence obtenue :

    bash

    ls -R ~/rsync-test/destination

    Pour vérifier la présence d’un fichier particulier :

    bash

    ls ~/rsync-test/destination
    ls ~/rsync-test/destination/docs

    Si vous travaillez à distance, vous pouvez aussi vous connecter à l’hôte distant et contrôler le contenu du dossier cible.

    La vérification finale est une étape souvent négligée, alors qu’elle permet de confirmer que :

    • la destination est bien la bonne ;
    • les exclusions ont été respectées ;
    • les fichiers attendus sont présents.

    Pour débuter sereinement, considérez qu’une synchronisation n’est pas totalement terminée tant qu’une vérification minimale n’a pas été faite.

Erreurs fréquentes & dépannage

• Inverser source et destination : c’est l’erreur la plus classique. Relisez toujours la commande avant validation.
• Oublier le mode simulation lors d’un premier essai : --dry-run permet de voir le résultat attendu sans modifier les fichiers.
• Mal gérer le slash final sur la source : cela peut changer la structure copiée.
• Tester directement sur des données importantes : commencez sur un répertoire d’essai.
• Employer des exclusions sans vérification : utilisez une simulation pour confirmer que les bons éléments seront ignorés.
• Supposer qu’une commande distante est “comme en local” sans contrôle : à distance, vérifiez encore plus attentivement les chemins.

Astuces & pour aller plus loin

• Commencez toujours par une commande simple avec -av, puis ajoutez les options une par une.
• Utilisez --dry-run dès que vous modifiez la source, la destination ou les exclusions.
• Gardez un dossier de test dédié pour expérimenter sans risque.
• Si un transfert peut être instable, essayez --partial.
• Relisez mentalement la commande comme une phrase : options, source, destination.
• Préférez des chemins clairs et explicites quand vous débutez.

Questions fréquentes

À quoi sert rsync par rapport à cp ?

Dans ce tutoriel, rsync est présenté comme un outil de synchronisation capable de recopier des fichiers et dossiers en évitant de retransférer inutilement ce qui est déjà présent à destination. Cela le rend pratique pour répéter des copies et maintenir deux emplacements cohérents.

Pourquoi utiliser --dry-run ?

L’option --dry-run permet de simuler une synchronisation sans modifier les fichiers. C’est une étape très utile pour vérifier les chemins, le sens de copie et les exclusions avant exécution réelle.

Comment exclure un dossier avec rsync ?

Vous pouvez utiliser l’option --exclude, par exemple : --exclude="docs/". Le tutoriel recommande de tester ce type d’exclusion avec --dry-run avant de lancer la vraie synchronisation.

Comment reprendre un transfert interrompu ?

Le tutoriel explique qu’il suffit très souvent de relancer la même commande rsync. Il présente aussi l’option --partial pour conserver des fichiers partiellement transférés dans certains cas.

Quelle est l’importance du slash final sur la source ?

Le slash final peut changer le résultat de la copie. Le tutoriel montre qu’avec un slash final sur la source, on synchronise généralement le contenu du dossier, alors que sans slash final on copie souvent le dossier lui-même.

Peut-on utiliser rsync avec une machine distante ?

Oui, le tutoriel montre des exemples de synchronisation via SSH, aussi bien pour envoyer des fichiers vers un hôte distant que pour les récupérer.

Conclusion

Vous avez maintenant une base solide pour utiliser rsync en ligne de commande sous Linux dans des cas très courants : synchroniser un dossier, copier un fichier, exclure certains éléments, simuler une opération et relancer un transfert interrompu.

Si vous ne deviez retenir qu’une méthode, ce serait celle-ci : préparer un dossier de test, construire une commande simple, lancer une simulation avec --dry-run, vérifier le résultat attendu, puis exécuter réellement. Cette discipline réduit fortement les erreurs et aide à progresser rapidement.

Une fois ces bases bien comprises, rsync devient un compagnon très fiable pour vos copies locales et distantes sous Linux.