Costruire un NAS RAIDZ1 su Debian 13 con OpenZFS: dataset, compressione e le bugie che mi ha raccontato dd

🌐 Anche in: English · Deutsch · Français · Español · Português · Nederlands · Polski
⚠️ Alcuni comandi in questo post creano pool ZFS oppure cancellano e sovrascrivono dati. Fai prima un backup, provali su un sistema di test e adatta nomi dei dispositivi e percorsi al tuo ambiente.
🪟➡️🐧 Contesto: mandare in pensione la macchina Windows
Un po’ di antefatto, perché “come mai questa Debian qualsiasi ha improvvisamente tre dischi e opinioni forti sulla compressione” merita una risposta. Fino a poco tempo fa, qui un Windows Server si occupava sia di Active Directory sia di file server/NAS — e diamo a Cesare quel che è di Cesare, faceva il suo lavoro benissimo. I login funzionavano, le share funzionavano, nessuno si lamentava, niente andava a fuoco. Ma ogni volta che passavo da quella macchina a qualcosa dal sapore DevSecOps, sentivo l’attrito: modello mentale diverso, strumenti diversi, memoria muscolare diversa per “ok, come controllo davvero cosa sta succedendo qui”. Il server Windows esisteva solo per NAS + login AD, mentre una macchina separata continuava a fare in silenzio tutto il vero lavoro Linux — jump host, qualche compito di contorno alla CI, e ultimamente anche la cosa che sta generando questa stessa frase. Due server, due filosofie operative, e la sensazione crescente di curare un piccolo museo di “come si faceva una volta” invece di gestire un setup coerente. 🏛️ Certo, avrei potuto ricorrere a Proxmox e aggirare la decisione virtualizzando invece di prenderla davvero — tirare su un guest Windows, tenere AD per abitudine, e chiamarlo consolidamento. Ma sono arrivato al punto in cui preferisco davvero mettere tutto su Linux, su una sola macchina, e andare fino in fondo: una toolchain, una cosa da patchare, una cosa da monitorare, invece di mantenere due mondi completamente diversi per una file share e un prompt di login. Ed è proprio inseguendo questo consolidamento che sono tornato a OpenZFS — se tanto devo ricostruire da zero il ruolo di NAS su Linux, voglio che lo strato di storage sottostante sia davvero buono, non solo “abbastanza buono da far smettere Explorer di lamentarsi”. Quindi: ho reinstallato una macchina di scorta con una Debian 13 (trixie) fresca e ho deciso che era ora di smettere di trattare lo storage come un ripensamento — sai, la classica bugia “un giorno metterò in ordine i miei file” che raccontiamo tutti a noi stessi. Sono entrati tre SSD WD Red SA500 da 2TB, e l’obiettivo sulla carta era semplice: un pool ridondante, una compressione che si ripaga da sola e share per utente che non si pestano i piedi a vicenda. OpenZFS l’ha reso davvero piacevole — dopo aver superato una stranezza di packaging, un bug estetico upstream che mi ha fatto dubitare di me stesso per dieci minuti, e il mio primo, profondamente imbarazzante benchmark. Ecco il percorso completo, difetti compresi. 🐛
🤔 Perché ZFS e non NTFS o mdadm + ext4
Versione breve: volevo dati con checksum, compressione trasparente, snapshot economici e uno strato di storage che capisca il “dataset” come concetto di prima classe invece che come “directory che prometto di trattare in modo speciale, giurin giurello”. Venendo da anni di NTFS su quel Windows Server, e avendo vissuto con ext4 ovunque altrove, vale la pena spiegare davvero cosa fa ZFS di diverso invece di limitarsi ad affermare che è migliore — perché sulla carta sia NTFS che ext4 sembrano a posto. Si montano, contengono file, sono pronti per la produzione da decenni. Le differenze emergono solo quando qualcosa va storto in silenzio, che è esattamente lo scenario che nessuno dei due è costruito per intercettare.
Checksum — la vera funzionalità di punta. ZFS calcola un checksum per ogni blocco di dati e per ogni blocco di metadati, e verifica quel checksum a ogni singola lettura, non solo durante una scansione programmata ogni tanto. NTFS non ha alcun checksum sui dati — la sua funzionalità integrity streams copre solo i metadati, è opzionale ed è stata silenziosamente abbandonata in ReFS nelle versioni successive di Windows Server per tutto tranne i metadati. ext4 è sulla stessa barca: metadata_csum protegge la contabilità del filesystem stesso, ma il contenuto vero e proprio dei tuoi file è considerato affidabile a occhi chiusi. Se un bit si inverte da qualche parte sul supporto fisico — e su qualsiasi disco abbastanza grande e abbastanza vecchio, prima o poi qualche bit lo farà — NTFS ed ext4 ti consegneranno il byte corrotto con un sorriso e senza alcuna indicazione che sia successo qualcosa. Questo è il bit-rot silenzioso, e “silenzioso” è la parola chiave: nessun errore, nessuna voce nel log, nessun avviso, solo un pixel leggermente sbagliato in una foto o un byte leggermente sbagliato in un archivio di backup che nessuno nota finché non conta.
Autoriparazione, non solo rilevamento. È qui che ZFS supera persino le alternative con checksum: poiché gestisce la ridondanza (RAIDZ, mirror) e i checksum nello stesso strato, non solo può dire “questo blocco è sbagliato”, ma può ricostruire il valore corretto dalla parità e riscriverlo automaticamente — durante le letture normali, e in modo completo durante uno zpool scrub. Confrontalo con il classico stack mdadm + ext4: lo strato RAID e lo strato del filesystem non si parlano. mdadm può dirti che un intero disco è morto. Non può dirti che un blocco specifico si è guastato in silenzio mentre ogni disco riporta “sto bene” — non c’è nessun checksum da confrontare, quindi non c’è niente su cui essere in disaccordo. La corruzione si propaga semplicemente in silenzio attraverso ogni calcolo di parità come se fossero dati corretti, perché per quanto riguarda il RAID lo sono.
Nessun “resync iniziale” alla creazione, perché la parità non è un concetto separato. Chiunque abbia costruito un array mdadm RAID5/6 conosce il rituale: lo crei, poi aspetti — a volte per ore — mentre macina un resync iniziale dell’intero array, scrivendo parità coerente su ogni singolo blocco indipendentemente dal fatto che contenga dati veri o sia ancora completamente vuoto. Deve farlo: mdadm opera puramente a livello di dispositivo a blocchi, sotto il filesystem, senza alcuna visibilità su quali blocchi siano “veri” e quali spazio inutilizzato. Non può saltare niente, quindi non lo fa. zpool create sullo stesso set di tre dischi, invece, ha richiesto pochi secondi. Nessun resync, nessuna attesa, niente da recuperare — perché in ZFS la parità viene calcolata e scritta come parte della stessa scrittura atomica che deposita i dati, e lo spazio non allocato semplicemente non ha parità che possa essere incoerente. Non c’è nessuno “stato iniziale” da correggere perché non c’è mai un momento in cui dati e parità siano in disaccordo.
L’equivalente ZFS più vicino a una ricostruzione RAID è un resilver — avviato quando un disco guasto viene sostituito o uno nuovo viene aggiunto a un mirror — e anche quello eredita lo stesso vantaggio di consapevolezza del filesystem: ZFS fa il resilver solo dei blocchi effettivamente allocati, non dell’intera capacità grezza del disco. Un pool pieno al 40% deve fare il resilver solo del 40% dei dati; una ricostruzione tradizionale con mdadm macinerebbe comunque il 100% dell’array, perché non conosce la differenza. L’equivalente proattivo di un passaggio check/repair di mdadm è zpool scrub — stessa idea, stesso guadagno di efficienza: percorre e verifica (e, a differenza di uno stupido check RAID, corregge davvero) ogni blocco allocato rispetto al suo checksum, e salta tutto ciò che non è mai stato scritto.
Copy-on-write contro journaling. ext4 e NTFS sono entrambi filesystem con journaling: registrano le modifiche ai metadati prima di applicarle, quindi un crash a metà scrittura ti lascia con metadati coerenti, ma una scrittura di dati in corso può comunque lasciarti con un file scritto a metà. ZFS non sovrascrive mai i dati live sul posto — ogni scrittura va in un nuovo blocco, e il filesystem passa atomicamente al nuovo stato quando è completamente scritto. Non c’è nessuna finestra in cui un crash possa lasciare un file mezzo vecchio e mezzo nuovo; vedi o l’ultimo stato completo o il nuovo stato completo, mai un miscuglio dei due.
Snapshot davvero economici. NTFS ha Volume Shadow Copy, che funziona ma è legato a un servizio VSS separato, ha limiti pratici su quanti realisticamente ne terrai, e può diventare sensibilmente lento man mano che si accumulano modifiche. ext4 non ha niente di nativo — devi ricorrere agli snapshot LVM sotto di esso, che sono uno strato a sé con un proprio costo in prestazioni man mano che divergono dall’originale. Gli snapshot ZFS sono quasi istantanei (di nuovo copy-on-write — uno snapshot significa solo “non recuperare ancora questi blocchi”), non costano niente finché i dati non cambiano davvero, e puoi tranquillamente tenerne decine senza pensarci due volte.
La compressione come default, non come compromesso. La compressione di NTFS esiste ma è vecchia, single-thread e abbastanza lenta che attivarla su qualcosa di sensibile alle prestazioni è un errore che la maggior parte degli admin impara una volta sola. ext4 non ha alcuna compressione nativa. La compressione lz4 di ZFS, come spiegato sotto, è abbastanza veloce che lasciarla attiva è semplicemente il default corretto — non un compromesso a cui devi pensare.
Lo storage in pool come modello nativo. Ingrandire un volume NTFS o un filesystem ext4 significa combattere rispettivamente con Storage Spaces o LVM/mdadm — strumenti separati imbullonati sotto, ognuno con il proprio modello mentale e i propri modi di guastarsi. Pool e dataset ZFS sono l’astrazione nativa, non un’aggiunta: aggiungere capacità, ricavare un nuovo dataset o impostare una quota per dataset sono tutti semplici sottocomandi zpool/zfs, nessuna seconda toolchain necessaria.
| Funzionalità | NTFS | ext4 | ZFS |
|---|---|---|---|
| Checksum dei dati | No | No | Sì, ogni blocco, verificato a ogni lettura |
| Autoriparazione automatica | No | No | Sì, tramite ridondanza + checksum insieme |
| Coerenza dopo un crash | Solo metadati con journaling | Solo metadati con journaling | Copy-on-write completo, nessuna sovrascrittura sul posto |
| Snapshot | VSS (limitato, rallenta col tempo) | Nessuno nativo (serve LVM) | Nativi, quasi istantanei, economici |
| Compressione | Lenta, usata di rado | Nessuna nativa | Veloce (lz4), attiva di default |
| Storage in pool / quote | Storage Spaces (imbullonato) | LVM (imbullonato) | Nativi nel filesystem |
Niente di tutto questo rende NTFS o ext4 dei cattivi filesystem — sono maturi, ben compresi, e NTFS in particolare ha fatto girare quel Windows Server in modo impeccabile per anni. Ma “in modo impeccabile, per quanto ne sapessi” è esattamente la frase che dovrebbe renderti nervoso riguardo alla corruzione silenziosa: il punto è proprio che nessuno dei due filesystem me l’avrebbe detto se fosse successo. mdadm + LVM + ext4 possono approssimare parte dell’elenco di funzionalità di ZFS con abbastanza nastro adesivo e disciplina personale. ZFS semplicemente ce l’ha, batterie incluse, e non ti chiede di tenere insieme tre strumenti separati con la forza di volontà — né di fidarti che niente vada mai storto in silenzio proprio sull’unico asse che nessuno sorveglia.
📦 Passo 1: portare OpenZFS su Debian 13
Debian non include ZFS in main per motivi di licenza (CDDL contro GPL — la faida più lunga nella storia delle licenze software, più vecchia della maggior parte dei dischi in questo pool), quindi vive in contrib. Quel componente non è attivo di default:
# /etc/apt/sources.list — add contrib
deb http://deb.debian.org/debian trixie main contrib
deb http://deb.debian.org/debian trixie-updates main contrib
deb http://security.debian.org/debian-security trixie-security main contrib
apt-get update
apt-get install -y linux-headers-amd64 zfs-dkms zfsutils-linux
Questo installa DKMS, compila zfs.ko e spl.ko per il kernel in esecuzione (6.12.107+deb13-amd64 all’epoca) e — perché ormai la firma dei moduli per Secure Boot è una cosa reale — genera al volo una MOK (Machine Owner Key) autofirmata per firmare i moduli appena compilati. Se la tua macchina ha Secure Boot attivo dovrai registrare quella MOK al prossimo riavvio; questa non ce l’aveva, quindi non è stato un problema, ma è bene sapere che DKMS si sta forgiando in silenzio le proprie credenziali di firma in background, come un falsario molto educato e molto legale. 🔏
🏗️ Passo 2: costruire il pool
Tre dischi, RAIDZ1 (un disco di parità — la scelta giusta per tre dischi; RAIDZ2 vuole più dischi per non sprecare troppa capacità). L’unica regola che mi importa davvero qui: non puntare mai ZFS a /dev/sdX. Le lettere dei dispositivi vengono assegnate all’avvio e possono rimescolarsi dopo un aggiornamento del kernel, una modifica al BIOS, o semplicemente perché l’universo ha una giornata storta. Usa invece i percorsi stabili /dev/disk/by-id/, a meno che tu non apprezzi l’orrore specifico del tuo disco di parità che diventa in silenzio il tuo disco dati:
zpool create -o ashift=12 \
-O compression=lz4 \
-O atime=off \
-O xattr=sa \
storage raidz1 \
/dev/disk/by-id/ata-WD_Red_SA500_2.5_2TB_25273ZD00458 \
/dev/disk/by-id/ata-WD_Red_SA500_2.5_2TB_25273ZD01387 \
/dev/disk/by-id/ata-WD_Red_SA500_2.5_2TB_25273ZD02050
zpool set autotrim=on storage
zfs set relatime=on storage
ashift=12 dice a ZFS che si tratta di dispositivi con settori da 4K (gli SSD lo sono tutti, anche quando mentono nel firmware e riportano settori logici da 512 byte come se fosse ancora il 2009). Se lo sbagli alla creazione del pool non puoi correggerlo dopo senza distruggere e ricostruire il pool — è l’unica impostazione in tutta questa build davvero senza ripensamenti, quindi si merita il grassetto minaccioso. autotrim=on conta proprio perché sono SSD; senza, ti affidi a uno zpool trim manuale periodico e lasci che la write amplification salga piano piano in background come il colesterolo dello strato di storage.
Risultato finale: tre dischi da 2TB, ~5,45TB grezzi, ~3,6TB utilizzabili dopo la parità RAIDZ1. Gli ~1,85TB mancanti non sono spariti — sono il casello autostradale per “un disco può morire e ho ancora i miei dati”.
🗜️ Compressione: lz4, e perché non zstd
La compressione ZFS è trasparente, per dataset e — con lz4 — praticamente gratuita, che in termini da nerd dello storage è la cosa più vicina a un pasto gratis che ti verrà mai offerta. lz4 è stato costruito apposta per essere così veloce che attivarlo non è mai un peggioramento del throughput; ha anche un’euristica di early-abort che si arrende subito sui dati incomprimibili (video già compressi, blob cifrati) invece di provarci ostinatamente comunque e bruciare CPU per niente. zstd comprime di più ma costa più CPU per byte. Per un carico NAS generico — documenti, foto, qualche immagine di VM, repository di codice — lz4 era il default ovvio. Se questo fosse un target di backup pieno soprattutto di dump in testo semplice, avrei scelto zstd-3 e pagato volentieri la tassa sulla CPU.
Ora che sopra ci sono dati veri invece di file sintetici da benchmark, ecco cosa mi sta davvero facendo guadagnare — e nello spirito del filo conduttore di questo post, la risposta onesta è “non molto”, ed è esattamente quello che ti aspetteresti una volta che sai cosa c’è davvero memorizzato:
$ zfs get compressratio storage storage/user3 storage/user1 storage/user2 storage/nextcloud
NAME PROPERTY VALUE
storage compressratio 1.01x
storage/user3 compressratio 1.00x
storage/user1 compressratio 1.05x
storage/user2 compressratio 1.05x
storage/nextcloud compressratio 1.03x
| Dataset | Logico (non compresso) | Reale (su disco) | Rapporto |
|---|---|---|---|
| storage/user3 | 1.21T | 1.20T | 1.00x |
| storage/user1 | 15.0G | 14.3G | 1.05x |
| storage/user2 | 247G | 236G | 1.05x |
| storage/nextcloud | 385G | 375G | 1.03x |
Rapporti quasi inesistenti, e il motivo non è una configurazione sbagliata — sono i dati stessi. Questo pool contiene soprattutto foto, video, file PST di Outlook e archivi già compressi: esattamente il contenuto che l’euristica di early-abort di lz4 è progettata per riconoscere, smettendo di sprecarci CPU. Non è un fallimento della compressione, è la compressione che funziona correttamente e si toglie di mezzo. I dataset che ne beneficiano di più sono storage/user2 e storage/user1 a 1.05x — ancora modesto, ma un risparmio reale e gratuito su quella frazione di dati che è più vicina al testo (documenti, file di configurazione, l’overhead di metadati di centinaia di migliaia di piccoli file). Se questo pool ospitasse un dump di database o una montagna di file di log invece di un archivio di foto di famiglia, questa tabella sembrerebbe molto più impressionante — ed è questa la vera lezione: il rapporto di compressione ti dice tanto sui tuoi dati quanto sul tuo filesystem.
👻 Il bug estetico che mi ha fatto dubitare di me stesso
Alla creazione del pool ho impostato xattr=sa (attributi estesi memorizzati direttamente nel dnode invece che come voci di directory nascoste — più veloce, e necessario per prestazioni decenti con le ACL). Il comando è uscito con 0, nessuna lamentela, nessun dramma. Poi zfs get xattr storage riportava ostinatamente on invece di sa, ogni singola volta, come se non avesse mai sentito parlare dell’impostazione che gli avevo appena dato.
A quanto pare è un bug di visualizzazione noto e confermato in OpenZFS 2.3.2 (vedi openzfs/zfs discussion #16996 se vuoi i dettagli cruenti) — la proprietà è in realtà impostata correttamente, zfs get mostra solo l’etichetta sbagliata. Non una configurazione sbagliata, solo rumore estetico che ti farà assolutamente dubitare di te stesso al punto da rilanciare lo stesso comando cinque volte prima di pensare di cercarlo su Google. 🕵️
🧠 Tuning dell’ARC: lasciare RAM per tutto il resto
L’Adaptive Replacement Cache (ARC) di ZFS si mangerà volentieri la maggior parte della tua RAM se glielo permetti — il che è ottimo su un’appliance di storage dedicata e decisamente meno su una macchina che fa girare anche altri servizi e vorrebbe dire la sua. Lasciata senza controllo, l’ARC si comporta esattamente come un adolescente lasciato da solo con un frigorifero: dagli spazio, lo riempirà, e non ne restituirà niente di sua iniziativa. Con 31GB di RAM totale, l’ho limitata:
# /etc/modprobe.d/zfs.conf
options zfs zfs_arc_max=17179869184
options zfs zfs_arc_min=2147483648
16GiB massimo, 2GiB minimo. Applicato a caldo tramite /sys/module/zfs/parameters/zfs_arc_max per un effetto immediato, poi integrato nell’initramfs (update-initramfs -u -k all) così sopravvive a un riavvio e non torna semplicemente a saccheggiare il frigorifero.
🤥 Benchmark, ovvero: come mi sono mentito per cinque minuti
Al primo giro ho fatto quello che fa ogni principiante di ZFS e che ho subito rimpianto:
dd if=/dev/zero of=/storage/testfile bs=1M count=10000
8,7 GB/s in scrittura. 14,1 GB/s in lettura. Su tre SSD SATA. In una rete di casa. Per un attimo ho pensato di scrivere un post deciso su LinkedIn su quanto siano sottovalutati gli SSD consumer. Poi mi sono ricordato di come funziona la compressione: /dev/zero produce un flusso infinito di zeri, lz4 comprime una sequenza di zeri quasi a niente, e io avevo appena fatto il benchmark del mio compressore, non dei miei dischi. Profondamente sciocco, brevemente emozionante, in fin dei conti privo di significato — l’equivalente da storage di misurare quanto velocemente leggi un libro leggendo solo le pagine bianche. 📖💨
L’ho rifatto per bene con dati incomprimibili, perché mentire a sé stessi è divertente solo una volta:
dd if=/dev/urandom of=/storage/testfile bs=1M count=4096 # buffered write
dd if=/dev/urandom of=/storage/testfile bs=1M count=4096 oflag=direct # O_DIRECT write
dd if=/storage/testfile of=/dev/null bs=1M # buffered read
dd if=/storage/testfile of=/dev/null bs=1M iflag=direct # O_DIRECT read
L’ho rifatto per bene una seconda volta, settimane dopo, quando il pool aveva sopra dati veri e — soprattutto — quando ogni altro job sulla macchina (una migrazione da 380GB, uno spostamento tra dataset da 235GB, una ricostruzione delle ACL) era davvero finito e il load average era tornato vicino a zero. Fare un benchmark su un pool che sta ancora digerendo il lavoro di ieri misura solo la contesa, non i dischi.
| Test | Risultato |
|---|---|
| Scrittura, bufferizzata | 138 MB/s |
| Scrittura, O_DIRECT | 15,4 MB/s |
| Lettura, bufferizzata | 1,1 GB/s |
| Lettura, O_DIRECT | 931 MB/s |
Quella riga di scrittura non è un errore di battitura, e mi ha sorpreso abbastanza da ricontrollare due e tre volte che non fosse contesa dovuta a qualcos’altro prima di crederci: le scritture O_DIRECT sono risultate circa 9 volte più lente di quelle bufferizzate su questo pool, che è l’opposto dell’intuizione che la maggior parte delle persone si porta dietro da altri filesystem (“il direct I/O salta uno strato, quindi dovrebbe essere più veloce”). Su ZFS in particolare, quell’intuizione si ribalta. Il percorso bufferizzato non è solo “in cache” — è dove ZFS fa la sua vera ottimizzazione delle scritture: le scritture in arrivo vengono raggruppate in memoria e scritte sul vdev RAIDZ come parte di un transaction group, allineate e accorpate in scritture efficienti a stripe completa. O_DIRECT, per progettazione, salta esattamente quello strato di raggruppamento, quindi ogni scrittura deve andare direttamente al vdev per conto suo — il che su un array basato sulla parità può significare I/O più piccolo, meno allineato e l’overhead che ne consegue. Aggirare la cache qui non aggira nessuna vera inefficienza; aggira proprio la cosa che rendeva efficienti le scritture.
Aggiornamento (6 ottobre 2026): la maggior parte di quel divario di 9 volte alla fine non dipendeva affatto da ZFS. Il firmware del server aveva spento la cache di scrittura degli SSD stessi, quindi ogni scrittura non raggruppata doveva aspettare la memoria flash in persona (e anche i 138 MB/s bufferizzati erano bassi). La spiegazione del raggruppamento qui sotto resta vera, ma era la parte minore. La storia completa: Due cose che mancavano ai miei SSD: TRIM dopo BitLocker e una cache di scrittura che il mio server HPE aveva spento in silenzio.
I numeri di lettura hanno lo stesso asterisco di prima: questo è throughput single-thread su un singolo file, non un quadro realistico delle prestazioni aggregate del pool sotto carico concorrente, ed entrambi i valori di lettura potrebbero essere serviti in parte dall’ARC invece di arrivare al disco — l’ARC non è la stessa cosa della page cache di Linux, quindi echo 3 > /proc/sys/vm/drop_caches non fa niente per svuotarla, e il percorso di lettura O_DIRECT di OpenZFS ti consegnerà comunque volentieri i blocchi residenti nell’ARC invece di forzare una vera lettura da disco se i dati sono già lì. Prendi i numeri di un singolo run di dd come un controllo di sanità su “c’è qualcosa di palesemente rotto”, non come una scheda tecnica da mettere su una slide di vendita — e se ricordi una sola cosa di questa sezione, che sia “non dare per scontato che O_DIRECT sia il percorso veloce senza prima misurarlo sul tuo filesystem specifico”.
👨👩👧 Perché ogni utente ha il suo dataset
Il pool serve tre persone, ognuna con una share Samba. La radice della share di ciascuno è un dataset ZFS a sé (storage/user3, storage/user1, storage/user2) invece di tre semplici directory dentro un unico grande dataset. Non è un default in cui sono caduto per caso — è una scelta strutturale deliberata, e ripaga in modi con cui un albero di directory condiviso semplicemente non può competere:
- Quote.
zfs set quota=500G storage/user2limita un utente senza toccare gli altri. Una quota è una proprietà del dataset; una directory da sola non ha un concetto del genere, per quanto severamente glielo chiedi. - Snapshot indipendenti.
zfs snapshot storage/user2@before-cleanuppermette a una persona di annullare un brutto momento da “cancella tutto” senza trascinarsi dietro gli altri due dataset. - Conteggio immediato dello spazio.
zfs listlegge l’occupazione direttamente dai metadati del dataset. Niente attraversamento dell’albero, nientedu -shche macina centinaia di gigabyte di piccoli file per un minuto e mezzo mentre fissi un cursore lampeggiante mettendo in dubbio le tue scelte di carriera. - Confini di proprietà puliti. Il mountpoint di ogni dataset corrisponde 1:1 alla sua share Samba, con il proprio proprietario Unix. I permessi del filesystem e quelli della share restano allineati invece di affidarsi solo a trucchi a livello di Samba.
- Tuning per dataset. Compressione,
atime, record size — tutto sovrascrivibile per singolo dataset, se un giorno il carico di un utente richiedesse qualcosa di diverso dal default del pool. - Replica granulare.
zfs send/receivelavora per dataset. Vuoi fare il backup della share di una sola persona su un disco esterno senza toccare le altre? Una riga, non una lista di esclusioni per rsync tenuta insieme dal rimpianto.
Il prezzo di tutto questo: spostare dati tra dataset non è più gratis. 😬 mv all’interno di un singolo dataset è una pura rinomina — solo metadati, istantanea indipendentemente dalle dimensioni. mv tra dataset è un animale completamente diverso, anche se entrambi i dataset vivono nello stesso pool e sugli stessi dischi fisici: ZFS tratta ogni dataset come un filesystem a sé, quindi il kernel deve davvero copiare ogni byte nella nuova posizione e poi eliminare l’originale. L’ho reimparato nel modo divertente mentre districavo un pasticcio di cartelle annidate — un appiattimento nello stesso dataset è finito all’istante, e uno spostamento tra dataset di ~235GB è rimasto lì per buona parte di un’ora a fare, a tutti gli effetti pratici, una copia completa, mentre io fissavo un terminale senza barra di avanzamento chiedendomi se avessi rotto qualcosa. Non sei tu, ZFS, sono i confini dei dataset. Meglio saperlo prima di lanciarne uno aspettandosi la magia da tre secondi dell’ultimo.
🔑 Un admin, tre share: perché un semplice chmod non bastava
Il modello di accesso che volevo è semplice da dire ad alta voce: ognuno ha accesso completo alla propria cartella, e io in più ho accesso completo a quelle di tutti, sia sulla share Samba sia sul filesystem Linux grezzo sottostante. Semplice da dire, e poi ho provato davvero a costruirlo con il classico chmod e ho sbattuto subito contro il muro contro cui ogni sysadmin prima o poi sbatte: un file Unix ha esattamente un proprietario ed esattamente un gruppo. Tutto qui. Questo è l’intero cast. Tutti gli altri finiscono nell’unico secchio con l’etichetta “other”.
Quel modello può esprimere “il proprietario ha accesso” e “questo gruppo ha accesso” — non può esprimere “user1 ha accesso E anche user3 ha accesso, ma user2 no”, perché non c’è un secondo posto per un gruppo in cui mettere user3 senza inventare anche un gruppo condiviso, decidere chi altro potrebbe entrarci in futuro, e sperare che fra sei mesi nessuno ci aggiunga la persona sbagliata. Puoi aggirarlo aggiungendo user3 come membro secondario dei gruppi privati di user1 e user2 e impostando il bit setgid così che i nuovi file ereditino il gruppo — e per molti setup è una risposta perfettamente valida, noiosa e a basso sforzo. Qui non mi piaceva per due motivi: concede l’accesso a livello di gruppo (quindi cambia in silenzio se l’appartenenza al gruppo cambia per un motivo che non c’entra niente), e l’ereditarietà sui nuovi file dipende dal bit setgid più qualunque umask stia usando il processo che crea il file — il che funziona, ma “funziona perché tre meccanismi separati si sono allineati correttamente” non è una frase che ispira fiducia alle 2 di notte.
Le ACL POSIX risolvono il problema vero invece di aggirarlo: permettono a un file o a una directory di avere voci aggiuntive, con nome esplicito, per utenti e gruppi oltre alla classica triade owner/group/other. “Questo è di user1, e user3 in particolare ha anche rwx, punto” — nessun gruppo condiviso necessario, nessuno spettatore. Prima di tutto il supporto per le ACL va attivato per dataset (di default è spento):
zfs set acltype=posixacl storage/user1
zfs set acltype=posixacl storage/user2
Poi la concessione vera e propria, in due parti — una concessione ricorsiva per tutto ciò che esiste già, e una ACL di default così che tutto ciò che verrà creato d’ora in poi erediti automaticamente la stessa regola, senza affidarsi alla roulette dell’umask:
setfacl -R -m u:user3:rwx /storage/user1 # apply to everything that exists now
setfacl -R -d -m u:user3:rwx /storage/user1 # apply to everything created from now on
Le stesse due righe per /storage/user2. Insieme ai permessi di ciascuna cartella bloccati su 750 (solo proprietario e gruppo, niente per “other” — così user2 e user1 non possono categoricamente finire nei dati l’una dell’altro nemmeno per sbaglio), lo stato finale è esattamente l’obiettivo dichiarato: ognuno ha piena libertà nella propria cartella, io ho piena libertà in tutte e tre, e nessuno ha una porta laterale accidentale. Vale la pena ricontrollare l’effetto reale invece di fidarsi che il comando non sia stato silenziosamente un no-op:
$ getfacl /storage/user1
user::rwx
user:user3:rwx
group::r-x
mask::rwx
other::---
default:user::rwx
default:user:user3:rwx
default:group::r-x
default:mask::rwx
default:other::---
E sul lato Samba, questo lavoro sulle ACL si è rivelato meno importante del previsto — le tre share usano già force user, che fa sì che ogni connessione a una share operi come il proprietario di quella share, indipendentemente da chi si è effettivamente autenticato. Quindi il mio accesso alle share di user1 e user2 via SMB era già coperto da quella direttiva, a patto che la cartella sottostante appartenga davvero alla persona giusta — cosa che, in un divertente esercizio di archeologia autoinflitta, per un breve periodo non era vera (un residuo di una riorganizzazione precedente aveva lasciato un dataset di mia proprietà invece che del suo vero utente, concedendomi in silenzio un accesso in scrittura via SMB che non avevo previsto e negando alla legittima proprietaria della cartella i suoi diritti di default finché non me ne sono accorto e l’ho sistemato). Le ACL chiudono nello specifico l’altra falla: il semplice accesso via SSH / shell locale, che non passa affatto da force user e risponde solo ai permessi Unix grezzi.
😵 “Aspetta, ma è ancora un solo pool?” — la confusione con df
Dopo qualche settimana di utilizzo, un rapido df -h faceva sembrare che qualcosa fosse andato storto di brutto:
Filesystem Size Used Avail Use% Mounted on
storage 1.9T 256K 1.9T 1% /storage
storage/user3 3.1T 1.2T 1.9T 40% /storage/user3
storage/user1 1.9T 15G 1.9T 1% /storage/user1
storage/user2 2.1T 236G 1.9T 12% /storage/user2
Quattro valori di “Size” diversi, su un pool che dovrebbe essere un unico blocco unificato di storage che si comporta come un RAID5. Si è frammentato in silenzio in pool separati durante la notte? Ho configurato male qualcosa? 😱 No — è df che ha tecnicamente ragione nel modo meno utile possibile.
I dataset ZFS non hanno una dimensione fissa come una classica partizione RAID. La colonna “Size” di df viene calcolata per ogni mount come Used + Available, e — questa è la parte che conta davvero — Available è identico su ogni dataset, perché è lo stesso spazio libero condiviso nello stesso pool. Cambia solo “Used”, perché quello è davvero diverso per ogni persona. Lancia invece zfs list e smette di essere un mistero:
$ zfs list -r storage
NAME USED AVAIL REFER MOUNTPOINT
storage 1.67T 1.85T 160K /storage
storage/user1 14.3G 1.85T 14.3G /storage/user1
storage/user2 235G 1.85T 235G /storage/user2
storage/nextcloud 232G 1.85T 232G /storage/nextcloud
storage/user3 1.20T 1.85T 1.20T /storage/user3
Lo stesso AVAIL — 1.85T — su ogni singola riga, perché è un unico salvadanaio condiviso. La “dimensione” di 3.1T di user3 in df è solo 1.20T usati + 1.85T disponibili; l'1.9T di user1 è 14.3G + 1.85T. Niente di frammentato, niente di perso — nel momento in cui qualcuno scrive un gigabyte, quell’AVAIL condiviso scende per tutti contemporaneamente, che è esattamente il comportamento simile a RAID5 che ci si aspettava fin dall’inizio. zpool list chiude la questione una volta per tutte:
$ zpool list storage
NAME SIZE ALLOC FREE CKPOINT EXPANDSZ FRAG CAP DEDUP HEALTH
storage 5.45T 2.50T 2.95T - - 0% 45% 1.00x ONLINE
Un pool, 5.45T grezzi, un vdev RAIDZ1, tutti e tre i dischi dentro. df semplicemente non è stato costruito pensando a “più filesystem che condividono dinamicamente un unico pool di capacità” — riporta onestamente, solo che risponde a una domanda (“quanto è grande questo mount”) che qui non si applica allo stesso modo. Gli strumenti che rispondono davvero a “quanto spazio ho” sono zfs list / zpool list, non df.
📋 Cheatsheet: i comandi che uso davvero su questo pool
Metà dell’imparare ZFS sta nel rendersi conto che il sottocomando che vuoi quasi certamente esiste già, sepolto sotto un nome che col senno di poi ha perfettamente senso. Ecco il set di lavoro per questo esatto setup — pool storage, dataset storage/user3, storage/user1, storage/user2, storage/nextcloud.
Salute del pool
# Is everything online? Any read/write/checksum errors?
zpool status storage
# One-line health summary, good for a cron/monitoring check
zpool status -x
# I/O activity per vdev, refreshed every 2s
zpool iostat -v storage 2
# Manually kick a trim outside the autotrim schedule
zpool trim storage
# Integrity scrub — reads and verifies every block against its checksum
zpool scrub storage
zpool status storage # shows progress while it's running
Dataset: elenco e occupazione dello spazio
# All datasets under the pool, with usage — instant, no tree walk
zfs list -r storage
# Include snapshots in the listing
zfs list -t all -r storage
# Just one dataset
zfs list storage/user2
Compressione: quanto mi sta davvero facendo guadagnare
# The headline number: ratio of logical (pre-compression) to physical size
zfs get compressratio storage
zfs get compressratio storage/user3 storage/user1 storage/user2 storage/nextcloud
# Same thing, the manual way — logicalused is what it WOULD take uncompressed,
# used is what it actually takes on disk
zfs get logicalused,used storage
# Which compression algorithm is actually active per dataset
zfs get compression storage/user3 storage/nextcloud
Quote e riserve
# Cap a user's dataset so they can't eat the whole pool
zfs set quota=500G storage/user2
# Guarantee a dataset a minimum amount of space, even if others fill up
zfs set reservation=100G storage/nextcloud
# See what's currently set
zfs get quota,reservation -r storage
Snapshot
# Take one
zfs snapshot storage/user2@2026-09-01-before-cleanup
# List them
zfs list -t snapshot -r storage
# Roll back to one (destroys anything written after it — says so loudly for a reason)
zfs rollback storage/user2@2026-09-01-before-cleanup
# Recover a single file without a full rollback — snapshots are browsable here
ls /storage/user2/.zfs/snapshot/2026-09-01-before-cleanup/
# Done with it
zfs destroy storage/user2@2026-09-01-before-cleanup
Proprietà: get/set, la forma generale
# Everything set on a dataset, and where each value comes from
# (default / inherited / local override)
zfs get all storage/user3 | grep -v default
# Set anything per-dataset — overrides pool default for that subtree only
zfs set atime=off storage/nextcloud
zfs set recordsize=1M storage/nextcloud # bigger records suit large sequential files
ARC (la cache in RAM)
# Live stats: hit rate, size, current bounds
cat /proc/spl/kstat/zfs/arcstats | grep -E '^(size|c_max|c_min|hits|misses) '
# Or the friendlier summary, if arcstat is installed
arcstat 2
Replica
# Full send of a dataset to another pool/host, piped over SSH
zfs snapshot storage/user2@backup-2026-09-01
zfs send storage/user2@backup-2026-09-01 | ssh backup-host zfs receive backuppool/user2
# Incremental send — only what changed since the last snapshot
zfs send -i storage/user2@backup-2026-08-01 storage/user2@backup-2026-09-01 | ssh backup-host zfs receive backuppool/user2
🚑 Troubleshooting: quello che mi è servito davvero finora
La maggior parte della vita di questo pool è stata noiosa, che è esattamente il motivo per cui si usa ZFS — la noia è una funzionalità. Ma durante la costruzione sono saltate fuori alcune cose che vale la pena tenere a portata di mano per la prossima volta, archiviate qui così che il me del futuro non debba reimparare niente di tutto questo a sue spese una seconda volta. Il pool è DEGRADED o un disco risulta FAULTED
# First stop: what exactly is wrong, and with which vdev/disk
zpool status -v storage
# Confirm the disk is still physically present and matches the pool's idea of it
ls -la /dev/disk/by-id/ | grep WD_Red
# Once the disk is physically replaced, tell ZFS to resilver the new one in
zpool replace storage ata-WD_Red_SA500_2.5_2TB_OLDSERIAL ata-WD_Red_SA500_2.5_2TB_NEWSERIAL
# Watch the resilver progress
zpool status storage
# If a disk had a transient error but is actually fine (loose cable, one-off glitch),
# clear the error counters instead of replacing anything
zpool clear storage
Resilver o scrub sembrano bloccati / ci mettono un’eternità
# Check it's actually making progress, not hung
zpool status storage # look at the % done and time-remaining estimate, run twice a few minutes apart
# See if something else is hammering the pool's I/O concurrently
zpool iostat -v storage 2
# Scrub/resilver speed is throttled by design so it doesn't starve normal I/O;
# these bump the priority if you genuinely need it to finish faster
cat /sys/module/zfs/parameters/zfs_scan_vdev_limit
echo 33554432 > /sys/module/zfs/parameters/zfs_scan_vdev_limit # example: raise the per-vdev scan limit
Il dataset non si monta / “filesystem already mounted” / “dataset is busy”
# What does ZFS think is mounted where
zfs mount
# Force ZFS to (re)mount everything it thinks should be mounted
zfs mount -a
# "Device or resource busy" on unmount usually means an open file handle —
# find who's holding it
lsof +D /storage/user2
fuser -vm /storage/user2
# Last resort: force-unmount (drops any open handles, use with care)
umount -l /storage/user2
“Permission denied” spostando/scrivendo nel dataset di un altro utente
Mi è capitato direttamente spostando i file di user2 nel suo dataset come utente Unix user3 — proprietario e modalità del dataset non concedono accesso in scrittura, per progettazione, e ZFS non era interessato alle mie scuse. O fai l’operazione come root, o sistemi la proprietà dopo:
# Check who actually owns the mountpoint and what the mode is
ls -ld /storage/user2
# Do the privileged operation, then hand ownership back if root touched it
chown -R user2:user2 /storage/user2
Modulo kernel ZFS mancante dopo un aggiornamento del kernel
Visto che è compilato con DKMS (fuori dall’albero del kernel), un nuovo kernel significa che DKMS deve ricompilare zfs.ko/spl.ko per quel kernel prima che il modulo si carichi — normalmente succede in automatico come parte del postinst del pacchetto del kernel, ma è la prima cosa da controllare se un pool si rifiuta di essere importato dopo un riavvio e per un attimo sei convinto di aver perso 3,6TB di dati nel vuoto:
# Is the module actually loaded for the running kernel?
lsmod | grep zfs
# Does DKMS have a built module for this exact kernel version?
dkms status
# If not, force a rebuild against the current kernel
dkms install zfs/$(dkms status zfs | head -1 | cut -d, -f2 | tr -d ' ') -k $(uname -r)
# Then try importing again
zpool import storage
Un servizio dipendente (GitLab, un container, qualsiasi cosa) parte prima che il pool sia montato Sintomo: il servizio parte bene ma scrive in una directory vuota sul filesystem di root invece che nei veri dati su ZFS, perché il suo mountpoint all’avvio non era ancora pronto — in silenzio, senza errori, che è il peggior tipo di bug. Controlla l’ordinamento reale di systemd invece di dare per scontato che vada bene:
# Does local-fs.target really wait for this dataset's mount unit?
systemctl show local-fs.target -p After | tr ' ' '\n' | grep storage
# Is the mount unit itself enabled and correctly ordered before local-fs.target?
systemctl show storage-user2.mount -p Before,After,WantedBy
# And does the dependent service start late enough (after multi-user.target,
# which itself sits after local-fs.target)?
systemctl show gitlab-runsvdir.service -p After
Lo spazio libero è “sparito” e du non lo spiega
# Snapshots hold on to space for blocks that changed since they were taken —
# a forgotten snapshot is the single most common cause of "where did my space go"
zfs list -t snapshot -r storage -o name,used,creation
# See exactly how much of a dataset's usage is snapshots vs. live data
zfs get usedbydataset,usedbysnapshots storage/user2
L’ARC si mangia tutta la RAM
# Confirm it's actually ARC and not something else
free -h
cat /proc/spl/kstat/zfs/arcstats | grep '^size '
# Confirm the cap is actually applied (compare against zfs_arc_max in modprobe.d)
cat /sys/module/zfs/parameters/zfs_arc_max
# If the modprobe.d change hasn't taken effect yet, push it live without a reboot
echo 17179869184 > /sys/module/zfs/parameters/zfs_arc_max
🏁 Layout finale
$ zpool status storage
pool: storage
state: ONLINE
config:
NAME STATE
storage ONLINE
raidz1-0 ONLINE
ata-WD_Red_SA500_2.5_2TB_25273ZD00458 ONLINE
ata-WD_Red_SA500_2.5_2TB_25273ZD01387 ONLINE
ata-WD_Red_SA500_2.5_2TB_25273ZD02050 ONLINE
errors: No known data errors
$ zfs list -r storage
NAME USED AVAIL REFER MOUNTPOINT
storage ... 3.5T ... /storage
storage/user3 ... 3.5T ... /storage/user3
storage/user1 ... 3.5T ... /storage/user1
storage/user2 ... 3.5T ... /storage/user2
Tre SSD, un disco di parità di ridondanza, una compressione trasparente che non costa niente e dataset per utente che rendono quote, snapshot e backup una riga di comando invece di un progetto. Niente male per un pomeriggio — anche contando i dieci minuti passati a combattere un bug che non era reale e i cinque minuti passati a farmi impressionare da un benchmark che era, di fatto, interamente immaginario. 🎉
📚 Altro in questa serie: il NAS RAIDZ1
- Addendum al NAS RAIDZ1: come vengono davvero pianificati scrub e trim — e l’allarme che non c’era
- Tutti a sorridere — facciamo uno snapshot! Da rdiff-backup a ZFS sul NAS RAIDZ1
- Secondo addendum: ZED controlla la salute del mio pool, non il suo girovita
- Due cose che mancavano ai miei SSD: TRIM dopo BitLocker e una cache di scrittura che il mio server HPE aveva spento in silenzio
