Backup e recuperação agendados

Introdução

Um backup útil é mais do que executar um comando de arquivamento. É preciso saber o que ele contém, verificar se pode ser lido, restaurar o arquivo necessário e garantir que as execuções automáticas possam ser acompanhadas.

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

Definir 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 espaço de trabalho:

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

Criar um arquivo a partir do manifesto

Nesta etapa, você usará tar -T para ler os nomes dos arquivos no 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: comprime o arquivo usando gzip;
• -f: usa o nome de arquivo especificado 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 a data e hora e o tamanho dele 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

Verificar o arquivo sem extraí-lo

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

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

Nenhuma saída significa que o fluxo compactado passou na verificação de integridade. Agora liste os membros do arquivo 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 exibir 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

Restaurar um arquivo específico

Nesta etapa, você restaurará apenas um arquivo selecionado, evitando substituir dados não relacionados. Simule a exclusão acidental do arquivo de 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.

Criar um script de backup com marcação de data e hora

Nesta etapa, você criará um script de backup com marcação de data e hora. O Cron inicia os trabalhos com um ambiente limitado; por isso, use caminhos absolutos dentro dos scripts executados de forma automática.

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

A marcação de data e hora fornece um nome de arquivo exclusivo para cada execução. O arquivo .contents correspondente registra exatamente o conteúdo do arquivo compactado.

Instalar e inspecionar 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 consiste em preparar e instalar primeiro uma entrada válida e depois fazer uma pequena edição interativa. Crie uma entrada que use caminhos absolutos e capture tanto a saída padrão quanto 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 o agendamento:

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 de depender do agendamento.

Testar o registro em log e entender o escape do sinal de porcentagem

Nesta etapa, você testará o registro dos backups 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

A marcação de data e hora é criada dentro de backup.sh, onde os caracteres % comuns são seguros. No entanto, o Cron trata de maneira especial um % não escapado 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 corretamente escapado 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 trabalho instalado continua sendo a entrada mais simples, baseada em script. Ele usa caminhos absolutos, atribui uma marcação de data e hora a cada arquivo de backup e deixa um log que pode ser inspecionado após as execuções automáticas.

Resumo

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