Quelle est la difference entre rsync et cp pour les sauvegardes ?

rsync ne transfere que les fichiers modifies (en utilisant des checksums ou les dates de modification), rendant les sauvegardes suivantes considerablement plus rapides. cp copie tout a chaque fois sans tenir compte des changements, consommant davantage de bande passante, d'E/S disque et de temps.

rsync peut-il reprendre un transfert interrompu ?

Oui, utilisez l'option --partial (ou -P qui combine --partial et --progress). rsync conservera les fichiers partiellement transferes et reprendra la ou il s'est arrete lors de la prochaine execution.

Comment les sauvegardes de type snapshot avec --link-dest economisent-elles de l'espace disque ?

Avec --link-dest, rsync cree des liens physiques vers les fichiers inchanges de la sauvegarde precedente au lieu de les copier a nouveau. Chaque snapshot apparait comme une sauvegarde complete, mais les fichiers inchanges partagent les memes blocs disque, n'utilisant quasiment aucun espace supplementaire.

rsync est-il securise pour les sauvegardes distantes via Internet ?

Oui, lorsque vous utilisez rsync via SSH (la methode par defaut pour les transferts distants), toutes les donnees sont chiffrees en transit. Combinez cela avec l'authentification par cles SSH et des regles de pare-feu pour un pipeline de sauvegarde entierement securise.

Strategies de sauvegarde avec Rsync pour serveurs Linux

La perte de donnees n’est pas une question de si mais de quand. Le materiel tombe en panne, les ransomwares chiffrent et l’erreur humaine efface. La seule protection fiable est une strategie de sauvegarde automatisee et eprouvee. rsync est l’un des outils les plus puissants et flexibles disponibles sous Linux a cet effet — il ne transfere que les differences entre la source et la destination, fonctionne parfaitement via SSH et prend en charge les sauvegardes de type snapshot qui ressemblent a des copies completes tout en ne consommant qu’une fraction de l’espace disque.

Ce guide couvre tout ce dont vous avez besoin pour concevoir, mettre en oeuvre et automatiser une strategie de sauvegarde rsync de niveau production pour vos serveurs Linux.

Qu’est-ce que Rsync ?

Rsync (Remote Sync) est un utilitaire de copie de fichiers rapide et polyvalent pour les systemes Linux et Unix. Ecrit a l’origine par Andrew Tridgell et Paul Mackerras, il utilise un algorithme de transfert delta qui n’envoie que les differences entre les fichiers source et les fichiers existants a la destination. Cela le rend nettement plus efficace que des outils comme cp ou scp pour des sauvegardes recurrentes.

Caracteristiques principales :

Transferts delta — seuls les octets modifies sont envoyes, pas les fichiers entiers
Preservation des metadonnees — permissions, propriete, horodatages, liens symboliques
Integration SSH — transferts chiffres vers des serveurs distants nativement
Support des liens physiques — permet des sauvegardes snapshot economes en espace disque
Filtrage flexible — motifs d’inclusion/exclusion pour un controle granulaire

# Verifier si rsync est installe et sa version
rsync --version

Si rsync n’est pas installe :

# Debian/Ubuntu
sudo apt update && sudo apt install -y rsync

# RHEL/CentOS/Fedora
sudo dnf install -y rsync

Pourquoi Rsync pour les sauvegardes ?

De nombreux outils de sauvegarde existent — tar, cp, scp, Duplicity, Borg, Restic — alors pourquoi choisir rsync ?

Rapidite : Apres la copie initiale complete, les executions suivantes ne transferent que les donnees modifiees. Une sauvegarde de 500 Go ou 2 Go ont change prend quelques secondes, pas des heures.
Simplicite : rsync est une seule commande avec des options bien documentees. Pas de format proprietaire, pas de base de donnees de deduplication susceptible de se corrompre.
Transparence : Les sauvegardes sont des fichiers et repertoires ordinaires. Vous pouvez naviguer, chercher avec grep et restaurer avec les outils Unix standard — aucun utilitaire de restauration special n’est necessaire.
Universalite : rsync est disponible sur chaque distribution Linux, macOS et meme Windows (via WSL ou Cygwin). Il est deja installe sur la plupart des serveurs.
Composabilite : rsync s’integre parfaitement avec cron, les timers systemd, SSH et les scripts shell.

Le compromis est que rsync ne fournit pas nativement le chiffrement au repos, la deduplication entre sauvegardes ni une base de donnees de catalogue. Pour ces fonctionnalites, considerez Borg ou Restic. Mais pour des sauvegardes directes, fiables et transparentes, rsync est difficile a battre.

Prerequis

Avant de mettre en oeuvre les strategies de ce guide, assurez-vous de disposer de :

Deux systemes Linux — un serveur source (production) et une destination de sauvegarde (disque local, NAS ou serveur distant)
rsync installe sur la source et la destination (version 3.1+ recommandee)
Authentification SSH par cles configuree entre la source et la destination pour des transferts automatises sans mot de passe (consultez notre Guide de durcissement SSH)
Espace disque suffisant sur la destination — au minimum 1,5 fois la taille des donnees a sauvegarder
Acces root ou sudo sur les deux machines si vous devez preserver la propriete et les attributs speciaux des fichiers

# Verifier la version de rsync sur les deux machines
rsync --version | head -1

# Verifier que l'authentification SSH par cle fonctionne sans invite de mot de passe
ssh -o BatchMode=yes user@backup-server echo "SSH key auth works"

Syntaxe de base et options de Rsync

La syntaxe generale de rsync est :

rsync [OPTIONS] SOURCE DESTINATION

Comprendre les options les plus importantes est essentiel avant de construire une strategie de sauvegarde :

# Mode archive : preserve les permissions, la propriete, les horodatages, les symlinks, les peripheriques
rsync -a /source/ /destination/

# Archive + detaille + tailles lisibles + progression
rsync -avhP /source/ /destination/

# Execution a blanc -- montre ce qui serait transfere sans rien modifier
rsync -avhn /source/ /destination/

Detail critique : les barres obliques finales comptent. /source/ (avec barre oblique) copie le contenu du repertoire. /source (sans barre oblique) copie le repertoire lui-meme. C’est l’une des erreurs rsync les plus courantes.

# Copie le contenu de /var/www/ dans /backup/www/
rsync -avh /var/www/ /backup/www/

# Copie le repertoire /var/www (comme sous-repertoire) dans /backup/
# Resultat : /backup/www/
rsync -avh /var/www /backup/

Sauvegardes locales

La strategie rsync la plus simple est une sauvegarde locale vers un disque ou une partition separee. Cela protege contre la suppression accidentelle et la corruption du systeme de fichiers (mais pas contre la defaillance materielle de la machine entiere).

# Miroir de /home vers un disque externe monte sur /mnt/backup
rsync -avh --delete /home/ /mnt/backup/home/

L’option --delete est importante : elle supprime les fichiers de la destination qui n’existent plus sur la source, gardant la sauvegarde comme un miroir exact. Sans elle, les fichiers supprimes s’accumulent indefiniment sur la sauvegarde.

# Sauvegarder plusieurs repertoires en une seule commande
rsync -avh --delete \
  /etc/ \
  /var/www/ \
  /home/ \
  /mnt/backup/

# Sauvegarde avec fichier de log pour l'audit
rsync -avh --delete --log-file=/var/log/rsync-backup.log \
  /home/ /mnt/backup/home/

Pour des sauvegardes systeme qui incluent les fichiers de peripheriques et les attributs speciaux :

# Sauvegarde complete du systeme (necessite root)
sudo rsync -aAXvh --delete \
  --exclude={"/dev/*","/proc/*","/sys/*","/tmp/*","/run/*","/mnt/*","/media/*","/lost+found"} \
  / /mnt/backup/system/

Les options -aAX preservent le mode archive (-a), les ACL (-A) et les attributs etendus (-X), qui sont necessaires pour une sauvegarde systeme complete.

Sauvegardes distantes par SSH

Les sauvegardes distantes protegent contre les defaillances materielles locales, les incendies, les vols et autres sinistres physiques. rsync utilise SSH comme transport par defaut pour les transferts distants, fournissant le chiffrement sans configuration supplementaire.

# Sauvegarde de type push : envoyer les donnees locales vers un serveur distant
rsync -avhz -e ssh /var/www/ backupuser@192.168.1.100:/backup/www/

# Sauvegarde de type pull : recuperer les donnees d'un serveur distant en local
rsync -avhz -e ssh backupuser@192.168.1.100:/var/www/ /backup/www/

L’option -z active la compression pendant le transfert, ce qui est benefique sur des liaisons reseau plus lentes. Sur un reseau gigabit local, la compression peut en realite ralentir les choses en raison de la surcharge CPU.

Pour utiliser un port SSH non standard ou une cle specifique :

# Utiliser un port SSH personnalise et un fichier d'identite
rsync -avhz -e "ssh -p 2222 -i /home/backupuser/.ssh/backup_key" \
  /var/www/ backupuser@remote:/backup/www/

Pour les sauvegardes automatisees, la cle SSH ne doit pas avoir de phrase de passe (ou utiliser ssh-agent). Restreignez la cle de sauvegarde sur le serveur distant pour limiter ses capacites :

# Sur le serveur distant, dans ~backupuser/.ssh/authorized_keys :
# Restreindre la cle a rsync uniquement
command="rsync --server --sender -vlogDtprze.iLsfxCIvu . /backup/",no-port-forwarding,no-X11-forwarding,no-agent-forwarding ssh-ed25519 AAAAC3Nz... backup@source

Sauvegardes incrementales avec —link-dest (style snapshot)

C’est la strategie de sauvegarde rsync la plus puissante. Avec --link-dest, vous pouvez creer ce qui semble etre une sauvegarde complete chaque jour, mais seuls les fichiers modifies consomment de l’espace disque supplementaire. Les fichiers inchanges sont lies par des liens physiques a la sauvegarde precedente.

Fonctionnement :

rsync compare chaque fichier source avec le fichier correspondant dans le repertoire --link-dest
Si un fichier n’a pas change, rsync cree un lien physique (zero espace supplementaire)
Si un fichier a change ou est nouveau, rsync le copie normalement
Le resultat est un repertoire qui ressemble et se comporte comme une sauvegarde complete

# Creer une sauvegarde de type snapshot
DATE=$(date +%Y-%m-%d_%H-%M-%S)
DEST="/backup/snapshots/$DATE"
LATEST="/backup/snapshots/latest"

rsync -avh --delete \
  --link-dest="$LATEST" \
  /home/ "$DEST/"

# Mettre a jour le lien symbolique "latest"
rm -f "$LATEST"
ln -s "$DEST" "$LATEST"

L’utilisation de l’espace disque est remarquable. Considerons un jeu de donnees de 100 Go ou 1 % change quotidiennement :

Jour	Taille apparente	Utilisation reelle du disque
Jour 1 (complet)	100 Go	100 Go
Jour 2	100 Go	~1 Go (nouvelles donnees uniquement)
Jour 3	100 Go	~1 Go
30 jours au total	3 000 Go apparents	~129 Go reels

Chaque repertoire de snapshot est entierement navigable avec les outils standard. Vous pouvez faire cd dans la sauvegarde de n’importe quel jour et voir l’etat complet de vos fichiers a ce moment precis.

# Parcourir la sauvegarde d'il y a 5 jours
ls /backup/snapshots/2026-01-17_02-00-00/home/jc/documents/

# Restaurer un fichier specifique d'il y a 3 jours
cp /backup/snapshots/2026-01-19_02-00-00/home/jc/report.pdf /home/jc/report.pdf

# Verifier l'utilisation reelle du disque par snapshot (montre uniquement les donnees uniques)
du -sh /backup/snapshots/*/

Motifs d’exclusion et filtres

Tout ne necessite pas d’etre sauvegarde. Exclure les fichiers temporaires, les caches et les artefacts de compilation economise du temps et de l’espace disque.

# Motifs d'exclusion en ligne
rsync -avh --delete \
  --exclude='*.tmp' \
  --exclude='*.log' \
  --exclude='.cache/' \
  --exclude='node_modules/' \
  --exclude='__pycache__/' \
  /home/ /backup/home/

Pour des regles d’exclusion complexes, utilisez un fichier d’exclusion :

# Creer /etc/rsync-excludes.txt
cat > /etc/rsync-excludes.txt << 'EOF'
# Fichiers temporaires et de cache
*.tmp
*.swp
*.swo
*~
.cache/
.thumbnails/

# Artefacts de compilation
node_modules/
vendor/
__pycache__/
*.pyc
target/
build/
dist/

# Fichiers systeme a ne pas sauvegarder
/proc/
/sys/
/dev/
/run/
/tmp/
/mnt/
/media/
/lost+found/

# Fichiers multimedia volumineux (optionnel)
# *.iso
# *.mp4
EOF

# Utiliser le fichier d'exclusion
rsync -avh --delete --exclude-from=/etc/rsync-excludes.txt \
  /home/ /backup/home/

rsync prend egalement en charge les combinaisons inclusion/exclusion pour un controle plus granulaire :

# Sauvegarder uniquement les fichiers .conf et .sh de /etc
rsync -avh \
  --include='*/' \
  --include='*.conf' \
  --include='*.sh' \
  --exclude='*' \
  /etc/ /backup/etc-configs/

Limitation de bande passante et compression

Lorsque vous sauvegardez via un WAN ou une liaison reseau partagee, vous devez controler la quantite de bande passante consommee par rsync pour eviter d’impacter le trafic de production.

# Limiter la bande passante a 5 Mo/s (la valeur est en Ko/s)
rsync -avhz --bwlimit=5000 -e ssh \
  /var/www/ backupuser@remote:/backup/www/

# Limiter a 10 Mbps (~1250 Ko/s)
rsync -avhz --bwlimit=1250 -e ssh \
  /var/www/ backupuser@remote:/backup/www/

Options de compression :

# Activer la compression de transfert (utile sur les liaisons lentes)
rsync -avhz -e ssh /source/ user@remote:/backup/

# Ignorer la compression pour les fichiers deja compresses
rsync -avh --compress --skip-compress=gz/bz2/zip/7z/jpg/png/mp4/mkv \
  -e ssh /source/ user@remote:/backup/

Pour la compression au niveau SSH (alternative au -z de rsync) :

# Utiliser la compression SSH au lieu de la compression rsync
rsync -avh -e "ssh -C" /source/ user@remote:/backup/

Conseil : N’activez pas simultanement la compression rsync (-z) et la compression SSH (-C). La double compression gaspille des cycles CPU et peut meme augmenter la taille du transfert. Utilisez l’une ou l’autre — le -z de rsync est generalement plus efficace car il compresse par fichier.

Script de sauvegarde automatise avec Cron

Un script de sauvegarde complet doit gerer la journalisation, le signalement d’erreurs, la rotation des snapshots et les notifications par email. Voici un exemple pret pour la production :

#!/usr/bin/env bash
# /usr/local/bin/rsync-backup.sh
# Sauvegarde rsync de type snapshot avec rotation et journalisation

set -euo pipefail

# --- Configuration --------------------------------------------------------
SOURCE="/home/"
BACKUP_ROOT="/backup/snapshots"
REMOTE_USER="backupuser"
REMOTE_HOST="192.168.1.100"
REMOTE_DEST="${REMOTE_USER}@${REMOTE_HOST}:${BACKUP_ROOT}"
SSH_KEY="/root/.ssh/backup_ed25519"
EXCLUDE_FILE="/etc/rsync-excludes.txt"
LOG_DIR="/var/log/rsync-backup"
RETENTION_DAYS=30
BWLIMIT=0  # 0 = illimite, ou definir en Ko/s

# --- Variables derivees ---------------------------------------------------
DATE=$(date +%Y-%m-%d_%H-%M-%S)
DEST="${BACKUP_ROOT}/${DATE}"
LATEST="${BACKUP_ROOT}/latest"
LOG_FILE="${LOG_DIR}/backup-${DATE}.log"
LOCK_FILE="/tmp/rsync-backup.lock"

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

cleanup() {
    rm -f "$LOCK_FILE"
    log "Lock file removed."
}

# --- Verifications prealables ---------------------------------------------
mkdir -p "$LOG_DIR" "$BACKUP_ROOT"

# Empecher les executions concurrentes
if [ -f "$LOCK_FILE" ]; then
    echo "Backup already running (lock file exists). Exiting."
    exit 1
fi
trap cleanup EXIT
touch "$LOCK_FILE"

log "=== Backup started ==="
log "Source: $SOURCE"
log "Destination: $DEST"

# --- Executer rsync -------------------------------------------------------
RSYNC_OPTS=(
    -avh
    --delete
    --numeric-ids
    --log-file="$LOG_FILE"
)

[ -f "$EXCLUDE_FILE" ] && RSYNC_OPTS+=(--exclude-from="$EXCLUDE_FILE")
[ "$BWLIMIT" -gt 0 ] 2>/dev/null && RSYNC_OPTS+=(--bwlimit="$BWLIMIT")
[ -L "$LATEST" ] && RSYNC_OPTS+=(--link-dest="$LATEST")

if rsync "${RSYNC_OPTS[@]}" "$SOURCE" "$DEST/"; then
    log "rsync completed successfully."
else
    RSYNC_EXIT=$?
    log "ERROR: rsync exited with code $RSYNC_EXIT"
    exit $RSYNC_EXIT
fi

# --- Mettre a jour le lien symbolique latest ------------------------------
rm -f "$LATEST"
ln -s "$DEST" "$LATEST"
log "Updated 'latest' symlink to $DEST"

# --- Rotation des anciennes sauvegardes -----------------------------------
log "Removing backups older than $RETENTION_DAYS days..."
find "$BACKUP_ROOT" -maxdepth 1 -type d -name "20*" -mtime +$RETENTION_DAYS -exec rm -rf {} \;
log "Rotation complete."

# --- Rapport d'utilisation du disque --------------------------------------
USAGE=$(du -sh "$BACKUP_ROOT" | cut -f1)
log "Total backup storage used: $USAGE"

log "=== Backup finished ==="

Rendez le script executable et planifiez-le avec cron :

# Rendre executable
sudo chmod +x /usr/local/bin/rsync-backup.sh

# Editer le crontab de root
sudo crontab -e

Ajoutez l’entree cron suivante :

# Executer la sauvegarde chaque jour a 2h00
0 2 * * * /usr/local/bin/rsync-backup.sh >> /var/log/rsync-backup/cron.log 2>&1

# Executer la sauvegarde toutes les 6 heures
0 */6 * * * /usr/local/bin/rsync-backup.sh >> /var/log/rsync-backup/cron.log 2>&1

Vous pouvez egalement utiliser un timer systemd pour une planification plus robuste :

# /etc/systemd/system/rsync-backup.service
[Unit]
Description=Rsync Backup Service
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/rsync-backup.sh
Nice=10
IOSchedulingClass=idle

# /etc/systemd/system/rsync-backup.timer
[Unit]
Description=Run Rsync Backup Daily

[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true
RandomizedDelaySec=300

[Install]
WantedBy=timers.target

# Activer et demarrer le timer
sudo systemctl daemon-reload
sudo systemctl enable --now rsync-backup.timer

# Verifier l'etat du timer
systemctl list-timers rsync-backup.timer

Restauration depuis les sauvegardes

Une sauvegarde n’est utile que si vous pouvez la restaurer. Comme les sauvegardes rsync sont de simples fichiers et repertoires, la restauration est directe.

Restaurer un seul fichier

# Trouver le fichier dans un snapshot specifique
ls -la /backup/snapshots/2026-01-20_02-00-00/home/jc/documents/report.pdf

# Le restaurer
cp /backup/snapshots/2026-01-20_02-00-00/home/jc/documents/report.pdf \
   /home/jc/documents/report.pdf

Restaurer un repertoire entier

# Restaurer un repertoire complet depuis la derniere sauvegarde
rsync -avh /backup/snapshots/latest/var/www/ /var/www/

Restauration complete du systeme

# Restaurer le systeme entier (depuis une cle USB live ou un environnement de secours)
sudo rsync -aAXvh --delete \
  --exclude={"/dev/*","/proc/*","/sys/*","/tmp/*","/run/*","/mnt/*","/media/*","/lost+found"} \
  /mnt/backup/system/ /mnt/target/

Restaurer depuis une sauvegarde distante

# Recuperer les fichiers depuis le serveur de sauvegarde distant
rsync -avhz -e "ssh -i /root/.ssh/backup_ed25519" \
  backupuser@192.168.1.100:/backup/snapshots/latest/var/www/ \
  /var/www/

Important : Effectuez toujours une execution a blanc avec --dry-run (ou -n) avant de restaurer, surtout pour les restaurations systeme completes. Cela vous montre exactement ce qui sera modifie sans rien changer.

# Execution a blanc -- apercu de ce que ferait la restauration
rsync -avhn /backup/snapshots/latest/home/ /home/

Verification de l’integrite des sauvegardes

Les sauvegardes que vous ne verifiez pas sont des sauvegardes auxquelles vous ne pouvez pas faire confiance. Planifiez des verifications d’integrite regulieres.

# Comparer la source et la sauvegarde en utilisant les checksums (ne transfere aucune donnee)
rsync -avnc /home/ /backup/snapshots/latest/home/

# L'option -c force la comparaison par checksum au lieu de taille+horodatage
# -n garantit qu'aucun transfert n'est effectue (execution a blanc)

Si la sortie ne montre aucune difference, la sauvegarde est une copie exacte. Toute divergence est listee avec son chemin.

Pour une verification automatisee, ajoutez une verification a votre script de sauvegarde :

# Verification post-sauvegarde
log "Running integrity verification..."
DIFF_COUNT=$(rsync -anc --delete "$SOURCE" "$DEST/" 2>/dev/null | wc -l)
if [ "$DIFF_COUNT" -le 1 ]; then
    log "Verification PASSED: backup matches source."
else
    log "WARNING: $DIFF_COUNT differences found between source and backup."
fi

Tableau de reference des options Rsync

Option	Description
`-a`	Mode archive : equivalent a `-rlptgoD` (recursif, liens, permissions, horodatages, groupe, proprietaire, peripheriques)
`-v`	Sortie detaillee
`-h`	Tailles de fichiers lisibles
`-z`	Compresser les donnees pendant le transfert
`-P`	Equivalent a `--partial --progress` (reprendre les transferts partiels + afficher la progression)
`-n`	Execution a blanc — montre ce qui serait transfere sans rien modifier
`-c`	Utiliser les checksums au lieu de la date de modification + taille pour determiner les changements
`--delete`	Supprimer les fichiers sur la destination qui n’existent plus sur la source
`--delete-after`	Supprimer apres la fin du transfert (plus sur que `--delete-during`)
`--link-dest=DIR`	Creer des liens physiques vers les fichiers inchanges depuis DIR (pour les sauvegardes snapshot)
`--exclude=MOTIF`	Exclure les fichiers correspondant a MOTIF
`--exclude-from=FICHIER`	Lire les motifs d’exclusion depuis FICHIER
`--include=MOTIF`	Inclure les fichiers correspondant a MOTIF (prime sur l’exclusion)
`--bwlimit=KBPS`	Limiter la bande passante en kilo-octets par seconde
`-e "ssh ..."`	Specifier le shell distant et ses options
`--numeric-ids`	Preserver les UID/GID numeriques (important pour les sauvegardes entre machines)
`--log-file=FICHIER`	Ecrire un journal de transfert detaille dans FICHIER
`--partial`	Conserver les fichiers partiellement transferes pour reprise
`--stats`	Afficher les statistiques de transfert a la fin
`--progress`	Afficher la progression du transfert par fichier
`--backup`	Creer des sauvegardes des fichiers ecrases/supprimes (avec `--backup-dir`)
`--timeout=SECONDES`	Definir le delai d’attente E/S en secondes

Depannage

rsync: connection unexpectedly closed

Cela indique generalement un probleme SSH. Deboguez avec :

# Tester d'abord la connectivite SSH
ssh -v backupuser@remote echo "Connection works"

# Executer rsync avec la sortie de debogage SSH
rsync -avhz -e "ssh -vvv" /source/ user@remote:/backup/

Causes courantes : pare-feu bloquant le port SSH, chemin de cle SSH incorrect, cle SSH avec phrase de passe mais sans ssh-agent en cours d’execution.

Erreurs de permission refusee

# Executer rsync en tant que root pour les sauvegardes systeme completes
sudo rsync -aAXvh /source/ /backup/

# Ou utiliser --no-owner --no-group si la preservation de la propriete n'est pas necessaire
rsync -avh --no-owner --no-group /source/ /backup/

rsync: —link-dest arg does not exist

Assurez-vous que le chemin --link-dest est absolu et accessible :

# Incorrect : chemin relatif
rsync --link-dest=../latest ...

# Correct : chemin absolu
rsync --link-dest=/backup/snapshots/latest ...

La sauvegarde prend trop de temps

# Identifier ce qui est transfere
rsync -avh --progress --stats /source/ /backup/ 2>&1 | tail -20

# Exclure les fichiers volumineux inutiles
rsync -avh --exclude='*.iso' --exclude='*.vmdk' /source/ /backup/

L’espace disque se remplit sur la destination

# Verifier l'utilisation de l'espace par snapshot
du -sh /backup/snapshots/*/

# Supprimer manuellement les anciens snapshots
rm -rf /backup/snapshots/2026-01-01_02-00-00

# Verifier le nombre de liens physiques (un nombre eleve signifie une bonne deduplication)
stat /backup/snapshots/latest/some-file

rsync se bloque ou cale sur les fichiers volumineux

# Definir un delai d'attente pour eviter les blocages indefinis
rsync -avh --timeout=300 --partial /source/ /backup/

Resume

Une strategie de sauvegarde rsync bien concue offre une protection des donnees fiable, econome en espace et transparente pour vos serveurs Linux. Les composants essentiels sont :

Sauvegardes locales pour une recuperation rapide en cas de suppression accidentelle
Sauvegardes distantes par SSH pour la reprise apres sinistre
Sauvegardes incrementales de type snapshot avec --link-dest pour un versionnage econome en espace
Fichiers d’exclusion pour ignorer les caches, fichiers temporaires et artefacts de compilation
Planification automatisee avec cron ou les timers systemd
Verification reguliere pour garantir l’integrite des sauvegardes
Procedures de restauration testees — une sauvegarde que vous n’avez pas testee n’est pas une sauvegarde

Combinez cette strategie de sauvegarde rsync avec le durcissement SSH pour securiser la couche de transport, et suivez la Checklist de securite pour serveurs Linux pour proteger les serveurs eux-memes. Ensemble, ces pratiques forment une base solide pour l’administration des serveurs et la reprise apres sinistre.