FR

Linux et réseau

Sauvegarde incrémentale avec rsync et cron

Sauvegardez un serveur Linux vers un autre avec rsync et cron : clé SSH dédiée et restreinte, snapshots par liens physiques, rotation et test de restauration.

8 min de lecture, mis à jour le 18 novembre 2026

Sur cette page

Ce guide vous explique comment sauvegarder chaque nuit un serveur vers un second serveur avec rsync et cron. Chaque sauvegarde apparaît comme une copie complète et datée, mais les fichiers inchangés ne sont pas stockés une nouvelle fois : ils sont reliés à la sauvegarde précédente par des liens physiques.

Le serveur sauvegardé utilise une clé SSH dédiée, limitée à l'écriture dans un seul dossier. Même si ce serveur est compromis, cette clé ne permet ni d'ouvrir un shell sur le serveur de sauvegarde, ni de relire ou de supprimer les anciennes sauvegardes par rsync.

Prérequis

  • Deux serveurs sous Debian 12 ou 13, ou Ubuntu 22.04 ou 24.04, avec un accès sudo
  • Le serveur source, à sauvegarder, nommé web01 dans ce guide
  • Le serveur de sauvegarde, avec assez d'espace disque, idéalement dans un autre lieu
  • Un système de fichiers acceptant les attributs étendus sur le serveur de sauvegarde, comme ext4 ou XFS

Remplacez IP_SERVEUR_SAUVEGARDE et IP_SERVEUR_SOURCE par les adresses de vos serveurs.

Port à ouvrir

Seul le serveur de sauvegarde reçoit une connexion : le port 22/tcp, ou votre port SSH, doit être joignable depuis l'adresse du serveur source. Avec UFW, sur le serveur de sauvegarde :

Terminal
sudo ufw allow from IP_SERVEUR_SOURCE to any port 22 proto tcp

Conservez la règle qui vous permet à vous-même d'administrer ce serveur. Notre guide Sécuriser son serveur détaille la configuration de SSH.

Préparer le serveur de sauvegarde

  1. Installez les paquets. python3 est nécessaire au script rrsync, fourni avec rsync :

    Terminal
    sudo apt update
    sudo apt install -y rsync python3 cron
  2. Créez un compte dédié, sans mot de passe utilisable, et le dossier de destination :

    Terminal
    sudo useradd --create-home --home-dir /srv/rsyncbackup --shell /bin/sh rsyncbackup
    sudo install -d -o rsyncbackup -g rsyncbackup -m 700 /srv/rsyncbackup/.ssh /srv/rsyncbackup/web01

Préparer le serveur source

  1. Installez les paquets :

    Terminal
    sudo apt update
    sudo apt install -y rsync cron openssh-client
  2. Créez une clé réservée à la sauvegarde. Elle n'a pas de phrase secrète, car cron doit pouvoir l'utiliser seul : c'est pourquoi elle sera fortement restreinte à l'étape suivante.

    Terminal
    sudo install -d -m 700 /root/.ssh
    sudo ssh-keygen -t ed25519 -N '' -C 'backup-rsync@web01' -f /root/.ssh/backup_rsync
    sudo cat /root/.ssh/backup_rsync.pub

Restreindre la clé sur le serveur de sauvegarde

  1. Ouvrez le fichier des clés autorisées :

    Terminal
    sudo nano /srv/rsyncbackup/.ssh/authorized_keys
  2. Ajoutez une seule ligne, avec votre clé publique à la fin :

    Texte
    from="IP_SERVEUR_SOURCE",restrict,command="/usr/bin/rrsync -wo -no-del /srv/rsyncbackup/web01" ssh-ed25519 AAAA...votre_cle_publique backup-rsync@web01
    Élément Rôle
    from= Accepte cette clé depuis le serveur source uniquement
    restrict Désactive le terminal et les redirections SSH
    command= Impose rrsync à la place de toute autre commande
    -wo Autorise l'écriture seule, sans relecture
    -no-del Refuse les options de suppression de rsync
  3. Appliquez les droits :

    Terminal
    sudo chown rsyncbackup:rsyncbackup /srv/rsyncbackup/.ssh/authorized_keys
    sudo chmod 600 /srv/rsyncbackup/.ssh/authorized_keys
  4. Affichez l'empreinte du serveur pour la comparer à l'étape suivante :

    Terminal
    sudo ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub

Vérifier la connexion

Sur le serveur source, enregistrez la clé du serveur de sauvegarde, puis comparez son empreinte avec la précédente :

Terminal
ssh-keyscan -t ed25519 IP_SERVEUR_SAUVEGARDE | sudo tee -a /root/.ssh/known_hosts
sudo ssh-keygen -lf /root/.ssh/known_hosts

Si les empreintes diffèrent, supprimez la ligne ajoutée et cherchez la cause avant de continuer. Testez ensuite la clé :

Terminal
sudo ssh -i /root/.ssh/backup_rsync -o IdentitiesOnly=yes rsyncbackup@IP_SERVEUR_SAUVEGARDE

La réponse attendue est une erreur de rrsync contenant Not invoked via sshd. Elle prouve que la clé est acceptée et qu'elle ne donne pas de shell.

Créer le script de sauvegarde

Sur le serveur source :

  1. Créez la liste des exclusions :

    Terminal
    sudo nano /etc/backup-rsync.exclude
    Texte
    /root/.ssh/backup_rsync*
    /root/.ssh/restore_rsync*
    /root/.cache/
    /home/*/.cache/
    /var/www/*/cache/
    *.tmp
  2. Créez le script, en renseignant l'adresse du serveur de sauvegarde et les dossiers à copier :

    Terminal
    sudo nano /usr/local/sbin/backup-rsync.sh
    Terminal
    #!/bin/bash
    set -uo pipefail
    
    BACKUP_HOST="IP_SERVEUR_SAUVEGARDE"
    BACKUP_USER="rsyncbackup"
    SSH_PORT=22
    SSH_KEY="/root/.ssh/backup_rsync"
    SOURCES=(/etc /home /root /var/www /var/backups)
    EXCLUDES="/etc/backup-rsync.exclude"
    STATE_DIR="/var/lib/backup-rsync"
    SNAPSHOT="$(date +%Y-%m-%d_%H%M%S)"
    
    exec 9>/run/lock/backup-rsync.lock
    if ! flock -n 9; then
      echo "$(date -Is) backup already running"
      exit 0
    fi
    
    mkdir -p "$STATE_DIR"
    EXISTING=()
    for path in "${SOURCES[@]}"; do
      [ -e "$path" ] && EXISTING+=("$path")
    done
    
    SSH_CMD="ssh -i $SSH_KEY -p $SSH_PORT -o BatchMode=yes -o IdentitiesOnly=yes -o StrictHostKeyChecking=yes -o ConnectTimeout=20"
    OPTIONS=(-aHAX --numeric-ids --relative --timeout=600 --stats
      --exclude-from="$EXCLUDES" -M--fake-super -e "$SSH_CMD")
    
    if [ -s "$STATE_DIR/last" ]; then
      OPTIONS+=("--link-dest=/$(cat "$STATE_DIR/last")")
    fi
    
    echo "$(date -Is) starting $SNAPSHOT"
    rsync "${OPTIONS[@]}" "${EXISTING[@]}" "$BACKUP_USER@$BACKUP_HOST:$SNAPSHOT/"
    status=$?
    
    # Le code 24 signale des fichiers disparus pendant la copie.
    if [ "$status" -ne 0 ] && [ "$status" -ne 24 ]; then
      echo "$(date -Is) failed with rsync code $status"
      exit "$status"
    fi
    
    MARKER="$(mktemp)"
    rsync -e "$SSH_CMD" "$MARKER" "$BACKUP_USER@$BACKUP_HOST:$SNAPSHOT/.backup-complete"
    status=$?
    rm -f "$MARKER"
    if [ "$status" -ne 0 ]; then
      echo "$(date -Is) could not write completion marker, rsync code $status"
      exit "$status"
    fi
    
    echo "$SNAPSHOT" > "$STATE_DIR/last"
    echo "$(date -Is) finished $SNAPSHOT"
  3. Rendez-le exécutable et lancez la première sauvegarde. Elle copie tout et peut être longue :

    Terminal
    sudo chmod 700 /usr/local/sbin/backup-rsync.sh
    sudo /usr/local/sbin/backup-rsync.sh
  4. Attendez une minute, puis relancez-le pour créer un second snapshot :

    Terminal
    sudo /usr/local/sbin/backup-rsync.sh
Option Rôle
-a Conserve l'arborescence, les dates, les droits et les liens symboliques
-H, -A, -X Conservent les liens physiques, les ACL et les attributs étendus
--numeric-ids Conserve les identifiants numériques d'utilisateur et de groupe
--relative Reproduit les chemins complets dans le snapshot
--link-dest Relie les fichiers inchangés au snapshot précédent
-M--fake-super Enregistre propriétaires et droits dans des attributs étendus, sans être root à destination

Vérifier les snapshots

Sur le serveur de sauvegarde :

Terminal
sudo ls -la /srv/rsyncbackup/web01
sudo sh -c 'du -sh /srv/rsyncbackup/web01/*'
sudo sh -c 'stat -c "%h %n" /srv/rsyncbackup/web01/*/etc/hostname'

du compte chaque fichier partagé une seule fois : le second snapshot doit donc paraître beaucoup plus petit que le premier. stat doit afficher un nombre de liens d'au moins 2 pour un fichier inchangé. Chaque snapshot terminé contient un fichier .backup-complete.

Planifier avec cron

Sur le serveur source :

  1. Créez la tâche planifiée :

    Terminal
    sudo nano /etc/cron.d/backup-rsync
    Texte
    SHELL=/bin/bash
    PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
    15 3 * * * root /usr/local/sbin/backup-rsync.sh >> /var/log/backup-rsync.log 2>&1

    Ce fichier doit appartenir à root et se terminer par un retour à la ligne.

  2. Limitez la taille du journal :

    Terminal
    sudo nano /etc/logrotate.d/backup-rsync
    Texte
    /var/log/backup-rsync.log {
        weekly
        rotate 8
        compress
        missingok
        notifempty
    }
  3. Vérifiez que cron est actif, puis contrôlez le journal le lendemain :

    Terminal
    sudo systemctl is-active cron
    sudo tail -n 30 /var/log/backup-rsync.log
    sudo cat /var/lib/backup-rsync/last

Supprimer les anciens snapshots

La rotation s'exécute sur le serveur de sauvegarde. Le serveur source n'a donc aucun moyen d'effacer l'historique.

  1. Créez le script :

    Terminal
    sudo nano /usr/local/bin/backup-rsync-prune
    Terminal
    #!/bin/bash
    set -euo pipefail
    
    ROOT="/srv/rsyncbackup/$1"
    KEEP="${2:-14}"
    cd "$ROOT"
    
    mapfile -t COMPLETE < <(find . -mindepth 2 -maxdepth 2 -type f -name .backup-complete -printf '%h\n' | sed 's|^\./||' | sort)
    COUNT="${#COMPLETE[@]}"
    [ "$COUNT" -gt "$KEEP" ] || exit 0
    
    OLDEST_KEPT="${COMPLETE[COUNT-KEEP]}"
    for dir in 20*/; do
      snapshot="${dir%/}"
      if [[ "$snapshot" < "$OLDEST_KEPT" ]]; then
        rm -rf -- "${ROOT:?}/$snapshot"
      fi
    done

    Il garde les 14 derniers snapshots terminés et retire tout ce qui est plus ancien, y compris les snapshots interrompus. Supprimer un snapshot ne retire pas les fichiers encore utilisés par les suivants.

  2. Planifiez-le :

    Terminal
    sudo chmod 755 /usr/local/bin/backup-rsync-prune
    echo '45 5 * * * rsyncbackup /usr/local/bin/backup-rsync-prune web01 14' | sudo tee /etc/cron.d/backup-rsync-prune
  3. Pour être prévenu d'un arrêt des sauvegardes, surveillez ce contrôle, qui échoue si aucun snapshot n'a été terminé depuis 26 heures :

    Terminal
    sudo find /srv/rsyncbackup/web01 -mindepth 2 -maxdepth 2 -name .backup-complete -mmin -1560 | grep -q . && echo "OK" || echo "NO RECENT BACKUP"

Tester la restauration

Faites ce test dès maintenant, puis régulièrement. La clé de sauvegarde ne pouvant pas lire les données, créez une seconde clé, en lecture seule, réservée à la restauration.

  1. Sur le serveur source, créez cette clé :

    Terminal
    sudo ssh-keygen -t ed25519 -N '' -C 'restore-rsync@web01' -f /root/.ssh/restore_rsync
    sudo cat /root/.ssh/restore_rsync.pub
  2. Sur le serveur de sauvegarde, ajoutez cette ligne à /srv/rsyncbackup/.ssh/authorized_keys :

    Texte
    from="IP_SERVEUR_SOURCE",restrict,command="/usr/bin/rrsync -ro /srv/rsyncbackup/web01" ssh-ed25519 AAAA...cle_de_restauration restore-rsync@web01
  3. Sur le serveur source, listez les snapshots :

    Terminal
    BACKUP_HOST="IP_SERVEUR_SAUVEGARDE"
    SSH_RESTORE="ssh -i /root/.ssh/restore_rsync -p 22 -o BatchMode=yes -o IdentitiesOnly=yes"
    sudo rsync --list-only -e "$SSH_RESTORE" "rsyncbackup@$BACKUP_HOST:/"
  4. Restaurez /etc dans un dossier temporaire, depuis le dernier snapshot terminé :

    Terminal
    SNAPSHOT="$(sudo cat /var/lib/backup-rsync/last)"
    sudo mkdir -p /var/tmp/rsync-restore
    sudo rsync -aHAX --numeric-ids -M--fake-super -e "$SSH_RESTORE" "rsyncbackup@$BACKUP_HOST:$SNAPSHOT/etc/" /var/tmp/rsync-restore/etc/
  5. Comparez le contenu, le propriétaire et les droits :

    Terminal
    sudo diff -r /etc /var/tmp/rsync-restore/etc | head -n 20
    sudo stat -c '%U:%G %a %n' /etc/shadow /var/tmp/rsync-restore/etc/shadow

    Seuls les fichiers modifiés depuis la sauvegarde doivent différer, et les deux lignes de stat doivent indiquer le même propriétaire et les mêmes droits.

  6. Effacez la copie de test, qui contient des données sensibles :

    Terminal
    sudo rm -rf /var/tmp/rsync-restore
  7. Si vous n'avez pas de restauration à faire, retirez la ligne de la clé restore-rsync sur le serveur de sauvegarde. Vous l'ajouterez de nouveau au besoin.

Restaurer après un incident

Choisissez dans la liste un snapshot contenant .backup-complete et placez son nom dans SNAPSHOT. Simulez d'abord l'opération avec --dry-run et vérifiez la liste, car elle peut écraser des fichiers :

Terminal
sudo rsync -aHAX --numeric-ids -M--fake-super --dry-run --itemize-changes -e "$SSH_RESTORE" "rsyncbackup@$BACKUP_HOST:$SNAPSHOT/var/www/" /var/www/

Si le résultat vous convient, relancez la commande sans --dry-run. Si le serveur source est perdu, préparez le nouveau serveur, générez une clé de restauration, ajoutez-la sur le serveur de sauvegarde avec la nouvelle adresse dans from=, puis restaurez vos dossiers un par un.

Mettre à jour

rsync est mis à jour avec le système, sur les deux serveurs :

Terminal
sudo apt update
sudo apt upgrade

Après une mise à jour, contrôlez le journal de la sauvegarde suivante. Si vous remplacez le serveur de sauvegarde, sa clé d'hôte change : mettez à jour /root/.ssh/known_hosts sur le serveur source après avoir vérifié la nouvelle empreinte.

En cas de problème

Permission denied (publickey)

Vérifiez sur le serveur de sauvegarde la clé publique, l'adresse dans from= et les droits. Le journal SSH indique souvent la cause :

Terminal
sudo ls -ld /srv/rsyncbackup /srv/rsyncbackup/.ssh
sudo ls -l /srv/rsyncbackup/.ssh/authorized_keys
sudo journalctl -u ssh -n 30 --no-pager

Le dossier personnel ne doit pas être modifiable par le groupe ou les autres utilisateurs.

Host key verification failed.

La clé du serveur de sauvegarde est absente de /root/.ssh/known_hosts ou a changé. Refaites l'étape de vérification, sans désactiver le contrôle.

python3: No such file or directory

rrsync ne peut pas démarrer. Installez python3 sur le serveur de sauvegarde.

rrsync refuse les chemins contenant ... Le chemin de --link-dest doit commencer par /, comme dans le script : il est alors relatif au dossier autorisé.

reading from write-only server is not allowed

Vous tentez de lire avec la clé de sauvegarde. Utilisez la clé de restauration restore_rsync.

Another instance of rrsync is already accessing this directory.

Une sauvegarde est déjà en cours, ou une ancienne connexion n'est pas terminée. Vérifiez avec pgrep -a rsync sur les deux serveurs.

Code 23 : some files/attrs were not transferred

Certains fichiers n'ont pas pu être copiés. Le journal les indique, juste avant ce message. Le script considère ce snapshot comme échoué : corrigez la cause et relancez-le.

Operation not supported (95) sur des attributs

Le système de fichiers du serveur de sauvegarde n'accepte pas les attributs étendus utilisés par --fake-super. Placez les sauvegardes sur un volume ext4 ou XFS.

Code 255 ou 12

La connexion SSH a échoué ou a été coupée. Relancez le test de connexion et vérifiez le réseau, le pare-feu et l'espace disque avec notre guide Vérifier l'espace disque.

Tous les fichiers sont recopiés à chaque passage

Vérifiez /var/lib/backup-rsync/last : il doit contenir le nom d'un snapshot existant. Contrôlez aussi que ce snapshot contient bien les fichiers attendus et que le système de fichiers de destination accepte les liens physiques.

Références