Tutoriel Détaillé : Sauvegarder les Volumes Docker sur Synology avec Restic et Automatisation

by  on  in Accueil

Tutoriel Détaillé : Sauvegarder les Volumes Docker sur Synology avec Restic et Automatisation

Introduction

Ce tutoriel vous guide pas à pas pour mettre en place une solution de sauvegarde robuste et automatisée pour vos données Docker (volumes et bind mounts) hébergées sur un NAS Synology, en utilisant l’outil de sauvegarde Restic et un disque dur externe USB.

Pourquoi Restic ?

  • Sécurité : Chiffrement de bout en bout de vos sauvegardes. Seul vous (avec le mot de passe) pouvez lire les données.

  • Efficacité : Déduplication agressive. Seules les données nouvelles ou modifiées sont réellement stockées après la première sauvegarde, économisant énormément d’espace et de temps.

  • Flexibilité : Peut sauvegarder vers de nombreuses destinations (local, USB, SFTP, Cloud S3, B2, etc.). Nous utilisons ici un disque USB.

  • Fiabilité : Vérification de l’intégrité des données.

  • Open Source : Gratuit et audité par la communauté.

Objectif de ce Tutoriel :

Configurer un script sur votre Synology qui, automatiquement (via le Planificateur de tâches) :

  1. Arrête les conteneurs Docker concernés pour assurer la cohérence des données.

  2. Utilise Restic (via son image Docker officielle) pour sauvegarder les données spécifiées (volumes nommés et bind mounts) vers un dépôt chiffré sur un disque USB.

  3. Redémarre les conteneurs Docker.

  4. Nettoie les anciennes sauvegardes selon une politique définie.

Ce tutoriel couvre également la restauration de vos données, une étape cruciale !

Public Cible : Utilisateurs de NAS Synology avec Docker (Container Manager) et Portainer (optionnel mais utile), ayant un accès SSH et des notions de base de la ligne de commande Linux.

Prérequis :

  1. NAS Synology avec DSM et accès SSH activé (Panneau de configuration > Terminal & SNMP).

  2. Docker (Container Manager) installé et fonctionnel.

  3. Portainer (optionnel, mais facilite l’identification des configurations).

  4. Conteneurs Docker que vous souhaitez sauvegarder (ex: Paperless-ngx, Vaultwarden, Plex, etc.).

  5. Un Disque Dur Externe USB formaté (par Synology de préférence, ex: en ext4) et branché au NAS.

  6. Un accès SSH à votre NAS avec un utilisateur ayant des droits sudo (administrateur).

  7. Un éditeur de texte en ligne de commande sur Synology (ex: vim ou nano).

Phase 1 : Préparation et Identification des Informations Clés

C’est l’étape la plus importante pour que la suite fonctionne correctement.

1. Identifier le Point de Montage du Disque USB :

  • Connectez-vous à votre Synology via SSH.

  • Branchez votre disque dur externe USB.

  • Exécutez la commande : mount | grep usbshare

  • Notez le chemin qui apparaît avant « type ext4 » (ou autre système de fichiers). Ce sera probablement /volumeUSB1/usbshare, /volumeUSB2/usbshare, etc. Dans ce tutoriel, nous utiliserons /volumeUSB1/usbshare. Adaptez ce chemin si le vôtre est différent.

2. Créer le Dossier de Destination pour Restic sur le Disque USB :

  • Toujours en SSH, créez le dossier qui contiendra le dépôt Restic. Utilisez le chemin trouvé à l’étape 1.

    sudo mkdir -p /volumeUSB1/usbshare/restic

  • Nous appellerons ce chemin complet CHEMIN_REPO_EXTERNE_SYNOLOGY. Dans notre exemple : /volumeUSB1/usbshare/restic.

3. Identifier les Chemins des Données Docker à Sauvegarder :

C’est ici qu’il faut lister précisément tout ce que vous voulez sauvegarder. Il existe deux types principaux d’emplacements de données pour Docker : les volumes nommés et les bind mounts.

  • a) Trouver les Volumes Nommés :

    • Les volumes nommés sont gérés par Docker et se trouvent généralement dans un sous-dossier de /volume1/@docker/volumes/ sur Synology.

    • Listez le contenu de ce dossier pour voir les noms :

      sudo ls -la /volume1/@docker/volumes

    • Repérez les noms qui correspondent à vos applications (ex: paperless_pgdata, portainer_data, etc.) ainsi que les éventuels volumes anonymes (longues chaînes hexadécimales).

    • Pour chaque volume nommé pertinent (ou anonyme contenant des données), trouvez son chemin exact (Mountpoint) :

      sudo docker volume inspect NOM_DU_VOLUME
# Exemple: sudo docker volume inspect paperless_pgdata

    • Notez le chemin indiqué par « Mountpoint ». Il se termine généralement par /_data. Par exemple : /volume1/@docker/volumes/paperless_pgdata/_data.

    • Faites une liste de tous ces chemins …/_data pour les volumes nommés que vous voulez sauvegarder.

  • b) Trouver les Bind Mounts :

    • Les bind mounts sont des dossiers directs de votre système de fichiers Synology (ex: /volume1/docker/plex/config) qui sont mappés à l’intérieur des conteneurs. Ils n’apparaissent pas dans /volume1/@docker/volumes.

    • La meilleure façon de les trouver est d’inspecter vos configurations Docker :

      • Via Portainer : Allez dans « Stacks », sélectionnez un stack, et regardez dans l’éditeur la section volumes: du service. Les lignes comme – /volume1/docker/plex/config:/config indiquent un bind mount. La partie avant les deux-points (:) est le chemin sur votre Synology.

      • Via Portainer (Détails Conteneur) : Allez dans « Containers », cliquez sur un conteneur, et descendez à la section « Volumes » ou « Mounts ». Repérez les lignes où « Host path » / « Source » est un chemin direct sur votre NAS (commençant par /volume1/… etc.).

      • Via Fichiers docker-compose.yml : Si vous avez les fichiers originaux, ouvrez-les et regardez la section volumes: de chaque service.

    • Faites une liste de tous ces chemins hôtes directs pour les bind mounts que vous voulez sauvegarder (ex: /volume1/docker/plex/config, /volume1/docker/vaultwarden/data, etc.).

4. Sauvegarder les Fichiers de Configuration Docker (INDISPENSABLE !) :

Restic sauvegarde les données, mais pas comment vos conteneurs sont configurés. Pour une restauration complète, vous avez besoin de ces configurations.

  • Via Portainer : Pour chaque Stack, copiez le contenu de l’éditeur et sauvegardez-le dans un fichier texte nommé NOM_DU_STACK.yml (ex: plex_stack.yml).

  • Via Fichiers Originaux : Si vous avez les fichiers docker-compose.yml et les fichiers d’environnement .env correspondants, assurez-vous d’en avoir une copie.

  • Stockage : Copiez tous ces fichiers .yml et .env dans un endroit sûr, par exemple dans un sous-dossier sur votre disque USB de sauvegarde (/volumeUSB1/usbshare/docker_configs). NE PAS OUBLIER CETTE ÉTAPE !

Phase 2 : Configuration de Restic

1. Choisir et Sécuriser un Mot de Passe Restic :

  • Choisissez un mot de passe TRÈS FORT pour votre dépôt Restic. Ce mot de passe est la seule clé pour accéder à vos sauvegardes chiffrées.

  • NE LE PERDEZ JAMAIS ! Conservez-le en lieu sûr (gestionnaire de mots de passe).

  • Méthode Recommandée : Fichier Mot de Passe

    • Nous allons stocker ce mot de passe dans un fichier sécurisé sur votre Synology pour que le script puisse le lire sans l’exposer en clair.

    • Connectez-vous en SSH.

    • Créez un dossier pour vos scripts (si ce n’est pas déjà fait) :

      sudo mkdir -p /volume1/scripts
cd /volume1/scripts

    • Créez le fichier .restic_password (le . le rend caché) et insérez votre mot de passe :

      # REMPLACEZ "VOTRE_MOT_DE_PASSE_TRES_FORT" par votre vrai mot de passe
echo "VOTRE_MOT_DE_PASSE_TRES_FORT" | sudo tee .restic_password

    • Sécurisez les permissions du fichier (seul root pourra le lire) :

      sudo chmod 600 .restic_password

2. Initialiser le Dépôt Restic sur le Disque USB :

Cette commande doit être exécutée UNE SEULE FOIS pour préparer le dossier sur votre disque USB.

  • Toujours en SSH (peu importe le dossier où vous êtes) :

    # Définit les variables pour la clarté (adaptez si vos chemins diffèrent)
export REPO_PATH_HOST="/volumeUSB1/usbshare/restic"
export REPO_PATH_CONTAINER="/backup"
export RESTIC_PASSWORD_FILE="/volume1/scripts/.restic_password"

# Lance le conteneur Restic pour l'initialisation
sudo docker run --rm -it \
  -v ${RESTIC_PASSWORD_FILE}:/pwdfile:ro \
  -v ${REPO_PATH_HOST}:${REPO_PATH_CONTAINER} \
  restic/restic \
  --password-file /pwdfile \
  init --repo ${REPO_PATH_CONTAINER}

  • Restic va utiliser le mot de passe du fichier et créer la structure nécessaire dans /volumeUSB1/usbshare/restic. Vous devriez voir un message created restic repository….

Phase 3 : Le Script de Sauvegarde Automatisé

Voici le script shell qui orchestrera tout le processus.

1. Créer et Éditer le Fichier Script :

  • En SSH, naviguez vers votre dossier de scripts : cd /volume1/scripts

  • Utilisez vim (ou nano) pour créer le fichier : sudo vim restic_backup.sh

  • Passez en mode insertion (i).

  • Copiez et collez l’intégralité du script ci-dessous.

  • Quittez le mode insertion (Esc).

  • Sauvegardez et quittez (:wq + Entrée).

Contenu du Script (restic_backup.sh) :

#!/bin/bash

# === CONFIGURATION UTILISATEUR ===
# --- Chemins et Fichiers ---
LOG_FILE="/volume1/scripts/restic_backup.log"     # Emplacement du fichier de log
RESTIC_PASSWORD_FILE="/volume1/scripts/.restic_password" # Chemin ABSOLU vers le fichier mot de passe Restic (NE PAS METTRE LE MOT DE PASSE ICI)
# RESTIC_PASSWORD='' # Laisser commenté si RESTIC_PASSWORD_FILE est utilisé
REPO_PATH_HOST="/volumeUSB1/usbshare/restic"     # Chemin ABSOLU vers le dossier du dépôt Restic sur le Synology
REPO_PATH_CONTAINER="/backup"                    # Point de montage du dépôt DANS le conteneur Restic (ne pas changer)

# --- Conteneurs à Gérer ---
# Liste des noms EXACTS des conteneurs à arrêter/démarrer.
# Vérifiez avec 'sudo docker ps -a' et ADAPTEZ cette liste !
CONTAINERS_TO_STOP=(
  "paperless-webserver-1"
  "paperless-db-1"
  "paperless-broker-1"
  "paperless-gotenberg-1"
  "paperless-tika-1"
  "homepage"
  "jellyfin"
  "metube"
  "navidrome-navidrome-1"
  "plex"
  "vaultwarden"
  "portainer"
  "cloudcmd-web-1"
  # Enlevez/Ajoutez des conteneurs selon votre configuration
)

# --- Données à Sauvegarder ---
# Liste des chemins ABSOLUS sur l'hôte Synology à inclure.
# ADAPTEZ cette liste avec les chemins trouvés en Phase 1 !
# Structure: "Chemin Hôte Absolu:Chemin dans Conteneur Restic:Nom pour Log"
VOLUMES_TO_BACKUP=(
  # Bind Mounts (Chemins directs)
  "/volume1/docker/homepage/config:/data/homepage_config:homepage_config"
  "/volume1/docker/jellyfin/config:/data/jellyfin_config:jellyfin_config"
  "/volume1/video/metube:/data/metube_downloads:metube_downloads"
  "/volume1/docker/navidrome/data:/data/navidrome_data:navidrome_data"
  "/volume1/docker/plex/config:/data/plex_config:plex_config"
  "/volume1/docker/vaultwarden/data:/data/vaultwarden_data:vaultwarden_data"
  "/volume1/docker/paperless/data:/data/paperless_data:paperless_data"
  "/volume1/docker/paperless/media:/data/paperless_media:paperless_media"
  # Volumes Nommés (Chemins se terminant par /_data)
  "/volume1/@docker/volumes/paperless_pgdata/_data:/data/paperless_pgdata:paperless_pgdata"
  "/volume1/@docker/volumes/paperless_redisdata/_data:/data/paperless_redisdata:paperless_redisdata"
  "/volume1/@docker/volumes/portainer_data/_data:/data/portainer_data:portainer_data"
  # Ajoutez ici d'autres volumes/bind mounts identifiés
  # N'oubliez pas les volumes anonymes importants si vous en avez
)

# --- Politique de Nettoyage Restic ---
# Garde : 7 sauvegardes journalières, 4 hebdo, 6 mensuelles, 1 annuelle
FORGET_OPTIONS="--keep-daily 7 --keep-weekly 4 --keep-monthly 6 --keep-yearly 1 --prune"

# === FIN DE LA CONFIGURATION UTILISATEUR ===


# --- Fonctions ---
log() {
  echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | sudo tee -a "$LOG_FILE"
}

# Fonction pour construire la commande docker run complète
# Retourne la commande construite dans la variable globale $BUILT_COMMAND
build_restic_docker_command_string() {
  local restic_action=$1 # backup, forget, snapshots, etc.
  local restic_args=$2   # Arguments spécifiques à l'action restic

  local docker_options="--rm --env RESTIC_REPOSITORY=${REPO_PATH_CONTAINER}"
  local restic_command_password_opt=""
  local restic_command_part=""

  # Gestion du mot de passe
  if [[ -n "$RESTIC_PASSWORD_FILE" && -f "$RESTIC_PASSWORD_FILE" ]]; then
    docker_options+=" -v ${RESTIC_PASSWORD_FILE}:/pwdfile:ro"
    restic_command_password_opt="--password-file /pwdfile"
  elif [[ -n "$RESTIC_PASSWORD" ]]; then
    docker_options+=" --env RESTIC_PASSWORD=${RESTIC_PASSWORD}"
  else
    log "ERREUR MAJEURE: Mot de passe Restic non configuré."
    return 1
  fi

  # Ajout du montage du dépôt (lecture-écriture par défaut)
  docker_options+=" -v ${REPO_PATH_HOST}:${REPO_PATH_CONTAINER}"

  # Ajout des montages de volumes de données (uniquement pour 'backup')
  if [[ "$restic_action" == "backup" ]]; then
    local backup_paths_inside_container=""
    local valid_paths_found=0
    for volume_info in "${VOLUMES_TO_BACKUP[@]}"; do
      IFS=':' read -r host_path container_path _ <<< "$volume_info"
      if [[ -z "$host_path" || -z "$container_path" ]]; then log "ERREUR: Ligne mal formée: $volume_info"; continue; fi
      if [ ! -e "$host_path" ]; then log "ATTENTION: Chemin hôte introuvable: ${host_path}"; continue; fi
      docker_options+=" -v ${host_path}:${container_path}:ro" # Montage en lecture seule pour sécurité
      backup_paths_inside_container+=" ${container_path}"
      valid_paths_found=1
    done
    if [ $valid_paths_found -eq 0 ]; then log "ERREUR: Aucun chemin valide à sauvegarder trouvé."; return 1; fi
    restic_command_part="restic/restic ${restic_command_password_opt} backup ${backup_paths_inside_container}"
  else
    # Pour les autres actions (forget, snapshots), pas besoin des volumes de données
    restic_command_part="restic/restic ${restic_command_password_opt} ${restic_action} ${restic_args}"
  fi

  # Assigner la commande construite à la variable globale
  BUILT_COMMAND="sudo docker run ${docker_options} ${restic_command_part}"
  # log "Commande construite : ${BUILT_COMMAND}" # Décommenter pour debug si besoin extrême
  return 0
}


# --- Début du Script ---
# Vérifier si le script est lancé en root (ou via sudo)
if [[ $EUID -ne 0 ]]; then
   echo "$(date '+%Y-%m-%d %H:%M:%S') - ERREUR: Ce script doit être exécuté avec sudo ou en tant que root." | sudo tee -a "$LOG_FILE"
   exit 1
fi

# Assurer l'existence et les permissions du fichier log
sudo touch "$LOG_FILE" || { echo "ERREUR CRITIQUE: Impossible de créer/accéder au fichier log $LOG_FILE"; exit 1; }
sudo chown root:root "$LOG_FILE"
sudo chmod 644 "$LOG_FILE"

log "===== Début du script de sauvegarde Restic ====="

# Vérification initiale de la configuration du mot de passe
if [[ -z "$RESTIC_PASSWORD_FILE" && -z "$RESTIC_PASSWORD" ]]; then
  log "ERREUR CRITIQUE: Mot de passe Restic non configuré. Vérifiez RESTIC_PASSWORD_FILE ou RESTIC_PASSWORD."
  exit 1
fi
if [[ -n "$RESTIC_PASSWORD_FILE" ]]; then
  if [[ ! -f "$RESTIC_PASSWORD_FILE" ]]; then
      log "ERREUR CRITIQUE: Fichier de mot de passe défini (${RESTIC_PASSWORD_FILE}) mais non trouvé."
      exit 1
  fi
  log "Utilisation du fichier de mot de passe: ${RESTIC_PASSWORD_FILE}"
  sudo chmod 600 "$RESTIC_PASSWORD_FILE" || log "ATTENTION: Impossible de définir les permissions 600 sur ${RESTIC_PASSWORD_FILE}"
elif [[ -n "$RESTIC_PASSWORD" ]]; then
  log "Utilisation de la variable d'environnement RESTIC_PASSWORD (moins sûr)."
fi


# Arrêt des conteneurs
log "Arrêt des conteneurs (peut prendre un moment)..."
containers_actually_identified=()
for container in "${CONTAINERS_TO_STOP[@]}"; do
  container_exists=$(sudo docker ps -a -q -f name="^${container}$")
  if [ -n "$container_exists" ]; then
      containers_actually_identified+=("$container")
      if sudo docker ps -q -f name="^${container}$" | grep -q .; then
          log "  Arrêt de ${container}..."
          if sudo docker stop "$container" >> "$LOG_FILE" 2>&1; then
              log "  ${container} arrêté."
          else
              log "  ERREUR lors de l'arrêt de ${container}."
          fi
      else
          log "  Conteneur ${container} déjà arrêté."
      fi
  else
      log "  Conteneur ${container} non trouvé dans la liste d'arrêt."
  fi
done
log "Phase d'arrêt des conteneurs terminée."
log "Pause de 10 secondes..."
sleep 10

# Variable globale pour stocker la commande construite
declare BUILT_COMMAND=""

# Construction de la Commande de Sauvegarde Restic
log "Construction de la commande de sauvegarde Restic..."
build_restic_docker_command_string "backup" ""
BACKUP_BUILD_EC=$?

# Exécution de la Sauvegarde Restic (si construction réussie)
RESTIC_EXIT_CODE=1 # Initialiser à échec par défaut
if [ $BACKUP_BUILD_EC -eq 0 ]; then
    log "Lancement de la sauvegarde Restic..."
    backup_output=$( $BUILT_COMMAND 2>&1 )
    RESTIC_EXIT_CODE=$?
    printf "%s\n" "$backup_output" >> "$LOG_FILE"
    if [ $RESTIC_EXIT_CODE -eq 0 ]; then
      log "Sauvegarde Restic terminée avec succès."
    else
      log "ERREUR: La sauvegarde Restic a échoué avec le code de sortie : $RESTIC_EXIT_CODE. Voir sortie ci-dessus et dans le log."
    fi
else
    log "ERREUR lors de la construction de la commande de sauvegarde. Vérifiez la configuration."
fi

# Démarrage des conteneurs (ceux qu'on a identifiés comme existants)
log "Démarrage des conteneurs..."
if [ ${#containers_actually_identified[@]} -gt 0 ]; then
    for (( idx=${#containers_actually_identified[@]}-1 ; idx>=0 ; idx-- )) ; do
        container="${containers_actually_identified[idx]}"
        log "  Démarrage de ${container}..."
        if ! sudo docker start "$container" >> "$LOG_FILE" 2>&1; then
             log "  ERREUR lors du démarrage de ${container}."
        else
             log "  ${container} démarré (ou tentative effectuée)."
        fi
    done
else
    log "Aucun conteneur n'a été identifié dans la liste d'arrêt, tentative de redémarrage annulée."
fi
log "Phase de démarrage des conteneurs terminée."

# Nettoyage des anciens snapshots (uniquement si la sauvegarde a réussi)
if [ $RESTIC_EXIT_CODE -eq 0 ]; then
  log "Construction de la commande de nettoyage Restic..."
  build_restic_docker_command_string "forget" "${FORGET_OPTIONS}"
  CLEANUP_BUILD_EC=$?

  if [ $CLEANUP_BUILD_EC -eq 0 ]; then
      log "Nettoyage des anciens snapshots (politique: ${FORGET_OPTIONS})..."
      cleanup_output=$( $BUILT_COMMAND 2>&1 )
      CLEANUP_EXIT_CODE=$?
      printf "%s\n" "$cleanup_output" >> "$LOG_FILE"
      if [ $CLEANUP_EXIT_CODE -eq 0 ]; then
        log "Nettoyage terminé."
      else
        log "ERREUR: Le nettoyage Restic a échoué avec le code de sortie : $CLEANUP_EXIT_CODE. Voir sortie ci-dessus et dans le log."
      fi
  else
       log "ERREUR lors de la construction de la commande de nettoyage."
  fi
else
    log "Nettoyage annulé car la sauvegarde a échoué."
fi

log "===== Fin du script de sauvegarde Restic ====="
exit $RESTIC_EXIT_CODE

2. Rendre le Script Exécutable :

  • En SSH, assurez-vous d’être dans le dossier /volume1/scripts et exécutez :

    sudo chmod +x restic_backup.sh

3. Personnaliser le Script :

  • TRÈS IMPORTANT : Ouvrez le script (sudo vim restic_backup.sh) et modifiez les sections sous # === CONFIGURATION UTILISATEUR === pour qu’elles correspondent exactement à votre environnement :

    • Vérifiez RESTIC_PASSWORD_FILE et REPO_PATH_HOST.

    • Adaptez la liste CONTAINERS_TO_STOP avec les noms précis de vos conteneurs (utilisez sudo docker ps -a).

    • Adaptez la liste VOLUMES_TO_BACKUP avec tous les chemins (volumes _data et bind mounts) que vous avez identifiés en Phase 1. Enlevez ceux qui ne sont pas pertinents.

  • Sauvegardez les modifications (Esc, :wq, Entrée).

Phase 4 : Première Sauvegarde Manuelle et Vérification

Avant d’automatiser, lancez le script une fois manuellement pour tout vérifier.

1. Lancer le Script :

  • En SSH :

    sudo bash /volume1/scripts/restic_backup.sh

2. Surveiller l’Exécution :

  • Regardez la sortie dans le terminal. Vous verrez les étapes : arrêt des conteneurs, pause, construction de la commande, lancement de Restic, progression de la sauvegarde (peut être long la première fois !), fin de la sauvegarde, redémarrage des conteneurs, nettoyage.

  • Attendez le message final : ===== Fin du script de sauvegarde Restic =====.

3. Vérifier le Résultat :

  • Consulter le Log : Vérifiez qu’il n’y a pas d’ERREUR signalée :

    cat /volume1/scripts/restic_backup.log

  • Lister les Snapshots Restic : Vérifiez qu’une sauvegarde a bien été créée :

    # Définir les variables (adaptez si besoin)
export REPO_PATH_HOST="/volumeUSB1/usbshare/restic"
export REPO_PATH_CONTAINER="/backup"
export RESTIC_PASSWORD_FILE="/volume1/scripts/.restic_password"

# Exécuter la commande (en root ou avec sudo)
sudo docker run --rm \
  -v ${RESTIC_PASSWORD_FILE}:/pwdfile:ro \
  -v ${REPO_PATH_HOST}:${REPO_PATH_CONTAINER} \
  restic/restic \
  --password-file /pwdfile \
  snapshots --repo ${REPO_PATH_CONTAINER}

    Vous devriez voir au moins un snapshot listé.

  • Vérifier les Applications : Accédez à vos services Docker (Paperless, Vaultwarden…) pour vous assurer qu’ils fonctionnent correctement après le redémarrage.

Phase 5 : Automatisation via le Planificateur de Tâches Synology

Rendons cette sauvegarde automatique !

  1. Ouvrir le Planificateur de tâches : Dans DSM > Panneau de configuration > Planificateur de tâches.

  2. Créer : Tâche planifiée > Script défini par l’utilisateur.

  3. Onglet Général :

    • Tâche : Backup Docker Restic USB (ou autre nom clair).

    • Utilisateur : root (TRÈS IMPORTANT).

    • Activé : Coché.

  4. Onglet Programmer :

    • Choisissez votre fréquence (ex: « Tous les jours »).

    • Choisissez l’heure (ex: 03:00).

    • Fréquence : « Une fois par jour ».

  5. Onglet Paramètres de tâche :

    • Notifications : Cochez si vous voulez être notifié par e-mail (recommandé : « Notifier uniquement lorsque le script se termine anormalement »).

    • Script défini par l’utilisateur :

      bash /volume1/scripts/restic_backup.sh

  6. OK : Sauvegardez la tâche.

Votre sauvegarde s’exécutera désormais automatiquement.

Phase 6 : Restauration des Données (TESTEZ CECI !)

Une sauvegarde n’est utile que si vous savez restaurer. Voici les procédures. Il est crucial de tester au moins la restauration sélective.

Scénario A : Restauration Complète (ex: après changement de disques, nouveau NAS)

Prérequis : Nouveau NAS avec Docker, accès au dépôt Restic USB, copie de vos fichiers docker-compose.yml/.env.

  1. Préparer le Nouveau NAS :

    • Créez les dossiers hôtes nécessaires pour vos bind mounts (ex: sudo mkdir -p /volume1/docker/plex/config, /volume1/docker/paperless/data, etc.).

    • Copiez vos fichiers docker-compose.yml/.env sur le nouveau NAS (ex: dans /volume1/docker_setup/).

    • Copiez votre fichier .restic_password sur le nouveau NAS (ex: /volume1/scripts/).

    • Créez un dossier temporaire pour la restauration Restic : sudo mkdir /volume1/restore_temp.

  2. Restaurer TOUTES les données Restic :

    # Définir les variables sur le NOUVEAU NAS
export REPO_PATH_HOST="/volumeUSB1/usbshare/restic" # Point de montage USB sur nouveau NAS
export REPO_PATH_CONTAINER="/backup"
export RESTIC_PASSWORD_FILE="/volume1/scripts/.restic_password" # Sur nouveau NAS
export TEMP_RESTORE_DIR="/volume1/restore_temp"

# Commande de restauration complète
sudo docker run --rm \
  -v ${RESTIC_PASSWORD_FILE}:/pwdfile:ro \
  -v ${REPO_PATH_HOST}:${REPO_PATH_CONTAINER}:ro \
  -v ${TEMP_RESTORE_DIR}:/restore_target \
  restic/restic \
  --password-file /pwdfile \
  restore latest --target /restore_target

  3. Recréer l’Environnement Docker :

    • Naviguez vers les dossiers contenant vos fichiers docker-compose.yml.

    • Exécutez sudo docker-compose up –no-start (ou create) pour chaque stack. Cela crée les conteneurs, les réseaux, et surtout les volumes nommés.

  4. Copier les Données Restaurées vers les Emplacements Finaux :

    • Pour les Bind Mounts : Copiez depuis /volume1/restore_temp/data/NOM_INTERNE/ vers le dossier hôte correspondant (ex: /volume1/docker/plex/config/).

      # Exemple Plex (adaptez !)
sudo rsync -avh --delete ${TEMP_RESTORE_DIR}/data/plex_config/ /volume1/docker/plex/config/

    • Pour les Volumes Nommés : Trouvez leur nouveau Mountpoint sur le nouveau NAS (ex: sudo docker volume inspect stack_nom_volume) et copiez dedans.

      # Exemple Paperless DB (adaptez !)
PGDATA_MOUNTPOINT=$(sudo docker volume inspect VOTRE_STACK_PAPERLESS_pgdata -f '{{ .Mountpoint }}')
sudo rsync -avh --delete ${TEMP_RESTORE_DIR}/data/paperless_pgdata/ ${PGDATA_MOUNTPOINT}/

    • Répétez rsync pour toutes les données. Attention aux / finaux dans les chemins rsync.

  5. Démarrer les Conteneurs :

    • Retournez dans les dossiers compose et lancez sudo docker-compose up -d.

Scénario B : Restauration Sélective (ex: restaurer uniquement Navidrome)

  1. Arrêter/Supprimer le Conteneur Corrompu : (ex: sudo docker stop navidrome… && sudo docker rm navidrome…)

  2. Créer un Dossier Temporaire : sudo mkdir /volume1/navidrome_restore_temp

  3. Restaurer Uniquement les Données Cibles :

    # Définir variables...
# ...
export TEMP_RESTORE_DIR="/volume1/navidrome_restore_temp"

# Commande restore avec --include
sudo docker run --rm \
  -v ${RESTIC_PASSWORD_FILE}:/pwdfile:ro \
  -v ${REPO_PATH_HOST}:${REPO_PATH_CONTAINER}:ro \
  -v ${TEMP_RESTORE_DIR}:/restore_target \
  restic/restic \
  --password-file /pwdfile \
  restore latest --target /restore_target --include "/data/navidrome_data" # Chemin INTERNE utilisé lors du backup

  4. Recréer le Conteneur : Utilisez le compose ou le stack Portainer pour recréer le conteneur Navidrome. Assurez-vous qu’il pointe vers le bon dossier hôte (ex: /volume1/docker/navidrome/data).

  5. Copier les Données Restaurées :

    sudo rsync -avh --delete ${TEMP_RESTORE_DIR}/data/navidrome_data/ /volume1/docker/navidrome/data/

  6. Vérifier et Nettoyer : Démarrez le conteneur si besoin, vérifiez l’application, supprimez le dossier temporaire (sudo rm -rf ${TEMP_RESTORE_DIR}).

Phase 7 : Maintenance et Bonnes Pratiques

  • Vérifier les Logs Régulièrement : Jetez un œil au fichier /volume1/scripts/restic_backup.log de temps en temps pour vous assurer qu’il n’y a pas d’erreurs répétées.

  • Tester les Restaurations Périodiquement : Au moins une fois tous les 6 mois, faites un test de restauration (au moins sélective) pour vérifier que tout fonctionne toujours et que vous maîtrisez la procédure.

  • Vérifier l’Intégrité du Dépôt : De temps en temps, lancez une vérification Restic :

    # Définir variables...
sudo docker run --rm \
  -v ${RESTIC_PASSWORD_FILE}:/pwdfile:ro \
  -v ${REPO_PATH_HOST}:${REPO_PATH_CONTAINER} \
  restic/restic \
  --password-file /pwdfile \
  check --repo ${REPO_PATH_CONTAINER}

  • Stratégie 3-2-1 : Idéalement, ayez 3 copies de vos données (production + 2 sauvegardes), sur 2 supports différents (NAS + USB), avec 1 copie hors site (un autre disque USB stocké ailleurs, ou un dépôt Restic dans le cloud comme Backblaze B2).

  • Sécurité du Mot de Passe : Gardez votre mot de passe Restic en lieu sûr !

Conclusion

Vous disposez maintenant d’une sauvegarde automatisée, chiffrée et efficace pour vos données Docker critiques sur votre Synology. Restic est un outil puissant, et bien que la configuration initiale puisse sembler complexe, la tranquillité d’esprit qu’elle apporte en vaut largement la peine. N’oubliez pas de tester vos restaurations !