Sauvegarde et restauration Docker avec exemples pratiques

Intro

Cette version française explique Docker backup and restore with practical examples avec le même objectif pratique que l article source : aider le lecteur à comprendre le contexte, les décisions à prendre et les points à vérifier avant de passer à l action.

Ce guide montre comment effectuer des Docker backup et Docker restore d'images, de volumes et de configurations avec des exemples prêts à copier-coller. Vous apprendrez un workflow simple, un pilote local sûr, des Docker validation checks, la planification d'un Docker rollback et les erreurs courantes à éviter. Les exemples ciblent Linux et Docker Compose, avec des notes pour faire le lien vers Kubernetes et les pipelines GitLab CI/CD. À la fin, vous aurez une approche reproductible que vous pouvez exécuter sur un laptop et étendre en production.

Vue d'ensemble du workflow

Utilisez ce workflow de bout en bout pour vos Docker backup et restaurations.

Inventorier ce qu'il faut protéger

Images et tags (évitez unlatest non épinglé)
Définitions des conteneurs (fichiers Compose, Dockerfiles, fichiers env)
Volumes et bind mounts qui contiennent l'état
Bases de données dans des conteneurs (utilisez des dumps, pas des copies brutes de fichiers)
Secrets et clés (stocker à part ou chiffrer)

Quiescer ou snapshotter

Mettre en pause les écritures : mode maintenance ou courte indisponibilité
Pour les bases : dumps logiques (pg_dump, mysqldump) ou snapshots cohérents

Sauvegarder

Config : fichiers gérés par git, plus une export "compose.lock" immuable
Images : docker save vers une archive tar
Volumes : tar via un conteneur auxiliaire temporaire
Bases de données : dumps vers des fichiers stockés avec la sauvegarde

Stocker et protéger

Ajouter des checksums (sha256)
Chiffrer au repos et en transit
Conserver des copies hors site et une rétention versionnée

Valider

Tester une restauration sur un hôte ou une VM propre
Vérifier la santé des conteneurs, les checksums des données et les endpoints applicatifs

Automatiser

Scripts shell ou Makefile
Planifier via cron ou des runners CI/CD

Documenter le rollback

Les étapes exactes pour revenir à une sauvegarde connue comme bonne
Qui décide, où sont les artefacts, comment valider le succès

Sauvegardes pratiques

L'exemple suivant sauvegarde un simple site Nginx qui sert un contenu depuis un volume nommé. Adaptez ce même schéma à d'autres services.

Mettre en place un service de démonstration

# Réseau et volume
docker network create appnet
docker volume create webdata

# Démarrer Nginx avec un tag épinglé
docker run -d --name web \
  --network appnet -p 8080:80 \
  -v webdata:/usr/share/nginx/html \
  nginx:1.25

# Placer un contenu d'exemple dans le volume
docker run --rm -v webdata:/data alpine \
  sh -c "echo 'Hello from backup demo' > /data/index.html"

Sauvegarder le volume avec un conteneur auxiliaire

mkdir -p backups
STAMP=$(date +%F_%H%M%S)
VOL_ARCHIVE=backups/webdata-$STAMP.tar.gz
VOL_SUM=backups/webdata-$STAMP.sha256

docker run --rm \
  -v webdata:/data: ro \
  -v "$(pwd)/backups":/backup \
  alpine sh -c "tar czf /backup/$(basename $VOL_ARCHIVE) -C /data ."

sha256sum "$VOL_ARCHIVE" > "$VOL_SUM"

Sauvegarder l'image (pour restaurer sans re-pull)

IMG_ARCHIVE=backups/nginx-1.25-images-$STAMP.tar

docker pull nginx:1.25
docker save -o "$IMG_ARCHIVE" nginx:1.25
sha256sum "$IMG_ARCHIVE" > "${IMG_ARCHIVE}.sha256"

Sauvegarder la définition du conteneur et Compose

# Enregistrer l'inspect du conteneur en cours (ports, montages, env)
docker inspect web > backups/web-$STAMP.inspect.json

# Si vous utilisez Compose, verrouillez et sauvegardez la config résolue
# (à exécuter dans un répertoire contenant compose.yaml)
# docker compose config > backups/compose-$STAMP.lock.yaml

Optionnel : dumps de base de données (exemples Postgres et MySQL)

# Dump logique Postgres
# docker exec -e PGPASSWORD=$PGPASSWORD pg \
#   pg_dump -U $PGUSER -h localhost -F c -f /tmp/db.dump $PGDATABASE
# docker cp pg:/tmp/db.dump backups/pg-$STAMP.dump

# Dump logique MySQL
# docker exec mysql \
#   sh -c 'mysqldump -u$MYSQL_USER -p$MYSQL_PASSWORD $MYSQL_DATABASE > /tmp/db.sql'
# docker cp mysql:/tmp/db.sql backups/mysql-$STAMP.sql

Restauration pratique

Restaurez d'abord sur un hôte propre ou une VM jetable. Traitez cela comme un exercice de Docker disaster recovery.

Charger les images

# Vérifier et charger l'image sauvegardée
sha256sum -c backups/nginx-1.25-images-*.tar.sha256
IMG_TAR=$(ls -1 backups/nginx-1.25-images-*.tar | tail -n1)
docker load -i "$IMG_TAR"

Recréer et restaurer le volume

# Créer le volume cible
NEW_VOL=webdata
docker volume create $NEW_VOL

# Choisir la dernière archive et vérifier
sha256sum -c backups/webdata-*.sha256
VOL_ARCHIVE=$(ls -1 backups/webdata-*.tar.gz | tail -n1)

# Extraire dans le volume vide
docker run --rm \
  -v $NEW_VOL:/data \
  -v "$(pwd)/backups":/backup \
  alpine sh -c "cd /data && tar xzf /backup/$(basename $VOL_ARCHIVE)"

Démarrer le conteneur et valider

docker run -d --name web-restore \
  -p 8080:80 \
  -v $NEW_VOL:/usr/share/nginx/html \
  nginx:1.25

# Contrôle de santé de base
curl -fsS http://localhost:8080 | tee /tmp/page.html
grep -q "Hello from backup demo" /tmp/page.html && echo OK || echo FAIL

Si vous utilisez Compose, restaurez avec la configuration verrouillée

# Dans le répertoire du projet qui contient compose-$STAMP.lock.yaml
# docker compose -f backups/compose-$STAMP.lock.yaml up -d
# Validez avec docker compose ps et des vérifications applicatives

Plan pilote local

Démarrez par un pilote réduit, mesurable et inspectable en local.

Périmètre

Un service (Nginx comme ci-dessus) avec un volume nommé
Artefacts de sauvegarde : tar d'image, tar.gz de volume, JSON d'inspect, checksums

Critères de succès

RTO inférieur à 5 minutes sur un laptop
Validation des checksums pour tous les artefacts
Le contenu de la page d'accueil correspond au texte attendu

Étapes

Implémentez les scripts de sauvegarde des exemples
Planifiez un cron quotidien qui écrit dans ./backups
Exécutez une restauration sur une VM neuve ou un contexte Docker Desktop
Documentez les commandes exactes, durées et résultats

Itération suivante

Ajoutez un petit conteneur Postgres avec pg_dump dans la sauvegarde
Placez les scripts derrière des cibles Make (make backup, make restore)
Stockez les artefacts avec chiffrement et synchronisation hors site quand disponible

Validation et Rollback

Contrôles de validation

Pré-sauvegarde : conteneurs sains (docker ps), endpoint OK, espace disque OK
Contrôles d'artefacts : sha256sum pour tous les tar, lister le contenu des tar
Post-restauration : service répond, données présentes, logs sans erreurs

Commandes utiles

# Pré-vol
docker ps --format 'table {{.Names}}\t{{.Status}}\t{{.Ports}}'

# Valider le contenu du tar sans extraire
tar tzf backups/webdata-YYYYMMDD_HHMMSS.tar.gz | head -n 10

# Vérification HTTP rapide
curl -fsSI http://localhost:8080 | grep -E 'HTTP/|Content-Type'

Planification du rollback

Conservez au moins 3 jeux de sauvegardes récents par service
Étiquetez les jeux avec timestamp, environnement et un commit git de l'app
Pour revenir en arrière : stoppez les conteneurs actuels, restaurez l'ensemble connu bon, démarrez, puis validez

Exemples de Docker rollback

# Arrêter la version défaillante
docker compose down  # ou docker stop <containers>

# Restaurer les artefacts précédents (images et volumes) comme dans la section restauration

# Démarrer explicitement des images connues comme bonnes
docker run -d --name app \
  -v appdata:/var/lib/app \
  myorg/app:1.2.3

# Pour Compose, épingler et démarrer
docker compose -f compose-rollback.lock.yaml up -d

Astuce : évitez les tags latest non épinglés. Utilisez des tags immuables ou des digests pour rendre le rollback déterministe.

Erreurs courantes

Évitez ces pièges

Utiliser docker export pour des apps stateful. Il n'inclut pas les volumes nommés. Utilisez docker save pour les images et tar pour les volumes.
Copier des fichiers de base de données à chaud. Préférez pg_dump ou mysqldump, ou arrêtez proprement la BD.
Oublier les bind mounts vers des chemins hôte. Incluez-les ou migrez vers des volumes nommés.
Pas de checksums ni de chiffrement. Ajoutez sha256 et chiffrez si requis.
Ne pas tester les restaurations. Planifiez un test périodique sur un hôte propre.
Faire les backups à l'intérieur du conteneur principal. Utilisez un conteneur auxiliaire éphémère.
Dépendre de latest. Épinglez des versions spécifiques ou des digests.
Négliger la gestion des secrets. Gardez-les hors des backups en clair ou chiffrez-les.

Notes pour plateformes liées

Docker Compose : validez vos fichiers compose dans git, créez un compose.lock via docker compose config, et sauvegardez-le.
Kubernetes : mêmes concepts. Sauvegardez les manifests et utilisez des snapshots de volumes ou des dumps logiques de BD. Testez les restaurations dans un namespace séparé.
GitLab CI/CD : exécutez les scripts de sauvegarde dans un pipeline planifié, stockez les artefacts et envoyez-les vers votre stockage. Gardez les identifiants en sécurité.

Conclusion

Vous disposez maintenant d'un workflow pratique pour réaliser des Docker backup et Docker restore d'images, de volumes et de configurations, ainsi qu'un petit pilote que vous pouvez lancer dès aujourd'hui. Commencez par un service, ajoutez des checksums et entraînez-vous à une restauration propre. Étendez ensuite aux bases de données, épinglez les versions et planifiez l'automatisation. À mesure que vous montez vers des stacks Compose ou Kubernetes, conservez les mêmes principes : inventorier l'état, quiescer, sauvegarder, valider et documenter le rollback.