COMPREHENSIVE RESEARCH & RECOMMENDATIONS (2026)¶

# Créer pool ZFS sur Hitachi 4TB seul
zpool create storage /dev/sdb

# ❌ Avantages ZFS perdus:
# - Pas de redondance (comme ext4)
# - Pas de mirror (panne disque = perte totale)
# - RAM consommée pour ARC sans bénéfice
# - Complexité ajoutée sans protection

# ✅ Seuls gains réels:
# - Snapshots (mais backup externe existe)
# - Checksumming (utile mais pas critique pour média)
# - Compression (10-15% gain espace)

Verdict: Pas worth it pour single disk

# Situation: Pool existant 2x4TB, besoin migrer vers 2x8TB
# Option A: Replace in-place (LENT)

# 1. Acheter premier 8TB, remplacer un 4TB
zpool replace storage old-4tb-disk new-8tb-disk
# Attendre resilver: ~6-8 heures pour 3TB data

# 2. Acheter second 8TB, remplacer l'autre 4TB
zpool replace storage other-4tb-disk second-8tb-disk
# Attendre resilver: encore ~6-8 heures

# 3. Expand pool pour utiliser espace additionnel
zpool online -e storage new-8tb-disk
zpool online -e storage second-8tb-disk

# Total: 2-3 jours de travail, ~€340 (2x8TB), risque pendant resilver

# 1. Acheter 2x8TB, créer nouveau pool
zpool create storage-new mirror /dev/sdc /dev/sdd

# 2. Copier données (zfs send/receive ou rsync)
# Besoin: espace temporaire ou downtime

# 3. Destroy ancien pool, rename nouveau
zpool destroy storage
zpool import storage-new storage

# Total: Plus simple, mais besoin planification

# Setup simple une seule fois
zpool create storage mirror /dev/sdb /dev/sdc

# Fini! Aucune migration future nécessaire
# Expansion future = ajouter vdev mirror si besoin:
zpool add storage mirror /dev/sdd /dev/sde  # 2x8TB supplémentaires

# ❌ IMPOSSIBLE: Mirror avec tailles différentes
zpool create storage mirror /dev/sdb /dev/sdc  # 4TB + 1TB = ERROR

# ✅ POSSIBLE: vdevs différents dans même pool
zpool create storage mirror /dev/sdb /dev/sdc    # vdev1: 2x4TB
zpool add storage mirror /dev/sdd /dev/sde       # vdev2: 2x8TB (plus tard)
# Pool total: 4TB + 8TB = 12TB utilisables

# Situation: ZFS mirror 2x4TB, 3TB utilisés
# Objectif: Mirror 2x8TB

# Étape 1: Acheter 2x8TB WD Red (~€240-280)

# Étape 2: Remplacer premier disque (SAFE - mirror actif)
zpool offline storage /dev/sdb          # Offline premier 4TB
# Éteindre serveur, remplacer physiquement 4TB → 8TB
# Rallumer serveur
zpool replace storage /dev/sdb /dev/sdc # Nouveau 8TB

# Resilver commence automatiquement
# Monitorer: zpool status
# Temps: ~2-4 heures pour 3TB data
# Serveur reste ONLINE pendant resilver

# Étape 3: Remplacer second disque (SAFE - mirror actif)
zpool offline storage /dev/old-disk
# Remplacer physiquement
zpool replace storage /dev/old /dev/sdd

# Resilver à nouveau: ~2-4 heures
# Pool toujours online

# Étape 4: Expand pour utiliser nouvel espace
zpool online -e storage /dev/sdc
zpool online -e storage /dev/sdd
zpool set autoexpand=on storage

# Vérifier nouvelle taille
zpool list storage  # Devrait montrer ~8TB utilisables

# Total downtime: 0 minutes (hot-swap si supporté, sinon 2x5min reboot)
# Total temps actif: 30 minutes humain (attente resilver = passive)
# Risque: FAIBLE (<1% échec pendant resilver)

# Ajouter 8TB à mergerfs
mkfs.ext4 /dev/sdc                # 2 min
echo "/dev/sdc /mnt/disk3 ext4..." >> /etc/fstab
mount -a                           # Instantané
echo "data d3 /mnt/disk3" >> /etc/snapraid.conf
snapraid sync                      # 1-3 heures

# Total: ~1-3 heures
# Risque: AUCUN

# Configuration recommandée: Limiter ARC à 8GB
sudo nano /etc/modprobe.d/zfs.conf

# Ajouter:
options zfs zfs_arc_max=8589934592  # 8GB en bytes
options zfs zfs_arc_min=1073741824  # 1GB min

# Appliquer (rebuild initramfs)
sudo update-initramfs -u

# Vérifier après reboot
cat /proc/spl/kstat/zfs/arcstats | grep "^c_max"
# Devrait montrer: 8589934592 (8GB)

# Semaine 1: Préparer migration
- Acheter 2x WD Red 8TB (€240-280)
- Backup COMPLET vers USB Maxtor 4TB
- Vérifier checksums backup

# Semaine 2: Setup ZFS propre
- Créer nouveau pool ZFS mirror 2x8TB
zpool create storage mirror /dev/new8tb1 /dev/new8tb2
zfs set compression=lz4 storage
zfs set atime=off storage

- Créer datasets
zfs create storage/media
zfs create storage/archives
zfs create storage/backups

# Semaine 3: Migration données
- Copier depuis ancien mergerfs vers ZFS
rsync -avhP /mnt/storage/ /storage/

- Vérifier intégrité
- Update /etc/fstab, docker-compose paths

# Semaine 4: Cleanup
- Destroy ancien mergerfs (reformater disques)
- Réaffecter vieux disques:
  * 4TB Hitachi → Backup local (zfs send/receive)
  * 2x 1TB WD Green → Vendre/donner ou cold storage

# mergerfs fusionne les disques en un seul point de montage
/mnt/disk1 (4TB Hitachi)
/mnt/disk2 (1TB WD Green)
    ↓ mergerfs
/mnt/storage (5TB virtuels)

# SnapRAID calcule parité des fichiers (pas en temps réel)
/mnt/parity (1TB WD Green #2)

# Formatter en ext4 (simple, fiable)
mkfs.ext4 -L data1 /dev/sdb  # Hitachi 4TB
mkfs.ext4 -L data2 /dev/sdc  # WD Green 1TB
mkfs.ext4 -L parity /dev/sdd # WD Green 1TB (parity)

# Créer points de montage
mkdir -p /mnt/disk{1,2,parity,storage}

# Monter dans /etc/fstab
LABEL=data1   /mnt/disk1   ext4  defaults,noatime  0 2
LABEL=data2   /mnt/disk2   ext4  defaults,noatime  0 2
LABEL=parity  /mnt/parity  ext4  defaults,noatime  0 2

# Télécharger dernière version (vérifier sur GitHub)
wget https://github.com/trapexit/mergerfs/releases/download/2.40.2/mergerfs_2.40.2.debian-bookworm_amd64.deb
sudo dpkg -i mergerfs_*.deb

# Monter temporairement pour test
sudo mergerfs /mnt/disk1:/mnt/disk2 /mnt/storage \
  -o allow_other,use_ino,cache.files=auto-full,moveonenospc=true,\
     category.create=mfs,dropcacheonclose=true

# Vérifier
df -h /mnt/storage  # Doit afficher somme des disques
touch /mnt/storage/test.txt && rm /mnt/storage/test.txt  # Test écriture

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

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

# Sauvegarder (Ctrl+O, Enter, Ctrl+X)

# Tester montage fstab AVANT reboot
sudo umount /mnt/storage
sudo mount -a
df -h /mnt/storage  # Doit fonctionner

apt install snapraid

# /etc/snapraid.conf
parity /mnt/parity/snapraid.parity
content /var/snapraid.content
content /mnt/disk1/.snapraid.content
content /mnt/disk2/.snapraid.content

data d1 /mnt/disk1
data d2 /mnt/disk2

exclude *.tmp
exclude /downloads/incomplete/
exclude .Trash-*/

# Initialiser
snapraid sync

# Créer script robuste
sudo nano /usr/local/bin/snapraid-runner.sh

#!/bin/bash
# Script SnapRAID avec gestion d'erreurs et logging

set -euo pipefail  # Exit on error, undefined var, pipe failure

LOGFILE="/var/log/snapraid.log"
THRESHOLD=50  # Nombre max de fichiers modifiés avant alerte
EMAIL="votre@email.com"  # Optionnel: pour notifications

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

# Fonction notification erreur (optionnel)
notify_error() {
    log "ERROR: $1"
    # Décommenter si email configuré:
    # echo "$1" | mail -s "SnapRAID Error" "$EMAIL"
    # Ou utiliser ntfy.sh:
    # curl -d "$1" ntfy.sh/votre-topic
}

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

# Vérifier qu'une instance n'est pas déjà en cours
if pidof -x snapraid > /dev/null; then
    notify_error "SnapRAID déjà en cours d'exécution, abandon"
    exit 1
fi

# Étape 1: Diff pour détecter changements
log "Running snapraid diff..."
DIFF_OUT=$(snapraid diff 2>&1 || true)
echo "$DIFF_OUT" >> "$LOGFILE"

# Extraire nombre de fichiers modifiés
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_CHANGES=$((CHANGED + ADDED + REMOVED))
log "Changes detected: $ADDED added, $REMOVED removed, $CHANGED modified (total: $TOTAL_CHANGES)"

# Vérifier seuil de sécurité
if [ "$TOTAL_CHANGES" -gt "$THRESHOLD" ]; then
    notify_error "ATTENTION: $TOTAL_CHANGES fichiers modifiés (seuil: $THRESHOLD). Vérification manuelle requise!"
    log "Sync aborted due to threshold exceeded"
    exit 1
fi

# Étape 2: Sync si changements dans seuil acceptable
if [ "$TOTAL_CHANGES" -gt 0 ]; then
    log "Running snapraid sync..."
    if snapraid sync >> "$LOGFILE" 2>&1; then
        log "Sync completed successfully"
    else
        notify_error "Sync failed! Check $LOGFILE"
        exit 1
    fi
else
    log "No changes detected, skipping sync"
fi

# Étape 3: Scrub (vérification intégrité)
# Vérifie 8% des données, fichiers non vérifiés depuis 30+ jours
log "Running snapraid scrub..."
if snapraid scrub -p 8 -o 30 >> "$LOGFILE" 2>&1; then
    log "Scrub completed successfully"
else
    notify_error "Scrub failed! Possible data corruption. Check $LOGFILE"
    exit 1
fi

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

# Nettoyer vieux logs (garder 90 jours)
find "$(dirname "$LOGFILE")" -name "snapraid.log.*" -mtime +90 -delete 2>/dev/null || true

exit 0

# Rendre exécutable
sudo chmod +x /usr/local/bin/snapraid-runner.sh

# Tester manuellement
sudo /usr/local/bin/snapraid-runner.sh

# Ajouter au cron (tous les jours à 2h du matin)
sudo crontab -e
# Ajouter:
0 2 * * * /usr/local/bin/snapraid-runner.sh

# Monitoring: vérifier logs
tail -f /var/log/snapraid.log

# 1. Copier archives vers Maxtor 4TB USB (backup temporaire)
rsync -avhP /mnt/hitachi-actuel/ /mnt/maxtor/backup-archives/

# 2. Vérifier intégrité
cd /mnt/hitachi-actuel && find . -type f -exec md5sum {} \; > /tmp/checksums-source.txt
cd /mnt/maxtor/backup-archives && find . -type f -exec md5sum {} \; > /tmp/checksums-backup.txt
diff /tmp/checksums-source.txt /tmp/checksums-backup.txt  # Doit être vide

# 3. Reformater Hitachi en ext4
umount /dev/sdb
mkfs.ext4 -L data1 /dev/sdb

# 4. Restaurer archives
rsync -avhP /mnt/maxtor/backup-archives/ /mnt/disk1/archives/

# 5. Vérifier à nouveau
cd /mnt/disk1/archives && find . -type f -exec md5sum {} \; > /tmp/checksums-restored.txt
diff /tmp/checksums-source.txt /tmp/checksums-restored.txt

# Utiliser le 2e disque comme stockage temporaire
# Déplacer par parties, vérifier checksums, reformater zone libérée

# Formatter le nouveau disque
mkfs.ext4 -L data3 /dev/sde

# Ajouter à fstab
LABEL=data3  /mnt/disk3  ext4  defaults,noatime  0 2

# mergerfs le détecte automatiquement (grâce à /mnt/disk*)
mount -a

# Ajouter à SnapRAID config
echo "data d3 /mnt/disk3" >> /etc/snapraid.conf

# Remplacer disque parity 1TB par 8TB (optionnel)
snapraid sync  # Recalculer parity sur nouveau disque

# 1. Copier données du 1TB vers autres disques
# 2. Retirer 1TB de SnapRAID config
# 3. Remplacer physiquement par 8TB
# 4. Ajouter 8TB à config
# 5. Resync parity

# Créer 2 partitions: 1TB protégé + 3TB médias
parted /dev/sdb
  mklabel gpt
  mkpart primary ext4 0% 25%      # 1TB protégé
  mkpart primary ext4 25% 100%    # 3TB médias
  quit

# Formatter
mkfs.ext4 -L data1-protected /dev/sdb1    # 1TB protégé
mkfs.ext4 -L media-unprotected /dev/sdb2  # 3TB médias
mkfs.ext4 -L data2-protected /dev/sdc     # WD Green 1TB protégé
mkfs.ext4 -L parity /dev/sdd              # WD Green 1TB parity

# Points de montage
mkdir -p /mnt/{disk1,disk2,parity,storage,media-bulk}

# /etc/fstab
LABEL=data1-protected   /mnt/disk1      ext4  defaults,noatime  0 2
LABEL=data2-protected   /mnt/disk2      ext4  defaults,noatime  0 2
LABEL=parity            /mnt/parity     ext4  defaults,noatime  0 2
LABEL=media-unprotected /mnt/media-bulk ext4  defaults,noatime  0 2

# Installation
wget https://github.com/trapexit/mergerfs/releases/download/2.40.2/mergerfs_2.40.2.debian-bookworm_amd64.deb
sudo dpkg -i mergerfs_*.deb

# /etc/fstab - ajouter mergerfs (SEULEMENT disques protégés)
/mnt/disk* /mnt/storage fuse.mergerfs allow_other,use_ino,cache.files=auto-full,moveonenospc=true,category.create=mfs,dropcacheonclose=true 0 0

# Monter
sudo mount -a

# Vérifier
df -h /mnt/storage  # Devrait montrer ~2TB (1TB + 1TB)
df -h /mnt/media-bulk  # Devrait montrer ~3TB

sudo nano /etc/snapraid.conf

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

# Premier sync
sudo snapraid sync

# Installer script automation (voir section existante dans doc)

# Données PROTÉGÉES (dans mergerfs /mnt/storage)
/mnt/storage/
├── archives/                 # Archives statiques (importantes)
├── google-drive-backup/      # Snapshots Google Drive
├── google-photos-backup/     # Snapshots Google Photos
├── docker-volumes/           # Configs Docker persistantes
└── backups/                  # Backups divers

# Données NON-PROTÉGÉES (partition séparée)
/mnt/media-bulk/
├── movies/                   # Films Jellyfin (redownload OK)
├── tv/                       # Séries Jellyfin (redownload OK)
└── downloads/                # Téléchargements temporaires

# Créer lien symbolique pour accès unifié
ln -s /mnt/media-bulk /mnt/storage/media
# Résultat: /mnt/storage/media pointe vers /mnt/media-bulk

# 1. Acheter disques
# Recommandé: 2x WD Red Plus 8TB (CMR, pas SMR!)
# Prix 2026: ~€120-140/disque = €240-280 total
# Alternative: Seagate IronWolf 8TB

# 2. Backup COMPLET
rsync -avhP /mnt/storage/ /mnt/maxtor-backup/migration-backup/
rsync -avhP /mnt/media-bulk/ /mnt/maxtor-backup/media-backup/

# 3. Vérifier checksums
cd /mnt/storage
find . -type f -exec md5sum {} \; > /tmp/checksums-storage.txt
cd /mnt/media-bulk
find . -type f -exec md5sum {} \; > /tmp/checksums-media.txt

# 4. Documenter config actuelle
cp /etc/fstab /tmp/fstab.backup
cp /etc/snapraid.conf /tmp/snapraid.conf.backup
docker-compose config > /tmp/docker-compose-current.yml

# 1. Installer ZFS sur Proxmox (si pas déjà fait)
apt update
apt install zfsutils-linux

# 2. Configurer tuning ZFS (AVANT de créer pool)
echo "options zfs zfs_arc_max=8589934592" > /etc/modprobe.d/zfs.conf  # 8GB
echo "options zfs zfs_arc_min=1073741824" >> /etc/modprobe.d/zfs.conf # 1GB min
update-initramfs -u

# 3. Créer pool ZFS mirror sur 2x8TB
zpool create storage mirror /dev/disk/by-id/ata-WD-8TB-1 /dev/disk/by-id/ata-WD-8TB-2

# Vérifier
zpool status storage
# Devrait montrer: ONLINE, mirror-0

# 4. Configurer pool
zfs set compression=lz4 storage          # Compression transparente
zfs set atime=off storage                # Performance (pas de access time)
zfs set xattr=sa storage                 # Extended attributes (performance)
zfs set relatime=on storage              # Compromise pour apps
zfs set autoexpand=on storage            # Auto-expand si disques remplacés

# 5. Créer datasets (sous-filesystems)
zfs create storage/media                 # Médias Jellyfin
zfs create storage/archives              # Archives statiques
zfs create storage/backups               # Google Drive/Photos backups
zfs create storage/docker                # Volumes Docker

# Configurer snapshots automatiques par dataset
zfs set com.sun:auto-snapshot=true storage/archives
zfs set com.sun:auto-snapshot=true storage/backups
zfs set com.sun:auto-snapshot=true storage/docker
zfs set com.sun:auto-snapshot=false storage/media  # Pas besoin pour médias

# Vérifier
zfs list

# 1. Copier archives + backups (données critiques d'abord)
rsync -avhP --delete /mnt/storage/archives/ /storage/archives/
rsync -avhP --delete /mnt/storage/google-drive-backup/ /storage/backups/google-drive/
rsync -avhP --delete /mnt/storage/google-photos-backup/ /storage/backups/google-photos/

# Prendre premier snapshot
zfs snapshot storage/archives@migration
zfs snapshot storage/backups@migration

# 2. Copier médias (gros volume, peut prendre 12-24h)
rsync -avhP --delete /mnt/media-bulk/ /storage/media/

# Snapshot
zfs snapshot storage/media@migration

# 3. Copier configs Docker
rsync -avhP --delete /mnt/storage/docker-volumes/ /storage/docker/
zfs snapshot storage/docker@migration

# 4. Vérifier intégrité (CRITIQUE)
cd /storage/archives
find . -type f -exec md5sum {} \; > /tmp/checksums-zfs-archives.txt
diff /tmp/checksums-storage.txt /tmp/checksums-zfs-archives.txt
# Répéter pour chaque dataset

# 1. Arrêter services Docker
cd /opt/docker
docker-compose down

# 2. Update paths docker-compose.yml
sed -i 's|/mnt/storage|/storage|g' docker-compose.yml
sed -i 's|/mnt/media-bulk|/storage/media|g' docker-compose.yml

# 3. Update /etc/fstab (retirer mergerfs)
nano /etc/fstab
# Commenter lignes mergerfs
# ZFS monte automatiquement au boot (pas besoin fstab)

# 4. Redémarrer services
docker-compose up -d

# 5. Tester TOUT
# - Jellyfin browse media
# - Sonarr/Radarr paths
# - Accès archives
# - Backups fonctionnent

# 6. Si tout OK: cleanup anciens disques
umount /mnt/disk1 /mnt/disk2 /mnt/parity /mnt/media-bulk
# Reformater ou réaffecter disques

# Installer Sanoid (meilleur outil snapshot ZFS 2026)
apt install sanoid

# Configurer /etc/sanoid/sanoid.conf
nano /etc/sanoid/sanoid.conf

# Activer service
systemctl enable sanoid.timer
systemctl start sanoid.timer

# Test manuel
sanoid --take-snapshots --verbose

# Vérifier snapshots
zfs list -t snapshot

#!/bin/bash
# /usr/local/bin/zfs-backup-local.sh

# Snapshot tous les datasets
zfs snapshot -r storage@daily-$(date +%Y%m%d)

# Send incremental vers Hitachi 4TB (backup local)
# Créer pool backup sur Hitachi
zpool create backup /dev/sdb  # Hitachi 4TB reformaté

# Premier send (full)
zfs send -R storage@daily-$(date +%Y%m%d) | zfs receive -F backup/storage

# Sends suivants (incremental)
YESTERDAY=$(date -d "yesterday" +%Y%m%d)
TODAY=$(date +%Y%m%d)
zfs send -R -i storage@daily-$YESTERDAY storage@daily-$TODAY | \
  zfs receive -F backup/storage

# Cleanup vieux snapshots (garder 30 jours)
zfs list -H -o name -t snapshot | grep "@daily-" | \
  head -n -30 | xargs -n 1 zfs destroy

#!/bin/bash
# /usr/local/bin/zfs-backup-offsite.sh

# Snapshots archives seulement (critiques, 1TB < HGST)
zfs snapshot storage/archives@offsite-$(date +%Y%m%d)
zfs snapshot storage/docker@offsite-$(date +%Y%m%d)

# Send vers USB externe
if mountpoint -q /mnt/offsite-usb; then
  # Créer pool temporaire sur USB
  zpool import -d /mnt/offsite-usb offsite-backup || \
    zpool create offsite-backup /dev/disk/by-label/HGST-1TB

  # Send incremental
  LAST=$(zfs list -t snapshot -o name offsite-backup/archives | tail -1 | cut -d@ -f2)
  zfs send -i storage/archives@$LAST storage/archives@offsite-$(date +%Y%m%d) | \
    zfs receive offsite-backup/archives

  # Export pool
  zpool export offsite-backup
  echo "Offsite backup ready for swap"
fi

#!/bin/bash
# /usr/local/bin/sync-google-to-zfs.sh

# Prendre snapshot AVANT sync (safety net)
zfs snapshot storage/backups/google-drive@pre-sync-$(date +%Y%m%d-%H%M)

# Sync Google Drive
rclone sync gdrive:/ /storage/backups/google-drive/ \
  --backup-dir /storage/backups/gdrive-versions/$(date +%Y%m%d) \
  --drive-skip-gdocs \
  --fast-list

# Snapshot APRÈS sync (point de restore)
zfs snapshot storage/backups/google-drive@post-sync-$(date +%Y%m%d-%H%M)

# Si problème détecté, rollback facile:
# zfs rollback storage/backups/google-drive@pre-sync-20260125-0400

# Utiliser vos 2x Samsung EVO 250GB pour apprendre

# 1. Créer pool mirror test
zpool create testpool mirror /dev/sda /dev/sdb

# 2. Créer datasets
zfs create testpool/docker
zfs create testpool/test-data

# 3. Pratiquer opérations
# - Snapshots
zfs snapshot testpool/docker@test1
# - Clones
zfs clone testpool/docker@test1 testpool/docker-clone
# - Send/receive
zfs send testpool/docker@test1 | zfs receive testpool/docker-backup
# - Scrub
zpool scrub testpool
# - Replace disk (simulation)
zpool offline testpool /dev/sda
# ... remplacer physiquement ...
zpool replace testpool /dev/sda /dev/sdc

# 4. Monitorer
zpool status
zfs list
zpool iostat -v 1

# 5. Apprendre recovery
# Simuler corruption, pratiquer import/export

# Temps apprentissage: 2-4 semaines en parallèle Phase 1

# In Proxmox LXC config (/etc/pve/lxc/XXX.conf)
lxc.cgroup2.devices.allow: c 195:* rwm
lxc.cgroup2.devices.allow: c 509:* rwm
lxc.mount.entry: /dev/nvidia0 dev/nvidia0 none bind,create=file
lxc.mount.entry: /dev/nvidiactl dev/nvidiactl none bind,create=file

# Verify IOMMU enabled
dmesg | grep -e DMAR -e IOMMU

# Check IOMMU groups
for d in /sys/kernel/iommu_groups/*/devices/*; do
  n=${d#*/iommu_groups/*}; n=${n%%/*}
  printf 'IOMMU Group %s ' "$n"
  lspci -nns "${d##*/}"
done

# On server (Proxmox host or Ubuntu)
curl -fsSL https://tailscale.com/install.sh | sh
tailscale up

# On phone/laptop/tablet
# Install Tailscale app from app store
# Login with same account

# Access Jellyfin: http://100.x.x.x:8096

# Server
apt install wireguard
wg genkey | tee privatekey | wg pubkey > publickey

# Create /etc/wireguard/wg0.conf
[Interface]
Address = 10.0.0.1/24
ListenPort = 51820
PrivateKey = <server-private-key>

[Peer]
PublicKey = <client-public-key>
AllowedIPs = 10.0.0.2/32

cloudflared tunnel create homeserver
cloudflared tunnel route dns homeserver umami.yourdomain.com

# Create single-disk pool
zpool create tank /dev/sdb
zfs set compression=lz4 tank
zfs set atime=off tank

# Current: single-disk pool
zpool status
  pool: tank
    state: ONLINE
    config:
        NAME        STATE
        tank        ONLINE
          sdb       ONLINE

# Add second 4TB as mirror (converts to mirror)
zpool attach tank sdb sdc

# Resilver begins automatically
zpool status
  pool: tank
    state: ONLINE
    scan: resilvering (1.2TB scanned, 35% complete)

# Step 1: Replace first disk
zpool offline tank sdb          # Mark old disk offline
# Physically swap 4TB → 8TB
zpool replace tank sdb sdc      # Tell ZFS about new disk
# Resilver: 4-8 hours for 3TB data

# Step 2: After resilver completes, replace second disk
zpool offline tank sde          # Mark old disk offline
# Physically swap 4TB → 8TB
zpool replace tank sde sdf      # Replace second disk
# Resilver: 4-8 hours again

# Step 3: Expand pool to use new space
zpool set autoexpand=on tank
zpool online -e tank sdc
zpool online -e tank sdf
# Pool now shows 8TB usable

# Create new 2x8TB pool
zpool create tank2 mirror sdc sdd
zfs set compression=lz4 tank2

# Snapshot old pool
zfs snapshot -r tank@migrate

# Send to new pool (single-threaded, slow)
zfs send -R tank@migrate | zfs receive tank2

# OR use mbuffer for speed
zfs send -R tank@migrate | mbuffer -m 1G | zfs receive tank2

# Verify data, then destroy old pool
zpool destroy tank
zpool export tank2
zpool import tank2 tank  # Rename to original

# WRONG: Adding single disk as new vdev
zpool add tank sdc              # Creates striped pool

# 1. Check current pool
zpool status tank
zpool list tank

# 2. Verify new disk is clean
lsblk | grep sdc
wipefs -a /dev/sdc              # Erase old filesystem signatures

# 3. Attach to create mirror
zpool attach tank sdb sdc       # sdb=existing, sdc=new

# 4. Monitor resilver
watch -n 30 'zpool status tank'

# Output during resilver:
#   scan: resilver in progress since Thu Jan 23 14:22:13 2026
#         1.2TB scanned at 150MB/s, 850GB issued at 140MB/s
#         850GB resilvered, 35.42% done, 01:23:45 to go

# Increase resilver priority (use during night)
echo 10000 > /sys/module/zfs/parameters/zfs_resilver_min_time_ms

# Limit resilver I/O (use during day)
echo 50 > /sys/module/zfs/parameters/zfs_resilver_delay

# Check mirror is healthy
zpool status tank
#   mirror-0    ONLINE
#     sdb       ONLINE
#     sdc       ONLINE

# Run scrub to verify all data
zpool scrub tank

# Check for errors
zpool status -v tank

#!/bin/bash
# migrate-to-8tb.sh

set -e  # Exit on error

echo "ZFS Mirror Upgrade: 2x4TB → 2x8TB"
echo "Current pool status:"
zpool status tank

echo -e "\n[STEP 1] Replace first 4TB with 8TB"
echo "Physically remove sdb, insert new 8TB as sdc"
read -p "Press enter when disk is swapped..."

zpool replace tank sdb sdc
echo "Resilver started. Monitor with: watch -n 30 'zpool status tank'"

# Wait for resilver to complete
while zpool status tank | grep -q "resilver"; do
    sleep 300  # Check every 5 minutes
done

echo -e "\n[STEP 2] First resilver complete! Waiting 24h before second disk..."
echo "Run this script again tomorrow to replace second disk."

# Optional: Run scrub for safety
read -p "Run scrub before second replacement? (y/n): " -n 1 -r
if [[ $REPLY =~ ^[Yy]$ ]]; then
    zpool scrub tank
fi

# Default behavior (no limits)
# ARC will consume up to 50% of RAM
32GB RAM → 16GB ARC maximum

# Check current ARC usage
arc_summary | grep "ARC size"
# Output: Current size: 14.2 GiB  (Target: 16.0 GiB)

# Edit /etc/default/grub
GRUB_CMDLINE_LINUX="zfs.zfs_arc_max=8589934592"  # 8GB in bytes

# Update grub
update-grub
reboot

# Create /etc/modprobe.d/zfs.conf
echo "options zfs zfs_arc_max=8589934592" > /etc/modprobe.d/zfs.conf

# Reload ZFS module
rmmod zfs
modprobe zfs

# Set 8GB limit immediately
echo 8589934592 > /sys/module/zfs/parameters/zfs_arc_max

# Verify
arc_summary | head -20

# Recommended: 8GB ARC
options zfs zfs_arc_max=8589934592    # 8GB
options zfs zfs_arc_min=2147483648    # 2GB minimum

# Conservative: 6GB ARC (if running many VMs)
options zfs zfs_arc_max=6442450944    # 6GB

# Test 1: Large file read (Jellyfin movie)
time cat /tank/media/movie.mkv > /dev/null
# 8GB ARC: 42.3s
# 16GB ARC: 42.1s
# Difference: 0.5% (within margin of error)

# Test 2: Metadata operations (directory listing)
time find /tank/media -type f | wc -l
# 8GB ARC: 2.1s
# 16GB ARC: 1.8s
# Difference: 14% (ARC caches metadata)

# Test 3: Random small files (Docker layers)
time tar -czf /dev/null /var/lib/docker
# 8GB ARC: 18.3s
# 16GB ARC: 12.7s
# Difference: 30% (high cache hit rate)

# /etc/modprobe.d/zfs.conf

# ARC Memory Limits
options zfs zfs_arc_max=8589934592          # 8GB max
options zfs zfs_arc_min=2147483648          # 2GB min (prevents thrashing)

# ARC Metadata Preference (benefit metadata caching)
options zfs zfs_arc_meta_limit=4294967296   # 4GB for metadata (50% of ARC)

# Prefetch (disable for media server, enable for databases)
options zfs zfs_prefetch_disable=1          # Disable (Jellyfin = sequential reads)

# Commit Behavior (writeback cache)
options zfs zfs_txg_timeout=5               # Flush every 5s (default 5)

# Async Write Performance
options zfs zfs_vdev_async_write_active_min_dirty_percent=20
options zfs zfs_vdev_async_write_active_max_dirty_percent=60

# Scrub/Resilver Speed (balance performance vs speed)
options zfs zfs_resilver_delay=2            # Lower = faster resilver, higher I/O impact
options zfs zfs_scrub_delay=4               # Higher = slower scrub, less I/O impact

# L2ARC (if using SSD cache - you have 2x250GB SSDs)
options zfs l2arc_write_max=16777216        # 16MB/s write to L2ARC
options zfs l2arc_headroom=2                # Prefetch 2x data for L2ARC

# Update initramfs
update-initramfs -u -k all

# Reboot required
reboot

# Verify settings after reboot
cat /sys/module/zfs/parameters/zfs_arc_max
# Should show: 8589934592

# Add 250GB SSD as L2ARC (read cache)
zpool add tank cache /dev/nvme0n1

# Check cache effectiveness
zpool iostat -v tank 5

# L2ARC hit rate
arc_summary | grep "L2ARC"

# Manual snapshot
zfs snapshot tank/media@backup-2026-01-23

# Automated with Sanoid (best practice)
apt install sanoid
cat > /etc/sanoid/sanoid.conf << 'EOF'
[tank/media]
    use_template = production
    recursive = yes

[template_production]
    frequently = 0
    hourly = 24
    daily = 7
    monthly = 3
    yearly = 0
    autosnap = yes
    autoprune = yes
EOF

# Enable Sanoid
systemctl enable --now sanoid.timer

# List snapshots
zfs list -t snapshot tank/media

# Rollback (DESTRUCTIVE - deletes newer data)
zfs rollback tank/media@backup-2026-01-23

# Restore single file (NON-DESTRUCTIVE)
cp /tank/media/.zfs/snapshot/backup-2026-01-23/movie.mkv /tank/media/

# Initial snapshot: 0 bytes
zfs create tank/test
dd if=/dev/zero of=/tank/test/file bs=1M count=1000  # 1GB file
zfs snapshot tank/test@snap1
zfs list -t all

# Output:
# NAME              USED  AVAIL  REFER
# tank/test         1.0G  100G   1.0G
# tank/test@snap1      0     -   1.0G   ← Snapshot takes 0 space

# Modify 20% of file
dd if=/dev/urandom of=/tank/test/file bs=1M count=200 conv=notrunc

zfs list -t all
# tank/test         1.2G  100G   1.0G
# tank/test@snap1    200M    -   1.0G   ← Snapshot now stores 200MB (changed blocks)

# 1. Take ZFS snapshot before rclone sync
zfs snapshot tank/google-drive@pre-sync-$(date +%Y%m%d-%H%M)

# 2. Run rclone sync
rclone sync /tank/google-drive remote:GoogleDrive \
    --transfers 4 \
    --checkers 8 \
    --buffer-size 16M

# 3. If sync corrupted data, rollback
zfs rollback tank/google-drive@pre-sync-20260123-1430

# 4. Automated script
cat > /usr/local/bin/zfs-rclone-sync.sh << 'EOF'
#!/bin/bash
DATASET="tank/google-drive"
SNAPSHOT="${DATASET}@rclone-$(date +%Y%m%d-%H%M)"

# Snapshot before sync
zfs snapshot "$SNAPSHOT"

# Sync to cloud
rclone sync /${DATASET} remote:GoogleDrive \
    --log-file=/var/log/rclone-sync.log \
    --log-level INFO

# Keep last 7 snapshots
zfs list -t snapshot -o name | grep rclone | sort | head -n -7 | xargs -r -n1 zfs destroy
EOF

chmod +x /usr/local/bin/zfs-rclone-sync.sh

# Install
apt install sanoid

# Config: /etc/sanoid/sanoid.conf
[tank/media]
    use_template = media
    recursive = yes

[tank/docker]
    use_template = production
    recursive = yes

[template_media]
    frequently = 0
    hourly = 0
    daily = 7        # Keep 7 daily snapshots
    weekly = 0
    monthly = 3      # Keep 3 monthly snapshots
    yearly = 0
    autosnap = yes
    autoprune = yes

[template_production]
    frequently = 4   # Every 15 minutes
    hourly = 24
    daily = 7
    weekly = 4
    monthly = 3
    yearly = 0
    autosnap = yes
    autoprune = yes

#!/bin/bash
# /usr/local/bin/zfs-auto-snapshot.sh

DATASET="tank/media"
SNAPNAME="${DATASET}@auto-$(date +%Y%m%d-%H%M)"
KEEP_DAYS=7

# Create snapshot
zfs snapshot "$SNAPNAME"

# Prune old snapshots (keep last 7 days)
zfs list -t snapshot -o name,creation -s creation | \
    grep "${DATASET}@auto-" | \
    head -n -$((KEEP_DAYS)) | \
    awk '{print $1}' | \
    xargs -r -n1 zfs destroy

# Cron: Daily at 2 AM
# 0 2 * * * /usr/local/bin/zfs-auto-snapshot.sh >> /var/log/zfs-snapshot.log 2>&1

# Global pool setting (recommended)
zfs set compression=lz4 tank

# Per-dataset (granular control)
zfs set compression=lz4 tank/docker       # High benefit
zfs set compression=off tank/media        # No benefit (already compressed)

# Check compression ratio
zfs get compressratio tank
# Output: compressratio  1.42x  -

# Every block has sha256 checksum
# Write: Calculate checksum → Store with data
# Read:  Read data → Verify checksum → Return data OR error

# Check for corruption
zpool scrub tank

# Results
zpool status -v tank
# Output:
#   scan: scrub repaired 0B in 08:32:11 with 0 errors
#   errors: No known data errors

# If corruption found (with mirror)
#   scan: scrub repaired 4.2MB in 08:45:03 with 12 errors
#   errors: Permanent errors detected, <12> files affected

# Initial full backup
zfs snapshot tank/media@backup-2026-01-23
zfs send tank/media@backup-2026-01-23 | pv | zfs receive usbdrive/backup

# Incremental backup (week later)
zfs snapshot tank/media@backup-2026-01-30
zfs send -i tank/media@backup-2026-01-23 tank/media@backup-2026-01-30 | pv | zfs receive usbdrive/backup

# Size comparison
# Full backup: 3TB (entire dataset)
# Incremental: 50GB (only changes in 1 week)

#!/bin/bash
# /usr/local/bin/zfs-backup-to-usb.sh

DATASET="tank/media"
USB_POOL="usbdrive"
SNAPSHOT_NAME="backup-$(date +%Y%m%d)"

# Check if USB drive is connected
if ! zpool list "$USB_POOL" >/dev/null 2>&1; then
    echo "Error: USB drive not connected"
    exit 1
fi

# Create new snapshot
zfs snapshot "${DATASET}@${SNAPSHOT_NAME}"

# Find last backup snapshot
LAST_SNAP=$(zfs list -t snapshot -o name -s creation | grep "${DATASET}@backup-" | tail -n 2 | head -n 1)

if [ -n "$LAST_SNAP" ]; then
    # Incremental send
    echo "Incremental backup from $LAST_SNAP"
    zfs send -i "$LAST_SNAP" "${DATASET}@${SNAPSHOT_NAME}" | \
        pv | \
        zfs receive "${USB_POOL}/backup"
else
    # Full send (first backup)
    echo "Full backup"
    zfs send "${DATASET}@${SNAPSHOT_NAME}" | \
        pv | \
        zfs receive "${USB_POOL}/backup"
fi

# Sync to disk
zpool export "$USB_POOL"
echo "Backup complete. USB drive can be removed."

# Enable dedup (DON'T DO THIS)
zfs set dedup=on tank

# RAM requirements
# Dedup table: ~320 bytes per block
# 4KB blocks: 1TB data = 262M blocks × 320 bytes = 84GB RAM needed
# Your 32GB RAM: Dedup table goes to disk → DEATH SPIRAL

# Block cloning (OpenZFS 2.2+, 2026 feature)
# Fast reflinks for duplicates, no dedup table
zfs set block_cloning=enabled tank

# Automatic for cp --reflink, docker layers
# Zero cost, moderate benefit

zpool status tank
  pool: tank
    state: DEGRADED
    config:
        mirror-0    DEGRADED
          sdb       ONLINE
          sdc       UNAVAIL   # ← Failed disk

# Start scrub
zpool scrub tank

# Monitor
zpool status
  scan: scrub in progress since Thu Jan 23 10:00:00 2026
        1.2TB scanned out of 3.8TB at 120MB/s
        0B repaired, 31.58% done, 06:12:34 to go

# Default: Low priority (nice to other I/O)
cat /sys/module/zfs/parameters/zfs_scrub_delay
# Output: 4 (milliseconds between I/Os)

# Slower scrub, less impact (run during day)
echo 10 > /sys/module/zfs/parameters/zfs_scrub_delay

# Faster scrub, more impact (run at night)
echo 1 > /sys/module/zfs/parameters/zfs_scrub_delay

# Monthly scrub (recommended minimum)
# Cron: First Sunday of month at 2 AM
0 2 1-7 * 0 [ "$(date +\%u)" = 7 ] && /sbin/zpool scrub tank

# Weekly scrub (paranoid, acceptable)
# Cron: Every Sunday at 2 AM
0 2 * * 0 /sbin/zpool scrub tank