Sauvegarde de la carte SD du Raspberry Pi sur un serveur externe

Guillaume

30 janv. 2015 • 4 min read

Personne n'est jamais à l'abri d'une panne, et la sauvegarde (backup en anglais) est l'opération qui consiste à dupliquer et à mettre en sécurité les données contenues dans un système informatique.

Le Raspberry Pi utilise une carte SD ou micro-SD selon la version dont vous disposez. Ces cartes sont pratiques car pas chères et peu encombrantes, mais sont détournées de leur usage principal et doivent encaisser plus de cycles de lecture-écriture qu'une carte SD utilisée d'une façon plus normale.

Si votre carte SD voit ses données corrompues, il vous faudra donc réinstaller le système, refaire votre configuration, ... ce qui peut être évité si vous avez une sauvegarde de votre carte SD.

Vous pouvez très bien utiliser le logiciel Win32DiskImager, mais cela implique de devoir arrêter votre Raspberry Pi et donc les services hébergés.

Nous allons voir ici comment réaliser une image de votre carte SD de manière automatique, sans arrêt du système, et en externalisant la copie vers un serveur sur votre réseau local. Vous serez ainsi à même de restaurer votre carte SD et de limiter les pertes de données.

Pour ma part, je me suis servi de mon NAS Synology pour recevoir les images des cartes SD de mes Raspberry Pi.

Prérequis

Il faut configurer activer le protocole NFS et créer un partage accessible en
NFS (notez le chemin d’accès dans un coin). (Pour les NAS Synology, vous pouvez suivre la procédure suivante.)

Sur votre Raspberry, il faut vérifier que les paquets nécessaires à l'opération soient présents sur votre système, et le cas échéant les installer.

Tester la présence du protocole NFS :
```
  dpkg -l | grep nfs-common
```
- Installer NFS s’il est absent de votre système :
```
  apt-get install nfs-common
```
Tester la présence de l’outil PV (Pipe Viewer pour voir la progression du clonage lancé manuellement) :
```
  dpkg -l | grep pv
```
- Installer PV s’il est absent de votre système :
```
  apt-get install pv
```

Paramétrage du clonage

Créer un point de montage :
```
  sudo mkdir /mnt/Backup_NAS
```
Inscrire le montage dans fstab (pour permettre le montage automatique du partage au démarrage du système) :
```
  sudo nano /etc/fstab
```
Et ajouter la ligne suivante :
```
  192.168.1.100:/volume1/Backup_Jeedom    /mnt/Backup_NAS    nfs    rw,user    0    0
```
Tester le montage du partage distant :
```
  sudo mount -a && sudo df
```
Votre partage devrait maintenant apparaître.
Tester l’accès en écriture au partage distant :
```
  sudo mkdir /mnt/Backup_NAS/totofaitdubato
```
Vous ne devriez pas avoir d'erreur
Lancer manuellement le clonage de la carte SD (utile pour obtenir l’espace et le temps nécessaires au clonage) :
```
  sudo dd if=/dev/mmcblk0 bs=4M | sudo pv -treb | sudo dd of=/mnt/Backup_NAS/SD_Backup/Backup_SD_TEST.img && sync
```
L'image ainsi générée occupera 4Go d'espace si votre carte SD fait 4Go. Il est tout à fait possible de compresser l'image pour gagner en espace, notamment sur l'espace libre disponible sur votre carte SD.
```
  sudo dd if=/dev/mmcblk0 bs=4M | sudo pv -treb | sudo gzip -1 -| sudo dd of=/mnt/Backup_NAS/SD_Backup/Backup_SD_TEST.img && sync
```
Pour mon Raspberry Pi B avec une carte SD de 8Go, le clonage classique s'est fait en 1h44 pour un fichier généré de 8Go et le clonage compressé s'est fait en 2h19 pour un fichier généré de 4,3 Go.

Automatisation du clonage

Maintenant que le test a été effectué, nous pouvons automatiser tout ça. La durée de l'opération va permettre de bien planifier la tâche de clonage tandis que la taille du fichier permettra au script de contrôler son poids. Pour aller au bout de l’idée, nous allons mettre en place l’envoi de rapports par mail...

Installer et Paramétrer les fonctionnalités d’envoi de mails
- Installation de la fonction mail
```
  sudo apt-get install mailutils mpack ssmtp
```
- Editer la configuration de ssmtp pour paramétrer la passerelle smtp
```
  sudo nano /etc/ssmtp/ssmtp.conf
```
- Le fichier ssmtp.conf est à paramétrer comme suit :
```
  root=monLogin@gmail.com
  mailhub=smtp.gmail.com:587
  hostname=RaspberryPi
  AuthUser= monLogin@gmail.com
  AuthPass=monMotdepasse
  FromLineOverride=YES
  UseSTARTTLS=YES
```
  == ATTENTION :== Si vous utilisez la validation en deux étapes chez Google, vous devez générer un mot de passe d’application.
- Tester l’envoi d'un mail :
  
  echo "Contenu du mail" | mail -s "Titre du mail" AdresseDestinataire@gmail.com

Créer un script CloneSD.sh pour l’exécution du clonage :

  sudo nano CloneSD.sh

Et copier le contenu suivant :

  #!/bin/bash
  DATE=$(date +"%Y-%m-%d")
  BoxToClone=RaspberryPi
  SdImgSize=2032664576
  FileName=SD-Backup_$BoxToClone\_$DATE.img
  File=/mnt/img_nas/$FileName

  #sans compression : sudo dd if=/dev/mmcblk0 bs=4M of=$File && sync
  sudo dd if=/dev/mmcblk0 bs=4M | sudo gzip -1 -| sudo dd of=$File && sync

  FileStat=$(wc -c "$File" | cut -f 1 -d ' ')

  if [ $? -eq 0 ]; then
          if [ $FileStat -ge $SdImgSize ]; then
                  Objet="($DATE) SD-Backup $BoxToClone : ERREUR"
                  Message="Taille du fichier $FileName incorrecte"
          else
                  #taille OK
                  Objet="($DATE) SD-Backup $BoxToClone : OK"
                  Message="Clonage OK"
          fi
  else
          if [ -e $File ]; then
                  sudo rm $File
          fi<br>
          Objet="($DATE) SD-Backup $BoxToClone : ECHEC"
          Message="Echec du Clonage : fichier inexistant."
  fi

  echo "$Message" | mail -s "$Objet"  AdresseDestinataire@gmail.com

Autoriser l’exécution de ce script CloneSD.sh :
```
  sudo chmod u+x /home/user/CloneSD.sh
```
Exécuter le script manuellement pour tester son bon fonctionnement :
```
  sudo bash /home/user/CloneSD.sh
```
Planifier l’exécution du script (chaque Mercredi à 9h dans l’exemple)
```
  sudo crontab -e
```
- Ajouter la ligne suivante puis enregistrer :
```
  00 9 * * 3 sh /home/user/CloneSD.sh
```

Voilà, ce tutorial est terminé, vous aurez maintenant une image de votre carte SD au cas où un problème surviendrait et que celle-ci serait corrompue ou inutilisable.

N'hésitez pas à laisser des commentaires !

Source : Tutorial de Masterfion sur le forum de Jeedom