Procedure Break-Glass¶

1. DNS          → AdGuard Home (penny ou dns-failover)
2. Reverse Proxy → Traefik (penny) — necessite CF_DNS_API_TOKEN
3. Passwords    → Vaultwarden (LXC 102 galahad) — PAS de dependance SSO
4. SSO          → Authelia (penny) — necessite secrets generes
5. Tout le reste → depend de 1-4

# Premier boot : connexion console locale, mdp default DietPi
# Changer le password root immediatement
passwd

# Installer la cle SSH
mkdir -p ~/.ssh && chmod 700 ~/.ssh
# Copier la cle publique depuis la cle USB ou depuis GitHub
curl -s https://github.com/GabinSMD.keys >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

# Configurer le SSD (si nouveau, formater en ext4 avec le meme UUID)
# Si SSD recupere : monter directement
mkdir -p /mnt/ssd
mount /dev/sda1 /mnt/ssd

# Cloner le repo config (ou restaurer depuis la cle USB)
cd /mnt/ssd
git clone https://github.com/GabinSMD/homelab-config.git config-repo

# Appliquer les configs systeme
cd /mnt/ssd/config-repo
cp boot/config.txt /boot/firmware/config.txt
cp boot/cmdline.txt /boot/firmware/cmdline.txt
cp udev/50-argon-ssd.rules /etc/udev/rules.d/
udevadm control --reload-rules
cp system/fstab /etc/fstab                         # Adapter UUID si SSD different
cp system/97-dietpi.conf /etc/sysctl.d/
cp system/99-sysctl.conf /etc/sysctl.conf
cp system/crontab /var/spool/cron/crontabs/root
cp network/interfaces /etc/network/interfaces       # IP 192.168.1.28
sysctl --system

# Installer les paquets essentiels
dietpi-software install 162  # Docker
apt install -y fail2ban restic watchdog unattended-upgrades

# Configurer Docker
mkdir -p /etc/docker
cp docker/daemon.json /etc/docker/daemon.json
systemctl restart docker

# Preparer les configs applicatives
mkdir -p /mnt/ssd/config
cp -r adguard/ /mnt/ssd/config/adguard/
cp -r traefik/ /mnt/ssd/config/traefik/
cp -r homepage/ /mnt/ssd/config/homepage/

# Restaurer le .env depuis la cle USB (contient TOUS les tokens)
cp /media/usb/.env /mnt/ssd/config/.env

# Restaurer le .restic-env depuis la cle USB
cp /media/usb/.restic-env /root/.restic-env
chmod 600 /root/.restic-env

# Copier le docker-compose
cp docker/docker-compose.yml /mnt/ssd/config/docker-compose.yml

# Restaurer les volumes Docker depuis restic (B2, chiffre AES-256)
source /root/.restic-env
export RESTIC_PASSWORD RESTIC_REPOSITORY B2_ACCOUNT_ID B2_ACCOUNT_KEY

# Lister les snapshots disponibles
restic snapshots

# Restaurer les volumes stages dans le dernier snapshot
restic restore latest --target /tmp/restore --include "/mnt/ssd/.restic-staging"

# Injecter les donnees dans les volumes Docker
for vol in beszel portainer; do
    docker volume create config_${vol}-data 2>/dev/null
    docker run --rm \
        -v config_${vol}-data:/data \
        -v /tmp/restore/mnt/ssd/.restic-staging/${vol}:/source:ro \
        alpine sh -c "cp -a /source/. /data/"
    echo "Restored: $vol"
done

rm -rf /tmp/restore

# Restaurer la config Authelia depuis restic ou regenerer les secrets
# (les configs bind-mount sont deja restaurees par restic dans /mnt/ssd/config/)
source /root/.restic-env && export RESTIC_PASSWORD RESTIC_REPOSITORY B2_ACCOUNT_ID B2_ACCOUNT_KEY
restic restore latest --target /tmp/restore --include "/mnt/ssd/config/authelia"
if [ -d /tmp/restore/mnt/ssd/config/authelia ]; then
    cp -a /tmp/restore/mnt/ssd/config/authelia/. /mnt/ssd/config/authelia/
    rm -rf /tmp/restore
    echo "Authelia restauree depuis restic"
else
    # Regenerer depuis les templates (cle USB pour les secrets)
    cp authelia/configuration.yml.example /mnt/ssd/config/authelia/configuration.yml
    cp authelia/users_database.yml.example /mnt/ssd/config/authelia/users_database.yml
    # Generer les secrets
    openssl rand -hex 32  # jwt_secret
    openssl rand -hex 32  # session_secret
    openssl rand -hex 32  # storage_key
    openssl rand -hex 32  # hmac_secret
    openssl genrsa -out /mnt/ssd/config/authelia/oidc.pem 4096
    # ATTENTION : si on regenere oidc.pem, il faut reconfigurer
    # tous les clients OIDC (Proxmox, Portainer, Grafana, Beszel)
    echo "SECRETS REGENERES — mettre a jour configuration.yml manuellement"
fi

# Installer et configurer Tailscale
curl -fsSL https://tailscale.com/install.sh | sh
tailscale up --authkey=<TS_AUTHKEY_DEPUIS_CLE_USB>
# Ou se connecter via login.tailscale.com si pas d'authkey

# Deployer le script monitoring
cp scripts/homelab_monitor.sh /root/homelab_monitor.sh
chmod +x /root/homelab_monitor.sh
cp scripts/homelab_backup.sh /root/homelab_backup.sh
chmod +x /root/homelab_backup.sh

# Lancer la stack
cd /mnt/ssd/config
docker compose up -d

# Verifier que restic fonctionne
source /root/.restic-env && export RESTIC_PASSWORD RESTIC_REPOSITORY B2_ACCOUNT_ID B2_ACCOUNT_KEY
restic snapshots  # doit lister les snapshots existants

# Sur chaque ZimaBoard : boot depuis USB Proxmox VE 9
# IMPORTANT : patch eMMC avant installation
# Ctrl+Alt+F2 depuis l'installeur Proxmox, puis :
# (voir proxmox-fix-emmc.sh dans homelab-config/scripts/)

# Apres installation et reboot, appliquer le post-install depuis penny :
cd /mnt/ssd/homelab-config/scripts && python3 -m http.server 8888

# Sur galahad (192.168.1.18) :
wget -O- http://192.168.1.28:8888/proxmox-post-install.sh | bash

# Sur lancelot (192.168.1.19) :
wget -O- http://192.168.1.28:8888/proxmox-post-install.sh | bash

# Sur galahad
pvecm create homelab

# Sur lancelot
pvecm add 192.168.1.18
# Mot de passe root de galahad requis

# Verifier
pvecm status

# Configurer Authelia OIDC pour Proxmox
pveum realm add authelia --type openid \
    --issuer-url https://auth.home.gabin-simond.fr \
    --client-id proxmox \
    --client-key <SECRET_DEPUIS_VAULTWARDEN> \
    --autocreate 1

# Token API pour Homepage
pveum user add homepage@pve
pveum aclmod / -user homepage@pve -role PVEAuditor
pveum user token add homepage@pve homepage --privsep=0

# Installer les agents Beszel sur chaque ZimaBoard
# (utiliser beszel-agent-compose.yml depuis homelab-config/scripts/)

# Installer Tailscale sur les ZimaBoards
curl -fsSL https://tailscale.com/install.sh | sh
tailscale up

T+0     Achat/recuperation du materiel
        Flasher DietPi sur la SD card

T+0.5h  PARALLELISER :
        ├── penny : OS, configs, SSD (Phase 2-3 du Scenario 1)
        └── galahad + lancelot : Proxmox installer boot USB

T+1h    penny : Docker up, restauration volumes depuis B2
        galahad : post-install.sh, creation cluster

T+1.5h  penny : Authelia restauree, Traefik + DNS UP
        lancelot : rejoint le cluster

T+2h    LXC 100 (dns-failover) : AdGuard secondaire UP
        LXC 102 (vault) : Vaultwarden restaure depuis B2

T+2.5h  LXC 101 (logs) : Grafana + Loki
        SSO reconfigure : OIDC Proxmox + Portainer + Grafana

T+3h    Tests end-to-end (voir checklist ci-dessous)

T+3.5h  Agents Beszel + Tailscale sur tout le cluster
        Verification backup fonctionne (restic snapshots)

T+4h    OPERATIONNEL

# Verifier les logs
docker logs authelia --tail 50

# Option A : Restaurer depuis le dernier backup
docker compose stop authelia
source /root/.restic-env && export RESTIC_PASSWORD RESTIC_REPOSITORY B2_ACCOUNT_ID B2_ACCOUNT_KEY
restic restore latest --target /tmp/restore --include "/mnt/ssd/config/authelia"
cp -a /tmp/restore/mnt/ssd/config/authelia/. /mnt/ssd/config/authelia/
rm -rf /tmp/restore
docker compose up -d authelia

# Option B : Regenerer les secrets (si backup corrompu aussi)
# ATTENTION : cela invalide TOUS les clients OIDC existants
cd /mnt/ssd/homelab-config
cp authelia/configuration.yml.example /mnt/ssd/config/authelia/configuration.yml
cp authelia/users_database.yml.example /mnt/ssd/config/authelia/users_database.yml

# Generer les 4 secrets + cle OIDC
for secret in jwt session storage hmac; do
    echo "$secret: $(openssl rand -hex 32)"
done
openssl genrsa -out /mnt/ssd/config/authelia/oidc.pem 4096

# Regenerer les client secrets OIDC et les hasher
openssl rand -hex 32  # → secret clair pour le service
docker run --rm --entrypoint authelia authelia/authelia:latest \
    crypto hash generate pbkdf2 --password "<SECRET_CLAIR>"
# Mettre le hash dans configuration.yml, le secret clair dans le service

# Regenerer le hash du mot de passe utilisateur
docker run --rm --entrypoint authelia authelia/authelia:latest \
    crypto hash generate argon2 --password "<MOT_DE_PASSE>"

# Redemarrer et reconfigurer chaque client OIDC :
# - Proxmox : pveum realm modify authelia --client-key <NEW_SECRET>
# - Portainer : Settings > Authentication > OAuth > update secret
# - Grafana : variable d'environnement GF_AUTH_GENERIC_OAUTH_CLIENT_SECRET
# - Beszel : variable OIDC_SECRET dans l'environnement
docker compose up -d authelia

# Diagnostic
ping 1.1.1.1                           # Internet accessible ?
dig gabin-simond.fr @1.1.1.1           # DNS public fonctionne ?
curl -s https://api.cloudflare.com/     # Cloudflare accessible ?
tailscale status                        # Tailscale connecte ?

# Si Internet down :
# - Les services restent accessibles en LAN via IP directe
# - Les certificats TLS existants restent valides (90 jours Let's Encrypt)
# - Contacter le FAI (Free : 3244)

# Si Cloudflare down ou token revoque :
# - Generer un nouveau token API sur dashboard.cloudflare.com
# - Mettre a jour CF_DNS_API_TOKEN dans /mnt/ssd/config/.env
# - docker compose restart traefik

# Si Tailscale down :
# - Acces LAN uniquement
# - Re-authentifier : tailscale up --force-reauth
# - Si cle revoquee : login.tailscale.com > Machines > re-authorize

# Si cle SSH compromise (vol/fuite) :
# 1. Retirer la cle de TOUTES les machines
for host in homelab pve1 pve2; do
    ssh gabins@$host "sed -i '/<FINGERPRINT>/d' ~/.ssh/authorized_keys"
done

# 2. Generer une nouvelle paire
ssh-keygen -t ed25519 -C "homelab-$(date +%Y%m%d)"

# 3. Deployer la nouvelle cle
for host in homelab pve1 pve2; do
    ssh-copy-id -i ~/.ssh/id_ed25519.pub gabins@$host
done

# Si YubiKey perdue/defaillante :
# 1. Se connecter avec TOTP (backup) sur Authelia
# 2. Supprimer la YubiKey defaillante dans Authelia (user settings)
# 3. Enregistrer la YubiKey de remplacement
# 4. Revoquer les sessions actives par precaution

#!/bin/bash
# break-glass-verify.sh — a lancer depuis penny

echo "=== VERIFICATION POST-RESTAURATION ==="

echo -n "SSD monte rw : "
mount | grep -q "/mnt/ssd.*rw" && echo "OK" || echo "FAIL"

echo -n "ASPM off : "
cat /sys/module/pcie_aspm/parameters/policy | grep -q "\[off\]" && echo "OK" || echo "FAIL"

echo -n "DNS primaire : "
dig +short home.gabin-simond.fr @192.168.1.28 | grep -q "192.168.1.28" && echo "OK" || echo "FAIL"

echo -n "DNS secondaire : "
dig +short home.gabin-simond.fr @192.168.1.30 | grep -q "192.168.1.28" && echo "OK" || echo "FAIL"

echo -n "Traefik HTTPS : "
curl -sko /dev/null -w "%{http_code}" https://home.gabin-simond.fr | grep -qE "200|302" && echo "OK" || echo "FAIL"

echo -n "Authelia : "
curl -sko /dev/null -w "%{http_code}" https://auth.home.gabin-simond.fr | grep -qE "200|302" && echo "OK" || echo "FAIL"

echo -n "Vaultwarden : "
curl -sko /dev/null -w "%{http_code}" https://vault.home.gabin-simond.fr | grep -qE "200|302" && echo "OK" || echo "FAIL"

echo -n "Tailscale : "
tailscale status >/dev/null 2>&1 && echo "OK" || echo "FAIL"

echo -n "Docker containers : "
total=$(docker ps -q | wc -l)
healthy=$(docker ps --filter "status=running" -q | wc -l)
echo "$healthy/$total running"

echo -n "Backup B2 accessible : "
source /root/.restic-env && restic snapshots >/dev/null 2>&1 && echo "OK" || echo "FAIL"

echo -n "Temperature : "
temp=$(vcgencmd measure_temp | grep -oP '[0-9.]+')
echo "${temp}C $([ $(echo "$temp < 70" | bc) -eq 1 ] && echo 'OK' || echo 'WARN')"

echo "=== FIN ==="