Guide Linux : Automatiser ses sauvegardes avec rsync, sans mauvaise surprise

1. Rsync : un excellent copieur, pas une stratégie complète

Rsync synchronise des fichiers dans un sens, d’une source vers une destination. Il compare principalement la taille et la date de modification, copie les nouveaux fichiers, met à jour ceux qui ont changé et peut préserver de nombreuses métadonnées. Sur un réseau, son algorithme limite les données retransmises pour les fichiers déjà présents.

Il fonctionne en local, au travers de SSH ou avec un démon rsync. Ce guide retient SSH, plus courant et chiffré. Rsync n’est en revanche ni un service permanent de synchronisation bidirectionnelle, ni un outil de chiffrement au repos, ni une sauvegarde immuable.

2. Installer rsync et vérifier l’environnement

Rsync est souvent déjà présent. Sinon, installez-le avec le gestionnaire de paquets de votre distribution :

    # Debian, Ubuntu, Linux Mint
      $ sudo apt update
      $ sudo apt install rsync
      # Fedora
      $ sudo dnf install rsync
      # Arch Linux et dérivées
      $ sudo pacman -S rsync
  

Vérifiez ensuite le binaire réellement utilisé et sa version :

    $ command -v rsync
      /usr/bin/rsync
      $ rsync --version
      rsync  version …  protocol version …
  

Pour une copie via SSH, rsync doit être installé des deux côtés. Testez d’abord la connexion et acceptez la clé d’hôte uniquement après avoir vérifié son empreinte auprès de l’administrateur du serveur :

    $ ssh sauvegarde@serveur.example
      $ rsync --version
      $ exit
  

3. Le slash final qui change la destination

C’est la subtilité à apprendre avant toute automatisation. Sur la source, un slash final signifie « copie le contenu de ce dossier ». Sans slash, rsync copie aussi le dossier lui-même.

        $ rsync -a /home/alice/Documents /mnt/backup/
      

        $ rsync -a /home/alice/Documents/ /mnt/backup/
      

Le slash de la destination est moins décisif quand le dossier existe déjà. Pour rester lisible, utilisez des chemins absolus, nommez clairement la destination et conservez la même convention dans tous vos essais.

4. Première sauvegarde locale, étape par étape

Supposons que vos documents soient dans /home/alice/Documents/ et qu’un disque externe soit monté dans /mnt/backup-alice/. Commencez par vérifier ce que le système voit :

    $ findmnt --target /mnt/backup-alice
      $ df -h /home/alice/Documents /mnt/backup-alice
      $ ls -la /home/alice/Documents /mnt/backup-alice
  

Lancez ensuite une simulation. Les guillemets évitent qu’un espace ou un caractère spécial soit interprété par le shell :

    $ rsync -avhn --itemize-changes \
      "/home/alice/Documents/" \
      "/mnt/backup-alice/current/"
  

Lisez la liste, contrôlez les deux chemins, puis retirez seulement -n :

    $ rsync -avh --itemize-changes \
      "/home/alice/Documents/" \
      "/mnt/backup-alice/current/"
  

Au premier passage, tout est copié. Aux suivants, rsync ne met à jour que ce qui le nécessite. Tant que --delete n’est pas présent, un fichier qui existe seulement dans la destination y reste.

5. Sauvegarder sur une autre machine via SSH

La forme utilisateur@hôte:chemin désigne un chemin distant. Pour pousser les documents vers un serveur :

    $ rsync -avhn --itemize-changes \
      "/home/alice/Documents/" \
      "sauvegarde@serveur.example:/srv/backups/alice/current/"
  

Après contrôle, retirez -n. Pour un port SSH différent, utilisez -e :

    $ rsync -avh -e "ssh -p 2222" \
      "/home/alice/Documents/" \
      "sauvegarde@serveur.example:/srv/backups/alice/current/"
  

Une tâche planifiée ne peut pas répondre à un mot de passe. Utilisez une clé SSH dédiée, idéalement limitée au compte et à la destination de sauvegarde. Testez impérativement le mode non interactif :

    $ ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_backup
      $ ssh-copy-id -i ~/.ssh/id_ed25519_backup.pub sauvegarde@serveur.example
      $ ssh -o BatchMode=yes -i ~/.ssh/id_ed25519_backup sauvegarde@serveur.example true
      $ echo $?
      0
  

BatchMode=yes interdit les demandes interactives : l’automatisation échoue clairement au lieu de rester bloquée. Ne désactivez pas la vérification de clé d’hôte avec StrictHostKeyChecking=no ; enregistrez et vérifiez plutôt la bonne clé dans known_hosts.

6. Les options essentielles, sans alphabet magique

Pour sauvegarder ACL et attributs étendus sur un système de fichiers compatible, ajoutez -A -X. La conservation fidèle des propriétaires demande des privilèges adéquats côté réception. Pour une sauvegarde personnelle sans droits root, une variante réaliste est :

    $ rsync -a --no-owner --no-group SOURCE/ DESTINATION/
  

Sur FAT, exFAT ou certains montages réseau, les permissions Unix, liens et attributs ne peuvent pas tous être représentés. Ne considérez pas les avertissements comme du bruit : ils disent parfois que la restauration ne sera pas fidèle.

7. Exclusions : gagner de la place sans oublier l’essentiel

On peut ignorer les caches, corbeilles et fichiers temporaires avec plusieurs --exclude :

    $ rsync -avhn --itemize-changes \
      --exclude='.cache/' \
      --exclude='.local/share/Trash/' \
      --exclude='*.tmp' \
      "/home/alice/" "/mnt/backup-alice/home/"
  

Pour une liste maintenable, créez /home/alice/.config/rsync/exclusions.txt :

    # Un motif par ligne
      /.cache/
      /.local/share/Trash/
      *.tmp
      *.part
  

Puis utilisez-la :

    $ rsync -avhn --itemize-changes \
      --exclude-from="/home/alice/.config/rsync/exclusions.txt" \
      "/home/alice/" "/mnt/backup-alice/home/"
  

Un motif commençant par / est ancré à la racine du transfert. Sans slash initial, il peut correspondre plus profondément. Vérifiez toujours les motifs avec --dry-run et --itemize-changes.

8. --delete : utile pour un miroir, dangereux pour une sauvegarde

Avec --delete, rsync supprime de la destination les éléments absents de la source dans les dossiers synchronisés. C’est pratique pour maintenir un miroir exact, mais cela propage aussi les suppressions accidentelles.

    $ rsync -avhn --delete-delay --max-delete=20 \
      --itemize-changes \
      "/home/alice/Documents/" \
      "/mnt/backup-alice/current/"
  

--delete-delay calcule les suppressions pendant le transfert et les applique à la fin. --max-delete=20 arrête la phase de suppression si la limite est dépassée et renvoie le code 25. Adaptez ce seuil à votre usage ; il ne remplace ni la simulation ni les versions.

Par défaut, les éléments exclus sont aussi protégés contre la suppression. --delete-excluded change ce comportement et mérite donc la même prudence que --delete.

9. Une stratégie prudente contre les chemins inversés et les supports absents

Créez une fois deux fichiers sentinelles. Ils prouvent que la source attendue et le bon disque de destination sont présents :

    $ touch "/home/alice/Documents/.lrg-backup-source"
      $ touch "/mnt/backup-alice/.lrg-backup-target"
  

Le script suivant refuse les chemins vides ou racine, exige les sentinelles, vérifie que le disque est réellement monté, empêche deux exécutions simultanées, journalise la copie et conserve le code de sortie. Remplacez alice par votre nom d’utilisateur.

    #!/usr/bin/env bash
      set -u
      SOURCE="/home/alice/Documents"
      BACKUP_ROOT="/mnt/backup-alice"
      DEST="$BACKUP_ROOT/current"
      LOG_DIR="/home/alice/.local/state/rsync-backup"
      LOG_FILE="$LOG_DIR/backup.log"
      mkdir -p "$LOG_DIR"
      exec 9>"$LOG_DIR/backup.lock"
      flock -n 9 || { echo "Sauvegarde déjà en cours"; exit 75; }
      fail() { printf '%s ERREUR: %s\n' "$(date --iso-8601=seconds)" "$*" | tee -a "$LOG_FILE" >&2; exit 64; }
      [[ -n "$SOURCE" && "$SOURCE" != "/" ]] || fail "source invalide"
      [[ -n "$DEST" && "$DEST" != "/" ]] || fail "destination invalide"
      [[ -d "$SOURCE" ]] || fail "source absente"
      [[ -f "$SOURCE/.lrg-backup-source" ]] || fail "sentinelle source absente"
      mountpoint -q "$BACKUP_ROOT" || fail "support de destination non monté"
      [[ -f "$BACKUP_ROOT/.lrg-backup-target" ]] || fail "sentinelle destination absente"
      [[ "$(realpath -m "$SOURCE")" != "$(realpath -m "$DEST")" ]] || fail "source et destination identiques"
      mkdir -p "$DEST"
      printf '%s DÉBUT\n' "$(date --iso-8601=seconds)" >> "$LOG_FILE"
      /usr/bin/rsync -a --partial --delete-delay --max-delete=20 \
      --exclude='.lrg-backup-source' \
      --itemize-changes --stats \
      --log-file="$LOG_FILE" \
      "$SOURCE/" "$DEST/"
      status=$?
      printf '%s FIN code=%s\n' "$(date --iso-8601=seconds)" "$status" >> "$LOG_FILE"
      exit "$status"
  

Enregistrez-le dans /home/alice/.local/bin/sauvegarde-rsync, rendez-le exécutable, puis lancez-le manuellement :

    $ chmod 700 /home/alice/.local/bin/sauvegarde-rsync
      $ /home/alice/.local/bin/sauvegarde-rsync
      $ echo $?
  

Le script ne contient pas --delete seul : il ajoute un délai et une limite. Pour une phase d’observation encore plus sûre, ajoutez temporairement --dry-run à la commande du script.

10. Automatiser : cron ou timer systemd

Automatisez seulement après plusieurs exécutions manuelles réussies, dont une sans support branché : le script doit alors échouer sans écrire dans un simple dossier vide sous /mnt.

Option A : cron, simple et largement disponible

Ouvrez la crontab de l’utilisateur avec crontab -e, puis ajoutez une exécution quotidienne à 20 h 00 :

    SHELL=/bin/sh
      PATH=/usr/local/bin:/usr/bin:/bin
      0 20 * * * /home/alice/.local/bin/sauvegarde-rsync >> /home/alice/.local/state/rsync-backup/cron.log 2>&1
  

Cron dispose d’un environnement réduit : utilisez des chemins absolus. Si la machine est éteinte à 20 h, cette occurrence est normalement manquée. Vérifiez la crontab avec crontab -l et consultez les journaux du service cron selon votre distribution.

Option B : un timer systemd utilisateur, mieux observable

Créez ~/.config/systemd/user/sauvegarde-rsync.service :

    [Unit]
      Description=Sauvegarde des documents avec rsync
      [Service]
      Type=oneshot
      ExecStart=%h/.local/bin/sauvegarde-rsync
  

Puis ~/.config/systemd/user/sauvegarde-rsync.timer :

    [Unit]
      Description=Lancer la sauvegarde rsync chaque soir
      [Timer]
      OnCalendar=*-*-* 20:00:00
      Persistent=true
      RandomizedDelaySec=10m
      [Install]
      WantedBy=timers.target
  

Rechargez, activez et testez :

    $ systemctl --user daemon-reload
      $ systemctl --user enable --now sauvegarde-rsync.timer
      $ systemctl --user list-timers sauvegarde-rsync.timer
      $ systemctl --user start sauvegarde-rsync.service
      $ systemctl --user status sauvegarde-rsync.service
      $ journalctl --user -u sauvegarde-rsync.service --since today
  

Persistent=true déclenche au prochain démarrage du gestionnaire utilisateur une occurrence manquée pendant son arrêt. Un timer utilisateur n’est pas nécessairement actif tant que l’utilisateur n’a pas de session ; le comportement dépend aussi de l’activation du lingering par l’administrateur. Pour un poste personnel, le rattrapage à la prochaine connexion suffit souvent.

11. Vérifier le résultat et tester une vraie restauration

Une commande terminée n’est pas une preuve suffisante. Vérifiez d’abord son code de sortie. Les plus utiles au quotidien sont :

Après une sauvegarde, une nouvelle simulation doit normalement afficher peu ou pas de changements :

    $ rsync -avni --delete-delay \
      "/home/alice/Documents/" \
      "/mnt/backup-alice/current/"
  

Pour une vérification plus forte du contenu, ajoutez ponctuellement --checksum. Cette option relit les fichiers des deux côtés et peut être lente ; elle ne remplace pas la détection d’un support défaillant.

Le test qui compte : restaurer ailleurs

Choisissez un petit dossier, restaurez-le dans un emplacement temporaire qui n’écrase rien, ouvrez plusieurs fichiers et comparez-en au moins un :

    $ mkdir -p /home/alice/Restauration-test
      $ rsync -avh \
      "/mnt/backup-alice/current/Projet-important/" \
      "/home/alice/Restauration-test/Projet-important/"
      $ cmp \
      "/home/alice/Documents/Projet-important/rapport.pdf" \
      "/home/alice/Restauration-test/Projet-important/rapport.pdf"
      $ echo $?
      0
  

Un code 0 de cmp signifie que les deux fichiers comparés sont identiques octet par octet. Faites ce test après la mise en place, puis régulièrement et après tout changement du script.

12. Conserver plusieurs états sans multiplier tout l’espace

Une approche rsync raisonnable consiste à créer un dossier daté et à réutiliser les fichiers inchangés de l’état précédent avec des liens physiques grâce à --link-dest. Chaque dossier ressemble à une sauvegarde complète, mais les fichiers identiques partagent les mêmes données sur le disque.

    $ BACKUP_ROOT="/mnt/backup-alice/snapshots"
      $ STAMP="$(date +%F_%H-%M-%S)"
      $ mkdir -p "$BACKUP_ROOT/$STAMP"
      $ rsync -a --delete-delay \
      --link-dest="../latest" \
      "/home/alice/Documents/" \
      "$BACKUP_ROOT/$STAMP/"
      $ ln -sfn "$STAMP" "$BACKUP_ROOT/latest"
  

N’actualisez le lien latest que si rsync a renvoyé 0. Les snapshots et leur référence doivent être sur le même système de fichiers. Un fichier modifié reçoit sa propre copie ; ne modifiez jamais un ancien snapshot en place.

13. Trucs et astuces

• Affichez précisément les changements : --itemize-changes est plus parlant qu’une longue sortie verbeuse.
• Testez une source minuscule : dix fichiers factices suffisent pour comprendre slash, exclusions et suppressions.
• Évitez les mots de passe dans les scripts : utilisez une clé SSH dédiée et des droits 600 sur la clé privée.
• Surveillez l’espace : df -h contrôle le système de fichiers ; du -sh CHEMIN mesure une arborescence.
• Conservez les journaux : configurez leur rotation avec logrotate ou appuyez-vous sur le journal systemd.
• Limitez la bande passante au besoin : par exemple --bwlimit=10M pour environ 10 Mio/s selon la syntaxe acceptée par votre version.
• Ne montez pas tout avec sudo : sauvegarder en utilisateur réduit les dégâts possibles. N’employez root que si vous devez réellement préserver l’ensemble du système.

Conclusion : automatiser seulement ce que l’on sait restaurer

La bonne progression est volontairement lente : une copie locale sans suppression, un --dry-run lisible, une première exécution contrôlée, puis des sentinelles, des journaux et enfin une planification. SSH étend la même logique à une autre machine. --delete ne devient acceptable qu’avec des limites et plusieurs états conservés.

Le meilleur indicateur de réussite n’est pas « le timer est vert », mais « j’ai restauré un dossier dans un emplacement neuf et vérifié son contenu ». Une sauvegarde que personne n’a essayé de restaurer reste une hypothèse.