Todo mundo sorrindo — vamos tirar um snapshot! Do rdiff-backup para ZFS no NAS RAIDZ1

Ilustração de snapshots ZFS em um NAS

🌐 Também em: English · Deutsch · Français · Español · Italiano · Nederlands · Polski

Já escrevi duas vezes sobre este NAS — a montagem com RAIDZ1 no Debian 13 e depois o adendo sobre como scrub e trim são realmente agendados, e o alerta que não existia.

Este aqui é sobre versionamento. Por anos, minha resposta para “como eu recupero a versão de ontem deste arquivo” foi o rdiff-backup, e é uma resposta realmente boa. Ele continua instalado nesta máquina:

$ rdiff-backup --version
rdiff-backup 2.2.6

Mas montar o pool em OpenZFS colocou um segundo mecanismo na mesa — um que resolve o mesmo problema por uma direção completamente diferente. Então passei uma noite entendendo como os snapshots ZFS funcionam de verdade, quanto custam e onde superam a ferramenta que eu vinha usando feliz da vida. Este post é essa noite, incluindo as partes que errei na primeira tentativa.

Índice

🔄 Duas formas de responder à mesma pergunta

As duas ferramentas respondem “me dá o estado de N dias atrás”. Elas só discordam fundamentalmente sobre quando o trabalho acontece.

O rdiff-backup mantém um espelho simples do estado mais recente, mais incrementos reversos em rdiff-backup-data/. Para fazer um backup, ele percorre toda a árvore de origem, compara com o espelho e calcula deltas binários com a librsync para o que tiver mudado. O trabalho acontece na hora do backup e escala com a quantidade de dados que você tem — não com o quanto deles mudou. Restaurar uma versão antiga significa partir do espelho e aplicar os incrementos de trás para frente.

Os snapshots ZFS não fazem nada disso, porque o sistema de arquivos já sabe. O ZFS é copy-on-write: quando você modifica um bloco, ele nunca sobrescreve no lugar; grava a nova versão em outro ponto e redireciona a referência. O bloco antigo normalmente viraria espaço livre.

Um snapshot diz exatamente uma coisa: guarde todos os blocos para os quais este dataset aponta agora.

Não há nada para varrer, nada para comparar, nada para calcular. Por isso criar um fica assim:

$ 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. Quatro snapshots cobrindo 1,8 TB, tirados em milissegundos, ocupando nada. Todo mundo sorriu, a foto foi tirada e o filme não custou nada — porque não existe filme. Um snapshot não é uma cópia dos seus dados. É a promessa de não jogar fora a versão atual.

⚡ É mais rápido mesmo? Sim, mas seja preciso sobre o quê

Criar um snapshot é O(1). Leva os mesmos poucos milissegundos se o dataset tem 14 GB ou 1,17 TB, porque o custo não depende dos dados — só de congelar um conjunto de referências.

O rdiff-backup precisa percorrer a árvore em cada execução para descobrir o que mudou. Em storage/user3 (1,17 TB) isso é uma quantidade considerável de I/O e de tempo, mesmo numa noite em que nada mudou.

A restauração é a mesma história ao contrário. Cada snapshot ZFS é uma árvore completa e legível diretamente — sem etapa de reconstrução, sem aplicar incrementos, sem espera:

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

Esse é o estado daquele momento, navegável agora mesmo com ls, cp, rsync ou um gerenciador de arquivos.

A ressalva honesta, porque é aqui que a comparação costuma ser exagerada: um snapshot só versiona dados que já estão no pool. Ele não move nada para o NAS. Levar dados de um servidor para esta máquina continua sendo trabalho do rsync — o snapshot substitui a camada de versionamento, não a transferência. E o rdiff-backup consegue gravar numa máquina totalmente diferente via SSH, o que snapshots categoricamente não conseguem. Mais sobre isso abaixo.

💾 E o espaço?

As duas abordagens são eficientes, mas de jeitos diferentes, e a resposta honesta tem um “depende” no meio.

O rdiff-backup guarda deltas binários comprimidos com granularidade de byte. Mude três linhas num dump de banco de dados e o incremento é minúsculo — realmente impressionante para esse padrão.

O ZFS retém records inteiros que mudaram. Neste pool são 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

Então uma mudança de um byte num arquivo enorme segura um bloco de 128 KB, onde o rdiff-backup talvez tivesse guardado algumas centenas de bytes. Mais grosseiro, sem discussão.

O que o ZFS entrega em troca:

  • Nenhum overhead de espelho. O estado mais recente do rdiff-backup é uma segunda cópia completa de tudo. Snapshots compartilham cada bloco inalterado com os dados ativos — não existe linha de base duplicada.
  • Nenhuma contabilidade por versão. Trinta snapshots de um dataset inalterado custam trinta vezes nada.
  • lz4 em tudo, de forma transparente, tanto nos dados ativos quanto nos snapshots.

Aquele compressratio de 1,03x merece ser apontado com honestidade: meus dados são fotos e mídia, já comprimidos, então o lz4 quase não me rende nada aqui. Não é crítica ao lz4 — é o resultado correto para esse conteúdo, e seria bem diferente num dataset cheio de logs ou texto.

Resultado líquido para dados típicos misturados de casa e escritório: comparável em espaço, dramaticamente mais barato na operação. Para o padrão específico de pequenas mudanças frequentes dentro de arquivos muito grandes, os deltas por byte do rdiff-backup ainda ganham em bytes.

📁 Onde os snapshots moram: o diretório que não está lá

Snapshots não são arquivos para os quais você aponta um gerenciador de arquivos. Mas o ZFS dá uma janela que se comporta como um diretório comum:

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

A pegadinha que derruba todo mundo exatamente uma vez: .zfs fica oculto por padrão e não aparece no ls -la. Não é uma entrada de diretório normal, é sintética. Digite o caminho mesmo assim e funciona.

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

Tudo ali dentro é somente leitura. Você não consegue estragar um snapshot navegando nele e não consegue gravar nele sem querer. Só dá para copiar para fora — exatamente o que você quer durante uma recuperação.

⏱️ O script, e por que timers do systemd desta vez

No post sobre scrub e trim descobri que o Debian agenda a manutenção do ZFS via /etc/cron.d/zfsutils-linux, com os timers do systemd incluídos, mas desativados. Para os snapshots fui deliberadamente pelo outro caminho:

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

Persistent=true é o motivo. Se o NAS estiver desligado à meia-noite, o cron simplesmente pula aquele dia e não avisa ninguém. O systemd executa o job perdido no próximo boot. Para algo cujo valor inteiro é existir antes de você precisar, pular dias em silêncio não é um modo de falha aceitável — e eu tinha acabado de gastar um post inteiro com coisas que falham em silêncio.

RandomizedDelaySec escalona os quatro datasets para que não disparem todos no mesmo segundo.

O script de rotação faz uma única coisa: tira um snapshot e depois apaga os mais antigos até a contagem de retenção.

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

Três guardas antes de qualquer coisa ser destruída, e não é teatro de paranoia. zfs destroy aceita um nome de snapshot e um nome de dataset exatamente na mesma posição de argumento. Se $snap algum dia estivesse vazio ou truncado, zfs destroy storage/user3 levaria 1,17 TB de fotos da família junto, sem fazer nenhuma pergunta. A verificação do @ torna isso estruturalmente impossível.

O filtro de prefixo também importa: só snapshots criados por este script podem ser apagados. Qualquer coisa tirada à mão, ou por outra ferramenta, é invisível para ele.

🧪 Testando o caminho do destroy, porque é claro que você testa o caminho do destroy

Um zfs destroy não testado dentro de um timer noturno apontado para os seus próprios dados não é algo que você queira descobrir num momento inconveniente. Então, antes de confiar nele, rodei a rotação no menor dataset com KEEP=1, forçando-o a apagar algo de verdade:

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

Snapshot antigo apagado, o novo mantido, dataset intacto. Verificado em vez de presumido.

Uma limitação que encontrei nos testes e decidi manter: os nomes levam %H%M, então duas execuções no mesmo minuto colidem com “dataset already exists”. Irrelevante para um timer diário, um enigma de dois segundos para quem testa à mão. Agora você sabe.

🦠 O ângulo do ransomware, que é onde isso realmente compensa

Várias pessoas sincronizam com o meu Nextcloud pelo cliente desktop do Windows — aquele que monta a nuvem como unidade no Explorer. É prático, e também significa que a descrição do trabalho do cliente é “perceber arquivos alterados e enviá-los”. Um ransomware numa máquina dessas criptografa os arquivos locais, e o cliente faz obedientemente aquilo para que foi feito.

É nesse cenário que a diferença entre um espelho e um histórico versionado deixa de ser acadêmica. Um espelho puro reproduz fielmente o estado criptografado. Um histórico versionado permite voltar para antes dele.

A ordem de recuperação que funciona de verdade:

Pare a sincronização primeiro. Desconecte o cliente afetado ou coloque o Nextcloud em modo de manutenção. Restaurar dentro de uma sincronização ativa com um endpoint infectado só faz sua restauração ser criptografada de novo, e agora você também perdeu tempo.

Depois tente as camadas do próprio Nextcloud. A lixeira do lado do servidor e o versionamento de arquivos são de longe o caminho mais barato, e para qualquer coisa abaixo de um evento em massa costumam bastar sozinhos.

Aí recorra aos snapshots. E aqui exatamente uma distinção importa:

  • zfs rollback reseta o dataset no lugar e destrói irreversivelmente tudo o que for mais novo, incluindo snapshots mais novos. Erre o momento e sua segunda tentativa já era.
  • Copiar de .zfs/snapshot/<name>/ não muda absolutamente nada. Faça dez vezes, compare os resultados, sem pressa.

Use a segunda opção. Rollback é uma ferramenta afiada para outro trabalho.

Você também não precisa adivinhar quando o estrago começou, que foi meu primeiro instinto. O ZFS te conta:

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

O snapshot em que milhares de arquivos aparecem de repente como modificados é o depois do evento. Pegue o anterior.

📤 Onde o rdiff-backup ainda ganha, e não é pouca coisa

Snapshots moram no pool. Os mesmos três discos, o mesmo destino. RAIDZ1 sobrevive a um disco morto; não sobrevive a um incêndio, a um roubo, a uma controladora que leva o array junto, nem a alguém com root rodando zfs destroy.

Então snapshots protegem contra danos lógicos — ransomware, uma exclusão por dedo gordo, uma sincronização que deu errado. Não fazem nada contra perda física. Essa é a metade que o rdiff-backup sempre cobriu bem, gravando via SSH em hardware totalmente separado.

O ZFS tem a sua própria resposta para isso, e ela se encaixa bem:

$ 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 então envia só o delta entre dois snapshots, o que torna o “disco externo que mora numa gaveta” algo prático em vez de um projeto de fim de semana.

A conclusão a que cheguei não é “substituir o rdiff-backup”. É que essas ferramentas nunca estiveram realmente competindo:

  • Snapshots — histórico instantâneo, gratuito e ilimitado contra danos lógicos, bem onde os dados estão
  • Uma cópia em hardware separado — a única coisa que sobrevive à perda da própria máquina

🔧 Os comandos que realmente vale a pena lembrar

Inspeção:

$ 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

Navegação e recuperação:

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

Operações manuais:

$ 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 é subestimado. Ele faz um snapshot se recusar a ser destruído até você liberá-lo explicitamente — ideal para aquele estado reconhecidamente bom que você quer que sobreviva a qualquer lógica de rotação, incluindo a sua.

⚠️ Duas coisas para saber antes de confiar nisso

A retenção é um limite real. Trinta dias aqui. Um incidente que passar despercebido por mais tempo sai do alcance pela rotação. Confortável para um sistema em uso ativo; para arquivos frios, adicione uma camada mensal em vez de torcer.

Snapshots seguem datasets, não diretórios. Essa me pegou enquanto eu conferia meu próprio trabalho. /storage contém quatro datasets — e um diretório comum que não é dataset e, portanto, silenciosamente não recebe nada:

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

Ele resolveu para o pai, não para si mesmo. Faça mkdir /storage/something amanhã e ele não herda nenhuma política de snapshot, sem aviso. Use zfs create storage/something e ele ganha tudo próprio — snapshots, quotas, propriedades. Não custa nada, e é a diferença entre a proteção que você tem e a proteção que você supõe ter.

A lição de verdade

O que mais me chamou a atenção fazendo isso não foi a eficiência de espaço nem mesmo a velocidade. Foi onde o trabalho acontece.

O rdiff-backup, como quase toda ferramenta de backup, precisa ir lá descobrir o que mudou — percorrendo árvores, comparando, calculando. É um esforço enorme gasto para redescobrir algo que o sistema de arquivos viu acontecer em tempo real e depois esqueceu.

O ZFS não esquece. Copy-on-write significa que a informação já estava lá; um snapshot só se recusa a descartá-la. Por isso é instantâneo, e por isso não custa nada até que algo realmente mude.

O que é um bom lembrete de que a pergunta interessante sobre infraestrutura normalmente não é “qual ferramenta é melhor”. É “quem já sabe a resposta, e estou perguntando a ele — ou recalculando tudo toda noite às 3 da manhã?”


📚 Mais nesta série: o NAS RAIDZ1

Alguns textos e imagens deste site foram criados com a ajuda de IA ou gerados por IA. Detalhes