Entenda ZFS no Fedora 42: backups KVM e recuperação eficiente

18 min de leitura  ·  Guia técnico

ZFS no Fedora 42 com KVM é uma combinação poderosa para ambientes de virtualização que exigem backups consistentes e recuperação rápida. O ZFS oferece snapshots copy-on-write instantâneos que, combinados com o gerenciador de VMs libvirt/KVM, permitem proteger discos virtuais sem downtime prolongado. Para implementar o fluxo completo, siga estes passos:

1. Instale o módulo ZFS via repositório OpenZFS no Fedora 42
2. Crie um pool ZFS dedicado para armazenar os volumes de disco das VMs KVM
3. Configure as VMs para usar volumes ZFS como discos virtuais
4. Escreva o script de backup que pausa a VM, cria o snapshot e retoma a execução
5. Agende o script via cron para execução automática diária
6. Teste o rollback e o envio remoto do snapshot para validar a recuperação

Pré-requisitos

• Fedora 42 instalado com acesso root ou sudo
• KVM/QEMU e libvirt instalados (dnf groupinstall "Virtualization")
• Pelo menos um disco ou partição disponível para criar o pool ZFS
• Repositório RPM Fusion Free habilitado (necessário para zfs-dkms)
• Utilitário virsh funcionando — confirme com virsh list --all
• Kernel headers instalados para compilação do módulo DKMS
• Conexão SSH configurada se o destino do backup for um servidor remoto

Instalando o ZFS no Fedora 42 via OpenZFS

O suporte a ZFS no Fedora 42 depende do módulo zfs-dkms fornecido pelo projeto OpenZFS, pois a licença CDDL é incompatível com a GPL do kernel Linux e impede inclusão nativa. O processo de instalação compila o módulo para o kernel vigente usando DKMS, garantindo recompilação automática em atualizações de kernel.

Primeiro, habilite o repositório oficial do OpenZFS para Fedora:

dnf install -y https://zfsonlinux.org/fedora/zfs-release-2-5$(rpm --eval "%{dist}").noarch.rpm

Instale as dependências de compilação e o pacote zfs:

dnf install -y kernel-devel zfs zfs-dkms

Após a compilação do módulo via DKMS (pode levar alguns minutos), carregue o módulo manualmente:

modprobe zfs

Verifique se o módulo foi carregado com sucesso:

lsmod | grep zfs

zfs                  4554752  0
zunicode              335872  1 zfs
zzstd                 585728  1 zfs
zavl                   32768  1 zfs
icp                   393216  1 zfs
zcommon                98304  2 zfs,icp
znvpair               114688  2 zfs,zcommon
spl                   139264  7 zfs,zavl,zzstd,zunicode,icp,zcommon,znvpair

Para que o ZFS seja carregado automaticamente a cada boot, adicione o módulo ao carregamento do sistema:

echo "zfs" > /etc/modules-load.d/zfs.conf

Criando o pool ZFS para volumes de VMs KVM

Com o módulo ZFS ativo, o próximo passo é criar um zpool dedicado para hospedar os discos virtuais das VMs. Usar um pool separado facilita o gerenciamento de snapshots e evita interferências com o sistema de arquivos raiz. Neste exemplo, usaremos o disco /dev/sdb — ajuste conforme sua topologia.

Atenção: o comando abaixo destrói todos os dados existentes no disco especificado. Confirme o nome correto do dispositivo com lsblk antes de prosseguir.

lsblk -o NAME,SIZE,TYPE,MOUNTPOINT

Crie o pool chamado vmpool:

zpool create -f vmpool /dev/sdb

Verifique o estado do pool:

zpool status vmpool

  pool: vmpool
 state: ONLINE
config:
        NAME        STATE     READ WRITE CKSUM
        vmpool      ONLINE       0     0     0
          sdb       ONLINE       0     0     0
errors: No known data errors

Crie um dataset específico para discos de VMs:

zfs create vmpool/vms

Para melhor performance com QCOW2 ou raw images, ajuste o recordsize do dataset para 64K, que se alinha melhor com I/O de discos virtuais:

zfs set recordsize=64K vmpool/vms

Habilite a compressão lz4, que tem overhead mínimo e reduz uso de espaço em discos VM:

zfs set compression=lz4 vmpool/vms

Configurando VMs KVM para usar volumes ZFS

Para aproveitar os snapshots ZFS com consistência de dados para VMs KVM, o disco virtual da VM deve residir dentro do pool ZFS. A forma mais eficiente é usar volumes ZFS (zvols) ou arquivos de imagem raw armazenados no dataset. Zvols são recomendados para melhor performance com virtio.

Crie um zvol de 50GB para uma VM chamada web-server:

zfs create -V 50G vmpool/vms/web-server-disk

O zvol ficará disponível em /dev/zvol/vmpool/vms/web-server-disk. Para anexar ao XML da VM via virsh:

virsh edit web-server

Adicione o seguinte bloco dentro da seção <devices> do XML da VM:

<disk type="block" device="disk">
  <driver name="qemu" type="raw" cache="none" io="native"/>
  <source dev="/dev/zvol/vmpool/vms/web-server-disk"/>
  <target dev="vdb" bus="virtio"/>
</disk>

Reinicie a VM para que o novo disco seja reconhecido:

virsh reboot web-server

Para VMs que já existem com discos em outros locais, utilize virsh domblklist web-server para listar os discos atuais e planeje a migração copiando a imagem existente para o dataset ZFS antes de alterar o XML. Consulte o artigo sobre Dicas de Otimização de Servidores Linux para ajustes adicionais de performance no host KVM.

Criando snapshots ZFS e realizando backups de VMs KVM

A rotina de backup de VMs KVM com ZFS baseia-se em três etapas: pausar a VM para garantir consistência do sistema de arquivos do guest, capturar o snapshot ZFS e retomar a VM. O intervalo de pausa é geralmente inferior a um segundo para snapshots locais, minimizando o impacto no serviço.

Pause a VM antes do snapshot para garantir consistência:

virsh suspend web-server

Domain 'web-server' suspended

Crie o snapshot ZFS com uma nomenclatura com timestamp:

zfs snapshot vmpool/vms/web-server-disk@backup-$(date +%Y%m%d-%H%M%S)

Retome a VM imediatamente após o snapshot:

virsh resume web-server

Domain 'web-server' resumed

Liste os snapshots criados para confirmar:

zfs list -t snapshot -o name,creation,used vmpool/vms/web-server-disk

NAME                                              CREATION           USED
vmpool/vms/web-server-disk@backup-20260115-020001  Thu Jan 15 2:00  0B

Para enviar o snapshot para um servidor remoto via SSH (backup offsite), utilize o zfs send combinado com zfs receive:

zfs send vmpool/vms/web-server-disk@backup-20260115-020001 | \
  ssh backup-server "zfs receive backuppool/vms/web-server-disk"

Para backups incrementais (enviando apenas o delta entre dois snapshots), use a flag -i:

zfs send -i \
  vmpool/vms/web-server-disk@backup-20260114-020001 \
  vmpool/vms/web-server-disk@backup-20260115-020001 | \
  ssh backup-server "zfs receive backuppool/vms/web-server-disk"

Automatizando backups ZFS de VMs KVM com cron no Fedora 42

A automação de backups ZFS com cron elimina a necessidade de intervenção manual e garante janelas de proteção regulares. O script abaixo encapsula todo o fluxo: suspend, snapshot, resume, envio remoto e rotação de snapshots antigos.

Crie o script em /usr/local/bin/zfs-kvm-backup.sh:

#!/bin/bash
set -euo pipefail

VM_NAME="web-server"
ZFS_DATASET="vmpool/vms/web-server-disk"
REMOTE_HOST="backup-server"
REMOTE_DATASET="backuppool/vms/web-server-disk"
SNAPSHOT_PREFIX="backup"
RETENTION=7

TIMESTAMP=$(date +%Y%m%d-%H%M%S)
SNAP_NAME="${ZFS_DATASET}@${SNAPSHOT_PREFIX}-${TIMESTAMP}"

echo "[$(date)] Suspendendo VM: ${VM_NAME}"
virsh suspend "${VM_NAME}"

echo "[$(date)] Criando snapshot: ${SNAP_NAME}"
zfs snapshot "${SNAP_NAME}"

echo "[$(date)] Retomando VM: ${VM_NAME}"
virsh resume "${VM_NAME}"

LAST_REMOTE=$(ssh "${REMOTE_HOST}" "zfs list -t snapshot -o name -s creation ${REMOTE_DATASET} 2>/dev/null | tail -1" || echo "")

if [ -n "${LAST_REMOTE}" ]; then
    LAST_LOCAL=$(echo "${LAST_REMOTE}" | awk -F@ '{print $2}')
    echo "[$(date)] Enviando snapshot incremental desde: ${LAST_LOCAL}"
    zfs send -i "${ZFS_DATASET}@${LAST_LOCAL}" "${SNAP_NAME}" | \
        ssh "${REMOTE_HOST}" "zfs receive ${REMOTE_DATASET}"
else
    echo "[$(date)] Enviando snapshot completo"
    zfs send "${SNAP_NAME}" | ssh "${REMOTE_HOST}" "zfs receive ${REMOTE_DATASET}"
fi

echo "[$(date)] Removendo snapshots antigos (retendo ${RETENTION})"
SNAPS_TO_DELETE=$(zfs list -t snapshot -o name -s creation "${ZFS_DATASET}" | \
    grep "@${SNAPSHOT_PREFIX}" | head -n -${RETENTION})

for snap in ${SNAPS_TO_DELETE}; do
    echo "[$(date)] Removendo: ${snap}"
    zfs destroy "${snap}"
done

echo "[$(date)] Backup concluído com sucesso."

Torne o script executável:

chmod +x /usr/local/bin/zfs-kvm-backup.sh

Abra o crontab do root para agendar a execução diária às 2h:

crontab -e

Adicione a linha:

0 2 * * * /usr/local/bin/zfs-kvm-backup.sh >> /var/log/zfs-kvm-backup.log 2>&1

Teste o script manualmente antes de confiar no agendamento:

/usr/local/bin/zfs-kvm-backup.sh

Restaurando VMs KVM a partir de snapshots ZFS

O processo de recuperação de VMs KVM com ZFS rollback é notavelmente mais rápido do que restaurar a partir de backups tradicionais, independentemente do tamanho do disco. O ZFS reverte o estado do volume para o ponto exato do snapshot em questão de segundos, pois opera com metadados de blocos.

Atenção: o rollback destrói todos os snapshots mais recentes do que o snapshot alvo. Liste os snapshots disponíveis antes de executar:

zfs list -t snapshot -o name,creation vmpool/vms/web-server-disk

NAME                                              CREATION
vmpool/vms/web-server-disk@backup-20260113-020001  Tue Jan 13 2:00
vmpool/vms/web-server-disk@backup-20260114-020001  Wed Jan 14 2:00
vmpool/vms/web-server-disk@backup-20260115-020001  Thu Jan 15 2:00

Desligue a VM antes do rollback:

virsh shutdown web-server

Aguarde até que a VM esteja desligada:

virsh list --all | grep web-server

 -     web-server            shut off

Execute o rollback para o snapshot desejado (use -r para remover snapshots dependentes automaticamente):

zfs rollback -r vmpool/vms/web-server-disk@backup-20260114-020001

Inicie a VM após o rollback:

virsh start web-server

Domain 'web-server' started

Verifique o estado da VM:

virsh dominfo web-server | grep State

State:          running

Se precisar restaurar a partir de um snapshot armazenado em um servidor remoto, use zfs send/receive no sentido inverso:

ssh backup-server "zfs send backuppool/vms/web-server-disk@backup-20260114-020001" | \
  zfs receive -F vmpool/vms/web-server-disk-restored

Para ambientes de alta disponibilidade, considere também revisar o artigo sobre Guia de Backup, Restore e Snapshot: diferenças práticas e quando usar cada um para entender quando cada estratégia é mais adequada.

Problemas comuns e como resolver

Sintoma: módulo ZFS não carrega após atualização de kernel no Fedora 42

Causa: o DKMS precisa recompilar o módulo zfs para a nova versão do kernel. Se a recompilação falhou silenciosamente, o módulo da versão anterior não é compatível com o novo kernel.
Solução: verifique o status do DKMS com dkms status. Se o módulo aparecer como built mas não installed, force a recompilação: dkms autoinstall. Se houver erros de compilação, instale os headers do kernel atual: dnf install kernel-devel-$(uname -r) e repita dkms autoinstall.

Sintoma: virsh suspend retorna erro "domain is not running"

Causa: a VM já está desligada ou em estado de erro quando o script de backup é executado, causando falha na chamada virsh suspend.
Solução: adicione verificação de estado antes de suspender no script: STATE=$(virsh domstate web-server); if [ "$STATE" = "running" ]; then virsh suspend web-server; fi. Isso torna o script idempotente e evita falhas desnecessárias que impediriam a criação do snapshot.

Sintoma: zfs send pipe para servidor remoto falha com "cannot receive: dataset already exists"

Causa: o dataset de destino no servidor remoto já possui snapshots com o mesmo nome, ou o snapshot base para o envio incremental não existe no destino.
Solução: para forçar a recepção e substituir o estado atual, adicione a flag -F ao zfs receive: zfs send snap | ssh host "zfs receive -F destino". Atenção — a flag -F realiza rollback no destino antes de receber. Para envios incrementais, confirme que o snapshot base existe no destino com ssh backup-server "zfs list -t snapshot destino".

Sintoma: pool ZFS mostra estado DEGRADED após reboot no Fedora 42

Causa: o ZFS pode não importar o pool automaticamente após o boot se o serviço zfs-import-cache não estiver habilitado, ou se o cache file estiver desatualizado.
Solução: habilite os serviços ZFS necessários para importação automática: systemctl enable zfs-import-cache zfs-import-scan zfs-mount zfs-share zfs.target e execute systemctl start zfs.target. Importe manualmente o pool se necessário: zpool import vmpool. Para persistir o cache: zpool set cachefile=/etc/zfs/zpool.cache vmpool.

Sintoma: snapshot ocupa mais espaço do que o esperado no pool ZFS

Causa: snapshots ZFS retêm blocos referenciados pelos dados excluídos ou modificados após a criação do snapshot. Quanto mais tempo o snapshot existir e mais alterações ocorrerem na VM, maior será seu consumo de espaço.
Solução: monitore o uso com zfs list -t snapshot -o name,used,referenced vmpool/vms/web-server-disk. Implemente rotação automática conforme demonstrado no script de backup (variável RETENTION). Para liberar espaço imediatamente, destrua snapshots antigos: zfs destroy vmpool/vms/web-server-disk@snapshot-antigo.

Perguntas frequentes sobre ZFS no Fedora 42 com KVM

O ZFS funciona nativamente no Fedora 42?

O ZFS não está incluído no kernel padrão do Fedora por questões de licença (CDDL vs GPL). Para usá-lo, é necessário instalar o módulo zfs-dkms via repositório OpenZFS. Após a instalação, o módulo é compilado automaticamente para o kernel atual e carregado com modprobe zfs. A compatibilidade com o Fedora 42 é mantida pelo projeto OpenZFS, que publica pacotes para as versões mais recentes da distribuição.

Como fazer backup de uma VM KVM usando ZFS?

O fluxo recomendado é: pausar ou desligar a VM, criar um snapshot ZFS do volume de disco com zfs snapshot pool/vm@backup-data, depois retomar a VM. O snapshot é consistente e pode ser enviado para outro pool ou servidor remoto com zfs send | zfs receive. Isso preserva o estado exato do disco da VM no momento do snapshot. A pausa da VM garante que o buffer de escrita do guest seja esvaziado antes da captura, evitando inconsistências no sistema de arquivos da VM.

Qual a diferença entre snapshot ZFS e backup tradicional para VMs KVM?

Snapshots ZFS são operações copy-on-write instantâneas que não copiam dados imediatamente — apenas registram o estado do sistema de arquivos naquele momento. Backups tradicionais copiam todos os blocos de dados, consumindo mais tempo e I/O. Para VMs KVM, snapshots ZFS são mais rápidos de criar e permitem recuperação granular por ponto no tempo, enquanto backups tradicionais oferecem portabilidade maior para mídias externas. A combinação ideal usa snapshots ZFS para recuperação rápida local e zfs send para arquivamento offsite.

Como restaurar uma VM KVM a partir de um snapshot ZFS?

Para restaurar, execute zfs rollback pool/vm@snapshot-desejado para reverter o volume ao estado do snapshot. Se a VM estiver em execução, desligue-a antes do rollback com virsh shutdown nome-da-vm. Após o rollback, inicie a VM normalmente com virsh start nome-da-vm. O processo leva segundos independentemente do tamanho do disco, pois o ZFS opera no nível de metadados de blocos e não precisa copiar dados fisicamente.

É possível automatizar backups ZFS de VMs KVM com cron no Fedora 42?

Sim. Crie um script shell que pause a VM com virsh suspend, crie o snapshot ZFS, retome a VM com virsh resume e opcionalmente envie o snapshot para um servidor remoto via zfs send. Agende o script no cron com crontab -e usando expressão como 0 2 * * * para execução diária às 2h. Adicione rotação de snapshots antigos para controlar o uso de espaço. O script completo neste artigo cobre todos esses aspectos incluindo envio incremental e retenção configurável.

Conclusão

• Instale o zfs-dkms via OpenZFS e habilite os serviços ZFS com systemctl para garantir importação automática do pool após reboots no Fedora 42.
• Use o padrão suspend → snapshot → resume no script de backup para garantir consistência de dados da VM sem downtime prolongado, mantendo o intervalo de pausa abaixo de 1-2 segundos.
• Combine rollback local com zfs send remoto para uma estratégia de recuperação em camadas: restauração rápida a partir de snapshots locais e proteção contra falha de hardware via backups offsite incrementais.

Leia também

• Entenda servidor comprometido: contenção e recuperação
• Checklist de Segurança para Servidor Linux em Produção 2026
• Como fazer backup no cPanel: frequência, destino e teste

Precisa de ajuda com ZFS e KVM em servidor Linux?

Configurar ZFS com KVM envolve ajustes de kernel, compilação de módulos e planejamento de storage que variam conforme o ambiente. Em um VPS Linux com recursos dedicados, você tem controle total sobre o kernel e os dispositivos de bloco necessários para implementar esta solução.

Conheça os planos de VPS Linux da AviraHost