rsync : synchroniser et sauvegarder des fichiers

Quand on sauvegarde des serveurs, déploie des applications ou synchronise des dossiers entre machines, rsync est l'outil de référence. Contrairement à cp ou scp, rsync ne transfère que les différences : si 1% d'un fichier a changé, seul ce 1% traverse le réseau. Résultat : des sauvegardes rapides, reprises possibles si coupure, et un contrôle fin sur ce qui est copié.

Ce que vous allez apprendre

• Synchroniser des dossiers en local avec -av, et à distance avec -avz
• Transférer vers/depuis un serveur distant via SSH
• Exclure des fichiers avec --exclude et --exclude-from
• Utiliser --delete pour un miroir exact (avec précautions)
• Créer des sauvegardes incrémentielles avec --link-dest

La commande rsync dans l'écosystème Linux

rsync fait partie des outils de transfert et de sauvegarde sous Linux. Chaque outil a sa spécialité, et le premier tableau les place côte à côte. Le second répond à la question pratique : pour cette situation, quel outil prendre ? rsync l'emporte dès que le transfert se répète, parce que chaque passage ne renvoie que ce qui a changé.

Commande	Spécialité	Quand l'utiliser
rsync	Synchronisation intelligente (delta)	Sauvegardes, déploiements, gros fichiers
cp	Copie locale simple	Fichiers ponctuels, scripts simples
scp	Copie distante via SSH	Transfert rapide one-shot
sftp	Session de transfert interactive via SSH	Explorer un serveur, plusieurs fichiers en une session
tar	Archivage avec compression	Créer des archives, backups complets
dd	Copie bit-à-bit	Images disques, clonage bas niveau

Glissez pour voir

Quand utiliser rsync plutôt que les autres :

Situation	Meilleur outil	Pourquoi
Sauvegarde quotidienne	rsync	Ne transfère que les changements
Copie d'un fichier vers serveur	scp ou rsync	scp plus simple, rsync reprend si coupé
Synchronisation bi-directionnelle	unison	rsync est unidirectionnel
Cloner un disque	dd	Copie bit-à-bit exacte
Archive compressée à envoyer	tar + ssh	Un seul fichier à transférer

Glissez pour voir

Combinaisons fréquentes :

rsync se combine avec trois outils du quotidien : cron pour planifier, find pour choisir les fichiers, ssh pour le transport. La deuxième forme passe la liste de find à --files-from, qui conserve l'arborescence : un -exec rsync {} fichier par fichier déposerait tout à plat à la racine de la destination.

# rsync + cron : sauvegarde automatique quotidienne
0 2 * * * rsync -avz --delete /data/ backup-srv:/backups/

# rsync + find : sauvegarder uniquement les fichiers modifiés depuis 24 h
find /data -mtime -1 -type f -printf '%P\n' | rsync -av --files-from=- /data/ backup:/data/

# rsync + ssh personnalisé : port non standard
rsync -avz -e "ssh -p 2222" source/ user@server:/dest/

Comprendre rsync en 2 min

Le modèle ci-dessous résume la commande : une source, des filtres qui décident de ce qui passe, une comparaison avec la destination, puis l'envoi des seules différences. Gardez l'ordre en tête, il est le même pour une copie locale et pour un transfert via SSH.

🧠 Modèle mental : Comment fonctionne rsync

rsync = Source → [Filtres] → Destination (ne transfère que les différences)

Source · SVG

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

Points clés

• rsync compare les fichiers par taille et date (ou checksum avec -c)
• Seuls les blocs modifiés sont transférés (algorithme delta)
• Le slash final sur la source change tout : /source/ ≠ /source
• Mode archive (-a) préserve permissions, dates, liens symboliques
• Toujours tester avec --dry-run avant --delete
• SSH est le transport par défaut pour les transferts distants

Règles d'or

1

Toujours tester avec --dry-run avant d'exécuter Surtout avec --delete qui supprime des fichiers sur la destination.

2

Attention au slash final sur la source /source/ copie le contenu, /source copie le dossier lui-même.

Vocabulaire essentiel

-a (archive)

Préserve permissions, dates, liens, récursif

-v (verbose)

Affiche les fichiers traités

-z (compress)

Compresse les données pendant le transfert

-n (dry-run)

Simule sans rien modifier

--delete

Supprime les fichiers absents de la source

--progress

Affiche la progression du transfert

📚 Pour aller plus loin : 12 options avancées

--exclude

Exclure des fichiers/dossiers par pattern

--exclude-from

Lire les exclusions depuis un fichier

--include

Inclure explicitement : la première règle qui correspond l'emporte, à placer avant --exclude

--partial

Conserver les fichiers partiellement transférés

--append

Ajouter à la fin d'un fichier qui ne fait que grossir (journaux), sans vérifier l'existant

--bwlimit

Limiter la bande passante (Kio/s)

--link-dest

Sauvegardes incrémentielles avec liens durs

-e ssh

Spécifier la commande SSH (port, clé...)

--inplace

Modifier les fichiers sur place (risqué)

-c (checksum)

Comparer par checksum au lieu de taille/date

--max-delete

Arrêter les suppressions au-delà de N fichiers (code de sortie 25)

-P

Équivalent à --partial --progress

L'algorithme delta : rsync divise les fichiers en blocs, calcule des sommes de contrôle, et ne transfère que les blocs modifiés. Sur un fichier de 1 Go modifié à 1 %, seuls ~10 Mo de données transitent, plus les sommes de contrôle. Cet algorithme ne sert qu'à travers le réseau : entre deux chemins locaux, le manuel indique que --whole-file est le comportement par défaut, car relire les deux fichiers coûterait plus cher que de recopier.

Syntaxe minimale

Deux règles gouvernent cette syntaxe. La source est toujours à gauche, la destination à droite : inverser les deux écrase les données de travail par une sauvegarde périmée. Et une seule des deux extrémités peut être distante : un transfert de serveur à serveur est refusé avec The source and destination cannot both be remote. et le code de sortie 1. Retenez aussi que le slash final sur la source change le résultat, point détaillé plus bas.

rsync [OPTIONS] SOURCE DESTINATION

Les 3 scénarios d'utilisation

Le passage du local au distant ne change rien à la syntaxe : on ajoute simplement user@serveur: devant le chemin. rsync détecte le deux-points et bascule automatiquement sur SSH comme transport, sans option supplémentaire. C'est aussi ce qui explique une erreur courante : un chemin local contenant un deux-points est interprété comme une destination distante. rsync -av a:b/ /tmp/y/ tente ainsi une connexion vers une machine a et répond ssh: Could not resolve hostname a. Préfixez le chemin par ./ pour lever l'ambiguïté.

Scénario	Syntaxe	Exemple
Local → Local	rsync source/ dest/	rsync -av ~/docs/ /backup/docs/
Local → Distant	rsync source/ user@srv:dest/	rsync -avz ~/data/ admin@srv:/backup/
Distant → Local	rsync user@srv:source/ dest/	rsync -avz srv:/logs/ ~/local-logs/

Glissez pour voir

Le piège du slash final

C'est la source d'erreur n°1 avec rsync, parce qu'elle ne produit aucun message : la commande réussit, mais l'arborescence arrive décalée d'un niveau. Le tableau et le bloc ci-dessous montrent les deux résultats côte à côte.

Commande	Résultat
rsync -av source dest/	Crée dest/source/... (copie le dossier)
rsync -av source/ dest/	Copie le contenu dans dest/...

Glissez pour voir

Règle simple : slash sur source = copie le contenu. Pas de slash = copie le dossier.

/backup/projet/src/...

rsync -av ~/projet /backup/

# Avec slash, résultat : /backup/src/... (contenu directement)
rsync -av ~/projet/ /backup/

Les options essentielles

Ces six options couvrent la quasi-totalité des usages, et l'ordre du tableau reflète leur fréquence réelle. Deux d'entre elles méritent une attention particulière. -a n'est pas une simple abréviation de « récursif » : il préserve permissions, propriétaires, horodatages et liens symboliques, ce qui est indispensable pour une sauvegarde restaurable. -n est le garde-fou : lancé une fois avant chaque commande destructrice, il coûte quelques secondes et évite les pertes irréversibles.

Option	Signification	Usage
-a	Archive	Mode standard : récursif + préserve permissions, dates, liens
-v	Verbose	Affiche les fichiers traités
-z	Compress	Compresse pendant le transfert (utile en réseau)
-n	Dry-run	Simule sans modifier (indispensable avant --delete)
-P	Progress + Partial	Affiche progression + conserve fichiers partiels
--delete	Supprimer	Supprime de dest ce qui n'existe plus dans source

Glissez pour voir

La combo standard :

# Sauvegarde locale basique
rsync -av ~/Documents/ /media/backup/Documents/

# Transfert distant avec compression
rsync -avz ~/projet/ deployer@prod:/var/www/app/

# Test avant suppression
rsync -avn --delete ~/master/ /backup/mirror/

Le delta-transfer en action

L'atout de rsync sur un simple cp ou scp : il ne transfère que les différences. La première synchronisation copie tout, les suivantes ne touchent que ce qui a changé. Démonstration sur trois fichiers, sortie relevée sur Debian 13 (rsync 3.5.0) :

# 1. Première synchro : tout est copié
$ rsync -av src/ dst/
sending incremental file list
created directory dst
./
app.conf
data.txt
logs/
logs/app.log

sent 320 bytes  received 114 bytes  868.00 bytes/sec
total size is 24  speedup is 0.06

# 2. Rien n'a changé : aucun fichier n'est transféré
$ rsync -av src/ dst/
sending incremental file list

sent 149 bytes  received 13 bytes  324.00 bytes/sec
total size is 24  speedup is 0.15

# 3. Un seul fichier modifié : seul lui repart
$ echo "listen 8443 ssl" > src/app.conf
$ rsync -av src/ dst/
sending incremental file list
app.conf

sent 220 bytes  received 36 bytes  512.00 bytes/sec
total size is 28  speedup is 0.11

C'est ce qui rend rsync rapide et économe sur les gros volumes : sur une sauvegarde de plusieurs Go à travers le réseau, seuls les blocs modifiés circulent, pas les fichiers entiers. L'absence de nom de fichier à l'étape 2 prouve que rien n'a été retransféré.

Pour décider qu'un fichier a changé, rsync ne lit pas son contenu : il compare la taille et la date de modification. Un fichier réécrit avec le même nombre d'octets et la même date, à la seconde près, est donc ignoré en silence, ce que la mesure reproduit en recopiant la date avec touch -r. L'option -c force la comparaison par somme de contrôle et rattrape ce cas, au prix d'une relecture complète des deux côtés.

Exclure des fichiers et dossiers

Deux méthodes permettent d'ignorer certains fichiers : des options --exclude sur la ligne de commande pour deux ou trois motifs, un fichier d'exclusions dès que la liste s'allonge ou se partage entre plusieurs scripts. Les motifs suivent la syntaxe glob, et c'est rsync qui les interprète, pas le shell.

Méthode 1 : options --exclude

rsync -av --exclude '*.log' --exclude 'cache/' source/ dest/

Méthode 2 : fichier d'exclusions

# Créer un fichier .rsyncignore
cat > .rsyncignore << 'EOF'
*.log
*.tmp
cache/
.git/
node_modules/
EOF

# Utiliser le fichier
rsync -av --exclude-from=.rsyncignore source/ dest/

Ordre des règles : --include doit venir avant --exclude, car rsync applique la première règle qui correspond. Mesuré sur les trois distributions : la forme incorrecte ne copie aucun fichier et ne signale rien.

# Incorrect : exclude * matche tout avant include
rsync -av --exclude '*' --include '*.txt' source/ dest/

# Correct : include d'abord
rsync -av --include '*.txt' --exclude '*' source/ dest/

Miroir exact avec --delete

L'option --delete rend la destination identique à la source en supprimant les fichiers qui n'existent plus côté source. Le danger est réel : une erreur de chemin transforme la synchronisation en effacement, sans confirmation. D'où la règle en deux étapes, toujours dans cet ordre : prévisualiser avec -n, puis exécuter.

# Étape 1 : TOUJOURS prévisualiser
rsync -avn --delete ~/source/ /backup/mirror/
# Vérifier la liste des fichiers qui seraient supprimés

# Étape 2 : exécuter seulement si la liste est correcte
rsync -av --delete ~/source/ /backup/mirror/

Variantes de --delete :

Depuis rsync 3.0.0, --delete seul équivaut à --delete-during : les suppressions ont lieu pendant le transfert, répertoire par répertoire, et non avant. --delete-before existe toujours mais force l'ancien algorithme de parcours non incrémental, plus gourmand en mémoire. Le vrai filet de sécurité n'est d'ailleurs aucune de ces variantes mais --max-delete=N, qui arrête les suppressions au-delà de N fichiers : rsync affiche Deletions stopped due to --max-delete limit (2 skipped) et sort avec le code 25.

Option	Comportement
--delete	Supprime pendant le transfert, répertoire par répertoire (équivaut à --delete-during depuis rsync 3.0.0)
--delete-before	Supprime avant le début du transfert, au prix de l'ancien parcours non incrémental
--delete-after	Supprime une fois le transfert terminé
--delete-excluded	Supprime aussi les fichiers exclus du transfert
--max-delete=N	Arrête les suppressions au-delà de N fichiers, code de sortie 25

Glissez pour voir

Transferts distants via SSH

SSH est le transport par défaut pour les transferts distants : rsync lance ssh vers la machine désignée, puis démarre un second rsync à l'autre bout. rsync doit donc être installé des deux côtés, et tout ce que sait faire votre client SSH (clés, ~/.ssh/config, rebond) s'applique sans option supplémentaire.

# Syntaxe de base
rsync -avz source/ user@serveur:/chemin/dest/

# Récupérer depuis un serveur
rsync -avz user@serveur:/var/log/ ~/logs-serveur/

SSH personnalisé (port différent, clé spécifique) : l'option -e remplace la commande de transport, ce qui permet de lui passer n'importe quelle option de ssh.

# Port SSH non standard
rsync -avz -e "ssh -p 2222" source/ user@srv:/dest/

# Clé SSH spécifique
rsync -avz -e "ssh -i ~/.ssh/backup_key" source/ backup@srv:/data/

# Combiné
rsync -avz -e "ssh -p 2222 -i ~/.ssh/backup_key" source/ user@srv:/dest/

Reprise de transfert et bande passante

Pour les gros fichiers ou les connexions instables, trois options changent la donne. -P conserve le fichier partiel et affiche la progression, --bwlimit plafonne le débit en Kio/s (unités de 1 024 octets selon le manuel), et --append a un usage bien plus étroit qu'il n'y paraît.

# -P = --partial + --progress
# --partial conserve les fichiers partiellement transférés
rsync -avP grosfichier.iso user@serveur:/data/

# Limiter la bande passante (en Kio/s)
rsync -avz --bwlimit=1000 source/ user@serveur:/dest/

# --append : réservé aux fichiers qui ne font que grossir (journaux)
rsync -av --append /var/log/app/ user@serveur:/archives/logs/

-P suffit à reprendre un transfert coupé : le fichier partiel conservé sert de base à l'algorithme delta au passage suivant. --append n'est pas un mode de reprise générique : il ajoute des octets à la fin sans jamais vérifier le contenu déjà présent, et corrompt donc silencieusement tout fichier qui aurait été modifié ailleurs qu'à sa fin. Réservez-le aux fichiers strictement croissants, ou utilisez --append-verify qui contrôle la partie existante par somme de contrôle.

Sauvegardes incrémentielles avec --link-dest

--link-dest crée des sauvegardes qui semblent complètes mais n'utilisent de l'espace que pour les fichiers modifiés : chaque fichier identique à celui du répertoire de référence devient un lien dur vers lui. Un chemin relatif est résolu depuis la destination, et le répertoire parent de la destination doit exister, sinon rsync répond mkdir "/backup/auj" failed: No such file or directory (2) avec le code 11.

# Structure de sauvegardes
/backup/
├── 2024-01-01/   # Sauvegarde complète
├── 2024-01-02/   # Liens durs vers 2024-01-01 + nouveaux fichiers
└── 2024-01-03/   # Liens durs vers 2024-01-02 + nouveaux fichiers

# Commande
rsync -av --link-dest=/backup/2024-01-01 ~/data/ /backup/2024-01-02/

Script de sauvegarde incrémentielle :

Au premier lancement, la sauvegarde de la veille n'existe pas encore : rsync affiche --link-dest arg does not exist: /backup/2026-09-29, fait une copie complète et sort avec le code 0. Le script n'a donc pas besoin de traiter ce cas à part.

#!/bin/bash
BACKUP_DIR="/backup"
SOURCE="/home/user/data"
TODAY=$(date +%Y-%m-%d)
YESTERDAY=$(date -d "yesterday" +%Y-%m-%d)

mkdir -p "$BACKUP_DIR"
# Créer la sauvegarde en utilisant l'ancienne comme référence
rsync -av --link-dest="$BACKUP_DIR/$YESTERDAY" \
    "$SOURCE/" "$BACKUP_DIR/$TODAY/"

Économie d'espace : avec 100 Go de données dont 1 % change par jour, sept sauvegardes quotidiennes occupent ~106 Go (une copie complète, puis six fois 1 Go) au lieu de 700 Go. Le calcul suppose que ce 1 % tient dans peu de fichiers : un lien dur porte sur un fichier entier, et un fichier modifié d'un seul octet est recopié en totalité.

Automatisation avec cron

cron lance la commande à heure fixe, sans terminal : tout ce que rsync affiche doit donc partir dans un journal, sans quoi un échec passe inaperçu. Dans une crontab, le caractère % a un sens particulier et doit être échappé en \%, d'où la forme de la date ci-dessous.

# Éditer la crontab
crontab -e

# Ajouter (sauvegarde à 2h du matin)
0 2 * * * rsync -avz --delete /data/ backup-server:/backups/$(date +\%Y-\%m-\%d)/ >> /var/log/rsync-backup.log 2>&1

Script complet avec rotation :

La rotation décale chaque instantané d'un jour, puis fige l'état courant avec cp -al, qui crée des liens durs au lieu de copier. Chaque mv est conditionné à l'existence du répertoire : sans cette précaution, les six premières nuits échoueraient faute de day.6. Rejoué sur neuf nuits consécutives sous Debian 13 : sept instantanés, le plus récent dans day.1, et les fichiers inchangés partagés par liens durs.

#!/bin/bash
# backup.sh - Sauvegarde avec rotation sur 7 jours

REMOTE="backup@srv:/backups"
SOURCE="/home/user/data"
LOG="/var/log/rsync-backup.log"

echo "=== Backup started: $(date) ===" >> "$LOG"

# Sauvegarde
rsync -avz --delete "$SOURCE/" "$REMOTE/current/" >> "$LOG" 2>&1

# Rotation (garder 7 jours)
ssh backup@srv 'cd /backups && rm -rf day.7 &&
    for i in 6 5 4 3 2 1; do
      if [ -d "day.$i" ]; then mv "day.$i" "day.$((i + 1))"; fi
    done &&
    cp -al current day.1'

echo "=== Backup completed: $(date) ===" >> "$LOG"

Les pièges à éviter

Ces erreurs reviennent constamment avec rsync. Les connaître à l'avance vous évite des pertes de données et des heures de diagnostic.

Le piège du slash final

rsync -av /source /destination

Symptôme : un dossier source/ inattendu apparaît dans destination/.

Cause : sans slash final, rsync copie le dossier lui-même ; avec slash, il copie son contenu.

rsync -av /source/ /destination/

--delete sans test préalable

rsync -av --delete source/ dest/

Symptôme : des fichiers importants disparaissent de la destination.

Cause : --delete supprime tout ce qui n'est pas présent dans la source, une erreur de chemin devient destructrice.

rsync -av --delete --dry-run source/ dest/   # vérifier, puis relancer sans --dry-run

Inversion source/destination

rsync -av --delete backup/ source/

Symptôme : les fichiers de travail sont écrasés par une vieille sauvegarde.

Cause : confusion entre source et destination, rsync copie toujours ce qui est à gauche vers ce qui est à droite.

rsync -av source/ backup/

Ordre des --include / --exclude

rsync -av --exclude "*" --include "*.txt" source/ dest/

Symptôme : aucun fichier n'est copié malgré le --include.

Cause : rsync applique les règles dans l'ordre ; --exclude "*" capture tout avant que --include ne soit évalué.

rsync -av --include "*.txt" --exclude "*" source/ dest/

Erreurs de permissions sur la destination

rsync -av ~/files/ /opt/

Symptôme : une ligne rsync: [receiver] mkstemp "/opt/.app.conf.ms5nIm" failed: Permission denied (13) par fichier, puis la sortie avec le code 23.

Cause : l'utilisateur courant n'a pas le droit d'écrire dans la destination. rsync crée chaque fichier sous un nom temporaire avant de le renommer, d'où ce nom en .app.conf.XXXXXX. À ne pas confondre avec le propriétaire : un compte non root ne peut pas le conserver, et -a attribue alors les fichiers au compte courant sans aucune erreur.

rsync -av ~/files/ ~/sauvegarde/                            # destination accessible
rsync -av --rsync-path="sudo rsync" ~/files/ admin@srv:/opt/  # côté distant, si sudo est prévu pour rsync

Espaces dans les chemins distants

rsync -av user@srv:/path/with spaces/ local/

Symptôme : fichiers inattendus, ou un chemin introuvable côté distant.

Cause : le shell local découpe l'argument sur l'espace avant même que rsync ne le voie.

rsync -av "user@srv:/path/with spaces/" local/

Les simples guillemets suffisent : depuis la version 3.2.4, rsync échappe lui-même les caractères actifs, espaces compris, dans les arguments transmis au shell distant. Ajouter une contre-oblique à la main aboutit à un double échappement : mesuré sur rsync 3.2.7 et 3.5.0, la commande répond change_dir "/srv/avec\ espaces" failed: No such file or directory (2) et sort avec le code 23. Sur un serveur équipé d'un rsync antérieur, l'option --old-args rétablit l'ancien comportement.

Garder rsync à jour : le réflexe sécurité 2026

rsync est un outil mûr, mais 2026 a été une année chargée pour sa sécurité. La version 3.4.3 (20 mai 2026) corrige six CVE, dont CVE-2026-43618 (CVSS v3.1 8.1, dépassement d'entier dans le décodeur de jetons compressés, atteignable depuis un simple pull) et CVE-2026-29518 (CVSS v4.0 7.3, race condition TOCTOU en mode daemon sans chroot). La 3.5.0 (13 août 2026), présentée par ses mainteneurs comme une « major security release », corrige ensuite 33 failles issues d'un audit du traitement des chemins et du protocole daemon : la plupart exploitent un lien symbolique posé par un utilisateur local qu'un rsync lancé en root finit par suivre. La 3.5.1 (21 septembre 2026) corrige les régressions de la 3.5.0 (source : fichier NEWS du projet).

Le numéro de version ne suffit pas à juger d'une machine : les distributions rétroportent les correctifs sans changer de version amont. Mesuré le 2026-09-30 :

Distribution	rsync --version
Ubuntu 24.04	3.2.7, protocole 31
Debian 13	3.5.0, protocole 32
AlmaLinux 10	3.5.0, protocole 32

Glissez pour voir

rsync --version | head -1
# rsync  version 3.5.0  protocol version 32

Sur Ubuntu, c'est le suivi de sécurité de la distribution qui fait foi (apt changelog rsync), pas le 3.2.7 affiché. Deux réflexes en découlent. D'abord, mettre rsync à jour sur les machines qui l'exposent (serveurs de sauvegarde, relais de transfert). Ensuite, ne jamais exposer un daemon rsync nu : la plupart des usages passent par SSH (rsync -e ssh), qui chiffre et authentifie le transfert. Le mode daemon (rsync://) reste réservé à des réseaux de confiance, idéalement derrière un pare-feu et avec chroot.

Travaux pratiques

Ce lab vous fait manipuler rsync sur une arborescence réelle, de la synchronisation basique à la sauvegarde incrémentielle. Comptez 15 minutes.

Préparer le terrain

Le script suivant crée une arborescence de test avec des fichiers de tailles et de dates variées, plus deux cas pièges : des fichiers à exclure et un nom qui contient une espace.

# Créer le lab
mkdir -p ~/rsync-lab/{source,backup,remote-sim}
cd ~/rsync-lab/source

# Créer des fichiers variés
echo "Configuration principale" > config.conf
echo "Application logs" > app.log
dd if=/dev/zero of=data.bin bs=1M count=5 2>/dev/null
mkdir -p docs
echo "Documentation" > docs/readme.md
echo "Notes" > docs/notes.txt

# Fichiers à exclure
echo "Temporaire" > temp.tmp
mkdir -p cache
echo "Cache data" > cache/data.cache

# Fichier avec espace dans le nom
echo "Rapport important" > "rapport 2024.pdf"

# Fichier ancien
touch -d "30 days ago" docs/old-doc.md

echo "Lab créé dans ~/rsync-lab"
ls -laR ~/rsync-lab/source

Pour tout nettoyer à la fin : rm -rf ~/rsync-lab.

Les 8 étapes du lab

Les étapes s'enchaînent sur la même arborescence et l'état obtenu à chaque étape sert à la suivante : ne les prenez pas dans le désordre. Après chacune, comparez les deux dossiers avec diff -r ~/rsync-lab/source ~/rsync-lab/backup pour constater l'effet réel de l'option employée plutôt que de vous fier au message affiché.

1. Synchronisation basique, copiez le contenu de source/ vers backup/ en mode archive : rsync -av ~/rsync-lab/source/ ~/rsync-lab/backup/. Tous les fichiers sont copiés avec leurs attributs préservés.

2. Test avec --dry-run, simulez une synchronisation avec --delete sans rien modifier : rsync -av --delete --dry-run ~/rsync-lab/source/ ~/rsync-lab/backup/. La sortie affiche ce qui serait fait, sans toucher aux fichiers.

3. Exclure des fichiers, synchronisez en ignorant les .tmp et le dossier cache/ : rsync -av --exclude "*.tmp" --exclude "cache/" ~/rsync-lab/source/ ~/rsync-lab/backup/. temp.tmp et cache/ ne sont pas copiés.

4. Miroir exact avec --delete, créez un fichier orphelin puis synchronisez : touch ~/rsync-lab/backup/fichier-orphelin.txt suivi de rsync -av --delete ~/rsync-lab/source/ ~/rsync-lab/backup/. Le fichier orphelin est supprimé car absent de la source.

5. Transfert distant (simulé en local), utilisez la compression : rsync -avz ~/rsync-lab/source/ ~/rsync-lab/remote-sim/. Pour un vrai serveur, la destination serait user@serveur:/chemin/, et avec un port SSH personnalisé : rsync -avz -e "ssh -p 2222" source/ user@serveur:/backup/.

6. Afficher la progression, synchronisez data.bin avec la barre de progression : rsync -av --progress ~/rsync-lab/source/data.bin ~/rsync-lab/backup/. Taille, vitesse et pourcentage s'affichent pendant le transfert.

7. Limiter la bande passante, transférez data.bin à 500 Kio/s maximum : rsync -avz --bwlimit=500 ~/rsync-lab/source/data.bin ~/rsync-lab/backup/. Le transfert est plafonné, utile pour ne pas saturer le réseau.

8. Sauvegarde incrémentielle, créez une sauvegarde avec liens durs vers la précédente : rsync -av --link-dest=../backup ~/rsync-lab/source/ ~/rsync-lab/backup-new/. Les fichiers inchangés deviennent des liens durs, ce qui économise l'espace disque.

Exercices progressifs

Ces exercices vont du réflexe de base à la sauvegarde professionnelle. Lisez l'énoncé, cherchez la commande, puis dépliez la solution pour vérifier.

Niveau fondations

Les deux premiers exercices posent les deux réflexes qui évitent presque toutes les pertes : le mode archive avec le slash final, et la simulation avant toute suppression.

Exercice 1, Première synchronisation. Synchronisez le dossier ~/Documents vers /media/backup/Documents en préservant les attributs.

Indice : -a pour archive, -v pour voir ce qui se passe.

Voir la solution

rsync -av ~/Documents/ /media/backup/Documents/

-a préserve tout (permissions, dates, liens). N'oubliez pas le slash final sur la source.

Exercice 2, Test avant exécution. Simulez une synchronisation avec --delete sans rien modifier.

Indice : --dry-run (ou -n) simule sans modifier.

Voir la solution

rsync -av --delete --dry-run ~/source/ ~/backup/

--dry-run est essentiel avant toute commande --delete : il montre l'impact réel sans risque.

Niveau composition

Ces trois exercices combinent le transfert avec un filtre, la compression ou un miroir exact.

Exercice 3, Exclusion de fichiers. Synchronisez en excluant tous les fichiers .log et le dossier cache/.

Indice : --exclude peut être utilisé plusieurs fois.

Voir la solution

rsync -av --exclude "*.log" --exclude "cache/" ~/source/ ~/backup/

--exclude accepte des motifs glob et se répète autant de fois que nécessaire.

Exercice 4, Transfert vers serveur distant. Envoyez le dossier ~/projet vers user@serveur:/var/www/app avec compression.

Indice : -z active la compression, utile sur le réseau.

Voir la solution

rsync -avz ~/projet/ user@serveur:/var/www/app/

-z compresse les données pendant le transfert. SSH est le transport par défaut.

Exercice 5, Miroir exact. Créez un miroir exact de ~/master vers /backup/mirror en supprimant les fichiers obsolètes.

Indice : --delete supprime ce qui n'existe plus dans la source.

Voir la solution

rsync -av --delete ~/master/ /backup/mirror/

--delete rend la destination identique à la source. Testez toujours avec --dry-run d'abord.

Niveau industrialisation

Ici le transfert doit tenir dans un contexte réel : un port SSH non standard et une connexion instable.

Exercice 6, SSH avec port personnalisé. Synchronisez vers un serveur qui utilise le port SSH 2222.

Indice : -e permet de spécifier la commande SSH.

Voir la solution

rsync -avz -e "ssh -p 2222" ~/data/ user@serveur:/backup/

-e "ssh -p 2222" change le port. La même syntaxe accepte -i pour une clé privée dédiée.

Exercice 7, Transfert avec reprise. Transférez un gros fichier avec possibilité de reprise si la connexion est coupée.

Indice : -P combine --partial et --progress.

Voir la solution

rsync -avP grosfichier.iso user@serveur:/data/

-P conserve les fichiers partiels et affiche la progression : le transfert reprend où il s'était arrêté.

Niveau sécurité

Le dernier exercice construit une sauvegarde incrémentielle, celle qui permet de revenir à un état antérieur sans multiplier l'espace disque.

Exercice 8, Sauvegarde incrémentielle. Créez une sauvegarde datée utilisant des liens durs vers la précédente.

Indice : --link-dest référence la sauvegarde précédente.

Voir la solution

rsync -av --link-dest=/backup/2024-01-01 ~/data/ /backup/2024-01-02/

--link-dest économise énormément d'espace : seuls les fichiers modifiés sont réellement dupliqués.

Dépannage

Quand un transfert échoue ou se comporte mal, ces méthodes de diagnostic et ces erreurs fréquentes couvrent la grande majorité des cas. Commencez par la méthode, qui dit où chercher, puis confrontez le message et le code de sortie au tableau.

Méthodes de diagnostic

Ces quatre commandes répondent chacune à une question différente. --dry-run répond à « qu'est-ce que rsync va faire ? », -vvv à « pourquoi ce fichier est-il retransféré ? », le test SSH séparé à « le problème vient-il de rsync ou du transport ? », et --stats à « combien a réellement circulé ? ». Commencez toujours par isoler le transport : un ssh user@serveur "ls" qui échoue rend inutile tout diagnostic côté rsync.

# Simuler sans rien modifier
rsync -av --dry-run source/ dest/

# Mode très verbeux : tous les détails
rsync -avvv source/ dest/

# Tester la connexion SSH avant rsync
ssh -v user@serveur "ls /chemin/"

# Afficher les statistiques de transfert
rsync -av --stats source/ dest/

Erreurs fréquentes

Deux de ces cinq erreurs concernent le transport, pas la copie elle-même : c'est le réflexe à garder quand un transfert distant échoue. rsync renvoie un code de sortie distinct pour chaque famille de problème, visible avec echo $? juste après la commande et documenté dans la section EXIT VALUES du manuel : 1 pour une erreur de syntaxe, 10 pour une erreur de socket, 11 pour une erreur d'entrée-sortie sur un fichier, 12 pour une erreur du protocole, 23 pour un transfert partiel dû à des erreurs, 24 quand des fichiers source ont disparu en cours de route, 25 quand la limite --max-delete a stoppé les suppressions. Si la connexion SSH échoue, c'est 255 qui remonte. Tous les messages du tableau ont été relevés sur rsync 3.2.7 et 3.5.0.

Erreur	Cause probable	Solution
mkstemp "..." failed: Permission denied (13), code 23	Pas de droits d'écriture sur la destination, ou SELinux/AppArmor bloque	Viser un dossier accessible, ou --rsync-path="sudo rsync" côté distant
ssh: connect to host srv port 22: Connection refused, code 255	sshd arrêté, pare-feu, ou mauvais port SSH	Démarrer sshd, ouvrir le pare-feu, ou préciser le bon port avec -e "ssh -p ..."
failed to connect to srv (...): Connection refused (111), code 10	URL rsync:// alors qu'aucun daemon rsync n'écoute	Passer par SSH (user@srv:/chemin) ou démarrer le daemon
Host key verification failed	Première connexion, ou serveur réinstallé (clé changée)	ssh-keygen -R serveur puis ssh user@serveur pour accepter la clé
write failed on "...": No space left on device (28), code 11	Disque destination plein ou quota atteint	Vérifier avec df -h, libérer de l'espace ou augmenter le quota

Glissez pour voir

Aide-mémoire rsync

À garder sous la main : la syntaxe générale, les options de base et les filtres les plus utilisés au quotidien.

Syntaxe et slash final

Les deux dernières lignes sont celles à relire avant chaque commande de sauvegarde. La différence entre source/ et source ne provoque aucune erreur, elle produit simplement une arborescence décalée d'un niveau, souvent découverte plusieurs sauvegardes plus tard. Le slash sur la destination n'a, lui, aucun effet.

Syntaxe	Signification	Exemple
rsync [OPTIONS] SOURCE DEST	Format général de la commande	rsync -av source/ dest/
rsync ... user@host:path	Transfert distant via SSH	rsync -avz data/ user@srv:/backup/
source/	Copie le contenu de source	rsync -av source/ dest/
source	Copie le dossier source	rsync -av source dest/

Glissez pour voir

Options courantes

Ces options se cumulent librement, à une exception près : -c force la comparaison par somme de contrôle de tous les fichiers et annule l'optimisation par taille et date, ce qui allonge considérablement le traitement sur de gros volumes. Ne l'activez que pour vérifier une sauvegarde suspecte, jamais dans une tâche planifiée quotidienne.

Syntaxe	Signification	Exemple
-a (archive)	Récursif + préserve tout	rsync -a source/ dest/
-v (verbose)	Affiche les fichiers traités	rsync -av source/ dest/
-z (compress)	Compresse pendant le transfert	rsync -avz source/ dest/
-n (dry-run)	Simule sans modifier	rsync -avn --delete source/ dest/
-P	--partial + --progress	rsync -avP gros.iso dest/
--bwlimit=RATE	Limite la bande passante (Kio/s par défaut)	--bwlimit=1000
-c (checksum)	Compare par checksum	rsync -avc source/ dest/
--stats	Affiche les statistiques	rsync -av --stats source/ dest/
-e "ssh ..."	Personnalise SSH (port, clé)	-e "ssh -p 2222"

Glissez pour voir

Synchronisation et filtres

Les filtres sont évalués dans l'ordre où ils apparaissent sur la ligne de commande, et la première règle qui correspond l'emporte. C'est la cause de la totalité des surprises sur --include et --exclude. Le motif suit la syntaxe glob du shell, mais c'est rsync qui l'interprète, pas le shell : entourez toujours vos motifs de guillemets pour qu'ils lui parviennent intacts.

Syntaxe	Signification	Exemple
--delete	Supprime les fichiers absents de la source	rsync -av --delete source/ dest/
--delete-after	Supprime après le transfert	rsync -av --delete-after source/ dest/
--update	Ignore les fichiers plus récents sur la destination	rsync -av --update source/ dest/
--exclude "pattern"	Exclut des fichiers	--exclude "*.log"
--exclude-from=FILE	Exclusions depuis un fichier	--exclude-from=.rsyncignore
--include "pattern"	Inclut (à placer avant --exclude)	--include "*.txt" --exclude "*"
--link-dest=DIR	Liens durs pour sauvegarde incrémentielle	--link-dest=/backup/prev

Glissez pour voir

Checklist de maîtrise

Vous maîtrisez rsync quand vous pouvez cocher chacun de ces points sans hésiter. Un point que vous ne cochez pas vous renvoie à la section correspondante plus haut.

• Je sais utiliser -a, -v, -z pour une synchronisation standard.
• Je sais tester avec --dry-run avant d'exécuter.
• Je sais exclure des fichiers avec --exclude.
• Je sais transférer vers et depuis un serveur distant.
• Je sais utiliser --delete pour un miroir exact.
• Je sais personnaliser SSH (port, clé).
• Je sais reprendre un transfert interrompu avec -P.
• Je sais faire des sauvegardes incrémentielles avec --link-dest.
• Je comprends l'importance du slash final sur la source.
• Je sais diagnostiquer une erreur de connexion SSH.

À retenir

• -avz : la combinaison standard (archive + verbose + compression)
• Slash final : /source/ copie le contenu, /source copie le dossier
• --dry-run : TOUJOURS tester avant --delete
• --link-dest : sauvegardes incrémentielles économes en espace
• -P : reprise possible des transferts interrompus
• Taille et date : un fichier modifié sans changer ni l'une ni l'autre est ignoré, sauf avec -c
• Codes de sortie : 23 transfert partiel, 25 limite --max-delete, 255 échec SSH

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

FAQ - Questions Fréquemment Posées

Les réponses ci-dessous reprennent, sous forme de questions, les points qui reviennent le plus souvent : la syntaxe, le slash final, les filtres, la suppression avec --delete et la bande passante. Chacune tient seule et renvoie aux mesures faites plus haut.

Qu'est-ce que la commande rsync sous Linux ?

Pourquoi utiliser rsync plutôt que cp ou scp ?

Quelle est la syntaxe de base de rsync ?

Que signifie l'option -a dans rsync ?

Comment exclure des fichiers avec rsync ?

Quelle différence entre /source et /source/ dans rsync ?

Comment synchroniser des fichiers via SSH avec rsync ?

Comment supprimer les fichiers obsolètes dans la destination ?

Comment simuler une synchronisation avec rsync ?

Comment limiter la bande passante utilisée par rsync ?

×

📖 Voir la documentation →