Système d'implémentation de sauvegarde et de restauration

# Plan de Sauvegarde et Restauration PostgreSQL avec Cloudflare R2 ## Contexte - **Base de données cible** : PostgreSQL s'exécutant dans un conteneur Docker (`statence_db`) - **Stockage hors site** : Bucket Cloudflare R2 via API compatible S3 - **Environnement hôte** : VPS Linux (Ubuntu/Debian) --- ## Environnement et Prérequis ### BACKUP-ENV-001 [Valider les variables d'environnement] - **Portée** : Valider les variables `.env` et la connectivité R2 - **Variables** : `CONTAINER_NAME`, `POSTGRES_USER`, `POSTGRES_DB`, `POSTGRES_PASSWORD`, `CF_R2_ACCESS_KEY_ID`, `CF_R2_SECRET_ACCESS_KEY`, `CF_R2_ENDPOINT_URL`, `CF_R2_BUCKET` - **Validation** : Confirmer le format du point de terminaison R2 et l'accessibilité du bucket - **Résultat** : Toutes les variables sont renseignées et la connectivité est vérifiée ### BACKUP-ENV-002 [Configurer le profil aws-cli] - **Portée** : Configuration d'un profil dédié pour R2 - **Profil** : Profil nommé dédié pour éviter les conflits avec AWS S3 - **Identifiants** : Provenant du fichier `.env` - **Résultat** : `aws s3 ls` contre le bucket R2 réussit ### BACKUP-ENV-003 [Vérifier la disponibilité des outils] - **Portée** : Vérifier que `pg_dump`, `gzip` et `aws-cli` sont installés - **Versions** : `pg_dump` compatible avec la version PostgreSQL du conteneur - **Résultat** : Tous les outils sont disponibles et compatibles ### BACKUP-ENV-004 [Valider l'accès au conteneur PostgreSQL] - **Portée** : Vérifier que le conteneur Docker `statence_db` est accessible - **Validation** : Exécuter une commande `docker exec` de test - **Résultat** : Le conteneur répond correctement --- ## Tâches d'Implémentation ### BACKUP-SCRIPT-001 [Créer le script de sauvegarde] - **Fichier** : `backup.sh` - **Portée** : Gestion complète des erreurs, `pg_dump`, compression, upload, nettoyage - **Dépendances** : Docker, aws-cli, gzip, pg_dump - **Résultat** : Sauvegarde automatisée de bout en bout avec journalisation ### RESTORE-SCRIPT-001 [Créer le script de restauration] - **Fichier** : `restore.sh` - **Portée** : Sélection interactive des sauvegardes, téléchargement, décompression, restauration avec garde-fou - **Dépendances** : Docker, aws-cli, gunzip, psql - **Résultat** : Capacité de récupération après sinistre vérifiée ### CRON-SETUP-001 [Configurer la planification cron] - **Planification** : Quotidienne à 03h00 - **Portée** : Générer une entrée cron vérifiée avec chemins absolus - **Journalisation** : Rediriger la sortie vers `logs/pg_backup.log` - **Résultat** : Exécution quotidienne de la sauvegarde sans intervention --- ## Tâches de Documentation ### DOC-INSTALL-001 [Créer le guide d'installation] - **Fichier** : `install.md` - **Portée** : Prérequis, procédure d'installation, dépannage - **Public** : Équipe des opérations et futurs mainteneurs - **Résultat** : Installation reproductible du clone du dépôt au cron actif --- ## Modifications de Code Proposées ### Contenu complet de `backup.sh` ```bash #!/bin/bash set -euo pipefail # Script de sauvegarde PostgreSQL vers Cloudflare R2 # Charge les variables d'environnement set -a source "$(dirname "$0")/.env" set +a # Configuration CONTAINER_NAME="${CONTAINER_NAME:-statence_db}" BACKUP_DIR="/tmp/pg_backup_$$" LOG_FILE="$(dirname "$0")/logs/pg_backup.log" TIMESTAMP=$(date +%Y-%m-%d_%H-%M) BACKUP_FILE="db_backup_${TIMESTAMP}.sql.gz" R2_PATH="s3://${CF_R2_BUCKET}/${BACKUP_FILE}" # Fonction de journalisation log() { echo "[$(date -Iseconds)] $1" >> "$LOG_FILE" } # Vérification des prérequis check_prerequisites() { if ! docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then log "FAILURE: Conteneur ${CONTAINER_NAME} non trouvé" exit 1 fi if ! command -v aws &> /dev/null; then log "FAILURE: aws-cli non installé" exit 1 fi if ! command -v gzip &> /dev/null; then log "FAILURE: gzip non installé" exit 1 fi } # Création du répertoire temporaire mkdir -p "$BACKUP_DIR" mkdir -p "$(dirname "$LOG_FILE")" log "Début de la sauvegarde" # Vérification des prérequis check_prerequisites # Sauvegarde PostgreSQL log "Exécution de pg_dump" if ! docker exec -i "$CONTAINER_NAME" \ pg_dump -U "$POSTGRES_USER" -d "$POSTGRES_DB" \ --no-owner --no-acl | gzip -9 > "$BACKUP_DIR/$BACKUP_FILE"; then log "FAILURE: Échec de pg_dump" rm -rf "$BACKUP_DIR" exit 1 fi # Vérification de la taille du fichier if [ ! -s "$BACKUP_DIR/$BACKUP_FILE" ]; then log "FAILURE: Fichier de sauvegarde vide" rm -rf "$BACKUP_DIR" exit 1 fi # Upload vers R2 log "Upload vers R2" if ! aws s3 cp "$BACKUP_DIR/$BACKUP_FILE" "$R2_PATH" \ --endpoint-url "$CF_R2_ENDPOINT_URL" \ --profile r2; then log "FAILURE: Échec de l'upload vers R2" rm -rf "$BACKUP_DIR" exit 1 fi # Vérification de l'upload if ! aws s3 ls "$R2_PATH" \ --endpoint-url "$CF_R2_ENDPOINT_URL" \ --profile r2 > /dev/null 2>&1; then log "FAILURE: Vérification de l'upload échouée" rm -rf "$BACKUP_DIR" exit 1 fi # Nettoyage rm -rf "$BACKUP_DIR" # Journalisation du succès FILE_SIZE=$(stat -f%z "$BACKUP_DIR/$BACKUP_FILE" 2>/dev/null || echo "0") log "SUCCESS: Sauvegarde terminée - $BACKUP_FILE - Taille: $FILE_SIZE octets" ``` ### Contenu complet de `restore.sh` ```bash #!/bin/bash set -euo pipefail # Script de restauration PostgreSQL depuis Cloudflare R2 # Charge les variables d'environnement set -a source "$(dirname "$0")/.env" set +a # Configuration CONTAINER_NAME="${CONTAINER_NAME:-statence_db}" TEMP_DIR="/tmp/pg_restore_$$" LOG_FILE="$(dirname "$0")/logs/pg_backup.log" R2_BASE="s3://${CF_R2_BUCKET}" # Fonction de journalisation log() { echo "[$(date -Iseconds)] $1" >> "$LOG_FILE" } # Fonction de vérification des prérequis check_prerequisites() { if ! docker ps --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then log "FAILURE: Conteneur ${CONTAINER_NAME} non trouvé" exit 1 fi if ! command -v aws &> /dev/null; then log "FAILURE: aws-cli non installé" exit 1 fi } # Liste des sauvegardes disponibles list_backups() { echo "Sauvegardes disponibles (10 dernières) :" aws s3 ls "$R2_BASE/" \ --endpoint-url "$CF_R2_ENDPOINT_URL" \ --profile r2 | sort -r | head -10 | awk '{print NR")", $4, "("$3, $2")"}' } # Sélection de la sauvegarde select_backup() { echo "Sélectionnez une sauvegarde (ou 'latest' pour la plus récente) :" read -r SELECTION if [ "$SELECTION" = "latest" ] || [ -z "$SELECTION" ]; then BACKUP_FILE=$(aws s3 ls "$R2_BASE/" \ --endpoint-url "$CF_R2_ENDPOINT_URL" \ --profile r2 | sort -r | head -1 | awk '{print $4}') else BACKUP_FILE=$(aws s3 ls "$R2_BASE/" \ --endpoint-url "$CF_R2_ENDPOINT_URL" \ --profile r2 | sort -r | head -10 | sed -n "${SELECTION}p" | awk '{print $4}') fi if [ -z "$BACKUP_FILE" ]; then echo "Sauvegarde non trouvée" exit 1 fi echo "Sauvegarde sélectionnée : $BACKUP_FILE" } # Confirmation de restauration confirm_restore() { echo "ATTENTION : Cette opération va écraser la base de données $POSTGRES_DB" echo "dans le conteneur $CONTAINER_NAME." echo "Cette action est irréversible." echo "" echo "Tapez 'RESTAURER' pour confirmer :" read -r CONFIRMATION if [ "$CONFIRMATION" != "RESTAURER" ]; then echo "Restauration annulée" exit 1 fi } # Fonction principale main() { mkdir -p "$TEMP_DIR" mkdir -p "$(dirname "$LOG_FILE")" log "Début de la restauration" # Vérification des prérequis check_prerequisites # Liste des sauvegardes list_backups # Sélection de la sauvegarde select_backup # Confirmation confirm_restore # Téléchargement log "Téléchargement de $BACKUP_FILE" if ! aws s3 cp "$R2_BASE/$BACKUP_FILE" "$TEMP_DIR/$BACKUP_FILE" \ --endpoint-url "$CF_R2_ENDPOINT_URL" \ --profile r2; then log "FAILURE: Échec du téléchargement" rm -rf "$TEMP_DIR" exit 1 fi # Restauration log "Restauration de la base de données" if ! gunzip -c "$TEMP_DIR/$BACKUP_FILE" | \ docker exec -i "$CONTAINER_NAME" \ psql -U "$POSTGRES_USER" -d "$POSTGRES_DB"; then log "FAILURE: Échec de la restauration" rm -rf "$TEMP_DIR" exit 1 fi # Nettoyage rm -rf "$TEMP_DIR" log "SUCCESS: Restauration terminée - $BACKUP_FILE" echo "Restauration terminée avec succès" } # Exécution main ``` ### Contenu complet de `install.md` # Guide d'Installation - Sauvegarde et Restauration PostgreSQL ## Prérequis ### Paquets système (apt/yum) ```bash # Ubuntu/Debian sudo apt update sudo apt install -y awscli postgresql-client gzip # CentOS/RHEL sudo yum install -y awscli postgresql gzip ``` ### Vérification des versions ```bash aws --version pg_dump --version gzip --version ``` ### Configuration Docker - Docker doit être installé et fonctionnel - Le conteneur `statence_db` doit être en cours d'exécution - Vérifier : `docker ps | grep statence_db` ## Configuration ### 1. Cloner le dépôt ```bash git clone <votre-repo> cd <votre-repo> ``` ### 2. Créer le fichier `.env` ```bash cp .env.example .env chmod 600 .env ``` Remplir les variables : ```env CONTAINER_NAME=statence_db POSTGRES_USER=votre_utilisateur POSTGRES_DB=votre_base POSTGRES_PASSWORD=votre_mot_de_passe CF_R2_ACCESS_KEY_ID=votre_access_key CF_R2_SECRET_ACCESS_KEY=votre_secret_key CF_R2_ENDPOINT_URL=https://<account_id>.r2.cloudflarestorage.com CF_R2_BUCKET=votre_bucket ``` ### 3. Configurer le profil aws-cli ```bash aws configure --profile r2 # AWS Access Key ID: <CF_R2_ACCESS_KEY_ID> # AWS Secret Access Key: <CF_R2_SECRET_ACCESS_KEY> # Default region name: auto # Default output format: json ``` ### 4. Vérifier la connectivité R2 ```bash aws s3 ls s3://votre_bucket --endpoint-url https://<account_id>.r2.cloudflarestorage.com --profile r2 ``` ### 5. Rendre les scripts exécutables ```bash chmod +x backup.sh restore.sh ``` ### 6. Créer le répertoire de logs ```bash mkdir -p logs chmod 755 logs ``` ## Installation du cron ### Ajouter l'entrée cron ```bash crontab -e ``` Ajouter la ligne : ```cron 0 3 * * * /chemin/absolu/vers/backup.sh >> /chemin/absolu/vers/logs/pg_backup.log 2>&1 ``` ### Vérifier le cron ```bash crontab -l ``` ## Test de la sauvegarde ### Test manuel ```bash ./backup.sh ``` ### Vérifier le log ```bash cat logs/pg_backup.log ``` ### Vérifier sur R2 ```bash aws s3 ls s3://votre_bucket --endpoint-url https://<account_id>.r2.cloudflarestorage.com --profile r2 ``` ## Test de la restauration ### Test avec la dernière sauvegarde ```bash ./restore.sh # Sélectionner "latest" # Confirmer avec "RESTAURER" ``` ## Dépannage ### Erreur : "Conteneur non trouvé" - Vérifier que Docker est en cours d'exécution : `systemctl status docker` - Vérifier le nom du conteneur : `docker ps` ### Erreur : "Échec de l'upload vers R2" - Vérifier le format de l'endpoint URL - Vérifier les identifiants R2 - Tester avec : `aws s3 ls s3://bucket --endpoint-url <URL> --profile r2` ### Erreur : "Permission refusée" - Vérifier les permissions des scripts : `ls -la backup.sh restore.sh` - Vérifier les permissions du répertoire logs ### Erreur : "Version pg_dump incompatible" - Installer la version correspondante de postgresql-client - Ou utiliser le pg_dump du conteneur ## Bonnes pratiques - Tester la restauration régulièrement - Surveiller les logs de sauvegarde - Faire une rotation des sauvegardes - Garder les identifiants sécurisés - Documenter toute modification --- ## Commandes ### Configuration de l'environnement ```bash # Installation des paquets sudo apt update && sudo apt install -y awscli postgresql-client gzip # Configuration aws-cli aws configure --profile r2 # Vérification de la connectivité aws s3 ls s3://votre_bucket --endpoint-url https://<account_id>.r2.cloudflarestorage.com --profile r2 ``` ### Test des scripts ```bash # Test de sauvegarde ./backup.sh # Test de restauration ./restore.sh # Vérification des logs cat logs/pg_backup.log ``` ### Installation du cron ```bash # Édition du crontab crontab -e # Ajouter la ligne 0 3 * * * /chemin/absolu/backup.sh >> /chemin/absolu/logs/pg_backup.log 2>&1 # Vérification crontab -l ``` --- ## Liste de Contrôle Assurance Qualité - [ ] Les commandes `aws-cli` fonctionnent avec le format d'endpoint R2 spécifique - [ ] La version de `pg_dump` correspond ou est compatible avec la version du conteneur - [ ] Les niveaux de compression gzip sont appliqués correctement - [ ] Les scripts ont les permissions d'exécution (`chmod +x`) - [ ] Les logs sont accessibles en écriture par l'utilisateur cron - [ ] Le script de restauration avertit l'utilisateur avant d'écraser les données - [ ] Les scripts sont idempotents lorsque c'est possible - [ ] Aucun identifiant codé en dur dans les scripts (variables d'environnement uniquement)