Sauvegarde et récupération planifiées

Introduction

Une sauvegarde utile ne se résume pas à exécuter une commande d’archivage. Vous devez savoir ce qu’elle contient, vérifier qu’elle peut être lue, restaurer le fichier dont vous avez besoin et rendre observables les exécutions automatisées.

Dans ce laboratoire, vous sauvegarderez un petit espace de travail applicatif à partir d’un manifeste, restaurerez un fichier donné, transformerez le processus en script horodaté et installerez une planification Cron. Tous les chemins utilisés par l’automatisation sont absolus afin que la tâche ne dépende pas du répertoire courant d’un shell interactif.

Définir le périmètre de la sauvegarde avec un manifeste

Dans cette étape, vous allez créer un manifeste : une liste de chemins en texte brut qui rend le périmètre de la sauvegarde visible et facile à vérifier.

Accédez à l’espace de travail :

cd /home/labex/project/backup-lab

Créez un manifeste contenant des chemins relatifs au répertoire data :

cat > backup-manifest.txt <<'EOF'
config/app.conf
documents/runbook.txt
EOF

Numérotez les entrées pour faciliter leur vérification :

nl -ba backup-manifest.txt

Vérifiez que chaque source répertoriée existe à l’aide d’une boucle while. Examinez sa structure avant de l’exécuter :

• IFS= empêche le shell de supprimer les espaces au début ou à la fin d’une ligne ;
• read -r item lit une ligne complète dans item sans traiter les antislashs de manière particulière ;
• do ... done délimite la commande répétée pour chaque ligne ;
• < backup-manifest.txt fournit le manifeste comme entrée de la boucle ;
• test -f vérifie que le chemin correspondant désigne un fichier ordinaire, et && affiche ready uniquement lorsque cette vérification réussit.

while IFS= read -r item; do
  test -f "data/$item" && echo "ready: $item"
done < backup-manifest.txt

Le fichier non répertorié documents/scratch.txt est volontairement exclu de cette sauvegarde gérée.

Créer une archive à partir du manifeste

Dans cette étape, vous utiliserez tar -T pour lire les noms de fichiers depuis le manifeste. L’option -C data permet d’utiliser des chemins relatifs courts dans l’archive.

tar -czf backups/manual-backup.tar.gz -C data -T backup-manifest.txt

Voici la signification des options :

• -c : créer une archive ;
• -z : la compresser avec gzip ;
• -f : utiliser le nom d’archive indiqué ensuite ;
• -C data : travailler relativement au répertoire data ;
• -T backup-manifest.txt : lire dans le manifeste les éléments à sauvegarder.

Inspectez le fichier obtenu :

ls -lh backups/manual-backup.tar.gz

Comparez son horodatage et sa taille avec ceux des fichiers sources :

stat -c '%n size=%s modified=%y' backups/manual-backup.tar.gz data/config/app.conf data/documents/runbook.txt

Vérifier l’archive sans l’extraire

Dans cette étape, vous testerez l’archive avant de lui faire confiance. Commencez par tester le flux gzip :

gzip -t backups/manual-backup.tar.gz

L’absence de sortie signifie que le contrôle d’intégrité du flux compressé a réussi. Listez maintenant les éléments tar sans les extraire :

tar -tzf backups/manual-backup.tar.gz | tee archive-contents.txt

Comparez la liste enregistrée avec le manifeste :

diff -u backup-manifest.txt archive-contents.txt

La commande ne doit afficher aucune différence. Vérifiez que le fichier de travail non géré est absent :

if tar -tzf backups/manual-backup.tar.gz | grep -qx 'documents/scratch.txt'; then
  echo "Unexpected scratch file found"
else
  echo "Archive scope is correct"
fi

Restaurer un fichier sélectionné

Dans cette étape, vous restaurerez uniquement un fichier précis afin de ne pas écraser des données sans rapport. Simulez la suppression accidentelle de la configuration :

rm data/config/app.conf

test -e data/config/app.conf || echo "app.conf is missing"

Extrayez uniquement config/app.conf dans le répertoire de restauration distinct :

rm -rf restore/*

tar -xzf backups/manual-backup.tar.gz -C restore config/app.conf

Examinez le fichier récupéré, puis recopiez-le à son emplacement de travail :

cat restore/config/app.conf

cp restore/config/app.conf data/config/app.conf

cmp -s restore/config/app.conf data/config/app.conf && echo "Configuration restored"

Seul l’élément demandé de l’archive a été extrait.

Créer un script de sauvegarde horodaté

Dans cette étape, vous allez créer un script de sauvegarde horodaté. Cron démarre les tâches avec un environnement limité ; utilisez donc des chemins absolus dans les scripts exécutés sans intervention.

Créez backup.sh :

cat > backup.sh <<'EOF'
#!/bin/bash

source_dir=/home/labex/project/backup-lab/data
manifest=/home/labex/project/backup-lab/backup-manifest.txt
backup_dir=/home/labex/project/backup-lab/backups
timestamp=$(date +%Y%m%d-%H%M%S)
archive="$backup_dir/backup-$timestamp.tar.gz"

mkdir -p "$backup_dir"

if [ ! -d "$source_dir" ] || [ ! -f "$manifest" ]; then
  echo "Backup source or manifest is missing" >&2
  exit 1
fi

/bin/tar -czf "$archive" -C "$source_dir" -T "$manifest" || exit 1
/bin/tar -tzf "$archive" > "$archive.contents" || exit 1

echo "Created $archive"
exit 0
EOF

Rendez le script exécutable et testez-le immédiatement au lieu d’attendre son lancement par Cron :

chmod u+x backup.sh

./backup.sh | tee last-backup.txt

ls -1 backups

L’horodatage attribue à chaque exécution un nom de fichier unique. Le fichier .contents associé consigne précisément le contenu de l’archive.

Installer et inspecter une planification Cron

Dans cette étape, vous installerez et inspecterez une planification Cron personnelle. Une ligne de crontab commence par cinq champs de planification, suivis de la commande :

Un astérisque * représente toutes les valeurs autorisées. Un pas tel que */5 signifie « toutes les cinq unités » pour le champ concerné.

minute hour day-of-month month day-of-week command

Par exemple, */5 * * * * signifie toutes les cinq minutes. 0 2 * * * signifie tous les jours à 02:00.

crontab -e ouvre la crontab personnelle dans un éditeur. Une méthode fiable consiste à préparer et installer d’abord une entrée correcte, puis à effectuer une petite modification interactive. Créez une entrée utilisant des chemins absolus et redirigeant la sortie standard ainsi que la sortie d’erreur standard :

cat > backup.crontab <<'EOF'
*/5 * * * * /home/labex/project/backup-lab/backup.sh >> /home/labex/project/backup-lab/logs/backup.log 2>&1
EOF

Vérifiez-la, puis installez-la :

cat backup.crontab

crontab backup.crontab

Ouvrez maintenant la crontab installée dans Nano :

EDITOR=nano crontab -e

Ajoutez ce commentaire sur la ligne précédant la planification :

## LabEx managed backup schedule

Appuyez sur Ctrl+O, puis sur Entrée pour enregistrer. Appuyez sur Ctrl+X pour quitter Nano et revenir au shell. Utilisez crontab -l pour confirmer exactement ce que Cron lira et enregistrez cette sortie :

crontab -l | tee installed-crontab.txt

La sortie doit contenir le commentaire suivi de l’entrée exécutée toutes les cinq minutes. L’examen du résultat installé permet de détecter une erreur de saisie avant de dépendre de cette planification.

Tester la journalisation et comprendre l’échappement du signe pourcentage

Dans cette étape, vous testerez la journalisation des sauvegardes et découvrirez le traitement particulier des signes pourcentage par Cron. Commencez par exécuter manuellement la commande planifiée :

/home/labex/project/backup-lab/backup.sh >> /home/labex/project/backup-lab/logs/backup.log 2>&1

tail -n 5 logs/backup.log

find backups -maxdepth 1 -type f -name 'backup-*.tar.gz' -printf '%f\n' | sort

L’horodatage est créé dans backup.sh, où les caractères % ordinaires ne posent aucun problème. En revanche, Cron traite spécialement tout % non échappé présent dans une commande de crontab. Si vous placez directement date dans une ligne de crontab, échappez chaque signe pourcentage avec un antislash.

Enregistrez un exemple correctement échappé pour référence :

cat > cron-date-example.txt <<'EOF'
0 2 * * * /bin/echo "backup-$(/bin/date +\%Y\%m\%d-\%H\%M\%S)" >> /home/labex/project/backup-lab/logs/date-example.log 2>&1
EOF

cat cron-date-example.txt

La tâche installée reste l’entrée plus simple fondée sur un script. Elle utilise des chemins absolus, attribue un horodatage à chaque archive et laisse un journal qui peut être consulté après les exécutions sans intervention.

Résumé

Vous avez défini le périmètre d’une sauvegarde dans un manifeste, créé une archive avec tar -T, vérifié celle-ci sans l’extraire et récupéré un fichier sélectionné. Vous avez ensuite écrit un script de sauvegarde horodaté utilisant des chemins absolus, installé et inspecté une planification Cron, redirigé la sortie des exécutions automatisées vers un journal et compris pourquoi les signes pourcentage doivent être échappés lorsque date apparaît directement dans une commande de crontab.