Een RAIDZ1-NAS bouwen op Debian 13 met OpenZFS: datasets, compressie en de leugens die dd me vertelde

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski
⚠️ Sommige commando’s in dit bericht maken ZFS-pools aan of verwijderen en overschrijven data. Maak eerst een back-up, probeer ze uit op een testsysteem en pas apparaatnamen en paden aan je eigen omgeving aan.
🪟➡️🐧 Context: de Windows-bak met pensioen
Even wat achtergrond, want “waarom heeft deze willekeurige Debian-bak opeens drie schijven en uitgesproken meningen over compressie” verdient een antwoord. Tot voor kort deed hier een Windows Server zowel Active Directory als het werk van fileserver/NAS — en eerlijk is eerlijk, hij deed dat prima. Inloggen werkte, shares werkten, niemand klaagde, er stond niets in brand. Maar elke keer dat ik van die bak naar iets met een DevSecOps-vorm schakelde, voelde ik de wrijving: ander mentaal model, andere tooling, ander spiergeheugen voor “oké, hoe zie ik nou eigenlijk wat hier gebeurt”. De Windows-server bestond puur voor NAS + AD-logins, terwijl een aparte bak nog stilletjes al het echte Linux-werk deed — jumphost-taken, af en toe iets CI-achtigs en de laatste tijd ook het ding dat precies deze zin genereert. Twee servers, twee beheerfilosofieën en een langzaam groeiend gevoel dat ik een klein museum van “zo deden we dat vroeger” aan het cureren was in plaats van een samenhangende setup te draaien. 🏛️ Natuurlijk had ik naar Proxmox kunnen grijpen en me met virtualisatie om de beslissing heen kunnen draaien in plaats van haar echt te nemen — een Windows-guest opstarten, AD uit gewoonte aanhouden en het consolidatie noemen. Maar ik ben op het punt aangekomen dat ik echt liever alles op Linux zet, op één bak, en daar volledig voor ga: één toolchain, één ding om te patchen, één ding om te monitoren, in plaats van twee totaal verschillende werelden te onderhouden voor een fileshare en een loginprompt. En het najagen van die consolidatie is precies hoe ik weer bij OpenZFS uitkwam — als ik de NAS-rol toch van nul af aan op Linux opnieuw opbouw, wil ik dat de opslaglaag eronder echt goed is, niet alleen “goed genoeg dat Verkenner ophoudt met klagen”. Dus: ik heb een reservebak opnieuw geïnstalleerd met een verse Debian 13 (trixie) en besloot dat het tijd was om opslag niet langer als bijzaak te behandelen — je weet wel, de klassieke leugen “ik ga mijn bestanden ooit nog eens netjes ordenen” die we onszelf allemaal vertellen. Er gingen drie WD Red SA500 SSD’s van 2TB in, en het doel was op papier simpel: een redundante pool, compressie die zichzelf terugverdient en shares per gebruiker die elkaar niet in de weg zitten. OpenZFS maakte dit oprecht aangenaam — nadat ik voorbij een packaging-eigenaardigheid was, een cosmetische upstream-bug die me tien minuten aan mezelf liet twijfelen, en mijn eigen diep gênante eerste benchmark. Hier is de volledige walkthrough, met alle wratten erbij. 🐛
🤔 Waarom ZFS en niet NTFS of mdadm + ext4
Korte versie: ik wilde data met checksums, transparante compressie, goedkope snapshots en een opslaglaag die “dataset” als volwaardig concept begrijpt in plaats van als “map die ik beloof speciaal te behandelen, pinkie swear”. Na jaren NTFS op die Windows Server, en met ext4 overal elders, is het de moeite waard om echt uit te leggen wat ZFS anders doet in plaats van alleen te beweren dat het beter is — want op papier klinken NTFS en ext4 allebei prima. Ze mounten, ze bewaren bestanden en ze zijn al decennia productierijp. De verschillen komen pas aan het licht als er stilletjes iets misgaat, en dat is precies het scenario waarvoor geen van beide gebouwd is.
Checksums — de echte hoofdattractie. ZFS maakt een checksum van elk datablok en elk metadatablok, en verifieert die checksum bij elke leesactie, niet alleen tijdens een af en toe geplande scan. NTFS heeft helemaal geen checksums voor data — de feature integrity streams dekt alleen metadata, is opt-in en werd in latere Windows Server-releases in ReFS stilletjes teruggebracht tot niets anders dan metadata. ext4 zit in hetzelfde schuitje: metadata_csum beschermt de eigen boekhouding van het bestandssysteem, maar de daadwerkelijke inhoud van je bestanden wordt blind vertrouwd. Als er ergens op het fysieke medium een bit omvalt — en op elke schijf die groot en oud genoeg is, gebeurt dat uiteindelijk — geven NTFS en ext4 je de corrupte byte met een glimlach en zonder enige aanwijzing dat er iets gebeurd is. Dit is stille bit-rot, en “stil” is hier het sleutelwoord: geen fout, geen logregel, geen alert, alleen een net verkeerde pixel in een foto of een net verkeerde byte in een back-uparchief, die niemand opmerkt tot het ertoe doet.
Zelfherstel, niet alleen detectie. Hier loopt ZFS zelfs uit op alternatieven met checksums: omdat het de redundantie (RAIDZ, mirrors) en de checksums in dezelfde laag beheert, kan het niet alleen zeggen “dit blok klopt niet”, maar de juiste waarde uit de pariteit reconstrueren en automatisch opnieuw wegschrijven — tijdens normale leesacties, en grondig tijdens een zpool scrub. Vergelijk dat met de klassieke stack mdadm + ext4: de RAID-laag en de bestandssysteemlaag praten niet met elkaar. mdadm kan je vertellen dat een hele schijf dood is. Het kan je niet vertellen dat één specifiek blok stilletjes rot is geworden terwijl elke schijf meldt “met mij gaat het goed” — er wordt geen checksum vergeleken, dus er is niets om het over oneens te zijn. De corruptie plant zich gewoon stilletjes voort door elke pariteitsberekening alsof het correcte data is, want voor zover RAID weet, ís het dat ook.
Geen “initiële resync” bij het aanmaken, omdat pariteit geen apart concept is. Iedereen die ooit een mdadm-array met RAID5/6 heeft gebouwd, kent het ritueel: aanmaken en dan wachten — soms uren — terwijl hij een initiële resync van de hele array doormaalt en consistente pariteit naar elk afzonderlijk blok schrijft, ongeacht of dat blok echte data bevat of nog helemaal leeg is. Dat moet ook: mdadm werkt puur op blockdevice-niveau, onder het bestandssysteem, zonder enig zicht op welke blokken “echt” zijn en welke ongebruikte ruimte. Het kan niets overslaan, dus doet het dat ook niet. zpool create op precies deze drie schijven duurde daarentegen een paar seconden. Geen resync, geen wachten, niets in te halen — want in ZFS wordt pariteit berekend en weggeschreven als onderdeel van dezelfde atomaire schrijfactie die de data zelf neerlegt, en niet-toegewezen ruimte heeft simpelweg geen pariteit die inconsistent kan zijn. Er is geen “begintoestand” om te corrigeren, omdat er nooit een moment is waarop data en pariteit het oneens zijn.
Het dichtstbijzijnde ZFS-equivalent van een RAID-rebuild is een resilver — getriggerd wanneer een defecte schijf wordt vervangen of een nieuwe aan een mirror wordt gekoppeld — en zelfs die erft hetzelfde voordeel van bestandssysteembewustzijn: ZFS resilvert alleen de blokken die daadwerkelijk in gebruik zijn, niet de volledige ruwe capaciteit van de schijf. Een pool die voor 40% vol is, hoeft maar 40% aan data te resilveren; een traditionele mdadm-rebuild zou hoe dan ook 100% van de array doormalen, omdat hij het verschil niet kent. Het proactieve equivalent van een check/repair-run van mdadm is zpool scrub — zelfde idee, zelfde efficiëntiewinst: hij loopt elk toegewezen blok langs en verifieert het tegen zijn checksum (en, anders dan een domme RAID-check, corrigeert hij het ook echt), en slaat alles over wat nooit is beschreven.
Copy-on-write vs. journaling. ext4 en NTFS zijn allebei journaling-bestandssystemen: ze loggen metadatawijzigingen voordat ze die doorvoeren, dus een crash midden in een schrijfactie laat je achter met consistente metadata, maar een lopende dataschrijfactie kan je nog steeds opzadelen met een half geschreven bestand. ZFS overschrijft nooit levende data op dezelfde plek — elke schrijfactie gaat naar een nieuw blok, en het bestandssysteem schakelt atomair om zodra die volledig is doorgevoerd. Er is geen venster waarin een crash een bestand half oud, half nieuw kan achterlaten; je ziet óf de laatste complete toestand óf de nieuwe complete toestand, nooit een mengsel van beide.
Snapshots die echt goedkoop zijn. NTFS heeft Volume Shadow Copy, dat werkt, maar vastzit aan een aparte VSS-dienst, praktische grenzen heeft aan hoeveel je er realistisch bewaart en merkbaar traag kan worden naarmate wijzigingen zich opstapelen. ext4 heeft helemaal niets native — je grijpt naar LVM-snapshots eronder, die hun eigen laag zijn met hun eigen prestatiekosten naarmate ze van het origineel afwijken. ZFS-snapshots zijn bijna instant (weer copy-on-write — een snapshot betekent gewoon “deze blokken nog even niet vrijgeven”), kosten niets totdat de data echt verandert, en je kunt er zonder nadenken tientallen laten rondslingeren.
Compressie als standaard, niet als compromis. NTFS-compressie bestaat, maar is oud, single-threaded en traag genoeg dat het aanzetten ervan voor alles wat prestatiegevoelig is een fout is die de meeste beheerders maar één keer maken. ext4 heeft helemaal geen native compressie. De lz4-compressie van ZFS is, zoals hieronder blijkt, snel genoeg dat aan laten staan gewoon de juiste standaard is — geen afweging waar je over na hoeft te denken.
Gepoolde opslag als native model. Een NTFS-volume of een ext4-bestandssysteem vergroten betekent worstelen met respectievelijk Storage Spaces of LVM/mdadm — aparte tools die eronder zijn vastgeschroefd, elk met hun eigen mentale model en faalscenario’s. ZFS-pools en -datasets zijn de native abstractie, geen add-on: capaciteit toevoegen, een nieuwe dataset afsplitsen of een quota per dataset instellen zijn gewoon zpool/zfs-subcommando’s, zonder tweede toolchain.
| Feature | NTFS | ext4 | ZFS |
|---|---|---|---|
| Data-checksums | Nee | Nee | Ja, elk blok, bij elke leesactie geverifieerd |
| Automatisch zelfherstel | Nee | Nee | Ja, via redundantie + checksums samen |
| Crashconsistentie | Alleen metadata via journal | Alleen metadata via journal | Volledig copy-on-write, geen in-place overschrijvingen |
| Snapshots | VSS (beperkt, wordt na verloop van tijd trager) | Niets native (vereist LVM) | Native, bijna instant, goedkoop |
| Compressie | Traag, zelden gebruikt | Niets native | Snel (lz4), standaard aan |
| Gepoolde opslag / quota’s | Storage Spaces (vastgeschroefd) | LVM (vastgeschroefd) | Native in het bestandssysteem |
Niets hiervan maakt NTFS of ext4 slechte bestandssystemen — ze zijn volwassen, goed begrepen, en vooral NTFS heeft die Windows Server jarenlang foutloos laten draaien. Maar “foutloos, voor zover ik kon zien” is precies de zin die je zenuwachtig zou moeten maken als het om stille corruptie gaat: het hele punt is dat geen van beide bestandssystemen het me verteld zou hebben als het gebeurd was. mdadm + LVM + ext4 kunnen met genoeg ducttape en persoonlijke discipline een deel van de featurelijst van ZFS benaderen. ZFS heeft het gewoon, batterijen inbegrepen, en vraagt je niet om drie aparte tools met wilskracht bij elkaar te houden — of erop te vertrouwen dat er nooit stilletjes iets misgaat op precies die ene as waar niemand naar kijkt.
📦 Stap 1: OpenZFS op Debian 13 krijgen
Debian levert ZFS niet in main vanwege licenties (CDDL vs GPL — de langstlopende vete in de wereld van softwarelicenties, ouder dan de meeste schijven in deze pool), dus het woont in contrib. Dat component staat standaard niet aan:
# /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
Dit trekt DKMS binnen, bouwt zfs.ko en spl.ko tegen de draaiende kernel (6.12.107+deb13-amd64 op dat moment) en — omdat het ondertekenen van modules voor Secure Boot nu eenmaal een ding is — genereert on the fly een zelfondertekende MOK (Machine Owner Key) om de vers gebouwde modules te ondertekenen. Als je bak Secure Boot aan heeft, moet je die MOK bij de volgende reboot inschrijven; deze had dat niet, dus het was geen probleem, maar het is goed om te weten dat DKMS op de achtergrond stilletjes zijn eigen ondertekeningsgegevens vervalst, als een heel beleefde, heel legale vervalser. 🔏
🏗️ Stap 2: de pool bouwen
Drie schijven, RAIDZ1 (één schijf aan pariteit — de juiste keuze bij drie schijven; RAIDZ2 wil meer spindles om niet te veel capaciteit te verspillen). De enige regel die me hier echt aan het hart gaat: wijs ZFS nooit naar /dev/sdX. Apparaatletters worden bij het opstarten toegewezen en kunnen door elkaar raken na een kernelupdate, een BIOS-wijziging of gewoon omdat het universum een slechte dag heeft. Gebruik in plaats daarvan de stabiele paden onder /dev/disk/by-id/, tenzij je geniet van de specifieke horror dat je pariteitsschijf stilletjes je dataschijf wordt:
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 vertelt ZFS dat dit apparaten met 4K-sectoren zijn (SSD’s zijn dat allemaal, ook als ze er in hun firmware over liegen en logische sectoren van 512 bytes rapporteren alsof het nog 2009 is). Doe je dit verkeerd bij het aanmaken van de pool, dan kun je het later niet meer rechtzetten zonder de pool te vernietigen en opnieuw op te bouwen — dit is de enige instelling in deze hele build waarbij er echt geen weg terug is, dus die krijgt de enge vetgedrukte tekst. autotrim=on is specifiek belangrijk omdat dit SSD’s zijn; zonder dat ben je afhankelijk van een periodieke handmatige zpool trim en laat je write amplification stilletjes op de achtergrond oplopen, als opslaglaag-cholesterol.
Eindresultaat: drie schijven van 2TB, ~5,45TB ruw, ~3,6TB bruikbaar na de RAIDZ1-pariteit. De ontbrekende ~1,85TB is niet verdwenen — dat is de tolpoort voor “één schijf mag doodgaan en ik heb mijn data nog”.
🗜️ Compressie: lz4, en waarom niet zstd
ZFS-compressie is transparant, per dataset en — met lz4 — in wezen gratis, wat in opslagnerd-termen het dichtst bij een gratis lunch komt dat je ooit aangeboden krijgt. lz4 is speciaal gebouwd om zo snel te zijn dat aanzetten nooit een throughput-regressie is; het heeft ook een early-abort-heuristiek die meteen afhaakt bij niet-comprimeerbare data (al gecomprimeerde video, versleutelde blobs) in plaats van het koppig toch te proberen en voor niets CPU te verstoken. zstd comprimeert strakker, maar kost meer CPU per byte. Voor een algemene NAS-workload — documenten, foto’s, af en toe een VM-image, coderepo’s — was lz4 de voor de hand liggende standaard. Als dit een back-updoel was met vooral platte-tekstdumps, had ik zstd-3 gekozen en de CPU-belasting met plezier betaald.
Nu er echte data op staat in plaats van synthetische benchmarkbestanden, is dit wat het me werkelijk oplevert — en in de geest van het terugkerende thema van dit bericht is het eerlijke antwoord “niet veel”, en dat is precies wat je verwacht zodra je weet wat er echt opgeslagen is:
$ 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 | Logisch (ongecomprimeerd) | Werkelijk (op schijf) | Ratio |
|---|---|---|---|
| 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 |
Nauwelijks waarneembare ratio’s, en de reden is geen verkeerde configuratie — het is de data zelf. Deze pool bevat vooral foto’s, video’s, Outlook-PST-bestanden en al gecomprimeerde archieven: precies de inhoud die de early-abort-heuristiek van lz4 moet herkennen om er geen CPU meer aan te verspillen. Dat is geen falende compressie, dat is compressie die correct werkt en uit de weg gaat. De datasets die er het dichtst bij komen echt te profiteren zijn storage/user2 en storage/user1 met 1.05x — nog steeds bescheiden, maar echte, gratis besparing op het deel van die data dat toevallig tekstachtig is (documenten, configuratiebestanden, de metadata-overhead van honderdduizenden kleine bestanden). Als deze pool een databasedump of een berg logbestanden zou hosten in plaats van een familiefotoarchief, zag deze tabel er een stuk indrukwekkender uit — en dat is de eigenlijke les: de compressieratio vertelt je net zoveel over je data als over je bestandssysteem.
👻 De cosmetische bug die me aan mezelf liet twijfelen
Ik zette xattr=sa bij het aanmaken van de pool (extended attributes direct in de dnode opgeslagen in plaats van als verborgen directory-entries — sneller, en nodig voor fatsoenlijke ACL-prestaties). Het commando eindigde met 0, geen klachten, geen drama. Daarna meldde zfs get xattr storage koppig on in plaats van sa, elke keer weer, alsof het nog nooit had gehoord van de instelling die ik net had meegegeven.
Blijkt dat dit een bekende, bevestigde weergavebug in OpenZFS 2.3.2 is (zie openzfs/zfs discussion #16996 als je de bloederige details wilt) — de property staat eigenlijk correct, zfs get toont alleen het verkeerde label. Geen verkeerde configuratie, alleen cosmetische ruis die je gegarandeerd aan jezelf laat twijfelen, zodat je hetzelfde commando vijf keer opnieuw draait voordat je eraan denkt het te googelen. 🕵️
🧠 ARC-tuning: RAM overlaten voor al het andere
De Adaptive Replacement Cache (ARC) van ZFS eet vrolijk het grootste deel van je RAM op als je hem zijn gang laat gaan — wat geweldig is op een dedicated storage-appliance en een stuk minder geweldig op een bak die ook andere diensten draait en daar graag iets over zou zeggen. Zonder limiet gedraagt ARC zich precies als een tiener die alleen met een koelkast is achtergelaten: geef hem ruimte, hij vult hem, en hij geeft uit zichzelf niets terug. Met 31GB RAM in totaal heb ik hem begrensd:
# /etc/modprobe.d/zfs.conf
options zfs zfs_arc_max=17179869184
options zfs zfs_arc_min=2147483648
16GiB maximum, 2GiB als ondergrens. Live toegepast via /sys/module/zfs/parameters/zfs_arc_max voor direct effect, en daarna in de initramfs ingebakken (update-initramfs -u -k all) zodat het een reboot overleeft en niet gewoon weer de koelkast gaat plunderen.
🤥 Benchmarken, of: hoe ik mezelf vijf minuten voorloog
Bij de eerste poging deed ik wat elke ZFS-nieuwkomer doet en waar ik meteen spijt van had:
dd if=/dev/zero of=/storage/testfile bs=1M count=10000
8,7 GB/s schrijven. 14,1 GB/s lezen. Op drie SATA-SSD’s. Op een thuisnetwerk. Heel even overwoog ik een stevig LinkedIn-bericht te schrijven over hoe ondergewaardeerd consumenten-SSD’s zijn. Toen herinnerde ik me hoe compressie werkt: /dev/zero produceert een eindeloze stroom nullen, lz4 comprimeert een reeks nullen tot bijna niets, en ik had zojuist mijn compressor gebenchmarkt, niet mijn schijven. Diep onnozel, even opwindend, uiteindelijk betekenisloos — het opslagequivalent van meten hoe snel je een boek leest door alleen de lege pagina’s te lezen. 📖💨
Ik heb het netjes overgedaan met niet-comprimeerbare data, want jezelf voorliegen is maar één keer leuk:
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
Ik heb dit weken later een tweede keer netjes gedraaid, toen er echte data op de pool stond en — belangrijk — toen elke andere job op de bak (een migratie van 380GB, een verplaatsing van 235GB tussen datasets, een ACL-rebuild) echt klaar was en de load average weer rond nul zat. Benchmarken tegen een pool die nog bezig is het werk van gisteren te verteren, meet alleen contentie, niet de schijven.
| Test | Resultaat |
|---|---|
| Schrijven, gebufferd | 138 MB/s |
| Schrijven, O_DIRECT | 15,4 MB/s |
| Lezen, gebufferd | 1,1 GB/s |
| Lezen, O_DIRECT | 931 MB/s |
Die schrijfregel is geen typfout, en het verraste me genoeg om twee- en driemaal te controleren dat het geen contentie door iets anders was voordat ik het geloofde: O_DIRECT-schrijfacties waren ongeveer 9x trager dan gebufferde schrijfacties op deze pool, het tegendeel van de intuïtie die de meeste mensen van andere bestandssystemen meenemen (“direct I/O slaat een laag over, dus het zou sneller moeten zijn”). Specifiek op ZFS draait die intuïtie om. Het gebufferde pad is niet alleen “gecachet” — het is waar ZFS zijn eigenlijke schrijfoptimalisatie doet: binnenkomende schrijfacties worden in het geheugen gebundeld en als onderdeel van een transaction group naar de RAIDZ-vdev geschreven, uitgelijnd en samengevoegd tot efficiënte full-stripe-schrijfacties. O_DIRECT slaat by design precies die bundellaag over, dus elke schrijfactie moet op eigen houtje rechtstreeks naar de vdev — wat op een array op basis van pariteit kan betekenen: kleinere, minder goed uitgelijnde I/O, met de overhead die daarbij hoort. Het omzeilen van de cache omzeilt hier geen echte inefficiëntie; het omzeilt juist het ding dat de schrijfacties efficiënt maakte.
Update (6 oktober 2026): het grootste deel van dat 9x-verschil bleek helemaal niet aan ZFS te liggen. De serverfirmware had de eigen schrijfcache van de SSD’s uitgeschakeld, waardoor elke niet-gebundelde schrijfactie op het flashgeheugen zelf moest wachten (en ook de gebufferde 138 MB/s was laag). De verklaring over het bundelen hieronder klopt nog steeds, maar was het kleinere deel. Het hele verhaal: Twee dingen die mijn SSD’s misten: TRIM na BitLocker, en een schrijfcache die mijn HPE-server stilletjes uitzette.
De leescijfers krijgen hetzelfde sterretje als eerder: dit is single-threaded doorvoer van één bestand, geen realistisch beeld van de totale poolprestaties onder gelijktijdige belasting, en beide leeswaarden kunnen deels uit ARC zijn geleverd in plaats van van schijf — ARC is niet hetzelfde als de page cache van Linux, dus echo 3 > /proc/sys/vm/drop_caches doet niets om hem te legen, en het O_DIRECT-leespad van OpenZFS geeft je nog steeds vrolijk blokken uit ARC in plaats van een echte schijflezing af te dwingen als de data er al staat. Zie dd-cijfers uit één enkele run als sanity check op “is er iets duidelijk stuk”, niet als specsheet voor een verkoopslide — en als je maar één ding uit deze sectie onthoudt, laat het dan zijn: “ga er niet van uit dat O_DIRECT het snelle pad is zonder het eerst op jouw specifieke bestandssysteem te meten”.
👨👩👧 Waarom elke gebruiker een eigen dataset krijgt
De pool bedient drie mensen, elk met een Samba-share. De share-root van elke persoon is een eigen ZFS-dataset (storage/user3, storage/user1, storage/user2) in plaats van drie gewone mappen binnen één grote dataset. Dit was geen standaard waar ik toevallig in rolde — het is een bewuste structurele keuze, en die betaalt zich uit op manieren waar een gedeelde mappenstructuur gewoon niet tegenop kan:
- Quota’s.
zfs set quota=500G storage/user2begrenst één gebruiker zonder de anderen aan te raken. Een quota is een eigenschap van een dataset; een map kent zo’n concept op zichzelf niet, hoe streng je het ook vraagt. - Onafhankelijke snapshots. Met
zfs snapshot storage/user2@before-cleanupkan één persoon een slecht “alles verwijderen”-moment terugdraaien zonder de andere twee datasets mee te sleuren. - Directe gebruiksadministratie.
zfs listleest het ruimtegebruik rechtstreeks uit de metadata van de dataset. Geen boom doorlopen, geendu -shdat anderhalve minuut door honderden gigabytes aan kleine bestanden maalt terwijl jij naar een knipperende cursor staart en je carrièrekeuzes in twijfel trekt. - Duidelijke eigendomsgrenzen. Het mountpoint van elke dataset loopt 1:1 gelijk met zijn Samba-share, met een eigen Unix-eigenaar. Bestandssysteemrechten en share-rechten blijven synchroon in plaats van alleen op trucs in de Samba-laag te leunen.
- Tuning per dataset. Compressie,
atime, record size — allemaal per dataset te overschrijven als de workload van één gebruiker ooit iets anders zou rechtvaardigen dan de standaard van de pool. - Granulaire replicatie.
zfs send/receivewerkt per dataset. Wil je alleen de share van één persoon naar een externe schijf back-uppen zonder de anderen aan te raken? Eén regel, geen selectieve rsync-exclude-lijst die bij elkaar wordt gehouden door spijt.
De prijs voor dit alles: data tussen datasets verplaatsen is niet langer gratis. 😬 mv binnen één dataset is een pure rename — alleen metadata, direct, ongeacht de grootte. mv tussen datasets is een heel ander beest, ook al staan beide datasets op dezelfde pool en dezelfde fysieke schijven: ZFS behandelt elke dataset als een eigen bestandssysteem, dus de kernel moet echt elke byte naar de nieuwe locatie kopiëren en daarna het origineel verwijderen. Dat heb ik op de leuke manier opnieuw geleerd tijdens het ontwarren van een geneste mappenpuinhoop — het platslaan binnen dezelfde dataset was meteen klaar, en een verplaatsing van ~235GB tussen datasets stond daar het grootste deel van een uur te doen wat in de praktijk een volledige kopie was, terwijl ik naar een terminal zonder voortgangsbalk staarde en me afvroeg of ik iets kapot had gemaakt. Het ligt niet aan jou, ZFS, het ligt aan de datasetgrenzen. Goed om te weten voordat je er een start en driesecondenmagie verwacht zoals de vorige keer.
🔑 Eén admin, drie shares: waarom gewone chmod dit niet kon
Het toegangsmodel dat ik wilde, is simpel om hardop te zeggen: iedereen krijgt volledige toegang tot zijn eigen map, en ik krijg daarnaast volledige toegang tot die van iedereen, zowel op de Samba-share als op het ruwe Linux-bestandssysteem eronder. Simpel om te zeggen — en toen probeerde ik het daadwerkelijk te bouwen met klassieke chmod en liep meteen tegen de muur waar elke sysadmin uiteindelijk tegenaan loopt: een Unix-bestand heeft precies één eigenaar en precies één groep. Dat is het. Dat is de hele cast. Iedereen anders valt in die ene emmer met het label “other”.
Dat model kan “de eigenaar krijgt toegang” en “deze ene groep krijgt toegang” uitdrukken — het kan niet “user1 krijgt toegang EN user3 krijgt ook toegang, maar user2 niet” uitdrukken, want er is geen tweede groepsslot om user3 in te stoppen zonder ook een gedeelde groep te verzinnen, te beslissen wie er later nog meer bij mag en te hopen dat niemand er over zes maanden de verkeerde persoon aan toevoegt. Je kunt hier omheen hacken door user3 als secundair lid toe te voegen aan de privégroepen van user1 en user2 en het setgid-bit te zetten zodat nieuwe bestanden de groep erven — en voor veel setups is dat een prima, saai antwoord dat weinig moeite kost. Hier vond ik het om twee redenen niets: het verleent toegang op groepsniveau (en verandert dus stilletjes als het groepslidmaatschap ooit om een ongerelateerde reden wijzigt), en de overerving bij nieuwe bestanden hangt af van het setgid-bit plus welke umask het aanmakende proces toevallig gebruikt — wat werkt, maar “werkt omdat drie aparte mechanismen allemaal netjes op één lijn stonden” is geen zin die om 2 uur ’s nachts vertrouwen wekt.
POSIX-ACL’s lossen het echte probleem op in plaats van eromheen te werken: ze laten een bestand of map extra, expliciet benoemde gebruikers- en groepsentries dragen naast het klassieke drietal owner/group/other. “user1 is eigenaar hiervan, en user3 krijgt specifiek ook rwx, punt” — geen gedeelde groep nodig, geen omstanders. Eerst moet ACL-ondersteuning per dataset worden aangezet (standaard uit):
zfs set acltype=posixacl storage/user1
zfs set acltype=posixacl storage/user2
Dan de toekenning zelf, in twee delen — een recursieve toekenning voor alles wat al bestaat, en een default-ACL zodat alles wat vanaf nu wordt aangemaakt automatisch dezelfde regel erft, zonder umask-roulette:
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
Dezelfde twee regels voor /storage/user2. Gecombineerd met de rechten van elke map die op 750 zijn vastgezet (alleen eigenaar en groep, niets voor “other” — zodat user2 en user1 categorisch niet in elkaars data kunnen belanden, zelfs niet per ongeluk), is de eindtoestand precies het gestelde doel: iedereen heeft vrij spel in zijn eigen map, ik heb vrij spel in alle drie, en niemand krijgt per ongeluk een zijdeur. Het loont om het daadwerkelijke effect te controleren in plaats van erop te vertrouwen dat het commando niet stilletjes niets deed:
$ 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::---
En aan de kant van Samba bleek dit ACL-werk minder uit te maken dan verwacht — de drie shares gebruiken al force user, waardoor elke verbinding met een share werkt als de eigenaar van die share, ongeacht wie zich daadwerkelijk heeft aangemeld. Mijn toegang tot de shares van user1 en user2 via SMB was dus al gedekt door die directive, mits de onderliggende map echt eigendom is van de juiste persoon — wat, in een leuk stukje zelf veroorzaakte archeologie, even niet zo was (een overblijfsel van een eerdere reorganisatie had één dataset met mij als eigenaar achtergelaten in plaats van de echte gebruiker, wat me stilletjes SMB-schrijftoegang gaf die ik niet bedoeld had en de rechtmatige eigenares van de map haar eigen standaardrechten ontzegde, totdat ik het opmerkte en rechtzette). De ACL’s dichten specifiek het andere gat: gewone SSH- / lokale shelltoegang, die helemaal niet langs force user gaat en alleen naar de ruwe Unix-rechten luistert.
😵 “Wacht, is dit eigenlijk nog wel één pool?” — de df-verwarring
Een paar weken nadat dit draaide, liet een snelle df -h het lijken alsof er iets flink mis was gegaan:
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
Vier verschillende waarden voor “Size”, op een pool die één geheel blok opslag zou moeten zijn dat zich gedraagt als een RAID5. Was hij ’s nachts stilletjes in losse pools uiteengevallen? Had ik iets verkeerd geconfigureerd? 😱 Nee — dit is df dat technisch correct is op de meest onbehulpzame manier die er bestaat.
ZFS-datasets hebben geen vaste grootte zoals een klassieke RAID-partitie. De kolom “Size” van df wordt per mount berekend als Used + Available, en — dit is het deel dat er echt toe doet — Available is voor elke dataset identiek, omdat het dezelfde gedeelde vrije ruimte in dezelfde pool is. Alleen “Used” verschilt, omdat dat per persoon echt anders is. Draai in plaats daarvan zfs list en het mysterie verdwijnt:
$ 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
Dezelfde AVAIL — 1.85T — op elke regel, omdat het één gedeelde pot is. De df-“size” van 3.1T van user3 is gewoon 1.20T gebruikt + 1.85T beschikbaar; de 1.9T van user1 is 14.3G + 1.85T. Niets gefragmenteerd, niets kwijt — op het moment dat iemand een gigabyte schrijft, daalt die gedeelde AVAIL voor iedereen tegelijk, wat precies het RAID5-achtige gedrag is dat in de eerste plaats verwacht werd. zpool list beslecht het definitief:
$ 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
Eén pool, 5.45T ruw, één RAIDZ1-vdev, alle drie de schijven erin. df is gewoon niet gebouwd met “meerdere bestandssystemen die dynamisch één capaciteitspool delen” in gedachten — het rapporteert eerlijk, het beantwoordt alleen een vraag (“hoe groot is deze mount”) die hier niet op dezelfde manier van toepassing is. zfs list / zpool list zijn de tools die echt antwoord geven op “hoeveel ruimte heb ik”, niet df.
📋 Cheatsheet: de commando’s die ik op deze pool echt gebruik
De helft van ZFS leren is beseffen dat het subcommando dat je zoekt vrijwel zeker al bestaat, begraven onder een naam die achteraf volkomen logisch is. Hier is de werkset voor precies deze setup — pool storage, datasets storage/user3, storage/user1, storage/user2, storage/nextcloud.
Gezondheid van de 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
Datasets: overzicht en ruimtegebruik
# 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
Compressie: hoeveel levert het me echt op
# 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
Quota’s en reserveringen
# 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
Snapshots
# 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
Properties: get/set, de algemene vorm
# 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 (de RAM-cache)
# 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
Replicatie
# 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: wat ik tot nu toe echt nodig had
Het grootste deel van het leven van deze pool is saai geweest, en dat is precies het punt van ZFS draaien — saai is een feature. Maar tijdens het bouwen kwamen er een paar dingen voorbij die het waard zijn om voor de volgende keer vast te leggen, hier opgeborgen zodat mijn toekomstige ik niets hiervan twee keer op de harde manier opnieuw hoeft te leren. Pool is DEGRADED of een schijf staat op 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 of scrub lijkt vast te zitten / duurt eeuwig
# 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
Dataset wil niet mounten / “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” bij het verplaatsen naar/schrijven in de dataset van een andere gebruiker
Hier liep ik direct tegenaan bij het verplaatsen van de bestanden van user2 naar haar dataset als de Unix-gebruiker user3 — de eigenaar en modus van de dataset geven by design geen schrijftoegang, en ZFS had geen boodschap aan mijn excuses. Voer de operatie uit als root, of corrigeer het eigendom achteraf:
# 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
ZFS-kernelmodule ontbreekt na een kernelupdate
Omdat dit met DKMS is gebouwd (out-of-tree), betekent een nieuwe kernel dat DKMS zfs.ko/spl.ko daartegen opnieuw moet bouwen voordat de module laadt — dat gebeurt normaal gesproken automatisch als onderdeel van de postinst van het kernelpakket, maar het is het eerste wat je controleert als een pool na een reboot weigert te importeren en je er even van overtuigd bent dat je 3,6TB aan data aan de leegte bent kwijtgeraakt:
# 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
Een afhankelijke dienst (GitLab, een container, wat dan ook) start voordat de pool gemount is Symptoom: de dienst komt prima op, maar schrijft naar een lege map op het root-bestandssysteem in plaats van naar de echte data op ZFS, omdat zijn mountpoint bij het opstarten nog niet klaar was — stilletjes, zonder fout, en dat is de ergste soort bug. Controleer de werkelijke systemd-volgorde in plaats van aan te nemen dat het wel goed zit:
# 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
Vrije ruimte is “verdwenen” en du verklaart het niet
# 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
ARC eet al het RAM op
# 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
🏁 Uiteindelijke indeling
$ 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
Drie SSD’s, redundantie ter waarde van één pariteitsschijf, transparante compressie die niets kost en datasets per gebruiker die quota’s, snapshots en back-ups tot een one-liner maken in plaats van een project. Niet slecht voor een middag — zelfs als je de tien minuten meetelt die ik besteedde aan het bevechten van een bug die niet echt was, en de vijf minuten waarin ik onder de indruk was van een benchmark die in feite volledig fictief was. 🎉
📚 Meer in deze serie: de RAIDZ1-NAS
- Aanvulling op de RAIDZ1-NAS: hoe scrub en trim echt worden ingepland — en de alert die er niet was
- Iedereen lachen — we maken een snapshot! Van rdiff-backup naar ZFS op de RAIDZ1-NAS
- Tweede aanvulling: ZED bewaakt de gezondheid van mijn pool, niet zijn taille
- Twee dingen die mijn SSD’s misten: TRIM na BitLocker, en een schrijfcache die mijn HPE-server stilletjes uitzette
