Implémentation Stockage Personnel — ZFS + SFTPGo¶

Date : 2026
Solution retenue : ZFS (IronWolf 4TB) + Sanoid + SFTPGo v2.7.1+ + ZfDash
Évaluation complète : storage-solution-evaluation.md

1. Architecture Cible¶

Structure de stockage¶

IronWolf 4TB (sdd) — pool ZFS "storage"

storage/              (dataset racine)
├── alice/            ← dataset ZFS, espace alice
│   ├── drive/        ← rclone PULL drive Google alice
│   ├── photos/       ← Takeout alice
│   └── archives/     ← archives personnelles alice
├── nico/             ← dataset ZFS, espace nico (admin)
│   ├── drive/        ← rclone PULL drive Google nico
│   ├── photos/       ← Takeout nico
│   └── archives/     ← archives personnelles nico
├── family/           ← dataset ZFS, espace commun alice+nico
│   ├── drive/        ← rclone PULL dossier Drive partagé
│   └── archives/     ← archives communes
├── shared/           ← dataset ZFS, optionnel — contenu pour guests
└── others/           ← inboxes guests (optionnel)
    └── {username}/

Sanoid (host Proxmox) → snapshots auto daily×7 / weekly×4 / monthly×3

Composants et rôles¶

2. Utilisateurs et Groupes SFTPGo¶

Comptes¶

nico est le compte admin SFTPGo. Il dispose simultanément d'un compte utilisateur ordinaire (espace personnel, accès family) et du rôle administrateur (gestion des users, groupes, virtual folders via web UI).

Groupes¶

Vue utilisateur dans SFTPGo¶

alice :

/                    ← home = /storage/alice/
  drive/
  photos/
  archives/
  family/            ← virtual folder → /storage/family/  [rw]
  .snapshots/        ← virtual folder → /storage/.zfs/snapshot/  [ro]

nico (compte utilisateur) :

/                    ← home = /storage/nico/
  drive/
  photos/
  archives/
  family/            ← virtual folder → /storage/family/  [rw]
  .snapshots/        ← virtual folder → /storage/.zfs/snapshot/  [ro]

nico (vue admin via interface admin SFTPGo) : accès à tous les datasets, utilisateurs, groupes et virtual folders.

Autres utilisateurs (guests)¶

Les autres utilisateurs ont un compte Authelia mais pas de sync Drive/Photos côté serveur. Deux options :

3. Plan d'Implémentation¶

Phase 1 — Conversion ZFS (IronWolf sdd)¶

Prérequis : sauvegarder /mnt/storage/ — seulement 1.1 GB, trivial.
Risque : faible, peu de données existantes.

# 1. Backup du contenu actuel
rsync -avP /mnt/storage/ /tmp/storage-backup/

# 2. Démonter et recréer en ZFS
umount /mnt/storage
# (supprimer la ligne sdd dans /etc/fstab si présente)

zpool create -o ashift=12 storage /dev/sdd
zfs set compression=zstd storage
zfs set mountpoint=/mnt/storage storage

# 3. Créer les datasets
zfs create storage/alice
zfs create storage/nico
zfs create storage/family
zfs create storage/shared   # optionnel — guests
zfs create storage/others   # optionnel — inboxes guests

# 4. Restaurer le contenu antérieur
rsync -avP /tmp/storage-backup/archives/ /mnt/storage/family/archives/
# (ou storage/alice/archives/ selon l'appartenance)

Sanoid — configuration snapshots¶

Installer Sanoid sur le host Proxmox puis configurer /etc/sanoid/sanoid.conf :

[storage/alice]
  use_template = personal

[storage/nico]
  use_template = personal

[storage/family]
  use_template = personal

[storage/shared]
  use_template = personal

[template_personal]
  frequently = 0
  hourly = 0
  daily = 7
  weekly = 4
  monthly = 3
  autosnap = yes
  autoprune = yes

Phase 2 — rclone PULL (Host Proxmox)¶

Prérequis : rclone v1.73.3 déjà installé sur host, remote gdrive: existant (compte nico).
Risque : nul — read-only depuis Google Drive.

Remote existant et dual-role de gdrive-nico:¶

Le compte nico sert en même temps de cible backup (gdrive-nico:backup/homeserver/ — PUSH) et de source Drive personnel (PULL). Pas de conflit : les paths sont disjoints. Seule précaution : exclure backup/ du job PULL pour éviter de syncer les archives serveur localement.

Renommer le remote existant gdrive: → gdrive-nico: et mettre à jour les scripts backup :

# Renommer la section dans rclone.conf
sed -i 's/^\[gdrive\]$/[gdrive-nico]/' /root/.config/rclone/rclone.conf

# Mettre à jour les scripts backup existants
sed -i 's/gdrive:/gdrive-nico:/g' /usr/local/bin/backup-docker-configs.sh
sed -i 's/gdrive:/gdrive-nico:/g' /usr/local/bin/backup-proxmox-host.sh

# Créer le remote alice (OAuth interactif — navigateur requis)
rclone config  # → créer "gdrive-alice" (OAuth compte alice)

LXC 102 conserve son rclone et son cron PBS→GDrive sans modification. Une consolidation ultérieure (copier le script + cron vers le host) est triviale mais hors périmètre.

Script /usr/local/bin/pull-gdrive.sh¶

#!/bin/bash
set -e

LOG_DIR=/var/log

# Drive personnel alice
rclone sync gdrive-alice:/ /mnt/storage/alice/drive/ \
  --exclude="**/.Trash/**" \
  --backup-dir=/mnt/storage/alice/.deleted/$(date +%Y%m) \
  --log-file=${LOG_DIR}/rclone-pull-alice.log \
  --log-level INFO

# Drive personnel nico
# --exclude "backup/**" : gdrive-nico: est aussi la cible des backups serveur
rclone sync gdrive-nico:/ /mnt/storage/nico/drive/ \
  --exclude="**/.Trash/**" \
  --exclude="backup/**" \
  --backup-dir=/mnt/storage/nico/.deleted/$(date +%Y%m) \
  --log-file=${LOG_DIR}/rclone-pull-nico.log \
  --log-level INFO

# Dossier Drive partagé (depuis le compte propriétaire du dossier)
rclone sync gdrive-alice:Dossier-Partage/ /mnt/storage/family/drive/ \
  --log-file=${LOG_DIR}/rclone-pull-family.log \
  --log-level INFO

Cron sur host (/etc/cron.d/pull-gdrive) :

0 3 * * * root /usr/local/bin/pull-gdrive.sh

Le compte propriétaire du dossier Drive partagé (alice) suffit pour les trois jobs. L'OAuth nico n'est nécessaire que pour son Drive personnel.

Phase 3 — Déploiement SFTPGo (LXC 106 dédié)¶

⚠️ Version minimale : v2.7.1 — fix CVE-2026-30914 (path traversal virtual folders, 2026-03-13).

LXC 106 dédié plutôt que LXC 104 : isolation du blast radius, et surtout nécessité d'un custom idmap UID 1000 pour que SFTPGo Docker lise les fichiers créés par rclone sur le host (UID 1000). Modifier l'idmap de LXC 104 briserait les services existants (Endurain, FreshRSS, Romm).

Étape 0 — Créer LXC 106 avec custom idmap¶

# Sur host — autoriser le mapping UID/GID 1000 pour root
echo "root:1000:1" >> /etc/subuid
echo "root:1000:1" >> /etc/subgid

# Créer user "storage" UID 1000 sur le host (propriétaire de /mnt/storage)
useradd -u 1000 -M -s /usr/sbin/nologin storage
chown -R 1000:1000 /mnt/storage/

# Créer le LXC 106
pct create 106 local:vztmpl/debian-12-standard_12.x-1_amd64.tar.zst \
  --hostname storage \
  --memory 512 \
  --cores 2 \
  --net0 name=eth0,bridge=vmbr0,ip=192.168.1.106/24,gw=192.168.1.254 \
  --rootfs local-zfs:8 \
  --unprivileged 1 \
  --features nesting=1 \
  --onboot 1

Dans /etc/pve/lxc/106.conf :

mp0: /mnt/lxc-data/106-storage,mp=/opt/docker
mp1: /mnt/storage,mp=/mnt/storage
lxc.idmap: u 0 100000 1000
lxc.idmap: u 1000 1000 1
lxc.idmap: u 1001 101001 64535
lxc.idmap: g 0 100000 1000
lxc.idmap: g 1000 1000 1
lxc.idmap: g 1001 101001 64535

Optionnel : ajouter mp2: /mnt/media,mp=/mnt/media si l'admin nico doit accéder à /mnt/media/ via SFTPGo.

Étape 1 — Portainer agent¶

Démarrer LXC 106, installer Docker, puis créer mkdir -p /mnt/lxc-data/106-storage sur le host. Déployer le portainer-agent standard et ajouter LXC 106 comme nouvel environnement dans Portainer (192.168.1.106:9001).

Étape 2 — Stack SFTPGo (Portainer)¶

Créer une stack "sftpgo" dans Portainer (environnement LXC 106) :

services:
  sftpgo:
    image: drakkan/sftpgo:v2.7.1
    container_name: sftpgo
    restart: unless-stopped
    user: "1000:1000"
    ports:
      - "2022:2022"   # SFTP
      - "8090:8090"   # WebDAV + web client
      - "8080:8080"   # Interface admin (restreindre à VPN/LAN)
    volumes:
      - /mnt/storage:/storage:rw
      - /mnt/media:/media:ro
      - ./sftpgo/data:/var/lib/sftpgo
      - ./sftpgo/config:/etc/sftpgo
    environment:
      - SFTPGO_HTTPD__BINDINGS__0__PORT=8090
      - SFTPGO_HTTPD__BINDINGS__1__PORT=8080
      - SFTPGO_HTTPD__BINDINGS__1__ENABLE_WEB_ADMIN=true

Configuration OIDC (Authelia)¶

Dans sftpgo.json (ou variables d'env) :

{
  "oidc": {
    "client_id": "sftpgo",
    "client_secret": "...",
    "config_url": "https://auth.example.com/.well-known/openid-configuration",
    "redirect_base_url": "https://files.example.com",
    "username_field": "preferred_username"
  }
}

Configuration des groupes et utilisateurs (web UI admin)¶

Ordre de création important :

1. Créer virtual folders (onglet "Folders" dans l'admin) :
2. family → /storage/family [rw]
3. snapshots → /storage/.zfs/snapshot [ro]
4. shared → /storage/shared [ro] (optionnel)

5. media → /media [ro]

6. Créer groupe primaire owners :

7. home_dir = /storage/%username%

8. Créer groupe secondaire owners-shared :

9. Virtual folder family/ → folder family [rw]

10. Virtual folder .snapshots/ → folder snapshots [ro]

11. Créer groupe secondaire guests (optionnel) :

12. Virtual folder shared/ → folder shared [ro]

13. Créer utilisatrice alice :

14. Groupe primaire : owners
15. Groupe secondaire : owners-shared

16. Auth : OIDC (Authelia)

17. Créer utilisateur nico :

18. Groupe primaire : owners
19. Groupe secondaire : owners-shared
20. Auth : OIDC (Authelia)

21. Cocher "admin" → nico devient administrateur SFTPGo

22. Pour guests (optionnel) : créer le compte, groupe secondaire guests.

Configuration nginx (LXC 103)¶

# Web client SFTPGo (HTTPS public, accès via Authelia)
server {
  server_name files.example.com;
  location / {
    proxy_pass http://192.168.1.106:8090;
    # middleware Authelia
  }
}

# Interface admin (VPN/LAN only)
server {
  server_name sftpgo-admin.internal;
  allow 10.0.0.0/8;
  deny all;
  location / {
    proxy_pass http://192.168.1.106:8080;
  }
}

Phase 4 — ZfDash (admin ZFS)¶

ZfDash est un outil de visualisation ZFS — sa place est dans LXC 101 (management) avec Homepage, Portainer, Uptime-Kuma et CoolerControl, et non dans LXC 106 dont le rôle est l'accès aux fichiers. Les deux LXC nécessitent le même passthrough /dev/zfs; LXC 101 offre en plus le backup PBS et le cycle de maintenance déjà établis pour les outils admin.

Pré-requis — passer /dev/zfs dans LXC 101¶

Ajouter dans /etc/pve/lxc/101.conf puis redémarrer LXC 101 :

lxc.mount.entry: /dev/zfs dev/zfs none bind,optional,create=file

Stack Portainer (LXC 101)¶

Créer une stack "zfdash" dans Portainer (environnement LXC 101) :

services:
  zfdash:
    image: ghcr.io/j0sh-park/zfdash:latest
    container_name: zfdash
    restart: unless-stopped
    ports:
      - "8091:8080"
    privileged: true
    volumes:
      - /dev:/dev

Exposer uniquement sur VPN/réseau local — pas de nginx public pour cet outil d'administration.

Phase 5 — Backup Photos (Takeout)¶

1. Déclencher export Google Takeout (alice + nico séparément) → format .tgz
2. Télécharger les archives sur /mnt/storage/alice/ et /mnt/storage/nico/
3. Extraire avec immich-go pour dédupliquer et organiser dans photos/ :

   immich-go upload --target-dir /mnt/storage/alice/photos/ takeout-alice.tgz
   immich-go upload --target-dir /mnt/storage/nico/photos/  takeout-nico.tgz
   

4. Planifier rappel Takeout tous les 3 mois (Google limite à ~100 exports/an)

Phase 6 — Migration Archives (HGST externe)¶

1. Brancher le disque externe HGST Touro (~1TB) sur le host Proxmox
2. Monter et migrer :

   mount /dev/sdX1 /mnt/hgst-ext
   rsync -avP /mnt/hgst-ext/alice/ /mnt/storage/alice/archives/
   rsync -avP /mnt/hgst-ext/nico/  /mnt/storage/nico/archives/
   rsync -avP /mnt/hgst-ext/common/ /mnt/storage/family/archives/
   

3. Vérifier, puis prendre un snapshot ZFS manuel :

   zfs snapshot -r storage@post-migration-$(date +%Y%m%d)
   

4. Conserver le HGST externe comme backup offline hors-site

Phase 7 — Mise à Jour Documentation¶

Suivre les guidelines CONTRIBUTING — documenter l'état final en production, pas le process d'implémentation.

4. Accès Distant¶

SFTPGo gère nativement les deux cas : l'interface web complète derrière Authelia, et les share links accessibles sans authentification (token + expiration + MdP optionnel).

5. Résumé Décisionnel¶