Budowa NAS-a RAIDZ1 na Debianie 13 z OpenZFS: datasety, kompresja i kłamstwa, które opowiedział mi dd

Ilustracja NAS-a RAIDZ1 zbudowanego z OpenZFS na Debianie

🌐 Także w: English · Deutsch · Français · Español · Italiano · Português · Nederlands

⚠️ Niektóre polecenia w tym wpisie tworzą pule ZFS albo usuwają i nadpisują dane. Najpierw zrób kopię zapasową, wypróbuj je na systemie testowym i dostosuj nazwy urządzeń oraz ścieżki do swojego środowiska.

🪟➡️🐧 Kontekst: emerytura dla windowsowej maszyny

Trochę tła, bo pytanie „dlaczego ta przypadkowa maszyna z Debianem nagle ma trzy dyski i stanowcze poglądy na kompresję” zasługuje na odpowiedź. Do niedawna Windows Server obsługiwał u mnie zarówno Active Directory, jak i rolę serwera plików/NAS — i trzeba oddać mu sprawiedliwość, robił to bez zarzutu. Logowanie działało, udziały działały, nikt nie narzekał, nic się nie paliło. Ale za każdym razem, gdy przełączałem się z tej maszyny na cokolwiek w klimacie DevSecOps, czułem tarcie: inny model mentalny, inne narzędzia, inna pamięć mięśniowa w stylu „dobra, jak tu właściwie sprawdzić, co się dzieje”. Serwer z Windowsem istniał wyłącznie dla NAS-a i logowania do AD, podczas gdy osobna maszyna wciąż po cichu odwalała całą prawdziwą robotę linuksową — rolę jump hosta, okazjonalne zadania w okolicach CI, a ostatnio także rzecz, która generuje właśnie to zdanie. Dwa serwery, dwie filozofie administrowania i powoli narastające poczucie, że jestem kustoszem małego muzeum „tak się to kiedyś robiło”, a nie operatorem spójnego setupu. 🏛️ Jasne, mogłem sięgnąć po Proxmoxa i zwirtualizować sobie drogę naokoło decyzji, zamiast ją faktycznie podjąć — postawić gościa z Windowsem, zostawić AD z przyzwyczajenia i nazwać to konsolidacją. Ale doszedłem do punktu, w którym naprawdę wolę mieć wszystko na Linuksie, na jednej maszynie, i pójść w to na całość: jeden toolchain, jedna rzecz do łatania, jedna rzecz do monitorowania, zamiast utrzymywać dwa zupełnie różne światy dla jednego udziału plików i jednego okna logowania. I właśnie pogoń za tą konsolidacją zaprowadziła mnie z powrotem do OpenZFS — skoro i tak odbudowuję rolę NAS-a od zera na Linuksie, chcę, żeby warstwa storage pod spodem była naprawdę dobra, a nie tylko „wystarczająco dobra, żeby Eksplorator przestał marudzić”. Więc: przeinstalowałem zapasową maszynę na świeżego Debiana 13 (trixie) i uznałem, że czas przestać traktować storage po macoszemu — znasz to, klasyczne kłamstwo „kiedyś porządnie poukładam swoje pliki”, które wszyscy sobie opowiadamy. Weszły trzy dyski SSD WD Red SA500 po 2TB, a cel na papierze był prosty: redundantna pula, kompresja, która się zwraca, i udziały per użytkownik, które nie wchodzą sobie w drogę. OpenZFS sprawił, że było to naprawdę przyjemne — gdy już przebrnąłem przez dziwactwo pakietowania, kosmetyczny bug upstreamu, który przez dziesięć minut robił mi gaslighting, i mój własny, głęboko żenujący pierwszy benchmark. Oto pełny przewodnik, ze wszystkimi brodawkami. 🐛

🤔 Dlaczego ZFS, a nie NTFS albo mdadm + ext4

Wersja skrócona: chciałem danych z sumami kontrolnymi, przezroczystej kompresji, tanich snapshotów i warstwy storage, która rozumie „dataset” jako pełnoprawne pojęcie, a nie jako „katalog, który obiecuję traktować wyjątkowo, słowo harcerza”. Po latach NTFS na tamtym Windows Serverze i życiu z ext4 wszędzie indziej warto naprawdę rozpisać, co ZFS robi inaczej, zamiast tylko twierdzić, że jest lepszy — bo na papierze NTFS i ext4 brzmią całkiem dobrze. Montują się, przechowują pliki i od dekad nadają się na produkcję. Różnice wychodzą dopiero wtedy, gdy coś po cichu pójdzie nie tak, a to dokładnie ten scenariusz, do którego wychwytywania żaden z nich nie został zbudowany. Sumy kontrolne — prawdziwa gwiazda wieczoru. ZFS liczy sumę kontrolną każdego bloku danych i każdego bloku metadanych, i weryfikuje ją przy każdym odczycie, a nie tylko podczas okazjonalnego zaplanowanego skanu. NTFS w ogóle nie ma sum kontrolnych danych — funkcja integrity streams obejmuje tylko metadane, jest opcjonalna, a w ReFS w późniejszych wydaniach Windows Server została po cichu ograniczona do samych metadanych. ext4 jest w tej samej łodzi: metadata_csum chroni wewnętrzną księgowość systemu plików, ale faktyczna zawartość twoich plików jest przyjmowana na ślepo. Jeśli gdzieś na fizycznym nośniku przekręci się bit — a na każdym dysku wystarczająco dużym i starym niektóre bity w końcu się przekręcą — NTFS i ext4 podadzą ci uszkodzony bajt z uśmiechem i bez żadnego sygnału, że cokolwiek się stało. To jest cichy bit-rot, a „cichy” to tu słowo-klucz: żadnego błędu, żadnego wpisu w logu, żadnego alertu, tylko odrobinę zły piksel na zdjęciu albo odrobinę zły bajt w archiwum kopii zapasowej, którego nikt nie zauważy, dopóki nie będzie to miało znaczenia. Samonaprawa, a nie tylko wykrywanie. Tu ZFS wyprzedza nawet alternatywy z sumami kontrolnymi: ponieważ zarządza redundancją (RAIDZ, mirrory) i sumami kontrolnymi w tej samej warstwie, potrafi nie tylko stwierdzić „ten blok jest zły”, ale odtworzyć poprawną wartość z parzystości i automatycznie ją zapisać na nowo — podczas zwykłych odczytów, a kompleksowo podczas zpool scrub. Porównaj to z klasycznym stosem mdadm + ext4: warstwa RAID i warstwa systemu plików ze sobą nie rozmawiają. mdadm powie ci, że padł cały dysk. Nie powie ci, że jeden konkretny blok po cichu się zepsuł, podczas gdy każdy dysk melduje „u mnie wszystko w porządku” — nie ma porównywania sum kontrolnych, więc nie ma się o co spierać. Uszkodzenie po prostu po cichu propaguje się przez każde obliczenie parzystości, jakby było poprawnymi danymi, bo z punktu widzenia RAID-u nimi jest. Brak „początkowego resyncu” przy tworzeniu, bo parzystość nie jest osobnym pojęciem. Każdy, kto budował macierz mdadm RAID5/6, zna ten rytuał: tworzysz ją, a potem czekasz — czasem godzinami — aż przemieli początkowy resync całej macierzy, zapisując spójną parzystość w każdym bloku, niezależnie od tego, czy ten blok zawiera prawdziwe dane, czy jest jeszcze zupełnie pusty. Musi tak robić: mdadm działa wyłącznie na poziomie urządzenia blokowego, pod systemem plików, bez żadnego wglądu w to, które bloki są „prawdziwe”, a które to nieużywane miejsce. Nie może niczego pominąć, więc nie pomija. Natomiast zpool create na tym samym zestawie trzech dysków zajął kilka sekund. Bez resyncu, bez czekania, bez nadrabiania zaległości — bo w ZFS parzystość jest liczona i zapisywana w ramach tego samego atomowego zapisu, który kładzie same dane, a nieprzydzielone miejsce po prostu nie ma parzystości, która mogłaby być niespójna. Nie ma „stanu początkowego” do poprawienia, bo nigdy nie ma momentu, w którym dane i parzystość by się nie zgadzały. Najbliższym odpowiednikiem przebudowy RAID-u w ZFS jest resilver — uruchamiany, gdy uszkodzony dysk zostaje wymieniony albo nowy zostaje dołączony do mirrora — i nawet on dziedziczy tę samą przewagę świadomości systemu plików: ZFS resilveruje tylko faktycznie przydzielone bloki, a nie pełną surową pojemność dysku. Pula zapełniona w 40% musi zresilverować tylko 40% danych; tradycyjna przebudowa mdadm i tak przemieliłaby 100% macierzy, bo nie zna różnicy. Proaktywnym odpowiednikiem przebiegu check/repair w mdadm jest zpool scrub — ten sam pomysł, ta sama oszczędność: przechodzi i weryfikuje (a w odróżnieniu od głupiego sprawdzenia RAID-u faktycznie naprawia) każdy przydzielony blok względem jego sumy kontrolnej i pomija wszystko, co nigdy nie zostało zapisane. Copy-on-write kontra journaling. ext4 i NTFS to systemy plików z journalingiem: logują zmiany metadanych przed ich zatwierdzeniem, więc awaria w trakcie zapisu zostawia spójne metadane, ale trwający zapis danych wciąż może zostawić cię z do połowy zapisanym plikiem. ZFS nigdy nie nadpisuje żywych danych w miejscu — każdy zapis trafia do nowego bloku, a system plików atomowo się przełącza, gdy zapis jest w pełni zatwierdzony. Nie ma okna, w którym awaria mogłaby zostawić plik w połowie stary, w połowie nowy; widzisz albo ostatni kompletny stan, albo nowy kompletny stan, nigdy mieszankę obu. Snapshoty, które naprawdę są tanie. NTFS ma Volume Shadow Copy, które działa, ale jest przywiązane do osobnej usługi VSS, ma praktyczne limity tego, ile kopii realnie utrzymasz, i potrafi zauważalnie zwolnić w miarę narastania zmian. ext4 nie ma nic natywnego — sięgasz po snapshoty LVM pod spodem, które są osobną warstwą z własnym kosztem wydajności w miarę rozjeżdżania się z oryginałem. Snapshoty ZFS są niemal natychmiastowe (znowu copy-on-write — snapshot oznacza po prostu „na razie nie odzyskuj tych bloków”), nic nie kosztują, dopóki dane faktycznie się nie zmienią, i spokojnie możesz trzymać ich dziesiątki bez zastanowienia. Kompresja jako domyślne ustawienie, a nie kompromis. Kompresja NTFS istnieje, ale jest stara, jednowątkowa i na tyle wolna, że włączenie jej dla czegokolwiek wrażliwego na wydajność to błąd, który większość adminów popełnia tylko raz. ext4 nie ma żadnej natywnej kompresji. Kompresja lz4 w ZFS, jak opisuję niżej, jest na tyle szybka, że zostawienie jej włączonej to po prostu właściwe ustawienie domyślne — a nie kompromis, nad którym trzeba się zastanawiać. Pula storage jako natywny model. Powiększenie wolumenu NTFS albo systemu plików ext4 oznacza zmaganie się odpowiednio ze Storage Spaces albo LVM/mdadm — osobnymi narzędziami przykręconymi od spodu, każde z własnym modelem mentalnym i własnymi sposobami na awarię. Pule i datasety ZFS to natywna abstrakcja, a nie dodatek: dodanie pojemności, wydzielenie nowego datasetu czy ustawienie quoty per dataset to po prostu podpolecenia zpool/zfs, bez drugiego toolchainu.

FunkcjaNTFSext4ZFS
Sumy kontrolne danychNieNieTak, każdy blok, weryfikowane przy każdym odczycie
Automatyczna samonaprawaNieNieTak, dzięki redundancji + sumom kontrolnym razem
Spójność po awariiTylko metadane w journaluTylko metadane w journaluPełne copy-on-write, bez nadpisywania w miejscu
SnapshotyVSS (ograniczone, z czasem zwalniają)Nic natywnego (wymaga LVM)Natywne, niemal natychmiastowe, tanie
KompresjaWolna, rzadko używanaNic natywnegoSzybka (lz4), domyślnie włączona
Pula storage / quotyStorage Spaces (przykręcone)LVM (przykręcone)Natywnie w systemie plików

Nic z tego nie czyni NTFS ani ext4 złymi systemami plików — są dojrzałe, dobrze poznane, a NTFS w szczególności przez lata bezbłędnie obsługiwał tamten Windows Server. Ale „bezbłędnie, o ile mi wiadomo” to dokładnie to zdanie, które powinno cię niepokoić w kontekście cichego uszkodzenia danych: cały sens polega na tym, że żaden z tych systemów plików by mi nie powiedział, gdyby do tego doszło. mdadm + LVM + ext4 mogą przybliżyć część listy funkcji ZFS przy odpowiedniej ilości taśmy klejącej i osobistej dyscypliny. ZFS po prostu to ma, z bateriami w zestawie, i nie każe ci trzymać trzech osobnych narzędzi razem siłą woli — ani ufać, że nic nigdy nie zepsuje się po cichu na tej jednej osi, której nikt nie pilnuje.

📦 Krok 1: OpenZFS na Debianie 13

Debian nie dostarcza ZFS w main z powodów licencyjnych (CDDL kontra GPL — najdłużej trwający spór w historii licencjonowania oprogramowania, starszy niż większość dysków w tej puli), więc mieszka on w contrib. Ten komponent nie jest domyślnie włączony:

# /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

To dociąga DKMS, buduje zfs.ko i spl.ko pod działające jądro (wtedy 6.12.107+deb13-amd64) i — ponieważ podpisywanie modułów dla Secure Boot to teraz norma — w locie generuje samopodpisany MOK (Machine Owner Key), żeby podpisać świeżo zbudowane moduły. Jeśli twoja maszyna ma włączony Secure Boot, przy następnym restarcie musisz zarejestrować ten MOK; ta nie miała, więc problemu nie było, ale warto wiedzieć, że DKMS po cichu, w tle, fałszuje sobie własne poświadczenia do podpisywania, jak bardzo uprzejmy i bardzo legalny fałszerz. 🔏

🏗️ Krok 2: budowa puli

Trzy dyski, RAIDZ1 (jeden dysk parzystości — właściwy wybór przy trzech dyskach; RAIDZ2 potrzebuje więcej dysków, żeby nie marnować za dużo pojemności). Jedyna zasada, na której tu naprawdę mi zależy: nigdy nie wskazuj ZFS-owi /dev/sdX. Litery urządzeń są przydzielane przy starcie i mogą się przetasować po aktualizacji jądra, zmianie w BIOS-ie albo po prostu w gorszy dzień wszechświata. Używaj zamiast tego stabilnych ścieżek z /dev/disk/by-id/, chyba że lubisz ten szczególny rodzaj horroru, w którym twój dysk parzystości po cichu staje się dyskiem z danymi:

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 mówi ZFS-owi, że to urządzenia z sektorami 4K (dyski SSD takie są bez wyjątku, nawet jeśli kłamią w firmware i zgłaszają 512-bajtowe sektory logiczne, jakby wciąż był 2009 rok). Pomyl się przy tworzeniu puli, a nie naprawisz tego później bez zniszczenia i odbudowania puli — to jedyne ustawienie w całym tym projekcie, którego naprawdę nie da się cofnąć, więc dostaje straszny pogrubiony tekst. autotrim=on ma znaczenie właśnie dlatego, że to SSD; bez niego zdajesz się na okresowy ręczny zpool trim i pozwalasz, by write amplification po cichu rosło w tle jak cholesterol warstwy storage. Efekt końcowy: trzy dyski po 2TB, ~5,45TB surowo, ~3,6TB użytkowo po parzystości RAIDZ1. Brakujące ~1,85TB nie zniknęło — to opłata na bramce za „jeden dysk może umrzeć, a ja wciąż mam swoje dane”.

🗜️ Kompresja: lz4, i dlaczego nie zstd

Kompresja w ZFS jest przezroczysta, ustawiana per dataset i — z lz4 — w zasadzie darmowa, co w języku nerdów od storage jest najbliższe darmowego obiadu, jaki ktokolwiek ci kiedyś zaproponuje. lz4 zaprojektowano tak, by był na tyle szybki, że włączenie go nigdy nie obniża przepustowości; ma też heurystykę early-abort, która natychmiast odpuszcza przy danych nieściśliwych (już skompresowane wideo, zaszyfrowane bloby), zamiast uparcie próbować i palić CPU na darmo. zstd kompresuje mocniej, ale kosztuje więcej CPU na bajt. Dla ogólnego obciążenia NAS-a — dokumenty, zdjęcia, okazjonalny obraz VM, repozytoria kodu — lz4 było oczywistym domyślnym wyborem. Gdyby to był cel kopii zapasowych z głównie tekstowymi dumpami, sięgnąłbym po zstd-3 i chętnie zapłacił podatek od CPU. Teraz, gdy są na niej prawdziwe dane zamiast syntetycznych plików do benchmarków, oto co faktycznie mi to daje — i w duchu przewodniego motywu tego wpisu uczciwa odpowiedź brzmi „niewiele”, i dokładnie tego należy się spodziewać, gdy wiesz, co tam faktycznie leży:

$ 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
DatasetLogicznie (bez kompresji)Faktycznie (na dysku)Współczynnik
storage/user31.21T1.20T1.00x
storage/user115.0G14.3G1.05x
storage/user2247G236G1.05x
storage/nextcloud385G375G1.03x

Ledwo zauważalne współczynniki, a powodem nie jest błędna konfiguracja — to same dane. Ta pula to głównie zdjęcia, filmy, pliki PST z Outlooka i już skompresowane archiwa: dokładnie ta zawartość, którą heurystyka early-abort lz4 ma rozpoznawać, żeby przestać marnować na nią CPU. To nie porażka kompresji, to kompresja działająca poprawnie i schodząca z drogi. Najbliżej faktycznych korzyści są storage/user2 i storage/user1 z 1.05x — wciąż skromnie, ale to realna, darmowa oszczędność na tej części danych, która akurat jest zbliżona do tekstu (dokumenty, pliki konfiguracyjne, narzut metadanych setek tysięcy małych plików). Gdyby ta pula trzymała dump bazy danych albo stertę plików logów zamiast rodzinnego archiwum zdjęć, ta tabela wyglądałaby dużo bardziej imponująco — i to jest właściwa lekcja: współczynnik kompresji mówi tyle samo o twoich danych, co o twoim systemie plików.

👻 Kosmetyczny bug, przez który zwątpiłem w siebie

Ustawiłem xattr=sa przy tworzeniu puli (atrybuty rozszerzone przechowywane bezpośrednio w dnode zamiast jako ukryte wpisy katalogowe — szybciej, i potrzebne dla przyzwoitej wydajności ACL). Polecenie zakończyło się kodem 0, bez skarg, bez dramatu. Potem zfs get xattr storage uparcie pokazywał on zamiast sa, za każdym razem, jakby nigdy nie słyszał o ustawieniu, które właśnie mu podałem. Okazuje się, że to znany, potwierdzony błąd wyświetlania w OpenZFS 2.3.2 (zobacz openzfs/zfs discussion #16996, jeśli chcesz krwawych szczegółów) — właściwość jest ustawiona poprawnie, zfs get po prostu pokazuje złą etykietę. Żadna błędna konfiguracja, tylko kosmetyczny szum, który na sto procent sprawi, że zwątpisz w siebie i odpalisz to samo polecenie pięć razy, zanim przyjdzie ci do głowy to wygooglować. 🕵️

🧠 Tuning ARC: zostawić RAM dla całej reszty

Adaptive Replacement Cache (ARC) w ZFS z radością zje większość twojego RAM-u, jeśli mu pozwolisz — co jest świetne na dedykowanym urządzeniu storage, a dużo mniej świetne na maszynie, która uruchamia też inne usługi i chciałaby mieć coś do powiedzenia. Bez ograniczeń ARC zachowuje się dokładnie jak nastolatek zostawiony sam na sam z lodówką: daj mu miejsce, to je zapełni, i sam z siebie niczego nie odda. Przy 31GB RAM-u łącznie ograniczyłem go:

# /etc/modprobe.d/zfs.conf
options zfs zfs_arc_max=17179869184
options zfs zfs_arc_min=2147483648

16GiB maksimum, 2GiB minimum. Zastosowane na żywo przez /sys/module/zfs/parameters/zfs_arc_max dla natychmiastowego efektu, a potem wpieczone w initramfs (update-initramfs -u -k all), żeby przetrwało restart i nie wróciło po prostu do plądrowania lodówki.

🤥 Benchmarki, czyli jak okłamywałem sam siebie przez pięć minut

Za pierwszym podejściem zrobiłem to, co robi każdy nowicjusz w ZFS, i od razu tego pożałowałem:

dd if=/dev/zero of=/storage/testfile bs=1M count=10000

8,7 GB/s zapisu. 14,1 GB/s odczytu. Na trzech dyskach SSD SATA. W sieci domowej. Przez chwilę rozważałem napisanie stanowczego posta na LinkedInie o tym, jak niedoceniane są konsumenckie SSD. Potem przypomniałem sobie, jak działa kompresja: /dev/zero produkuje nieskończony strumień zer, lz4 kompresuje ciąg zer do prawie niczego, a ja właśnie zbenchmarkowałem swój kompresor, a nie dyski. Głęboko głupie, przez chwilę ekscytujące, ostatecznie bez znaczenia — storage’owy odpowiednik mierzenia, jak szybko czytasz książkę, czytając tylko puste strony. 📖💨 Powtórzyłem to porządnie z danymi nieściśliwymi, bo okłamywanie samego siebie bawi tylko raz:

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

Uruchomiłem to porządnie drugi raz, kilka tygodni później, gdy na puli były już prawdziwe dane i — co ważne — gdy każde inne zadanie na maszynie (migracja 380GB, przeniesienie 235GB między datasetami, przebudowa ACL) faktycznie się zakończyło, a load average spadł z powrotem w okolice zera. Benchmarkowanie puli, która wciąż trawi wczorajszą robotę, mierzy tylko rywalizację o zasoby, a nie dyski.

TestWynik
Zapis, buforowany138 MB/s
Zapis, O_DIRECT15,4 MB/s
Odczyt, buforowany1,1 GB/s
Odczyt, O_DIRECT931 MB/s

Ten wiersz zapisu to nie literówka, i zaskoczył mnie na tyle, że dwa i trzy razy sprawdziłem, czy to nie rywalizacja z czymś innym, zanim w to uwierzyłem: zapisy O_DIRECT były na tej puli mniej więcej 9x wolniejsze niż zapisy buforowane, co jest przeciwieństwem intuicji, którą większość ludzi przenosi z innych systemów plików („direct I/O pomija jedną warstwę, więc powinno być szybciej”). Akurat w ZFS ta intuicja się odwraca. Ścieżka buforowana to nie tylko „cache” — to miejsce, w którym ZFS robi swoją właściwą optymalizację zapisu: przychodzące zapisy są grupowane w pamięci i zatwierdzane na vdev RAIDZ jako część transaction group, wyrównane i scalone w wydajne zapisy pełnego stripe’a. O_DIRECT z założenia pomija dokładnie tę warstwę grupowania, więc każdy zapis musi trafić prosto na vdev na własnych warunkach — co w macierzy opartej na parzystości może oznaczać mniejsze, gorzej wyrównane I/O i związany z tym narzut. Ominięcie cache’u nie omija tu żadnej faktycznej nieefektywności; omija właśnie to, co sprawiało, że zapisy były wydajne. Aktualizacja (6 października 2026): większa część tej 9-krotnej różnicy okazała się w ogóle nie być winą ZFS. Firmware serwera wyłączył własny cache zapisu dysków SSD, więc każdy niezgrupowany zapis musiał czekać na samą pamięć flash (a buforowane 138 MB/s też było niskie). Wyjaśnienie z grupowaniem poniżej nadal jest prawdziwe, ale stanowiło mniejszą część. Cała historia: Dwie rzeczy, których brakowało moim SSD: TRIM po BitLockerze i cache zapisu, który mój serwer HPE po cichu wyłączył. Wyniki odczytu dostają tę samą gwiazdkę co wcześniej: to jednowątkowa przepustowość jednego pliku, a nie realistyczny obraz łącznej wydajności puli pod równoległym obciążeniem, a obie wartości odczytu mogły być częściowo serwowane z ARC zamiast z dysku — ARC to nie to samo co page cache Linuksa, więc echo 3 > /proc/sys/vm/drop_caches nic nie robi, żeby go wyczyścić, a ścieżka odczytu O_DIRECT w OpenZFS wciąż z radością poda ci bloki z ARC, zamiast wymusić prawdziwy odczyt z dysku, jeśli dane już tam są. Traktuj wyniki pojedynczego przebiegu dd jako test zdrowego rozsądku „czy coś jest ewidentnie zepsute”, a nie jako specyfikację do wrzucenia na slajd sprzedażowy — a jeśli masz zapamiętać z tej sekcji tylko jedno, niech to będzie: „nie zakładaj, że O_DIRECT to szybka ścieżka, zanim nie zmierzysz tego na swoim konkretnym systemie plików”.

👨‍👩‍👧 Dlaczego każdy użytkownik dostaje własny dataset

Pula obsługuje trzy osoby, każdą z udziałem Samba. Korzeń udziału każdej osoby to jej własny dataset ZFS (storage/user3, storage/user1, storage/user2), a nie trzy zwykłe katalogi w jednym dużym datasecie. To nie było ustawienie domyślne, w które przypadkiem wpadłem — to świadomy wybór strukturalny i opłaca się w sposób, z którym wspólne drzewo katalogów po prostu nie ma szans:

  • Quoty. zfs set quota=500G storage/user2 ogranicza jednego użytkownika, nie ruszając pozostałych. Quota jest właściwością datasetu; katalog sam z siebie nie zna takiego pojęcia, choćbyś prosił nie wiem jak surowo.
  • Niezależne snapshoty. zfs snapshot storage/user2@before-cleanup pozwala jednej osobie cofnąć nieudany moment „usuń wszystko”, nie ciągnąc za sobą pozostałych dwóch datasetów.
  • Natychmiastowe rozliczanie zajętości. zfs list czyta zajętość miejsca prosto z metadanych datasetu. Żadnego przechodzenia drzewa, żadnego du -sh mielącego setki gigabajtów małych plików przez półtorej minuty, podczas gdy ty gapisz się na mrugający kursor i kwestionujesz swoje wybory zawodowe.
  • Czyste granice własności. Mountpoint każdego datasetu odpowiada 1:1 jego udziałowi Samba, z własnym właścicielem uniksowym. Uprawnienia systemu plików i udziału pozostają zsynchronizowane, zamiast polegać wyłącznie na sztuczkach w warstwie Samby.
  • Tuning per dataset. Kompresja, atime, record size — wszystko można nadpisać per dataset, gdyby obciążenie jednego użytkownika kiedyś uzasadniało coś innego niż domyślne ustawienia puli.
  • Granularna replikacja. zfs send/receive działa per dataset. Chcesz zrobić kopię udziału tylko jednej osoby na dysk zewnętrzny, nie ruszając pozostałych? Jedna linijka, a nie selektywna lista wykluczeń rsync trzymana w kupie żalem.

Cena za to wszystko: przenoszenie danych między datasetami przestaje być darmowe. 😬 mv w obrębie jednego datasetu to czysta zmiana nazwy — tylko metadane, natychmiast, niezależnie od rozmiaru. mv między datasetami to zupełnie inne zwierzę, nawet jeśli oba datasety leżą w tej samej puli i na tych samych fizycznych dyskach: ZFS traktuje każdy dataset jako osobny system plików, więc jądro musi faktycznie skopiować każdy bajt w nowe miejsce, a potem usunąć oryginał. Przypomniałem to sobie w zabawny sposób, rozplątując pomieszanie zagnieżdżonych folderów — spłaszczenie w obrębie tego samego datasetu skończyło się natychmiast, a przeniesienie ~235GB między datasetami ciągnęło się przez większą część godziny, robiąc w praktyce pełną kopię, podczas gdy ja wpatrywałem się w terminal bez paska postępu i zastanawiałem, czy czegoś nie zepsułem. To nie twoja wina, ZFS, to granice datasetów. Warto o tym wiedzieć, zanim odpalisz taką operację, spodziewając się trzysekundowej magii jak poprzednio.

🔑 Jeden admin, trzy udziały: dlaczego zwykły chmod tego nie umiał

Model dostępu, którego chciałem, łatwo powiedzieć na głos: każdy ma pełny dostęp do własnego folderu, a ja dodatkowo mam pełny dostęp do folderów wszystkich, zarówno na udziale Samba, jak i na surowym linuksowym systemie plików pod spodem. Łatwo powiedzieć — a potem faktycznie spróbowałem zbudować to klasycznym chmod i od razu uderzyłem w ścianę, w którą każdy sysadmin w końcu uderza: plik uniksowy ma dokładnie jednego właściciela i dokładnie jedną grupę. I tyle. To cała obsada. Wszyscy pozostali lądują w jednym wiaderku z etykietą „other”. Ten model potrafi wyrazić „właściciel ma dostęp” i „ta jedna grupa ma dostęp” — nie potrafi wyrazić „user1 ma dostęp I user3 też ma dostęp, ale user2 nie”, bo nie ma drugiego miejsca na grupę, w które dałoby się wstawić user3, bez wymyślania wspólnej grupy, decydowania, kto jeszcze może do niej później dołączyć, i nadziei, że za pół roku nikt nie doda do niej niewłaściwej osoby. Możesz to obejść, dodając user3 jako dodatkowego członka prywatnych grup user1 i user2 i ustawiając bit setgid, żeby nowe pliki dziedziczyły grupę — i dla wielu setupów to całkowicie dobra, nudna i mało pracochłonna odpowiedź. Tu mi się nie podobała z dwóch powodów: nadaje dostęp na poziomie grupy (więc zmienia się po cichu, jeśli członkostwo w grupie kiedyś zmieni się z niezwiązanego powodu), a dziedziczenie w nowych plikach zależy od bitu setgid plus umaski, której akurat używa tworzący proces — co działa, ale „działa, bo trzy osobne mechanizmy akurat poprawnie się zgrały” to nie jest zdanie, które budzi zaufanie o 2 w nocy. ACL-e POSIX rozwiązują faktyczny problem, zamiast go obchodzić: pozwalają, by plik lub katalog miał dodatkowe, jawnie nazwane wpisy użytkowników i grup poza klasyczną triadą owner/group/other. „user1 jest właścicielem, a user3 konkretnie też dostaje rwx, kropka” — bez wspólnej grupy, bez przypadkowych gapiów. Najpierw obsługę ACL trzeba włączyć per dataset (domyślnie wyłączona):

zfs set acltype=posixacl storage/user1
zfs set acltype=posixacl storage/user2

Potem samo nadanie uprawnień, w dwóch częściach — rekurencyjne nadanie dla wszystkiego, co już istnieje, i ACL default, żeby wszystko, co powstanie od teraz, automatycznie dziedziczyło tę samą regułę, bez rosyjskiej ruletki z 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

Te same dwie linijki dla /storage/user2. W połączeniu z uprawnieniami każdego folderu ustawionymi na sztywno na 750 (tylko właściciel i grupa, nic dla „other” — więc user2 i user1 kategorycznie nie mogą zawędrować do swoich danych nawzajem, nawet przypadkiem), stan końcowy to dokładnie zamierzony cel: każda osoba ma pełną swobodę we własnym folderze, ja mam pełną swobodę we wszystkich trzech, a nikt nie dostaje przypadkowych bocznych drzwi. Warto sprawdzić faktyczny efekt, zamiast ufać, że polecenie po cichu nie zrobiło nic:

$ 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::---

A po stronie Samby ta praca z ACL-ami okazała się mniej istotna, niż się spodziewałem — trzy udziały już używają force user, co sprawia, że każde połączenie z udziałem działa jako właściciel tego udziału, niezależnie od tego, kto się faktycznie uwierzytelnił. Mój dostęp do udziałów user1 i user2 przez SMB był więc już pokryty tą dyrektywą, pod warunkiem, że folder pod spodem faktycznie należy do właściwej osoby — co, w zabawnym epizodzie archeologii na własne życzenie, przez chwilę nie było prawdą (pozostałość po wcześniejszej reorganizacji zostawiła jeden dataset ze mną jako właścicielem zamiast faktycznej użytkowniczki, po cichu dając mi zapis przez SMB, którego nie zamierzałem mieć, i odbierając prawowitej właścicielce folderu jej własne domyślne uprawnienia, dopóki tego nie wyłapałem i nie naprawiłem). ACL-e zamykają konkretnie drugą lukę: zwykły dostęp przez SSH / lokalną powłokę, który w ogóle nie przechodzi przez force user i słucha wyłącznie surowych uprawnień uniksowych.

😵 „Chwila, czy to w ogóle jest jeszcze jedna pula?” — zamieszanie z df

Kilka tygodni po uruchomieniu tego wszystkiego szybkie df -h sprawiło wrażenie, że coś poszło bardzo nie tak:

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

Cztery różne wartości „Size” na puli, która ma być jednym zunifikowanym blokiem storage, działającym jak RAID5. Czy przez noc po cichu rozpadła się na osobne pule? Czy coś źle skonfigurowałem? 😱 Nie — to df, które jest technicznie poprawne w najmniej pomocny możliwy sposób. Datasety ZFS nie mają stałego rozmiaru, tak jak klasyczna partycja RAID. Kolumna „Size” w df jest liczona per mount jako Used + Available, i — to jest ta część, która naprawdę się liczy — Available jest identyczne dla każdego datasetu, bo to ta sama wspólna wolna przestrzeń w tej samej puli. Różni się tylko „Used”, bo to faktycznie jest inne dla każdej osoby. Uruchom zamiast tego zfs list i tajemnica znika:

$ 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

To samo AVAIL — 1.85T — w każdej linii, bo to jedna wspólna pula. „Rozmiar” 3.1T dla user3 w df to po prostu 1.20T zajęte + 1.85T dostępne; 1.9T dla user1 to 14.3G + 1.85T. Nic się nie pofragmentowało, nic nie zginęło — w chwili, gdy ktoś zapisze gigabajt, wspólne AVAIL spada dla wszystkich naraz, co jest dokładnie tym zachowaniem podobnym do RAID5, którego oczekiwano od początku. zpool list rozstrzyga sprawę ostatecznie:

$ 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

Jedna pula, 5.45T surowo, jeden vdev RAIDZ1, wszystkie trzy dyski w nim. df po prostu nie powstało z myślą o „wielu systemach plików dynamicznie dzielących jedną pulę pojemności” — raportuje uczciwie, tylko odpowiada na pytanie („jak duży jest ten mount”), które tutaj nie ma takiego samego zastosowania. To zfs list / zpool list są narzędziami, które faktycznie odpowiadają na pytanie „ile mam miejsca”, a nie df.

📋 Ściągawka: polecenia, których naprawdę używam na tej puli

Połowa nauki ZFS to uświadomienie sobie, że podpolecenie, którego szukasz, niemal na pewno już istnieje, zakopane pod nazwą, która z perspektywy czasu ma idealny sens. Oto zestaw roboczy dla dokładnie tego setupu — pula storage, datasety storage/user3, storage/user1, storage/user2, storage/nextcloud. Kondycja puli

# 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

Datasety: lista i zajętość miejsca

# 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

Kompresja: ile naprawdę mi daje

# 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

Quoty i rezerwacje

# 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

Snapshoty

# 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

Właściwości: get/set, forma ogólna

# 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 (cache w 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

Replikacja

# 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: czego faktycznie do tej pory potrzebowałem

Przez większość życia ta pula była nudna, i właśnie o to chodzi w ZFS — nuda to funkcja. Ale podczas budowy wyszło kilka rzeczy, które warto mieć zapisane na następny raz, odłożonych tutaj, żeby przyszły ja nie musiał uczyć się żadnej z nich dwa razy na własnej skórze. Pula jest DEGRADED albo dysk pokazuje 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 albo scrub wydaje się zawieszony / trwa wieczność

# 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 nie chce się zamontować / „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” przy przenoszeniu/zapisie do datasetu innego użytkownika Wpadłem na to bezpośrednio, przenosząc pliki user2 do jej datasetu jako uniksowy użytkownik user3 — właściciel i tryb datasetu z założenia nie dają prawa zapisu, a ZFS nie był zainteresowany moimi wymówkami. Albo wykonaj operację jako root, albo popraw własność później:

# 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

Brak modułu jądra ZFS po aktualizacji jądra Ponieważ jest budowany przez DKMS (out-of-tree), nowe jądro oznacza, że DKMS musi przebudować pod nie zfs.ko/spl.ko, zanim moduł się załaduje — zwykle dzieje się to automatycznie w ramach postinst pakietu jądra, ale to pierwsza rzecz do sprawdzenia, jeśli pula po restarcie odmawia importu, a ty przez chwilę jesteś przekonany, że straciłeś 3,6TB danych w otchłani:

# 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

Zależna usługa (GitLab, kontener, cokolwiek) startuje, zanim pula zostanie zamontowana Objaw: usługa wstaje bez problemu, ale zapisuje do pustego katalogu na głównym systemie plików zamiast do prawdziwych danych na ZFS, bo jej mountpoint nie był jeszcze gotowy przy starcie — po cichu, bez błędu, a to najgorszy rodzaj buga. Sprawdź faktyczną kolejność w systemd, zamiast zakładać, że jest w porządku:

# 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

Wolne miejsce „zniknęło”, a du tego nie wyjaśnia

# 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 zjada cały 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

🏁 Ostateczny układ

$ 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

Trzy SSD, redundancja równa jednemu dyskowi parzystości, przezroczysta kompresja, która nic nie kosztuje, i datasety per użytkownik, dzięki którym quoty, snapshoty i kopie zapasowe to jedna linijka zamiast projektu. Nieźle jak na jedno popołudnie — nawet licząc dziesięć minut walki z bugiem, który nie był prawdziwy, i pięć minut zachwytu nad benchmarkiem, który w rzeczywistości był czystą fikcją. 🎉


📚 Więcej z tej serii: NAS RAIDZ1

Część tekstów i obrazów na tej stronie powstała z pomocą AI lub została wygenerowana przez AI. Szczegóły