Tutorial de Ubuntu 26.04 / Faça backup de configurações, pacotes e dados

Um backup do Ubuntu precisa de um escopo definido, armazenamento independente de falhas da origem e uma restauração testada. Apenas uma lista de pacotes ou um snapshot de VM não é suficiente. Esta lição planeja o escopo do backup e demonstra a restauração em um diretório separado sem sobrescrever a origem.

Decida o que precisa ser restaurado

Um tar simples de um banco de dados ativo pode misturar dados de diferentes pontos no tempo. Use um dump suportado pelo aplicativo ou um procedimento coordenado de parada/congelamento, e identifique os armazenamentos que devem ser restaurados juntos. Teste separadamente a preservação e restauração de ACLs e atributos estendidos quando necessário.

Registre pacotes e locais de configuração

Esses comandos criam um novo diretório de inventário no diretório pessoal do usuário atual sem instalar ou remover pacotes. Restrinja o acesso, pois os inventários podem conter detalhes operacionais. Eles não contêm a configuração real ou o conteúdo dos arquivos do usuário.

(
set -eu
umask 077
inventory_dir=$(mktemp -d "$HOME/ubuntu-inventory.XXXXXX")
apt-mark showmanual > "$inventory_dir/apt-manual.txt"
dpkg-query -W -f='${binary:Package}\t${Version}\n' > "$inventory_dir/dpkg-versions.tsv"
if command -v snap >/dev/null 2>&1; then
    snap list > "$inventory_dir/snap-list.txt"
fi
cat /etc/os-release > "$inventory_dir/os-release.txt"
printf "%s\n" "$inventory_dir"
)

Antes da restauração, revise quais pacotes e repositórios são suportados e necessários na versão de destino em vez de reinstalar toda a lista cegamente. Distinga backups de configuração de identidades específicas da máquina, como machine-id, chaves SSH do host e endereços estáticos. A recuperação do mesmo servidor difere da clonagem de outro servidor.

Realize uma pequena rodada de backup e restauração

Salve o script completo como ~/backup-roundtrip-lab.sh e execute bash ~/backup-roundtrip-lab.sh. Ele requer tar, sha256sum e cmp, não usa sudo, e toca apenas em novos arquivos de teste em um diretório temporário. Este exercício no mesmo disco não substitui o armazenamento de backup independente.

set -eu
umask 077
lab_dir=$(mktemp -d)
mkdir "$lab_dir/source" "$lab_dir/restored"
printf "original data\n" > "$lab_dir/source/note with spaces.txt"
tar -C "$lab_dir/source" -cpf "$lab_dir/data.tar" .
(
    cd "$lab_dir"
    sha256sum data.tar > data.tar.sha256
    sha256sum -c data.tar.sha256
)
tar -tf "$lab_dir/data.tar"
tar -C "$lab_dir/restored" -xpf "$lab_dir/data.tar"
cmp "$lab_dir/source/note with spaces.txt" "$lab_dir/restored/note with spaces.txt"
printf "Round trip passed: %s\n" "$lab_dir"

O checksum verifica se o arquivo corresponde aos bytes registrados, e a listagem do tar verifica os nomes dos membros. Um cmp bem-sucedido seguido de Round trip passed confirma a restauração do conteúdo do arquivo deste exemplo. Não testa criptografia, controles de acesso ou inicialização de aplicativos. Não extraia arquivos desconhecidos como administrador; comece a restauração real em um diretório vazio isolado.

Faça backup da configuração real do Nginx e de uma pasta de usuário

Use /etc/nginx depois do laboratório de configuração de sites Nginx e uma pasta de documento comum dentro do seu diretório home. Identifique a pasta e pause a edição, sincronização e gravações do aplicativo para consistência. Isso não substitui dumps de banco de dados ou backups coordenados de volume. Registre o ponto de montagem/UUID do disco de backup separado e verifique se ele é independente do dispositivo de origem.

Salve o script completo como ~/backup-course-data.sh. Ele requer Bash, GNU tar, util-linux findmnt e coreutils realpath/sha256sum. Passe a pasta de dados do usuário, o ponto de montagem do sistema de backup e o UUID real. Adapte bash ~/backup-course-data.sh "$HOME/Documents/course-data" /srv/backup ACTUAL_UUID para valores locais verificados.

set -eu
umask 077
if [ "$#" -ne 3 ]; then
    printf 'Usage: bash backup-course-data.sh SOURCE_DIR BACKUP_MOUNT EXPECTED_UUID\n' >&2; exit 2
fi
source_dir=$(realpath -- "$1")
backup_mount=$(realpath -- "$2")
expected_uuid=$3
case "$source_dir" in
    "$HOME"/*) ;;
    *) printf 'Choose a specific ordinary-data folder inside your home.\n' >&2; exit 1 ;;
esac
test -d "$source_dir"
if [ -z "$expected_uuid" ] || [ "$expected_uuid" = REPLACE_WITH_VERIFIED_UUID ]; then
    printf 'Record the actual backup filesystem UUID first.\n' >&2; exit 1
fi
actual_uuid=$(findmnt -rn --mountpoint "$backup_mount" -o UUID || true)
if [ "$actual_uuid" != "$expected_uuid" ]; then
    printf 'Expected backup filesystem is not mounted; stop.\n' >&2; exit 1
fi
for original in "$source_dir" /etc/nginx; do
    original_uuid=$(findmnt -rn --target "$original" -o UUID)
    if [ -z "$original_uuid" ] || [ "$original_uuid" = "$actual_uuid" ]; then
        printf 'Use a separate verified backup filesystem.\n' >&2; exit 1
    fi
done
case "$backup_mount/" in
    "$source_dir/"*) printf 'Backup must be outside the source tree.\n' >&2; exit 1 ;;
esac
sudo test -d /etc/nginx
df -h "$source_dir" "$backup_mount"
set_dir=$(sudo mktemp -d "$backup_mount/ubuntu-course-backup.XXXXXX")
sudo chmod 0700 "$set_dir"
sudo tar --acls --xattrs --numeric-owner -C / -cpf "$set_dir/nginx.tar" etc/nginx
sudo tar --acls --xattrs --numeric-owner -C "$source_dir" -cpf "$set_dir/user-data.tar" .
sudo sh -c 'cd "$1" && sha256sum nginx.tar user-data.tar > SHA256SUMS && sha256sum -c SHA256SUMS' sh "$set_dir"
printf 'Backup set: %s\n' "$set_dir"

Se o ponto de montagem estiver ausente ou o UUID não coincidir, o script para antes de criar os arquivos. Uma falha posterior pode deixar um conjunto parcial: inspecione-o antes de tentar novamente. O sucesso imprime o caminho do conjunto e dois resultados OK. UUIDs diferentes identificam sistemas de arquivos diferentes, mas não garantem discos físicos independentes: confira também os dispositivos subjacentes. Restringir o conjunto potencialmente sensível ao root com modo 0700 não criptografa os dados em caso de perda do disco. Planeje armazenamento/criptografia separadamente e teste a restauração de ACL/xattr nos sistemas de arquivos reais.

Restaure em um local separado vazio e compare

Use apenas o conjunto confiável recém-criado. Salve isto como ~/restore-course-data.sh e execute bash ~/restore-course-data.sh DIRETÓRIO_DO_CONJUNTO_DE_BACKUP. Ele extrai apenas em um novo diretório /var/tmp, preservando a configuração ativa e os originais dos usuários. Verifique primeiro a capacidade e o mapeamento de UID/GID.

set -eu
if [ "$#" -ne 1 ]; then
    printf 'Usage: bash restore-course-data.sh BACKUP_SET_DIRECTORY\n' >&2; exit 2
fi
set_dir=$(realpath -- "$1")
sudo test -f "$set_dir/SHA256SUMS"
sudo sh -c 'cd "$1" && sha256sum -c SHA256SUMS' sh "$set_dir"
restore_dir=$(sudo mktemp -d /var/tmp/ubuntu-course-restore.XXXXXX)
sudo chmod 0700 "$restore_dir"
sudo mkdir "$restore_dir/config" "$restore_dir/data"
sudo tar --acls --xattrs --same-owner -C "$restore_dir/config" -xpf "$set_dir/nginx.tar"
sudo tar --acls --xattrs --same-owner -C "$restore_dir/data" -xpf "$set_dir/user-data.tar"
sudo ls -ldn "$restore_dir/config/etc/nginx" "$restore_dir/data"
printf 'Isolated restore: %s\n' "$restore_dir"

Substitua o caminho de restauração impresso e compare com uma origem não alterada. Um diff sem saída e com código 0 indica que o conteúdo comparado corresponde; código 1 indica diferenças. Alterações na origem pós-backup por si só não estabelecem corrupção. Investigue permissões e arquivos ausentes para outros erros.

restore_dir=/var/tmp/REPLACE_WITH_PRINTED_RESTORE_DIRECTORY
source_dir="$HOME/Documents/course-data"
sudo diff --no-dereference -r /etc/nginx "$restore_dir/config/etc/nginx"
sudo diff --no-dereference -r "$source_dir" "$restore_dir/data"

Compare conteúdos importantes, proprietários e modos numéricos com ls -ln, e as ACLs e os atributos estendidos necessários com getfacl/getfattr; instale acl/attr se necessário. Com --xattrs na extração, o GNU tar restaura por padrão apenas o espaço de nomes user; outros espaços exigem inclusão explícita e verificação de compatibilidade com o sistema de destino. Consulte o manual do tar no Ubuntu sobre atributos estendidos. A extração sozinha não completa a recuperação do serviço. Valide a configuração e o comportamento do aplicativo em um servidor de recuperação separado antes da restauração real. Limpe apenas o diretório de comparação identificado ao terminar.

Prepare armazenamento independente e detecção de falhas

Para um disco externo ou outro host, um diretório de destino existente não prova que o armazenamento está conectado. Compare o SOURCE/UUID do ponto de montagem de destino com a identidade registrada e pare em caso de incompatibilidade. Escrever em um diretório que não está montado pode preencher o disco do sistema. Planeje a capacidade, o acesso à descriptografia e gerações off-site ou offline de acordo com a necessidade de recuperação.

O guia de backup via shell do Ubuntu inclui exemplos com tar e restauração para um diretório diferente.

Automatize após a restauração manual ter sucesso. Registre o status de saída, o último sucesso, gerações retidas e falhas de espaço, e teste a rota de notificação. Um hash armazenado ao lado de um arquivo gravável não é por si só proteção contra adulteração; use registros de verificação independentes ou retenção imutável quando necessário.

Avalie a recuperação pelo comportamento dos dados e do serviço

No destino, verifique contagens de arquivos, conteúdo importante, propriedade e permissões, depois teste leituras/escritas de aplicativos e login de usuários. Verifique DNS, certificados, compartilhamentos e backups retomados conforme aplicável. Registre a duração da recuperação e atualizações perdidas; revise a frequência ou procedimentos se excederem os limites aceitáveis. Preserve a fonte com falha até que as evidências e os dados necessários estejam seguros.