Plan de Mise en Place d'un Serveur Domestique¶

# Écran 1 : Welcome
Install Proxmox VE (Graphical)

# Écran 2 : EULA
Accept (I agree)

# Écran 3 : Target Harddisk
├─ Target Harddisk : /dev/sda (Samsung EVO 250GB #1)
├─ Filesystem : ext4
└─ Advanced Options (laisser par défaut)
   ├─ hdsize : <vide> (utilise tout le disque sauf 20GB réservés)
   ├─ swapsize : <vide> (auto: ~8GB pour 32GB RAM)
   ├─ maxroot : <vide> (auto: ~50GB pour /)
   └─ maxvz : <vide> (auto: reste pour /var/lib/vz - VMs/containers)

# Écran 4 : Localisation
├─ Country : France
├─ Time zone : Europe/Paris
└─ Keyboard Layout : French

# Écran 5 : Mot de passe
├─ Password : [MOT_DE_PASSE_FORT_32_CARACTERES]
├─ Confirm : [RÉPÉTER]
└─ Email : votre@email.com

# Écran 6 : Network Configuration
├─ Management Interface : <auto-détecté> (votre carte Ethernet)
├─ Hostname (FQDN) : pve.local.lan (ou pve.home.arpa)
├─ IP Address (CIDR) : <pré-rempli par DHCP> (ex: 192.168.1.100/24)
├─ Gateway : <pré-rempli> (ex: 192.168.1.254)
└─ DNS Server : <pré-rempli> (ex: 192.168.1.254)

# Installation : ~10-15 minutes
# Reboot automatique

# Accès Shell : Web UI → Datacenter → [nom-du-noeud] → Shell

# 1. Update système complet
apt update && apt dist-upgrade -y

# 2. Installer outils essentiels
apt install -y vim git curl wget htop iotop ncdu net-tools smartmontools

# 3. Configurer timezone
timedatectl set-timezone Europe/Paris

# 4. Vérifier NTP (activé par défaut sur PVE 9)
timedatectl status
# Devrait montrer : "System clock synchronized: yes"

# 5. Activer firmware non-free (si pas déjà fait)
# Pour microcode CPU et drivers matériels
nano /etc/apt/sources.list.d/debian.sources
# Vérifier que "non-free-firmware" est dans "Components:" de chaque stanza
# Devrait ressembler à : Components: main non-free-firmware

# 6. Reboot pour appliquer tous les changements
reboot

# Shell Proxmox (Web UI → Node → Shell)

# Commande testée et fonctionnelle sur Proxmox VE 9.1
sed -Ezi.bak "s/(function ?\(orig_cmd\) \{)/\1\n\torig_cmd\(\);\n\treturn;/g" /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js && systemctl restart pveproxy.service

# Vérifier que le backup a été créé
ls -lh /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js*
# Devrait montrer : proxmoxlib.js et proxmoxlib.js.bak

# Rafraîchir la page Web UI dans le navigateur (Ctrl+F5)
# Le popup ne devrait plus apparaître ✓

# Méthode 1 : Restaurer depuis backup (RECOMMANDÉ)
mv /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js.bak /usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js
systemctl restart pveproxy.service

# Méthode 2 : Télécharger manuellement depuis les dépôts
# Si la commande apt install --reinstall échoue avec "cannot be downloaded"
cd /tmp
apt download proxmox-widget-toolkit
dpkg -x proxmox-widget-toolkit_*.deb extracted/
cp extracted/usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js /usr/share/javascript/proxmox-widget-toolkit/
systemctl restart pveproxy.service

# Méthode 3 : Depuis le cache APT (si disponible)
cp /var/cache/apt/archives/proxmox-widget-toolkit_*.deb /tmp/
cd /tmp
dpkg -x proxmox-widget-toolkit_*.deb extracted/
cp extracted/usr/share/javascript/proxmox-widget-toolkit/proxmoxlib.js /usr/share/javascript/proxmox-widget-toolkit/
systemctl restart pveproxy.service

# Lister tous les disques
lsblk -o NAME,SIZE,TYPE,FSTYPE,MOUNTPOINT,MODEL

# Identifier par numéro série (méthode fiable)
ls -l /dev/disk/by-id/ | grep -v part

# ⚠️ ATTENTION : Ceci effacera TOUTES les données de sdc
# Assurez-vous que le backup est complet avant de continuer

# Partition 1 : 1TB protégé
# Partition 2 : 2.6TB médias non-protégés

parted /dev/sdc
  (parted) mklabel gpt
  (parted) unit GB
  (parted) mkpart primary ext4 0 1000        # 0-1TB
  (parted) mkpart primary ext4 1000 100%     # 1TB-3.6TB
  (parted) name 1 data-protected
  (parted) name 2 media-bulk
  (parted) print  # Vérifier
  (parted) quit

# ⚠️ ATTENTION : Ces commandes effaceront toutes les données
# Vérifiez bien que les sauvegardes sont complètes

# Disques données protégées
mkfs.ext4 -L data1-protected /dev/sdc1  # Hitachi 1TB partition
mkfs.ext4 -L data2-protected /dev/sdd1  # WD Green 1TB #1

# Médias non-protégés
mkfs.ext4 -L media-bulk /dev/sdc2       # Hitachi 2.6TB partition

# SSD Docker/LXC
mkfs.ext4 -L lxc-storage /dev/sdb1      # Samsung SSD 233GB

# Disque parity SnapRAID
mkfs.ext4 -L parity /dev/sde1         # WD Green 1TB #2 (parity)

# Vérifier labels
blkid | grep LABEL

mkdir -p /mnt/{disk1,disk2,storage,media-bulk,lxc-data,parity}

# Obtenir UUIDs
blkid | grep -E 'data1-protected|data2-protected|media-bulk|lxc-storage|parity'

# Éditer /etc/fstab
nano /etc/fstab

# Ajouter à /etc/fstab (remplacer UUIDs par valeurs réelles obtenues avec blkid) :

# Données protégées mergerfs
UUID=xxxx-xxxx /mnt/disk1      ext4 defaults,noatime 0 2  # sdc1 (Hitachi 1TB)
UUID=yyyy-yyyy /mnt/disk2      ext4 defaults,noatime 0 2  # sdd1 (WD Green 1TB)

# Médias non-protégés
UUID=aaaa-aaaa /mnt/media-bulk ext4 defaults,noatime 0 2  # sdc2 (Hitachi 2.6TB)

# LXC storage
UUID=bbbb-bbbb /mnt/lxc-data   ext4 defaults,noatime 0 2  # sdb1 (Samsung SSD 233GB)

# Disque parity SnapRAID
UUID=zzzz-zzzz /mnt/parity   ext4 defaults,noatime 0 2  # sde1 (WD Green 1TB)

# Monter tout
mount -a

# Vérifier
df -h | grep /mnt

# Télécharger dernière version mergerfs
cd /tmp
wget https://github.com/trapexit/mergerfs/releases/download/2.40.2/mergerfs_2.40.2.debian-bookworm_amd64.deb

# Installer
dpkg -i mergerfs_*.deb

# Ajouter à /etc/fstab
nano /etc/fstab

# Ajouter ligne mergerfs (à la fin du fichier) :
/mnt/disk* /mnt/storage fuse.mergerfs allow_other,use_ino,cache.files=auto-full,moveonenospc=true,category.create=mfs,dropcacheonclose=true,minfreespace=50G 0 0

# Monter mergerfs
mount /mnt/storage

# Vérifier capacité totale
df -h /mnt/storage
# Devrait montrer ~2TB (1TB sdc1 + 1TB sdd1)

# Test écriture
touch /mnt/storage/test.txt
ls -la /mnt/storage/
rm /mnt/storage/test.txt

# Installer SnapRAID
apt install -y snapraid

# Créer répertoire content
mkdir -p /var/snapraid

# Configuration
nano /etc/snapraid.conf

# Initialiser SnapRAID (premier sync)
snapraid sync

# Vérifier status
snapraid status

# Données PROTÉGÉES (mergerfs)
mkdir -p /mnt/storage/{archives,google-drive-backup,google-photos-backup,docker-configs,backups}

# Médias NON-PROTÉGÉS
mkdir -p /mnt/media-bulk/{movies,tv,downloads}

# Lien symbolique pour accès unifié
ln -s /mnt/media-bulk /mnt/storage/media

# Permissions
chown -R root:root /mnt/storage
chmod -R 755 /mnt/storage
chown -R root:root /mnt/media-bulk
chmod -R 755 /mnt/media-bulk

# Brancher USB HGST 1TB (contenant backup fait à l'étape 3.3)
# Devrait apparaître /dev/sdf (vérifier avec lsblk)

mkdir -p /mnt/usb-backup
mount /dev/sdf1 /mnt/usb-backup

# Copier archives vers stockage protégé
rsync -avhP --info=progress2 /mnt/usb-backup/archives-backup/ /mnt/storage/archives/

# Vérifier intégrité post-copie
du -sh /mnt/storage/archives/
du -sh /mnt/usb-backup/archives-backup/
# Les tailles doivent correspondre

# Démonter USB
umount /mnt/usb-backup

# Si SnapRAID configuré, lancer sync avec nouvelles données
# snapraid sync

# Proxmox Shell (pas dans container)

# Éditer config LXC
nano /etc/pve/lxc/100.conf

# Ajouter en fin de fichier :
# Mount point données protégées (mergerfs)
mp0: /mnt/storage,mp=/mnt/storage
# Mount point médias non-protégés
mp1: /mnt/media-bulk,mp=/mnt/media
# Mount point configs Docker
mp2: /mnt/lxc-data/docker-100,mp=/opt/docker

# Créer répertoire configs Docker sur host
mkdir -p /mnt/lxc-data/docker-100

# Start container
pct start 100

# Accéder console
pct enter 100

# Dans container (pct enter 100)

# Update système
apt update && apt upgrade -y

# Installer prérequis
apt install -y ca-certificates curl gnupg lsb-release

# Ajouter clé GPG Docker
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
chmod a+r /etc/apt/keyrings/docker.gpg

# Ajouter repository Docker
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

# Installer Docker
apt update
apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# Vérifier installation
docker --version
docker compose version

# Démarrer Docker
systemctl enable docker
systemctl start docker

# Test
docker run hello-world

# Sur Proxmox HOST (pas container)

# Vérifier iGPU détecté
ls -la /dev/dri
# Devrait montrer : card0, renderD128

# Ajouter à config LXC
nano /etc/pve/lxc/100.conf

# Ajouter :
lxc.cgroup2.devices.allow: c 226:0 rwm
lxc.cgroup2.devices.allow: c 226:128 rwm
lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir 0 0

# Restart container
pct stop 100
pct start 100
pct enter 100

# Dans container, vérifier
ls -la /dev/dri
# Devrait montrer : card0, renderD128

# Dans container
cd /opt/docker
mkdir -p jellyfin sonarr radarr prowlarr sabnzbd

# Créer docker-compose.yml
nano docker-compose.yml

# Démarrer stack
docker compose up -d

# Vérifier containers
docker compose ps

# Vérifier logs
docker compose logs -f jellyfin

docker compose up -d

cd /opt/docker/homepage
mkdir -p {services,widgets,bookmarks}

nano services.yaml

nano widgets.yaml

# Proxmox Shell

# Changer port SSH
nano /etc/ssh/sshd_config

# Modifier :
Port 2222
PermitRootLogin prohibit-password
PasswordAuthentication no
PubkeyAuthentication yes
MaxAuthTries 3

# Générer clé SSH depuis PC (si pas déjà fait)
# Sur PC : ssh-keygen -t ed25519 -a 100

# Copier clé publique vers serveur
# Sur PC : ssh-copy-id -p 22 root@192.168.1.10
# (Avant changement port)

# Tester connexion avec clé
ssh -p 22 root@192.168.1.10

# Si succès, redémarrer SSH
systemctl restart sshd

# Tester nouveau port
ssh -p 2222 root@192.168.1.10

# Proxmox Shell
apt install -y fail2ban

# Configuration
nano /etc/fail2ban/jail.local

systemctl enable fail2ban
systemctl start fail2ban

# Vérifier
fail2ban-client status

apt install -y ufw

# Règles par défaut
ufw default deny incoming
ufw default allow outgoing

# Autoriser services
ufw allow 2222/tcp comment 'SSH'
ufw allow from 192.168.1.0/24 to any port 8006 proto tcp comment 'Proxmox Web'
ufw allow from 192.168.1.0/24 comment 'LAN complet'

# Activer
ufw enable

# Vérifier
ufw status verbose

# Proxmox Shell
mkdir -p /opt/backup-scripts

nano /opt/backup-scripts/backup-configs.sh

#!/bin/bash
# Backup configurations critiques

BACKUP_DIR="/mnt/storage/backups/configs"
DATE=$(date +%Y%m%d-%H%M)
BACKUP_FILE="$BACKUP_DIR/server-configs-$DATE.tar.gz"

# Créer répertoire si absent
mkdir -p $BACKUP_DIR

# Backup Proxmox configs
tar -czf $BACKUP_FILE \
    /etc/pve/ \
    /etc/network/interfaces \
    /etc/hosts \
    /etc/fstab \
    /etc/snapraid.conf \
    /opt/backup-scripts/ \
    /mnt/lxc-data/docker-100/ \
    2>/dev/null

# Liste paquets installés
dpkg --get-selections > $BACKUP_DIR/packages-$DATE.list

# Cleanup anciens backups (garder 30 jours)
find $BACKUP_DIR -name "server-configs-*.tar.gz" -mtime +30 -delete
find $BACKUP_DIR -name "packages-*.list" -mtime +30 -delete

# Log
echo "Backup completed: $BACKUP_FILE ($(du -h $BACKUP_FILE | cut -f1))" | \
    tee -a /var/log/backup-configs.log

# Copier vers USB si monté
if mountpoint -q /mnt/usb-backup; then
    rsync -a $BACKUP_DIR/ /mnt/usb-backup/configs/
    echo "USB backup synced" | tee -a /var/log/backup-configs.log
fi

chmod +x /opt/backup-scripts/backup-configs.sh

# Tester
/opt/backup-scripts/backup-configs.sh

# Automatiser (cron quotidien 3h)
crontab -e
# Ajouter :
0 3 * * * /opt/backup-scripts/backup-configs.sh

# Proxmox Shell - Activer onboot pour CT 100 et 101
pct set 100 --onboot 1
pct set 101 --onboot 1
pct set 102 --onboot 1  # PBS

# Vérifier configuration
grep onboot /etc/pve/lxc/100.conf
grep onboot /etc/pve/lxc/101.conf
grep onboot /etc/pve/lxc/102.conf
# Devrait afficher : onboot: 1

# Test redémarrage complet
reboot

# Après reboot, vérifier containers démarrés
pct list
# Status devrait montrer "running" pour CT 100, 101, 102

# Vérifier Docker auto-start dans containers
pct enter 100
docker ps
# Tous les services (jellyfin, sonarr, radarr...) doivent être "Up"

# Installation PBS dans CT 102
pct enter 102

# Ajouter repository
echo "deb http://download.proxmox.com/debian/pbs bookworm pbs-no-subscription" > /etc/apt/sources.list.d/pbs.list
wget https://enterprise.proxmox.com/debian/proxmox-release-bookworm.gpg -O /etc/apt/trusted.gpg.d/proxmox-release-bookworm.gpg

# Installer
apt update && apt install proxmox-backup-server -y

# Vérifier
systemctl status proxmox-backup.service
systemctl status proxmox-backup-proxy.service

# Sur host Proxmox - Créer datastore sur stockage protégé
mkdir -p /mnt/storage/pbs-datastore
chown -R 34:34 /mnt/storage/pbs-datastore  # UID backup:backup

# Ajouter mount point au CT PBS
nano /etc/pve/lxc/102.conf
# Ajouter ligne :
mp0: /mnt/storage/pbs-datastore,mp=/mnt/datastore

# Restart container
pct stop 102 && pct start 102

# Proxmox Web UI
Datacenter → Storage → Add → Proxmox Backup Server

├─ ID: pbs-backups
├─ Server: 192.168.1.102
├─ Port: 8007
├─ Username: root@pam
├─ Datastore: backups
└─ Enable: ✓

# Créer job backup
Datacenter → Backup → Add

├─ Node: pve
├─ Storage: pbs-backups
├─ Schedule: Daily 03:00
├─ VMs: 100, 101
├─ Compression: zstd
├─ Mode: Snapshot
└─ Enable: ✓

# Dans CT PBS (102)
pct enter 102

# Installer rclone
curl https://rclone.org/install.sh | bash

# Configurer OAuth Google Drive
rclone config
# name: gdrive
# storage: drive (Google Drive)
# scope: drive (Full access)
# [Suivre wizard OAuth dans navigateur]

# Test connexion
rclone ls gdrive:

# Créer répertoires
rclone mkdir gdrive:backup/homeserver/pbs

cat > /usr/local/bin/pbs-sync-gdrive << 'EOF'
#!/bin/bash
# Sync PBS datastore vers Google Drive

PBS_DIR="/mnt/datastore"
GDRIVE_DIR="gdrive:backup/homeserver/pbs"
LOG="/var/log/pbs-gdrive-sync.log"

log() {
    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG"
}

log "=== Starting PBS → Google Drive sync ==="

if rclone sync "$PBS_DIR" "$GDRIVE_DIR" \
    --bwlimit 10M \
    --progress \
    --log-file "$LOG" \
    --transfers 4 \
    --checkers 8 \
    --exclude '.lock' \
    --exclude '.chunks/**'; then

    log "✓ Sync completed"

    USAGE=$(rclone size "$GDRIVE_DIR" --json 2>/dev/null | grep -oP '"bytes":\K[0-9]+' || echo "0")
    USAGE_GB=$((USAGE / 1024 / 1024 / 1024))
    log "Google Drive used: ${USAGE_GB}GB"
else
    log "✗ Sync FAILED"
    exit 1
fi

log "=== Sync completed ==="
EOF

chmod +x /usr/local/bin/pbs-sync-gdrive

# Test manuel
/usr/local/bin/pbs-sync-gdrive

# Automatiser avec cron quotidien 4h
crontab -e
# Ajouter ligne :
0 4 * * * /usr/local/bin/pbs-sync-gdrive

# Depuis PBS (après crash container)
pct restore <VMID> pbs-backups:ct/<ID>/<SNAPSHOT-ID> \
  --storage local-lvm --rootfs 32

# Exemple : Restore CT 100
pct restore 100 pbs-backups:ct/100/2026-01-24T03:00:00Z \
  --storage local-lvm --rootfs 32

# Reconfigurer mount points
nano /etc/pve/lxc/100.conf
# Ajouter :
mp0: /mnt/storage,mp=/mnt/storage
mp1: /mnt/media-bulk,mp=/mnt/media
mp2: /mnt/lxc-data/docker-100,mp=/opt/docker

# Activer auto-start et démarrer
pct set 100 --onboot 1
pct start 100

# Vérifier services
sleep 30
pct enter 100
docker ps  # Tous les conteneurs doivent être UP

# Après réinstallation Proxmox + CT PBS
# Dans CT PBS
rclone sync gdrive:backup/homeserver/pbs /mnt/datastore \
  --progress \
  --bwlimit 50M

# Attendre fin sync (peut prendre 1-2h selon taille)
# Puis restore containers normalement via PBS UI

# 1. Réinstaller Proxmox VE 9.1 (ISO USB)
#    - IP: 192.168.1.10/24
#    - Gateway: 192.168.1.254
#    - Disk: Samsung SSD sda

# 2. Configurer stockage
# Recréer /etc/fstab manuellement (voir section 3.4)
mount -a

# 3. Créer CT PBS (102)
# [Suivre étapes 7.5.2]

# 4. Restore depuis Google Drive
pct enter 102
rclone sync gdrive:backup/homeserver/pbs /mnt/datastore

# 5. Restore containers
pct restore 100 pbs-backups:ct/100/[LATEST] --storage local-lvm --rootfs 32
pct restore 101 pbs-backups:ct/101/[LATEST] --storage local-lvm --rootfs 32

# 6. Reconfigurer mount points (éditer /etc/pve/lxc/*.conf)

# 7. Démarrer
pct set 100 --onboot 1 && pct start 100
pct set 101 --onboot 1 && pct start 101

# 8. Validation
pct enter 100
docker ps
curl http://localhost:8096  # Jellyfin

# Script test restauration mensuel
cat > /opt/backup-scripts/test-backup-restore.sh << 'EOF'
#!/bin/bash
# Test automatique restauration backup

TEST_VMID=900
LOG="/var/log/backup-validation.log"

log() {
    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG"
}

log "=== Starting backup validation test ==="

# Trouver dernier backup CT 100 dans PBS
LATEST=$(pvesm list pbs-backups | grep "ct/100" | tail -1 | awk '{print $1}')

if [ -z "$LATEST" ]; then
    log "ERROR: No backup found for CT 100"
    exit 1
fi

log "Testing backup: $LATEST"

# Détruire CT test si existe
if pct status $TEST_VMID &>/dev/null; then
    log "Destroying existing test CT $TEST_VMID"
    pct stop $TEST_VMID 2>/dev/null
    pct destroy $TEST_VMID
fi

# Restore vers CT test
log "Restoring to test CT $TEST_VMID..."
if pct restore $TEST_VMID "$LATEST" --storage local-lvm --rootfs 32; then
    log "✓ Restore successful"
else
    log "✗ Restore FAILED"
    exit 1
fi

# Démarrer CT test
log "Starting test CT..."
if pct start $TEST_VMID; then
    log "✓ Container started"
else
    log "✗ Container start FAILED"
    pct destroy $TEST_VMID
    exit 1
fi

sleep 15

# Valider Docker
log "Validating Docker service..."
if pct exec $TEST_VMID -- systemctl is-active docker >/dev/null 2>&1; then
    log "✓ Docker service active"
else
    log "✗ Docker service FAILED"
    pct stop $TEST_VMID
    pct destroy $TEST_VMID
    exit 1
fi

# Valider docker-compose.yml
log "Validating docker-compose.yml..."
if pct exec $TEST_VMID -- test -f /opt/docker/docker-compose.yml; then
    log "✓ docker-compose.yml exists"
else
    log "✗ docker-compose.yml MISSING"
    pct stop $TEST_VMID
    pct destroy $TEST_VMID
    exit 1
fi

# Cleanup
log "Cleaning up test CT..."
pct stop $TEST_VMID
pct destroy $TEST_VMID

log "=== Backup validation SUCCESSFUL ==="
exit 0
EOF

chmod +x /opt/backup-scripts/test-backup-restore.sh

# Test manuel
/opt/backup-scripts/test-backup-restore.sh

# Automatiser - cron mensuel premier dimanche 6h
crontab -e
# Ajouter ligne :
0 6 1-7 * 0 /opt/backup-scripts/test-backup-restore.sh

nano /opt/backup-scripts/snapraid-runner.sh

#!/bin/bash
# SnapRAID automation avec sécurité

LOGFILE="/var/log/snapraid.log"
THRESHOLD=50

log() {
    echo "[$(date +'%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOGFILE"
}

log "=== SnapRAID run started ==="

# Vérifier pas déjà en cours
if pidof -x snapraid > /dev/null; then
    log "ERROR: SnapRAID already running"
    exit 1
fi

# Diff
DIFF_OUT=$(snapraid diff 2>&1)
CHANGED=$(echo "$DIFF_OUT" | grep -oP '\d+(?= modified)' | head -1 || echo "0")
ADDED=$(echo "$DIFF_OUT" | grep -oP '\d+(?= added)' | head -1 || echo "0")
REMOVED=$(echo "$DIFF_OUT" | grep -oP '\d+(?= removed)' | head -1 || echo "0")
TOTAL=$((CHANGED + ADDED + REMOVED))

log "Changes: $ADDED added, $REMOVED removed, $CHANGED modified (total: $TOTAL)"

# Seuil sécurité
if [ "$TOTAL" -gt "$THRESHOLD" ]; then
    log "ERROR: Too many changes ($TOTAL > $THRESHOLD). Manual review required!"
    exit 1
fi

# Sync si changements
if [ "$TOTAL" -gt 0 ]; then
    log "Running sync..."
    if snapraid sync >> "$LOGFILE" 2>&1; then
        log "Sync completed"
    else
        log "ERROR: Sync failed"
        exit 1
    fi
else
    log "No changes, skipping sync"
fi

# Scrub (8% données, 30+ jours non vérifiés)
log "Running scrub..."
if snapraid scrub -p 8 -o 30 >> "$LOGFILE" 2>&1; then
    log "Scrub completed"
else
    log "ERROR: Scrub failed"
    exit 1
fi

log "=== SnapRAID run completed ==="

# Cleanup vieux logs
find /var/log -name "snapraid.log.*" -mtime +90 -delete

exit 0

chmod +x /opt/backup-scripts/snapraid-runner.sh

# Automatiser (cron quotidien 2h)
crontab -e
# Ajouter :
0 2 * * * /opt/backup-scripts/snapraid-runner.sh

# Créer fichier README serveur
nano /root/SERVER-INFO.md

# Dans CT PBS (102)
rclone sync gdrive:backup/homeserver/pbs /mnt/datastore --progress

# Puis restore containers via PBS UI ou CLI