Sauvegarder votre Raspberry Pi avec rpi-clone et rsync

Corrompre une carte SD sur un Raspberry Pi qui tourne depuis des mois, c'est vite arrivé. Une mise à jour qui se passe mal, une coupure de courant au mauvais moment, et vous vous retrouvez à tout reconfigurer depuis zéro. Que vous fassiez tourner Home Assistant, Jeedom ou n'importe quel autre service, perdre des semaines de configuration, c'est clairement évitable.

Dans ce tutoriel, on met en place une solution de sauvegarde automatique avec deux outils complémentaires : rsync pour sauvegarder vers votre NAS via le réseau, et rpi-clone pour cloner vers une clé USB ou une carte SD bootable. On commence par rsync, qui demande un peu plus de configuration mais offre l'historique et les snapshots, puis on attaque rpi-clone, plus simple à prendre en main pour un clone bootable rapide.

Pourquoi combiner rpi-clone et rsync ?

rpi-clone est un outil qui clone votre système vers un disque physique : clé USB, SSD, HDD ou carte SD. Il crée une copie bootable à l'identique, ce qui est très pratique pour une restauration rapide.

C'est pourquoi on va combiner deux outils complémentaires :

• Pour une sauvegarde vers un disque USB → rpi-clone
• Pour une sauvegarde vers un partage réseau sur un NAS → rsync

La solution rsync

Pour commencer, nous allons attaquer la sauvegarde avec rsync vers le NAS. Nous devons d'abord monter le partage réseau sur le Raspberry Pi.

Partage réseau

Nous allons configurer un de nos dossiers backups en partage réseau sur notre NAS pour recevoir les sauvegardes. Voici comment configurer cela sur DSM de Synology si cela n'est pas déjà fait.

• Panneau de configuration → Dossier partagé
• Sélectionnez votre dossier backups → Modifier
• Permissions NFS → Créer
• Configurez :
  • Nom d'hôte ou IP : 192.168.1.* (ou l'IP exacte de votre Pi)
  • Privilège : Lecture/Écriture
  • Squash : Mapper tous les utilisateurs sur admin
  • Sécurité : sys
  • Cochez Autoriser les connexions de ports non privilégiés.

Maintenant direction le Raspberry en SSH pour configurer le partage réseau. Pensez à adapter l'adresse IP et le chemin du dossier de partage.

# Installer le client NFS
sudo apt update
sudo apt install nfs-common

# Créer le point de montage
sudo mkdir -p /mnt/nas-backup

# Tester le montage manuel d'abord
sudo mount -t nfs 192.168.1.100:/volume1/backups /mnt/nas-backup

# Vérifier que ça fonctionne
df -h | grep nas
ls -la /mnt/nas-backup

Si le test fonctionne, nous pouvons configurer le montage automatique au démarrage en éditant le fstab :

sudo nano /etc/fstab

# Ajoutez :
192.168.1.100:/volume1/backups /mnt/nas-backup nfs defaults,noatime,_netdev 0 0

# Paramètres expliqués
# -defaults : options par défaut
# -noatime : n'écrit pas les temps d'accès (meilleure performance)
# -_netdev : attend que le réseau soit prêt avant de monter


# Options avancées (optionnel)
# Pour plus de robustesse en cas de déconnexion réseau :
192.168.1.100:/volume1/backups /mnt/nas-backup nfs defaults,noatime,soft,timeo=30,retrans=2,_netdev 0 0

# Paramètres expliqués
# -soft : retourne une erreur si le NAS ne répond pas (évite de bloquer)
# -timeo=30 : timeout de 30 secondes
# -retrans=2 : 2 tentatives de connexion

# Démonter le montage d'avant
sudo umount -l /mnt/nas-backup

# Tester le montage
sudo mount -a

# Vérifier
df -h | grep nas
mount | grep nfs

# Créer un fichier test pour vérifier l'écriture
sudo touch /mnt/nas-backup/test-rpi.txt
ls -la /mnt/nas-backup/
# Vous devez voir le nouveau fichier "test-rpi.txt"

Sauvegarde incrémentale vers le NAS

Pour sauvegarder vers un NAS, rsync est la meilleure solution. Il copie exclusivement les fichiers modifiés et exclut automatiquement les montages réseau. Nous allons créer un script qui va encadrer la sauvegarde par rsync en collant le contenu ci-dessous.

sudo nano /usr/local/bin/backup-rpi-rsync.sh

#!/bin/bash
#
# Sauvegarde incrémentale du Raspberry Pi vers NAS avec rsync
#

# Configuration
NAS_MOUNT="/mnt/nas-backup"
BACKUP_DIR="$NAS_MOUNT/raspberry-pi"
BACKUP_NAME="rpi-rsync-backup"
DATE=$(date +%Y%m%d-%H%M)
LOG_FILE="/var/log/rpi-rsync-backup.log"

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

# Vérifier que le NAS est monté
if ! mountpoint -q $NAS_MOUNT; then
    log "ERREUR : Le NAS n'est pas monté. Tentative de montage..."
    sudo mount $NAS_MOUNT
    if [ $? -ne 0 ]; then
        log "ERREUR : Impossible de monter le NAS. Sauvegarde annulée."
        exit 1
    fi
fi

# Créer les répertoires
mkdir -p $BACKUP_DIR/$BACKUP_NAME
mkdir -p $BACKUP_DIR/snapshots

log "=== Début de la sauvegarde incrémentale ==="

# Nettoyage optionnel avant sauvegarde
log "Nettoyage du cache APT..."
sudo apt-get clean >/dev/null 2>&1

# Sauvegarde avec rsync (exclut automatiquement les montages et dossiers système)
sudo rsync -aAXHv --delete --stats --no-o --no-g \
    --exclude='/dev/*' \
    --exclude='/proc/*' \
    --exclude='/sys/*' \
    --exclude='/tmp/*' \
    --exclude='/run/*' \
    --exclude='/mnt/*' \
    --exclude='/media/*' \
    --exclude='/lost+found' \
    --exclude='/var/swap' \
    --exclude='/var/cache/apt/archives/*' \
    --exclude='.gvfs' \
    --link-dest=$BACKUP_DIR/$BACKUP_NAME \
    / \
    $BACKUP_DIR/$BACKUP_NAME-temp/ 2>&1 | tee -a $LOG_FILE

# Vérifier le succès
if [ ${PIPESTATUS[0]} -eq 0 ]; then
    # Créer un snapshot daté (liens durs = pas d'espace supplémentaire)
    log "Création du snapshot daté..."
    cp -al $BACKUP_DIR/$BACKUP_NAME-temp $BACKUP_DIR/snapshots/backup-$DATE
    
    # Remplacer l'ancienne sauvegarde
    rm -rf $BACKUP_DIR/$BACKUP_NAME
    mv $BACKUP_DIR/$BACKUP_NAME-temp $BACKUP_DIR/$BACKUP_NAME
    
    BACKUP_SIZE=$(du -sh $BACKUP_DIR/$BACKUP_NAME | cut -f1)
    SNAPSHOT_COUNT=$(ls -1 $BACKUP_DIR/snapshots/ | wc -l)
    
    log "Sauvegarde réussie : $BACKUP_SIZE"
    log "Snapshots disponibles : $SNAPSHOT_COUNT"
    
    # Nettoyer les vieux snapshots (garder les 7 derniers)
    cd $BACKUP_DIR/snapshots
    OLD_SNAPSHOTS=$(ls -t | tail -n +8)
    if [ -n "$OLD_SNAPSHOTS" ]; then
        log "Nettoyage des anciens snapshots..."
        echo "$OLD_SNAPSHOTS" | xargs -r rm -rf
    fi
    
    log "=== Sauvegarde terminée ==="
    exit 0
else
    log "ERREUR : La sauvegarde a échoué"
    rm -rf $BACKUP_DIR/$BACKUP_NAME-temp
    exit 1
fi

Il vous reste à rendre le script exécutable et à le lancer pour vérifier que tout marche bien. La première fois, rsync copie tous les fichiers (10-15 minutes). Les sauvegardes suivantes seront beaucoup plus rapides (30 secondes à 2 minutes).

sudo chmod +x /usr/local/bin/backup-rpi-rsync.sh
sudo /usr/local/bin/backup-rpi-rsync.sh

Par ailleurs, vous pouvez vérifier les logs avec la commande suivante :

tail -f /var/log/rpi-rsync-backup.log

Après plusieurs sauvegardes, vous aurez une structure ainsi sur votre NAS :

/mnt/nas-backup/raspberry-pi/
├── rpi-rsync-backup/          ← Sauvegarde la plus récente
└── snapshots/
    ├── backup-20251228-1430/  ← Snapshot du 28/12 à 14h30
    ├── backup-20251227-0200/  ← Snapshot du 27/12 à 2h
    ├── backup-20251226-0200/  ← etc...
    └── ...                    (7 snapshots max conservés)

Automatisation des sauvegardes vers le NAS

Pour automatiser les sauvegardes rsync, nous allons ajouter une tâche cron :

sudo crontab -e

Ajoutez selon vos besoins :

# Sauvegarde quotidienne à 2h du matin
0 2 * * * /usr/local/bin/backup-rpi-rsync.sh

# OU sauvegarde toutes les 6 heures
0 */6 * * * /usr/local/bin/backup-rpi-rsync.sh

# OU sauvegarde hebdomadaire le dimanche à 4h
0 4 * * 0 /usr/local/bin/backup-rpi-rsync.sh

# OU sauvegarde hebdomadaire le lundi à 3h10
10 3 * * 1 /usr/local/bin/backup-rpi-rsync.sh

La solution rpi-clone

Commençons par installer rpi-clone sur votre Raspberry Pi. Connectez-vous en SSH et exécutez la commande d'installation automatique :

curl https://raw.githubusercontent.com/geerlingguy/rpi-clone/master/install | sudo bash

Vous pouvez vérifier la bonne installation en vérifiant la version installée :

rpi-clone --version

Utiliser rpi-clone

Nous avons vu comment sauvegarder vers le NAS avec rsync. Si vous avez un disque USB ou une carte SD, rpi-clone permet de créer un clone bootable à l'identique, utile pour une sauvegarde hors réseau. Le support cible doit être d'une capacité égale ou supérieure à votre carte SD principale.

Pour un clone ponctuel, une seule commande suffit. Branchez votre clé USB et identifiez-la avec lsblk.

NAME        MAJ:MIN RM  SIZE RO TYPE MOUNTPOINT
sda           8:0    1 14.9G  0 disk  
└─sda2        8:1    1 14.9G  0 part 
mmcblk0     179:0    0 14.4G  0 disk 
├─mmcblk0p1 179:1    0  256M  0 part /boot
└─mmcblk0p2 179:2    0 14.2G  0 part /

Ici sda est la clé USB et mmcblk0 la carte SD intégrée. Lancez ensuite le clone :

sudo rpi-clone sda

Pour une première sauvegarde, rpi-clone détecte que les partitions ne correspondent pas, propose d'initialiser le disque, crée les systèmes de fichiers et copie tous les fichiers. Comptez jusqu'à 20 minutes selon l'occupation de votre SD. À la fin, appuyez simplement sur Entrée.

Si vous souhaitez automatiser ce processus pour des clones réguliers sans intervention, passez à la section suivante.

Automatiser les clones vers clé USB

Pour créer automatiquement des clones de secours sur clé USB, vous pouvez programmer rpi-clone avec un script d'automatisation. Créez le fichier suivant :

sudo nano /usr/local/bin/auto-clone-usb.sh

#!/bin/bash
#
# Clone automatique vers clé USB si elle est branchée
# Avec notifications Telegram/Pushover
#

# ================== CONFIGURATION ==================
LOG_FILE="/var/log/rpi-clone-usb.log"
USB_DEVICE=""

# Notifications (décommenter et configurer selon vos besoins)
# TELEGRAM
ENABLE_TELEGRAM=false
TELEGRAM_BOT_TOKEN="votre_bot_token"
TELEGRAM_CHAT_ID="votre_chat_id"

# PUSHOVER
ENABLE_PUSHOVER=false
PUSHOVER_TOKEN="votre_app_token"
PUSHOVER_USER="votre_user_key"

# EMAIL (nécessite mailutils: sudo apt install mailutils)
ENABLE_EMAIL=false
EMAIL_TO="votre@email.com"
# ===================================================

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

# Fonction notification Telegram
send_telegram() {
    if [ "$ENABLE_TELEGRAM" = true ]; then
        local message="$1"
        curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
            -d chat_id="${TELEGRAM_CHAT_ID}" \
            -d text="${message}" \
            -d parse_mode="HTML" >/dev/null 2>&1
    fi
}

# Fonction notification Pushover
send_pushover() {
    if [ "$ENABLE_PUSHOVER" = true ]; then
        local title="$1"
        local message="$2"
        curl -s -X POST "https://api.pushover.net/1/messages.json" \
            -d "token=${PUSHOVER_TOKEN}" \
            -d "user=${PUSHOVER_USER}" \
            -d "title=${title}" \
            -d "message=${message}" >/dev/null 2>&1
    fi
}

# Fonction notification Email
send_email() {
    if [ "$ENABLE_EMAIL" = true ]; then
        local subject="$1"
        local body="$2"
        echo "$body" | mail -s "$subject" "$EMAIL_TO"
    fi
}

# Chercher une clé USB branchée (exclut la carte SD principale)
for device in /dev/sd?; do
    if [ -b "$device" ]; then
        USB_DEVICE=$(basename $device)
        log "Clé USB détectée : $USB_DEVICE"
        break
    fi
done

# Si aucune clé USB trouvée, sortir silencieusement
if [ -z "$USB_DEVICE" ]; then
    log "Aucune clé USB détectée. Clone annulé."
    exit 0
fi

# Vérifier que la clé a une taille raisonnable (au moins 8GB)
USB_SIZE=$(lsblk -b -d -n -o SIZE /dev/$USB_DEVICE)
MIN_SIZE=$((8*1024*1024*1024))  # 8 GB en bytes

if [ "$USB_SIZE" -lt "$MIN_SIZE" ]; then
    USB_SIZE_HR=$(numfmt --to=iec-i --suffix=B $USB_SIZE)
    log "ERREUR : Clé USB trop petite ($USB_SIZE_HR). Minimum requis: 8GB"
    
    send_telegram "⚠️ <b>Clone USB échoué</b>
Clé USB trop petite: $USB_SIZE_HR
Minimum requis: 8GB"
    send_pushover "Clone USB échoué" "Clé USB trop petite: $USB_SIZE_HR (min: 8GB)"
    send_email "Clone USB échoué" "Clé USB trop petite: $USB_SIZE_HR. Minimum requis: 8GB"
    
    exit 1
fi

# Notification de début
USB_SIZE_HR=$(numfmt --to=iec-i --suffix=B $USB_SIZE)
log "=== Début du clone vers /dev/$USB_DEVICE ==="
log "Taille de la clé : $USB_SIZE_HR"

send_telegram "🔄 <b>Clone USB démarré</b>
Destination: /dev/$USB_DEVICE
Taille: $USB_SIZE_HR"

# Clone non-interactif avec l'option -f pour forcer si nécessaire
START_TIME=$(date +%s)
/usr/local/bin/rpi-clone $USB_DEVICE -f -U 2>&1 | tee -a $LOG_FILE
CLONE_EXIT_CODE=${PIPESTATUS[0]}
END_TIME=$(date +%s)
DURATION=$((END_TIME - START_TIME))
DURATION_MIN=$((DURATION / 60))

if [ $CLONE_EXIT_CODE -eq 0 ]; then
    log "=== Clone réussi vers /dev/$USB_DEVICE ==="
    log "Durée: ${DURATION_MIN} minutes"
    
    send_telegram "✅ <b>Clone USB réussi</b>
Destination: /dev/$USB_DEVICE
Taille: $USB_SIZE_HR
Durée: ${DURATION_MIN} min
Date: $(date '+%d/%m/%Y %H:%M')"
    
    send_pushover "Clone USB réussi" "Clé /dev/$USB_DEVICE clonée avec succès en ${DURATION_MIN} min"
    send_email "Clone USB réussi" "Clone vers /dev/$USB_DEVICE terminé avec succès.
Taille: $USB_SIZE_HR
Durée: ${DURATION_MIN} minutes
Date: $(date '+%d/%m/%Y %H:%M:%S')"
    
    # Optionnel : Éjecter la clé après clone
    # sync
    # udisksctl power-off -b /dev/$USB_DEVICE
    # log "Clé USB éjectée, vous pouvez la retirer en sécurité"
    
    exit 0
else
    log "ERREUR : Le clone a échoué (code: $CLONE_EXIT_CODE)"
    
    send_telegram "❌ <b>Clone USB échoué</b>
Destination: /dev/$USB_DEVICE
Code erreur: $CLONE_EXIT_CODE
Vérifiez les logs: /var/log/rpi-clone-usb.log"
    
    send_pushover "Clone USB échoué" "Échec du clone vers /dev/$USB_DEVICE (code: $CLONE_EXIT_CODE)"
    send_email "Clone USB échoué" "Le clone vers /dev/$USB_DEVICE a échoué.
Code erreur: $CLONE_EXIT_CODE
Consultez les logs: /var/log/rpi-clone-usb.log"
    
    exit 1
fi

Il vous reste à rendre le script exécutable et à le lancer pour vérifier que tout marche bien :

sudo chmod +x /usr/local/bin/auto-clone-usb.sh
sudo /usr/local/bin/auto-clone-usb.sh

Il vous reste à planifier le script comme précédemment en évitant d'avoir des exécutions qui se chevauchent :

sudo crontab -e

# Clone automatique tous les dimanches à 4h du matin (si clé USB branchée)
0 4 * * 0 /usr/local/bin/auto-clone-usb.sh

# OU clone automatique tous les jours à 4h (si clé USB branchée)
0 4 * * * /usr/local/bin/auto-clone-usb.sh

Fonctionnement :

• Le script vérifie si une clé USB est branchée
• Si oui, il lance automatiquement un clone
• Sinon, il s'arrête silencieusement
• Vous pouvez laisser une clé USB branchée en permanence pour des clones automatiques (mon choix)

Logs du clone

# Voir les logs des clones automatiques
sudo tail -f /var/log/rpi-clone-usb.log

# Voir l'historique complet
sudo cat /var/log/rpi-clone-usb.log

rpi-clone ne conserve qu'une seule version : la dernière. Si vous voulez de l'historique, travaillez avec plusieurs supports en rotation :

• Semaine 1 : Clé USB A
• Semaine 2 : Clé USB B
• Semaine 3 : Clé USB C
• Semaine 4 : Clé USB A (écrase l'ancien clone)

Ainsi, vous avez toujours 2-3 sauvegardes bootables d'âges différents — option bien utile si le Raspberry n'a pas un accès permanent au NAS, mais qui demande une action humaine.

Restauration de votre Raspberry Pi

C'est super, on a sauvegardé notre Raspberry, mais savoir comment faire en cas de souci pour utiliser nos sauvegardes, c'est mieux.

Depuis la sauvegarde NAS (rsync)

Depuis un PC Linux avec la carte SD montée :

# Monter la partition root de la nouvelle carte SD
sudo mount /dev/sdX2 /mnt/sdcard-root
sudo mount /dev/sdX1 /mnt/sdcard-root/boot

# Monter le NAS
sudo mount -t nfs 192.168.1.100:/volume1/Sauvegarde /mnt/nas

# Restaurer tout le système
sudo rsync -aAXHv --delete \
    /mnt/nas/raspberry-pi/rpi-rsync-backup/ \
    /mnt/sdcard-root/

# Synchroniser et démonter
sync
sudo umount /mnt/sdcard-root/boot
sudo umount /mnt/sdcard-root

Pour restaurer un fichier ou dossier spécifique, pointez directement vers le snapshot voulu dans /mnt/nas-backup/raspberry-pi/snapshots/.

Si vous ne disposez pas de machine Linux sous la main, voici comment restaurer votre Raspberry Pi depuis Windows. Installez les outils nécessaires :

• Win32 Disk Imager ou Balena Etcher : pour écrire l'image sur la carte SD

Cependant, une sauvegarde rsync ne peut pas être directement écrite sur une carte SD depuis Windows comme une image .img. Vous avez deux options :

Utiliser une carte SD bootable existante et restaurer les fichiers

1. Créez une nouvelle installation Raspberry Pi OS sur une carte SD avec Raspberry Pi Imager
2. Lancez le Raspberry Pi avec cette nouvelle carte
3. Montez le NAS sur le Raspberry Pi :

sudo mount -t nfs 192.168.1.100:/volume1/backups /mnt/nas-backup

4. Restaurez les fichiers importants uniquement :

# Restaurer les configurations
sudo rsync -av /mnt/nas-backup/raspberry-pi/rpi-rsync-backup/home/ /home/
sudo rsync -av /mnt/nas-backup/raspberry-pi/rpi-rsync-backup/etc/ /etc/

# Restaurer vos données spécifiques
sudo rsync -av /mnt/nas-backup/raspberry-pi/rpi-rsync-backup/opt/ /opt/

Avec la sauvegarde réalisée sur le disque USB

La méthode la plus simple : retirez votre carte SD principale et démarrez directement sur le disque USB cloné (sur Pi 3/4/5 avec USB boot activé). En cas de SD dans un adaptateur, vous pouvez simplement remplacer la SD du Raspberry.

Vérification après restauration

Une fois le système redémarré, vérifiez l'espace disque et pensez à agrandir la partition pour utiliser toute la carte SD :

# Vérifier l'espace disque
df -h

sudo raspi-config
# Choisir : Advanced Options → Expand Filesystem
sudo reboot

Récapitulatif des méthodes

Points de vigilance

• Espace disque : prévoyez 2-3× la taille de votre SD sur le NAS (snapshots inclus), et un support USB de capacité égale ou supérieure à la SD principale.
• Sécurité : n'exposez pas votre partage NFS sur Internet et conservez au moins une sauvegarde de chaque type (NAS + USB).
• Cron : évitez que rsync et rpi-clone tournent en même temps — espacez-les dans votre planning.
• Limites : les sauvegardes rsync ne sont pas bootables directement ; les clones USB n'ont pas d'historique sans rotation de supports.

Conclusion

Vous avez maintenant un système de sauvegarde solide pour votre Raspberry Pi : des sauvegardes incrémentales vers le NAS avec rsync, et des clones bootables sur clé USB avec rpi-clone. De quoi dormir tranquille avant une mise à jour système ou un changement de config risqué.

Un dernier conseil, et c'est peut-être le plus important : testez vos sauvegardes. Une restauration de test sur une carte SD de rechange tous les deux ou trois mois, c'est la seule façon de savoir si elles sont vraiment exploitables. Une sauvegarde non testée, c'est juste une illusion de sécurité.

N'hésitez pas à partager vos déploiements ou venir chercher de l'aide avec la communauté sur le groupe Telegram ou bien en commentaire !