Sorridete tutti — facciamo uno snapshot! Da rdiff-backup a ZFS sul NAS RAIDZ1

Illustrazione degli snapshot ZFS su un NAS

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

Di questo NAS ho già scritto due volte — la costruzione con RAIDZ1 su Debian 13, e poi l’aggiunta su come scrub e trim vengono davvero pianificati, e l’alert che non c’era.

Questo parla di versioning. Per anni la mia risposta a “come recupero la versione di ieri di questo file” è stata rdiff-backup, ed è una risposta davvero buona. È ancora installato su questa macchina:

$ rdiff-backup --version
rdiff-backup 2.2.6

Ma costruire il pool su OpenZFS ha messo sul tavolo un secondo meccanismo — uno che risolve lo stesso problema da una direzione completamente diversa. Così ho passato una serata a capire come funzionano davvero gli snapshot ZFS, quanto costano e dove battono lo strumento che usavo felicemente. Questo post è quella serata, comprese le parti che ho sbagliato al primo tentativo.

Indice

🔄 Due modi di rispondere alla stessa domanda

Entrambi gli strumenti rispondono a “dammi lo stato di N giorni fa”. Sono solo radicalmente in disaccordo su quando si fa il lavoro.

rdiff-backup tiene un semplice mirror dello stato più recente, più incrementi inversi in rdiff-backup-data/. Per fare un backup percorre l’intero albero sorgente, lo confronta con il mirror e calcola delta binari con librsync per tutto ciò che è cambiato. Il lavoro avviene al momento del backup, e cresce con la quantità di dati che hai — non con quanta parte è cambiata. Ripristinare una vecchia versione significa partire dal mirror e applicare gli incrementi all’indietro.

Gli snapshot ZFS non fanno niente di tutto questo, perché il filesystem lo sa già. ZFS è copy-on-write: quando modifichi un blocco non sovrascrive mai sul posto, scrive la nuova versione altrove e sposta il puntatore. Il vecchio blocco diventerebbe normalmente spazio libero.

Uno snapshot dice esattamente una cosa: tieni ogni blocco a cui questo dataset punta adesso.

Non c’è niente da scansionare, niente da confrontare, niente da calcolare. Ed è per questo che crearne uno appare così:

$ 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. Quattro snapshot che coprono 1,8 TB, fatti in millisecondi, che non occupano nulla. Tutti hanno sorriso, la foto è stata scattata e la pellicola non è costata niente — perché non c’è pellicola. Uno snapshot non è una copia dei tuoi dati. È la promessa di non buttare via la versione attuale.

⚡ È davvero più veloce? Sì, ma sii preciso su cosa

La creazione di uno snapshot è O(1). Richiede gli stessi pochi millisecondi che il dataset contenga 14 GB o 1,17 TB, perché il costo non dipende affatto dai dati — solo dal congelare un insieme di riferimenti.

rdiff-backup deve attraversare l’albero a ogni singola esecuzione per scoprire cosa è cambiato. Su storage/user3 (1,17 TB) è una quantità notevole di I/O e di tempo reale anche in una notte in cui non si è mosso niente.

Il ripristino è la stessa storia al contrario. Ogni snapshot ZFS è un albero completo, leggibile direttamente — nessun passo di ricostruzione, nessun incremento da applicare, nessuna attesa:

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

Quello è lo stato di quel momento, sfogliabile subito con ls, cp, rsync o un file manager.

L’avvertenza onesta, perché è qui che il confronto viene gonfiato: uno snapshot versiona solo dati che sono già nel pool. Non sposta niente sul NAS. Portare i dati da un server su questa macchina resta compito di rsync — lo snapshot sostituisce il livello di versioning, non il trasferimento. E rdiff-backup può scrivere su una macchina completamente diversa via SSH, cosa che gli snapshot categoricamente non possono fare. Ne parlo più sotto.

💾 E lo spazio?

Entrambi gli approcci sono efficienti, ma in modo diverso, e la risposta onesta contiene un “dipende”.

rdiff-backup salva delta binari compressi con granularità al byte. Cambia tre righe in un dump di database e l’incremento è minuscolo — davvero impressionante per quel tipo di modifica.

ZFS conserva interi record modificati. Su questo pool sono 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

Quindi una modifica di un byte a un file enorme trattiene un blocco da 128 KB, dove rdiff-backup avrebbe salvato forse qualche centinaio di byte. Più grossolano, nessuna discussione.

Cosa ottiene ZFS in cambio:

  • Nessun overhead del mirror. Lo stato più recente di rdiff-backup è una seconda copia completa di tutto. Gli snapshot condividono ogni blocco non modificato con i dati live — non c’è nessuna baseline duplicata.
  • Nessuna contabilità per versione. Trenta snapshot di un dataset invariato costano trenta volte niente.
  • lz4 ovunque, in modo trasparente, su dati live e snapshot allo stesso modo.

Quel compressratio di 1.03x merita di essere indicato onestamente: i miei dati sono foto e media, già compressi, quindi qui lz4 mi fa guadagnare quasi niente. Non è una critica a lz4 — è il risultato corretto per questo contenuto, e su un dataset pieno di log o testo apparirebbe molto diverso.

Risultato netto per i tipici dati misti casa-e-ufficio: paragonabile sullo spazio, enormemente più economico nella gestione. Per il caso specifico di piccole modifiche frequenti dentro file molto grandi, i delta a livello di byte di rdiff-backup vincono ancora sui byte.

📁 Dove vivono gli snapshot: la directory che non c’è

Gli snapshot non sono file su cui puoi puntare un file manager. Ma ZFS ti dà una finestra che si comporta come una directory normale:

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

Il tranello in cui cascano tutti esattamente una volta: .zfs è nascosta di default e non compare in ls -la. Non è una normale voce di directory, è sintetica. Scrivi comunque il percorso e funziona.

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

Tutto lì sotto è in sola lettura. Non puoi danneggiare uno snapshot sfogliandolo e non puoi scriverci dentro per sbaglio. Puoi solo copiare fuori — che è esattamente ciò che vuoi durante un ripristino.

⏱️ Lo script, e perché stavolta i timer systemd

Nel post su scrub e trim ho scoperto che Debian pianifica la manutenzione ZFS tramite /etc/cron.d/zfsutils-linux, con i timer systemd forniti ma disabilitati. Per gli snapshot sono andato volutamente nell’altra direzione:

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

Il motivo è Persistent=true. Se il NAS è spento a mezzanotte, cron salta semplicemente quel giorno e non lo dice a nessuno. systemd esegue il job mancato al boot successivo. Per qualcosa il cui intero valore è esistere prima che ti serva, saltare giorni in silenzio non è un modo di fallire accettabile — e avevo appena passato un intero post su cose che falliscono in silenzio.

RandomizedDelaySec scagliona i quattro dataset così non scattano tutti nello stesso secondo.

Lo script di rotazione fa un solo lavoro: fare uno snapshot, poi sfoltire i più vecchi fino al numero di retention.

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

Tre protezioni prima che venga distrutto qualunque cosa, e non sono teatro della paranoia. zfs destroy accetta un nome di snapshot e un nome di dataset esattamente nella stessa posizione dell’argomento. Se $snap fosse mai vuoto o troncato, zfs destroy storage/user3 si porterebbe via 1,17 TB di foto di famiglia senza fare altre domande. Il controllo sulla @ lo rende strutturalmente impossibile.

Anche il filtro sul prefisso conta: solo gli snapshot creati da questo script possono essere cancellati. Tutto ciò che è stato fatto a mano, o da un altro strumento, per lui è invisibile.

🧪 Testare il percorso di destroy, perché ovviamente il percorso di destroy lo testi

Uno zfs destroy mai testato dentro un timer notturno puntato sui tuoi dati non è qualcosa che vuoi scoprire in un momento scomodo. Quindi prima di fidarmi ho fatto girare la rotazione sul dataset più piccolo con KEEP=1, costringendola a cancellare davvero qualcosa:

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

Vecchio snapshot sparito, nuovo mantenuto, dataset intatto. Verificato invece che dato per scontato.

Una limitazione in cui sono incappato durante i test e che ho deciso di tenere: i nomi contengono %H%M, quindi due esecuzioni nello stesso minuto si scontrano con “dataset already exists”. Irrilevante per un timer giornaliero, un rompicapo di due secondi per chi testa a mano. Ora lo sai.

🦠 Il discorso ransomware, ed è qui che rende davvero

Diverse persone sincronizzano con il mio Nextcloud tramite il client desktop Windows — quello che monta il cloud come unità in Explorer. È comodo, e significa anche che il mansionario del client è “accorgiti dei file modificati, caricali.” Un ransomware su una macchina del genere cifra i file locali, e il client fa diligentemente ciò per cui è stato costruito.

Questo è lo scenario in cui la differenza tra un mirror e una cronologia versionata smette di essere accademica. Un mirror puro riproduce fedelmente lo stato cifrato. Una cronologia versionata ti permette di tornare indietro oltre quel punto.

L’ordine di ripristino che funziona davvero:

Prima ferma la sincronizzazione. Scollega il client colpito, o metti Nextcloud in maintenance mode. Ripristinare dentro una relazione di sync attiva con un endpoint infetto fa solo ricifrare il tuo ripristino, e in più hai perso tempo.

Poi prova i livelli propri di Nextcloud. Cestino lato server e versioning dei file sono di gran lunga la via più economica, e per tutto ciò che non sia un evento di massa di solito bastano da soli.

Poi ricorri agli snapshot. E qui conta esattamente una distinzione:

  • zfs rollback riporta il dataset indietro sul posto e distrugge irreversibilmente tutto ciò che è più recente, compresi gli snapshot più recenti. Sbagli la tempistica e il tuo secondo tentativo non c’è più.
  • Copiare fuori da .zfs/snapshot/<name>/ non cambia assolutamente niente. Fallo dieci volte, confronta i risultati, prenditi il tuo tempo.

Usa la seconda. Il rollback è uno strumento affilato per un altro lavoro.

Inoltre non devi indovinare quando è iniziato il danno, che era il mio primo istinto. Te lo dice ZFS:

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

Lo snapshot in cui migliaia di file risultano improvvisamente modificati è quello dopo l’evento. Prendi quello prima.

📤 Dove rdiff-backup vince ancora, e non è poco

Gli snapshot vivono nel pool. Stessi tre dischi, stesso destino. RAIDZ1 sopravvive a un disco morto; non sopravvive a un incendio, a un furto, a un controller che si porta via l’array, o a qualcuno con root che lancia zfs destroy.

Quindi gli snapshot difendono dal danno logico — ransomware, una cancellazione col dito sbagliato, una sync andata storta. Non fanno niente contro la perdita fisica. Quella è la metà che rdiff-backup ha sempre coperto bene, scrivendo via SSH su hardware completamente separato.

ZFS ha la sua risposta anche qui, e si combina bene:

$ 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 poi spedisce solo il delta tra due snapshot, il che rende il “disco esterno che vive in un cassetto” una cosa pratica invece di un progetto da weekend.

La conclusione a cui sono arrivato non è “sostituire rdiff-backup”. È che questi strumenti non sono mai stati davvero in competizione:

  • Snapshot — cronologia istantanea, gratuita, illimitata contro i danni logici, proprio dove vivono i dati
  • Una copia su hardware separato — l’unica cosa che sopravvive alla perdita della macchina stessa

🔧 I comandi che vale davvero la pena ricordare

Ispezione:

$ 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

Sfogliare e ripristinare:

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

Operazioni manuali:

$ 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 è sottovalutato. Fa sì che uno snapshot si rifiuti di essere distrutto finché non lo rilasci esplicitamente — ideale per quell’unico stato sicuramente buono che vuoi far sopravvivere a qualsiasi logica di rotazione, compresa la tua.

⚠️ Due cose da sapere prima di affidarti a questo

La retention è un confine reale. Qui trenta giorni. Un incidente non notato per più tempo esce dalla portata con la rotazione. Comodo per un sistema usato attivamente; per archivi freddi aggiungi un livello mensile invece di sperare.

Gli snapshot seguono i dataset, non le directory. Questo mi ha colto mentre controllavo il mio stesso lavoro. /storage contiene quattro dataset — e una directory semplice che non è un dataset, e che quindi in silenzio non riceve niente:

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

Si è risolto nel genitore, non in se stesso. Fai mkdir /storage/something domani e non eredita nessuna policy di snapshot, senza alcun avviso. Usa invece zfs create storage/something e ottiene tutto il suo — snapshot, quote, proprietà. Non costa niente, ed è la differenza tra la protezione che hai e quella che presumi di avere.

Il vero insegnamento

Ciò che mi ha colpito di più facendo tutto questo non è stata l’efficienza di spazio e nemmeno la velocità. È stato dove avviene il lavoro.

rdiff-backup, come quasi ogni strumento di backup, deve andare a scoprire cosa è cambiato — percorrendo alberi, confrontando, calcolando. È un’enorme quantità di fatica spesa per riscoprire qualcosa che il filesystem ha visto succedere in tempo reale e poi ha dimenticato.

ZFS non dimentica. Copy-on-write significa che l’informazione c’era già; uno snapshot si limita a rifiutarsi di scartarla. Per questo è istantaneo, e per questo non costa niente finché qualcosa non cambia davvero.

Il che è un buon promemoria: la domanda interessante sull’infrastruttura di solito non è “quale strumento è migliore”. È “chi conosce già la risposta, e la sto chiedendo a lui — o la ricalcolo ogni notte alle 3?”


📚 Altro in questa serie: il NAS RAIDZ1

Alcuni testi e immagini di questo sito sono creati con l’aiuto dell’IA o generati dall’IA. Dettagli