Allemaal lachen — we maken een snapshot! Van rdiff-backup naar ZFS op de RAIDZ1-NAS

Illustratie van ZFS-snapshots op een NAS

🌐 Ook in: English · Deutsch · Français · Español · Italiano · Português · Polski

Ik heb al twee keer over deze NAS geschreven — de opbouw met RAIDZ1 op Debian 13, en daarna het addendum over hoe scrub en trim echt worden ingepland, en de alert die er niet was.

Deze gaat over versiebeheer. Jarenlang was mijn antwoord op “hoe krijg ik de versie van gisteren van dit bestand terug” rdiff-backup, en dat is echt een goed antwoord. Het staat nog steeds op deze machine:

$ rdiff-backup --version
rdiff-backup 2.2.6

Maar door de pool op OpenZFS te bouwen kwam er een tweede mechanisme op tafel — een dat hetzelfde probleem vanuit een totaal andere richting oplost. Dus heb ik een avond besteed aan begrijpen hoe ZFS-snapshots echt werken, wat ze kosten en waar ze beter zijn dan de tool die ik tot dan toe tevreden gebruikte. Deze post is die avond, inclusief de dingen die ik de eerste keer fout deed.

Inhoud

🔄 Twee manieren om dezelfde vraag te beantwoorden

Beide tools beantwoorden “geef me de toestand van N dagen geleden”. Ze verschillen alleen fundamenteel van mening over wanneer het werk gebeurt.

rdiff-backup houdt een gewone mirror bij van de nieuwste toestand, plus omgekeerde increments in rdiff-backup-data/. Voor een backup loopt het de hele bronboom door, vergelijkt die met de mirror en berekent met librsync binaire delta’s voor alles wat veranderd is. Het werk gebeurt op het moment van de backup, en het schaalt met hoeveel data je hebt — niet met hoeveel daarvan veranderd is. Een oude versie terugzetten betekent bij de mirror beginnen en de increments achterwaarts toepassen.

ZFS-snapshots doen niets van dat alles, want het bestandssysteem weet het al. ZFS is copy-on-write: als je een blok wijzigt, overschrijft het nooit ter plekke, maar schrijft het de nieuwe versie ergens anders weg en zet de verwijzing om. Het oude blok zou normaal vrije ruimte worden.

Een snapshot zegt precies één ding: bewaar elk blok waar deze dataset nu naar wijst.

Er is niets te scannen, niets te vergelijken, niets te berekenen. Daarom ziet het aanmaken er zo uit:

$ zfs list -t snapshot -o name,used,creation
NAME                                     USED  CREATION
storage/user1@auto-2026-09-11_1250         0B  Fr Sep 11 12:50 2026
storage/user2@auto-2026-09-11_1250         0B  Fr Sep 11 12:50 2026
storage/nextcloud@auto-2026-09-11_1250     0B  Fr Sep 11 12:50 2026
storage/user3@auto-2026-09-11_1250         0B  Fr Sep 11 12:50 2026

0B. Vier snapshots die 1,8 TB dekken, gemaakt in milliseconden, en ze nemen niets in beslag. Iedereen lachte, de foto was gemaakt en de film kostte niets — want er is geen film. Een snapshot is geen kopie van je data. Het is een belofte om de huidige versie niet weg te gooien.

⚡ Is het echt sneller? Ja, maar wees precies over wat

Een snapshot maken is O(1). Het duurt dezelfde paar milliseconden of de dataset nu 14 GB of 1,17 TB bevat, want de kosten hangen helemaal niet van de data af — alleen van het bevriezen van een set verwijzingen.

rdiff-backup moet bij elke run de boom doorlopen om te ontdekken wat er veranderd is. Op storage/user3 (1,17 TB) is dat een flinke hoeveelheid I/O en tijd, zelfs in een nacht waarin niets bewoog.

Terugzetten is hetzelfde verhaal, maar omgekeerd. Elke ZFS-snapshot is een complete, direct leesbare boom — geen reconstructiestap, geen increments toepassen, geen wachten:

$ ls /storage/nextcloud/.zfs/snapshot/auto-2026-09-11_1250/
instance-a  instance-b

Dat is de toestand van dat moment, nu meteen te doorbladeren met ls, cp, rsync of een bestandsbeheerder.

Het eerlijke voorbehoud, want hier wordt de vergelijking vaak overdreven: een snapshot versioneert alleen data die al op de pool staat. Het zet niets op de NAS. Data van een server naar deze machine krijgen blijft het werk van rsync — de snapshot vervangt de versielaag, niet de overdracht. En rdiff-backup kan via SSH naar een volledig andere machine schrijven, wat snapshots categorisch niet kunnen. Daarover hieronder meer.

💾 En de ruimte?

Beide aanpakken zijn efficiënt, maar op een andere manier, en het eerlijke antwoord bevat een “het hangt ervan af”.

rdiff-backup slaat gecomprimeerde binaire delta’s op met bytegranulariteit. Verander drie rijen in een databasedump en de increment is piepklein — echt indrukwekkend voor dat patroon.

ZFS bewaart hele gewijzigde records. Op deze pool is dat 128 KB:

$ zfs get recordsize,compression,compressratio storage/nextcloud
NAME               PROPERTY       VALUE
storage/nextcloud  recordsize     128K
storage/nextcloud  compression    lz4
storage/nextcloud  compressratio  1.03x

Een wijziging van één byte in een enorm bestand houdt dus een blok van 128 KB vast, waar rdiff-backup misschien een paar honderd bytes had opgeslagen. Grover, geen discussie.

Wat ZFS daar tegenover zet:

  • Geen mirror-overhead. De nieuwste toestand van rdiff-backup is een volledige tweede kopie van alles. Snapshots delen elk ongewijzigd blok met de live data — er is helemaal geen dubbele basis.
  • Geen administratie per versie. Dertig snapshots van een ongewijzigde dataset kosten dertig keer niets.
  • lz4 over de hele linie, transparant, op live data en snapshots.

Die compressratio van 1,03x verdient een eerlijke vermelding: mijn data bestaat uit foto’s en media, al gecomprimeerd, dus lz4 levert me hier bijna niets op. Dat is geen kritiek op lz4 — het is het juiste resultaat voor deze inhoud, en op een dataset vol logs of tekst zou het er heel anders uitzien.

Netto resultaat voor typische gemengde thuis- en kantoordata: vergelijkbaar qua ruimte, dramatisch goedkoper in beheer. Voor het specifieke patroon van kleine frequente wijzigingen in heel grote bestanden winnen de delta’s per byte van rdiff-backup nog steeds op bytes.

📁 Waar snapshots wonen: de map die er niet is

Snapshots zijn geen bestanden waar je een bestandsbeheerder op kunt richten. Maar ZFS geeft je een venster dat zich als een gewone map gedraagt:

$ ls /storage/nextcloud/.zfs/snapshot/
auto-2026-09-11_1250

De valkuil waar iedereen precies één keer in trapt: .zfs is standaard verborgen en verschijnt niet in ls -la. Het is geen normale map-entry, het is synthetisch. Typ het pad toch in en het werkt.

$ zfs get snapdir storage/nextcloud
NAME               PROPERTY  VALUE     SOURCE
storage/nextcloud  snapdir   hidden    default

Alles daaronder is alleen-lezen. Je kunt een snapshot niet beschadigen door erin te bladeren en je kunt er niet per ongeluk in schrijven. Je kunt alleen eruit kopiëren — precies wat je bij een herstel wilt.

⏱️ Het script, en waarom deze keer systemd-timers

In de post over scrub en trim ontdekte ik dat Debian het ZFS-onderhoud inplant via /etc/cron.d/zfsutils-linux, met de systemd-timers wel meegeleverd maar uitgeschakeld. Voor snapshots koos ik bewust de andere weg:

[Timer]
OnCalendar=daily
RandomizedDelaySec=15m
Persistent=true

Persistent=true is de reden. Als de NAS om middernacht uit staat, slaat cron die dag gewoon over en vertelt het niemand. systemd voert de gemiste job bij de volgende boot uit. Voor iets waarvan de hele waarde is dat het bestaat voordat je het nodig hebt, is stilletjes dagen overslaan geen acceptabele manier van falen — en ik had net een hele post besteed aan dingen die stil falen.

RandomizedDelaySec spreidt de vier datasets zodat ze niet allemaal in dezelfde seconde afgaan.

Het rotatiescript doet één ding: een snapshot maken en daarna de oudste wegsnoeien tot het retentieaantal.

#!/bin/bash
# /usr/local/sbin/zfs-snapshot-rotate.sh
set -euo pipefail

DATASET="${1:?Dataset missing}"
KEEP="${2:-30}"
PREFIX="auto-"

zfs list -H -o name "$DATASET" >/dev/null 2>&1 || {
    echo "Dataset $DATASET does not exist" >&2; exit 1; }

zfs snapshot "${DATASET}@${PREFIX}$(date +%Y-%m-%d_%H%M)"

# Newest first, keep the first $KEEP, everything after that goes.
# "|| true": grep returns 1 when nothing matches yet, which is not an error.
mapfile -t old < <(
    zfs list -H -t snapshot -o name -S creation -r "$DATASET" 2>/dev/null \
      | grep -E "^${DATASET}@${PREFIX}" \
      | tail -n "+$((KEEP + 1))" || true
)

for snap in "${old[@]}"; do
    [ -n "$snap" ]                           || continue
    [[ "$snap" == "${DATASET}@${PREFIX}"* ]] || continue
    [[ "$snap" == *"@"* ]]                   || continue
    zfs destroy "$snap"
done

Drie beveiligingen voordat er iets vernietigd wordt, en dat is geen paranoia-theater. zfs destroy accepteert een snapshotnaam en een datasetnaam op precies dezelfde argumentpositie. Als $snap ooit leeg of afgekapt zou zijn, zou zfs destroy storage/user3 1,17 TB aan familiefoto’s meenemen zonder verdere vragen. De @-controle maakt dat structureel onmogelijk.

Het prefixfilter doet er ook toe: alleen snapshots die dit script heeft gemaakt, komen in aanmerking voor verwijdering. Alles wat met de hand of door een andere tool is gemaakt, is voor het script onzichtbaar.

🧪 Het destroy-pad testen, want natuurlijk test je het destroy-pad

Een ongeteste zfs destroy in een nachtelijke timer die op je eigen data gericht is, wil je niet op een ongelegen moment ontdekken. Dus voordat ik het vertrouwde, liet ik de rotatie los op de kleinste dataset met KEEP=1, zodat hij echt iets moest verwijderen:

--- before ---
storage/user1@auto-2026-09-11_1252

--- rotate with keep=1 ---

--- after ---
storage/user1@auto-2026-09-11_1253

--- dataset intact? ---
storage/user1      14.4G

Oude snapshot weg, nieuwe bewaard, dataset onaangeroerd. Geverifieerd in plaats van aangenomen.

Eén beperking kwam ik tijdens het testen tegen en heb ik bewust gehouden: namen bevatten %H%M, dus twee runs binnen dezelfde minuut botsen met “dataset already exists”. Irrelevant voor een dagelijkse timer, een puzzel van twee seconden voor wie met de hand test. Nu weet je het.

🦠 De ransomware-invalshoek, en daar betaalt dit zich echt uit

Meerdere mensen synchroniseren met mijn Nextcloud via de Windows-desktopclient — die de cloud als schijf in Verkenner koppelt. Dat is handig, en het betekent ook dat de functieomschrijving van de client is: “gewijzigde bestanden opmerken en uploaden.” Ransomware op zo’n machine versleutelt de lokale bestanden, en de client doet braaf waarvoor hij gebouwd is.

Dit is het scenario waarin het verschil tussen een mirror en een geversioneerde geschiedenis niet langer academisch is. Een pure mirror reproduceert de versleutelde toestand trouw. Een geversioneerde geschiedenis laat je erachter terugstappen.

De herstelvolgorde die echt werkt:

Stop eerst de synchronisatie. Koppel de getroffen client los, of zet Nextcloud in onderhoudsmodus. Terugzetten in een actieve synchronisatie met een geïnfecteerd endpoint zorgt er alleen voor dat je herstel opnieuw versleuteld wordt, en dan ben je ook nog tijd kwijt.

Probeer daarna de eigen lagen van Nextcloud. De prullenbak aan serverkant en het bestandsversiebeheer zijn verreweg de goedkoopste weg, en voor alles behalve een massale gebeurtenis zijn ze meestal op zichzelf genoeg.

Grijp dan naar snapshots. En hier telt precies één onderscheid:

  • zfs rollback zet de dataset ter plekke terug en vernietigt onomkeerbaar alles wat nieuwer is, ook nieuwere snapshots. Schat je het moment verkeerd in, dan is je tweede poging weg.
  • Kopiëren uit .zfs/snapshot/<name>/ verandert helemaal niets. Doe het tien keer, vergelijk de resultaten, neem je tijd.

Gebruik de tweede. Rollback is scherp gereedschap voor een ander klusje.

Je hoeft ook niet te raden wanneer de schade begon, wat mijn eerste ingeving was. ZFS vertelt het je:

$ zfs diff storage/nextcloud@auto-2026-09-10_0000 \
           storage/nextcloud@auto-2026-09-11_0000

De snapshot waarin plotseling duizenden bestanden als gewijzigd verschijnen, is die na de gebeurtenis. Neem die ervoor.

📤 Waar rdiff-backup nog steeds wint, en dat is niet niks

Snapshots wonen in de pool. Dezelfde drie schijven, hetzelfde lot. RAIDZ1 overleeft één dode schijf; het overleeft geen brand, geen diefstal, geen controller die de array meeneemt, en ook niet iemand met root die zfs destroy draait.

Snapshots beschermen dus tegen logische schade — ransomware, een verwijdering met dikke vingers, een synchronisatie die misging. Tegen fysiek verlies doen ze niets. Dat is de helft die rdiff-backup altijd goed heeft afgedekt, door via SSH naar volledig aparte hardware te schrijven.

ZFS heeft hier een eigen antwoord op, en dat combineert mooi:

$ zfs send storage/nextcloud@auto-2026-09-11_1250 > /mnt/usb/nextcloud.zfs
$ zfs send storage/nextcloud@auto-2026-09-11_1250 | zfs recv usbpool/nextcloud

zfs send -i stuurt daarna alleen de delta tussen twee snapshots, wat “een externe schijf die in een la ligt” praktisch maakt in plaats van een weekendproject.

De conclusie waar ik op uitkwam is niet “rdiff-backup vervangen”. Het is dat deze tools eigenlijk nooit met elkaar concurreerden:

  • Snapshots — directe, gratis, onbeperkte geschiedenis tegen logische schade, precies waar de data staat
  • Een kopie op aparte hardware — het enige dat het verlies van de machine zelf overleeft

🔧 De commando’s die het onthouden echt waard zijn

Inspectie:

$ zfs list -t snapshot -o name,used,creation        # what exists, how big, when
$ zfs list -o name,used,avail -r storage            # datasets and space
$ systemctl list-timers 'zfs-snapshot@*'            # when did/will it run
$ journalctl -u 'zfs-snapshot@*' --since today      # did it work

Bladeren en herstellen:

$ ls /storage/<dataset>/.zfs/snapshot/              # available points in time
$ ls /storage/<dataset>/.zfs/snapshot/auto-*/       # the files themselves
$ zfs diff <snapshot-a> <snapshot-b>                # what changed between them
$ rsync -a /storage/x/.zfs/snapshot/<snap>/foo/ /restore/foo/

Handmatige handelingen:

$ zfs snapshot storage/user3@before-something-risky
$ zfs destroy storage/user3@before-something-risky
$ zfs hold keep storage/user3@important           # protect from deletion

zfs hold wordt onderschat. Het zorgt dat een snapshot weigert vernietigd te worden totdat je hem expliciet vrijgeeft — ideaal voor die ene bekende goede toestand die elke rotatielogica moet overleven, inclusief je eigen.

⚠️ Twee dingen om te weten voordat je hierop vertrouwt

Retentie is een echte grens. Hier dertig dagen. Een incident dat langer onopgemerkt blijft, roteert buiten bereik. Comfortabel voor een actief gebruikt systeem; voor koude archieven voeg je beter een maandelijkse laag toe dan te hopen.

Snapshots volgen datasets, geen mappen. Deze ving mij toen ik mijn eigen werk controleerde. /storage bevat vier datasets — en één gewone map die geen dataset is en daardoor stilletjes niets krijgt:

$ zfs list /storage/gitlab-migration
NAME      USED  AVAIL  REFER  MOUNTPOINT
storage   1.78T  1.73T   160K  /storage

Hij werd opgelost naar de ouder, niet naar zichzelf. Doe morgen mkdir /storage/something en die map erft geen enkel snapshotbeleid, zonder waarschuwing. Gebruik in plaats daarvan zfs create storage/something en hij krijgt alles zelf — snapshots, quota, properties. Kost niets, en het is het verschil tussen bescherming die je hebt en bescherming die je aanneemt.

De echte les

Wat me het meest opviel, was niet de ruimte-efficiëntie of zelfs de snelheid. Het was waar het werk gebeurt.

rdiff-backup moet, zoals bijna elke backuptool, gaan uitzoeken wat er veranderd is — bomen doorlopen, vergelijken, berekenen. Dat is een enorme hoeveelheid moeite om iets opnieuw te ontdekken dat het bestandssysteem in realtime zag gebeuren en daarna vergat.

ZFS vergeet niet. Copy-on-write betekent dat de informatie er al was; een snapshot weigert alleen om ze weg te gooien. Daarom is het direct, en daarom kost het niets totdat er echt iets verandert.

Een goede herinnering dat de interessante vraag over infrastructuur meestal niet is “welke tool is beter”. Het is “wie weet het antwoord al, en vraag ik het hem — of reken ik het elke nacht om 3 uur opnieuw uit?”


📚 Meer in deze serie: de RAIDZ1-NAS

Sommige teksten en afbeeldingen op deze site zijn met hulp van AI gemaakt of door AI gegenereerd. Details