508 lines
17 KiB
Bash
508 lines
17 KiB
Bash
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
###############################################################################
|
|
# restore-postgres-db.sh
|
|
#
|
|
# Finalité :
|
|
# Restaurer une base PostgreSQL à partir du dernier dump disponible sur un
|
|
# serveur distant.
|
|
#
|
|
# Fonctionnement global :
|
|
# 1. charge les variables depuis un fichier .env placé à côté du script ;
|
|
# 2. vérifie les dépendances locales nécessaires ;
|
|
# 3. détermine la base à restaurer ;
|
|
# 4. teste la connexion SSH au serveur distant ;
|
|
# 5. recherche automatiquement le dump .dump le plus récent ;
|
|
# 6. recherche automatiquement le fichier .sql des rôles le plus récent ;
|
|
# 7. télécharge les fichiers dans un dossier temporaire local ;
|
|
# 8. vérifie que le dump téléchargé est valide ;
|
|
# 9. demande confirmation si la base existe déjà ;
|
|
# 10. recrée la base si nécessaire ;
|
|
# 11. restaure éventuellement les rôles PostgreSQL ;
|
|
# 12. restaure le contenu de la base ;
|
|
# 13. supprime les fichiers temporaires.
|
|
#
|
|
# Hypothèses :
|
|
# - machine locale de restauration sous Linux Debian/Ubuntu ou macOS ;
|
|
# - serveur distant compatible GNU find si l'on utilise -printf ;
|
|
# - dumps PostgreSQL au format custom (.dump) ;
|
|
# - rôles exportés dans un fichier .sql rejouable.
|
|
###############################################################################
|
|
|
|
###############################################################################
|
|
# Chargement du .env
|
|
#
|
|
# Le script cherche automatiquement un fichier .env dans le même dossier
|
|
# que lui. Cela évite d'avoir des chemins absolus codés en dur.
|
|
###############################################################################
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
ENV_FILE="${SCRIPT_DIR}/.env"
|
|
|
|
if [[ ! -f "$ENV_FILE" ]]; then
|
|
echo "ERROR: fichier .env introuvable : $ENV_FILE" >&2
|
|
exit 1
|
|
fi
|
|
|
|
set -a
|
|
# shellcheck disable=SC1090
|
|
source "$ENV_FILE"
|
|
set +a
|
|
|
|
###############################################################################
|
|
# Vérification des variables obligatoires
|
|
#
|
|
# Ces variables doivent exister dans le .env. Sans elles, le script ne peut
|
|
# pas fonctionner correctement.
|
|
###############################################################################
|
|
: "${PGHOST:?Variable PGHOST manquante}"
|
|
: "${PGPORT:?Variable PGPORT manquante}"
|
|
: "${PGUSER:?Variable PGUSER manquante}"
|
|
: "${PGPASSWORD:?Variable PGPASSWORD manquante}"
|
|
: "${BACKUP_LOG_DIR:?Variable BACKUP_LOG_DIR manquante}"
|
|
: "${SSH_KEY:?Variable SSH_KEY manquante}"
|
|
: "${IA_SSH:?Variable IA_SSH manquante}"
|
|
: "${IA_BASE_DIR:?Variable IA_BASE_DIR manquante}"
|
|
|
|
###############################################################################
|
|
# Variables optionnelles
|
|
#
|
|
# Valeurs par défaut appliquées si elles ne sont pas définies dans le .env.
|
|
###############################################################################
|
|
SSH_TIMEOUT="${SSH_TIMEOUT:-10}"
|
|
|
|
# Nom du dossier distant contenant les exports SQL des rôles PostgreSQL.
|
|
# Exemple distant :
|
|
# /home/backup/backups/user
|
|
REMOTE_ROLES_DIR_NAME="${REMOTE_ROLES_DIR_NAME:-user}"
|
|
|
|
###############################################################################
|
|
# Mise en place des logs
|
|
#
|
|
# Tous les messages stdout/stderr sont redirigés vers la console ET vers
|
|
# un fichier de log horodaté.
|
|
###############################################################################
|
|
mkdir -p "$BACKUP_LOG_DIR"
|
|
LOG_FILE="${BACKUP_LOG_DIR}/restore_$(date +'%Y-%m-%d_%H-%M-%S').log"
|
|
touch "$LOG_FILE"
|
|
|
|
exec > >(tee -a "$LOG_FILE") 2>&1
|
|
|
|
###############################################################################
|
|
# Fonctions utilitaires
|
|
###############################################################################
|
|
|
|
# Écrit un message daté dans les logs.
|
|
log() {
|
|
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*"
|
|
}
|
|
|
|
# Affiche une erreur puis quitte le script.
|
|
fail() {
|
|
echo "ERROR: $*" >&2
|
|
exit 1
|
|
}
|
|
|
|
# Vérifie que le nom de base est acceptable.
|
|
#
|
|
# Règle choisie ici :
|
|
# - lettres
|
|
# - chiffres
|
|
# - underscore
|
|
#
|
|
# Cela évite beaucoup de problèmes d'injection ou de nom invalide.
|
|
validate_db_name() {
|
|
local db_name="$1"
|
|
|
|
[[ -n "$db_name" ]] || return 1
|
|
[[ "$db_name" =~ ^[a-zA-Z0-9_]+$ ]] || return 1
|
|
|
|
return 0
|
|
}
|
|
|
|
# Vérifie qu'une commande existe.
|
|
require_command() {
|
|
local cmd="$1"
|
|
command -v "$cmd" >/dev/null 2>&1
|
|
}
|
|
|
|
# Petite fonction de confirmation utilisateur.
|
|
# Retourne 0 si oui, 1 sinon.
|
|
confirm_yes_no() {
|
|
local prompt="$1"
|
|
local answer=""
|
|
|
|
read -r -p "$prompt" answer
|
|
case "${answer,,}" in
|
|
oui|o|yes|y) return 0 ;;
|
|
*) return 1 ;;
|
|
esac
|
|
}
|
|
|
|
###############################################################################
|
|
# Installation des dépendances manquantes
|
|
#
|
|
# On privilégie ici les clients PostgreSQL plutôt que l'installation complète
|
|
# du serveur si ce n'est pas nécessaire.
|
|
###############################################################################
|
|
install_postgres_client() {
|
|
log "Installation des outils PostgreSQL..."
|
|
|
|
if require_command apt-get; then
|
|
sudo apt-get update
|
|
sudo apt-get install -y postgresql-client
|
|
elif require_command brew; then
|
|
brew install postgresql
|
|
else
|
|
fail "impossible d'installer automatiquement les outils PostgreSQL : gestionnaire non supporté"
|
|
fi
|
|
}
|
|
|
|
install_scp_client() {
|
|
log "Installation de OpenSSH client..."
|
|
|
|
if require_command apt-get; then
|
|
sudo apt-get update
|
|
sudo apt-get install -y openssh-client
|
|
elif require_command brew; then
|
|
fail "scp / ssh introuvable sur macOS. Installe OpenSSH manuellement."
|
|
else
|
|
fail "impossible d'installer automatiquement openssh-client : gestionnaire non supporté"
|
|
fi
|
|
}
|
|
|
|
###############################################################################
|
|
# Résolution du nom de la base à restaurer
|
|
#
|
|
# Priorité :
|
|
# 1. variable DB si elle existe déjà
|
|
# 2. sélection depuis DBS si défini dans le .env
|
|
# 3. saisie manuelle
|
|
#
|
|
# IMPORTANT :
|
|
# - les messages d'interface sont envoyés sur stderr ;
|
|
# - seul le résultat final (nom de base) est envoyé sur stdout.
|
|
#
|
|
# Cela évite de polluer la variable récupérée via :
|
|
# DB="$(resolve_db_name)"
|
|
###############################################################################
|
|
resolve_db_name() {
|
|
local selected_db=""
|
|
local choice=""
|
|
local custom_db=""
|
|
local -a dbs_array=()
|
|
|
|
if [[ -n "${DB:-}" ]]; then
|
|
printf '%s\n' "$DB"
|
|
return 0
|
|
fi
|
|
|
|
if [[ -n "${DBS:-}" ]]; then
|
|
read -r -a dbs_array <<< "$DBS"
|
|
|
|
if [[ "${#dbs_array[@]}" -gt 0 ]]; then
|
|
echo "Bases disponibles dans le .env :" >&2
|
|
for i in "${!dbs_array[@]}"; do
|
|
printf ' %d) %s\n' "$((i + 1))" "${dbs_array[$i]}" >&2
|
|
done
|
|
echo >&2
|
|
|
|
read -r -p "Voulez-vous utiliser une base de cette liste ? (oui/non) : " choice
|
|
|
|
case "${choice,,}" in
|
|
oui|o|yes|y)
|
|
while true; do
|
|
read -r -p "Sélectionnez le numéro de la base à restaurer : " selected_db
|
|
|
|
if [[ "$selected_db" =~ ^[0-9]+$ ]] && (( selected_db >= 1 && selected_db <= ${#dbs_array[@]} )); then
|
|
printf '%s\n' "${dbs_array[$((selected_db - 1))]}"
|
|
return 0
|
|
fi
|
|
|
|
echo "Choix invalide. Veuillez entrer un numéro entre 1 et ${#dbs_array[@]}." >&2
|
|
done
|
|
;;
|
|
non|n|no)
|
|
read -r -p "Entrez le nom de la base à restaurer hors liste : " custom_db
|
|
printf '%s\n' "$custom_db"
|
|
return 0
|
|
;;
|
|
*)
|
|
echo "Réponse invalide. Saisie manuelle de la base." >&2
|
|
read -r -p "Entrez le nom de la base à restaurer : " custom_db
|
|
printf '%s\n' "$custom_db"
|
|
return 0
|
|
;;
|
|
esac
|
|
fi
|
|
fi
|
|
|
|
read -r -p "Aucune base définie via DB ou DBS. Entrez le nom de la base à restaurer : " custom_db
|
|
printf '%s\n' "$custom_db"
|
|
}
|
|
|
|
###############################################################################
|
|
# Détermination de la base cible
|
|
###############################################################################
|
|
DB="$(resolve_db_name)"
|
|
|
|
if ! validate_db_name "$DB"; then
|
|
fail "nom de base invalide : '$DB'. Caractères autorisés : lettres, chiffres, underscore."
|
|
fi
|
|
|
|
log "Base cible sélectionnée : $DB"
|
|
|
|
###############################################################################
|
|
# Vérification des dépendances locales
|
|
###############################################################################
|
|
if ! require_command psql; then
|
|
log "psql introuvable."
|
|
install_postgres_client
|
|
fi
|
|
|
|
if ! require_command pg_restore; then
|
|
log "pg_restore introuvable."
|
|
install_postgres_client
|
|
fi
|
|
|
|
if ! require_command createdb; then
|
|
log "createdb introuvable."
|
|
install_postgres_client
|
|
fi
|
|
|
|
if ! require_command dropdb; then
|
|
log "dropdb introuvable."
|
|
install_postgres_client
|
|
fi
|
|
|
|
if ! require_command ssh; then
|
|
log "ssh introuvable."
|
|
install_scp_client
|
|
fi
|
|
|
|
if ! require_command scp; then
|
|
log "scp introuvable."
|
|
install_scp_client
|
|
fi
|
|
|
|
###############################################################################
|
|
# Vérification de la clé SSH
|
|
###############################################################################
|
|
[[ -f "$SSH_KEY" ]] || fail "clé SSH introuvable : $SSH_KEY"
|
|
|
|
###############################################################################
|
|
# Configuration SSH
|
|
#
|
|
# BatchMode=yes :
|
|
# empêche les demandes interactives de mot de passe.
|
|
#
|
|
# IdentitiesOnly=yes :
|
|
# force l'usage de la clé fournie.
|
|
###############################################################################
|
|
SSH_OPTS=(
|
|
-i "$SSH_KEY"
|
|
-o IdentitiesOnly=yes
|
|
-o BatchMode=yes
|
|
-o ConnectTimeout="$SSH_TIMEOUT"
|
|
)
|
|
|
|
###############################################################################
|
|
# Test de connexion SSH
|
|
#
|
|
# On teste la connexion immédiatement pour échouer tôt si le serveur distant
|
|
# n'est pas joignable ou si la clé n'est pas acceptée.
|
|
###############################################################################
|
|
log "Test de connexion SSH vers ${IA_SSH}..."
|
|
ssh "${SSH_OPTS[@]}" "$IA_SSH" "echo OK" >/dev/null 2>&1 \
|
|
|| fail "connexion SSH impossible vers ${IA_SSH}"
|
|
|
|
###############################################################################
|
|
# Définition des chemins distants
|
|
#
|
|
# Structure attendue :
|
|
# $IA_BASE_DIR/$DB/ -> contient les dumps .dump de la base
|
|
# $IA_BASE_DIR/$REMOTE_ROLES_DIR_NAME/ -> contient les exports .sql des rôles
|
|
###############################################################################
|
|
REMOTE_DUMP_DIR="${IA_BASE_DIR}/${DB}"
|
|
REMOTE_ROLES_DIR="${IA_BASE_DIR}/${REMOTE_ROLES_DIR_NAME}"
|
|
|
|
log "Recherche du dernier dump distant pour ${DB} dans : $REMOTE_DUMP_DIR"
|
|
log "Recherche du dernier fichier de rôles dans : $REMOTE_ROLES_DIR"
|
|
|
|
###############################################################################
|
|
# Recherche automatique du dump le plus récent
|
|
#
|
|
# On cherche tous les fichiers .dump dans le dossier distant de la base,
|
|
# puis on les trie par date de modification décroissante.
|
|
#
|
|
# Le premier résultat est donc le plus récent.
|
|
###############################################################################
|
|
REMOTE_DUMP_PATH="$(
|
|
ssh "${SSH_OPTS[@]}" "$IA_SSH" "
|
|
if [ -d '$REMOTE_DUMP_DIR' ]; then
|
|
find '$REMOTE_DUMP_DIR' -maxdepth 1 -type f -name '*.dump' -printf '%T@ %p\n' 2>/dev/null \
|
|
| sort -nr \
|
|
| head -n 1 \
|
|
| cut -d' ' -f2-
|
|
fi
|
|
"
|
|
)"
|
|
|
|
if [[ -z "$REMOTE_DUMP_PATH" ]]; then
|
|
fail "aucun dump distant trouvé dans : $REMOTE_DUMP_DIR"
|
|
fi
|
|
|
|
REMOTE_DUMP_FILE="$(basename "$REMOTE_DUMP_PATH")"
|
|
|
|
###############################################################################
|
|
# Recherche automatique du dernier fichier des rôles
|
|
#
|
|
# Ce fichier n'est pas obligatoire pour restaurer la base elle-même.
|
|
# Si aucun fichier de rôles n'est trouvé, le script continue quand même.
|
|
###############################################################################
|
|
REMOTE_ROLES_PATH="$(
|
|
ssh "${SSH_OPTS[@]}" "$IA_SSH" "
|
|
if [ -d '$REMOTE_ROLES_DIR' ]; then
|
|
find '$REMOTE_ROLES_DIR' -maxdepth 1 -type f -name '*.sql' -printf '%T@ %p\n' 2>/dev/null \
|
|
| sort -nr \
|
|
| head -n 1 \
|
|
| cut -d' ' -f2-
|
|
fi
|
|
"
|
|
)"
|
|
|
|
REMOTE_ROLES_FILE=""
|
|
if [[ -n "$REMOTE_ROLES_PATH" ]]; then
|
|
REMOTE_ROLES_FILE="$(basename "$REMOTE_ROLES_PATH")"
|
|
fi
|
|
|
|
log "Dernier dump distant sélectionné : $REMOTE_DUMP_PATH"
|
|
if [[ -n "$REMOTE_ROLES_PATH" ]]; then
|
|
log "Dernier fichier des rôles sélectionné : $REMOTE_ROLES_PATH"
|
|
else
|
|
log "Aucun fichier des rôles trouvé sur le serveur distant."
|
|
fi
|
|
|
|
###############################################################################
|
|
# Dossier temporaire local
|
|
#
|
|
# Les fichiers téléchargés sont stockés dans un dossier temporaire, puis
|
|
# supprimés automatiquement à la fin du script.
|
|
###############################################################################
|
|
TMP_DIR="$(mktemp -d)"
|
|
LOCAL_DUMP_PATH="${TMP_DIR}/${REMOTE_DUMP_FILE}"
|
|
LOCAL_ROLES_PATH=""
|
|
|
|
cleanup() {
|
|
rm -rf "$TMP_DIR"
|
|
}
|
|
trap cleanup EXIT
|
|
|
|
###############################################################################
|
|
# Téléchargement du dump et des rôles
|
|
###############################################################################
|
|
log "Téléchargement du dump..."
|
|
scp "${SSH_OPTS[@]}" "${IA_SSH}:${REMOTE_DUMP_PATH}" "$LOCAL_DUMP_PATH"
|
|
|
|
if [[ ! -f "$LOCAL_DUMP_PATH" ]]; then
|
|
fail "échec du téléchargement du dump : fichier local introuvable"
|
|
fi
|
|
|
|
if [[ -n "$REMOTE_ROLES_PATH" ]]; then
|
|
LOCAL_ROLES_PATH="${TMP_DIR}/${REMOTE_ROLES_FILE}"
|
|
log "Téléchargement du fichier des rôles..."
|
|
scp "${SSH_OPTS[@]}" "${IA_SSH}:${REMOTE_ROLES_PATH}" "$LOCAL_ROLES_PATH"
|
|
|
|
if [[ ! -f "$LOCAL_ROLES_PATH" ]]; then
|
|
fail "échec du téléchargement du fichier des rôles"
|
|
fi
|
|
else
|
|
log "La restauration des rôles sera ignorée."
|
|
fi
|
|
|
|
###############################################################################
|
|
# Vérification du format du dump
|
|
#
|
|
# pg_restore --list permet de vérifier que le fichier est bien un dump
|
|
# PostgreSQL lisible au format attendu.
|
|
###############################################################################
|
|
if ! pg_restore --list "$LOCAL_DUMP_PATH" >/dev/null 2>&1; then
|
|
fail "le fichier téléchargé n'est pas un dump PostgreSQL valide : $LOCAL_DUMP_PATH"
|
|
fi
|
|
|
|
###############################################################################
|
|
# Vérification de l'existence de la base
|
|
#
|
|
# Si la base existe déjà, on demande explicitement à l'utilisateur s'il veut
|
|
# l'écraser. Sinon, on la crée simplement.
|
|
###############################################################################
|
|
DB_EXISTS="false"
|
|
if psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -tAc \
|
|
"SELECT 1 FROM pg_database WHERE datname = '$DB'" | grep -q '^1$'; then
|
|
DB_EXISTS="true"
|
|
fi
|
|
|
|
if [[ "$DB_EXISTS" == "true" ]]; then
|
|
if confirm_yes_no "La base '${DB}' existe déjà. Voulez-vous l'écraser ? (oui/non) : "; then
|
|
log "Suppression de la base existante : $DB"
|
|
|
|
# Coupe les connexions actives sur la base pour permettre sa suppression.
|
|
psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -c \
|
|
"SELECT pg_terminate_backend(pid)
|
|
FROM pg_stat_activity
|
|
WHERE datname = '$DB'
|
|
AND pid <> pg_backend_pid();" >/dev/null
|
|
|
|
dropdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB"
|
|
createdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB"
|
|
else
|
|
log "Restauration annulée par l'utilisateur."
|
|
exit 0
|
|
fi
|
|
else
|
|
log "Création de la base : $DB"
|
|
createdb -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" "$DB"
|
|
fi
|
|
|
|
###############################################################################
|
|
# Restauration éventuelle des rôles PostgreSQL
|
|
#
|
|
# Cette étape est optionnelle. Elle permet par exemple de recréer des rôles
|
|
# ou utilisateurs nécessaires avant la restauration de la base.
|
|
#
|
|
# Attention :
|
|
# le fichier doit être conçu pour être rejouable sans casser l'existant.
|
|
###############################################################################
|
|
if [[ -n "$LOCAL_ROLES_PATH" && -f "$LOCAL_ROLES_PATH" ]]; then
|
|
log "Restauration des rôles PostgreSQL..."
|
|
psql -h "$PGHOST" -p "$PGPORT" -U "$PGUSER" -d postgres -f "$LOCAL_ROLES_PATH"
|
|
else
|
|
log "Aucune restauration des rôles effectuée."
|
|
fi
|
|
|
|
###############################################################################
|
|
# Restauration de la base
|
|
#
|
|
# --clean / --if-exists :
|
|
# demande à pg_restore de supprimer les objets avant de les recréer.
|
|
#
|
|
# --no-owner :
|
|
# évite les problèmes si le propriétaire original n'existe pas localement.
|
|
#
|
|
# --verbose :
|
|
# détaille la restauration dans les logs.
|
|
###############################################################################
|
|
log "Restauration de la base '${DB}' depuis ${LOCAL_DUMP_PATH}..."
|
|
|
|
pg_restore \
|
|
-h "$PGHOST" \
|
|
-p "$PGPORT" \
|
|
-U "$PGUSER" \
|
|
-d "$DB" \
|
|
--clean \
|
|
--if-exists \
|
|
--no-owner \
|
|
--verbose \
|
|
"$LOCAL_DUMP_PATH"
|
|
|
|
log "Restauration terminée avec succès pour la base : $DB" |