Entenda backup Linux com snapshots: rotina e verificação

Backup Linux com snapshots é uma rotina que captura estados consistentes dos arquivos, mantém retenção por data e valida se os dados copiados continuam íntegros. Para criar uma rotina segura, use snapshots como ponto de recuperação rápido, mas mantenha também cópia em outro destino e verificação de integridade.

1. Defina quais diretórios entram no backup e quais caminhos temporários devem ser excluídos.
2. Crie um diretório de snapshots com retenção organizada por data e link para o último snapshot válido.
3. Execute a cópia com preservação de permissões, atributos e remoção controlada de arquivos apagados na origem.
4. Gere checksums dos arquivos copiados e valide a leitura do snapshot mais recente.
5. Automatize a rotina com agendamento, logs e limpeza de snapshots antigos somente após validação.

Pré-requisitos para backup Linux com snapshots

Uma rotina de snapshots no Linux precisa começar com escopo claro, acesso administrativo e um destino que não esteja no mesmo caminho lógico dos dados protegidos. Ao executar em servidores de hospedagem, aplicações web ou ambientes com muitos arquivos pequenos, separe diretórios de sistema, dados persistentes e arquivos temporários para evitar cópias inúteis e restaurações confusas.

• Acesso SSH com usuário administrativo ou permissão para usar sudo.
• Espaço livre suficiente no destino de backup, preferencialmente em disco, volume ou ponto de montagem separado.
• Ferramentas comuns de linha de comando: rsync, find, sha256sum, readlink, date e cron.
• Lista dos diretórios críticos, como arquivos de sites, configurações e dados de aplicações.
• Janela de execução definida para reduzir impacto durante horários de maior escrita.
• Política de retenção por quantidade de dias ou por quantidade de snapshots mantidos.

Antes de seguir, confirme que o destino está montado corretamente. Se você depende de acesso remoto para administrar o servidor, revise também Acessando servidores VPS Linux da AviraHost, pois uma rotina de backup mal validada fica difícil de corrigir sem acesso confiável ao terminal.

findmnt /backup
df -h /backup

Output esperado:
TARGET  SOURCE       FSTYPE OPTIONS
/backup /dev/sdb1    ext4   rw,relatime
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb1       ...   ...  ...   ...  /backup

Planejar a rotina de snapshots no Linux

O planejamento de backup incremental com snapshots evita o erro comum de copiar tudo sem critério e descobrir, na restauração, que faltavam arquivos essenciais ou que o destino foi preenchido por cache. Em Linux genérico, uma abordagem prática é manter snapshots por data dentro de um diretório dedicado, usando um ponteiro chamado ultimo para acelerar a próxima execução. Essa estrutura facilita auditoria, comparação e rollback manual.

Defina a origem como o conjunto de dados reais. Para backup do sistema inteiro, exclua pseudo-sistemas de arquivos e diretórios voláteis como proc, sys, dev, run e tmp. Também exclua o próprio destino de backup; caso contrário, a rotina pode copiar snapshots dentro de snapshots até consumir o disco. Para sites e aplicações, considere separar arquivos de aplicação, uploads, configurações e dumps de banco gerados por ferramentas próprias. Snapshot de arquivo não garante, sozinho, consistência de banco em escrita intensa.

1. Crie a árvore principal para snapshots, logs e manifestos de integridade.
2. Documente quais caminhos entram e quais ficam fora da cópia.
3. Escolha uma retenção inicial conservadora, validando consumo de disco antes de aumentar o histórico.
4. Teste a primeira execução manualmente antes de agendar no cron.

sudo mkdir -p /backup/snapshots /backup/logs /backup/manifests
sudo chmod 700 /backup
sudo ls -ld /backup /backup/snapshots /backup/logs /backup/manifests

Output esperado:
drwx------ ... /backup
drwxr-xr-x ... /backup/logs
drwxr-xr-x ... /backup/manifests
drwxr-xr-x ... /backup/snapshots

Backup Linux com snapshots: diretórios padrão

Para uma rotina genérica, comece protegendo dados que realmente precisam voltar após incidente: configurações em etc, conteúdo em var e diretórios de usuários. Em servidores com painel, e-mail ou aplicações web, valide os caminhos específicos antes de excluir qualquer diretório. Se o servidor tem serviços críticos, mantenha uma anotação operacional com origem, destino, retenção e responsável pela verificação. Essa documentação reduz erro humano quando a restauração precisa ser feita sob pressão.

Criar snapshots consistentes com rsync e link de referência

Snapshots com rsync e link de referência permitem manter cópias datadas economizando espaço quando arquivos não mudam entre execuções. A lógica é simples: o primeiro snapshot copia os arquivos; os próximos usam o último snapshot como referência e criam links para arquivos idênticos, enquanto arquivos alterados são copiados novamente. Isso não substitui snapshot nativo de sistema de arquivos, mas é uma rotina portátil para Linux genérico e funciona bem quando o objetivo é histórico por data com restauração simples.

Atenção: o parâmetro --delete remove do snapshot atual arquivos que não existem mais na origem. Ele não deve ser executado apontando para o destino errado. Confira cuidadosamente as variáveis, exclusões e ponto de montagem antes de rodar em produção.

DATA=$(date +%F-%H%M)
ANTERIOR=$(readlink -f /backup/snapshots/ultimo 2>/dev/null || true)
DESTINO=/backup/snapshots/$DATA
sudo mkdir -p "$DESTINO"
if [ -n "$ANTERIOR" ]; then
  sudo rsync -aHAX --numeric-ids --delete --link-dest="$ANTERIOR" --exclude=/proc --exclude=/sys --exclude=/dev --exclude=/run --exclude=/tmp --exclude=/mnt --exclude=/media --exclude=/backup / "$DESTINO"/
else
  sudo rsync -aHAX --numeric-ids --delete --exclude=/proc --exclude=/sys --exclude=/dev --exclude=/run --exclude=/tmp --exclude=/mnt --exclude=/media --exclude=/backup / "$DESTINO"/
fi
sudo ln -sfn "$DESTINO" /backup/snapshots/ultimo
readlink -f /backup/snapshots/ultimo

Output esperado:
/backup/snapshots/2026-...-...

Ao rodar este comando, você verá o link ultimo apontando para o snapshot recém-criado. Em uma restauração manual, isso facilita localizar a cópia mais recente sem depender de nomes longos. Para servidores que também hospedam e-mail, alinhe essa rotina com cópias específicas dos serviços; se o ambiente inclui MTA, veja como contexto operacional o artigo Passo a passo para configurar servidor de e-mail no VPS Linux.

Automatizar backup com cron, logs e retenção segura

A automação de backup com cron transforma a cópia manual em rotina auditável, mas só é confiável quando registra saída, código de erro e retenção. Não agende antes de testar manualmente, porque uma exclusão errada será repetida sem supervisão. Abaixo, o script cria um snapshot datado, atualiza o link do último snapshot, gera log por execução e deixa a limpeza separada para ser validada com cuidado.

sudo tee /usr/local/sbin/backup-snapshot.sh >/dev/null <<'EOF'
#!/bin/sh
DATA=$(date +%F-%H%M)
LOG=/backup/logs/backup-$DATA.log
ANTERIOR=$(readlink -f /backup/snapshots/ultimo 2>/dev/null || true)
DESTINO=/backup/snapshots/$DATA

mkdir -p "$DESTINO"

if [ -n "$ANTERIOR" ]; then
  rsync -aHAX --numeric-ids --delete --link-dest="$ANTERIOR" --exclude=/proc --exclude=/sys --exclude=/dev --exclude=/run --exclude=/tmp --exclude=/mnt --exclude=/media --exclude=/backup / "$DESTINO"/ >"$LOG" 2>&1
else
  rsync -aHAX --numeric-ids --delete --exclude=/proc --exclude=/sys --exclude=/dev --exclude=/run --exclude=/tmp --exclude=/mnt --exclude=/media --exclude=/backup / "$DESTINO"/ >"$LOG" 2>&1
fi

STATUS=$?
if [ "$STATUS" -eq 0 ]; then
  ln -sfn "$DESTINO" /backup/snapshots/ultimo
fi
exit "$STATUS"
EOF
sudo chmod 700 /usr/local/sbin/backup-snapshot.sh
sudo /usr/local/sbin/backup-snapshot.sh
echo $?

Output esperado:
0

Depois de obter saída 0, agende a execução. O exemplo abaixo roda diariamente em horário de baixa atividade. Ajuste a janela conforme sua aplicação e evite executar ao mesmo tempo que tarefas pesadas de banco de dados, compactação ou deploy.

echo "30 2 * * * root /usr/local/sbin/backup-snapshot.sh" | sudo tee /etc/cron.d/backup-snapshot
sudo cat /etc/cron.d/backup-snapshot

Output esperado:
30 2 * * * root /usr/local/sbin/backup-snapshot.sh

Atenção: retenção remove snapshots antigos. Antes de apagar, liste o que seria removido e confirme se existe pelo menos um snapshot recente validado.

sudo find /backup/snapshots -mindepth 1 -maxdepth 1 -type d -mtime +14 -print

Output esperado:
/backup/snapshots/2026-...-...

Somente depois de revisar a lista, aplique a remoção. O comando abaixo pressupõe nomes de diretório gerados pela rotina, sem espaços.

for dir in $(sudo find /backup/snapshots -mindepth 1 -maxdepth 1 -type d -mtime +14 -print); do sudo rm -rf "$dir"; done

Output esperado:
sem saída quando a remoção termina sem erro

Verificação de integridade de backup com checksums

A verificação de integridade de backup confirma se os arquivos copiados podem ser lidos e se o conteúdo não mudou de forma inesperada após o snapshot. Checksums não provam que a aplicação voltará perfeita, mas ajudam a detectar corrupção, cópia incompleta, erro de leitura e alteração indevida no destino. Em uma rotina madura, a validação roda após a cópia e o backup anterior válido não é apagado quando a verificação falha.

Gere um manifesto de hashes para o snapshot mais recente. Em árvores muito grandes, essa etapa pode levar tempo; por isso, execute em janela adequada e acompanhe uso de disco e I/O. Ao rodar este comando, você verá uma lista de hashes associada aos arquivos encontrados no snapshot atual.

ULTIMO=$(readlink -f /backup/snapshots/ultimo)
MANIFESTO=/backup/manifests/manifesto-$(date +%F-%H%M).sha256
sudo find "$ULTIMO" -type f -print0 | sudo xargs -0 sha256sum | sudo tee "$MANIFESTO" >/dev/null
sudo tail "$MANIFESTO"

Output esperado:
hash_gerado  /backup/snapshots/ultimo/caminho/do/arquivo

Agora valide o manifesto mais recente. A saída OK indica que os arquivos lidos correspondem aos hashes registrados. Se aparecer falha, trate o snapshot como suspeito e investigue antes de atualizar retenção ou apagar cópias anteriores.

MANIFESTO=$(ls -1t /backup/manifests/*.sha256 | head -n 1)
sudo sha256sum -c "$MANIFESTO" | tail

Output esperado:
/backup/snapshots/ultimo/caminho/do/arquivo: OK

Além dos hashes, faça testes de restauração parcial. Copie um diretório pequeno para uma área temporária, confira permissões e abra arquivos relevantes. Em hospedagem, isso pode significar validar uploads, configurações e arquivos de aplicação. Para serviços que dependem de inicialização correta após restauração, a leitura complementar Como solucionar problemas de inicialização de serviços no VPS Linux: Guia Completo ajuda a organizar verificações pós-restore.

Problemas comuns e como resolver

Sintoma: o snapshot ocupa quase o mesmo espaço de uma cópia completa

Causa: o link de referência pode estar apontando para caminho inexistente, o link ultimo pode não ter sido atualizado ou atributos dos arquivos mudam a cada execução. Solução: confira readlink -f /backup/snapshots/ultimo, revise se --link-dest aponta para o snapshot anterior e valide se a origem não gera arquivos temporários demais dentro dos caminhos copiados.

readlink -f /backup/snapshots/ultimo
sudo du -sh /backup/snapshots/* | tail

Output esperado:
/backup/snapshots/2026-...-...
tamanhos listados por snapshot

Sintoma: a verificação de integridade retorna FAILED

Causa: o arquivo pode ter sido alterado no destino depois da geração do manifesto, pode haver falha de leitura no disco ou a rotina pode ter gerado manifesto enquanto a cópia ainda estava incompleta. Solução: não remova snapshots anteriores, leia o log da execução, gere uma nova cópia em janela estável e rode sha256sum -c novamente antes de considerar o backup confiável.

MANIFESTO=$(ls -1t /backup/manifests/*.sha256 | head -n 1)
sudo sha256sum -c "$MANIFESTO" | grep FAILED

Output esperado:
arquivo_com_falha: FAILED

Sintoma: o cron não executa a rotina

Causa: caminho incorreto, permissão insuficiente no script, arquivo em /etc/cron.d com formato inválido ou ambiente diferente do shell interativo. Solução: use caminhos absolutos, confirme permissão de execução, valide o arquivo de cron e rode o script manualmente com o mesmo usuário administrativo.

sudo ls -l /usr/local/sbin/backup-snapshot.sh
sudo cat /etc/cron.d/backup-snapshot
sudo /usr/local/sbin/backup-snapshot.sh
echo $?

Output esperado:
-rwx------ ... /usr/local/sbin/backup-snapshot.sh
30 2 * * * root /usr/local/sbin/backup-snapshot.sh
0

Sintoma: o destino de backup fica sem espaço

Causa: retenção longa demais, inclusão acidental do próprio diretório de backup, arquivos de cache entrando na cópia ou crescimento real dos dados protegidos. Solução: confirme exclusões, revise uso por snapshot, reduza retenção com cautela e mantenha pelo menos um backup anterior validado antes de apagar histórico.

df -h /backup
sudo du -sh /backup/snapshots/* | tail

Output esperado:
uso do ponto de montagem /backup
tamanho dos snapshots mais recentes

Perguntas frequentes sobre backup Linux com snapshots

Como criar uma rotina de backup Linux com snapshots?

Uma rotina de backup Linux com snapshots combina cópias agendadas, retenção por data e validação dos arquivos gerados. O processo normalmente envolve definir origem e destino, criar snapshots consistentes, sincronizar os dados e registrar logs para auditoria.

Snapshot substitui backup tradicional no Linux?

Snapshot não deve ser tratado como substituto único de backup tradicional. Ele ajuda a capturar um estado do sistema em um momento específico, mas a rotina fica mais segura quando inclui cópia para outro destino, retenção e verificação de integridade.

Como verificar a integridade de um backup no Linux?

A integridade pode ser verificada com checksums, comparação de arquivos e testes de leitura dos dados copiados. Em rotinas automatizadas, o ideal é gerar hashes após o backup e conferir se os arquivos principais continuam legíveis e consistentes.

Qual frequência usar para snapshots e backups em Linux?

A frequência depende da criticidade dos dados e do volume de alterações. Ambientes com mudanças frequentes costumam exigir snapshots mais próximos e backups recorrentes, enquanto servidores com pouca alteração podem usar janelas mais espaçadas e retenção maior.

O que fazer se a verificação de integridade do backup falhar?

Se a verificação falhar, não remova o backup anterior válido e investigue logs, permissões, espaço em disco e falhas de leitura no destino. Depois de corrigir a causa, execute uma nova cópia e valide novamente antes de considerar o backup confiável.

Conclusão

Uma rotina confiável de backup Linux com snapshots depende de três pilares: cópia consistente, retenção controlada e verificação de integridade. O snapshot acelera recuperação e comparação por data, mas a segurança operacional aumenta quando você mantém logs, valida hashes e evita apagar o último backup comprovadamente funcional.

• Teste a primeira execução manualmente e só depois agende no cron.
• Gere manifestos com sha256sum e trate qualquer falha como incidente de backup.
• Revise retenção, exclusões e espaço livre antes de remover snapshots antigos.

Leia também

• Backup MariaDB Docker com rsync: automação e integridade
• Otimizar Rsync no Rocky Linux 9: velocidade e eficiência
• Passo a passo para configurar backup automático com cron no VPS Linux e servidor dedicado

Precisa de ajuda com rotina de backup Linux com snapshots?

A AviraHost oferece infraestrutura para quem precisa organizar servidores Linux com mais previsibilidade, incluindo espaço, acesso e administração adequados para rotinas de backup. Avalie o ambiente antes de definir retenção, destino e janela de execução.

Conheça os planos de Servidor VPS