Backup e recuperação agendados

Introdução

Um backup útil é mais do que executar um comando de arquivamento. Você precisa saber o que ele contém, verificar se pode ser lido, restaurar o arquivo necessário e tornar observáveis as execuções automáticas.

Neste laboratório, você fará o backup de um pequeno workspace de aplicação a partir de um manifesto, restaurará um arquivo específico, transformará o fluxo em um script com registro de data e hora e instalará um agendamento do Cron. Todos os caminhos usados pela automação são absolutos, para que o job não dependa do diretório atual de um shell interativo.

Defina o escopo do backup com um manifesto

Nesta etapa, você criará um manifesto: uma lista de caminhos em texto simples que torna o escopo do backup visível e fácil de revisar.

Entre no workspace:

cd /home/labex/project/backup-lab

Crie um manifesto contendo caminhos relativos ao diretório data:

cat > backup-manifest.txt <<'EOF'
config/app.conf
documents/runbook.txt
EOF

Numere as entradas para facilitar a revisão:

nl -ba backup-manifest.txt

Confirme que todas as fontes listadas existem usando um loop while. Leia a estrutura do loop antes de executá-lo:

• IFS= impede que o shell remova espaços em branco no início ou no fim de uma linha;
• read -r item lê uma linha completa na variável item sem tratar barras invertidas de forma especial;
• do ... done delimita o comando repetido para cada linha;
• < backup-manifest.txt fornece o manifesto como entrada do loop;
• test -f verifica se o caminho correspondente é um arquivo regular, e && exibe ready somente quando essa verificação é bem-sucedida.

while IFS= read -r item; do
  test -f "data/$item" && echo "ready: $item"
done < backup-manifest.txt

O arquivo não listado documents/scratch.txt está intencionalmente fora deste backup gerenciado.

Crie um arquivo a partir do manifesto

Nesta etapa, você usará tar -T para ler os nomes de arquivo do manifesto. A opção -C data faz com que o arquivo use caminhos relativos curtos.

tar -czf backups/manual-backup.tar.gz -C data -T backup-manifest.txt

As opções significam:

• -c: cria um arquivo;
• -z: compacta o arquivo com gzip;
• -f: usa o nome de arquivo informado em seguida;
• -C data: executa a operação relativa a data;
• -T backup-manifest.txt: lê do manifesto os membros que serão incluídos no backup.

Inspecione o arquivo resultante:

ls -lh backups/manual-backup.tar.gz

Compare o registro de data e hora e o tamanho com os arquivos de origem:

stat -c '%n size=%s modified=%y' backups/manual-backup.tar.gz data/config/app.conf data/documents/runbook.txt

Verifique o arquivo sem extraí-lo

Nesta etapa, você testará o arquivo antes de confiar nele. Primeiro, teste o fluxo gzip:

gzip -t backups/manual-backup.tar.gz

Nenhuma saída significa que o fluxo compactado passou pela verificação de integridade. Agora liste os membros do tar sem extraí-los:

tar -tzf backups/manual-backup.tar.gz | tee archive-contents.txt

Compare a listagem salva com o manifesto:

diff -u backup-manifest.txt archive-contents.txt

O comando não deve mostrar diferenças. Confirme que o arquivo temporário não gerenciado está ausente:

if tar -tzf backups/manual-backup.tar.gz | grep -qx 'documents/scratch.txt'; then
  echo "Unexpected scratch file found"
else
  echo "Archive scope is correct"
fi

Restaure um arquivo específico

Nesta etapa, você restaurará somente um arquivo selecionado, para não substituir dados que não têm relação com a operação. Simule a exclusão acidental da configuração:

rm data/config/app.conf

test -e data/config/app.conf || echo "app.conf is missing"

Extraia somente config/app.conf para o diretório separado de restauração:

rm -rf restore/*

tar -xzf backups/manual-backup.tar.gz -C restore config/app.conf

Inspecione o arquivo recuperado e depois copie-o de volta para o local de trabalho:

cat restore/config/app.conf

cp restore/config/app.conf data/config/app.conf

cmp -s restore/config/app.conf data/config/app.conf && echo "Configuration restored"

Somente o membro solicitado do arquivo foi extraído.

Crie um script de backup com registro de data e hora

Nesta etapa, você criará um script de backup com registro de data e hora. O Cron inicia os jobs com um ambiente limitado; por isso, use caminhos absolutos dentro de scripts executados sem intervenção.

Crie backup.sh:

cat > backup.sh <<'EOF'
#!/bin/bash

source_dir=/home/labex/project/backup-lab/data
manifest=/home/labex/project/backup-lab/backup-manifest.txt
backup_dir=/home/labex/project/backup-lab/backups
timestamp=$(date +%Y%m%d-%H%M%S)
archive="$backup_dir/backup-$timestamp.tar.gz"

mkdir -p "$backup_dir"

if [ ! -d "$source_dir" ] || [ ! -f "$manifest" ]; then
  echo "Backup source or manifest is missing" >&2
  exit 1
fi

/bin/tar -czf "$archive" -C "$source_dir" -T "$manifest" || exit 1
/bin/tar -tzf "$archive" > "$archive.contents" || exit 1

echo "Created $archive"
exit 0
EOF

Torne o script executável e teste-o agora, em vez de esperar pelo Cron:

chmod u+x backup.sh

./backup.sh | tee last-backup.txt

ls -1 backups

O registro de data e hora fornece um nome de arquivo exclusivo para cada execução. O arquivo complementar .contents registra exatamente o conteúdo do arquivo.

Instale e inspecione um agendamento do Cron

Nesta etapa, você instalará e inspecionará um agendamento pessoal do Cron. Uma linha do crontab começa com cinco campos de agendamento, seguidos pelo comando:

Um asterisco * significa todos os valores permitidos. Um passo como */5 significa a cada cinco unidades nesse campo.

minute hour day-of-month month day-of-week command

Por exemplo, */5 * * * * significa a cada cinco minutos. 0 2 * * * significa às 02:00 todos os dias.

crontab -e abre o crontab pessoal em um editor. Um fluxo confiável é preparar e instalar primeiro uma entrada conhecida como válida e depois fazer uma pequena edição interativa. Crie uma entrada que use caminhos absolutos e capture a saída padrão e a saída de erro padrão:

cat > backup.crontab <<'EOF'
*/5 * * * * /home/labex/project/backup-lab/backup.sh >> /home/labex/project/backup-lab/logs/backup.log 2>&1
EOF

Revise e instale a entrada:

cat backup.crontab

crontab backup.crontab

Agora abra o crontab instalado no Nano:

EDITOR=nano crontab -e

Adicione este comentário na linha acima do agendamento:

## LabEx managed backup schedule

Pressione Ctrl+O e depois Enter para salvar. Pressione Ctrl+X para sair do Nano e voltar ao shell. Use crontab -l para confirmar exatamente o que o Cron lerá e salve essa saída:

crontab -l | tee installed-crontab.txt

A saída deve conter o comentário seguido da entrada executada a cada cinco minutos. Inspecionar o resultado instalado permite detectar erros de edição antes que você dependa do agendamento.

Teste o logging e entenda o escape do sinal de porcentagem

Nesta etapa, você testará o registro de logs do backup e aprenderá como o Cron trata especialmente os sinais de porcentagem. Primeiro, execute manualmente o comando agendado:

/home/labex/project/backup-lab/backup.sh >> /home/labex/project/backup-lab/logs/backup.log 2>&1

tail -n 5 logs/backup.log

find backups -maxdepth 1 -type f -name 'backup-*.tar.gz' -printf '%f\n' | sort

O registro de data e hora é criado dentro de backup.sh, onde os caracteres % comuns são seguros. No entanto, o Cron trata especialmente um % sem escape em um comando do crontab. Se você colocar date diretamente em uma linha do crontab, escape cada sinal de porcentagem com uma barra invertida.

Salve um exemplo com o escape correto para referência:

cat > cron-date-example.txt <<'EOF'
0 2 * * * /bin/echo "backup-$(/bin/date +\%Y\%m\%d-\%H\%M\%S)" >> /home/labex/project/backup-lab/logs/date-example.log 2>&1
EOF

cat cron-date-example.txt

O job instalado continua sendo a entrada mais simples baseada em script. Ele usa caminhos absolutos, atribui um registro de data e hora a cada arquivo e deixa um log que pode ser inspecionado após execuções sem intervenção.

Resumo

Você definiu o escopo de um backup em um manifesto, criou um arquivo com tar -T, verificou esse arquivo sem extraí-lo e recuperou um arquivo específico. Depois, escreveu um script de backup com registro de data e hora e caminhos absolutos, instalou e inspecionou um agendamento do Cron, redirecionou a saída de execuções sem intervenção para um log e aprendeu por que os sinais de porcentagem precisam ser escapados quando date aparece diretamente em um comando do crontab.