Introdução à Infraestrutura de Backup Linux
A gestão de dados é um dos pilares fundamentais da infraestrutura de TI moderna. Para sysadmins e profissionais de DevOps, a perda de dados não é apenas um inconveniente operacional, mas uma falha crítica que pode comprometer a continuidade do negócio. Configurar um servidor de backups robusto exige mais do que simples cópias manuais; requer automação, verificação de integridade e, crucialmente, planos claros de recuperação (DR - Disaster Recovery).
Neste tutorial, abordaremos a configuração de um ambiente de backup seguro em ambientes Linux. Utilizaremos ferramentas padrão da indústria, como rsync para sincronização eficiente de arquivos e duplicity para backups criptografados e incrementais via SSH. O objetivo é fornecer um guia prático, direto e replicável para proteger seus servidores contra exclusões acidentais, corrupção de dados ou ataques de ransomware.
Planejamento da Estratégia de Backup
Antes de executar qualquer comando, é essencial definir a política de retenção e o tipo de backup. Uma boa prática é adotar o padrão 3-2-1: manter três cópias dos dados, em dois mídias diferentes, com uma delas fora do local (offsite). Para este tutorial, focaremos na replicação para um servidor remoto seguro via rede criptografada.
Definiremos os seguintes componentes:
- Servidor de Origem (Source): O servidor que contém os dados a serem protegidos.
- Servidor de Destino (Target): O servidor de backups dedicado onde os dados serão armazenados.
- Usuário de Backup: Uma conta de sistema com permissões restritas, utilizada exclusivamente para operações de leitura e escrita nos repositórios de backup.
Passo 1: Preparação do Servidor de Destino
O primeiro passo é garantir que o servidor que receberá os backups esteja preparado. Instalaremos as dependências necessárias e configuraremos o diretório de armazenamento.
Inicie sessão no seu servidor de backups (destino) e atualize o sistema:
sudo apt update && sudo apt upgrade -y
Instale o duplicity e suas dependências. O duplicity é uma ferramenta de backup em linha de comando que realiza backups criptografados de nível de arquivo usando a biblioteca GPG. Ele suporta uma ampla variedade de backends, incluindo SSH, S3 e FTP.
sudo apt install duplicity python3-paramiko python3-boto3 rsync gnupg
Crie um diretório dedicado para armazenar os backups. É recomendável usar permissões restritas para evitar que usuários não autorizados acessem ou modifiquem os dados de backup.
sudo mkdir -p /var/backups/remote_storage
sudo chown -R root:root /var/backups/remote_storage
sudo chmod 700 /var/backups/remote_storage
Passo 2: Configuração de Autenticação Segura (SSH)
A segurança é primordial. Nunca utilize senhas em texto claro para scripts de backup. Utilizaremos chaves SSH para autenticação mútua ou, neste caso, chave pública do servidor de origem para o servidor de destino.
No servidor de origem, gere um par de chaves SSH específico para o backup, se ainda não existir:
ssh-keygen -t ed25519 -C "backup_key" -f ~/.ssh/id_backup_ed25519 -N ""
Copie a chave pública para o servidor de destino. Substitua user@destino_ip pelo usuário e IP do seu servidor de backups:
ssh-copy-id -i ~/.ssh/id_backup_ed25519.pub user@destino_ip
Teste a conexão sem senha para garantir que a autentação está funcionando corretamente:
ssh -i ~/.ssh/id_backup_ed25519 user@destino_ip "echo 'Conexão SSH bem-sucedida'"
Passo 3: Configuração do GPG para Criptografia
O duplicity utiliza GPG para criptografar os dados antes de enviá-los. Você precisa gerar um par de chaves GPG no servidor de origem para assinar e criptografar o backup.
Gere uma chave GPG:
gpg --full-generate-key
Selecione as opções padrão (RSA and RSA, tamanho 4096 bits). Anote o Key ID gerado (ex: 12345678ABCD1234). Você também precisará da chave pública correspondente para importar no servidor de destino, permitindo a descriptografia se necessário.
Exporte a chave pública para compartilhamento:
gpg --armor --export 12345678ABCD1234 > backup_key.asc
Transfira o arquivo backup_key.asc para o servidor de destino e importe-o:
sudo gpg --import backup_key.asc
Passo 4: Execução do Backup com Duplicity
Agora que a infraestrutura está pronta, vamos executar o primeiro backup completo. O comando duplicity segue a sintaxe básica:
duplicity [opções] [origem] [destino]
Para realizar um backup completo do diretório /home/dados para o servidor remoto via SSH, utilize o seguinte comando:
duplicity \
--encrypt-key 12345678ABCD1234 \
--sign-key 12345678ABCD1234 \
/home/dados \
scp://user@destino_ip//var/backups/remote_storage
Explicação dos parâmetros:
--encrypt-key: Especifica a chave GPG usada para criptografar o backup.--sign-key: Especifica a chave GPG usada para assinar digitalmente o backup, garantindo integridade.scp://: Protocolo de transporte via SSH.//var/backups/remote_storage: O caminho absoluto no servidor de destino (note o duplo slash após o protocolo).
A primeira execução será lenta, pois realiza um backup completo. Execuções subsequentes realizarão apenas backups diferenciais ou incrementais, otimizando tempo e espaço em disco.
Passo 5: Automatização com Cron
Backups manuais estão sujeitos ao esquecimento. Para garantir a consistência dos dados, automatize a tarefa usando o cron.
Edite o crontab do usuário root ou do usuário dedicado:
sudo crontab -e
Adicione as seguintes linhas para executar backups incrementais diários às 2:00 da manhã e backups completos semanais aos domingos às 3:00:
# Backup incremental diário às 02:00
0 2 * * * duplicity --encrypt-key 12345678ABCD1234 --sign-key 12345678ABCD1234 /home/dados scp://user@destino_ip//var/backups/remote_storage
# Backup completo semanal aos domingos às 03:00
0 3 * * 0 duplicity full --encrypt-key 12345678ABCD1234 --sign-key 12345678ABCD1234 /home/dados scp://user@destino_ip//var/backups/remote_storage
Para gerenciar a retenção e evitar que o disco do servidor de backups encha, utilize a opção --remove-older-than. Por exemplo, para remover backups com mais de 30 dias:
duplicity remove-older-than 30M --encrypt-key CHAVE_GPG scp://user@destino_ip//var/backups/remote_storage
Passo 6: Sincronização Rápida com Rsync
Embora o duplicity seja excelente para backups criptografados e incrementais, há cenários onde a velocidade de sincronização de arquivos grandes é prioritária e a criptografia em tempo real pode ser um gargalo. Para esses casos, o rsync é a ferramenta padrão ouro.
O rsync é ideal para espelhamento de diretórios e transferências incrementais rápidas. Um comando típico de backup via rsync seria:
rsync -avz --delete -e "ssh -i ~/.ssh/id_backup_ed25519" /home/dados/ user@destino_ip:/var/backups/rsync_storage/
Parâmetros importantes:
-a: Modo arquivo, preserva permissões, tempos, owner e grupo.-v: Verbosidade para monitoramento.-z: Compressão durante a transferência.--delete: Remove arquivos no destino que foram excluídos na origem (use com cautela).
Aviso: O rsync não criptografa os dados em repouso por padrão. Se usar rsync para enviar para um servidor remoto, certifique-se de que o disco do destino esteja criptografado ou que a conexão SSH esteja bem configurada. Para proteção máxima contra exclusões acidentais, considere manter uma cópia imutável ou usar snapshots de sistema de arquivos (como ZFS ou Btrfs) antes de rodar o rsync.
Passo 7: Teste de Restore e Validação
O backup só é válido se o restore funcionar. Um plano de DR sem testes de recuperação é apenas uma esperança, não uma estratégia. Defina um calendário regular (mensal ou trimestral) para realizar testes de restauração.
Para testar a restauração com duplicity, você pode listar os backups disponíveis:
duplicity collection-status scp://user@destino_ip//var/backups/remote_storage
Para restaurar um diretório específico para um local temporário de teste:
duplicity restore \
--encrypt-key 12345678ABCD1234 \
scp://user@destino_ip//var/backups/remote_storage \
/tmp/test_restore
Verifique a integridade dos arquivos restaurados. Confirme que os dados estão completos e acessíveis. Se estiver usando rsync, compare hashes MD5 ou SHA256 entre a origem e o destino para garantir que não houve corrupção durante a transferência.
Melhores Práticas de Segurança e Monitoramento
Para manter a saúde do seu sistema de backup, adote as seguintes práticas:
- Monitoramento Ativo: Configure alertas (via email, Slack ou PagerDuty) para falhas de backup. Scripts de cron devem retornar códigos de erro não nulos em caso de falha.
- Imutabilidade: Se possível, utilize sistemas de arquivos que suportam WORM (Write Once, Read Many) ou snapshots imutáveis no servidor de destino para proteger contra ransomware que possa tentar criptografar seus backups.
- Segregação de Funções: O usuário usado para backup não deve ter privilégios de root no servidor de origem, apenas permissão de leitura nos diretórios relevantes. No servidor de destino, ele deve ter acesso apenas ao diretório de backups.
- Documentação: Mantenha um documento atualizado com as chaves GPG, credenciais SSH e procedimentos de restore. Em caso de desastre, o tempo para encontrar essa informação é crítico.
Conclusão
Estabelecer um servidor de backups confiável é uma responsabilidade contínua do sysadmin. Ao combinar a robustez do duplicity para backups criptografados e incrementais com a velocidade do rsync para sincronizações rápidas, você cria uma camada dupla de proteção.
Lembre-se: o objetivo final não é apenas fazer o backup, mas garantir a capacidade de restore rápida e íntegra. Invista tempo na automação e nos testes de recuperação. Dessa forma, sua infraestrutura estará preparada para lidar com imprevistos, garantindo a continuidade dos seus serviços digitais e a proteção dos dados essenciais.
Para aprofundar seus conhecimentos em infraestrutura Linux, explore documentações oficiais do duplicity e do rsync, e considere integrar esses processos a ferramentas de orquestração como Ansible para gerenciar múltiplos servidores de forma consistente.