Merge branch 'develop' into fix/correctif

Merge pull request 'feat/script-redéploiement-BDD-utilisable-interface-web' (#13 ) from feat/script-redéploiement-BDD-utilisable-interface-web into develop
Reviewed-on: #13
2026-03-18 11:50:32 +01:00 · 2026-03-18 10:49:52 +00:00 · 2026-03-18 11:37:53 +01:00 · 2026-03-18 10:12:33 +01:00 · 2026-03-17 16:34:40 +01:00 · 2026-03-17 16:31:56 +01:00
28 changed files with 3677 additions and 1243 deletions
--- a/BackupVaultWarden/.env.exemple
+++ b/BackupVaultWarden/.env.exemple
@@ -2,6 +2,9 @@
 # VAULTWARDEN BACKUP CONFIGURATION
 #############################################

+# Webhook Discord pour notifications (optionnel)
+DISCORD_WEBHOOK_URL=
+
 # Répertoire contenant les données Vaultwarden
 DATA_DIR=

--- a/BackupVaultWarden/README.md
+++ b/BackupVaultWarden/README.md
@@ -1,4 +1,3 @@
-markdown
 # README — Mise en place du script de sauvegarde Vaultwarden

 Ce script permet d’automatiser la sauvegarde de Vaultwarden afin de conserver une copie du dossier `data`, de la transférer vers un serveur distant et d’envoyer une notification Discord en cas de succès ou d’échec.
@@ -67,8 +66,8 @@ Elles doivent être placées dans un fichier `.env`.

 ```bash
 WEBHOOK_URL=https://discord.com/api/webhooks/...
-REMOTE_USER=backup
-REMOTE_HOST=192.168.1.50
+REMOTE_USER=<USER>
+REMOTE_HOST=<IP_SERVEUR>
 SSH_KEY=/home/matt/.ssh/id_ed25519_vaultwarden_backup
 DATA_DIR=/opt/vaultwarden/data
 REMOTE_DIR=/home/backup/backups/vaultwarden
@@ -89,70 +88,49 @@ REMOTE_DIR=/home/backup/backups/vaultwarden

 # 5. Chargement des variables dans le script

-Le script récupère les variables du fichier `.env`.
+Le script charge directement le fichier `.env` avec `source` et exporte automatiquement les variables pendant le chargement.

-Exemple :
+Mécanisme utilisé :

 ```bash
-REMOTE_USER=$(grep -E '^REMOTE_USER=' .env | cut -d '=' -f2-)
+set -a
+source "$ENV_FILE"
+set +a
 ```

 Explication :

-* `grep` recherche la variable dans `.env`
-* `cut` récupère uniquement la valeur après `=`
-* la variable shell reçoit la valeur correspondante
+* `set -a` exporte automatiquement les variables définies ensuite
+* `source "$ENV_FILE"` lit et exécute le contenu du fichier `.env` dans le shell courant
+* `set +a` désactive ensuite l'export automatique

 Cela permet :

-* d'améliorer la sécurité
-* de modifier la configuration sans toucher au script
+* de charger toutes les variables du fichier `.env` en une seule fois
+* de conserver la configuration en dehors du script
+* de rester aligné avec le comportement réel du script

 ---

-# 6. Connexion au serveur de sauvegarde (Machine IA)
+### 6. Connexion au serveur de sauvegarde (Machine IA)

-Le transfert des sauvegardes vers la machine IA repose sur une **authentification par clé SSH**.  
-Cette méthode permet au script de se connecter automatiquement au serveur distant sans mot de passe.
+Le transfert des sauvegardes utilise une **clé SSH** afin de permettre une connexion automatique au serveur distant sans mot de passe.

-La clé utilisée pour ce script est :
+#### 1. Génération de la clé

-```
-~/.ssh/id_ed25519_bitwarden
-
-````
-
---
-
-## 6.1 Vérifier la présence de la clé SSH
-
-Sur la machine exécutant le script, vérifier que la clé existe :
+Sur la machine exécutant les scripts :

 ```bash
-ls ~/.ssh/id_ed25519_bitwarden*
-````
-
-Les fichiers attendus sont :
-
-```
-~/.ssh/id_ed25519_bitwarden
-~/.ssh/id_ed25519_bitwarden.pub
+ssh-keygen -t ed25519 -f ~/.ssh/id_ed25519_bitwarden
 ```

-* `id_ed25519_bitwarden` → clé privée utilisée par le script
-* `id_ed25519_bitwarden.pub` → clé publique autorisée sur la machine IA
-
---
-
-## 6.2 Copier la clé publique sur la machine IA
-
-Envoyer la clé publique vers la machine IA :
+#### 2. Copie de la clé vers le serveur distant

 ```bash
-ssh-copy-id -i ~/.ssh/id_ed25519_bitwarden.pub backup@192.168.0.179
+ssh-copy-id -i ~/.ssh/id_ed25519_bitwarden.pub <USER>@<IP_SERVEUR>
 ```

-Cette commande ajoute automatiquement la clé dans :
+Cette commande ajoute la clé dans :

 ```
 ~/.ssh/authorized_keys
@@ -160,27 +138,28 @@ Cette commande ajoute automatiquement la clé dans :

 sur la machine IA.

---
-
-## 6.3 Ajout manuel de la clé (si ssh-copy-id n'est pas disponible)
-
-Afficher la clé publique :
+#### 3. Vérification de la connexion

 ```bash
-cat ~/.ssh/id_ed25519_bitwarden.pub
+ssh -i ~/.ssh/id_ed25519_bitwarden backup@192.168.0.179
 ```

-Copier son contenu puis l’ajouter sur la machine IA dans :
+#### 4. Vérification des fichiers de clé

-```
-~/.ssh/authorized_keys
+```bash
+ls ~/.ssh/id_ed25519_bitwarden*
 ```

---
+Fichiers attendus :

-## 6.4 Vérifier les permissions SSH
+```
+~/.ssh/id_ed25519_bitwarden
+~/.ssh/id_ed25519_bitwarden.pub
+```

-Sur la machine locale :
+#### 5. Permissions SSH
+
+Machine locale :

 ```bash
 chmod 700 ~/.ssh
@@ -188,40 +167,20 @@ chmod 600 ~/.ssh/id_ed25519_bitwarden
 chmod 644 ~/.ssh/id_ed25519_bitwarden.pub
 ```

-Sur la machine IA :
+Machine distante :

 ```bash
 chmod 700 ~/.ssh
 chmod 600 ~/.ssh/authorized_keys
 ```

---
-
-## 6.5 Tester la connexion
-
-Tester la connexion SSH avec la clé :
-
-```bash
-ssh -i ~/.ssh/id_ed25519_bitwarden backup@192.168.0.179
-```
-
-Si la configuration est correcte :
-
-* la connexion se fait **sans mot de passe**
-* la machine IA accepte la clé SSH
-* le script pourra envoyer les sauvegardes automatiquement
-
---
-
-## 6.6 Déclaration dans le fichier `.env`
-
-La clé utilisée par le script doit être déclarée dans `.env` :
+#### 6. Déclaration dans `.env`

 ```bash
 SSH_KEY=/home/matt/.ssh/id_ed25519_bitwarden
 ```

-Cette clé sera utilisée automatiquement par `scp` lors du transfert des sauvegardes.
+Cette clé sera utilisée automatiquement par les scripts (`scp` / `ssh`) pour transférer les sauvegardes.


 # 7. Sauvegarde des données Vaultwarden
--- a/BackupVaultWarden/backup-vaultwarden.sh
+++ b/BackupVaultWarden/backup-vaultwarden.sh
@@ -33,7 +33,7 @@ set +a
 #######################################
 # Variables obligatoires
 #######################################
-: "${WEBHOOK_URL:=}"
+: "${DISCORD_WEBHOOK_URL:=}"
 : "${DATA_DIR:?Variable DATA_DIR manquante dans .env}"
 : "${LOCAL_BACKUP:?Variable LOCAL_BACKUP manquante dans .env}"
 : "${REMOTE_USER:?Variable REMOTE_USER manquante dans .env}"
@@ -47,13 +47,12 @@ set +a
 DATE="$(date +'%Y-%m-%d_%H-%M-%S')"
 BACKUP_PREFIX="vaultwarden-backup"
 BACKUP_NAME="${BACKUP_PREFIX}-${DATE}.tar.gz"
-LOCAL_BACKUP_DIR="$LOCAL_BACKUP"
-LOCAL_BACKUP_FILE="${LOCAL_BACKUP_DIR}/${BACKUP_NAME}"
-RETENTION_DAYS=10
+LOCAL_BACKUP_FILE="${LOCAL_BACKUP}/${BACKUP_NAME}"
+RETENTION_DAYS="${BACKUP_RETENTION_DAYS:-10}"

 SSH_OPTS=(-i "$SSH_KEY" -o IdentitiesOnly=yes -o BatchMode=yes -o ConnectTimeout=10)

-mkdir -p "$LOCAL_BACKUP_DIR"
+mkdir -p "$LOCAL_BACKUP"

 #######################################
 # Notification Discord
@@ -62,7 +61,7 @@ discord_ping() {
    local success="$1"
    local details="${2:-}"

-    [[ -z "$WEBHOOK_URL" ]] && return 0
+    [[ -z "$DISCORD_WEBHOOK_URL" ]] && return 0

    local icon status_line
    if [[ "$success" == "true" ]]; then
@@ -81,10 +80,9 @@ discord_ping() {
    msg+="Data transfer: ${status_line}\n"
    [[ -n "$details" ]] && msg+="Détails: ${details}"

-    python3 - <<PY | curl -fsS -H "Content-Type: application/json" -d @- "$WEBHOOK_URL" >/dev/null || true
-import json
-print(json.dumps({"content": """$msg"""}))
-PY
+    local payload
+    payload="$(jq -n --arg content "$msg" '{content: $content}')"
+    curl -fsS -H "Content-Type: application/json" -d "$payload" "$DISCORD_WEBHOOK_URL" >/dev/null || true
 }

 #######################################
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,7 +2,7 @@

 Liste des évolutions du projet Scripts Serveur  

-## [0.0.1]
+## [1.0.0]
 ### Parameters
 Ajouter dans le fichier /RecetteScripts/.env
 SSH_TIMEOUT
@@ -35,7 +35,9 @@ SSH_KEY
 * [#378] Script Backup BDD Vaultwarden
 * [#381] Variabiliser tous les scripts
 * [#384] Fix Correctif
-* [#391] Script Déploiement de Scripts
+* [#390] Rotation des script
+* [#392] Scripts de reconstruction des bases de données
+* [#427] Correctifs
 ### Changed

 ### Fixed
--- a/CheckStorage/.env.exemple
+++ b/CheckStorage/.env.exemple
@@ -3,4 +3,4 @@
 #############################################

 # Webhook Discord pour notifications
-WEBHOOK_URL=
+DISCORD_WEBHOOK_URL=
--- a/CheckStorage/README.md
+++ b/CheckStorage/README.md
@@ -18,7 +18,23 @@ La limite d'alerte est fixée à 70% d'utilisation, mais vous pouvez ajuster cet
 3. ```bash
   cd Scripts-Serveur/CheckStorage
   ```
-   
+### Génération de la clé SSH
+
+Sur la machine exécutant les scripts :
+
+```bash
+ssh-keygen -t ed25519 -f ~/.ssh/check_storage_key
+```
+Copier la clé sur le serveur distant :
+
+```bash
+ssh-copy-id -i ~/.ssh/check_storage_key.pub user@serveur
+```
+Tester la connexion sans mot de passe :
+
+```bash
+ssh -i ~/.ssh/check_storage_key <USER>@<HOST>
+```
 ## Utilisation du script
 0. Copiez le fichier d'environnement exemple et modifiez les variables selon votre configuration :
   ```bash
@@ -46,4 +62,4 @@ La limite d'alerte est fixée à 70% d'utilisation, mais vous pouvez ajuster cet
   ```
   
 ## Avertissement
-Assurez-vous de remplacer `/chemin/vers/le/script/check-storage.sh` par le chemin réel où se trouve le script sur votre système.
+Assurez-vous de remplacer `/chemin/vers/le/script/check-storage.sh` par le chemin réel où se trouve le script sur votre système.
--- a/CheckStorage/check-storage.sh
+++ b/CheckStorage/check-storage.sh
@@ -56,7 +56,7 @@ if [ "$usage" -ge "$limit" ]; then
    -H "Accept: application/json" \
    -H "Content-Type: application/json; charset=utf-8" \
    -d "$payload" \
-    "$WEBHOOK_URL"
+    "$DISCORD_WEBHOOK_URL"

 fi

@@ -66,4 +66,4 @@ fi

 echo "Espace disponible : ${avail_gb} GB"
 echo "Espace utilise / espace total : ${used_gb} GB / ${total_gb} GB"
-echo "Name: ${HOSTNAME}"
+echo "Name: ${HOSTNAME}"
--- a/Deployment/Deployment.sh
+++ b/Deployment/Deployment.sh
@@ -1,964 +0,0 @@
-#!/usr/bin/env bash
-set -Eeuo pipefail
-
-###############################################################################
-# bootstrap-backup-env.sh
-#
-# Prépare un environnement de déploiement pour :
-#   - backup-vaultwarden.sh
-#   - check-storage.sh
-#   - check-statut-recette.sh
-#   - backup-bdd-recette.sh
-#   - rebuild-bdd-recette.sh
-#
-# Fonctionnalités :
-#   - idempotent : relançable sans erreur ;
-#   - installation / mise à jour des dépendances ;
-#   - création des dossiers ;
-#   - permissions ;
-#   - génération des clés SSH si absentes ;
-#   - récupération depuis un dépôt Git privé volumineux via sparse-checkout ;
-#   - mise à jour du .env ;
-#   - injection des valeurs sensibles dans le .env si fournies ;
-#   - ajout automatique de la clé publique backup sur le serveur distant
-#     si un accès SSH bootstrap est disponible ;
-#   - questions interactives si lancé en local et que des variables obligatoires
-#     sont absentes ;
-#   - génération d'un fichier scripts.json pour un futur affichage web ;
-#   - exécutable en local ou envoyé via SSH sur un serveur distant.
-###############################################################################
-
-#######################################
-# Valeurs par défaut
-#######################################
-REPO_URL=""
-REPO_BRANCH="main"
-REPO_SUBDIR=""
-INSTALL_DIR="/opt/malio-backup"
-DEPLOY_USER="${SUDO_USER:-${USER}}"
-DEPLOY_GROUP=""
-ENV_FILE_NAME=".env"
-
-GIT_DIR_NAME="repo"
-SCRIPTS_DIR_NAME="scripts"
-CONFIG_DIR_NAME="config"
-LOG_DIR_NAME="logs"
-DATA_DIR_NAME="data"
-TMP_DIR_NAME="tmp"
-SSH_DIR_NAME="ssh"
-
-BACKUP_SSH_KEY_NAME="id_ed25519_backup"
-REPO_SSH_KEY_NAME="id_ed25519_repo"
-
-FORCE_CHOWN="false"
-NON_INTERACTIVE="false"
-
-# Paramètres fonctionnels
-ENV_NAME="RECETTE"
-PGHOST="localhost"
-PGPORT="5432"
-PGUSER_VALUE=""
-PGPASSWORD_VALUE=""
-DBS_VALUE="sirh inventory ferme"
-
-BACKUP_REMOTE_USER="backup"
-BACKUP_REMOTE_HOST=""
-BACKUP_REMOTE_DIR="/home/backup/backups/bdd-recette"
-SSH_CONNECT_TIMEOUT="10"
-RETENTION_DAYS="10"
-
-DISCORD_WEBHOOK_URL_VALUE=""
-DISCORD_PING_VALUE=""
-WEBHOOK_URL_VALUE=""
-VAULTWARDEN_DATA_DIR_VALUE="/var/lib/vaultwarden"
-CHECK_STORAGE_PATHS_VALUE="/ /var /home"
-
-APP_1_NAME_VALUE="ferme"
-APP_1_URL_VALUE="https://ferme.malio-dev.fr"
-APP_2_NAME_VALUE="sirh"
-APP_2_URL_VALUE="https://sirh.malio-dev.fr"
-APP_3_NAME_VALUE="inventory"
-APP_3_URL_VALUE="https://inventory.malio-dev.fr"
-
-# Bootstrap SSH vers le serveur de destination
-BOOTSTRAP_SSH_USER=""
-BOOTSTRAP_SSH_PORT="22"
-BOOTSTRAP_SSH_KEY=""
-BOOTSTRAP_SSH_STRICT="accept-new"
-INSTALL_BACKUP_KEY_ON_REMOTE="true"
-
-#######################################
-# Scripts attendus
-#######################################
-EXPECTED_SCRIPTS=(
-  "backup-vaultwarden.sh"
-  "check-storage.sh"
-  "check-statut-recette.sh"
-  "backup-bdd-recette.sh"
-  "rebuild-bdd-recette.sh"
-)
-
-#######################################
-# Journalisation
-#######################################
-timestamp() {
-  date '+%Y-%m-%d %H:%M:%S'
-}
-
-log() {
-  echo "[$(timestamp)] [INFO] $*"
-}
-
-warn() {
-  echo "[$(timestamp)] [WARN] $*" >&2
-}
-
-err() {
-  echo "[$(timestamp)] [ERROR] $*" >&2
-}
-
-die() {
-  err "$*"
-  exit 1
-}
-
-#######################################
-# Gestion erreurs
-#######################################
-on_error() {
-  local exit_code=$?
-  err "Échec ligne ${BASH_LINENO[0]} : ${BASH_COMMAND}"
-  exit "$exit_code"
-}
-trap on_error ERR
-
-#######################################
-# Aide
-#######################################
-usage() {
-  cat <<'EOF'
-Usage:
-  bootstrap-backup-env.sh [options]
-
-Options dépôt :
-  --repo-url URL
-  --repo-branch BRANCH
-  --repo-subdir PATH
-
-Options installation :
-  --install-dir PATH
-  --deploy-user USER
-  --deploy-group GROUP
-  --env-file-name NAME
-  --force-chown true|false
-  --non-interactive true|false
-
-Options configuration applicative :
-  --env-name NAME
-  --pghost HOST
-  --pgport PORT
-  --pguser USER
-  --pgpassword PASSWORD
-  --dbs "sirh inventory ferme"
-  --backup-remote-user USER
-  --backup-remote-host HOST
-  --backup-remote-dir PATH
-  --ssh-connect-timeout SECONDS
-  --retention-days DAYS
-  --discord-webhook-url URL
-  --discord-ping VALUE
-  --webhook-url URL
-  --vaultwarden-data-dir PATH
-  --check-storage-paths "/ /var /home"
-  --app-1-name NAME
-  --app-1-url URL
-  --app-2-name NAME
-  --app-2-url URL
-  --app-3-name NAME
-  --app-3-url URL
-
-Options bootstrap SSH distant :
-  --bootstrap-ssh-user USER
-  --bootstrap-ssh-port PORT
-  --bootstrap-ssh-key PATH
-  --bootstrap-ssh-strict accept-new|yes|no
-  --install-backup-key-on-remote true|false
-
-Divers :
-  --help
-
-Notes :
-  - si le script est lancé localement en mode interactif, il posera les
-    questions nécessaires pour compléter les champs obligatoires ;
-  - la clé publique backup peut être installée automatiquement sur le serveur
-    distant uniquement si un accès SSH bootstrap existe déjà ;
-  - le .env peut être rempli automatiquement si les valeurs sont passées en
-    arguments ou via variables d'environnement avant exécution.
-EOF
-}
-
-#######################################
-# Parsing arguments
-#######################################
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --repo-url) REPO_URL="${2:-}"; shift 2 ;;
-    --repo-branch) REPO_BRANCH="${2:-}"; shift 2 ;;
-    --repo-subdir) REPO_SUBDIR="${2:-}"; shift 2 ;;
-    --install-dir) INSTALL_DIR="${2:-}"; shift 2 ;;
-    --deploy-user) DEPLOY_USER="${2:-}"; shift 2 ;;
-    --deploy-group) DEPLOY_GROUP="${2:-}"; shift 2 ;;
-    --env-file-name) ENV_FILE_NAME="${2:-}"; shift 2 ;;
-    --force-chown) FORCE_CHOWN="${2:-}"; shift 2 ;;
-    --non-interactive) NON_INTERACTIVE="${2:-}"; shift 2 ;;
-
-    --env-name) ENV_NAME="${2:-}"; shift 2 ;;
-    --pghost) PGHOST="${2:-}"; shift 2 ;;
-    --pgport) PGPORT="${2:-}"; shift 2 ;;
-    --pguser) PGUSER_VALUE="${2:-}"; shift 2 ;;
-    --pgpassword) PGPASSWORD_VALUE="${2:-}"; shift 2 ;;
-    --dbs) DBS_VALUE="${2:-}"; shift 2 ;;
-    --backup-remote-user) BACKUP_REMOTE_USER="${2:-}"; shift 2 ;;
-    --backup-remote-host) BACKUP_REMOTE_HOST="${2:-}"; shift 2 ;;
-    --backup-remote-dir) BACKUP_REMOTE_DIR="${2:-}"; shift 2 ;;
-    --ssh-connect-timeout) SSH_CONNECT_TIMEOUT="${2:-}"; shift 2 ;;
-    --retention-days) RETENTION_DAYS="${2:-}"; shift 2 ;;
-    --discord-webhook-url) DISCORD_WEBHOOK_URL_VALUE="${2:-}"; shift 2 ;;
-    --discord-ping) DISCORD_PING_VALUE="${2:-}"; shift 2 ;;
-    --webhook-url) WEBHOOK_URL_VALUE="${2:-}"; shift 2 ;;
-    --vaultwarden-data-dir) VAULTWARDEN_DATA_DIR_VALUE="${2:-}"; shift 2 ;;
-    --check-storage-paths) CHECK_STORAGE_PATHS_VALUE="${2:-}"; shift 2 ;;
-    --app-1-name) APP_1_NAME_VALUE="${2:-}"; shift 2 ;;
-    --app-1-url) APP_1_URL_VALUE="${2:-}"; shift 2 ;;
-    --app-2-name) APP_2_NAME_VALUE="${2:-}"; shift 2 ;;
-    --app-2-url) APP_2_URL_VALUE="${2:-}"; shift 2 ;;
-    --app-3-name) APP_3_NAME_VALUE="${2:-}"; shift 2 ;;
-    --app-3-url) APP_3_URL_VALUE="${2:-}"; shift 2 ;;
-
-    --bootstrap-ssh-user) BOOTSTRAP_SSH_USER="${2:-}"; shift 2 ;;
-    --bootstrap-ssh-port) BOOTSTRAP_SSH_PORT="${2:-}"; shift 2 ;;
-    --bootstrap-ssh-key) BOOTSTRAP_SSH_KEY="${2:-}"; shift 2 ;;
-    --bootstrap-ssh-strict) BOOTSTRAP_SSH_STRICT="${2:-}"; shift 2 ;;
-    --install-backup-key-on-remote) INSTALL_BACKUP_KEY_ON_REMOTE="${2:-}"; shift 2 ;;
-
-    --help|-h) usage; exit 0 ;;
-    *) die "Option inconnue : $1" ;;
-  esac
-done
-
-#######################################
-# Surcharge par variables d'environnement
-#######################################
-PGPASSWORD_VALUE="${PGPASSWORD_VALUE:-${PGPASSWORD:-}}"
-DISCORD_WEBHOOK_URL_VALUE="${DISCORD_WEBHOOK_URL_VALUE:-${DISCORD_WEBHOOK_URL:-}}"
-DISCORD_PING_VALUE="${DISCORD_PING_VALUE:-${DISCORD_PING:-}}"
-WEBHOOK_URL_VALUE="${WEBHOOK_URL_VALUE:-${WEBHOOK_URL:-}}"
-
-#######################################
-# Détection mode interactif local
-#######################################
-is_interactive() {
-  [[ -t 0 && -t 1 && "${NON_INTERACTIVE}" != "true" ]]
-}
-
-#######################################
-# Questions interactives
-#######################################
-prompt_value() {
-  local var_name="$1"
-  local prompt_label="$2"
-  local default_value="${3:-}"
-  local secret="${4:-false}"
-  local required="${5:-false}"
-
-  local current_value
-  current_value="${!var_name:-}"
-
-  if [[ -n "$current_value" ]]; then
-    return 0
-  fi
-
-  if ! is_interactive; then
-    if [[ "$required" == "true" ]]; then
-      die "Valeur obligatoire manquante : ${var_name}. Fournissez-la en argument ou variable d'environnement."
-    fi
-    return 0
-  fi
-
-  local input=""
-  while true; do
-    if [[ "$secret" == "true" ]]; then
-      if [[ -n "$default_value" ]]; then
-        read -r -s -p "${prompt_label} [valeur masquée, Entrée pour conserver la valeur par défaut] : " input
-      else
-        read -r -s -p "${prompt_label} : " input
-      fi
-      echo
-    else
-      if [[ -n "$default_value" ]]; then
-        read -r -p "${prompt_label} [${default_value}] : " input
-      else
-        read -r -p "${prompt_label} : " input
-      fi
-    fi
-
-    if [[ -z "$input" && -n "$default_value" ]]; then
-      input="$default_value"
-    fi
-
-    if [[ "$required" == "true" && -z "$input" ]]; then
-      warn "Cette valeur est obligatoire."
-      continue
-    fi
-
-    printf -v "$var_name" '%s' "$input"
-    break
-  done
-}
-
-ask_required_local_configuration() {
-  if ! is_interactive; then
-    return 0
-  fi
-
-  log "Mode interactif local détecté : collecte des données obligatoires."
-
-  prompt_value REPO_URL "URL SSH du dépôt Git privé" "$REPO_URL" false true
-  prompt_value REPO_BRANCH "Branche Git" "$REPO_BRANCH" false true
-  prompt_value REPO_SUBDIR "Sous-dossier du dépôt contenant les scripts" "$REPO_SUBDIR" false true
-  prompt_value INSTALL_DIR "Répertoire d'installation" "$INSTALL_DIR" false true
-  prompt_value DEPLOY_USER "Utilisateur propriétaire du déploiement" "$DEPLOY_USER" false true
-
-  if [[ -z "$DEPLOY_GROUP" ]]; then
-    local deploy_group_default=""
-    if id "$DEPLOY_USER" >/dev/null 2>&1; then
-      deploy_group_default="$(id -gn "$DEPLOY_USER")"
-    fi
-    prompt_value DEPLOY_GROUP "Groupe propriétaire" "$deploy_group_default" false true
-  fi
-
-  prompt_value ENV_NAME "Nom de l'environnement" "$ENV_NAME" false true
-  prompt_value PGHOST "Host PostgreSQL" "$PGHOST" false true
-  prompt_value PGPORT "Port PostgreSQL" "$PGPORT" false true
-
-  if [[ -z "$PGUSER_VALUE" ]]; then
-    prompt_value PGUSER_VALUE "Utilisateur PostgreSQL" "$DEPLOY_USER" false true
-  fi
-
-  prompt_value PGPASSWORD_VALUE "Mot de passe PostgreSQL (PGPASSWORD)" "" true true
-  prompt_value DBS_VALUE "Bases PostgreSQL à gérer (séparées par des espaces)" "$DBS_VALUE" false true
-
-  prompt_value BACKUP_REMOTE_USER "Utilisateur du serveur de sauvegarde" "$BACKUP_REMOTE_USER" false true
-  prompt_value BACKUP_REMOTE_HOST "Host/IP du serveur de sauvegarde" "$BACKUP_REMOTE_HOST" false true
-  prompt_value BACKUP_REMOTE_DIR "Répertoire distant de sauvegarde" "$BACKUP_REMOTE_DIR" false true
-
-  prompt_value SSH_CONNECT_TIMEOUT "Timeout SSH en secondes" "$SSH_CONNECT_TIMEOUT" false true
-  prompt_value RETENTION_DAYS "Rétention en jours" "$RETENTION_DAYS" false true
-
-  prompt_value VAULTWARDEN_DATA_DIR_VALUE "Répertoire des données Vaultwarden" "$VAULTWARDEN_DATA_DIR_VALUE" false true
-  prompt_value CHECK_STORAGE_PATHS_VALUE "Chemins à surveiller pour le stockage" "$CHECK_STORAGE_PATHS_VALUE" false true
-
-  prompt_value APP_1_NAME_VALUE "Nom application 1" "$APP_1_NAME_VALUE" false true
-  prompt_value APP_1_URL_VALUE "URL application 1" "$APP_1_URL_VALUE" false true
-  prompt_value APP_2_NAME_VALUE "Nom application 2" "$APP_2_NAME_VALUE" false true
-  prompt_value APP_2_URL_VALUE "URL application 2" "$APP_2_URL_VALUE" false true
-  prompt_value APP_3_NAME_VALUE "Nom application 3" "$APP_3_NAME_VALUE" false true
-  prompt_value APP_3_URL_VALUE "URL application 3" "$APP_3_URL_VALUE" false true
-
-  prompt_value DISCORD_WEBHOOK_URL_VALUE "Discord webhook URL (optionnel)" "$DISCORD_WEBHOOK_URL_VALUE" true false
-  prompt_value DISCORD_PING_VALUE "Discord ping (optionnel)" "$DISCORD_PING_VALUE" false false
-  prompt_value WEBHOOK_URL_VALUE "Webhook URL générique (optionnel)" "$WEBHOOK_URL_VALUE" true false
-
-  if [[ "$INSTALL_BACKUP_KEY_ON_REMOTE" == "true" ]]; then
-    prompt_value BOOTSTRAP_SSH_USER "Utilisateur SSH bootstrap pour installer la clé distante" "${BOOTSTRAP_SSH_USER:-$BACKUP_REMOTE_USER}" false true
-    prompt_value BOOTSTRAP_SSH_PORT "Port SSH bootstrap" "$BOOTSTRAP_SSH_PORT" false true
-    prompt_value BOOTSTRAP_SSH_KEY "Chemin de la clé SSH bootstrap (optionnel si agent SSH ou accès existant)" "$BOOTSTRAP_SSH_KEY" false false
-  fi
-}
-
-#######################################
-# Vérifications initiales
-#######################################
-validate_required_values() {
-  [[ -n "$REPO_URL" ]] || die "L'option --repo-url est obligatoire."
-  [[ -n "$REPO_SUBDIR" ]] || die "L'option --repo-subdir est obligatoire."
-  [[ -n "$BACKUP_REMOTE_HOST" ]] || die "L'option --backup-remote-host est obligatoire."
-  [[ -n "$DEPLOY_USER" ]] || die "L'utilisateur de déploiement est obligatoire."
-
-  if ! id "$DEPLOY_USER" >/dev/null 2>&1; then
-    die "Utilisateur inexistant : $DEPLOY_USER"
-  fi
-
-  if [[ -z "$DEPLOY_GROUP" ]]; then
-    DEPLOY_GROUP="$(id -gn "$DEPLOY_USER")"
-  fi
-
-  if [[ -z "$PGUSER_VALUE" ]]; then
-    PGUSER_VALUE="$DEPLOY_USER"
-  fi
-}
-
-#######################################
-# Chemins calculés
-#######################################
-compute_paths() {
-  BASE_DIR="$INSTALL_DIR"
-  REPO_DIR="$BASE_DIR/$GIT_DIR_NAME"
-  APP_SCRIPTS_DIR="$BASE_DIR/$SCRIPTS_DIR_NAME"
-  CONFIG_DIR="$BASE_DIR/$CONFIG_DIR_NAME"
-  LOG_DIR="$BASE_DIR/$LOG_DIR_NAME"
-  DATA_DIR="$BASE_DIR/$DATA_DIR_NAME"
-  TMP_DIR="$BASE_DIR/$TMP_DIR_NAME"
-  APP_SSH_DIR="$BASE_DIR/$SSH_DIR_NAME"
-  ENV_FILE="$BASE_DIR/$ENV_FILE_NAME"
-  SCRIPTS_JSON="$CONFIG_DIR/scripts.json"
-
-  BACKUP_SSH_KEY="$APP_SSH_DIR/$BACKUP_SSH_KEY_NAME"
-  REPO_SSH_KEY="$APP_SSH_DIR/$REPO_SSH_KEY_NAME"
-}
-
-#######################################
-# Wrapper sudo
-#######################################
-run_root() {
-  if [[ "$(id -u)" -eq 0 ]]; then
-    "$@"
-  else
-    sudo "$@"
-  fi
-}
-
-run_as_deploy_user() {
-  if [[ "$(id -un)" == "$DEPLOY_USER" ]]; then
-    "$@"
-  else
-    run_root sudo -u "$DEPLOY_USER" -H "$@"
-  fi
-}
-
-#######################################
-# Détection package manager
-#######################################
-detect_pkg_manager() {
-  if command -v apt-get >/dev/null 2>&1; then
-    echo "apt"
-  elif command -v dnf >/dev/null 2>&1; then
-    echo "dnf"
-  elif command -v yum >/dev/null 2>&1; then
-    echo "yum"
-  elif command -v apk >/dev/null 2>&1; then
-    echo "apk"
-  elif command -v pacman >/dev/null 2>&1; then
-    echo "pacman"
-  else
-    echo ""
-  fi
-}
-
-install_packages() {
-  local packages=("$@")
-  [[ ${#packages[@]} -gt 0 ]] || return 0
-
-  case "$PKG_MANAGER" in
-    apt)
-      run_root apt-get update -y
-      run_root apt-get install -y "${packages[@]}"
-      ;;
-    dnf)
-      run_root dnf install -y "${packages[@]}"
-      ;;
-    yum)
-      run_root yum install -y "${packages[@]}"
-      ;;
-    apk)
-      run_root apk add --no-cache "${packages[@]}"
-      ;;
-    pacman)
-      run_root pacman -Sy --noconfirm "${packages[@]}"
-      ;;
-    *)
-      die "Package manager non géré : $PKG_MANAGER"
-      ;;
-  esac
-}
-
-ensure_cmd() {
-  local cmd="$1"
-  shift
-  local packages=("$@")
-
-  if command -v "$cmd" >/dev/null 2>&1; then
-    log "Dépendance OK : $cmd"
-  else
-    warn "Dépendance absente : $cmd"
-    install_packages "${packages[@]}"
-  fi
-}
-
-install_dependencies() {
-  case "$PKG_MANAGER" in
-    apt)
-      ensure_cmd git git
-      ensure_cmd ssh openssh-client
-      ensure_cmd ssh-keygen openssh-client
-      ensure_cmd rsync rsync
-      ensure_cmd curl curl
-      ensure_cmd jq jq
-      ensure_cmd psql postgresql-client
-      install_packages ca-certificates
-      ;;
-    dnf|yum)
-      ensure_cmd git git
-      ensure_cmd ssh openssh-clients
-      ensure_cmd ssh-keygen openssh-clients
-      ensure_cmd rsync rsync
-      ensure_cmd curl curl
-      ensure_cmd jq jq
-      ensure_cmd psql postgresql
-      install_packages ca-certificates
-      ;;
-    apk)
-      ensure_cmd git git
-      ensure_cmd ssh openssh-client
-      ensure_cmd ssh-keygen openssh-keygen
-      ensure_cmd rsync rsync
-      ensure_cmd curl curl
-      ensure_cmd jq jq
-      ensure_cmd psql postgresql-client
-      install_packages ca-certificates
-      ;;
-    pacman)
-      ensure_cmd git git
-      ensure_cmd ssh openssh
-      ensure_cmd ssh-keygen openssh
-      ensure_cmd rsync rsync
-      ensure_cmd curl curl
-      ensure_cmd jq jq
-      ensure_cmd psql postgresql-libs
-      install_packages ca-certificates
-      ;;
-  esac
-}
-
-#######################################
-# Création dossiers
-#######################################
-ensure_dir() {
-  local dir="$1"
-  local mode="$2"
-
-  run_root mkdir -p "$dir"
-  run_root chmod "$mode" "$dir"
-}
-
-prepare_directories() {
-  ensure_dir "$BASE_DIR" 0755
-  ensure_dir "$REPO_DIR" 0755
-  ensure_dir "$APP_SCRIPTS_DIR" 0750
-  ensure_dir "$CONFIG_DIR" 0750
-  ensure_dir "$LOG_DIR" 0750
-  ensure_dir "$DATA_DIR" 0750
-  ensure_dir "$TMP_DIR" 0750
-  ensure_dir "$APP_SSH_DIR" 0700
-}
-
-#######################################
-# Permissions
-#######################################
-apply_ownership() {
-  if [[ "$FORCE_CHOWN" == "true" ]]; then
-    run_root chown -R "${DEPLOY_USER}:${DEPLOY_GROUP}" "$BASE_DIR"
-  else
-    run_root chown "${DEPLOY_USER}:${DEPLOY_GROUP}" \
-      "$BASE_DIR" "$REPO_DIR" "$APP_SCRIPTS_DIR" "$CONFIG_DIR" \
-      "$LOG_DIR" "$DATA_DIR" "$TMP_DIR" "$APP_SSH_DIR"
-  fi
-}
-
-#######################################
-# SSH
-#######################################
-ensure_ssh_keypair() {
-  local private_key="$1"
-  local comment="$2"
-
-  if [[ -f "$private_key" && -f "${private_key}.pub" ]]; then
-    log "Clé SSH déjà présente : $private_key"
-    run_root chmod 600 "$private_key"
-    run_root chmod 644 "${private_key}.pub"
-    run_root chown "${DEPLOY_USER}:${DEPLOY_GROUP}" "$private_key" "${private_key}.pub"
-    return 0
-  fi
-
-  log "Génération de la clé SSH : $private_key"
-  run_root ssh-keygen -t ed25519 -N "" -C "$comment" -f "$private_key" >/dev/null
-  run_root chmod 600 "$private_key"
-  run_root chmod 644 "${private_key}.pub"
-  run_root chown "${DEPLOY_USER}:${DEPLOY_GROUP}" "$private_key" "${private_key}.pub"
-}
-
-build_bootstrap_ssh_cmd() {
-  local target="$1"
-  local -a cmd=(ssh -p "$BOOTSTRAP_SSH_PORT" -o "StrictHostKeyChecking=$BOOTSTRAP_SSH_STRICT")
-
-  if [[ -n "$BOOTSTRAP_SSH_KEY" ]]; then
-    cmd+=(-i "$BOOTSTRAP_SSH_KEY" -o IdentitiesOnly=yes)
-  fi
-
-  cmd+=("$target")
-  printf '%q ' "${cmd[@]}"
-}
-
-install_backup_key_on_remote() {
-  [[ "$INSTALL_BACKUP_KEY_ON_REMOTE" == "true" ]] || {
-    log "Installation de la clé backup sur le serveur distant désactivée."
-    return 0
-  }
-
-  [[ -n "$BACKUP_REMOTE_HOST" ]] || {
-    warn "BACKUP_REMOTE_HOST vide, installation de la clé distante ignorée."
-    return 0
-  }
-
-  local bootstrap_user="${BOOTSTRAP_SSH_USER:-$BACKUP_REMOTE_USER}"
-  local remote_target="${bootstrap_user}@${BACKUP_REMOTE_HOST}"
-  local remote_auth_user="$BACKUP_REMOTE_USER"
-  local pubkey
-
-  pubkey="$(run_root cat "${BACKUP_SSH_KEY}.pub")"
-
-  log "Tentative d'installation de la clé publique backup sur ${remote_auth_user}@${BACKUP_REMOTE_HOST}"
-
-  local ssh_cmd
-  ssh_cmd="$(build_bootstrap_ssh_cmd "$remote_target")"
-
-  if ! eval "$ssh_cmd" "true" >/dev/null 2>&1; then
-    warn "Accès SSH bootstrap indisponible vers ${remote_target}. Clé backup non installée automatiquement."
-    return 0
-  fi
-
-  local escaped_pubkey
-  escaped_pubkey="$(printf '%q' "$pubkey")"
-
-  eval "$ssh_cmd" "sudo -u '$remote_auth_user' sh -c '
-    set -eu
-    umask 077
-    mkdir -p ~/.ssh
-    touch ~/.ssh/authorized_keys
-    chmod 700 ~/.ssh
-    chmod 600 ~/.ssh/authorized_keys
-    grep -qxF $escaped_pubkey ~/.ssh/authorized_keys || printf \"%s\n\" $escaped_pubkey >> ~/.ssh/authorized_keys
-  '" >/dev/null
-
-  log "Clé publique backup installée / vérifiée sur ${remote_auth_user}@${BACKUP_REMOTE_HOST}"
-}
-
-#######################################
-# .env
-#######################################
-ensure_env_file() {
-  if [[ ! -f "$ENV_FILE" ]]; then
-    log "Création du fichier : $ENV_FILE"
-    run_root touch "$ENV_FILE"
-  fi
-
-  run_root chmod 0640 "$ENV_FILE"
-  run_root chown "${DEPLOY_USER}:${DEPLOY_GROUP}" "$ENV_FILE"
-}
-
-set_env_value() {
-  local key="$1"
-  local value="$2"
-  local escaped
-
-  escaped="$(printf '%s' "$value" | sed 's/[\/&]/\\&/g')"
-
-  if run_root grep -qE "^${key}=" "$ENV_FILE"; then
-    run_root sed -i "s/^${key}=.*/${key}=${escaped}/" "$ENV_FILE"
-  else
-    printf '%s=%s\n' "$key" "$value" | run_root tee -a "$ENV_FILE" >/dev/null
-  fi
-}
-
-update_env_defaults() {
-  set_env_value "ENV_NAME" "$ENV_NAME"
-
-  set_env_value "BASE_DIR" "$BASE_DIR"
-  set_env_value "SCRIPTS_DIR" "$APP_SCRIPTS_DIR"
-  set_env_value "CONFIG_DIR" "$CONFIG_DIR"
-  set_env_value "LOG_DIR" "$LOG_DIR"
-  set_env_value "DATA_DIR" "$DATA_DIR"
-  set_env_value "TMP_DIR" "$TMP_DIR"
-
-  set_env_value "SSH_DIR" "$APP_SSH_DIR"
-  set_env_value "SSH_KEY" "$BACKUP_SSH_KEY"
-  set_env_value "REPO_SSH_KEY" "$REPO_SSH_KEY"
-
-  set_env_value "PGHOST" "$PGHOST"
-  set_env_value "PGPORT" "$PGPORT"
-  set_env_value "PGUSER" "$PGUSER_VALUE"
-  set_env_value "PGPASSWORD" "${PGPASSWORD_VALUE:-change_me}"
-  set_env_value "DBS" "\"$DBS_VALUE\""
-
-  set_env_value "BACKUP_REMOTE_USER" "$BACKUP_REMOTE_USER"
-  set_env_value "BACKUP_REMOTE_HOST" "$BACKUP_REMOTE_HOST"
-  set_env_value "BACKUP_REMOTE_DIR" "$BACKUP_REMOTE_DIR"
-
-  set_env_value "SSH_CONNECT_TIMEOUT" "$SSH_CONNECT_TIMEOUT"
-  set_env_value "RETENTION_DAYS" "$RETENTION_DAYS"
-
-  set_env_value "DISCORD_WEBHOOK_URL" "$DISCORD_WEBHOOK_URL_VALUE"
-  set_env_value "DISCORD_PING" "$DISCORD_PING_VALUE"
-  set_env_value "WEBHOOK_URL" "$WEBHOOK_URL_VALUE"
-
-  set_env_value "VAULTWARDEN_DATA_DIR" "$VAULTWARDEN_DATA_DIR_VALUE"
-  set_env_value "CHECK_STORAGE_PATHS" "\"$CHECK_STORAGE_PATHS_VALUE\""
-
-  set_env_value "APP_1_NAME" "$APP_1_NAME_VALUE"
-  set_env_value "APP_1_URL" "$APP_1_URL_VALUE"
-  set_env_value "APP_2_NAME" "$APP_2_NAME_VALUE"
-  set_env_value "APP_2_URL" "$APP_2_URL_VALUE"
-  set_env_value "APP_3_NAME" "$APP_3_NAME_VALUE"
-  set_env_value "APP_3_URL" "$APP_3_URL_VALUE"
-}
-
-#######################################
-# Git privé + sparse checkout
-#######################################
-write_git_ssh_wrapper() {
-  local wrapper="$TMP_DIR/git_ssh_wrapper.sh"
-
-  cat > /tmp/.git_ssh_wrapper.$$ <<EOF
-#!/usr/bin/env bash
-exec ssh -i "$REPO_SSH_KEY" -o IdentitiesOnly=yes -o StrictHostKeyChecking=accept-new "\$@"
-EOF
-
-  run_root mv /tmp/.git_ssh_wrapper.$$ "$wrapper"
-  run_root chmod 0700 "$wrapper"
-  run_root chown "${DEPLOY_USER}:${DEPLOY_GROUP}" "$wrapper"
-
-  echo "$wrapper"
-}
-
-sync_repo() {
-  local wrapper
-  wrapper="$(write_git_ssh_wrapper)"
-
-  if [[ ! -d "$REPO_DIR/.git" ]]; then
-    log "Clone initial du dépôt"
-    run_root rm -rf "$REPO_DIR"
-    run_root mkdir -p "$REPO_DIR"
-    run_root chown "${DEPLOY_USER}:${DEPLOY_GROUP}" "$REPO_DIR"
-
-    run_as_deploy_user env GIT_SSH_COMMAND="$wrapper" \
-      git clone \
-      --filter=blob:none \
-      --no-checkout \
-      --branch "$REPO_BRANCH" \
-      "$REPO_URL" \
-      "$REPO_DIR"
-
-    run_as_deploy_user git -C "$REPO_DIR" sparse-checkout init --cone
-    run_as_deploy_user git -C "$REPO_DIR" sparse-checkout set "$REPO_SUBDIR"
-    run_as_deploy_user git -C "$REPO_DIR" checkout "$REPO_BRANCH"
-  else
-    log "Mise à jour du dépôt existant"
-    run_as_deploy_user git -C "$REPO_DIR" remote set-url origin "$REPO_URL"
-    run_as_deploy_user git -C "$REPO_DIR" sparse-checkout init --cone || true
-    run_as_deploy_user git -C "$REPO_DIR" sparse-checkout set "$REPO_SUBDIR"
-    run_as_deploy_user env GIT_SSH_COMMAND="$wrapper" \
-      git -C "$REPO_DIR" fetch origin "$REPO_BRANCH" --depth=1
-    run_as_deploy_user git -C "$REPO_DIR" checkout "$REPO_BRANCH"
-    run_as_deploy_user git -C "$REPO_DIR" reset --hard "origin/$REPO_BRANCH"
-    run_as_deploy_user git -C "$REPO_DIR" clean -fd
-  fi
-}
-
-#######################################
-# Déploiement scripts
-#######################################
-deploy_scripts() {
-  local source_dir="$REPO_DIR/$REPO_SUBDIR"
-  [[ -d "$source_dir" ]] || die "Sous-dossier introuvable : $source_dir"
-
-  local script
-  for script in "${EXPECTED_SCRIPTS[@]}"; do
-    [[ -f "$source_dir/$script" ]] || die "Script manquant dans le dépôt : $source_dir/$script"
-  done
-
-  for script in "${EXPECTED_SCRIPTS[@]}"; do
-    log "Déploiement : $script"
-    run_root install -m 0750 -o "$DEPLOY_USER" -g "$DEPLOY_GROUP" \
-      "$source_dir/$script" "$APP_SCRIPTS_DIR/$script"
-  done
-}
-
-verify_scripts() {
-  local script
-  for script in "${EXPECTED_SCRIPTS[@]}"; do
-    [[ -f "$APP_SCRIPTS_DIR/$script" ]] || die "Script absent après déploiement : $APP_SCRIPTS_DIR/$script"
-    [[ -x "$APP_SCRIPTS_DIR/$script" ]] || die "Script non exécutable : $APP_SCRIPTS_DIR/$script"
-  done
-}
-
-#######################################
-# Configuration web
-#######################################
-generate_scripts_json() {
-  local tmp_json
-  tmp_json="$(mktemp)"
-
-  cat > "$tmp_json" <<EOF
-{
-  "generated_at": "$(date -Iseconds)",
-  "base_dir": "$BASE_DIR",
-  "env_file": "$ENV_FILE",
-  "scripts": [
-    {
-      "id": "backup-vaultwarden",
-      "label": "Backup Vaultwarden",
-      "path": "$APP_SCRIPTS_DIR/backup-vaultwarden.sh",
-      "web_enabled": true,
-      "params": [
-        { "name": "env_file", "type": "string", "required": false, "default": "$ENV_FILE" },
-        { "name": "dry_run", "type": "boolean", "required": false, "default": false },
-        { "name": "json", "type": "boolean", "required": false, "default": true }
-      ]
-    },
-    {
-      "id": "check-storage",
-      "label": "Vérification stockage",
-      "path": "$APP_SCRIPTS_DIR/check-storage.sh",
-      "web_enabled": true,
-      "params": [
-        { "name": "env_file", "type": "string", "required": false, "default": "$ENV_FILE" },
-        { "name": "verbose", "type": "boolean", "required": false, "default": false },
-        { "name": "json", "type": "boolean", "required": false, "default": true }
-      ]
-    },
-    {
-      "id": "check-statut-recette",
-      "label": "Vérification statut recette",
-      "path": "$APP_SCRIPTS_DIR/check-statut-recette.sh",
-      "web_enabled": true,
-      "params": [
-        { "name": "env_file", "type": "string", "required": false, "default": "$ENV_FILE" },
-        { "name": "timeout", "type": "integer", "required": false, "default": 10 },
-        { "name": "json", "type": "boolean", "required": false, "default": true }
-      ]
-    },
-    {
-      "id": "backup-bdd-recette",
-      "label": "Backup BDD recette",
-      "path": "$APP_SCRIPTS_DIR/backup-bdd-recette.sh",
-      "web_enabled": true,
-      "params": [
-        { "name": "env_file", "type": "string", "required": false, "default": "$ENV_FILE" },
-        { "name": "db", "type": "select", "required": false, "values": ["sirh", "inventory", "ferme"] },
-        { "name": "dry_run", "type": "boolean", "required": false, "default": false },
-        { "name": "json", "type": "boolean", "required": false, "default": true }
-      ]
-    },
-    {
-      "id": "rebuild-bdd-recette",
-      "label": "Rebuild BDD recette",
-      "path": "$APP_SCRIPTS_DIR/rebuild-bdd-recette.sh",
-      "web_enabled": true,
-      "params": [
-        { "name": "env_file", "type": "string", "required": false, "default": "$ENV_FILE" },
-        { "name": "db", "type": "select", "required": true, "values": ["sirh", "inventory", "ferme"] },
-        { "name": "source", "type": "string", "required": false, "default": "latest" },
-        { "name": "force", "type": "boolean", "required": false, "default": false },
-        { "name": "json", "type": "boolean", "required": false, "default": true }
-      ]
-    }
-  ]
-}
-EOF
-
-  run_root mv "$tmp_json" "$SCRIPTS_JSON"
-  run_root chmod 0640 "$SCRIPTS_JSON"
-  run_root chown "${DEPLOY_USER}:${DEPLOY_GROUP}" "$SCRIPTS_JSON"
-}
-
-#######################################
-# Résumé
-#######################################
-print_summary() {
-  cat <<EOF
-
-========================================================================
-Bootstrap terminé
-========================================================================
-Utilisateur      : $DEPLOY_USER:$DEPLOY_GROUP
-Base             : $BASE_DIR
-Scripts          : $APP_SCRIPTS_DIR
-Config           : $CONFIG_DIR
-.env             : $ENV_FILE
-scripts.json     : $SCRIPTS_JSON
-Repo             : $REPO_DIR
-
-Clé SSH backup   : $BACKUP_SSH_KEY
-Clé SSH repo     : $REPO_SSH_KEY
-Remote backup    : ${BACKUP_REMOTE_USER}@${BACKUP_REMOTE_HOST}:${BACKUP_REMOTE_DIR}
-
-Clé publique repo :
-$(run_root cat "${REPO_SSH_KEY}.pub")
-
-Clé publique backup :
-$(run_root cat "${BACKUP_SSH_KEY}.pub")
-
-Vérifiez :
-  - la clé repo doit être ajoutée comme deploy key sur le dépôt Git privé ;
-  - la valeur PGPASSWORD dans $ENV_FILE ;
-  - les webhooks renseignés dans $ENV_FILE si nécessaires.
-========================================================================
-
-EOF
-}
-
-#######################################
-# Main
-#######################################
-main() {
-  ask_required_local_configuration
-  validate_required_values
-  compute_paths
-
-  PKG_MANAGER="$(detect_pkg_manager)"
-  [[ -n "$PKG_MANAGER" ]] || die "Gestionnaire de paquets non supporté."
-
-  log "Vérification / installation des dépendances"
-  install_dependencies
-
-  log "Création des répertoires"
-  prepare_directories
-
-  log "Préparation du .env"
-  ensure_env_file
-  update_env_defaults
-
-  log "Préparation des clés SSH"
-  ensure_ssh_keypair "$BACKUP_SSH_KEY" "${DEPLOY_USER}@backup-runtime"
-  ensure_ssh_keypair "$REPO_SSH_KEY" "${DEPLOY_USER}@repo-deploy"
-
-  log "Installation de la clé publique backup sur le serveur distant"
-  install_backup_key_on_remote
-
-  log "Synchronisation du dépôt Git privé"
-  sync_repo
-
-  log "Déploiement des scripts"
-  deploy_scripts
-  verify_scripts
-
-  log "Génération de la configuration web scripts.json"
-  generate_scripts_json
-
-  log "Application des permissions"
-  apply_ownership
-
-  print_summary
-}
-
-main "$@"
--- a/README.md
+++ b/README.md
@@ -1,43 +1,56 @@
-# Malio-Ops MALIO
-Ce dépôt sert au **versionnement des scripts utilisés dans l’infrastructure du projet Ferme**.
+# Malio-Ops

-L’objectif est de conserver un historique clair des scripts, suivre les évolutions et permettre leur amélioration progressive.
-
-## Contenu du dépôt
-
-Le dépôt peut contenir différents types de scripts utilisés pour l’exploitation technique :
-
-* scripts de **backup PostgreSQL**
-* scripts de **monitoring des applications**
-* scripts **d’automatisation système**
-* scripts **d’administration ou de maintenance**
+Ce depot centralise les scripts d'exploitation et de maintenance utilises pour l'infrastructure MALIO. Il sert de base de versionnement pour les sauvegardes, la supervision, les operations PostgreSQL et la reconstruction de bases.

 ## Objectif

-Ce dépôt permet de :
+Le depot permet de :

-* suivre les **modifications des scripts dans le temps**
-* garder une **version stable et reproductible**
-* faciliter la **maintenance et les corrections**
-* centraliser les scripts utilisés sur les serveurs
+* suivre les modifications des scripts dans le temps
+* conserver des versions stables et reproductibles
+* mutualiser la configuration et les bonnes pratiques d'exploitation
+* centraliser la documentation technique associee

-## Organisation
+## Structure du depot

-Les évolutions importantes sont documentées dans le fichier :
+Le depot est organise par dossier fonctionnel :

-```
-CHANGELOG.md
-```
+* [CheckStorage](CheckStorage) : surveillance de l'espace disque et alertes Discord
+* [BackupVaultWarden](BackupVaultWarden) : sauvegarde et transfert distant des donnees Vaultwarden
+* [RecetteScripts](RecetteScripts) : scripts historiques de backup, monitoring et rebuild pour l'environnement de recette
+* [RebuildBdd](RebuildBdd) : orchestration de reconstruction de bases PostgreSQL, bootstrap de cibles et checks de preparation

-Ce fichier décrit les nouvelles fonctionnalités, corrections et modifications apportées aux scripts.
+## Focus RebuildBdd

-## Remarque
+Le dossier [RebuildBdd](RebuildBdd) regroupe la nouvelle chaine de reconstruction de base. Il contient notamment :

-Ce dépôt est dédié au **versionnement des scripts uniquement**.
-Les configurations sensibles (mots de passe, clés, variables d’environnement) ne doivent pas être stockées directement dans le dépôt et doivent être placées dans des fichiers `.env` locaux.
+* [run-rebuild-bdd.sh](/home/matte/Malio-ops/RebuildBdd/run-rebuild-bdd.sh) : point d'entree principal
+* [rebuild-bdd-core.sh](/home/matte/Malio-ops/RebuildBdd/rebuild-bdd-core.sh) : logique de restauration
+* [bootstrap-target-host.sh](/home/matte/Malio-ops/RebuildBdd/bootstrap-target-host.sh) : preparation de la machine cible
+* [create-target-config.sh](/home/matte/Malio-ops/RebuildBdd/create-target-config.sh) : generation de configuration cible
+* [Checkup](RebuildBdd/Checkup) : scripts de verification prealable
+* [Config](RebuildBdd/Config) : fichiers d'exemple de configuration globale et par cible

-Ce projet contient des scripts pour la gestion et la maintenance des serveurs de MALIO.
+La documentation detaillee est disponible dans [RebuildBdd/README.md](/home/matte/Malio-ops/RebuildBdd/README.md).

+## Prerequis

-## Scripts disponibles
-*  [CheckStorage] : Script de vérification de l'espace de stockage
+Les scripts du depot reposent principalement sur :
+
+* `bash`
+* `jq`
+* `curl`
+* `ssh`
+* `scp`
+
+Selon les scripts, d'autres outils peuvent etre necessaires, notamment PostgreSQL (`psql`, `pg_dump`, `pg_restore`) ou `tar`.
+
+## Configuration
+
+Un modele commun est disponible dans [global.env.exemple](global.env.exemple). Il sert de base pour les variables partagees entre plusieurs scripts.
+
+Chaque dossier peut aussi contenir son propre fichier `.env.exemple` ou ses propres fichiers de configuration. Les secrets et webhooks ne doivent jamais etre versionnes dans git et doivent rester dans des fichiers locaux ignores.
+
+## Documentation
+
+Les evolutions importantes sont suivies dans [CHANGELOG.md](CHANGELOG.md).
--- a/RebuildBdd/Checkup/check-postgresql.sh
+++ b/RebuildBdd/Checkup/check-postgresql.sh
@@ -0,0 +1,221 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+DEFAULT_ENV_FILE="${REPO_DIR}/.env"
+
+ENV_FILE="${ENV_FILE:-$DEFAULT_ENV_FILE}"
+CLI_REQUEST_ID=""
+NON_INTERACTIVE="${NON_INTERACTIVE:-no}"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --env-file)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --env-file" >&2; exit 1; }
+      ENV_FILE="$2"
+      shift 2
+      ;;
+    --request-id)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --request-id" >&2; exit 1; }
+      CLI_REQUEST_ID="$2"
+      shift 2
+      ;;
+    --non-interactive)
+      NON_INTERACTIVE="yes"
+      shift
+      ;;
+    *)
+      echo "Argument inconnu : $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+log() {
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
+}
+
+fail() {
+  log "ERROR: $*" >&2
+  exit 1
+}
+
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+postgres_server_ready() {
+  require_cmd postgres || return 1
+  require_cmd pg_ctlcluster || return 1
+  require_cmd pg_lsclusters || return 1
+  return 0
+}
+
+ensure_postgres_cluster() {
+  if ! require_cmd pg_lsclusters || ! require_cmd pg_createcluster; then
+    return 0
+  fi
+
+  if pg_lsclusters --no-header 2>/dev/null | grep -q .; then
+    return 0
+  fi
+
+  local version=""
+  if [[ -d /etc/postgresql ]]; then
+    version="$(find /etc/postgresql -mindepth 1 -maxdepth 1 -type d -printf '%f\n' | LC_ALL=C sort -V | tail -n 1)"
+  fi
+
+  if [[ -z "$version" ]] && require_cmd psql; then
+    version="$(psql --version 2>/dev/null | awk '{print $3}' | cut -d. -f1)"
+  fi
+
+  [[ -n "$version" ]] || return 1
+
+  log "Aucun cluster PostgreSQL détecté, création de ${version}/main..."
+  "$SUDO_BIN" pg_createcluster "$version" main --start >/dev/null 2>&1 || return 1
+  return 0
+}
+
+collect_postgres_diagnostics() {
+  local diagnostics=""
+
+  if "$SUDO_BIN" systemctl status "$POSTGRES_SERVICE_NAME" --no-pager >/dev/null 2>&1; then
+    diagnostics+="systemctl status ${POSTGRES_SERVICE_NAME}: OK; "
+  elif require_cmd systemctl; then
+    diagnostics+="systemctl status ${POSTGRES_SERVICE_NAME}: $( "$SUDO_BIN" systemctl status "$POSTGRES_SERVICE_NAME" --no-pager 2>/dev/null | tail -n 5 | tr '\n' ' ' ); "
+  fi
+
+  if require_cmd pg_lsclusters; then
+    diagnostics+="pg_lsclusters: $(pg_lsclusters --no-header 2>/dev/null | tr '\n' ' '); "
+  fi
+
+  if require_cmd journalctl; then
+    diagnostics+="journalctl: $( "$SUDO_BIN" journalctl -u "$POSTGRES_SERVICE_NAME" -n 10 --no-pager 2>/dev/null | tr '\n' ' ' ); "
+  fi
+
+  printf '%s' "${diagnostics% }"
+}
+
+start_postgres_service() {
+  if "$SUDO_BIN" systemctl start "$POSTGRES_SERVICE_NAME" >/dev/null 2>&1; then
+    return 0
+  fi
+
+  if require_cmd service && "$SUDO_BIN" service "$POSTGRES_SERVICE_NAME" start >/dev/null 2>&1; then
+    return 0
+  fi
+
+  if require_cmd pg_lsclusters && require_cmd pg_ctlcluster; then
+    local version cluster
+    while read -r version cluster _; do
+      [[ -n "$version" && -n "$cluster" ]] || continue
+      if "$SUDO_BIN" pg_ctlcluster "$version" "$cluster" start >/dev/null 2>&1; then
+        return 0
+      fi
+    done < <(pg_lsclusters --no-header 2>/dev/null || true)
+  fi
+
+  return 1
+}
+
+[[ -f "$ENV_FILE" ]] || fail "fichier .env introuvable : $ENV_FILE"
+
+set -a
+# shellcheck disable=SC1090
+source "$ENV_FILE"
+set +a
+
+: "${PGHOST:?Variable PGHOST manquante}"
+: "${PGPORT:?Variable PGPORT manquante}"
+: "${PGUSER:?Variable PGUSER manquante}"
+: "${PGPASSWORD:?Variable PGPASSWORD manquante}"
+
+AUTO_INSTALL_POSTGRES="${AUTO_INSTALL_POSTGRES:-yes}"
+AUTO_CREATE_PGUSER="${AUTO_CREATE_PGUSER:-yes}"
+PGUSER_SUPERUSER="${PGUSER_SUPERUSER:-no}"
+POSTGRES_PACKAGE_LIST="${POSTGRES_PACKAGE_LIST:-postgresql postgresql-client postgresql-contrib}"
+POSTGRES_SERVICE_NAME="${POSTGRES_SERVICE_NAME:-postgresql}"
+SUDO_BIN="${SUDO_BIN:-sudo}"
+
+export PGPASSWORD
+
+if ! require_cmd "$SUDO_BIN"; then
+  fail "sudo absent sur la cible"
+fi
+
+if ! "$SUDO_BIN" /usr/bin/systemctl --version >/dev/null 2>&1; then
+  fail "sudo indisponible pour systemctl"
+fi
+
+if [[ ! "$PGPORT" =~ ^[0-9]+$ ]]; then
+  fail "PGPORT invalide : $PGPORT"
+fi
+
+POSTGRES_INSTALLED="no"
+
+if ! require_cmd psql || ! require_cmd pg_restore || ! require_cmd createdb || ! require_cmd dropdb || ! postgres_server_ready; then
+  [[ "${AUTO_INSTALL_POSTGRES,,}" == "yes" ]] || fail "PostgreSQL absent et AUTO_INSTALL_POSTGRES=no"
+
+  log "PostgreSQL absent : installation en cours..."
+  "$SUDO_BIN" apt update >/dev/null 2>&1 || fail "échec de apt update"
+  "$SUDO_BIN" apt install -y $POSTGRES_PACKAGE_LIST >/dev/null 2>&1 || fail "échec de l'installation PostgreSQL"
+  POSTGRES_INSTALLED="yes"
+  log "Installation PostgreSQL terminée."
+else
+  log "PostgreSQL déjà installé."
+fi
+
+ensure_postgres_cluster || fail "aucun cluster PostgreSQL disponible et création automatique impossible"
+
+if ! "$SUDO_BIN" systemctl is-active --quiet "$POSTGRES_SERVICE_NAME"; then
+  log "Démarrage du service PostgreSQL..."
+  if ! start_postgres_service; then
+    fail "impossible de démarrer PostgreSQL. $(collect_postgres_diagnostics)"
+  fi
+else
+  log "Service PostgreSQL déjà actif."
+fi
+
+log "Vérification de la disponibilité de PostgreSQL..."
+for _ in {1..20}; do
+  if "$SUDO_BIN" -u postgres psql -d postgres -c "SELECT 1;" >/dev/null 2>&1; then
+    log "PostgreSQL répond correctement."
+    break
+  fi
+  sleep 1
+done
+
+if ! "$SUDO_BIN" -u postgres psql -d postgres -c "SELECT 1;" >/dev/null 2>&1; then
+  fail "PostgreSQL ne répond pas correctement"
+fi
+
+if [[ "${AUTO_CREATE_PGUSER,,}" == "yes" ]]; then
+  ROLE_EXISTS="$(
+    "$SUDO_BIN" -u postgres psql -d postgres -tAc \
+      "SELECT 1 FROM pg_roles WHERE rolname='${PGUSER//\'/\'\'}'" 2>/dev/null || true
+  )"
+
+  if [[ "$ROLE_EXISTS" != "1" ]]; then
+    log "Création du rôle PostgreSQL ${PGUSER}..."
+
+    ROLE_ATTRIBUTES="LOGIN CREATEDB CREATEROLE"
+    if [[ "${PGUSER_SUPERUSER,,}" == "yes" ]]; then
+      ROLE_ATTRIBUTES="LOGIN SUPERUSER CREATEDB CREATEROLE"
+    fi
+
+    "$SUDO_BIN" -u postgres psql -d postgres -c \
+      "CREATE ROLE \"${PGUSER}\" WITH ${ROLE_ATTRIBUTES} PASSWORD '${PGPASSWORD//\'/\'\'}';" \
+      >/dev/null 2>&1 || fail "échec de création du rôle ${PGUSER}"
+
+    log "Rôle PostgreSQL ${PGUSER} créé."
+  else
+    log "Rôle PostgreSQL ${PGUSER} déjà présent."
+  fi
+fi
+
+if ! psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -c "SELECT 1;" >/dev/null 2>&1; then
+  fail "connexion PostgreSQL locale impossible avec PGUSER=${PGUSER}"
+fi
+
+log "Check PostgreSQL terminé avec succès."
--- a/RebuildBdd/Checkup/check-target-readiness.sh
+++ b/RebuildBdd/Checkup/check-target-readiness.sh
@@ -0,0 +1,336 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+###############################################################################
+# check-target-readiness.sh
+#
+# Prépare la machine cible pour permettre l'exécution non interactive du
+# script de rebuild depuis une interface web.
+###############################################################################
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+DEFAULT_ENV_FILE="${REPO_DIR}/.env"
+
+ENV_FILE="${ENV_FILE:-$DEFAULT_ENV_FILE}"
+CLI_REQUEST_ID=""
+NON_INTERACTIVE="${NON_INTERACTIVE:-no}"
+JSON_ONLY="${JSON_ONLY:-no}"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --env-file)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --env-file" >&2; exit 1; }
+      ENV_FILE="$2"
+      shift 2
+      ;;
+    --request-id)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --request-id" >&2; exit 1; }
+      CLI_REQUEST_ID="$2"
+      shift 2
+      ;;
+    --non-interactive)
+      NON_INTERACTIVE="yes"
+      shift
+      ;;
+    --json-only)
+      JSON_ONLY="yes"
+      shift
+      ;;
+    *)
+      echo "Argument inconnu : $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+json_escape() {
+  python3 - <<'PY' "$1"
+import json, sys
+print(json.dumps(sys.argv[1]))
+PY
+}
+
+print_json_and_exit() {
+  local status="$1"
+  local message="$2"
+  local exit_code="$3"
+
+  printf '{'
+  printf '"status":%s,' "$(json_escape "$status")"
+  printf '"message":%s,' "$(json_escape "$message")"
+  printf '"request_id":%s,' "$(json_escape "${REQUEST_ID:-}")"
+  printf '"environment":%s,' "$(json_escape "${ENV_NAME:-}")"
+  printf '"log_file":%s' "$(json_escape "${LOG_FILE:-}")"
+  printf '}\n'
+  exit "$exit_code"
+}
+
+print_stdout() {
+  [[ "$JSON_ONLY" == "yes" ]] || echo "$*"
+}
+
+log() {
+  local msg="[$(date '+%Y-%m-%d %H:%M:%S')] $*"
+  echo "$msg" >>"$LOG_FILE"
+  print_stdout "$msg"
+}
+
+fail() {
+  log "ERROR: $*"
+  print_json_and_exit "error" "$*" 1
+}
+
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1 || fail "commande requise absente : $1"
+}
+
+to_bool_yes_no() {
+  local v="${1:-}"
+  v="${v,,}"
+  case "$v" in
+    yes|y|oui|o|true|1) echo "yes" ;;
+    no|n|non|false|0|"") echo "no" ;;
+    *) return 1 ;;
+  esac
+}
+
+require_env_vars() {
+  local missing=()
+  local var
+
+  for var in \
+    ENV_NAME PGHOST PGPORT PGUSER PGPASSWORD DBS \
+    BACKUP_REMOTE_USER BACKUP_REMOTE_HOST BACKUP_REMOTE_DIR \
+    SSH_KEY BACKUP_LOG_DIR
+  do
+    [[ -n "${!var:-}" ]] || missing+=("$var")
+  done
+
+  if (( ${#missing[@]} > 0 )); then
+    fail "variables .env manquantes : ${missing[*]}"
+  fi
+}
+
+validate_env_values() {
+  [[ "$PGPORT" =~ ^[0-9]+$ ]] || fail "PGPORT invalide"
+  [[ -n "$DBS" ]] || fail "DBS vide"
+  [[ "$PGUSER" =~ ^[a-zA-Z0-9_][a-zA-Z0-9_-]*$ ]] || fail "PGUSER invalide"
+  [[ -n "$BACKUP_REMOTE_HOST" ]] || fail "BACKUP_REMOTE_HOST vide"
+  [[ -n "$BACKUP_REMOTE_USER" ]] || fail "BACKUP_REMOTE_USER vide"
+  [[ -n "$BACKUP_REMOTE_DIR" ]] || fail "BACKUP_REMOTE_DIR vide"
+  BACKUP_REMOTE_SSH_PORT="${BACKUP_REMOTE_SSH_PORT:-22}"
+  [[ "$BACKUP_REMOTE_SSH_PORT" =~ ^[0-9]+$ ]] || fail "BACKUP_REMOTE_SSH_PORT invalide"
+}
+
+prepare_log_file() {
+  mkdir -p "$BACKUP_LOG_DIR" || {
+    echo '{"status":"error","message":"impossible de créer le dossier de logs"}'
+    exit 1
+  }
+
+  local ts safe_request_id
+  ts="$(date '+%Y-%m-%d_%H-%M-%S')"
+  safe_request_id="${REQUEST_ID:-manual}"
+  safe_request_id="${safe_request_id//[^a-zA-Z0-9_.-]/_}"
+
+  LOG_FILE="${BACKUP_LOG_DIR}/check_target_${ENV_NAME,,}_${safe_request_id}_${ts}.log"
+  touch "$LOG_FILE" || {
+    echo '{"status":"error","message":"impossible de créer le fichier de log"}'
+    exit 1
+  }
+}
+
+prepare_local_paths() {
+  local restore_base
+  restore_base="${LOCAL_RESTORE_BASE_DIR:-${REPO_DIR}/restore_tmp}"
+
+  mkdir -p "$BACKUP_LOG_DIR" || fail "création BACKUP_LOG_DIR impossible"
+  [[ -w "$BACKUP_LOG_DIR" ]] || fail "BACKUP_LOG_DIR non inscriptible"
+
+  mkdir -p "$restore_base" || fail "création LOCAL_RESTORE_BASE_DIR impossible"
+  [[ -w "$restore_base" ]] || fail "LOCAL_RESTORE_BASE_DIR non inscriptible"
+
+  log "Dossiers locaux prêts."
+}
+
+prepare_scripts_permissions() {
+  local core_script check_pg_script
+  core_script="${REPO_DIR}/rebuild-bdd-core.sh"
+  check_pg_script="${REPO_DIR}/Checkup/check-postgresql.sh"
+
+  [[ -f "$core_script" ]] || fail "script core introuvable : $core_script"
+  [[ -f "$check_pg_script" ]] || fail "script PostgreSQL introuvable : $check_pg_script"
+
+  chmod 700 "$core_script" || fail "chmod impossible sur $core_script"
+  chmod 700 "$check_pg_script" || fail "chmod impossible sur $check_pg_script"
+
+  log "Permissions scripts corrigées."
+}
+
+prepare_ssh_key() {
+  local key_dir
+  key_dir="$(dirname "$SSH_KEY")"
+
+  mkdir -p "$key_dir" || fail "impossible de créer le dossier SSH : $key_dir"
+  chmod 700 "$key_dir" || fail "impossible de chmod 700 sur $key_dir"
+
+  [[ -f "$SSH_KEY" ]] || fail "clé SSH absente : $SSH_KEY"
+  chmod 600 "$SSH_KEY" || fail "impossible de chmod 600 sur la clé privée"
+
+  [[ -f "${SSH_KEY}.pub" ]] || log "clé publique absente : ${SSH_KEY}.pub"
+  [[ ! -f "${SSH_KEY}.pub" ]] || chmod 644 "${SSH_KEY}.pub" || fail "impossible de chmod 644 sur la clé publique"
+
+  log "Clé SSH prête."
+}
+
+prepare_known_hosts() {
+  local ssh_dir known_hosts
+  ssh_dir="$(dirname "$SSH_KEY")"
+  known_hosts="${ssh_dir}/known_hosts"
+
+  touch "$known_hosts" || fail "impossible de créer known_hosts"
+  chmod 644 "$known_hosts" || fail "impossible de chmod 644 sur known_hosts"
+
+  if ! ssh-keygen -F "$BACKUP_REMOTE_HOST" -f "$known_hosts" >/dev/null 2>&1; then
+    log "Ajout de ${BACKUP_REMOTE_HOST}:${BACKUP_REMOTE_SSH_PORT} à known_hosts"
+    ssh-keyscan -p "$BACKUP_REMOTE_SSH_PORT" -H "$BACKUP_REMOTE_HOST" >>"$known_hosts" 2>/dev/null || \
+      fail "échec de récupération de la clé hôte pour ${BACKUP_REMOTE_HOST}"
+  else
+    log "Host déjà présent dans known_hosts."
+  fi
+}
+
+test_backup_ssh() {
+  local ssh_timeout
+  ssh_timeout="${SSH_CONNECT_TIMEOUT:-8}"
+
+  ssh \
+    -i "$SSH_KEY" \
+    -p "$BACKUP_REMOTE_SSH_PORT" \
+    -o IdentitiesOnly=yes \
+    -o BatchMode=yes \
+    -o ConnectTimeout="$ssh_timeout" \
+    -o StrictHostKeyChecking=yes \
+    "${BACKUP_REMOTE_USER}@${BACKUP_REMOTE_HOST}" \
+    "test -d '$BACKUP_REMOTE_DIR'" \
+    >>"$LOG_FILE" 2>&1 || \
+    fail "connexion SSH backup impossible, clé non autorisée, ou dossier distant absent"
+
+  log "Connexion SSH backup validée."
+}
+
+install_sudoers_if_allowed() {
+  local auto_configure sudoers_file tmp_file
+  auto_configure="$(to_bool_yes_no "${AUTO_CONFIGURE_SUDOERS:-no}")" || fail "AUTO_CONFIGURE_SUDOERS invalide"
+
+  if [[ "$auto_configure" != "yes" ]]; then
+    log "Installation sudoers automatique désactivée."
+    return 0
+  fi
+
+  if ! sudo true >/dev/null 2>&1; then
+    fail "AUTO_CONFIGURE_SUDOERS=yes mais sudo n'est pas disponible ; configuration initiale manuelle requise"
+  fi
+
+  require_cmd visudo
+
+  sudoers_file="/etc/sudoers.d/rebuild-bdd-${USER}"
+  tmp_file="$(mktemp)"
+
+  cat >"$tmp_file" <<EOF
+${USER} ALL=(root) NOPASSWD: /usr/bin/apt, /usr/bin/apt-get, /usr/bin/systemctl
+${USER} ALL=(postgres) NOPASSWD: /usr/bin/psql
+EOF
+
+  chmod 440 "$tmp_file"
+
+  visudo -cf "$tmp_file" >/dev/null 2>&1 || {
+    rm -f "$tmp_file"
+    fail "fichier sudoers généré invalide"
+  }
+
+  sudo install -m 440 "$tmp_file" "$sudoers_file" || {
+    rm -f "$tmp_file"
+    fail "impossible d'installer $sudoers_file"
+  }
+
+  rm -f "$tmp_file"
+  log "Fichier sudoers installé : $sudoers_file"
+}
+
+check_sudo_non_interactive() {
+  sudo /usr/bin/systemctl --version >/dev/null 2>&1 || \
+    fail "sudo indisponible pour systemctl"
+
+  log "sudo pour systemctl validé."
+
+  if command -v apt >/dev/null 2>&1; then
+    sudo /usr/bin/apt --version >/dev/null 2>&1 || \
+      fail "sudo indisponible pour apt"
+    log "sudo pour apt validé."
+  elif command -v apt-get >/dev/null 2>&1; then
+    sudo /usr/bin/apt-get --version >/dev/null 2>&1 || \
+      fail "sudo indisponible pour apt-get"
+    log "sudo pour apt-get validé."
+  else
+    fail "ni apt ni apt-get disponibles sur la cible"
+  fi
+
+  sudo -u postgres /usr/bin/psql -d postgres -c "SELECT 1;" >/dev/null 2>&1 || \
+    fail "sudo -u postgres indisponible pour psql"
+
+  log "sudo -u postgres pour psql validé."
+}
+
+run_postgresql_check() {
+  local check_script
+  check_script="${REPO_DIR}/Checkup/check-postgresql.sh"
+
+  [[ -x "$check_script" ]] || fail "script introuvable ou non exécutable : $check_script"
+
+  "$check_script" \
+    --env-file "$ENV_FILE" \
+    --request-id "$REQUEST_ID" \
+    --non-interactive \
+    >>"$LOG_FILE" 2>&1 || fail "échec de préparation PostgreSQL"
+
+  sudo -u postgres /usr/bin/psql -d postgres -c "SELECT 1;" >/dev/null 2>&1 || \
+    fail "sudo -u postgres indisponible après préparation PostgreSQL"
+  log "Préparation PostgreSQL validée."
+}
+
+[[ -f "$ENV_FILE" ]] || {
+  echo '{"status":"error","message":"fichier .env introuvable"}'
+  exit 1
+}
+
+set -a
+# shellcheck disable=SC1090
+source "$ENV_FILE"
+set +a
+
+REQUEST_ID="${CLI_REQUEST_ID:-${REQUEST_ID:-}}"
+
+require_env_vars
+validate_env_values
+prepare_log_file
+
+require_cmd bash
+require_cmd python3
+require_cmd ssh
+require_cmd ssh-keygen
+require_cmd ssh-keyscan
+require_cmd sudo
+
+prepare_local_paths
+prepare_scripts_permissions
+prepare_ssh_key
+prepare_known_hosts
+test_backup_ssh
+install_sudoers_if_allowed
+check_sudo_non_interactive
+run_postgresql_check
+
+log "Machine cible prête pour le rebuild."
+print_json_and_exit "success" "machine cible prête" 0
--- a/RebuildBdd/Config/.env.exemple
+++ b/RebuildBdd/Config/.env.exemple
@@ -0,0 +1,38 @@
+###############################################################################
+# config/global.env.example
+###############################################################################
+
+# Defaults d'exécution
+ALLOW_OVERWRITE=no
+RESTORE_ROLES=yes
+
+# Dépôt scripts
+GLOBAL_REPO_URL=git@gitea.example.tld:team/RebuildBdd.git
+GLOBAL_REPO_BRANCH=main
+
+# Backup central
+GLOBAL_BACKUP_REMOTE_USER=backup
+GLOBAL_BACKUP_REMOTE_HOST=192.168.1.60
+GLOBAL_BACKUP_REMOTE_PORT=22
+GLOBAL_BACKUP_REMOTE_BASE_DIR=/home/backup/backups
+
+# Clé SSH de lecture backup copiée sur les cibles
+GLOBAL_BACKUP_SSH_PRIVATE_KEY=/home/matteo/.ssh/id_ed25519_backup_readonly
+GLOBAL_BACKUP_SSH_PUBLIC_KEY=/home/matteo/.ssh/id_ed25519_backup_readonly.pub
+GLOBAL_BACKUP_KNOWN_HOSTS_STRICT=yes
+
+# Defaults PostgreSQL
+GLOBAL_PGHOST=127.0.0.1
+GLOBAL_PGPORT=5432
+
+# Defaults scripts
+GLOBAL_REMOTE_ROLES_DIR_NAME=user
+GLOBAL_EXCLUDED_RESTORE_ROLES="postgres"
+
+# Defaults bootstrap / cible
+GLOBAL_ENABLE_BOOTSTRAP=yes
+GLOBAL_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO=yes
+GLOBAL_AUTO_INSTALL_POSTGRES=yes
+GLOBAL_AUTO_CREATE_PGUSER=yes
+GLOBAL_PGUSER_SUPERUSER=no
+GLOBAL_AUTO_CONFIGURE_SUDOERS=no
--- a/RebuildBdd/Config/Targets/prod.env.example
+++ b/RebuildBdd/Config/Targets/prod.env.example
@@ -0,0 +1,30 @@
+
+###############################################################################
+# CIBLE : prod
+###############################################################################
+
+# TARGET_HOST_prod=10.0.0.20
+# TARGET_PORT_prod=22
+# TARGET_BOOTSTRAP_USER_prod=backup_liot
+# TARGET_BOOTSTRAP_SSH_KEY_prod=/home/matteo/.ssh/id_ed25519_target_prod
+# TARGET_RUNTIME_USER_prod=backup_liot
+# TARGET_ENABLE_BOOTSTRAP_prod=yes
+# TARGET_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO_prod=yes
+# TARGET_REPO_DIR_prod=/home/backup_liot/RebuildBdd
+# TARGET_ENV_FILE_prod=/home/backup_liot/RebuildBdd/.env
+# TARGET_ENV_NAME_prod=PROD
+# TARGET_PGHOST_prod=127.0.0.1
+# TARGET_PGPORT_prod=5432
+# TARGET_PGUSER_prod=backup_liot
+# TARGET_PGPASSWORD_prod=change_me_prod_password
+# TARGET_DBS_prod="sirh inventory ferme"
+# TARGET_BACKUP_SUBDIR_prod=bdd-prod
+# TARGET_BACKUP_LOG_DIR_prod=/home/backup_liot/logs/rebuild_bdd
+# TARGET_LOCAL_RESTORE_BASE_DIR_prod=/home/backup_liot/RebuildBdd/restore_tmp
+# TARGET_SSH_KEY_prod=/home/backup_liot/.ssh/id_ed25519_backup_readonly
+# TARGET_REMOTE_ROLES_DIR_NAME_prod=user
+# TARGET_EXCLUDED_RESTORE_ROLES_prod="postgres"
+# TARGET_AUTO_INSTALL_POSTGRES_prod=yes
+# TARGET_AUTO_CREATE_PGUSER_prod=yes
+# TARGET_PGUSER_SUPERUSER_prod=no
+# TARGET_AUTO_CONFIGURE_SUDOERS_prod=no
--- a/RebuildBdd/Config/Targets/test.env.example
+++ b/RebuildBdd/Config/Targets/test.env.example
@@ -0,0 +1,42 @@
+###############################################################################
+# config/targets/test.env.example
+###############################################################################
+
+# SSH bootstrap cible
+TARGET_HOST=192.168.1.50
+TARGET_PORT=22
+TARGET_BOOTSTRAP_USER=backup_liot
+TARGET_BOOTSTRAP_SSH_KEY=/home/matteo/.ssh/id_ed25519_target_test
+TARGET_RUNTIME_USER=backup_liot
+
+# Bootstrap
+TARGET_ENABLE_BOOTSTRAP=yes
+TARGET_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO=yes
+
+# Repo local cible
+TARGET_REPO_DIR=/home/backup_liot/RebuildBdd
+TARGET_ENV_FILE=/home/backup_liot/RebuildBdd/.env
+
+# PostgreSQL cible
+TARGET_ENV_NAME=RECETTE
+TARGET_PGHOST=127.0.0.1
+TARGET_PGPORT=5432
+TARGET_PGUSER=backup_liot
+TARGET_PGPASSWORD=change_me_pg_password
+TARGET_DBS="sirh inventory ferme"
+
+# Backup cible
+TARGET_BACKUP_SUBDIR=bdd-recette
+
+# Logs / tmp / ssh cible
+TARGET_BACKUP_LOG_DIR=/home/backup_liot/logs/rebuild_bdd
+TARGET_LOCAL_RESTORE_BASE_DIR=/home/backup_liot/RebuildBdd/restore_tmp
+TARGET_SSH_KEY=/home/backup_liot/.ssh/id_ed25519_backup_readonly
+
+# Options cible
+TARGET_REMOTE_ROLES_DIR_NAME=user
+TARGET_EXCLUDED_RESTORE_ROLES="postgres"
+TARGET_AUTO_INSTALL_POSTGRES=yes
+TARGET_AUTO_CREATE_PGUSER=yes
+TARGET_PGUSER_SUPERUSER=no
+TARGET_AUTO_CONFIGURE_SUDOERS=no
--- a/RebuildBdd/README.md
+++ b/RebuildBdd/README.md
@@ -0,0 +1,566 @@
+# RebuildBdd
+
+Orchestration de reconstruction de bases PostgreSQL à partir de dumps distants, avec préparation automatique des machines cibles, exécution non interactive et intégration web.
+
+---
+
+## Objectif
+
+Ce projet permet de :
+
+- préparer automatiquement une machine cible neuve ou partiellement configurée ;
+- déployer et mettre à jour les scripts sur la cible ;
+- préparer PostgreSQL localement sur la cible ;
+- récupérer le dernier dump disponible depuis un serveur de backup ;
+- restaurer une base PostgreSQL de manière non interactive ;
+- exposer un flux exploitable depuis une interface web via des retours JSON.
+
+---
+
+## Fonctionnement global
+
+Le flux standard est le suivant :
+
+1. **Création ou mise à jour de la configuration d’une cible**
+2. **Bootstrap initial de la cible**
+3. **Précheck de préparation**
+4. **Rebuild de la base**
+
+En pratique :
+
+- `create-target-config.sh` crée un fichier de configuration cible ;
+- `bootstrap-target-host.sh` prépare la machine cible ;
+- `Checkup/check-target-readiness.sh` valide l’environnement ;
+- `rebuild-bdd-core.sh` exécute la restauration ;
+- `run-rebuild-bdd.sh` orchestre l’ensemble.
+
+---
+
+## Architecture
+
+### Configuration
+
+Le projet utilise deux niveaux de configuration :
+
+#### 1. Configuration globale
+Fichier :
+
+```bash
+config/global.env
+````
+
+Contient les paramètres stables, par exemple :
+
+* dépôt Git des scripts ;
+* serveur de backup ;
+* clé SSH de lecture backup ;
+* valeurs par défaut PostgreSQL ;
+* options globales de bootstrap.
+
+#### 2. Configuration par cible
+
+Fichiers :
+
+```bash
+config/targets/<nom_cible>.env
+```
+
+Chaque fichier cible contient :
+
+* accès SSH bootstrap ;
+* répertoires locaux de la cible ;
+* paramètres PostgreSQL ;
+* sous-répertoire backup associé ;
+* options spécifiques à la cible.
+
+---
+
+## Arborescence recommandée
+
+```bash
+RebuildBdd/
+├── bootstrap-target-host.sh
+├── create-target-config.sh
+├── run-rebuild-bdd.sh
+├── rebuild-bdd-core.sh
+├── config/
+│   ├── global.env
+│   └── targets/
+│       ├── test.env
+│       └── prod.env
+└── Checkup/
+    ├── check-postgresql.sh
+    └── check-target-readiness.sh
+```
+
+---
+
+## Scripts
+
+### `create-target-config.sh`
+
+Crée ou met à jour un fichier cible dans :
+
+```bash
+config/targets/<cible>.env
+```
+
+Usage :
+
+```bash
+./create-target-config.sh \
+  --target test \
+  --host 192.168.1.50 \
+  --port 22 \
+  --bootstrap-user backup_liot \
+  --bootstrap-key /home/user/.ssh/id_ed25519_target_test \
+  --runtime-user backup_liot \
+  --repo-dir /home/backup_liot/RebuildBdd \
+  --env-name RECETTE \
+  --pguser backup_liot \
+  --pgpassword secret \
+  --dbs "sirh inventory ferme" \
+  --backup-subdir bdd-recette
+```
+
+---
+
+### `bootstrap-target-host.sh`
+
+Prépare une machine cible neuve ou quasi neuve :
+
+* connexion SSH bootstrap ;
+* installation des paquets minimum ;
+* création des dossiers ;
+* génération du `.env` cible ;
+* copie de la clé SSH backup ;
+* préparation de `known_hosts` ;
+* installation éventuelle d’un `sudoers.d` minimal ;
+* synchronisation du dépôt ;
+* exécution de `check-postgresql.sh`.
+
+Usage :
+
+```bash
+./bootstrap-target-host.sh --target test
+```
+
+Mode JSON :
+
+```bash
+./bootstrap-target-host.sh --target test --json-only
+```
+
+---
+
+### `Checkup/check-postgresql.sh`
+
+Prépare PostgreSQL localement sur la cible :
+
+* installation si absent ;
+* démarrage du service ;
+* test de disponibilité ;
+* création du rôle PostgreSQL cible si nécessaire.
+
+Ce script est prévu pour fonctionner en non interactif avec `sudo -n`.
+
+---
+
+### `Checkup/check-target-readiness.sh`
+
+Valide la préparation complète de la cible :
+
+* lecture du `.env` cible ;
+* vérification des chemins ;
+* permissions locales ;
+* permissions SSH ;
+* `known_hosts` ;
+* accès SSH au serveur de backup ;
+* exécution de `check-postgresql.sh`.
+
+Mode JSON disponible pour usage web.
+
+---
+
+### `rebuild-bdd-core.sh`
+
+Script métier de reconstruction :
+
+* validation des paramètres ;
+* connexion au serveur de backup ;
+* récupération du dernier dump ;
+* récupération éventuelle du fichier des rôles ;
+* suppression/recréation de la base si autorisé ;
+* restauration des rôles ;
+* restauration du dump PostgreSQL ;
+* retour JSON final.
+
+---
+
+### `run-rebuild-bdd.sh`
+
+Script orchestrateur principal.
+
+Il peut :
+
+* lancer le bootstrap si activé pour la cible ;
+* synchroniser le dépôt distant ;
+* lancer le précheck ;
+* exécuter le rebuild.
+
+Usage :
+
+```bash
+./run-rebuild-bdd.sh \
+  --target test \
+  --db sirh \
+  --overwrite yes \
+  --restore-roles yes \
+  --request-id web_001 \
+  --non-interactive
+```
+
+---
+
+## Prérequis
+
+### Machine de lancement
+
+Doit disposer de :
+
+* `bash`
+* `ssh`
+* `scp`
+* `git`
+* `python3`
+
+### Machine cible
+
+Le bootstrap suppose :
+
+* accès SSH fonctionnel ;
+* utilisateur bootstrap existant ;
+* soit `root`, soit `sudo -n` déjà disponible pour le bootstrap initial.
+
+### Serveur de backup
+
+Doit :
+
+* être joignable en SSH depuis la cible ;
+* accepter la clé de lecture backup ;
+* contenir les dumps dans l’arborescence attendue.
+
+---
+
+## Structure des backups attendue
+
+Exemple :
+
+```bash
+/home/malio-b/backups/
+├── bdd-recette/
+│   ├── sirh/
+│   │   ├── sirh_2026-03-16_19-00-01.dump
+│   ├── inventory/
+│   ├── ferme/
+│   └── user/
+│       ├── user_2026-03-16_19-00-01.sql
+```
+
+Le script recherche :
+
+* le dernier dump dans :
+
+```bash
+<BACKUP_REMOTE_DIR>/<db>/<db>_*.dump
+```
+
+* le dernier fichier rôles dans :
+
+```bash
+<BACKUP_REMOTE_DIR>/<REMOTE_ROLES_DIR_NAME>/user_*.sql
+```
+
+---
+
+## Configuration
+
+### 1. Créer la configuration globale
+
+Copier :
+
+```bash
+config/global.env.example
+```
+
+vers :
+
+```bash
+config/global.env
+```
+
+Renseigner ensuite :
+
+* dépôt Git ;
+* serveur de backup ;
+* clé SSH backup ;
+* defaults globaux.
+
+---
+
+### 2. Créer une cible
+
+Deux possibilités.
+
+#### A. À la main
+
+Créer un fichier :
+
+```bash
+config/targets/test.env
+```
+
+à partir de :
+
+```bash
+config/targets/test.env.example
+```
+
+#### B. Via script
+
+Utiliser :
+
+```bash
+./create-target-config.sh ...
+```
+
+---
+
+## Exécution locale
+
+### Bootstrap seul
+
+```bash
+./bootstrap-target-host.sh --target test
+```
+
+### Rebuild complet
+
+```bash
+./run-rebuild-bdd.sh \
+  --target test \
+  --db sirh \
+  --overwrite yes \
+  --restore-roles yes \
+  --non-interactive
+```
+
+---
+
+## Intégration web
+
+L’interface web ne doit envoyer que les paramètres métier de l’exécution :
+
+```json
+{
+  "target": "test",
+  "db": "sirh",
+  "overwrite": "yes",
+  "restore_roles": "yes",
+  "request_id": "web_20260317_001"
+}
+```
+
+Le backend transforme cela en commande :
+
+```bash
+./run-rebuild-bdd.sh \
+  --target test \
+  --db sirh \
+  --overwrite yes \
+  --restore-roles yes \
+  --request-id web_20260317_001 \
+  --non-interactive
+```
+
+### Important
+
+Le web ne doit pas transmettre directement :
+
+* les clés SSH ;
+* les mots de passe PostgreSQL ;
+* les paramètres bas niveau de la cible ;
+* les chemins système sensibles.
+
+Ces informations doivent être stockées dans la configuration serveur.
+
+---
+
+## Ajouter une nouvelle machine depuis le web
+
+Le flux recommandé est :
+
+1. créer ou mettre à jour `config/targets/<cible>.env`
+2. lancer `bootstrap-target-host.sh --target <cible>`
+3. lancer ensuite `run-rebuild-bdd.sh --target <cible> ...`
+
+Le bouton web **“Ajouter une machine”** doit donc :
+
+* créer la configuration cible ;
+* déclencher le bootstrap ;
+* vérifier le retour ;
+* rendre ensuite la cible disponible pour les rebuilds.
+
+---
+
+## Sorties JSON
+
+### Succès
+
+Exemple :
+
+```json
+{
+  "status": "success",
+  "message": "restauration terminée avec succès",
+  "request_id": "web_001",
+  "environment": "RECETTE",
+  "database": "sirh",
+  "dump_file": "/home/backup/backups/bdd-recette/sirh/sirh_2026-03-16_19-00-01.dump",
+  "log_file": "/home/backup_liot/logs/rebuild_bdd/restore_recette_web_001_2026-03-17_09-10-00.log"
+}
+```
+
+### Erreur
+
+Exemple :
+
+```json
+{
+  "status": "error",
+  "message": "la base existe déjà et overwrite n'est pas autorisé",
+  "request_id": "web_001",
+  "environment": "RECETTE",
+  "database": "sirh",
+  "dump_file": "/home/backup/backups/bdd-recette/sirh/sirh_2026-03-16_19-00-01.dump",
+  "log_file": "/home/backup_liot/logs/rebuild_bdd/restore_recette_web_001_2026-03-17_09-10-00.log"
+}
+```
+
+---
+
+## Sécurité
+
+### Recommandations minimales
+
+* utiliser des clés SSH dédiées ;
+* limiter la clé backup à la lecture seule ;
+* restreindre les permissions des fichiers de config ;
+* exécuter les scripts avec un utilisateur dédié ;
+* ne pas exposer les secrets dans l’interface web ;
+* valider strictement toutes les entrées côté backend.
+
+### `sudoers`
+
+Le bootstrap peut installer un `sudoers.d` minimal pour l’utilisateur runtime :
+
+```sudoers
+<user> ALL=(root) NOPASSWD: /usr/bin/apt, /usr/bin/apt-get, /usr/bin/systemctl
+<user> ALL=(postgres) NOPASSWD: /usr/bin/psql
+```
+
+Adapter si d’autres commandes doivent être autorisées.
+
+---
+
+## Logs
+
+Les logs de rebuild sont stockés dans :
+
+```bash
+TARGET_BACKUP_LOG_DIR
+```
+
+Exemple :
+
+```bash
+/home/backup_liot/logs/rebuild_bdd/
+```
+
+Le chemin du log est renvoyé dans le JSON final.
+
+---
+
+## Limites connues
+
+* le bootstrap initial nécessite un accès SSH bootstrap valide ;
+* le bootstrap ne remplace pas une mauvaise architecture réseau ;
+* les secrets doivent être gérés proprement par la couche web/backend ;
+* des verrous d’exécution peuvent être ajoutés si plusieurs rebuilds concurrents sont prévus.
+
+---
+
+## Recommandations de validation
+
+Avant mise en production, tester au minimum :
+
+1. bootstrap d’une machine neuve ;
+2. rebuild complet d’une base ;
+3. refus si la base existe et `overwrite=no` ;
+4. relance complète une seconde fois sur la même cible ;
+5. accès backup invalide ;
+6. PostgreSQL absent au départ ;
+7. `sudo -n` indisponible.
+
+---
+
+## Commandes utiles
+
+### Créer une cible
+
+```bash
+./create-target-config.sh \
+  --target test \
+  --host 192.168.1.50 \
+  --port 22 \
+  --bootstrap-user backup_liot \
+  --bootstrap-key /home/matteo/.ssh/id_ed25519_target_test \
+  --runtime-user backup_liot \
+  --repo-dir /home/backup_liot/RebuildBdd \
+  --env-name RECETTE \
+  --pguser backup_liot \
+  --pgpassword secret \
+  --dbs "sirh inventory ferme" \
+  --backup-subdir bdd-recette
+```
+
+### Bootstrap
+
+```bash
+./bootstrap-target-host.sh --target test
+```
+
+### Rebuild
+
+```bash
+./run-rebuild-bdd.sh \
+  --target test \
+  --db sirh \
+  --overwrite yes \
+  --restore-roles yes \
+  --non-interactive
+``` 
+
+---
+
+## État du projet
+
+Le projet permet désormais une utilisation :
+
+* locale ;
+* automatisée ;
+* intégrée au web ;
+
+avec préparation des cibles, exécution non interactive et retour JSON.
+
+```
--- a/RebuildBdd/bootstrap-target-host.sh
+++ b/RebuildBdd/bootstrap-target-host.sh
@@ -0,0 +1,579 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CONFIG_DIR="${SCRIPT_DIR}/Config"
+GLOBAL_ENV_FILE_DEFAULT="${CONFIG_DIR}/global.env"
+TARGETS_DIR_DEFAULT="${CONFIG_DIR}/Targets"
+GIT_TOPLEVEL="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || true)"
+LOCAL_REPO_SUBDIR_DEFAULT=""
+
+if [[ -n "$GIT_TOPLEVEL" && "$SCRIPT_DIR" == "$GIT_TOPLEVEL"/* ]]; then
+  LOCAL_REPO_SUBDIR_DEFAULT="${SCRIPT_DIR#"$GIT_TOPLEVEL"/}"
+fi
+
+GLOBAL_ENV_FILE="${GLOBAL_ENV_FILE:-$GLOBAL_ENV_FILE_DEFAULT}"
+TARGETS_DIR="${TARGETS_DIR:-$TARGETS_DIR_DEFAULT}"
+
+TARGET_NAME="${TARGET_NAME:-}"
+CLI_TARGET=""
+JSON_ONLY="${JSON_ONLY:-no}"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --global-env-file)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --global-env-file" >&2; exit 1; }
+      GLOBAL_ENV_FILE="$2"
+      shift 2
+      ;;
+    --targets-dir)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --targets-dir" >&2; exit 1; }
+      TARGETS_DIR="$2"
+      shift 2
+      ;;
+    --target)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --target" >&2; exit 1; }
+      CLI_TARGET="$2"
+      shift 2
+      ;;
+    --json-only)
+      JSON_ONLY="yes"
+      shift
+      ;;
+    *)
+      echo "Argument inconnu : $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+json_escape() {
+  python3 - <<'PY' "$1"
+import json, sys
+print(json.dumps(sys.argv[1]))
+PY
+}
+
+print_stdout() {
+  [[ "$JSON_ONLY" == "yes" ]] || echo "$*"
+}
+
+log() {
+  print_stdout "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
+}
+
+fail() {
+  local msg="$1"
+  if [[ "$JSON_ONLY" == "yes" ]]; then
+    printf '{"status":%s,"message":%s}\n' \
+      "$(json_escape "error")" \
+      "$(json_escape "$msg")"
+  else
+    echo "ERROR: $msg" >&2
+  fi
+  exit 1
+}
+
+success() {
+  local msg="$1"
+  if [[ "$JSON_ONLY" == "yes" ]]; then
+    printf '{"status":%s,"message":%s}\n' \
+      "$(json_escape "success")" \
+      "$(json_escape "$msg")"
+  else
+    log "$msg"
+  fi
+}
+
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1 || fail "commande requise absente : $1"
+}
+
+to_bool_yes_no() {
+  local v="${1:-}"
+  v="${v,,}"
+  case "$v" in
+    yes|y|oui|o|true|1) echo "yes" ;;
+    no|n|non|false|0|"") echo "no" ;;
+    *) return 1 ;;
+  esac
+}
+
+shell_quote() {
+  printf "%q" "$1"
+}
+
+cleanup() {
+  rm -f "${TMP_ENV_FILE:-}"
+}
+trap cleanup EXIT
+
+copy_file_to_remote_via_ssh() {
+  local local_file="$1"
+  local remote_final_path="$2"
+  local remote_mode="$3"
+  local remote_parent
+  local remote_tmp
+
+  [[ -f "$local_file" ]] || fail "fichier source introuvable : $local_file"
+  [[ -r "$local_file" ]] || fail "fichier source non lisible : $local_file"
+
+  remote_parent="$(dirname "$remote_final_path")"
+  remote_tmp="/tmp/bootstrap_copy.$$.$RANDOM.tmp"
+
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "
+    set -euo pipefail
+    mkdir -p $(shell_quote "$remote_parent")
+    test -d $(shell_quote "$remote_parent")
+    test -w $(shell_quote "$remote_parent")
+  " >/dev/null 2>&1 || fail "dossier distant absent ou non inscriptible : $remote_parent"
+
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "
+    set -euo pipefail
+    cat > $(shell_quote "$remote_tmp")
+  " < "$local_file" >/dev/null 2>&1 || fail "échec d'écriture temporaire distante : $remote_tmp"
+
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "
+    set -euo pipefail
+    install -m $(shell_quote "$remote_mode") $(shell_quote "$remote_tmp") $(shell_quote "$remote_final_path")
+    rm -f $(shell_quote "$remote_tmp")
+  " >/dev/null 2>&1 || fail "échec d'installation distante : $remote_final_path"
+}
+
+TARGET_NAME="${CLI_TARGET:-${TARGET_NAME:-}}"
+[[ -n "$TARGET_NAME" ]] || fail "target manquante"
+
+TARGET_ENV_SOURCE="${TARGETS_DIR}/${TARGET_NAME}.env"
+
+[[ -f "$GLOBAL_ENV_FILE" ]] || fail "fichier global introuvable : $GLOBAL_ENV_FILE"
+[[ -f "$TARGET_ENV_SOURCE" ]] || fail "fichier cible introuvable : $TARGET_ENV_SOURCE"
+
+set -a
+# shellcheck disable=SC1090
+source "$GLOBAL_ENV_FILE"
+# shellcheck disable=SC1090
+source "$TARGET_ENV_SOURCE"
+set +a
+
+BOOTSTRAP_HOST="${TARGET_HOST:-}"
+BOOTSTRAP_PORT="${TARGET_PORT:-22}"
+BOOTSTRAP_USER="${TARGET_BOOTSTRAP_USER:-}"
+BOOTSTRAP_SSH_KEY="${TARGET_BOOTSTRAP_SSH_KEY:-}"
+
+TARGET_REPO_URL="${TARGET_REPO_URL:-${GLOBAL_REPO_URL:-}}"
+TARGET_REPO_BRANCH="${TARGET_REPO_BRANCH:-${GLOBAL_REPO_BRANCH:-}}"
+TARGET_REPO_DIR="${TARGET_REPO_DIR:-}"
+TARGET_REPO_SUBDIR="${TARGET_REPO_SUBDIR:-$LOCAL_REPO_SUBDIR_DEFAULT}"
+TARGET_ENV_FILE_PATH="${TARGET_ENV_FILE:-}"
+
+TARGET_ENV_NAME_VALUE="${TARGET_ENV_NAME:-}"
+TARGET_PGHOST_VALUE="${TARGET_PGHOST:-${GLOBAL_PGHOST:-}}"
+TARGET_PGPORT_VALUE="${TARGET_PGPORT:-${GLOBAL_PGPORT:-}}"
+TARGET_PGUSER_VALUE="${TARGET_PGUSER:-}"
+TARGET_PGPASSWORD_VALUE="${TARGET_PGPASSWORD:-}"
+TARGET_DBS_VALUE="${TARGET_DBS:-}"
+
+TARGET_BACKUP_REMOTE_USER_VALUE="${TARGET_BACKUP_REMOTE_USER:-${GLOBAL_BACKUP_REMOTE_USER:-}}"
+TARGET_BACKUP_REMOTE_HOST_VALUE="${TARGET_BACKUP_REMOTE_HOST:-${GLOBAL_BACKUP_REMOTE_HOST:-}}"
+TARGET_BACKUP_REMOTE_SSH_PORT_VALUE="${TARGET_BACKUP_REMOTE_SSH_PORT:-${GLOBAL_BACKUP_REMOTE_PORT:-22}}"
+GLOBAL_BACKUP_REMOTE_BASE_DIR_VALUE="${GLOBAL_BACKUP_REMOTE_BASE_DIR:-}"
+TARGET_BACKUP_SUBDIR_VALUE="${TARGET_BACKUP_SUBDIR:-}"
+TARGET_BACKUP_LOG_DIR_VALUE="${TARGET_BACKUP_LOG_DIR:-}"
+
+TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY_VALUE="${TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY:-${GLOBAL_BACKUP_SSH_PRIVATE_KEY:-}}"
+TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY_VALUE="${TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY:-${GLOBAL_BACKUP_SSH_PUBLIC_KEY:-}}"
+TARGET_BACKUP_KNOWN_HOSTS_STRICT_VALUE="${TARGET_BACKUP_KNOWN_HOSTS_STRICT:-${GLOBAL_BACKUP_KNOWN_HOSTS_STRICT:-yes}}"
+
+TARGET_LOCAL_RESTORE_BASE_DIR_VALUE="${TARGET_LOCAL_RESTORE_BASE_DIR:-${TARGET_REPO_DIR}/restore_tmp}"
+TARGET_REMOTE_ROLES_DIR_NAME_VALUE="${TARGET_REMOTE_ROLES_DIR_NAME:-${GLOBAL_REMOTE_ROLES_DIR_NAME:-user}}"
+TARGET_SSH_KEY_VALUE="${TARGET_SSH_KEY:-/home/${BOOTSTRAP_USER}/.ssh/id_ed25519_backup_readonly}"
+TARGET_AUTO_INSTALL_POSTGRES_VALUE="${TARGET_AUTO_INSTALL_POSTGRES:-${GLOBAL_AUTO_INSTALL_POSTGRES:-yes}}"
+TARGET_AUTO_CREATE_PGUSER_VALUE="${TARGET_AUTO_CREATE_PGUSER:-${GLOBAL_AUTO_CREATE_PGUSER:-yes}}"
+TARGET_PGUSER_SUPERUSER_VALUE="${TARGET_PGUSER_SUPERUSER:-${GLOBAL_PGUSER_SUPERUSER:-no}}"
+TARGET_AUTO_CONFIGURE_SUDOERS_VALUE="${TARGET_AUTO_CONFIGURE_SUDOERS:-${GLOBAL_AUTO_CONFIGURE_SUDOERS:-no}}"
+TARGET_EXCLUDED_RESTORE_ROLES_VALUE="${TARGET_EXCLUDED_RESTORE_ROLES:-${GLOBAL_EXCLUDED_RESTORE_ROLES:-postgres}}"
+
+TARGET_RUNTIME_USER_VALUE="${TARGET_RUNTIME_USER:-$BOOTSTRAP_USER}"
+TARGET_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO_VALUE="${TARGET_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO:-${GLOBAL_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO:-yes}}"
+
+[[ -n "$BOOTSTRAP_HOST" ]] || fail "TARGET_HOST manquante"
+[[ "$BOOTSTRAP_PORT" =~ ^[0-9]+$ ]] || fail "TARGET_PORT invalide"
+[[ -n "$BOOTSTRAP_USER" ]] || fail "TARGET_BOOTSTRAP_USER manquante"
+[[ -n "$BOOTSTRAP_SSH_KEY" ]] || fail "TARGET_BOOTSTRAP_SSH_KEY manquante"
+[[ -f "$BOOTSTRAP_SSH_KEY" ]] || fail "clé bootstrap introuvable : $BOOTSTRAP_SSH_KEY"
+[[ -r "$BOOTSTRAP_SSH_KEY" ]] || fail "clé bootstrap non lisible : $BOOTSTRAP_SSH_KEY"
+
+[[ -n "$TARGET_REPO_URL" ]] || fail "GLOBAL_REPO_URL/TARGET_REPO_URL manquant"
+[[ -n "$TARGET_REPO_BRANCH" ]] || fail "GLOBAL_REPO_BRANCH/TARGET_REPO_BRANCH manquant"
+[[ -n "$TARGET_REPO_DIR" ]] || fail "TARGET_REPO_DIR manquante"
+[[ -n "$TARGET_ENV_FILE_PATH" ]] || fail "TARGET_ENV_FILE manquante"
+
+TARGET_REPO_SUBDIR="${TARGET_REPO_SUBDIR#/}"
+TARGET_REPO_SUBDIR="${TARGET_REPO_SUBDIR%/}"
+
+TARGET_CLONE_DIR="$TARGET_REPO_DIR"
+TARGET_SCRIPT_DIR="$TARGET_REPO_DIR"
+if [[ -n "$TARGET_REPO_SUBDIR" ]]; then
+  if [[ "$TARGET_REPO_DIR" == */"$TARGET_REPO_SUBDIR" ]]; then
+    TARGET_CLONE_DIR="$(dirname "$TARGET_REPO_DIR")"
+  else
+    TARGET_SCRIPT_DIR="${TARGET_REPO_DIR}/${TARGET_REPO_SUBDIR}"
+  fi
+fi
+
+[[ -n "$TARGET_ENV_NAME_VALUE" ]] || fail "TARGET_ENV_NAME manquante"
+[[ -n "$TARGET_PGHOST_VALUE" ]] || fail "TARGET_PGHOST/GLOBAL_PGHOST manquant"
+[[ -n "$TARGET_PGPORT_VALUE" ]] || fail "TARGET_PGPORT/GLOBAL_PGPORT manquant"
+[[ -n "$TARGET_PGUSER_VALUE" ]] || fail "TARGET_PGUSER manquante"
+[[ -n "$TARGET_PGPASSWORD_VALUE" ]] || fail "TARGET_PGPASSWORD manquante"
+[[ -n "$TARGET_DBS_VALUE" ]] || fail "TARGET_DBS manquante"
+
+[[ -n "$TARGET_BACKUP_REMOTE_USER_VALUE" ]] || fail "GLOBAL_BACKUP_REMOTE_USER/TARGET_BACKUP_REMOTE_USER manquant"
+[[ -n "$TARGET_BACKUP_REMOTE_HOST_VALUE" ]] || fail "GLOBAL_BACKUP_REMOTE_HOST/TARGET_BACKUP_REMOTE_HOST manquant"
+[[ -n "$GLOBAL_BACKUP_REMOTE_BASE_DIR_VALUE" ]] || fail "GLOBAL_BACKUP_REMOTE_BASE_DIR manquant"
+[[ -n "$TARGET_BACKUP_SUBDIR_VALUE" ]] || fail "TARGET_BACKUP_SUBDIR manquante"
+[[ -n "$TARGET_BACKUP_LOG_DIR_VALUE" ]] || fail "TARGET_BACKUP_LOG_DIR manquante"
+TARGET_BACKUP_REMOTE_DIR_VALUE="${GLOBAL_BACKUP_REMOTE_BASE_DIR_VALUE%/}/${TARGET_BACKUP_SUBDIR_VALUE}"
+
+[[ -n "$TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY_VALUE" ]] || fail "GLOBAL_BACKUP_SSH_PRIVATE_KEY/TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY manquant"
+[[ -f "$TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY_VALUE" ]] || fail "clé privée backup introuvable : $TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY_VALUE"
+[[ -r "$TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY_VALUE" ]] || fail "clé privée backup non lisible : $TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY_VALUE"
+
+if [[ -n "$TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY_VALUE" ]]; then
+  [[ -f "$TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY_VALUE" ]] || fail "clé publique backup introuvable : $TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY_VALUE"
+  [[ -r "$TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY_VALUE" ]] || fail "clé publique backup non lisible : $TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY_VALUE"
+fi
+
+[[ "$TARGET_BACKUP_REMOTE_SSH_PORT_VALUE" =~ ^[0-9]+$ ]] || fail "port backup invalide"
+to_bool_yes_no "$TARGET_BACKUP_KNOWN_HOSTS_STRICT_VALUE" >/dev/null || fail "TARGET_BACKUP_KNOWN_HOSTS_STRICT invalide"
+to_bool_yes_no "$TARGET_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO_VALUE" >/dev/null || fail "TARGET_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO invalide"
+
+ALLOW_PASSWORDLESS_SUDO="$(to_bool_yes_no "$TARGET_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO_VALUE")"
+
+require_cmd ssh
+require_cmd python3
+
+SSH_OPTS=(
+  -i "$BOOTSTRAP_SSH_KEY"
+  -p "$BOOTSTRAP_PORT"
+  -o IdentitiesOnly=yes
+  -o BatchMode=yes
+  -o StrictHostKeyChecking=accept-new
+  -o ConnectTimeout=8
+)
+
+REMOTE="${BOOTSTRAP_USER}@${BOOTSTRAP_HOST}"
+
+log "Test de connexion SSH bootstrap vers ${REMOTE}:${BOOTSTRAP_PORT}"
+ssh "${SSH_OPTS[@]}" "$REMOTE" "exit 0" >/dev/null 2>&1 \
+  || fail "connexion SSH bootstrap impossible vers ${REMOTE}"
+
+REMOTE_SETUP_CMD="
+set -euo pipefail
+
+export DEBIAN_FRONTEND=noninteractive
+
+run_root() {
+  if [ \"\$(id -u)\" -eq 0 ]; then
+    \"\$@\"
+    return 0
+  fi
+
+  if command -v sudo >/dev/null 2>&1; then
+    sudo \"\$@\" || {
+      echo 'sudo indisponible pour le bootstrap' >&2
+      exit 1
+    }
+    return 0
+  fi
+
+  echo 'ni root ni sudo disponible pour le bootstrap' >&2
+  exit 1
+}
+
+if ! command -v apt-get >/dev/null 2>&1; then
+  echo 'apt-get absent sur la cible' >&2
+  exit 1
+fi
+
+run_root apt-get update
+run_root apt-get install -y bash git python3 sudo curl openssh-client ca-certificates postgresql-client
+
+mkdir -p $(shell_quote "$(dirname "$TARGET_CLONE_DIR")")
+mkdir -p $(shell_quote "$(dirname "$TARGET_SCRIPT_DIR")")
+mkdir -p $(shell_quote "$(dirname "$TARGET_ENV_FILE_PATH")")
+mkdir -p $(shell_quote "$TARGET_BACKUP_LOG_DIR_VALUE")
+mkdir -p $(shell_quote "$TARGET_LOCAL_RESTORE_BASE_DIR_VALUE")
+mkdir -p $(shell_quote "$(dirname "$TARGET_SSH_KEY_VALUE")")
+
+chmod 700 $(shell_quote "$(dirname "$TARGET_SSH_KEY_VALUE")") || true
+touch $(shell_quote "$(dirname "$TARGET_SSH_KEY_VALUE")/known_hosts")
+chmod 644 $(shell_quote "$(dirname "$TARGET_SSH_KEY_VALUE")/known_hosts") || true
+"
+
+log "Installation du socle minimal sur la cible"
+if [[ "$JSON_ONLY" == "yes" ]]; then
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_SETUP_CMD" >/dev/null \
+    || fail "échec de préparation système distante"
+else
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_SETUP_CMD" \
+    || fail "échec de préparation système distante"
+fi
+
+TMP_ENV_FILE="$(mktemp)"
+
+cat >"$TMP_ENV_FILE" <<EOF
+ENV_NAME=$(shell_quote "$TARGET_ENV_NAME_VALUE")
+PGHOST=$(shell_quote "$TARGET_PGHOST_VALUE")
+PGPORT=$(shell_quote "$TARGET_PGPORT_VALUE")
+PGUSER=$(shell_quote "$TARGET_PGUSER_VALUE")
+PGPASSWORD=$(shell_quote "$TARGET_PGPASSWORD_VALUE")
+DBS=$(shell_quote "$TARGET_DBS_VALUE")
+
+BACKUP_REMOTE_USER=$(shell_quote "$TARGET_BACKUP_REMOTE_USER_VALUE")
+BACKUP_REMOTE_HOST=$(shell_quote "$TARGET_BACKUP_REMOTE_HOST_VALUE")
+BACKUP_REMOTE_DIR=$(shell_quote "$TARGET_BACKUP_REMOTE_DIR_VALUE")
+BACKUP_REMOTE_SSH_PORT=$(shell_quote "$TARGET_BACKUP_REMOTE_SSH_PORT_VALUE")
+
+BACKUP_LOG_DIR=$(shell_quote "$TARGET_BACKUP_LOG_DIR_VALUE")
+LOCAL_RESTORE_BASE_DIR=$(shell_quote "$TARGET_LOCAL_RESTORE_BASE_DIR_VALUE")
+REMOTE_ROLES_DIR_NAME=$(shell_quote "$TARGET_REMOTE_ROLES_DIR_NAME_VALUE")
+SSH_KEY=$(shell_quote "$TARGET_SSH_KEY_VALUE")
+
+AUTO_INSTALL_POSTGRES=$(shell_quote "$TARGET_AUTO_INSTALL_POSTGRES_VALUE")
+AUTO_CREATE_PGUSER=$(shell_quote "$TARGET_AUTO_CREATE_PGUSER_VALUE")
+PGUSER_SUPERUSER=$(shell_quote "$TARGET_PGUSER_SUPERUSER_VALUE")
+AUTO_CONFIGURE_SUDOERS=$(shell_quote "$TARGET_AUTO_CONFIGURE_SUDOERS_VALUE")
+EXCLUDED_RESTORE_ROLES=$(shell_quote "$TARGET_EXCLUDED_RESTORE_ROLES_VALUE")
+EOF
+
+log "Copie du .env cible"
+copy_file_to_remote_via_ssh "$TMP_ENV_FILE" "$TARGET_ENV_FILE_PATH" "600"
+
+REMOTE_SSH_DIR="$(dirname "$TARGET_SSH_KEY_VALUE")"
+REMOTE_KNOWN_HOSTS="${REMOTE_SSH_DIR}/known_hosts"
+
+log "Copie de la clé privée backup sur la cible"
+copy_file_to_remote_via_ssh "$TARGET_BACKUP_SOURCE_SSH_PRIVATE_KEY_VALUE" "$TARGET_SSH_KEY_VALUE" "600"
+
+if [[ -n "$TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY_VALUE" ]]; then
+  log "Copie de la clé publique backup sur la cible"
+  copy_file_to_remote_via_ssh "$TARGET_BACKUP_SOURCE_SSH_PUBLIC_KEY_VALUE" "${TARGET_SSH_KEY_VALUE}.pub" "644"
+fi
+
+REMOTE_SSH_PERMS_CMD="
+set -euo pipefail
+chmod 700 $(shell_quote "$REMOTE_SSH_DIR")
+chmod 600 $(shell_quote "$TARGET_SSH_KEY_VALUE")
+if [[ -f $(shell_quote "${TARGET_SSH_KEY_VALUE}.pub") ]]; then
+  chmod 644 $(shell_quote "${TARGET_SSH_KEY_VALUE}.pub")
+fi
+touch $(shell_quote "$REMOTE_KNOWN_HOSTS")
+chmod 644 $(shell_quote "$REMOTE_KNOWN_HOSTS")
+"
+
+log "Correction des permissions SSH côté cible"
+ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_SSH_PERMS_CMD" \
+  || fail "échec de correction des permissions SSH sur la cible"
+
+REMOTE_KNOWN_HOSTS_CMD="
+set -euo pipefail
+
+if ! command -v ssh-keyscan >/dev/null 2>&1; then
+  echo 'ssh-keyscan absent sur la cible' >&2
+  exit 1
+fi
+
+if ! ssh-keygen -F $(shell_quote "$TARGET_BACKUP_REMOTE_HOST_VALUE") -f $(shell_quote "$REMOTE_KNOWN_HOSTS") >/dev/null 2>&1; then
+  ssh-keyscan -p $(shell_quote "$TARGET_BACKUP_REMOTE_SSH_PORT_VALUE") -H $(shell_quote "$TARGET_BACKUP_REMOTE_HOST_VALUE") >> $(shell_quote "$REMOTE_KNOWN_HOSTS") 2>/dev/null
+fi
+"
+
+log "Ajout du serveur de backup dans known_hosts côté cible"
+ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_KNOWN_HOSTS_CMD" \
+  || fail "échec de préparation known_hosts sur la cible"
+
+STRICT_OPTION="yes"
+case "${TARGET_BACKUP_KNOWN_HOSTS_STRICT_VALUE,,}" in
+  yes|y|oui|o|true|1) STRICT_OPTION="yes" ;;
+  no|n|non|false|0) STRICT_OPTION="no" ;;
+  *) fail "TARGET_BACKUP_KNOWN_HOSTS_STRICT invalide" ;;
+esac
+
+REMOTE_BACKUP_TEST_CMD="
+set -euo pipefail
+
+ssh \
+  -i $(shell_quote "$TARGET_SSH_KEY_VALUE") \
+  -p $(shell_quote "$TARGET_BACKUP_REMOTE_SSH_PORT_VALUE") \
+  -o IdentitiesOnly=yes \
+  -o BatchMode=yes \
+  -o ConnectTimeout=8 \
+  -o StrictHostKeyChecking=$(shell_quote "$STRICT_OPTION") \
+  $(shell_quote "${TARGET_BACKUP_REMOTE_USER_VALUE}@${TARGET_BACKUP_REMOTE_HOST_VALUE}") \
+  test -d $(shell_quote "$TARGET_BACKUP_REMOTE_DIR_VALUE")
+"
+
+log "Test de la connexion SSH cible -> backup"
+ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_BACKUP_TEST_CMD" \
+  || fail "la cible ne peut pas accéder au serveur de backup avec la clé fournie"
+
+if [[ "$ALLOW_PASSWORDLESS_SUDO" == "yes" ]]; then
+  REMOTE_SUDOERS_PRECHECK_CMD="
+set -euo pipefail
+
+if [ \"\$(id -u)\" -eq 0 ]; then
+  exit 0
+fi
+
+command -v sudo >/dev/null 2>&1 || exit 1
+sudo true </dev/null >/dev/null 2>&1
+"
+
+  REMOTE_SUDOERS_CMD="
+set -euo pipefail
+
+run_root() {
+  if [ \"\$(id -u)\" -eq 0 ]; then
+    \"\$@\"
+    return 0
+  fi
+
+  if command -v sudo >/dev/null 2>&1; then
+    sudo \"\$@\" || {
+      echo 'sudo indisponible pour installer sudoers' >&2
+      exit 1
+    }
+    return 0
+  fi
+
+  echo 'ni root ni sudo disponible pour sudoers' >&2
+  exit 1
+}
+
+if ! command -v visudo >/dev/null 2>&1; then
+  run_root apt-get update
+  run_root apt-get install -y sudo
+fi
+
+TMP_SUDOERS_FILE=\$(mktemp)
+cat >\"\$TMP_SUDOERS_FILE\" <<EOF
+${TARGET_RUNTIME_USER_VALUE} ALL=(root) NOPASSWD: /usr/bin/apt, /usr/bin/apt-get, /usr/bin/systemctl
+${TARGET_RUNTIME_USER_VALUE} ALL=(postgres) NOPASSWD: /usr/bin/psql
+EOF
+
+chmod 440 \"\$TMP_SUDOERS_FILE\"
+
+visudo -cf \"\$TMP_SUDOERS_FILE\" >/dev/null 2>&1 || {
+  rm -f \"\$TMP_SUDOERS_FILE\"
+  echo 'fichier sudoers généré invalide' >&2
+  exit 1
+}
+
+run_root install -m 440 \"\$TMP_SUDOERS_FILE\" /etc/sudoers.d/rebuild-bdd-${TARGET_RUNTIME_USER_VALUE}
+rm -f \"\$TMP_SUDOERS_FILE\"
+  "
+
+  log "Installation du sudoers minimal"
+  if ! ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_SUDOERS_PRECHECK_CMD" >/dev/null 2>&1; then
+    log "Installation du sudoers ignorée : élévation de privilèges indisponible sans interaction."
+  elif ! ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_SUDOERS_CMD" >/dev/null 2>&1; then
+    log "Installation du sudoers ignorée : privilèges root/sudo insuffisants pour cette étape."
+  fi
+else
+  log "Installation du sudoers minimal désactivée."
+fi
+
+REMOTE_REPO_CMD="
+set -euo pipefail
+
+if [[ ! -d $(shell_quote "${TARGET_CLONE_DIR}/.git") ]]; then
+  rm -rf $(shell_quote "$TARGET_CLONE_DIR")
+  git clone --branch $(shell_quote "$TARGET_REPO_BRANCH") --single-branch $(shell_quote "$TARGET_REPO_URL") $(shell_quote "$TARGET_CLONE_DIR")
+else
+  git -C $(shell_quote "$TARGET_CLONE_DIR") fetch --prune origin
+  git -C $(shell_quote "$TARGET_CLONE_DIR") checkout -f $(shell_quote "$TARGET_REPO_BRANCH")
+  git -C $(shell_quote "$TARGET_CLONE_DIR") reset --hard origin/$(shell_quote "$TARGET_REPO_BRANCH")
+fi
+
+chmod 700 $(shell_quote "$TARGET_SCRIPT_DIR/run-rebuild-bdd.sh") 2>/dev/null || true
+chmod 700 $(shell_quote "$TARGET_SCRIPT_DIR/rebuild-bdd-core.sh") 2>/dev/null || true
+chmod 700 $(shell_quote "$TARGET_SCRIPT_DIR/Checkup/check-postgresql.sh") 2>/dev/null || true
+chmod 700 $(shell_quote "$TARGET_SCRIPT_DIR/Checkup/check-target-readiness.sh") 2>/dev/null || true
+
+for required_file in \
+  $(shell_quote "$TARGET_SCRIPT_DIR/run-rebuild-bdd.sh") \
+  $(shell_quote "$TARGET_SCRIPT_DIR/rebuild-bdd-core.sh") \
+  $(shell_quote "$TARGET_SCRIPT_DIR/Checkup/check-postgresql.sh") \
+  $(shell_quote "$TARGET_SCRIPT_DIR/Checkup/check-target-readiness.sh"); do
+  if [[ ! -f \"\$required_file\" ]]; then
+    echo \"fichier requis absent après synchronisation du dépôt : \$required_file\" >&2
+    echo \"vérifier TARGET_REPO_DIR=$(shell_quote "$TARGET_REPO_DIR"), TARGET_REPO_SUBDIR=$(shell_quote "$TARGET_REPO_SUBDIR"), TARGET_REPO_URL=$(shell_quote "$TARGET_REPO_URL"), TARGET_REPO_BRANCH=$(shell_quote "$TARGET_REPO_BRANCH")\" >&2
+    exit 1
+  fi
+done
+"
+
+log "Clone / mise à jour du dépôt distant"
+if [[ "$JSON_ONLY" == "yes" ]]; then
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_REPO_CMD" >/dev/null \
+    || fail "échec de synchronisation du dépôt sur la cible"
+else
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_REPO_CMD" \
+    || fail "échec de synchronisation du dépôt sur la cible"
+fi
+
+REMOTE_VALIDATE_SUDO_ROOT_CMD="
+set -euo pipefail
+command -v sudo >/dev/null 2>&1 || {
+  echo 'sudo absent sur la cible' >&2
+  exit 1
+}
+sudo /usr/bin/systemctl --version >/dev/null 2>&1 || {
+  echo 'sudo indisponible pour systemctl' >&2
+  exit 1
+}
+"
+
+log "Validation initiale de sudo"
+ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_VALIDATE_SUDO_ROOT_CMD" \
+  || fail "sudo invalide sur la cible"
+
+REMOTE_RUN_CHECK_PG_CMD="
+set -euo pipefail
+
+CHECK_SCRIPT=$(shell_quote "${TARGET_SCRIPT_DIR}/Checkup/check-postgresql.sh")
+ENV_FILE=$(shell_quote "$TARGET_ENV_FILE_PATH")
+
+[[ -f \"\$CHECK_SCRIPT\" ]] || {
+  echo \"script PostgreSQL introuvable : \$CHECK_SCRIPT\" >&2
+  echo \"vérifier TARGET_REPO_DIR=$(shell_quote "$TARGET_REPO_DIR") et TARGET_REPO_SUBDIR=$(shell_quote "$TARGET_REPO_SUBDIR")\" >&2
+  exit 1
+}
+[[ -x \"\$CHECK_SCRIPT\" ]] || chmod 700 \"\$CHECK_SCRIPT\"
+
+\"\$CHECK_SCRIPT\" --env-file \"\$ENV_FILE\" --non-interactive
+"
+
+log "Préparation PostgreSQL via check-postgresql.sh"
+if [[ "$JSON_ONLY" == "yes" ]]; then
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_RUN_CHECK_PG_CMD" >/dev/null \
+    || fail "échec de préparation PostgreSQL pendant le bootstrap"
+else
+  ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_RUN_CHECK_PG_CMD" \
+    || fail "échec de préparation PostgreSQL pendant le bootstrap"
+fi
+
+REMOTE_VALIDATE_SUDO_POSTGRES_CMD="
+set -euo pipefail
+sudo -u postgres /usr/bin/psql -d postgres -c 'SELECT 1;' >/dev/null 2>&1 || {
+  echo 'sudo -u postgres indisponible après préparation PostgreSQL' >&2
+  exit 1
+}
+"
+
+log "Validation finale de sudo -u postgres"
+ssh "${SSH_OPTS[@]}" "$REMOTE" "$REMOTE_VALIDATE_SUDO_POSTGRES_CMD" \
+  || fail "sudo -u postgres invalide sur la cible"
+
+success "bootstrap initial terminé pour ${TARGET_NAME}"
--- a/RebuildBdd/create-target-config.sh
+++ b/RebuildBdd/create-target-config.sh
@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CONFIG_DIR="${SCRIPT_DIR}/Config"
+TARGETS_DIR_DEFAULT="${CONFIG_DIR}/Targets"
+
+TARGETS_DIR="${TARGETS_DIR:-$TARGETS_DIR_DEFAULT}"
+
+TARGET=""
+HOST=""
+PORT="22"
+BOOTSTRAP_USER=""
+BOOTSTRAP_SSH_KEY=""
+RUNTIME_USER=""
+REPO_DIR=""
+ENV_FILE=""
+ENV_NAME=""
+PGHOST=""
+PGPORT=""
+PGUSER=""
+PGPASSWORD=""
+DBS=""
+BACKUP_SUBDIR=""
+BACKUP_LOG_DIR=""
+LOCAL_RESTORE_BASE_DIR=""
+SSH_KEY_TARGET_PATH=""
+ENABLE_BOOTSTRAP="yes"
+ALLOW_PASSWORDLESS_SUDO="yes"
+AUTO_INSTALL_POSTGRES="yes"
+AUTO_CREATE_PGUSER="yes"
+PGUSER_SUPERUSER="no"
+AUTO_CONFIGURE_SUDOERS="no"
+REMOTE_ROLES_DIR_NAME="user"
+EXCLUDED_RESTORE_ROLES="postgres"
+FORCE="no"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --targets-dir) TARGETS_DIR="$2"; shift 2 ;;
+    --target) TARGET="$2"; shift 2 ;;
+    --host) HOST="$2"; shift 2 ;;
+    --port) PORT="$2"; shift 2 ;;
+    --bootstrap-user) BOOTSTRAP_USER="$2"; shift 2 ;;
+    --bootstrap-key) BOOTSTRAP_SSH_KEY="$2"; shift 2 ;;
+    --runtime-user) RUNTIME_USER="$2"; shift 2 ;;
+    --repo-dir) REPO_DIR="$2"; shift 2 ;;
+    --env-file) ENV_FILE="$2"; shift 2 ;;
+    --env-name) ENV_NAME="$2"; shift 2 ;;
+    --pghost) PGHOST="$2"; shift 2 ;;
+    --pgport) PGPORT="$2"; shift 2 ;;
+    --pguser) PGUSER="$2"; shift 2 ;;
+    --pgpassword) PGPASSWORD="$2"; shift 2 ;;
+    --dbs) DBS="$2"; shift 2 ;;
+    --backup-subdir) BACKUP_SUBDIR="$2"; shift 2 ;;
+    --backup-log-dir) BACKUP_LOG_DIR="$2"; shift 2 ;;
+    --local-restore-base-dir) LOCAL_RESTORE_BASE_DIR="$2"; shift 2 ;;
+    --ssh-key-target-path) SSH_KEY_TARGET_PATH="$2"; shift 2 ;;
+    --enable-bootstrap) ENABLE_BOOTSTRAP="$2"; shift 2 ;;
+    --allow-passwordless-sudo) ALLOW_PASSWORDLESS_SUDO="$2"; shift 2 ;;
+    --auto-install-postgres) AUTO_INSTALL_POSTGRES="$2"; shift 2 ;;
+    --auto-create-pguser) AUTO_CREATE_PGUSER="$2"; shift 2 ;;
+    --pguser-superuser) PGUSER_SUPERUSER="$2"; shift 2 ;;
+    --auto-configure-sudoers) AUTO_CONFIGURE_SUDOERS="$2"; shift 2 ;;
+    --remote-roles-dir-name) REMOTE_ROLES_DIR_NAME="$2"; shift 2 ;;
+    --excluded-restore-roles) EXCLUDED_RESTORE_ROLES="$2"; shift 2 ;;
+    --force) FORCE="yes"; shift ;;
+    *) echo "Argument inconnu : $1" >&2; exit 1 ;;
+  esac
+done
+
+fail() {
+  echo "ERROR: $*" >&2
+  exit 1
+}
+
+to_bool_yes_no() {
+  local v="${1:-}"
+  v="${v,,}"
+  case "$v" in
+    yes|y|oui|o|true|1) echo "yes" ;;
+    no|n|non|false|0|"") echo "no" ;;
+    *) return 1 ;;
+  esac
+}
+
+[[ -n "$TARGET" ]] || fail "--target manquant"
+[[ "$TARGET" =~ ^[a-zA-Z0-9_-]+$ ]] || fail "target invalide"
+
+[[ -n "$HOST" ]] || fail "--host manquant"
+[[ -n "$BOOTSTRAP_USER" ]] || fail "--bootstrap-user manquant"
+[[ -n "$BOOTSTRAP_SSH_KEY" ]] || fail "--bootstrap-key manquant"
+[[ -n "$REPO_DIR" ]] || fail "--repo-dir manquant"
+[[ -n "$ENV_NAME" ]] || fail "--env-name manquant"
+[[ -n "$PGUSER" ]] || fail "--pguser manquant"
+[[ -n "$PGPASSWORD" ]] || fail "--pgpassword manquant"
+[[ -n "$DBS" ]] || fail "--dbs manquant"
+[[ -n "$BACKUP_SUBDIR" ]] || fail "--backup-subdir manquant"
+[[ "$PORT" =~ ^[0-9]+$ ]] || fail "--port invalide"
+
+[[ -n "$RUNTIME_USER" ]] || RUNTIME_USER="$BOOTSTRAP_USER"
+[[ -n "$ENV_FILE" ]] || ENV_FILE="${REPO_DIR}/.env"
+[[ -n "$PGHOST" ]] || PGHOST="127.0.0.1"
+[[ -n "$PGPORT" ]] || PGPORT="5432"
+[[ "$PGPORT" =~ ^[0-9]+$ ]] || fail "--pgport invalide"
+[[ -n "$BACKUP_LOG_DIR" ]] || BACKUP_LOG_DIR="/home/${RUNTIME_USER}/logs/rebuild_bdd"
+[[ -n "$LOCAL_RESTORE_BASE_DIR" ]] || LOCAL_RESTORE_BASE_DIR="${REPO_DIR}/restore_tmp"
+[[ -n "$SSH_KEY_TARGET_PATH" ]] || SSH_KEY_TARGET_PATH="/home/${RUNTIME_USER}/.ssh/id_ed25519_backup_readonly"
+
+ENABLE_BOOTSTRAP="$(to_bool_yes_no "$ENABLE_BOOTSTRAP")" || fail "--enable-bootstrap invalide"
+ALLOW_PASSWORDLESS_SUDO="$(to_bool_yes_no "$ALLOW_PASSWORDLESS_SUDO")" || fail "--allow-passwordless-sudo invalide"
+AUTO_INSTALL_POSTGRES="$(to_bool_yes_no "$AUTO_INSTALL_POSTGRES")" || fail "--auto-install-postgres invalide"
+AUTO_CREATE_PGUSER="$(to_bool_yes_no "$AUTO_CREATE_PGUSER")" || fail "--auto-create-pguser invalide"
+PGUSER_SUPERUSER="$(to_bool_yes_no "$PGUSER_SUPERUSER")" || fail "--pguser-superuser invalide"
+AUTO_CONFIGURE_SUDOERS="$(to_bool_yes_no "$AUTO_CONFIGURE_SUDOERS")" || fail "--auto-configure-sudoers invalide"
+
+mkdir -p "$TARGETS_DIR" || fail "impossible de créer $TARGETS_DIR"
+
+TARGET_FILE="${TARGETS_DIR}/${TARGET}.env"
+if [[ -f "$TARGET_FILE" && "$FORCE" != "yes" ]]; then
+  fail "fichier déjà existant : $TARGET_FILE (utiliser --force pour écraser)"
+fi
+
+cat >"$TARGET_FILE" <<EOF
+TARGET_HOST=$(printf '%q' "$HOST")
+TARGET_PORT=$(printf '%q' "$PORT")
+TARGET_BOOTSTRAP_USER=$(printf '%q' "$BOOTSTRAP_USER")
+TARGET_BOOTSTRAP_SSH_KEY=$(printf '%q' "$BOOTSTRAP_SSH_KEY")
+TARGET_RUNTIME_USER=$(printf '%q' "$RUNTIME_USER")
+
+TARGET_ENABLE_BOOTSTRAP=$(printf '%q' "$ENABLE_BOOTSTRAP")
+TARGET_BOOTSTRAP_ALLOW_PASSWORDLESS_SUDO=$(printf '%q' "$ALLOW_PASSWORDLESS_SUDO")
+
+TARGET_REPO_DIR=$(printf '%q' "$REPO_DIR")
+TARGET_ENV_FILE=$(printf '%q' "$ENV_FILE")
+
+TARGET_ENV_NAME=$(printf '%q' "$ENV_NAME")
+TARGET_PGHOST=$(printf '%q' "$PGHOST")
+TARGET_PGPORT=$(printf '%q' "$PGPORT")
+TARGET_PGUSER=$(printf '%q' "$PGUSER")
+TARGET_PGPASSWORD=$(printf '%q' "$PGPASSWORD")
+TARGET_DBS=$(printf '%q' "$DBS")
+
+TARGET_BACKUP_SUBDIR=$(printf '%q' "$BACKUP_SUBDIR")
+
+TARGET_BACKUP_LOG_DIR=$(printf '%q' "$BACKUP_LOG_DIR")
+TARGET_LOCAL_RESTORE_BASE_DIR=$(printf '%q' "$LOCAL_RESTORE_BASE_DIR")
+TARGET_SSH_KEY=$(printf '%q' "$SSH_KEY_TARGET_PATH")
+
+TARGET_REMOTE_ROLES_DIR_NAME=$(printf '%q' "$REMOTE_ROLES_DIR_NAME")
+TARGET_EXCLUDED_RESTORE_ROLES=$(printf '%q' "$EXCLUDED_RESTORE_ROLES")
+TARGET_AUTO_INSTALL_POSTGRES=$(printf '%q' "$AUTO_INSTALL_POSTGRES")
+TARGET_AUTO_CREATE_PGUSER=$(printf '%q' "$AUTO_CREATE_PGUSER")
+TARGET_PGUSER_SUPERUSER=$(printf '%q' "$PGUSER_SUPERUSER")
+TARGET_AUTO_CONFIGURE_SUDOERS=$(printf '%q' "$AUTO_CONFIGURE_SUDOERS")
+EOF
+
+chmod 600 "$TARGET_FILE" || fail "chmod impossible sur $TARGET_FILE"
+
+echo "OK: ${TARGET_FILE}"
--- a/RebuildBdd/rebuild-bdd-core.sh
+++ b/RebuildBdd/rebuild-bdd-core.sh
@@ -0,0 +1,501 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DEFAULT_ENV_FILE="${SCRIPT_DIR}/.env"
+
+ENV_FILE="${ENV_FILE:-$DEFAULT_ENV_FILE}"
+
+CLI_DB=""
+CLI_OVERWRITE=""
+CLI_RESTORE_ROLES=""
+CLI_REQUEST_ID=""
+NON_INTERACTIVE="${NON_INTERACTIVE:-no}"
+JSON_ONLY="${JSON_ONLY:-no}"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --env-file)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --env-file" >&2; exit 1; }
+      ENV_FILE="$2"
+      shift 2
+      ;;
+    --db)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --db" >&2; exit 1; }
+      CLI_DB="$2"
+      shift 2
+      ;;
+    --overwrite)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --overwrite" >&2; exit 1; }
+      CLI_OVERWRITE="$2"
+      shift 2
+      ;;
+    --restore-roles)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --restore-roles" >&2; exit 1; }
+      CLI_RESTORE_ROLES="$2"
+      shift 2
+      ;;
+    --request-id)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --request-id" >&2; exit 1; }
+      CLI_REQUEST_ID="$2"
+      shift 2
+      ;;
+    --non-interactive)
+      NON_INTERACTIVE="yes"
+      shift
+      ;;
+    --json-only)
+      JSON_ONLY="yes"
+      shift
+      ;;
+    *)
+      echo "Argument inconnu : $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+json_escape() {
+  python3 - <<'PY' "$1"
+import json, sys
+print(json.dumps(sys.argv[1]))
+PY
+}
+
+print_json_and_exit() {
+  local status="$1"
+  local message="$2"
+  local exit_code="$3"
+
+  printf '{'
+  printf '"status":%s,' "$(json_escape "$status")"
+  printf '"message":%s,' "$(json_escape "$message")"
+  printf '"request_id":%s,' "$(json_escape "${REQUEST_ID:-}")"
+  printf '"environment":%s,' "$(json_escape "${ENV_NAME:-}")"
+  printf '"database":%s,' "$(json_escape "${DB:-}")"
+  printf '"dump_file":%s,' "$(json_escape "${LAST_REMOTE_DB_DUMP:-}")"
+  printf '"log_file":%s' "$(json_escape "${LOG_FILE:-}")"
+  printf '}\n'
+  exit "$exit_code"
+}
+
+print_stdout() {
+  [[ "$JSON_ONLY" == "yes" ]] || echo "$*"
+}
+
+log() {
+  local msg="[$(date '+%Y-%m-%d %H:%M:%S')] $*"
+  echo "$msg" >>"$LOG_FILE"
+  print_stdout "$msg"
+}
+
+fail() {
+  log "ERROR: $*"
+  print_json_and_exit "error" "$*" 1
+}
+
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1
+}
+
+download_remote_file() {
+  local remote_path="$1"
+  local local_path="$2"
+  local local_dir
+
+  local_dir="$(dirname "$local_path")"
+  mkdir -p "$local_dir" || fail "impossible de créer le dossier local de restauration : $local_dir"
+
+  if scp "${SCP_OPTS[@]}" "${REMOTE_SSH}:${remote_path}" "$local_path" >>"$LOG_FILE" 2>&1; then
+    return 0
+  fi
+
+  log "Téléchargement scp standard échoué, tentative avec scp -O"
+  scp -O "${SCP_OPTS[@]}" "${REMOTE_SSH}:${remote_path}" "$local_path" >>"$LOG_FILE" 2>&1
+}
+
+to_bool_yes_no() {
+  local v="${1:-}"
+  v="${v,,}"
+  case "$v" in
+    yes|y|oui|o|true|1) echo "yes" ;;
+    no|n|non|false|0|"") echo "no" ;;
+    *) return 1 ;;
+  esac
+}
+
+is_tty() {
+  [[ -t 0 && -t 1 ]]
+}
+
+sql_escape_literal() {
+  local s="${1:-}"
+  s="${s//\'/\'\'}"
+  printf "%s" "$s"
+}
+
+build_excluded_roles_regex() {
+  local roles_string="${1:-}"
+  local role
+  local -a escaped_roles=()
+
+  read -r -a roles_array <<< "$roles_string"
+
+  for role in "${roles_array[@]}"; do
+    [[ -n "$role" ]] || continue
+    [[ "$role" =~ ^[a-zA-Z0-9_][a-zA-Z0-9_-]*$ ]] || continue
+    escaped_roles+=("$role")
+  done
+
+  if [[ "${#escaped_roles[@]}" -eq 0 ]]; then
+    return 1
+  fi
+
+  local joined=""
+  local first="yes"
+  for role in "${escaped_roles[@]}"; do
+    if [[ "$first" == "yes" ]]; then
+      joined="$role"
+      first="no"
+    else
+      joined+="|$role"
+    fi
+  done
+
+  printf '%s' "$joined"
+}
+
+cleanup() {
+  rm -f \
+    "${LOCAL_DB_DUMP_FILE:-}" \
+    "${LOCAL_ROLES_FILE:-}" \
+    "${FILTERED_ROLES_FILE:-}" \
+    "${ROLES_CREATE_LIST:-}" \
+    "${ROLES_APPLY_FILE:-}"
+}
+trap cleanup EXIT
+
+[[ -f "$ENV_FILE" ]] || {
+  echo '{"status":"error","message":"fichier .env cible introuvable"}'
+  exit 1
+}
+
+set -a
+# shellcheck disable=SC1090
+source "$ENV_FILE"
+set +a
+
+: "${ENV_NAME:?Variable ENV_NAME manquante}"
+: "${PGHOST:?Variable PGHOST manquante}"
+: "${PGPORT:?Variable PGPORT manquante}"
+: "${PGUSER:?Variable PGUSER manquante}"
+: "${PGPASSWORD:?Variable PGPASSWORD manquante}"
+: "${DBS:?Variable DBS manquante}"
+: "${BACKUP_REMOTE_USER:?Variable BACKUP_REMOTE_USER manquante}"
+: "${BACKUP_REMOTE_HOST:?Variable BACKUP_REMOTE_HOST manquante}"
+: "${BACKUP_REMOTE_DIR:?Variable BACKUP_REMOTE_DIR manquante}"
+: "${SSH_KEY:?Variable SSH_KEY manquante}"
+: "${BACKUP_LOG_DIR:?Variable BACKUP_LOG_DIR manquante}"
+
+LOCAL_RESTORE_BASE_DIR="${LOCAL_RESTORE_BASE_DIR:-${SCRIPT_DIR}/restore_tmp}"
+REMOTE_ROLES_DIR_NAME="${REMOTE_ROLES_DIR_NAME:-user}"
+SSH_CONNECT_TIMEOUT="${SSH_CONNECT_TIMEOUT:-8}"
+BACKUP_REMOTE_SSH_PORT="${BACKUP_REMOTE_SSH_PORT:-22}"
+DISCORD_WEBHOOK_URL="${DISCORD_WEBHOOK_URL:-}"
+EXCLUDED_RESTORE_ROLES="${EXCLUDED_RESTORE_ROLES:-postgres}"
+
+REQUEST_ID="${CLI_REQUEST_ID:-${REQUEST_ID:-}}"
+REQUESTED_DB="${CLI_DB:-${REQUESTED_DB:-}}"
+ALLOW_OVERWRITE_RAW="${CLI_OVERWRITE:-${ALLOW_OVERWRITE:-no}}"
+RESTORE_ROLES_RAW="${CLI_RESTORE_ROLES:-${RESTORE_ROLES:-yes}}"
+
+ALLOW_OVERWRITE="$(to_bool_yes_no "$ALLOW_OVERWRITE_RAW")" || {
+  echo '{"status":"error","message":"ALLOW_OVERWRITE invalide"}'
+  exit 1
+}
+
+RESTORE_ROLES="$(to_bool_yes_no "$RESTORE_ROLES_RAW")" || {
+  echo '{"status":"error","message":"RESTORE_ROLES invalide"}'
+  exit 1
+}
+
+[[ "$PGPORT" =~ ^[0-9]+$ ]] || fail "PGPORT invalide"
+[[ "$BACKUP_REMOTE_SSH_PORT" =~ ^[0-9]+$ ]] || fail "BACKUP_REMOTE_SSH_PORT invalide"
+
+mkdir -p "$BACKUP_LOG_DIR" || {
+  echo '{"status":"error","message":"impossible de créer le dossier de logs"}'
+  exit 1
+}
+
+TIMESTAMP="$(date '+%Y-%m-%d_%H-%M-%S')"
+SAFE_REQUEST_ID="${REQUEST_ID:-manual}"
+SAFE_REQUEST_ID="${SAFE_REQUEST_ID//[^a-zA-Z0-9_.-]/_}"
+
+LOG_FILE="${BACKUP_LOG_DIR}/restore_${ENV_NAME,,}_${SAFE_REQUEST_ID}_${TIMESTAMP}.log"
+touch "$LOG_FILE" || {
+  echo '{"status":"error","message":"impossible de créer le log"}'
+  exit 1
+}
+
+LOCAL_RESTORE_DIR="${LOCAL_RESTORE_BASE_DIR}/${SAFE_REQUEST_ID}_${TIMESTAMP}"
+mkdir -p "$LOCAL_RESTORE_DIR" || fail "impossible de créer le dossier temporaire local"
+
+EXCLUDED_ROLES_REGEX=""
+if EXCLUDED_ROLES_REGEX="$(build_excluded_roles_regex "$EXCLUDED_RESTORE_ROLES")"; then
+  log "Rôles exclus de la restauration : $EXCLUDED_RESTORE_ROLES"
+else
+  log "Aucun rôle exclu de la restauration."
+fi
+
+for cmd in ssh scp psql pg_restore createdb dropdb python3 grep sed find basename curl; do
+  require_cmd "$cmd" || fail "commande requise absente : $cmd"
+done
+
+CHECK_SCRIPT="${SCRIPT_DIR}/Checkup/check-postgresql.sh"
+if [[ -x "$CHECK_SCRIPT" ]]; then
+  log "Précheck PostgreSQL déjà effectué par check-target-readiness.sh"
+else
+  fail "script introuvable ou non exécutable : $CHECK_SCRIPT"
+fi
+
+[[ -f "$SSH_KEY" ]] || fail "clé SSH source backup introuvable : $SSH_KEY"
+[[ -r "$SSH_KEY" ]] || fail "clé SSH source backup non lisible : $SSH_KEY"
+
+export PGPASSWORD
+
+SSH_OPTS=(
+  -i "$SSH_KEY"
+  -p "$BACKUP_REMOTE_SSH_PORT"
+  -o IdentitiesOnly=yes
+  -o BatchMode=yes
+  -o ConnectTimeout="$SSH_CONNECT_TIMEOUT"
+  -o StrictHostKeyChecking=yes
+)
+
+SCP_OPTS=(
+  -i "$SSH_KEY"
+  -P "$BACKUP_REMOTE_SSH_PORT"
+  -o IdentitiesOnly=yes
+  -o BatchMode=yes
+  -o ConnectTimeout="$SSH_CONNECT_TIMEOUT"
+  -o StrictHostKeyChecking=yes
+)
+
+REMOTE_SSH="${BACKUP_REMOTE_USER}@${BACKUP_REMOTE_HOST}"
+
+read -r -a DBS_ARRAY <<< "$DBS"
+[[ "${#DBS_ARRAY[@]}" -gt 0 ]] || fail "aucune base définie dans DBS"
+
+if [[ -z "$REQUESTED_DB" ]]; then
+  if [[ "$NON_INTERACTIVE" == "yes" ]]; then
+    fail "REQUESTED_DB manquante en mode non interactif"
+  fi
+
+  if is_tty; then
+    print_stdout "Bases disponibles :"
+    for i in "${!DBS_ARRAY[@]}"; do
+      print_stdout "  $((i + 1))) ${DBS_ARRAY[$i]}"
+    done
+    echo
+    read -r -p "Sélectionnez le numéro de la base à restaurer : " DB_INDEX
+    [[ "$DB_INDEX" =~ ^[0-9]+$ ]] || fail "numéro de base invalide"
+    (( DB_INDEX >= 1 && DB_INDEX <= ${#DBS_ARRAY[@]} )) || fail "numéro hors plage"
+    REQUESTED_DB="${DBS_ARRAY[$((DB_INDEX - 1))]}"
+  else
+    fail "REQUESTED_DB manquante et aucune interaction terminal disponible"
+  fi
+fi
+
+DB=""
+for candidate in "${DBS_ARRAY[@]}"; do
+  if [[ "$candidate" == "$REQUESTED_DB" ]]; then
+    DB="$candidate"
+    break
+  fi
+done
+
+[[ -n "$DB" ]] || fail "base refusée : non présente dans DBS"
+[[ "$DB" =~ ^[a-zA-Z0-9_]+$ ]] || fail "nom de base invalide"
+
+log "Environnement : $ENV_NAME"
+log "Base cible : $DB"
+log "Request ID : ${REQUEST_ID:-N/A}"
+log "Overwrite : $ALLOW_OVERWRITE"
+log "Restore roles : $RESTORE_ROLES"
+
+if ! psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -c "SELECT 1;" \
+  >>"$LOG_FILE" 2>&1; then
+  fail "connexion PostgreSQL locale impossible avec PGUSER=${PGUSER}"
+fi
+
+log "Test SSH vers ${REMOTE_SSH}"
+if ! ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" "exit 0" >>"$LOG_FILE" 2>&1; then
+  fail "connexion SSH impossible vers ${REMOTE_SSH}"
+fi
+
+REMOTE_DB_DIR="${BACKUP_REMOTE_DIR}/${DB}"
+REMOTE_ROLES_DIR="${BACKUP_REMOTE_DIR}/${REMOTE_ROLES_DIR_NAME}"
+
+LAST_REMOTE_DB_DUMP="$(
+  ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" \
+    "find '${REMOTE_DB_DIR}' -maxdepth 1 -type f -name '${DB}_*.dump' | LC_ALL=C sort | tail -n 1"
+)"
+
+[[ -n "$LAST_REMOTE_DB_DUMP" ]] || fail "aucun dump trouvé pour ${DB} dans ${REMOTE_DB_DIR}"
+log "Dernier dump sélectionné : ${LAST_REMOTE_DB_DUMP}"
+
+LAST_REMOTE_ROLES_FILE=""
+if [[ "$RESTORE_ROLES" == "yes" ]]; then
+  LAST_REMOTE_ROLES_FILE="$(
+    ssh "${SSH_OPTS[@]}" "$REMOTE_SSH" \
+      "find '${REMOTE_ROLES_DIR}' -maxdepth 1 -type f -name 'user_*.sql' | LC_ALL=C sort | tail -n 1"
+  )"
+  if [[ -n "$LAST_REMOTE_ROLES_FILE" ]]; then
+    log "Dernier fichier rôles sélectionné : ${LAST_REMOTE_ROLES_FILE}"
+  else
+    log "Aucun fichier rôles trouvé ; la restauration des rôles sera ignorée."
+  fi
+else
+  log "Restauration des rôles désactivée."
+fi
+
+LOCAL_DB_DUMP_FILE="${LOCAL_RESTORE_DIR}/$(basename "$LAST_REMOTE_DB_DUMP")"
+LOCAL_ROLES_FILE=""
+
+log "Téléchargement du dump principal"
+download_remote_file "$LAST_REMOTE_DB_DUMP" "$LOCAL_DB_DUMP_FILE" \
+  || fail "échec téléchargement du dump principal"
+
+if [[ -n "$LAST_REMOTE_ROLES_FILE" ]]; then
+  LOCAL_ROLES_FILE="${LOCAL_RESTORE_DIR}/$(basename "$LAST_REMOTE_ROLES_FILE")"
+  log "Téléchargement du fichier des rôles"
+  download_remote_file "$LAST_REMOTE_ROLES_FILE" "$LOCAL_ROLES_FILE" \
+    || fail "échec téléchargement du fichier des rôles"
+fi
+
+DB_EXISTS="$(
+  psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
+    "SELECT 1 FROM pg_database WHERE datname='$(sql_escape_literal "$DB")'" \
+    2>>"$LOG_FILE" || true
+)"
+
+if [[ "$DB_EXISTS" == "1" ]]; then
+  if [[ "$ALLOW_OVERWRITE" != "yes" ]]; then
+    if [[ "$NON_INTERACTIVE" == "yes" || ! -t 0 ]]; then
+      fail "la base existe déjà et overwrite n'est pas autorisé"
+    fi
+
+    read -r -p "La base '${DB}' existe déjà. Voulez-vous l'écraser ? (oui/non) : " CONFIRM_OVERWRITE
+    CONFIRM_OVERWRITE="$(to_bool_yes_no "$CONFIRM_OVERWRITE")" || fail "réponse overwrite invalide"
+    [[ "$CONFIRM_OVERWRITE" == "yes" ]] || fail "restauration annulée par l'utilisateur"
+  fi
+
+  log "Suppression de la base existante : ${DB}"
+  dropdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" --if-exists "$DB" \
+    >>"$LOG_FILE" 2>&1 || fail "échec suppression base ${DB}"
+fi
+
+if [[ -n "$LOCAL_ROLES_FILE" ]]; then
+  log "Restauration des rôles depuis : ${LOCAL_ROLES_FILE}"
+
+  FILTERED_ROLES_FILE="${LOCAL_RESTORE_DIR}/filtered_$(basename "$LOCAL_ROLES_FILE")"
+  ROLES_CREATE_LIST="${LOCAL_RESTORE_DIR}/roles_to_create_$(basename "$LOCAL_ROLES_FILE")"
+  ROLES_APPLY_FILE="${LOCAL_RESTORE_DIR}/roles_apply_$(basename "$LOCAL_ROLES_FILE")"
+
+  if [[ -n "$EXCLUDED_ROLES_REGEX" ]]; then
+    grep -viE "^(CREATE ROLE|ALTER ROLE) (${EXCLUDED_ROLES_REGEX})\\b" "$LOCAL_ROLES_FILE" \
+      > "$FILTERED_ROLES_FILE" || true
+  else
+    cp "$LOCAL_ROLES_FILE" "$FILTERED_ROLES_FILE"
+  fi
+
+  # Une exécution sous un rôle non superuser ne peut pas restaurer l'attribut
+  # SUPERUSER ; on ignore donc ces lignes pour laisser passer le reste.
+  sed -i -E '/^ALTER ROLE .* (NO)?SUPERUSER\b/d' "$FILTERED_ROLES_FILE"
+
+  log "Fichier des rôles filtré généré : ${FILTERED_ROLES_FILE}"
+
+  sed -nE 's/^CREATE ROLE "?([^" ;]+)"?;$/\1/p' "$FILTERED_ROLES_FILE" \
+    > "$ROLES_CREATE_LIST" || true
+
+  if [[ -s "$ROLES_CREATE_LIST" ]]; then
+    while IFS= read -r role_name; do
+      [[ -n "$role_name" ]] || continue
+      [[ "$role_name" =~ ^[a-zA-Z0-9_][a-zA-Z0-9_-]*$ ]] || {
+        log "Rôle ignoré car non conforme : ${role_name}"
+        continue
+      }
+
+      ROLE_EXISTS="$(
+        psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
+          "SELECT 1 FROM pg_roles WHERE rolname='$(sql_escape_literal "$role_name")'" \
+          2>>"$LOG_FILE" || true
+      )"
+
+      if [[ "$ROLE_EXISTS" != "1" ]]; then
+        log "Création du rôle manquant : ${role_name}"
+        psql -v ON_ERROR_STOP=1 \
+          -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres \
+          -c "CREATE ROLE \"${role_name}\";" \
+          >>"$LOG_FILE" 2>&1 || fail "échec création rôle ${role_name}"
+      else
+        log "Rôle déjà présent : ${role_name}"
+      fi
+    done < "$ROLES_CREATE_LIST"
+  fi
+
+  grep -viE '^CREATE ROLE ' "$FILTERED_ROLES_FILE" > "$ROLES_APPLY_FILE" || true
+
+  log "Application ALTER ROLE / privilèges / memberships"
+  psql -v ON_ERROR_STOP=1 \
+    -h "$PGHOST" \
+    -p "$PGPORT" \
+    -U "$PGUSER" \
+    -d postgres \
+    -f "$ROLES_APPLY_FILE" \
+    >>"$LOG_FILE" 2>&1 || fail "échec restauration rôles"
+else
+  log "Aucune restauration des rôles effectuée."
+fi
+
+log "Création de la base : ${DB}"
+createdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB" \
+  >>"$LOG_FILE" 2>&1 || fail "échec création base ${DB}"
+
+log "Restauration de la base ${DB}"
+pg_restore \
+  -h "$PGHOST" \
+  -p "$PGPORT" \
+  -U "$PGUSER" \
+  -d "$DB" \
+  --clean \
+  --if-exists \
+  --no-owner \
+  --no-privileges \
+  "$LOCAL_DB_DUMP_FILE" \
+  >>"$LOG_FILE" 2>&1 || fail "échec restauration base ${DB}"
+
+send_discord_message() {
+  local message="$1"
+  local payload=""
+
+  [[ -n "$DISCORD_WEBHOOK_URL" ]] || return 0
+
+  payload="$(python3 -c 'import json,sys; print(json.dumps({"content": sys.argv[1]}))' "$message")" || return 0
+
+  curl -sS -X POST "$DISCORD_WEBHOOK_URL" \
+    -H "Content-Type: application/json" \
+    -d "$payload" \
+    >/dev/null || true
+}
+
+SUCCESS_MESSAGE="✅ REBUILD BDD ${ENV_NAME}
+Base restaurée : ${DB}
+Hôte PostgreSQL : ${PGHOST}:${PGPORT}
+Dump utilisé : $(basename "$LAST_REMOTE_DB_DUMP")
+Log : ${LOG_FILE}"
+
+send_discord_message "$SUCCESS_MESSAGE"
+
+log "Restauration terminée avec succès pour ${DB}"
+print_json_and_exit "success" "restauration terminée avec succès" 0
--- a/RebuildBdd/run-rebuild-bdd.sh
+++ b/RebuildBdd/run-rebuild-bdd.sh
@@ -0,0 +1,428 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CONFIG_DIR="${SCRIPT_DIR}/Config"
+GLOBAL_ENV_FILE_DEFAULT="${CONFIG_DIR}/global.env"
+TARGETS_DIR_DEFAULT="${CONFIG_DIR}/Targets"
+GIT_TOPLEVEL="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || true)"
+LOCAL_REPO_SUBDIR_DEFAULT=""
+
+if [[ -n "$GIT_TOPLEVEL" && "$SCRIPT_DIR" == "$GIT_TOPLEVEL"/* ]]; then
+  LOCAL_REPO_SUBDIR_DEFAULT="${SCRIPT_DIR#"$GIT_TOPLEVEL"/}"
+fi
+
+GLOBAL_ENV_FILE="${GLOBAL_ENV_FILE:-$GLOBAL_ENV_FILE_DEFAULT}"
+TARGETS_DIR="${TARGETS_DIR:-$TARGETS_DIR_DEFAULT}"
+
+CLI_TARGET=""
+CLI_DB=""
+CLI_OVERWRITE=""
+CLI_RESTORE_ROLES=""
+CLI_REQUEST_ID=""
+NON_INTERACTIVE="${NON_INTERACTIVE:-no}"
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --global-env-file)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --global-env-file" >&2; exit 1; }
+      GLOBAL_ENV_FILE="$2"
+      shift 2
+      ;;
+    --targets-dir)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --targets-dir" >&2; exit 1; }
+      TARGETS_DIR="$2"
+      shift 2
+      ;;
+    --target)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --target" >&2; exit 1; }
+      CLI_TARGET="$2"
+      shift 2
+      ;;
+    --db)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --db" >&2; exit 1; }
+      CLI_DB="$2"
+      shift 2
+      ;;
+    --overwrite)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --overwrite" >&2; exit 1; }
+      CLI_OVERWRITE="$2"
+      shift 2
+      ;;
+    --restore-roles)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --restore-roles" >&2; exit 1; }
+      CLI_RESTORE_ROLES="$2"
+      shift 2
+      ;;
+    --request-id)
+      [[ $# -ge 2 ]] || { echo "Argument manquant pour --request-id" >&2; exit 1; }
+      CLI_REQUEST_ID="$2"
+      shift 2
+      ;;
+    --non-interactive)
+      NON_INTERACTIVE="yes"
+      shift
+      ;;
+    *)
+      echo "Argument inconnu : $1" >&2
+      exit 1
+      ;;
+  esac
+done
+
+log() {
+  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
+}
+
+fail() {
+  log "ERROR: $*" >&2
+  exit 1
+}
+
+require_cmd() {
+  command -v "$1" >/dev/null 2>&1 || fail "commande requise absente : $1"
+}
+
+to_bool_yes_no() {
+  local v="${1:-}"
+  v="${v,,}"
+  case "$v" in
+    yes|y|oui|o|true|1) echo "yes" ;;
+    no|n|non|false|0|"") echo "no" ;;
+    *) return 1 ;;
+  esac
+}
+
+is_tty() {
+  [[ -t 0 && -t 1 ]]
+}
+
+shell_quote() {
+  printf "%q" "$1"
+}
+
+cleanup() {
+  rm -f "${BOOTSTRAP_JSON:-}" "${REMOTE_RESULT_JSON:-}"
+}
+trap cleanup EXIT
+
+[[ -f "$GLOBAL_ENV_FILE" ]] || fail "fichier global introuvable : $GLOBAL_ENV_FILE"
+[[ -d "$TARGETS_DIR" ]] || fail "dossier targets introuvable : $TARGETS_DIR"
+
+set -a
+# shellcheck disable=SC1090
+source "$GLOBAL_ENV_FILE"
+set +a
+
+require_cmd ssh
+require_cmd git
+require_cmd python3
+
+TARGET="${CLI_TARGET:-${TARGET:-}}"
+REQUESTED_DB="${CLI_DB:-${REQUESTED_DB:-}}"
+ALLOW_OVERWRITE_RAW="${CLI_OVERWRITE:-${ALLOW_OVERWRITE:-no}}"
+RESTORE_ROLES_RAW="${CLI_RESTORE_ROLES:-${RESTORE_ROLES:-yes}}"
+REQUEST_ID="${CLI_REQUEST_ID:-${REQUEST_ID:-$(date '+%Y%m%d%H%M%S')_$RANDOM}}"
+
+ALLOW_OVERWRITE="$(to_bool_yes_no "$ALLOW_OVERWRITE_RAW")" || fail "ALLOW_OVERWRITE invalide"
+RESTORE_ROLES="$(to_bool_yes_no "$RESTORE_ROLES_RAW")" || fail "RESTORE_ROLES invalide"
+
+if [[ -z "$TARGET" ]]; then
+  if [[ "$NON_INTERACTIVE" == "yes" ]]; then
+    fail "TARGET manquante en mode non interactif"
+  fi
+
+  mapfile -t TARGET_LIST < <(find "$TARGETS_DIR" -maxdepth 1 -type f -name '*.env' -printf '%f\n' | sed 's/\.env$//' | LC_ALL=C sort)
+
+  [[ "${#TARGET_LIST[@]}" -gt 0 ]] || fail "aucune cible définie dans ${TARGETS_DIR}"
+
+  if is_tty; then
+    echo "Cibles disponibles :"
+    for i in "${!TARGET_LIST[@]}"; do
+      echo "  $((i + 1))) ${TARGET_LIST[$i]}"
+    done
+    echo
+    read -r -p "Sélectionnez le numéro de la cible : " TARGET_INDEX
+    [[ "$TARGET_INDEX" =~ ^[0-9]+$ ]] || fail "numéro de cible invalide"
+    (( TARGET_INDEX >= 1 && TARGET_INDEX <= ${#TARGET_LIST[@]} )) || fail "numéro hors plage"
+    TARGET="${TARGET_LIST[$((TARGET_INDEX - 1))]}"
+  else
+    fail "TARGET manquante et aucune interaction terminal disponible"
+  fi
+fi
+
+TARGET_ENV_SOURCE="${TARGETS_DIR}/${TARGET}.env"
+[[ -f "$TARGET_ENV_SOURCE" ]] || fail "fichier cible introuvable : $TARGET_ENV_SOURCE"
+
+set -a
+# shellcheck disable=SC1090
+source "$TARGET_ENV_SOURCE"
+set +a
+
+TARGET_HOST="${TARGET_HOST:-}"
+TARGET_PORT="${TARGET_PORT:-22}"
+TARGET_USER="${TARGET_BOOTSTRAP_USER:-}"
+TARGET_SSH_KEY="${TARGET_BOOTSTRAP_SSH_KEY:-}"
+TARGET_REPO_URL="${TARGET_REPO_URL:-${GLOBAL_REPO_URL:-}}"
+TARGET_REPO_BRANCH="${TARGET_REPO_BRANCH:-${GLOBAL_REPO_BRANCH:-main}}"
+TARGET_REPO_DIR="${TARGET_REPO_DIR:-}"
+TARGET_REPO_SUBDIR="${TARGET_REPO_SUBDIR:-$LOCAL_REPO_SUBDIR_DEFAULT}"
+TARGET_ENV_FILE="${TARGET_ENV_FILE:-}"
+TARGET_ENABLE_BOOTSTRAP="${TARGET_ENABLE_BOOTSTRAP:-${GLOBAL_ENABLE_BOOTSTRAP:-yes}}"
+
+[[ -n "$TARGET_HOST" ]] || fail "TARGET_HOST manquante"
+[[ "$TARGET_PORT" =~ ^[0-9]+$ ]] || fail "TARGET_PORT invalide"
+[[ -n "$TARGET_USER" ]] || fail "TARGET_BOOTSTRAP_USER manquante"
+[[ -n "$TARGET_SSH_KEY" ]] || fail "TARGET_BOOTSTRAP_SSH_KEY manquante"
+[[ -f "$TARGET_SSH_KEY" ]] || fail "clé SSH cible introuvable : $TARGET_SSH_KEY"
+[[ -r "$TARGET_SSH_KEY" ]] || fail "clé SSH cible non lisible : $TARGET_SSH_KEY"
+
+[[ -n "$TARGET_REPO_URL" ]] || fail "GLOBAL_REPO_URL/TARGET_REPO_URL manquant"
+[[ -n "$TARGET_REPO_BRANCH" ]] || fail "GLOBAL_REPO_BRANCH/TARGET_REPO_BRANCH manquant"
+[[ -n "$TARGET_REPO_DIR" ]] || fail "TARGET_REPO_DIR manquante"
+[[ -n "$TARGET_ENV_FILE" ]] || fail "TARGET_ENV_FILE manquante"
+
+TARGET_REPO_SUBDIR="${TARGET_REPO_SUBDIR#/}"
+TARGET_REPO_SUBDIR="${TARGET_REPO_SUBDIR%/}"
+
+TARGET_CLONE_DIR="$TARGET_REPO_DIR"
+TARGET_SCRIPT_DIR="$TARGET_REPO_DIR"
+if [[ -n "$TARGET_REPO_SUBDIR" ]]; then
+  if [[ "$TARGET_REPO_DIR" == */"$TARGET_REPO_SUBDIR" ]]; then
+    TARGET_CLONE_DIR="$(dirname "$TARGET_REPO_DIR")"
+  else
+    TARGET_SCRIPT_DIR="${TARGET_REPO_DIR}/${TARGET_REPO_SUBDIR}"
+  fi
+fi
+
+TARGET_ENABLE_BOOTSTRAP="$(to_bool_yes_no "$TARGET_ENABLE_BOOTSTRAP")" || fail "TARGET_ENABLE_BOOTSTRAP invalide"
+
+BOOTSTRAP_SCRIPT_LOCAL="${SCRIPT_DIR}/bootstrap-target-host.sh"
+[[ -f "$BOOTSTRAP_SCRIPT_LOCAL" ]] || fail "script bootstrap introuvable : $BOOTSTRAP_SCRIPT_LOCAL"
+[[ -x "$BOOTSTRAP_SCRIPT_LOCAL" ]] || chmod 700 "$BOOTSTRAP_SCRIPT_LOCAL" || fail "chmod impossible sur $BOOTSTRAP_SCRIPT_LOCAL"
+
+if [[ -z "$REQUESTED_DB" ]]; then
+  DBS_FOR_TARGET="${TARGET_DBS:-}"
+  if [[ "$NON_INTERACTIVE" == "yes" ]]; then
+    fail "REQUESTED_DB manquante en mode non interactif"
+  fi
+
+  read -r -a DBS_ARRAY <<< "$DBS_FOR_TARGET"
+  [[ "${#DBS_ARRAY[@]}" -gt 0 ]] || fail "TARGET_DBS vide"
+
+  if is_tty; then
+    echo "Bases disponibles :"
+    for i in "${!DBS_ARRAY[@]}"; do
+      echo "  $((i + 1))) ${DBS_ARRAY[$i]}"
+    done
+    echo
+    read -r -p "Nom exact de la base à restaurer : " REQUESTED_DB
+  else
+    fail "REQUESTED_DB manquante et aucune interaction terminal disponible"
+  fi
+fi
+
+[[ "$REQUESTED_DB" =~ ^[a-zA-Z0-9_]+$ ]] || fail "nom de base invalide"
+
+if [[ "$TARGET_ENABLE_BOOTSTRAP" == "yes" ]]; then
+  log "Bootstrap initial activé pour la cible ${TARGET}"
+  BOOTSTRAP_JSON="/tmp/bootstrap_target_${REQUEST_ID}.json"
+
+  "$BOOTSTRAP_SCRIPT_LOCAL" \
+    --global-env-file "$GLOBAL_ENV_FILE" \
+    --targets-dir "$TARGETS_DIR" \
+    --target "$TARGET" \
+    --json-only >"$BOOTSTRAP_JSON" || {
+      cat "$BOOTSTRAP_JSON" 2>/dev/null || true
+      fail "échec du bootstrap initial de la cible ${TARGET}"
+    }
+
+  BOOTSTRAP_STATUS="$(
+    python3 - <<'PY' "$BOOTSTRAP_JSON"
+import json, sys
+with open(sys.argv[1], 'r', encoding='utf-8') as f:
+    data = json.load(f)
+print(data.get("status", "error"))
+PY
+  )"
+
+  if [[ "$BOOTSTRAP_STATUS" != "success" ]]; then
+    cat "$BOOTSTRAP_JSON"
+    fail "bootstrap initial échoué pour la cible ${TARGET}"
+  fi
+
+  log "Bootstrap initial terminé pour ${TARGET}"
+else
+  log "Bootstrap initial désactivé pour ${TARGET}"
+fi
+
+SSH_OPTS=(
+  -i "$TARGET_SSH_KEY"
+  -p "$TARGET_PORT"
+  -o IdentitiesOnly=yes
+  -o BatchMode=yes
+  -o StrictHostKeyChecking=accept-new
+  -o ConnectTimeout=8
+)
+
+ssh "${SSH_OPTS[@]}" "${TARGET_USER}@${TARGET_HOST}" "exit 0" >/dev/null 2>&1 \
+  || fail "connexion SSH impossible vers la cible ${TARGET_USER}@${TARGET_HOST}"
+
+TARGET_CORE_SCRIPT="${TARGET_SCRIPT_DIR}/rebuild-bdd-core.sh"
+REMOTE_RESULT_JSON="/tmp/run_rebuild_bdd_${REQUEST_ID}.json"
+
+REMOTE_BOOTSTRAP_CMD="
+set -euo pipefail
+
+CLONE_DIR=$(shell_quote "$TARGET_CLONE_DIR")
+REPO_DIR=$(shell_quote "$TARGET_SCRIPT_DIR")
+REPO_URL=$(shell_quote "$TARGET_REPO_URL")
+REPO_BRANCH=$(shell_quote "$TARGET_REPO_BRANCH")
+CORE_SCRIPT=$(shell_quote "$TARGET_CORE_SCRIPT")
+PRECHECK_SCRIPT=$(shell_quote "${TARGET_SCRIPT_DIR}/Checkup/check-target-readiness.sh")
+TARGET_ENV_FILE=$(shell_quote "$TARGET_ENV_FILE")
+REQUESTED_DB=$(shell_quote "$REQUESTED_DB")
+ALLOW_OVERWRITE=$(shell_quote "$ALLOW_OVERWRITE")
+RESTORE_ROLES=$(shell_quote "$RESTORE_ROLES")
+REQUEST_ID=$(shell_quote "$REQUEST_ID")
+
+command -v git >/dev/null 2>&1 || { echo '{\"status\":\"error\",\"message\":\"git absent sur la cible\"}'; exit 1; }
+command -v bash >/dev/null 2>&1 || { echo '{\"status\":\"error\",\"message\":\"bash absent sur la cible\"}'; exit 1; }
+command -v python3 >/dev/null 2>&1 || { echo '{\"status\":\"error\",\"message\":\"python3 absent sur la cible\"}'; exit 1; }
+
+mkdir -p \"\$(dirname \"\$CLONE_DIR\")\"
+mkdir -p \"\$(dirname \"\$REPO_DIR\")\"
+
+if [[ ! -d \"\$CLONE_DIR/.git\" ]]; then
+  rm -rf \"\$CLONE_DIR\"
+  git clone --branch \"\$REPO_BRANCH\" --single-branch \"\$REPO_URL\" \"\$CLONE_DIR\" >/dev/null 2>&1
+else
+  git -C \"\$CLONE_DIR\" fetch --prune origin >/dev/null 2>&1
+  git -C \"\$CLONE_DIR\" checkout -f \"\$REPO_BRANCH\" >/dev/null 2>&1
+  git -C \"\$CLONE_DIR\" reset --hard \"origin/\$REPO_BRANCH\" >/dev/null 2>&1
+fi
+
+[[ -f \"\$CORE_SCRIPT\" ]] || { echo '{\"status\":\"error\",\"message\":\"script core introuvable sur la cible\"}'; exit 1; }
+[[ -f \"\$PRECHECK_SCRIPT\" ]] || { echo '{\"status\":\"error\",\"message\":\"script précheck introuvable sur la cible\"}'; exit 1; }
+
+chmod 700 \"\$CORE_SCRIPT\"
+chmod 700 \"\$PRECHECK_SCRIPT\"
+
+PRECHECK_JSON=\"/tmp/check_target_\${REQUEST_ID}.json\"
+PRECHECK_STDERR=\"/tmp/check_target_\${REQUEST_ID}.stderr\"
+CORE_JSON=\"/tmp/rebuild_target_\${REQUEST_ID}.json\"
+CORE_STDERR=\"/tmp/rebuild_target_\${REQUEST_ID}.stderr\"
+
+\"\$PRECHECK_SCRIPT\" \
+  --env-file \"\$TARGET_ENV_FILE\" \
+  --request-id \"\$REQUEST_ID\" \
+  --non-interactive \
+  --json-only >\"\$PRECHECK_JSON\" 2>\"\$PRECHECK_STDERR\" || {
+    cat \"\$PRECHECK_STDERR\" >&2 2>/dev/null || true
+    cat \"\$PRECHECK_JSON\" 2>/dev/null || true
+    rm -f \"\$PRECHECK_JSON\" \"\$PRECHECK_STDERR\" \"\$CORE_JSON\" \"\$CORE_STDERR\"
+    exit 1
+  }
+
+PRECHECK_STATUS=\"\$(python3 - <<'PY' \"\$PRECHECK_JSON\"
+import json, sys
+with open(sys.argv[1], 'r', encoding='utf-8') as f:
+    data = json.load(f)
+print(data.get('status', 'error'))
+PY
+)\" || {
+  cat \"\$PRECHECK_STDERR\" >&2 2>/dev/null || true
+  cat \"\$PRECHECK_JSON\" 2>/dev/null || true
+  rm -f \"\$PRECHECK_JSON\" \"\$PRECHECK_STDERR\" \"\$CORE_JSON\" \"\$CORE_STDERR\"
+  exit 1
+}
+
+if [[ \"\$PRECHECK_STATUS\" != \"success\" ]]; then
+  cat \"\$PRECHECK_STDERR\" >&2 2>/dev/null || true
+  cat \"\$PRECHECK_JSON\"
+  rm -f \"\$PRECHECK_JSON\" \"\$PRECHECK_STDERR\" \"\$CORE_JSON\" \"\$CORE_STDERR\"
+  exit 1
+fi
+
+rm -f \"\$PRECHECK_JSON\" \"\$PRECHECK_STDERR\"
+
+\"\$CORE_SCRIPT\" \
+  --env-file \"\$TARGET_ENV_FILE\" \
+  --db \"\$REQUESTED_DB\" \
+  --overwrite \"\$ALLOW_OVERWRITE\" \
+  --restore-roles \"\$RESTORE_ROLES\" \
+  --request-id \"\$REQUEST_ID\" \
+  --non-interactive \
+  --json-only >\"\$CORE_JSON\" 2>\"\$CORE_STDERR\" || {
+    cat \"\$CORE_STDERR\" >&2 2>/dev/null || true
+    cat \"\$CORE_JSON\" 2>/dev/null || true
+    rm -f \"\$CORE_JSON\" \"\$CORE_STDERR\"
+    exit 1
+  }
+
+CORE_STATUS=\"\$(python3 - <<'PY' \"\$CORE_JSON\"
+import json, sys
+with open(sys.argv[1], 'r', encoding='utf-8') as f:
+    data = json.load(f)
+print(data.get('status', 'error'))
+PY
+)\" || {
+  cat \"\$CORE_STDERR\" >&2 2>/dev/null || true
+  cat \"\$CORE_JSON\" 2>/dev/null || true
+  rm -f \"\$CORE_JSON\" \"\$CORE_STDERR\"
+  exit 1
+}
+
+if [[ \"\$CORE_STATUS\" != \"success\" ]]; then
+  cat \"\$CORE_STDERR\" >&2 2>/dev/null || true
+  cat \"\$CORE_JSON\"
+  rm -f \"\$CORE_JSON\" \"\$CORE_STDERR\"
+  exit 1
+fi
+
+cat \"\$CORE_JSON\"
+rm -f \"\$CORE_JSON\" \"\$CORE_STDERR\"
+"
+
+ssh "${SSH_OPTS[@]}" "${TARGET_USER}@${TARGET_HOST}" "$REMOTE_BOOTSTRAP_CMD" >"$REMOTE_RESULT_JSON" 2>&1 \
+  || {
+    cat "$REMOTE_RESULT_JSON" 2>/dev/null || true
+    fail "échec d'exécution distante sur la cible ${TARGET}"
+  }
+
+REMOTE_STATUS="$(
+  python3 - <<'PY' "$REMOTE_RESULT_JSON"
+import json, sys
+with open(sys.argv[1], 'r', encoding='utf-8') as f:
+    data = json.load(f)
+print(data.get("status", "error"))
+PY
+)" || {
+  cat "$REMOTE_RESULT_JSON" 2>/dev/null || true
+  fail "réponse JSON invalide renvoyée par la cible ${TARGET}"
+}
+
+if [[ "$REMOTE_STATUS" != "success" ]]; then
+  cat "$REMOTE_RESULT_JSON"
+  fail "restauration distante échouée pour la cible ${TARGET}"
+fi
+
+python3 - <<'PY' "$REMOTE_RESULT_JSON"
+import json, sys
+
+with open(sys.argv[1], 'r', encoding='utf-8') as f:
+    data = json.load(f)
+
+message = data.get("message", "restauration terminée")
+environment = data.get("environment") or "N/A"
+database = data.get("database") or "N/A"
+request_id = data.get("request_id") or "N/A"
+dump_file = data.get("dump_file") or "N/A"
+log_file = data.get("log_file") or "N/A"
+
+print(f"[{request_id}] {message}")
+print(f"Environnement : {environment}")
+print(f"Base : {database}")
+print(f"Dump : {dump_file}")
+print(f"Log : {log_file}")
+PY
--- a/RecetteScripts/.env.exemple
+++ b/RecetteScripts/.env.exemple
@@ -1,81 +0,0 @@
-#############################################
-# ENVIRONNEMENT
-#############################################
-
-# Nom de l'environnement (ex: DEV / RECETTE / PROD)
-ENV_NAME=RECETTE
-
-#############################################
-# POSTGRESQL
-#############################################
-
-# Host PostgreSQL
-PGHOST=localhost
-
-# Port PostgreSQL
-PGPORT=5432
-
-# Utilisateur utilisé pour les dumps
-PGUSER=nom_de_user
-
-# Mot de passe PostgreSQL
-PGPASSWORD=change_me_secure_password
-
-# Bases à sauvegarder (séparées par espace)
-DBS="sirh inventory ferme"
-
-#############################################
-# SERVEUR DE STOCKAGE DES BACKUPS
-#############################################
-
-# Utilisateur du serveur distant
-BACKUP_REMOTE_USER=nom_de_user
-
-# Host ou IP du serveur distant
-BACKUP_REMOTE_HOST=192.168.1.50
-
-# Dossier distant pour stocker les backups
-BACKUP_REMOTE_DIR=/home/nom_de_user/backups/bdd-recette
-
-#############################################
-# SSH
-#############################################
-
-# Clé SSH utilisée pour envoyer les dumps
-SSH_KEY=/home/nom_de_user/.ssh/id_ed25519_backup
-
-# Timeout SSH (secondes)
-SSH_TIMEOUT=10
-
-#############################################
-# LOGS
-#############################################
-
-# Dossier des logs backup
-BACKUP_LOG_DIR=/var/log/pg_backup
-
-# Dossier logs monitoring apps
-APP_LOG_DIR=/var/log/app_health
-
-#############################################
-# DISCORD
-#############################################
-
-# Webhook Discord pour notifications
-DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/xxxxxxxxxxxxxxxx/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-
-# Ping en cas d'erreur
-DISCORD_PING=@here
-
-#############################################
-# HEALTH CHECK APPS
-#############################################
-
-# Timeout connexion HTTP
-CHECK_CONNECT_TIMEOUT=3
-
-# Timeout total curl
-CHECK_MAX_TIME=8
-
-# Applications à vérifier
-APP_URLS="ferme.example.local sirh.example.local inventory.example.local"
--- a/RecetteScripts/README.md
+++ b/RecetteScripts/README.md
@@ -1,121 +1,378 @@
-# Scripts Recette
+# RecetteScripts 

-Ce dossier contient les scripts utilisés pour l’environnement **RECETTE** du projet **Ferme**.
+Scripts Bash permettant d’automatiser la gestion d’un environnement **PostgreSQL de recette**.

-Les scripts permettent principalement :
+Ces scripts permettent :

-* la **sauvegarde automatique des bases de données PostgreSQL**
-* la **vérification du statut des applications web**
+* la **sauvegarde automatisée des bases**
+* la **surveillance de la disponibilité des applications**
+* la **reconstruction d’une base à partir d’un dump**
+
+Chaque script possède son propre **fichier `.env` dédié** afin de séparer les configurations.(un global.env.exemple est disponible à la racine du projet)

 ---

-# Scripts disponibles
+# 0. Arborescence du projet

-## backup-bdd-recette.sh
-
-Script permettant de réaliser une **sauvegarde des bases de données PostgreSQL**.
-
-Fonctionnement :
-
-* export des bases PostgreSQL définies dans la configuration
-* export des utilisateurs PostgreSQL
-* création de dumps au format PostgreSQL (`pg_dump -Fc`)
-* transfert des sauvegardes vers un serveur distant
-* génération de logs locaux
-* envoi de notifications Discord en cas de succès ou d’erreur
+```
+RecetteScripts
+│
+├── backup-bdd-recette.sh        # script de sauvegarde PostgreSQL
+├── backup.env.exemple           # exemple de configuration backup
+│
+├── check-statut-recette.sh      # script de monitoring des applications
+├── check-statut.env.exemple     # exemple de configuration monitoring
+│
+├── rebuild-bdd-recette.sh       # script de restauration PostgreSQL
+├── rebuild.env.exemple          # exemple de configuration restauration
+│
+└── README.md
+```

 ---

-## check-statut-recette.sh
+# 1. Principe général

-Script permettant de **vérifier la disponibilité des applications web**.
+Les scripts fonctionnent indépendamment mais utilisent le même principe :

-Le script effectue les vérifications suivantes :
-
-* résolution DNS du site
-* connexion HTTP au service
-* vérification du code HTTP retourné
-
-Une application est considérée :
-
-* **OK** si le code HTTP est entre **200 et 399**
-* **DOWN** si la résolution DNS échoue ou si une erreur HTTP est détectée
-
-Chaque vérification est enregistrée dans un **fichier de log** et une notification peut être envoyée sur **Discord**.
+1. chargement d’un fichier `.env`
+2. vérification des variables obligatoires
+3. exécution de la tâche principale
+4. génération de logs
+5. notification Discord (optionnelle)

 ---

-# Installation
+# 2. Prérequis

-1. Clonez le dépôt Git :
+Environnement Linux recommandé.

-```bash
-git clone https://gitea.malio.fr/MALIO-DEV/Scripts-Serveur.git
+Packages nécessaires :
+
+```
+postgresql-client
+curl
+jq
+ssh
+scp
 ```

-2. Accédez au dossier des scripts :
+Commandes PostgreSQL requises :

-```bash
-cd Scripts-Serveur/RecetteScripts
+```
+pg_dump
+pg_dumpall
+pg_restore
+psql
+createdb
+dropdb
 ```

-3. Copiez le fichier d’environnement :
+---
+### 3 Connexion SSH
+
+Une connexion SSH avec **clé privée** est nécessaire afin de permettre les transferts automatisés de fichiers vers le serveur distant (dump PostgreSQL, rôles, etc.).
+
+### Génération de la clé SSH
+
+Sur la machine exécutant les scripts :

 ```bash
-cp .env.example .env
+ssh-keygen -t ed25519 -f ~/.ssh/id_backup_postgres
 ```

-4. Modifiez les variables du fichier `.env` selon votre configuration.
+Explication :
+
+* `-t ed25519` : algorithme recommandé
+* `-f` : chemin de la clé
+
+Deux fichiers seront créés :
+
+```
+~/.ssh/id_backup_postgres
+~/.ssh/id_backup_postgres.pub
+```

 ---

-# Utilisation
+### Copier la clé sur le serveur distant

-Donnez les permissions d’exécution aux scripts :
+Méthode recommandée :

 ```bash
-chmod +x backup-bdd-recette.sh
-chmod +x check-statut-recette.sh
+ssh-copy-id -i ~/.ssh/id_backup_postgres.pub user@serveur
 ```

-Exécution manuelle :
+Exemple :

 ```bash
+ssh-copy-id -i ~/.ssh/id_backup_postgres.pub backup@192.168.1.50
+```
+
+---
+
+### Vérifier la connexion
+
+Tester la connexion sans mot de passe :
+
+```bash
+ssh -i ~/.ssh/id_backup_postgres backup@192.168.1.50
+```
+
+La connexion doit fonctionner **sans demander de mot de passe**.
+
+---
+
+### Sécuriser les permissions
+
+Les permissions doivent être restreintes :
+
+```bash
+chmod 700 ~/.ssh
+chmod 600 ~/.ssh/id_backup_postgres
+chmod 644 ~/.ssh/id_backup_postgres.pub
+```
+
+---
+
+# 4. Configuration
+
+Chaque script possède un **fichier d’exemple** :
+
+```
+backup.env.exemple
+check-statut.env.exemple
+rebuild.env.exemple
+```
+
+Pour utiliser les scripts :
+
+```
+cp backup.env.exemple .env
+```
+
+Puis modifier les variables.
+
+---
+
+# 5. Script : backup-bdd-recette.sh
+
+Script :
+
+
+## Objectif
+
+Sauvegarder plusieurs bases PostgreSQL et transférer les dumps vers un serveur distant.
+
+---
+
+## Fonctionnement
+
+Le script :
+
+1. charge la configuration `.env`
+2. vérifie les dépendances
+3. empêche l’exécution simultanée (lock)
+4. exporte les rôles PostgreSQL
+5. crée un dump de chaque base
+6. transfère les dumps vers un serveur distant
+7. applique une rotation des sauvegardes
+8. envoie un résumé sur Discord
+
+---
+
+## Format des fichiers
+
+Dump base :
+
+```
+base_TIMESTAMP.dump
+```
+
+Export utilisateurs :
+
+```
+user_TIMESTAMP.sql
+```
+
+---
+
+## Rotation automatique
+
+Suppression des sauvegardes plus anciennes que :
+
+```
+10 jours
+```
+
+---
+
+## Exécution
+
+```
 ./backup-bdd-recette.sh
-./check-statut-recette.sh
 ```

 ---

-# Exécution automatique avec Cron
+# 6. Script : check-statut-recette.sh

-Ouvrez le crontab :
+Script :
+
+
+## Objectif
+
+Vérifier la disponibilité des applications web.
+
+Ce script agit comme un **mini système de monitoring**.
+
+---
+
+## Vérifications
+
+Pour chaque application :
+
+1. résolution DNS
+2. requête HTTP
+3. analyse du code HTTP
+
+Codes valides :

-```bash
-crontab -e
 ```
-
-Exemple de planification :
-
-Backup des bases tous les jours à 19h :
-
-```bash
-0 19 * * * /chemin/vers/le/script/backup-bdd-recette.sh
-```
-
-Vérification des applications tous les jours à 19h :
-
-```bash
-0 19 * * * /chemin/vers/le/script/check-statut-recette.sh
+200 → 399
 ```

 ---

-# Avertissement
+## Exemple de configuration

-Assurez-vous que :
+```
+APP_URLS="ferme.malio-dev.fr sirh.malio-dev.fr inventory.malio-dev.fr"
+```

-* PostgreSQL est accessible depuis la machine exécutant le script
-* la clé SSH pour le transfert des sauvegardes est configurée
-* les variables du fichier `.env` sont correctement renseignées
-* les commandes `curl`, `psql` et `pg_dump` sont installées sur le système
+---
+
+## Logs
+
+Fichier généré :
+
+```
+app_health_YYYY-MM-DD.log
+```
+
+Format :
+
+```
+date | statut | host | détail
+```
+
+---
+
+## Exemple de notification Discord
+
+```
+CHECK APP RECETTE 🟢
+
+✅ ferme.malio-dev.fr : OK
+✅ sirh.malio-dev.fr : OK
+✅ inventory.malio-dev.fr : OK
+```
+
+---
+
+# 7. Script : rebuild-bdd-recette.sh
+
+Script :
+
+
+## Objectif
+
+Restaurer une base PostgreSQL à partir d’un dump distant.
+
+---
+
+## Fonctionnement
+
+Le script :
+
+1. charge la configuration `.env`
+2. installe PostgreSQL si nécessaire
+3. démarre le service PostgreSQL
+4. demande la base à restaurer
+5. récupère le dernier dump sur le serveur distant
+6. récupère le dernier export des rôles
+7. crée les rôles manquants
+8. supprime la base existante si nécessaire
+9. restaure la base via `pg_restore`
+10. envoie une notification Discord
+
+---
+
+## Sélection de la base
+
+Les bases disponibles sont lues depuis :
+
+```
+DBS="sirh inventory ferme"
+```
+
+Exemple :
+
+```
+1) sirh
+2) inventory
+3) ferme
+```
+
+---
+
+## Commande utilisée pour la restauration
+
+```
+pg_restore
+--clean
+--if-exists
+--no-owner
+--no-privileges
+```
+
+Ces options évitent les conflits entre environnements.
+
+---
+
+# 8. Logs
+
+Les scripts produisent des logs détaillés :
+
+```
+backup logs
+restore logs
+app health logs
+```
+
+Ces logs permettent :
+
+* diagnostic des erreurs
+* audit des opérations
+* suivi des backups
+
+---
+
+# 9. Automatisation recommandée
+
+### Backup et check quotidien 
+
+```
+0 19 * * * /scripts/backup-bdd-recette.sh
+0 19 * * * /scripts/check-statut-recette.sh
+```
+
+---
+
+# 10. Bonnes pratiques
+
+Recommandé :
+
+* isoler le **serveur de stockage**
+* vérifier régulièrement les restaurations
+---
--- a/RecetteScripts/backup-bdd-recette.sh
+++ b/RecetteScripts/backup-bdd-recette.sh
@@ -281,7 +281,12 @@ REMOTE_DIR="${IA_BASE_DIR}"

 log "Creating remote directories"

-if ! ssh "${SSH_OPTS[@]}" "$IA_SSH" "mkdir -p '${REMOTE_DIR}/ferme' '${REMOTE_DIR}/sirh' '${REMOTE_DIR}/inventory' '${REMOTE_DIR}/user'"; then
+MKDIR_CMD="mkdir -p '${REMOTE_DIR}/user'"
+for DB in "${DBS_ARRAY[@]}"; do
+  MKDIR_CMD+=" '${REMOTE_DIR}/${DB}'"
+done
+
+if ! ssh "${SSH_OPTS[@]}" "$IA_SSH" "$MKDIR_CMD"; then
  log "ERROR: remote mkdir failed"
  discord_msg_users_error "" "" "Remote mkdir failed"
  exit 1
--- a/RecetteScripts/backup.env.exemple
+++ b/RecetteScripts/backup.env.exemple
@@ -0,0 +1,65 @@
+###############################################################################
+# ENVIRONNEMENT
+###############################################################################
+
+# Nom de l'environnement
+ENV_NAME=RECETTE
+
+###############################################################################
+# POSTGRESQL
+###############################################################################
+
+# Host du serveur PostgreSQL
+PGHOST=localhost
+
+# Port PostgreSQL
+PGPORT=5432
+
+# Utilisateur utilisé pour réaliser les dumps
+PGUSER=
+
+# Mot de passe PostgreSQL
+PGPASSWORD=
+
+# Bases de données à sauvegarder (séparées par des espaces)
+DBS="sirh inventory ferme"
+
+###############################################################################
+# SERVEUR DISTANT DE BACKUP
+###############################################################################
+
+# Utilisateur SSH du serveur de backup
+BACKUP_REMOTE_USER=
+
+# Host ou IP du serveur distant
+BACKUP_REMOTE_HOST=
+
+# Dossier distant où seront stockées les sauvegardes
+BACKUP_REMOTE_DIR=/home/.../backups/bdd-recette
+
+###############################################################################
+# SSH
+###############################################################################
+
+# Clé SSH utilisée pour se connecter au serveur distant
+SSH_KEY=/home/.../.ssh/id_ed25519_backup
+
+# Timeout de connexion SSH (secondes)
+SSH_TIMEOUT=10
+
+###############################################################################
+# LOGS
+###############################################################################
+
+# Dossier où seront stockés les logs du script
+BACKUP_LOG_DIR=/var/log/script/
+
+###############################################################################
+# DISCORD (optionnel)
+###############################################################################
+
+# Webhook Discord pour envoyer les notifications
+DISCORD_WEBHOOK_URL=
+
+# Mention envoyée en cas d'erreur
+DISCORD_PING=@here
--- a/RecetteScripts/check-statut-recette.sh
+++ b/RecetteScripts/check-statut-recette.sh
@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# -e omis volontairement : check_site retourne 1 pour les sites down
 set -uo pipefail

 ###############################################################################
@@ -114,7 +115,6 @@ add_summary_line() {
 #######################################
 # Envoi du message Discord récapitulatif
 #######################################
-
 send_discord_summary() {
  [[ -z "${DISCORD_WEBHOOK_URL:-}" ]] && return 0

@@ -201,6 +201,8 @@ check_site() {
 #######################################

 main() {
+  trap '[[ -n "$STDERR_TMP" ]] && rm -f "$STDERR_TMP"' EXIT
+
  local failures=0

  for site in "${SITES[@]}"; do
--- a/RecetteScripts/check-statut.env.exemple
+++ b/RecetteScripts/check-statut.env.exemple
@@ -0,0 +1,42 @@
+###############################################################################
+# ENVIRONNEMENT
+###############################################################################
+
+# Nom de l'environnement surveillé
+ENV_NAME=RECETTE
+
+###############################################################################
+# LOGS
+###############################################################################
+
+# Dossier où seront stockés les logs du script
+APP_LOG_DIR=/var/log/script
+
+###############################################################################
+# PARAMÈTRES DE VÉRIFICATION HTTP
+###############################################################################
+
+# Timeout de connexion à l'application (secondes)
+# Si le serveur ne répond pas dans ce délai, la connexion échoue
+CHECK_CONNECT_TIMEOUT=5
+
+# Temps maximum total autorisé pour la requête HTTP (secondes)
+CHECK_MAX_TIME=10
+
+###############################################################################
+# APPLICATIONS À SURVEILLER
+###############################################################################
+
+# Liste des applications à vérifier (séparées par des espaces)
+
+APP_URLS="ferme.malio-dev.fr inventory.malio-dev.fr sirh.malio-dev.fr"
+
+###############################################################################
+# DISCORD
+###############################################################################
+
+# Webhook Discord pour envoyer le résumé des vérifications
+DISCORD_WEBHOOK_URL=
+
+# Mention Discord en cas de problème
+DISCORD_PING=@here
--- a/RecetteScripts/rebuild-bdd-recette.sh
+++ b/RecetteScripts/rebuild-bdd-recette.sh
@@ -135,7 +135,7 @@ send_discord_message() {
    return 0
  fi

-  payload="$(python3 -c 'import json,sys; print(json.dumps({"content": sys.argv[1]}))' "$message")" || {
+  payload="$(jq -n --arg content "$message" '{content: $content}')" || {
    log "Impossible de construire le payload JSON Discord."
    return 0
  }
@@ -376,6 +376,10 @@ if [[ -n "$LOCAL_ROLES_FILE" ]]; then
  if [[ -s "$ROLES_CREATE_LIST" ]]; then
    while IFS= read -r role_name; do
      [[ -z "$role_name" ]] && continue
+      if [[ ! "$role_name" =~ ^[a-zA-Z_][a-zA-Z0-9_]*$ ]]; then
+        log "WARNING: nom de rôle suspect ignoré : ${role_name}"
+        continue
+      fi

      ROLE_EXISTS="$(
        psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
--- a/RecetteScripts/rebuild.env.exemple
+++ b/RecetteScripts/rebuild.env.exemple
@@ -0,0 +1,80 @@
+###############################################################################
+# ENVIRONNEMENT
+###############################################################################
+
+# Nom de l'environnement
+# Exemple : DEV / RECETTE / PROD
+ENV_NAME=RECETTE
+
+###############################################################################
+# POSTGRESQL LOCAL
+###############################################################################
+
+# Hôte PostgreSQL local sur lequel la restauration sera effectuée
+PGHOST=localhost
+
+# Port PostgreSQL local
+PGPORT=5432
+
+# Utilisateur PostgreSQL utilisé pour créer la base et lancer la restauration
+PGUSER=
+
+# Mot de passe
+PGPASSWORD=
+
+# Liste des bases proposées à la restauration (séparées par des espaces)
+# L'utilisateur pourra en choisir une dans le script
+DBS="sirh inventory ferme"
+
+###############################################################################
+# SERVEUR DISTANT DE BACKUP
+###############################################################################
+
+# Utilisateur SSH du serveur distant contenant les dumps
+BACKUP_REMOTE_USER=
+
+# Hôte ou IP du serveur distant
+BACKUP_REMOTE_HOST=
+
+# Répertoire racine distant :
+BACKUP_REMOTE_DIR=/home/.../backups/bdd-recette
+
+###############################################################################
+# SSH
+###############################################################################
+
+# Clé privée SSH utilisée pour se connecter au serveur distant
+SSH_KEY=/home/.../.ssh/id_ed25519_backup
+
+# Timeout de connexion SSH en secondes
+# Variable optionnelle dans le script, mais utile ici comme valeur par défaut
+SSH_CONNECT_TIMEOUT=8
+
+###############################################################################
+# LOGS
+###############################################################################
+
+# Dossier local dans lequel seront écrits les logs de restauration
+BACKUP_LOG_DIR=/var/log/pg_backup
+
+###############################################################################
+# RESTAURATION LOCALE
+###############################################################################
+
+# Dossier local temporaire pour télécharger les fichiers avant restauration
+# Optionnel : si absent, le script utilise ./restore_tmp
+LOCAL_RESTORE_DIR=/tmp/rebuild-bdd-recette
+
+###############################################################################
+# RÔLES POSTGRESQL DISTANTS
+###############################################################################
+
+# Nom du dossier distant contenant les exports SQL des rôles
+REMOTE_ROLES_DIR_NAME=user
+
+###############################################################################
+# DISCORD
+###############################################################################
+
+# Webhook Discord pour notifier le succès de la restauration
+DISCORD_WEBHOOK_URL=
--- a/global.env.exemple
+++ b/global.env.exemple
@@ -0,0 +1,132 @@
+###############################################################################
+# FICHIER .env.example
+#
+# Ce fichier sert de modèle de configuration pour les scripts d'automatisation :
+#   - backup-bdd-recette.sh       → sauvegarde PostgreSQL
+#   - rebuild-bdd-recette.sh      → reconstruction d'une base PostgreSQL
+#   - check-statut-recette.sh     → vérification disponibilité des applications
+#   - check-storage.sh            → surveillance de l'espace disque
+#   - backup-vaultwarden.sh       → sauvegarde du service Vaultwarden
+#
+# Copier ce fichier en .env puis remplir les valeurs.
+###############################################################################
+
+#############################################
+# ENVIRONNEMENT
+#############################################
+
+# Nom de l'environnement (ex : DEV / RECETTE / PROD)
+ENV_NAME=RECETTE
+
+
+#############################################
+# DISCORD
+#############################################
+
+# Webhook Discord utilisé pour envoyer les notifications
+DISCORD_WEBHOOK_URL=
+
+
+#############################################
+# POSTGRESQL
+#############################################
+
+# Adresse du serveur PostgreSQL
+PGHOST=localhost
+
+# Port PostgreSQL
+PGPORT=5432
+
+# Utilisateur utilisé pour les dumps
+PGUSER=
+
+# Mot de passe
+PGPASSWORD=
+
+# Bases de données à sauvegarder (séparées par espace)
+# Utilisé par backup-bdd-recette.sh
+DBS="sirh inventory ferme"
+
+
+#############################################
+# BACKUPS LOCAUX
+#############################################
+
+# Dossier local où les dumps seront générés temporairement
+BACKUP_LOCAL_DIR=/var/backups/postgresql
+
+# Dossier des logs de sauvegarde
+BACKUP_LOG_DIR=/var/log/script/...
+
+
+#############################################
+# SERVEUR DISTANT DE STOCKAGE
+#############################################
+
+# Utilisateur du serveur de backup distant
+BACKUP_REMOTE_USER=
+
+# Adresse IP ou hostname du serveur de stockage
+BACKUP_REMOTE_HOST=
+
+# Dossier distant où stocker les backups
+BACKUP_REMOTE_DIR=/home/.../backups/bdd-recette
+
+
+#############################################
+# SSH
+#############################################
+
+# Clé SSH utilisée pour se connecter au serveur distant
+SSH_KEY=/home/.../.ssh/id_ed25519_backup
+
+# Timeout SSH (secondes)
+SSH_TIMEOUT=10
+
+
+#############################################
+# ROTATION DES BACKUPS
+#############################################
+
+# Nombre de jours de conservation des sauvegardes
+BACKUP_RETENTION_DAYS=10
+
+
+#############################################
+# APPLICATIONS À SURVEILLER
+#############################################
+
+# Liste des applications à vérifier
+APPS="
+ferme.malio-dev.fr
+inventory.malio-dev.fr
+sirh.malio-dev.fr
+"
+
+
+#############################################
+# VAULTWARDEN
+#############################################
+
+# Dossier contenant les données Vaultwarden
+VAULTWARDEN_DATA_DIR=/opt/vaultwarden/data
+
+# Dossier local où stocker le backup
+VAULTWARDEN_BACKUP_DIR=/var/backups/vaultwarden
+
+
+#############################################
+# SERVEUR IA / STOCKAGE CENTRAL
+#############################################
+
+# Utilisateur SSH du serveur distant
+IA_SSH_USER=
+
+# Host du serveur distant
+IA_SSH_HOST=
+
+# Dossier racine contenant les dumps PostgreSQL
+IA_BASE_DIR=/home/.../backups/bdd-recette
+
+# Dossier contenant les rôles PostgreSQL exportés
+REMOTE_ROLES_NAME=user
Author	SHA1	Message	Date
Matteo	f3ebb4c011	Merge branch 'develop' into fix/correctif	2026-03-18 11:50:32 +01:00
Mattéo Dunoyer	83032ef5ab	Merge pull request 'feat/script-redéploiement-BDD-utilisable-interface-web' (#13 ) from feat/script-redéploiement-BDD-utilisable-interface-web into develop Reviewed-on: #13	2026-03-18 10:49:52 +00:00
Matteo	863fee91a9	fix : fichier executable	2026-03-18 11:37:53 +01:00
Matteo	0dddecd08f	fix : correctifs 002 a 006 et de 008 a 019	2026-03-18 10:12:33 +01:00
Matteo	66abdfca53	feat : correctif	2026-03-17 16:34:40 +01:00
Matteo	26101f2112	feat : bug telechargement	2026-03-17 16:31:56 +01:00
Matteo	0ee0c1328a	feat : bug telechargement	2026-03-17 16:28:54 +01:00
Matteo	f6e66e7bff	feat : debbug more easy	2026-03-17 16:23:43 +01:00
Matteo	41df83fe32	feat : debbug more easy	2026-03-17 16:21:46 +01:00
Matteo	3faf8ab71d	feat : debbug more easy	2026-03-17 16:19:20 +01:00
Matteo	685a65e2d1	feat : correctif mineur	2026-03-17 16:12:46 +01:00
Matteo	6a99a8115f	feat : correctif mineur	2026-03-17 16:11:00 +01:00
Matteo	f12c937b39	feat : correctif mineur	2026-03-17 16:09:00 +01:00
Matteo	cb94e74414	feat : preparation de postgresql (WIP)	2026-03-17 16:05:26 +01:00
Matteo	5b128bc81a	feat : preparation de postgresql (WIP)	2026-03-17 16:03:19 +01:00
Matteo	6c61f6e543	feat : preparation de postgresql (WIP)	2026-03-17 15:59:32 +01:00
Matteo	447b04ce20	feat : preparation de postgresql (WIP)	2026-03-17 15:57:18 +01:00
Matteo	29371b6529	feat : preparation de postgresql (WIP)	2026-03-17 15:55:33 +01:00
Matteo	b3de87a452	feat : preparation de postgresql (WIP)	2026-03-17 15:53:43 +01:00
Matteo	0ff3244c1d	feat : repertorie bug (WIP)	2026-03-17 15:51:45 +01:00
Matteo	12bbe6b1d9	feat : repertorie bug (WIP)	2026-03-17 15:49:44 +01:00
Matteo	fbefe3fb03	feat : repertorie bug (WIP)	2026-03-17 15:45:25 +01:00
Matteo	38b29796d3	feat : repertorie bug(WIP)	2026-03-17 15:41:29 +01:00
Matteo	01ac392fa9	feat : repertorie bug(WIP)	2026-03-17 15:38:17 +01:00
Matteo	e5b15426a1	feat : repertorie bug(WIP)	2026-03-17 15:35:40 +01:00
Matteo	7974491e93	feat : sudoers bug (WIP)	2026-03-17 15:18:35 +01:00
Matteo	b76b6613bf	feat : sudoers bug (WIP)	2026-03-17 15:14:52 +01:00
Matteo	122f53f804	feat : correction bug scp (WIP)	2026-03-17 13:55:25 +01:00
Matteo	741fef225b	feat : correction bug scp (WIP)	2026-03-17 13:49:14 +01:00
Matteo	8ef81add14	feat : utilisation web disponible et simplification du deployement des scripts (WIP)	2026-03-17 13:43:34 +01:00
Matteo	a1fb6f5504	feat : Utilisation web disponible et simplification du deployement des scripts (WIP)	2026-03-17 11:40:35 +01:00
Matteo	0d4ffd9391	feat : web interface valide (WIP)	2026-03-17 10:19:20 +01:00
AkiNoKure	94537de551	feat : update web available rebuild bdd (WIP)	2026-03-17 10:11:00 +01:00
AkiNoKure	2971ef0ff9	fix: add executable bit on rebuild scripts	2026-03-17 09:21:38 +01:00
AkiNoKure	f0dfd6acb1	feat : update web available rebuild bdd (WIP)	2026-03-17 08:48:59 +01:00
AkiNoKure	858cad8269	feat : update web available rebuild bdd (WIP)	2026-03-16 11:10:10 +01:00
Mattéo Dunoyer	fb1aaac418	Actualiser RecetteScripts/check-statut-recette.sh	2026-03-13 09:20:58 +00:00
Mattéo Dunoyer	d7cb9b34c4	Actualiser CHANGELOG.md	2026-03-13 08:05:11 +00:00
Mattéo Dunoyer	643a0d9ec7	Actualiser CHANGELOG.md	2026-03-13 08:04:26 +00:00
Mattéo Dunoyer	df77d8be21	Merge pull request 'fix/427-correctifs' (#12 ) from fix/427-correctifs into develop Reviewed-on: #12	2026-03-13 08:01:30 +00:00
Mattéo Dunoyer	038ddfe242	Actualiser BackupVaultWarden/README.md	2026-03-13 07:59:18 +00:00
AkiNoKure	a1ace94094	fix : correctifs	2026-03-13 08:55:11 +01:00