From f6053bb459294991faa9282ae8c8236f01bc16fc Mon Sep 17 00:00:00 2001 From: Romulus21 Date: Mon, 9 Nov 2026 16:32:49 +0100 Subject: [PATCH] Script de backup restic pour Lisette et Bermite MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pull depuis ce PC via SSH : snapshot SQLite à chaud (API backup de Python, sans fichier temporaire sur le serveur), vérification d'intégrité locale, puis restic backup taggé par service. Rétention configurable, isolation des échecs par service, commande `list`. Co-Authored-By: Claude Opus 5.5 --- .gitignore | 1 + README.md | 71 +++++++++++++++++++++++++++++++++++++++++ backup.sh | 72 ++++++++++++++++++++++++++++++++++++++++++ config.env.example | 9 ++++++ lib/common.sh | 67 +++++++++++++++++++++++++++++++++++++++ lib/sqlite_snapshot.py | 31 ++++++++++++++++++ services/bermite.sh | 8 +++++ services/lisette.sh | 8 +++++ 8 files changed, 267 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100755 backup.sh create mode 100644 config.env.example create mode 100644 lib/common.sh create mode 100644 lib/sqlite_snapshot.py create mode 100644 services/bermite.sh create mode 100644 services/lisette.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..2549b3d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +config.env diff --git a/README.md b/README.md new file mode 100644 index 0000000..b3c5d89 --- /dev/null +++ b/README.md @@ -0,0 +1,71 @@ +# Backups des services auto-hébergés + +Script lancé depuis ce PC : il se connecte en SSH à chaque serveur, prend un snapshot cohérent des données et les range dans un dépôt **restic** local, chiffré et dédupliqué. + +| Service | Hôte | Données sauvegardées | +|---------|----------|-----------------------------------------| +| lisette | raspiweb | `lisette.db` (SQLite) + `.env` | +| bermite | raspiweb | `bermite.db` (SQLite) + `.env` | + +## Installation (une fois) + +```sh +cp config.env.example config.env # adapter si besoin +./backup.sh --init # génère le mot de passe + restic init +``` + +⚠️ Il faut **copier `~/.config/backups/restic-password` ailleurs**, par exemple dans Vaultwarden. Sans ce mot de passe, le dépôt est irrécupérable. + +## Usage + +```sh +./backup.sh # tous les services (services/*.sh) +./backup.sh lisette # un seul +./backup.sh list # liste toutes les sauvegardes +./backup.sh list lisette # seulement celles de lisette +``` + +Un service en échec n'empêche pas les autres de tourner. Le résumé final et le code de sortie signalent l'échec. La rétention (`KEEP_*` dans `config.env`) n'est appliquée que si tout a réussi. + +Pour lancer restic à la main, il faut d'abord charger la config : + +```sh +set -a; source config.env; set +a +restic snapshots +``` + +## Fonctionnement + +1. **SQLite** : `lib/sqlite_snapshot.py` est envoyé au serveur par `ssh hôte python3 -`. Il utilise l'API `backup()` de SQLite, qui fonctionne à chaud sans arrêter le service, et renvoie la base sur stdout. Aucun fichier temporaire ne reste sur le serveur. Une fois la base rapatriée, on lance `PRAGMA integrity_check` en local. +2. **Fichiers** : ils sont récupérés par `rsync -a`. +3. Le staging (`~/.cache/backups/staging/`, en mode 700) part dans restic avec `--tag --host `, puis il est supprimé. + +## Restaurer + +```sh +set -a; source config.env; set +a +restic snapshots --tag lisette +restic restore latest --tag lisette --target /tmp/restore # ou un ID de snapshot + +ssh raspiweb sudo systemctl stop lisette +scp /tmp/restore/lisette.db raspiweb:/home/pi/Scripts/lisette/lisette.db +ssh raspiweb 'rm -f /home/pi/Scripts/lisette/lisette.db-wal /home/pi/Scripts/lisette/lisette.db-shm' +ssh raspiweb sudo systemctl start lisette +rm -rf /tmp/restore +``` + +## Ajouter un service + +Créer `services/.sh` : + +```bash +SERVICE_HOST=monserveur # alias ~/.ssh/config + +backup_service() { # $1 = dossier de staging + ssh_sqlite_snapshot "$SERVICE_HOST" /chemin/app.db "$1/app.db" + pull_files "$SERVICE_HOST" "$1" /chemin/.env /chemin/uploads + # ou un dump : ssh "$SERVICE_HOST" pg_dump ... > "$1/db.sql" +} +``` + +Les fonctions disponibles se trouvent dans `lib/common.sh`. diff --git a/backup.sh b/backup.sh new file mode 100755 index 0000000..d1b9d38 --- /dev/null +++ b/backup.sh @@ -0,0 +1,72 @@ +#!/usr/bin/env bash +# Sauvegarde des services auto-hébergés vers un dépôt restic local. +# ./backup.sh --init initialise le dépôt (une fois) +# ./backup.sh sauvegarde tous les services (services/*.sh) +# ./backup.sh lisette ... sauvegarde seulement ceux-là +# ./backup.sh list [svc...] liste les sauvegardes (filtrables par service) +set -euo pipefail + +ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +source "$ROOT/lib/common.sh" +load_config +: "${KEEP_DAILY:=7}" "${KEEP_WEEKLY:=4}" "${KEEP_MONTHLY:=12}" + +if [[ "${1:-}" == "--init" ]]; then + restic_init + exit 0 +fi + +restic cat config >/dev/null 2>&1 || die "dépôt restic absent/illisible : lance ./backup.sh --init" + +if [[ "${1:-}" == "list" ]]; then + shift + tags=() + for svc in "$@"; do tags+=(--tag "$svc"); done # plusieurs --tag = OU + exec restic snapshots --compact "${tags[@]}" +fi + +if (( $# )); then + services=("$@") +else + services=() + for f in "$ROOT"/services/*.sh; do services+=("$(basename "$f" .sh)"); done +fi + +declare -A status=() +failed=0 +for svc in "${services[@]}"; do + file="$ROOT/services/$svc.sh" + if [[ ! -f "$file" ]]; then + warn "service inconnu : $svc"; status[$svc]="INCONNU"; failed=1; continue + fi + log "=== $svc" + # Sous-shell hors contexte conditionnel pour que set -e reste actif dedans, + # et qu'un échec n'interrompe pas les services suivants. + set +e + ( + set -euo pipefail + SERVICE_HOST="" + source "$file" + [[ -n "$SERVICE_HOST" ]] || die "SERVICE_HOST non défini dans $file" + stage="$STAGING_DIR/$svc" + rm -rf "$stage" + trap 'rm -rf "$stage"' EXIT # le staging contient des secrets en clair + ( umask 077; mkdir -p "$stage" ) + backup_service "$stage" + restic_store "$svc" "$SERVICE_HOST" "$stage" + ) + rc=$? + set -e + if (( rc == 0 )); then status[$svc]="OK"; else status[$svc]="ÉCHEC"; failed=1; fi +done + +if (( failed == 0 )); then + restic_retention +else + warn "au moins un échec : rétention non appliquée" +fi + +echo +echo "Résumé :" +for svc in "${services[@]}"; do printf ' %-12s %s\n' "$svc" "${status[$svc]}"; done +exit "$failed" diff --git a/config.env.example b/config.env.example new file mode 100644 index 0000000..a81d095 --- /dev/null +++ b/config.env.example @@ -0,0 +1,9 @@ +# Copier en config.env et adapter. +RESTIC_REPOSITORY="$HOME/Backups/restic" +RESTIC_PASSWORD_FILE="$HOME/.config/backups/restic-password" +STAGING_DIR="$HOME/.cache/backups/staging" + +# Rétention (restic forget, groupé par hôte + service) +KEEP_DAILY=7 +KEEP_WEEKLY=4 +KEEP_MONTHLY=12 diff --git a/lib/common.sh b/lib/common.sh new file mode 100644 index 0000000..35d126f --- /dev/null +++ b/lib/common.sh @@ -0,0 +1,67 @@ +# Fonctions partagées — sourcé par backup.sh. + +log() { printf '\033[1;34m[%s]\033[0m %s\n' "$(date +%H:%M:%S)" "$*" >&2; } +warn() { printf '\033[1;33m[warn]\033[0m %s\n' "$*" >&2; } +die() { printf '\033[1;31m[erreur]\033[0m %s\n' "$*" >&2; exit 1; } + +load_config() { + local cfg="$ROOT/config.env" + [[ -f "$cfg" ]] || die "config.env manquant : cp config.env.example config.env" + # shellcheck source=/dev/null + source "$cfg" + : "${RESTIC_REPOSITORY:?}" "${RESTIC_PASSWORD_FILE:?}" "${STAGING_DIR:?}" + export RESTIC_REPOSITORY RESTIC_PASSWORD_FILE +} + +# ssh_sqlite_snapshot +ssh_sqlite_snapshot() { + local host=$1 src=$2 dst=$3 + log "snapshot SQLite $host:$src" + ssh -o BatchMode=yes "$host" python3 - "$(printf '%q' "$src")" \ + < "$ROOT/lib/sqlite_snapshot.py" > "$dst" + verify_sqlite "$dst" +} + +# verify_sqlite +verify_sqlite() { + local res + res=$(sqlite3 "$1" 'PRAGMA integrity_check;') || die "lecture impossible : $1" + [[ "$res" == "ok" ]] || die "intégrité KO pour $1 : $res" +} + +# pull_files ... +pull_files() { + local host=$1 dest=$2; shift 2 + local srcs=() p + for p in "$@"; do srcs+=("$host:$p"); done + log "rsync ${srcs[*]}" + rsync -a --protect-args "${srcs[@]}" "$dest/" +} + +# restic_store +restic_store() { + local service=$1 host=$2 dir=$3 + log "restic backup ($service)" + ( cd "$dir" && restic backup --quiet --host "$host" --tag "$service" . ) +} + +restic_init() { + if [[ ! -f "$RESTIC_PASSWORD_FILE" ]]; then + mkdir -p "$(dirname "$RESTIC_PASSWORD_FILE")" + ( umask 077; head -c 32 /dev/urandom | base64 > "$RESTIC_PASSWORD_FILE" ) + warn "mot de passe restic généré dans $RESTIC_PASSWORD_FILE" + warn "=> COPIE-LE AILLEURS (Vaultwarden…) : sans lui le dépôt est irrécupérable." + fi + if restic cat config >/dev/null 2>&1; then + log "dépôt déjà initialisé : $RESTIC_REPOSITORY" + else + mkdir -p "$RESTIC_REPOSITORY" + restic init + fi +} + +restic_retention() { + log "rétention (d=$KEEP_DAILY w=$KEEP_WEEKLY m=$KEEP_MONTHLY)" + restic forget --quiet --prune --group-by host,tags \ + --keep-daily "$KEEP_DAILY" --keep-weekly "$KEEP_WEEKLY" --keep-monthly "$KEEP_MONTHLY" +} diff --git a/lib/sqlite_snapshot.py b/lib/sqlite_snapshot.py new file mode 100644 index 0000000..6004fa4 --- /dev/null +++ b/lib/sqlite_snapshot.py @@ -0,0 +1,31 @@ +"""Snapshot cohérent d'une base SQLite, écrit sur stdout. + +Exécuté côté serveur via : ssh hôte python3 - < sqlite_snapshot.py +Utilise l'API backup de SQLite : fonctionne à chaud, respecte le WAL. +Uniquement la stdlib (le serveur n'a pas forcément le binaire sqlite3). +""" +import os +import shutil +import sqlite3 +import sys +import tempfile + +src = sys.argv[1] +if not os.path.isfile(src): + sys.exit(f"base introuvable : {src}") + +# mode=rw : ne jamais créer une base vide si le chemin est faux. +source = sqlite3.connect(f"file:{src}?mode=rw", uri=True) +fd, tmp = tempfile.mkstemp(suffix=".db") +os.close(fd) +try: + dest = sqlite3.connect(tmp) + with dest: + source.backup(dest) + dest.close() + source.close() + with open(tmp, "rb") as f: + shutil.copyfileobj(f, sys.stdout.buffer) + sys.stdout.buffer.flush() +finally: + os.unlink(tmp) diff --git a/services/bermite.sh b/services/bermite.sh new file mode 100644 index 0000000..b9ddc3c --- /dev/null +++ b/services/bermite.sh @@ -0,0 +1,8 @@ +# Bermite — serveur Leptos sur raspiweb, base SQLite + .env +SERVICE_HOST=raspiweb +APP_DIR=/home/pi/Scripts/bermite + +backup_service() { # $1 = dossier de staging + ssh_sqlite_snapshot "$SERVICE_HOST" "$APP_DIR/bermite.db" "$1/bermite.db" + pull_files "$SERVICE_HOST" "$1" "$APP_DIR/.env" +} diff --git a/services/lisette.sh b/services/lisette.sh new file mode 100644 index 0000000..1045013 --- /dev/null +++ b/services/lisette.sh @@ -0,0 +1,8 @@ +# Lisette — serveur Leptos sur raspiweb, base SQLite + .env +SERVICE_HOST=raspiweb +APP_DIR=/home/pi/Scripts/lisette + +backup_service() { # $1 = dossier de staging + ssh_sqlite_snapshot "$SERVICE_HOST" "$APP_DIR/lisette.db" "$1/lisette.db" + pull_files "$SERVICE_HOST" "$1" "$APP_DIR/.env" +}