rsync : Synchronisation et stratégies de sauvegarde

Prérequis

• Système d'exploitation : Distribution Linux (Debian, Ubuntu, CentOS, RHEL, Fedora, Arch)
• Privilèges : Accès root ou sudo pour l'installation et les sauvegardes système
• Réseau : Accès SSH configuré pour les synchronisations distantes
• Espace disque : Suffisant sur la destination pour stocker les sauvegardes
• Connaissances : Notions de base en ligne de commande Linux et permissions de fichiers

Installation

rsync est généralement préinstallé sur la plupart des distributions Linux. Vérifiez sa présence et installez-le si nécessaire.

Vérification de l'installation

rsync --version

Installation sur Debian / Ubuntu

sudo apt update
sudo apt install -y rsync

Installation sur CentOS / RHEL / Fedora

# CentOS / RHEL
sudo yum install -y rsync

# Fedora
sudo dnf install -y rsync

Installation sur Arch Linux

sudo pacman -S rsync

Syntaxe de base

La syntaxe générale de rsync est la suivante :

rsync [OPTIONS] SOURCE DESTINATION

Options principales

Voici les options les plus utilisées au quotidien :

# -a (archive) : préserve permissions, propriétaire, groupe, timestamps, liens symboliques
# Équivalent à -rlptgoD
rsync -a /source/ /destination/

# -v (verbose) : affiche les fichiers transférés
rsync -av /source/ /destination/

# -z (compress) : compresse les données pendant le transfert
# Utile pour les transferts réseau, inutile en local
rsync -avz /source/ serveur:/destination/

# -P (progress + partial) : affiche la progression et permet la reprise
rsync -avP /source/ /destination/

# --delete : supprime les fichiers de la destination absents de la source
# Crée un miroir exact de la source
rsync -av --delete /source/ /destination/

# --exclude : exclut des fichiers ou répertoires par motif
rsync -av --exclude='*.log' --exclude='.cache/' /source/ /destination/

# --dry-run (-n) : simule l'exécution sans modifier quoi que ce soit
rsync -avn --delete /source/ /destination/

Synchronisation locale

Copie simple de répertoire

Copier un répertoire en préservant tous les attributs :

# Copie du contenu de /home/user/documents vers /backup/documents
rsync -avP /home/user/documents/ /backup/documents/

Création d'un miroir exact

L'option --delete crée une copie miroir en supprimant de la destination les fichiers qui n'existent plus dans la source :

# Miroir exact : la destination sera identique à la source
rsync -av --delete /home/user/projets/ /backup/projets/

# Toujours tester avec --dry-run avant d'utiliser --delete
rsync -avn --delete /home/user/projets/ /backup/projets/

Exclusion de fichiers et répertoires

Utilisez des motifs d'exclusion pour filtrer les fichiers inutiles :

# Exclure par motif
rsync -av \
    --exclude='*.log' \
    --exclude='*.tmp' \
    --exclude='.cache/' \
    --exclude='node_modules/' \
    --exclude='__pycache__/' \
    /home/user/projets/ /backup/projets/

# Utiliser un fichier d'exclusion pour des règles complexes
rsync -av --exclude-from='/etc/rsync-excludes.txt' /source/ /destination/

Exemple de fichier d'exclusion :

# /etc/rsync-excludes.txt
# Fichiers temporaires
*.tmp
*.swp
*.bak
*~

# Caches et logs
.cache/
*.log
/var/log/

# Développement
node_modules/
__pycache__/
.git/
vendor/

# Système
/proc/
/sys/
/dev/
/tmp/
/run/

Synchronisation distante

Transfert via SSH

rsync utilise SSH par défaut pour les transferts distants :

# Pousser des fichiers vers un serveur distant
rsync -avz /home/user/documents/ user@serveur:/backup/documents/

# Récupérer des fichiers depuis un serveur distant
rsync -avz user@serveur:/backup/documents/ /home/user/documents/

# Synchronisation avec progression détaillée
rsync -avzP /home/user/documents/ user@serveur:/backup/documents/

Options SSH personnalisées

Utilisez -e pour spécifier des options SSH :

# Port SSH personnalisé
rsync -avz -e 'ssh -p 2222' /source/ user@serveur:/destination/

# Clé SSH spécifique
rsync -avz -e 'ssh -i /home/user/.ssh/id_backup' /source/ user@serveur:/destination/

# Combinaison port + clé + compression SSH
rsync -avz -e 'ssh -p 2222 -i /home/user/.ssh/id_backup -c aes128-ctr' \
    /source/ user@serveur:/destination/

Limitation de bande passante

Pour éviter de saturer la connexion réseau :

# Limiter à 5 Mo/s (valeur en Ko/s)
rsync -avz --bwlimit=5000 /source/ user@serveur:/destination/

Stratégie de backup incrémental

Principe de --link-dest

L'option --link-dest est la clé des sauvegardes incrémentales efficaces avec rsync. Elle compare chaque fichier avec une sauvegarde de référence : si le fichier n'a pas changé, un lien dur est créé au lieu de copier le fichier.

# Structure des sauvegardes
# /backup/
# ├── 2026-02-10/    (sauvegarde complète)
# ├── 2026-02-11/    (incrémentale, liens durs vers 2026-02-10)
# └── 2026-02-12/    (incrémentale, liens durs vers 2026-02-11)

# Sauvegarde incrémentale avec --link-dest
rsync -av --delete \
    --link-dest=/backup/2026-02-11 \
    /source/ \
    /backup/2026-02-12/

Rotation quotidienne manuelle

# Variables
BACKUP_DIR="/backup/serveur"
DATE=$(date +%Y-%m-%d)
LATEST=$(ls -1d ${BACKUP_DIR}/20* 2>/dev/null | tail -1)

# Créer le répertoire de destination
mkdir -p "${BACKUP_DIR}/${DATE}"

# Sauvegarde incrémentale
if [ -n "$LATEST" ]; then
    rsync -av --delete --link-dest="${LATEST}" /source/ "${BACKUP_DIR}/${DATE}/"
else
    rsync -av --delete /source/ "${BACKUP_DIR}/${DATE}/"
fi

# Créer un lien symbolique vers la dernière sauvegarde
ln -snf "${BACKUP_DIR}/${DATE}" "${BACKUP_DIR}/latest"

Script de sauvegarde automatique

Voici un script complet de sauvegarde avec rotation GFS (Grandfather-Father-Son) : 7 sauvegardes quotidiennes, 4 hebdomadaires et 12 mensuelles.

#!/bin/bash
# =============================================================================
# rsync-backup.sh - Sauvegarde incrémentale avec rotation GFS
# Usage : ./rsync-backup.sh [source] [destination]
# =============================================================================

set -euo pipefail

# --- Configuration ---
SOURCE="${1:-/home}"
BACKUP_BASE="${2:-/backup}"
RETENTION_DAILY=7
RETENTION_WEEKLY=4
RETENTION_MONTHLY=12

LOG_DIR="/var/log/rsync-backup"
LOG_FILE="${LOG_DIR}/backup-$(date +%Y%m%d-%H%M%S).log"
LOCK_FILE="/tmp/rsync-backup.lock"

EXCLUDE_FILE="/etc/rsync-backup-excludes.txt"

# --- Fonctions utilitaires ---
log() {
    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

cleanup() {
    rm -f "$LOCK_FILE"
    log "Verrou supprimé."
}

# --- Vérifications préalables ---
mkdir -p "$LOG_DIR"

# Vérifier qu'une autre instance ne tourne pas
if [ -f "$LOCK_FILE" ]; then
    LOCK_PID=$(cat "$LOCK_FILE" 2>/dev/null)
    if kill -0 "$LOCK_PID" 2>/dev/null; then
        log "ERREUR : Sauvegarde déjà en cours (PID: $LOCK_PID). Abandon."
        exit 1
    else
        log "AVERTISSEMENT : Verrou orphelin détecté. Nettoyage."
        rm -f "$LOCK_FILE"
    fi
fi

echo $$ > "$LOCK_FILE"
trap cleanup EXIT

log "=== Début de la sauvegarde ==="
log "Source : $SOURCE"
log "Destination : $BACKUP_BASE"

# --- Répertoires de rotation ---
DAILY_DIR="${BACKUP_BASE}/daily"
WEEKLY_DIR="${BACKUP_BASE}/weekly"
MONTHLY_DIR="${BACKUP_BASE}/monthly"
mkdir -p "$DAILY_DIR" "$WEEKLY_DIR" "$MONTHLY_DIR"

# --- Sauvegarde incrémentale quotidienne ---
DATE=$(date +%Y-%m-%d)
TODAY_DIR="${DAILY_DIR}/${DATE}"
LATEST=$(ls -1d ${DAILY_DIR}/20* 2>/dev/null | tail -1 || true)

LINKDEST_OPT=""
if [ -n "$LATEST" ] && [ -d "$LATEST" ]; then
    LINKDEST_OPT="--link-dest=${LATEST}"
    log "Référence incrémentale : $LATEST"
else
    log "Aucune sauvegarde précédente. Sauvegarde complète."
fi

EXCLUDE_OPT=""
if [ -f "$EXCLUDE_FILE" ]; then
    EXCLUDE_OPT="--exclude-from=${EXCLUDE_FILE}"
fi

log "Lancement de rsync..."
rsync -a --delete \
    ${LINKDEST_OPT} \
    ${EXCLUDE_OPT} \
    --stats \
    "$SOURCE/" \
    "$TODAY_DIR/" \
    >> "$LOG_FILE" 2>&1

RSYNC_EXIT=$?

if [ $RSYNC_EXIT -eq 0 ]; then
    log "Sauvegarde quotidienne réussie : $TODAY_DIR"
elif [ $RSYNC_EXIT -eq 24 ]; then
    log "AVERTISSEMENT : Certains fichiers ont disparu pendant le transfert (code 24)."
else
    log "ERREUR : rsync a échoué avec le code $RSYNC_EXIT"
    exit $RSYNC_EXIT
fi

# Mettre à jour le lien symbolique latest
ln -snf "$TODAY_DIR" "${BACKUP_BASE}/latest"

# --- Rotation hebdomadaire (dimanche) ---
DOW=$(date +%u)
if [ "$DOW" -eq 7 ]; then
    WEEK_LABEL=$(date +%Y-W%V)
    if [ ! -d "${WEEKLY_DIR}/${WEEK_LABEL}" ]; then
        cp -al "$TODAY_DIR" "${WEEKLY_DIR}/${WEEK_LABEL}"
        log "Sauvegarde hebdomadaire créée : ${WEEK_LABEL}"
    fi
fi

# --- Rotation mensuelle (1er du mois) ---
DOM=$(date +%d)
if [ "$DOM" -eq "01" ]; then
    MONTH_LABEL=$(date +%Y-%m)
    if [ ! -d "${MONTHLY_DIR}/${MONTH_LABEL}" ]; then
        cp -al "$TODAY_DIR" "${MONTHLY_DIR}/${MONTH_LABEL}"
        log "Sauvegarde mensuelle créée : ${MONTH_LABEL}"
    fi
fi

# --- Purge des anciennes sauvegardes ---
log "Purge des sauvegardes expirées..."

# Quotidiennes : garder les N plus récentes
DAILY_COUNT=$(ls -1d ${DAILY_DIR}/20* 2>/dev/null | wc -l)
if [ "$DAILY_COUNT" -gt "$RETENTION_DAILY" ]; then
    ls -1d ${DAILY_DIR}/20* | head -n -${RETENTION_DAILY} | while read OLD_DIR; do
        log "Suppression quotidienne : $(basename $OLD_DIR)"
        rm -rf "$OLD_DIR"
    done
fi

# Hebdomadaires : garder les N plus récentes
WEEKLY_COUNT=$(ls -1d ${WEEKLY_DIR}/20* 2>/dev/null | wc -l || echo 0)
if [ "$WEEKLY_COUNT" -gt "$RETENTION_WEEKLY" ]; then
    ls -1d ${WEEKLY_DIR}/20* | head -n -${RETENTION_WEEKLY} | while read OLD_DIR; do
        log "Suppression hebdomadaire : $(basename $OLD_DIR)"
        rm -rf "$OLD_DIR"
    done
fi

# Mensuelles : garder les N plus récentes
MONTHLY_COUNT=$(ls -1d ${MONTHLY_DIR}/20* 2>/dev/null | wc -l || echo 0)
if [ "$MONTHLY_COUNT" -gt "$RETENTION_MONTHLY" ]; then
    ls -1d ${MONTHLY_DIR}/20* | head -n -${RETENTION_MONTHLY} | while read OLD_DIR; do
        log "Suppression mensuelle : $(basename $OLD_DIR)"
        rm -rf "$OLD_DIR"
    done
fi

# --- Rapport final ---
TOTAL_SIZE=$(du -sh "$BACKUP_BASE" 2>/dev/null | cut -f1)
log "Espace total utilisé : $TOTAL_SIZE"
log "=== Sauvegarde terminée avec succès ==="

Rendez le script exécutable et créez le fichier d'exclusion :

# Rendre exécutable
chmod +x /usr/local/bin/rsync-backup.sh

# Créer le fichier d'exclusion
cat > /etc/rsync-backup-excludes.txt << 'EXCL'
# Fichiers temporaires et caches
*.tmp
*.swp
*~
.cache/
.thumbnails/

# Logs volumineux
*.log

# Développement
node_modules/
__pycache__/
.git/objects/

# Système (si sauvegarde root)
/proc/
/sys/
/dev/
/tmp/
/run/
/mnt/
/media/
EXCL

Sauvegarde avec cron

Configuration de la tâche cron

Automatisez l'exécution du script de sauvegarde avec cron :

# Éditer la crontab de root
sudo crontab -e

# Sauvegarde quotidienne à 2h00 du matin
0 2 * * * /usr/local/bin/rsync-backup.sh /home /backup/home >> /var/log/rsync-backup/cron.log 2>&1

# Sauvegarde de /etc toutes les 6 heures
0 */6 * * * /usr/local/bin/rsync-backup.sh /etc /backup/etc >> /var/log/rsync-backup/cron-etc.log 2>&1

# Sauvegarde vers un serveur distant le dimanche à 3h00
0 3 * * 0 rsync -avz --delete -e 'ssh -i /root/.ssh/id_backup' /backup/ backup@nas:/volume1/backups/serveur/ >> /var/log/rsync-backup/cron-remote.log 2>&1

Rotation des logs

Configurez logrotate pour éviter que les fichiers de log ne saturent le disque :

# /etc/logrotate.d/rsync-backup
/var/log/rsync-backup/*.log {
    weekly
    rotate 8
    compress
    delaycompress
    missingok
    notifempty
    create 640 root root
}

rsync daemon

Le mode daemon permet de servir des fichiers via le protocole rsync natif (port 873), sans SSH. Il est utile pour les transferts internes à un réseau de confiance.

Configuration de rsyncd.conf

# /etc/rsyncd.conf

# Configuration globale
uid = nobody
gid = nogroup
use chroot = yes
max connections = 4
log file = /var/log/rsyncd.log
pid file = /var/run/rsyncd.pid
lock file = /var/run/rsyncd.lock
timeout = 300

# Module de sauvegarde
[backup]
    path = /backup/shared
    comment = Repertoire de sauvegarde partage
    read only = no
    list = yes
    auth users = backup_user
    secrets file = /etc/rsyncd.secrets
    hosts allow = 192.168.1.0/24
    hosts deny = *

# Module public en lecture seule
[public]
    path = /srv/public
    comment = Fichiers publics
    read only = yes
    list = yes

Configuration de l'authentification

# Créer le fichier de secrets (format utilisateur:motdepasse)
echo 'backup_user:MotDePasseSecurise123' | sudo tee /etc/rsyncd.secrets
sudo chmod 600 /etc/rsyncd.secrets

# Démarrer le daemon rsync
sudo systemctl enable rsync
sudo systemctl start rsync

# Vérifier le statut
sudo systemctl status rsync

Utilisation du daemon

# Lister les modules disponibles
rsync rsync://serveur/

# Synchroniser avec le module backup
rsync -avz /source/ rsync://backup_user@serveur/backup/dossier/

# Avec mot de passe en fichier (pour automatisation)
echo 'MotDePasseSecurise123' > ~/.rsync-password
chmod 600 ~/.rsync-password
rsync -avz --password-file=~/.rsync-password /source/ rsync://backup_user@serveur/backup/

Restauration

La restauration est le test ultime de toute stratégie de sauvegarde. Avec rsync, la procédure est simple car les sauvegardes sont des copies directes du système de fichiers.

Restauration complète

# Identifier la sauvegarde à restaurer
ls -la /backup/daily/
ls -la /backup/weekly/
ls -la /backup/monthly/

# Restauration complète depuis la dernière sauvegarde
rsync -avP --delete /backup/latest/ /home/

# Restauration depuis une date spécifique
rsync -avP /backup/daily/2026-02-10/ /home/

Restauration sélective

# Restaurer un fichier unique
rsync -avP /backup/latest/user/documents/rapport.pdf /home/user/documents/

# Restaurer un répertoire spécifique
rsync -avP /backup/latest/user/projets/webapp/ /home/user/projets/webapp/

# Restaurer avec un dry-run préalable
rsync -avPn /backup/daily/2026-02-10/user/ /home/user/
# Si le résultat est correct, relancer sans -n

Restauration depuis un serveur distant

# Restauration complète depuis le NAS
rsync -avzP backup@nas:/volume1/backups/serveur/latest/ /home/

# Restauration d'un fichier unique depuis le distant
rsync -avzP backup@nas:/volume1/backups/serveur/latest/etc/nginx/nginx.conf /etc/nginx/nginx.conf

Monitoring des backups

Script de vérification

#!/bin/bash
# check-backup.sh - Vérification de l'état des sauvegardes

BACKUP_BASE="/backup"
MAX_AGE_HOURS=26
ALERT_EMAIL="admin@example.com"
ERRORS=0

check_backup() {
    local NAME="$1"
    local DIR="$2"
    local MAX_H="$3"

    if [ ! -d "$DIR" ]; then
        echo "CRITIQUE : Répertoire $DIR introuvable pour $NAME"
        ERRORS=$((ERRORS + 1))
        return
    fi

    LATEST=$(ls -1d ${DIR}/20* 2>/dev/null | tail -1)
    if [ -z "$LATEST" ]; then
        echo "CRITIQUE : Aucune sauvegarde trouvée pour $NAME"
        ERRORS=$((ERRORS + 1))
        return
    fi

    # Vérifier l'âge de la dernière sauvegarde
    LAST_MOD=$(stat -c %Y "$LATEST" 2>/dev/null)
    NOW=$(date +%s)
    AGE_H=$(( (NOW - LAST_MOD) / 3600 ))

    if [ "$AGE_H" -gt "$MAX_H" ]; then
        echo "ALERTE : $NAME - dernière sauvegarde il y a ${AGE_H}h (max: ${MAX_H}h)"
        ERRORS=$((ERRORS + 1))
    else
        SIZE=$(du -sh "$LATEST" | cut -f1)
        FILES=$(find "$LATEST" -type f | wc -l)
        echo "OK : $NAME - $(basename $LATEST) - ${SIZE} - ${FILES} fichiers - ${AGE_H}h"
    fi
}

echo "=== Rapport de sauvegarde $(date) ==="
check_backup "Quotidienne" "${BACKUP_BASE}/daily" "$MAX_AGE_HOURS"
check_backup "Hebdomadaire" "${BACKUP_BASE}/weekly" 170
check_backup "Mensuelle" "${BACKUP_BASE}/monthly" 744

# Espace disque
DISK_USAGE=$(df -h "$BACKUP_BASE" | tail -1 | awk '{print $5}')
DISK_PCT=${DISK_USAGE%\%}
if [ "$DISK_PCT" -gt 85 ]; then
    echo "ALERTE : Espace disque backup à ${DISK_USAGE}"
    ERRORS=$((ERRORS + 1))
else
    echo "OK : Espace disque backup à ${DISK_USAGE}"
fi

# Envoi d'alerte si erreurs
if [ "$ERRORS" -gt 0 ]; then
    echo "=== ${ERRORS} problème(s) détecté(s) ==="
    # Décommenter pour activer les alertes par email
    # mail -s "[BACKUP] ${ERRORS} alerte(s)" "$ALERT_EMAIL" < /tmp/backup-report.txt
    exit 1
fi

echo "=== Toutes les sauvegardes sont OK ==="
exit 0

Automatisation du monitoring

# Vérification quotidienne à 8h00
0 8 * * * /usr/local/bin/check-backup.sh >> /var/log/rsync-backup/check.log 2>&1

Sécurisation

Clés SSH dédiées à la sauvegarde

Créez une paire de clés spécifique pour les opérations de sauvegarde :

# Générer une clé dédiée
ssh-keygen -t ed25519 -f /root/.ssh/id_backup -N '' -C 'rsync-backup@serveur'

# Copier la clé publique sur le serveur de destination
ssh-copy-id -i /root/.ssh/id_backup.pub backup@nas

Restriction de commande SSH

Limitez la clé à exécuter uniquement rsync sur le serveur de destination :

# Sur le serveur de destination : ~/.ssh/authorized_keys
command="rsync --server --sender -logDtprze.iLsfxCIvu . /volume1/backups/",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-ed25519 AAAAC3Nza... rsync-backup@serveur

Chroot pour isoler l'accès

# /etc/ssh/sshd_config - Restreindre l'utilisateur backup
Match User backup
    ChrootDirectory /volume1/backups
    ForceCommand internal-sftp
    AllowTcpForwarding no
    X11Forwarding no

Pare-feu et réseau

# Autoriser rsync daemon uniquement depuis le réseau local
sudo ufw allow from 192.168.1.0/24 to any port 873 proto tcp comment 'rsync daemon LAN'

# Autoriser SSH depuis le serveur de backup uniquement
sudo ufw allow from 192.168.1.50 to any port 22 proto tcp comment 'SSH backup server'

Troubleshooting

Erreurs courantes

# Erreur : "rsync: failed to set times on ... Operation not permitted"
# Cause : le système de fichiers de destination ne supporte pas les timestamps
# Solution : ajouter --no-times ou --modify-window=1 pour les FS FAT/NTFS
rsync -av --no-times /source/ /mnt/usb/backup/

# Erreur : "rsync error: some files/attrs were not transferred (code 23)"
# Cause : problèmes de permissions ou fichiers verrouillés
# Solution : exécuter en root ou ajouter --no-perms
sudo rsync -av /source/ /destination/

# Erreur : "rsync: connection unexpectedly closed"
# Cause : timeout SSH, espace disque plein, ou OOM killer
# Solutions :
rsync -avz -e 'ssh -o ServerAliveInterval=60 -o ServerAliveCountMax=3' /source/ user@serveur:/dest/

# Erreur : "rsync error: max connections reached (code 10)"
# Cause : trop de connexions simultanées au daemon
# Solution : augmenter max connections dans rsyncd.conf ou attendre

Optimisation des performances

# Désactiver la compression pour les réseaux rapides (LAN Gigabit)
rsync -av --no-compress /source/ user@serveur:/destination/

# Utiliser un algorithme de checksum plus rapide (rsync 3.2+)
rsync -av --checksum-choice=xxh3 /source/ /destination/

# Transfert parallèle avec xargs (fichiers volumineux)
find /source/ -maxdepth 1 -type d | xargs -P 4 -I {} \
    rsync -av {}/ /destination/{}/

# Exclure les fichiers au-dessus d'une certaine taille
rsync -av --max-size='100M' /source/ /destination/

# Mode inplace pour éviter la copie temporaire (économise espace)
rsync -av --inplace /source/ /destination/

Diagnostic réseau

# Tester la connectivité SSH
ssh -v user@serveur 'echo OK'

# Mesurer le débit rsync
rsync -avP --stats /source/ user@serveur:/destination/ 2>&1 | tail -20

# Vérifier les différences sans transférer
rsync -avni /source/ /destination/ | head -50

Conclusion

rsync est un outil incontournable pour la synchronisation et la sauvegarde de données sous Linux. Grâce à son algorithme de transfert delta et l'option --link-dest, il permet de mettre en place des stratégies de sauvegarde incrémentale efficaces qui consomment peu d'espace disque tout en offrant une restauration rapide à n'importe quel point dans le temps.

• Utilisez rsync -av pour les copies locales simples
• Ajoutez -z et -P pour les transferts réseau
• Exploitez --link-dest pour des sauvegardes incrémentales économes
• Automatisez avec cron et un script de rotation GFS
• Sécurisez avec des clés SSH dédiées et des restrictions de commande
• Surveillez vos sauvegardes et testez régulièrement la restauration