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 automatiques.

Dans ce laboratoire, vous allez sauvegarder un petit espace de travail applicatif à partir d’un manifeste, restaurer un fichier précis, transformer le processus en script horodaté et installer une planification Cron. Tous les chemins utilisés par les processus automatisés sont absolus : la tâche ne dépend donc 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 indiquée existe à l’aide d’une boucle while. Lisez 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 barres obliques inverses 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 standard, et && affiche ready uniquement si 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 allez utiliser tar -T pour lire les noms de fichiers dans 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

Signification des options :

• -c : crée une archive ;
• -z : la compresse avec gzip ;
• -f : utilise le nom de fichier d’archive qui suit ;
• -C data : travaille relativement au répertoire data ;
• -T backup-manifest.txt : lit dans le manifeste les éléments à inclure dans la sauvegarde.

Inspectez le fichier obtenu :

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

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

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 allez tester l’archive avant de vous y fier. Commencez par tester le flux gzip :

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

L’absence de sortie signifie que le flux compressé a passé le contrôle d’intégrité. 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 scratch 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 précis

Dans cette étape, vous allez restaurer un seul fichier afin de ne pas écraser les 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 séparé :

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 d’archive demandé 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 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é enregistre exactement le contenu de l’archive.

Installer et examiner une planification Cron

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

Un astérisque * signifie « toute valeur autorisée ». 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 chaque jour à 02:00.

crontab -e ouvre votre crontab personnelle dans un éditeur. Une méthode fiable consiste d’abord à préparer et installer une entrée connue comme valide, puis à effectuer une petite modification interactive. Créez une entrée qui utilise des chemins absolus et redirige 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 située au-dessus de la planification :

## LabEx managed backup schedule

Appuyez sur Ctrl+O, puis sur Enter pour enregistrer. Appuyez sur Ctrl+X pour quitter Nano et revenir au shell. Utilisez crontab -l pour confirmer exactement ce que Cron va lire, puis 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 de la crontab installée permet de détecter les erreurs de l’éditeur avant de dépendre de la planification.

Tester la journalisation et comprendre l’échappement du caractère pourcentage

Dans cette étape, vous allez tester la journalisation de la sauvegarde et découvrir le traitement spécial des signes pourcentage par Cron. Exécutez d’abord 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 caractère % non échappé présent dans une commande de crontab. Si vous placez directement date dans une ligne de crontab, échappez chaque signe pourcentage avec une barre oblique inverse.

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, basée sur un script. Elle utilise des chemins absolus, attribue un horodatage à chaque archive et laisse un journal que vous pouvez examiner 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é cette archive sans l’extraire et récupéré un fichier précis. Vous avez ensuite écrit un script de sauvegarde horodaté utilisant des chemins absolus, installé et examiné une planification Cron, redirigé la sortie des exécutions automatiques vers un journal et appris pourquoi les signes pourcentage doivent être échappés lorsque date apparaît directement dans une commande de crontab.