Rsync : guide complet pour la synchronisation et sauvegarde Linux

Dans l'univers des systèmes Unix et Linux, rsync occupe une place à part : conçu en 1996 par Andrew Tridgell et Paul Mackerras, cet outil de synchronisation de fichiers reste en 2026 l'un des plus utilisés dans les scripts de sauvegarde et d'administration système. Sa popularité durable tient à un algorithme de transfert différentiel remarquablement efficace — l'algorithme delta de rsync — qui ne transfère que les blocs de données modifiés entre la source et la destination, réduisant drastiquement la bande passante et le temps de transfert par rapport à une copie traditionnelle. Que vous soyez administrateur système cherchant à automatiser les sauvegardes de serveurs Linux, développeur voulant synchroniser des environnements de développement, ou ingénieur DevOps gérant des déploiements, maîtriser rsync est une compétence fondamentale. Ce guide expert couvre toutes les facettes de rsync : l'algorithme de fonctionnement, la syntaxe de base, la synchronisation locale et distante via SSH, la sauvegarde incrémentale avec hard links pour l'économie d'espace disque, la gestion des exclusions, l'automatisation avec cron, un script de rotation complet sur 7 jours et 4 semaines, et une comparaison avec les alternatives modernes comme Restic et BorgBackup.

Fonctionnement de rsync (algorithme delta, SSH tunnel)

La force de rsync réside dans son algorithme de synchronisation delta, conçu pour minimiser les données transférées sur le réseau ou lues sur le disque.

L'algorithme delta de rsync

Lorsque rsync synchronise un fichier qui existe déjà à la destination, il procède en plusieurs étapes. Premièrement, le processus récepteur (destination) découpe le fichier existant en blocs de taille fixe et calcule deux sommes de contrôle pour chaque bloc : une somme de contrôle rapide (basée sur l'algorithme rolling checksum d'Adler) et une somme MD4 plus robuste. Ces signatures sont envoyées à l'expéditeur. Deuxièmement, l'expéditeur (source) analyse le fichier source en cherchant des correspondances avec les signatures reçues, en utilisant une fenêtre glissante. Troisièmement, seules les portions non correspondantes (les deltas) sont transmises, accompagnées des instructions pour reconstruire le fichier complet côté destination.

Concrètement, si un fichier de 100 Mo n'a été modifié qu'à 2%, rsync ne transférera que 2 Mo de delta plutôt que 100 Mo complets. Pour des synchronisations régulières de bases de données, images de machines virtuelles ou archives volumineuses, l'économie de bande passante est considérable.

Tunnel SSH

Pour la synchronisation distante sécurisée, rsync encapsule le transfert dans un tunnel SSH. Rsync démarre un processus rsync sur le serveur distant via SSH, et les données transitent chiffrées dans ce canal. Cela offre plusieurs avantages : chiffrement des données en transit, authentification par clés SSH (sans mot de passe interactif), compression optionnelle du flux SSH, et pas de port supplémentaire à ouvrir (seul le port SSH 22 est nécessaire).

Syntaxe de base et options essentielles (-a, -v, -z, --delete, --dry-run)

La syntaxe générale de rsync est :

rsync [OPTIONS] SOURCE DESTINATION

Le slash final sur les chemins source a une importance capitale : rsync /source/ (avec slash) synchronise le contenu du dossier, tandis que rsync /source (sans slash) synchronise le dossier lui-même.

Options essentielles

L'option -a (archive) est un raccourci pour -rlptgoD : elle active la récursivité (-r), préserve les liens symboliques (-l), les permissions (-p), les timestamps (-t), le propriétaire (-o), le groupe (-g) et les fichiers spéciaux (-D). C'est l'option de base pour toute synchronisation qui doit préserver fidèlement les métadonnées.

L'option -v (verbose) affiche les fichiers transférés. Combiner avec -h (human-readable) pour afficher les tailles en Ko/Mo/Go lisibles. L'option --progress affiche la progression de chaque fichier en temps réel.

L'option -z active la compression des données pendant le transfert. Utile sur les liaisons réseau lentes ou distantes. Inutile (voire contre-productif) sur les réseaux locaux rapides car la compression CPU peut dépasser le gain réseau.

L'option --delete supprime à la destination les fichiers qui n'existent plus à la source. Indispensable pour une synchronisation miroir, mais à utiliser avec prudence car elle peut supprimer des fichiers de manière irréversible.

L'option --dry-run (ou -n) simule le transfert sans effectuer aucune modification réelle. Toujours tester avec --dry-run avant d'exécuter une commande rsync destructive.

# Exemples d'options combinées

# Synchronisation complète avec affichage lisible
rsync -avh /source/ /destination/

# Synchronisation miroir (supprime les fichiers absents de la source)
rsync -avh --delete /source/ /destination/

# Simulation préalable
rsync -avhn --delete /source/ /destination/

# Avec compression et statistiques
rsync -avzhP --stats /source/ user@serveur:/destination/

Synchronisation locale (dossiers, partitions)

rsync excelle pour la synchronisation entre dossiers locaux ou partitions, offrant des performances souvent supérieures à cp -r pour les synchronisations répétées.

# Synchronisation simple entre deux dossiers locaux
rsync -avh /home/utilisateur/Documents/ /mnt/backup/Documents/

# Synchronisation d'une partition complète (ex: disque externe)
rsync -avhx --delete / /mnt/disque-externe/
# L'option -x (ou --one-file-system) empêche rsync de traverser les montages

# Synchronisation avec exclusion des fichiers système virtuels
rsync -avhx --delete \
  --exclude=/proc \
  --exclude=/sys \
  --exclude=/dev \
  --exclude=/run \
  --exclude=/tmp \
  / /mnt/backup-systeme/

# Vérification de l'intégrité après synchronisation
rsync -avhc /source/ /destination/
# L'option -c (checksum) vérifie chaque fichier par somme de contrôle
# (plus lent mais garantit l'intégrité absolue)

Synchronisation distante via SSH (rsync user@host:/path)

La synchronisation distante via SSH est l'un des cas d'usage les plus courants de rsync en entreprise.

# Syntaxe de base pour la synchronisation distante
rsync -avzh /local/source/ user@serveur-distant:/chemin/destination/

# Dans l'autre sens (télécharger depuis le serveur distant)
rsync -avzh user@serveur-distant:/chemin/source/ /local/destination/

# Spécifier un port SSH non standard
rsync -avzh -e "ssh -p 2222" /source/ user@serveur:/destination/

# Utiliser une clé SSH spécifique
rsync -avzh -e "ssh -i /home/user/.ssh/cle_backup" /source/ user@serveur:/destination/

# Synchronisation avec suppression et bande passante limitée
rsync -avzh --delete --bwlimit=10000 /source/ user@serveur:/destination/
# --bwlimit en Ko/s (10000 = 10 Mo/s)

# Reprendre un transfert interrompu
rsync -avzh --partial --partial-dir=.rsync-partial /source/ user@serveur:/destination/
# --partial conserve les fichiers partiellement transférés

Authentification sans mot de passe avec clés SSH

Pour l'automatisation (cron), l'authentification par mot de passe est impraticable. Configurer l'authentification par clé SSH :

# Générer une paire de clés dédiée aux sauvegardes
ssh-keygen -t ed25519 -f /root/.ssh/id_backup -N "" -C "rsync-backup-$(hostname)"

# Copier la clé publique sur le serveur distant
ssh-copy-id -i /root/.ssh/id_backup.pub user@serveur-distant

# Tester la connexion sans mot de passe
ssh -i /root/.ssh/id_backup user@serveur-distant "echo Connexion OK"

# Utiliser dans rsync
rsync -avzh -e "ssh -i /root/.ssh/id_backup" /source/ user@serveur-distant:/destination/

Sauvegarde incrémentale avec hard links (--link-dest) — économie espace disque

La technique de sauvegarde incrémentale par hard links est l'une des fonctionnalités les plus puissantes et méconnues de rsync. Elle permet de conserver plusieurs snapshots complets d'un système en n'utilisant que l'espace des données modifiées.

Principe des hard links

Un hard link est un second nom de fichier pointant vers les mêmes données sur le disque. Quand rsync utilise --link-dest, il compare la nouvelle sauvegarde avec la précédente et crée des hard links vers les fichiers inchangés plutôt que de les copier. Résultat : chaque snapshot ressemble à une copie complète (tous les fichiers sont présents), mais l'espace disque n'est consommé que pour les fichiers effectivement modifiés ou nouveaux.

# Principe de la sauvegarde incrémentale avec hard links
# Structure cible :
# /backup/
#   2026-06-01/  → snapshot complet du 1er juin (copie réelle)
#   2026-06-02/  → snapshot "complet" du 2 juin (hard links vers 01/ pour les fichiers inchangés)
#   2026-06-03/  → snapshot "complet" du 3 juin (hard links vers 02/ pour les fichiers inchangés)

# Commande de sauvegarde incrémentale
TODAY=$(date +%Y-%m-%d)
YESTERDAY=$(date -d "yesterday" +%Y-%m-%d)
BACKUP_ROOT=/backup

rsync -avh --delete \
  --link-dest="${BACKUP_ROOT}/${YESTERDAY}" \
  /source/ \
  "${BACKUP_ROOT}/${TODAY}/"

# Espace utilisé par chaque snapshot (approximatif)
du -sh /backup/2026-06-01/   # Espace réel complet (~10 Go)
du -sh /backup/2026-06-02/   # Affiche aussi ~10 Go mais n'utilise que les deltas (~50 Mo)
du -sh /backup/               # Espace total réel utilisé (~10.5 Go pour 2 jours)

Exclure des fichiers et dossiers (--exclude, --exclude-from)

# Exclure des fichiers ou dossiers spécifiques
rsync -avh --exclude='*.log' --exclude='*.tmp' --exclude='.cache/' /source/ /destination/

# Exclure un dossier et son contenu
rsync -avh --exclude='/proc/' --exclude='/sys/' --exclude='/tmp/' / /backup/

# Utiliser un fichier d'exclusions (un motif par ligne)
cat > /etc/rsync-exclude.txt << 'EOF'
*.log
*.tmp
*.swp
.cache/
.thumbnails/
node_modules/
__pycache__/
.git/
Thumbs.db
.DS_Store
EOF

rsync -avh --exclude-from='/etc/rsync-exclude.txt' /source/ /destination/

# Combiner exclude-from et excludes inline
rsync -avh --exclude-from='/etc/rsync-exclude.txt' --exclude='*.bak' /source/ /destination/

# Inclure des fichiers dans un dossier exclu (ordre important : include avant exclude)
rsync -avh \
  --include='logs/' \
  --include='logs/error.log' \
  --exclude='logs/*' \
  /source/ /destination/

Automatiser avec cron (sauvegarde quotidienne, hebdomadaire)

# Crontab pour des sauvegardes automatiques

# Sauvegarde quotidienne à 2h du matin
0 2 * * * root /usr/local/bin/rsync-backup-daily.sh >> /var/log/rsync-backup.log 2>&1

# Sauvegarde hebdomadaire le dimanche à 3h
0 3 * * 0 root /usr/local/bin/rsync-backup-weekly.sh >> /var/log/rsync-backup-weekly.log 2>&1

# Synchronisation continue toutes les heures (pour les fichiers critiques)
0 * * * * root rsync -avzh --delete /data/critique/ backup@nas:/backup/critique/ >> /var/log/rsync-hourly.log 2>&1

Script de sauvegarde complet avec rotation (7 jours, 4 semaines)

#!/bin/bash
# Script de sauvegarde rsync avec rotation 7 jours / 4 semaines
# /usr/local/bin/rsync-backup.sh

set -euo pipefail

# Configuration
SOURCE="/var/www"
BACKUP_ROOT="/mnt/backup"
REMOTE_USER="backup"
REMOTE_HOST="nas.monentreprise.fr"
REMOTE_PATH="/backups/serveur-web"
SSH_KEY="/root/.ssh/id_backup"
EXCLUDE_FILE="/etc/rsync-exclude.txt"
LOG_FILE="/var/log/rsync-backup.log"
KEEP_DAILY=7
KEEP_WEEKLY=4

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

# Dates
TODAY=$(date +%Y-%m-%d)
DAY_OF_WEEK=$(date +%u)  # 1=lundi, 7=dimanche
YESTERDAY=$(date -d "yesterday" +%Y-%m-%d)

log "=== Début sauvegarde $TODAY ==="

# Dossier de destination
DEST="${REMOTE_USER}@${REMOTE_HOST}:${REMOTE_PATH}"

# Sauvegarde incrémentale avec hard links vers la veille
if ssh -i "$SSH_KEY" "${REMOTE_USER}@${REMOTE_HOST}" "test -d ${REMOTE_PATH}/daily/${YESTERDAY}"; then
    LINK_DEST="--link-dest=${REMOTE_PATH}/daily/${YESTERDAY}"
else
    LINK_DEST=""
    log "Pas de sauvegarde de référence trouvée - sauvegarde complète"
fi

rsync -avzh --delete \
    --exclude-from="$EXCLUDE_FILE" \
    $LINK_DEST \
    -e "ssh -i $SSH_KEY -o StrictHostKeyChecking=no" \
    "$SOURCE/" \
    "${DEST}/daily/${TODAY}/" \
    || notify_error "rsync échoué"

log "Sauvegarde quotidienne terminée : ${REMOTE_PATH}/daily/${TODAY}"

# Sauvegarde hebdomadaire le dimanche
if [ "$DAY_OF_WEEK" -eq 7 ]; then
    WEEK=$(date +%Y-W%V)
    ssh -i "$SSH_KEY" "${REMOTE_USER}@${REMOTE_HOST}" \
        "cp -al ${REMOTE_PATH}/daily/${TODAY} ${REMOTE_PATH}/weekly/${WEEK}" \
        || notify_error "Sauvegarde hebdomadaire échouée"
    log "Sauvegarde hebdomadaire créée : ${REMOTE_PATH}/weekly/${WEEK}"
fi

# Rotation des sauvegardes quotidiennes (garder 7 jours)
ssh -i "$SSH_KEY" "${REMOTE_USER}@${REMOTE_HOST}" "
    ls -dt ${REMOTE_PATH}/daily/*/ 2>/dev/null | tail -n +$((KEEP_DAILY + 1)) | xargs rm -rf
    ls -dt ${REMOTE_PATH}/weekly/*/ 2>/dev/null | tail -n +$((KEEP_WEEKLY + 1)) | xargs rm -rf
" || log "AVERTISSEMENT: Rotation partielle"

log "Rotation terminée. Sauvegardes conservées: ${KEEP_DAILY} jours, ${KEEP_WEEKLY} semaines"
log "=== Fin sauvegarde ==="

# Rendre le script exécutable et configurer cron
chmod +x /usr/local/bin/rsync-backup.sh
echo "0 2 * * * root /usr/local/bin/rsync-backup.sh" > /etc/cron.d/rsync-backup

Rsync Daemon — serveur rsync natif pour les transferts à haut débit

Au-delà de son utilisation via SSH, rsync peut fonctionner en mode daemon, exposant directement un service rsync sur le réseau (port 873 TCP). Ce mode est particulièrement adapté aux transferts intra-datacenter ou aux réseaux locaux sécurisés où le surcoût du chiffrement SSH n'est pas nécessaire, offrant des performances significativement supérieures pour les transferts à haut débit.

Configurer rsyncd (daemon rsync)

# Fichier de configuration /etc/rsyncd.conf
[global]
uid = backup
gid = backup
use chroot = yes
max connections = 10
log file = /var/log/rsyncd.log
pid file = /var/run/rsyncd.pid

[backups]
path = /srv/backups
comment = Dépôt de sauvegardes
read only = false
list = yes
auth users = rsync-client
secrets file = /etc/rsyncd.secrets
hosts allow = 192.168.10.0/24
hosts deny = *

[public-mirror]
path = /srv/mirror
comment = Miroir public
read only = yes
list = yes

# Fichier de mots de passe /etc/rsyncd.secrets
rsync-client:motdepasse_securise

chmod 600 /etc/rsyncd.secrets

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

# Utilisation depuis un client
rsync -avh rsync://rsync-client@serveur/backups/ /destination/
# ou avec le module
rsync -avh --password-file=/etc/rsync.password /source/ rsync-client@serveur::backups

Performances rsync daemon vs SSH

En mode daemon, rsync peut atteindre des débits nettement supérieurs au mode SSH car il n'y a pas de surcoût de chiffrement. Sur un réseau 10 Gbps intra-datacenter, rsync daemon peut atteindre 800-900 Mo/s contre 200-400 Mo/s en mode SSH (en fonction du CPU pour le chiffrement). Combiner rsync daemon avec l'option --compress (-z) offre un bon compromis performances/ressources réseau pour les liaisons de quelques centaines de Mbps.

Sécurisation du daemon rsync

Sans SSH, la sécurisation du daemon rsync repose sur plusieurs mécanismes : restriction d'accès par IP source (directive hosts allow), authentification par fichier de secrets, isolation chroot, et limitation du nombre de connexions simultanées. Pour les environnements sensibles, le daemon rsync ne devrait jamais être exposé directement sur Internet — le passage par SSH reste la seule option recommandée pour les synchronisations via des réseaux non maîtrisés.

Surveiller et alerter sur les sauvegardes rsync

Une sauvegarde non vérifiée est une sauvegarde qui n'existe pas. La mise en place d'un système de monitoring des sauvegardes rsync est aussi importante que la sauvegarde elle-même.

Vérifier le succès des sauvegardes

#!/bin/bash
# Script de vérification des sauvegardes rsync
# /usr/local/bin/check-backup.sh

BACKUP_PATH="/backup/$(date +%Y-%m-%d)"
MIN_SIZE_GB=5  # Taille minimale attendue en Go
ALERT_EMAIL="[email protected]"
MAX_AGE_HOURS=25  # Alerte si la sauvegarde a plus de 25h

# Vérifier l'existence du dossier de sauvegarde du jour
if [ ! -d "$BACKUP_PATH" ]; then
    echo "CRITIQUE: Sauvegarde du jour absente: $BACKUP_PATH" | \
        mail -s "[BACKUP] ECHEC - Sauvegarde absente" "$ALERT_EMAIL"
    exit 1
fi

# Vérifier la taille minimale
ACTUAL_SIZE=$(du -sg "$BACKUP_PATH" | awk '{print $1}')
if [ "$ACTUAL_SIZE" -lt "$MIN_SIZE_GB" ]; then
    echo "AVERTISSEMENT: Sauvegarde trop petite: ${ACTUAL_SIZE}G (minimum: ${MIN_SIZE_GB}G)" | \
        mail -s "[BACKUP] AVERTISSEMENT - Taille insuffisante" "$ALERT_EMAIL"
fi

# Vérifier l'âge de la sauvegarde
BACKUP_AGE=$(( ($(date +%s) - $(stat -c %Y "$BACKUP_PATH")) / 3600 ))
if [ "$BACKUP_AGE" -gt "$MAX_AGE_HOURS" ]; then
    echo "AVERTISSEMENT: Dernière sauvegarde il y a ${BACKUP_AGE}h (seuil: ${MAX_AGE_HOURS}h)" | \
        mail -s "[BACKUP] AVERTISSEMENT - Sauvegarde ancienne" "$ALERT_EMAIL"
fi

echo "OK: Sauvegarde du $(date +%Y-%m-%d) vérifiée: ${ACTUAL_SIZE}G"

# Ajouter la vérification au cron (après la sauvegarde)
# Vérification à 4h (la sauvegarde tourne à 2h)
0 4 * * * root /usr/local/bin/check-backup.sh >> /var/log/backup-check.log 2>&1

Intégration avec Healthchecks.io ou Prometheus

Pour une supervision plus robuste, intégrer les scripts rsync avec des outils de monitoring dédiés. Healthchecks.io (service freemium) permet de déclarer des "heartbeats" : le script rsync envoie un signal HTTP à la fin d'une sauvegarde réussie, et Healthchecks.io alerte par email ou Slack si le heartbeat n'arrive pas dans le délai attendu. Cette approche simple détecte les échecs de sauvegarde même si le serveur de monitoring est le même que le serveur sauvegardé (contrairement aux alertes locales qui ne s'envoient pas si le serveur est hors ligne).

rsync vs autres outils (Duplicati, Restic, BorgBackup) — comparatif

Bien que rsync soit un outil de référence, l'écosystème de la sauvegarde Linux s'est enrichi d'alternatives modernes qui comblent certaines lacunes de rsync.

rsync reste le meilleur choix pour les synchronisations de fichiers entre serveurs Linux en réseau local ou via SSH, les miroirs de répertoires, et les situations où la lisibilité des fichiers sauvegardés est importante (accès direct sans déchiffrement). Restic et BorgBackup sont préférables pour les sauvegardes chiffrées vers des destinations non fiables (stockage cloud, serveur tiers), grâce à leur déduplication et chiffrement natifs. Pour les environnements d'entreprise, les deux approches sont complémentaires : rsync pour les réplications locales rapides, Restic ou Borg pour les sauvegardes offsite chiffrées.

Pour les systèmes nécessitant une gestion centralisée des accès aux sauvegardes, l'intégration avec un annuaire OpenLDAP pour l'authentification des accès est une bonne pratique. Nos experts peuvent vous aider à concevoir une stratégie de sauvegarde adaptée, que ce soit dans le cadre d'un accompagnement RSSI externalisé ou d'un audit de votre plan de continuité.

Dépannage rsync (erreurs permission, connexion SSH, timeout)

Erreurs courantes et solutions

# Augmenter le timeout SSH pour les longues sauvegardes
# Dans /etc/ssh/ssh_config ou ~/.ssh/config
Host serveur-backup
    HostName nas.monentreprise.fr
    User backup
    IdentityFile /root/.ssh/id_backup
    ServerAliveInterval 60
    ServerAliveCountMax 10
    ConnectTimeout 30

# Déboguer rsync avec --itemize-changes
rsync -avh --itemize-changes /source/ /destination/
# Chaque ligne indique le type de changement :
# >f+++++++ : nouveau fichier transféré
# >f.st.... : fichier modifié (taille et timestamp)
# .d..t.... : dossier dont le timestamp a changé

# Vérifier la vitesse de transfert
rsync -avzh --progress --stats /source/ user@serveur:/destination/

La documentation officielle rsync est disponible sur rsync.samba.org et la page de manuel complète sur linux.die.net/man/1/rsync.

rsync peut-il sauvegarder des bases de données MySQL en toute sécurité ?

rsync ne doit pas être utilisé directement sur les fichiers de données MySQL actifs (dans /var/lib/mysql) car une copie de fichiers ouverts par le moteur de base de données peut produire une sauvegarde incohérente. La bonne pratique est d'exporter d'abord la base avec mysqldump ou mysqlpump, puis de synchroniser le fichier .sql.gz résultant avec rsync. Alternativement, XtraBackup de Percona permet des sauvegardes à chaud de MySQL InnoDB compatibles avec rsync.

Comment utiliser rsync avec rclone pour sauvegarder vers le cloud ?

rclone est souvent décrit comme "rsync pour le cloud". Il supporte plus de 70 services cloud (S3, Google Cloud, Azure, Backblaze B2) avec une syntaxe similaire à rsync. Pour les sauvegardes cloud, une approche courante consiste à utiliser rsync pour la synchronisation locale rapide, puis rclone pour pousser les snapshots vers le cloud : rclone sync /backup/2026-06-14/ s3:mon-bucket/backup/2026-06-14/.

rsync préserve-t-il les ACL et attributs étendus ?

Oui, avec les options appropriées. L'option -A préserve les ACL POSIX. L'option -X préserve les attributs étendus (xattr), utiles pour les contextes SELinux par exemple. Ces options ne sont pas incluses dans -a et doivent être ajoutées explicitement. Pour une sauvegarde système complète, utiliser rsync -aAXvh.

Quelle est la différence entre rsync --checksum et le mode par défaut ?

Par défaut, rsync décide si un fichier a changé en comparant sa taille et sa date de modification. C'est rapide mais peut manquer des modifications qui ne changent pas la taille ou le timestamp (cas rare). Avec --checksum (ou -c), rsync calcule une somme MD5 de chaque fichier et compare les deux côtés, garantissant une vérification exacte de l'intégrité au prix d'un temps de traitement plus long. À utiliser pour les audits d'intégrité ponctuels, pas pour les synchronisations quotidiennes.

Comment limiter l'impact de rsync sur le serveur source ?

Pour les sauvegardes sur des serveurs en production, limiter l'impact de rsync est important. L'option --bwlimit=N limite la bande passante en Ko/s. L'outil ionice permet de baisser la priorité I/O de rsync : ionice -c3 rsync .... L'outil nice réduit la priorité CPU : nice -n 19 rsync .... Combinés, ces outils permettent d'exécuter rsync en arrière-plan sans impact perceptible sur les utilisateurs.