Pesquisa de site

Como criar backups com Rsnapshot no Linux


Rsnapshot é um utilitário gratuito e de código aberto que funciona como um wrapper em torno do Rsync para executar instantâneos incrementais de sistemas locais ou remotos via SSH. Links físicos são usados para economizar espaço ao fazer backup de arquivos inalterados, para preservar espaço e ao mesmo tempo exibir sistemas de arquivos completos para o usuário. Neste tutorial, aprendemos como instalar e configurar o Rsnapshot em algumas das distribuições Linux mais utilizadas.

Neste tutorial você aprenderá:

  • Como instalar o rsnapshot em algumas das distribuições Linux mais usadas
  • Como configurar rsnapshots para fazer backup de máquinas locais e remotas via SSH

Instalação

Sendo o rsnapshot um utilitário gratuito e de código aberto, está disponível nos repositórios oficiais ou de terceiros confiáveis de todas as distribuições Linux mais utilizadas. Para instalar o utilitário no Fedora, por exemplo, basta iniciar nosso emulador de terminal favorito e emitir o seguinte comando:

$ sudo dnf install rsnapshot

Podemos instalar o Rsnapshot no RHEL (Red Hat Enterprise Linux) e seus clones, usando o mesmo comando; nessas distribuições, entretanto, precisamos adicionar previamente o repositório EPEL como fonte de software.

Para realizar a instalação no Debian, Ubuntu e outras distribuições baseadas em Debian, usamos o gerenciador de pacotes apt:

$ sudo apt install rsnapshot

Rsnapshot também está disponível no repositório “extra” do Archlinux. Podemos instalá-lo usando pacman:

$ sudo pacman -S rsnapshot

Depois de instalar o Rsnapshot em nossa distribuição Linux favorita, podemos usá-lo para criar backups incrementais. Vamos ver como.

Configuração do Rsnapshot

Para configurar o rsnapshot, editamos seu arquivo de configuração: /etc/rsnapshot.conf. Conforme indicado no grande aviso no início do arquivo, apenas tabulações devem ser utilizadas entre os elementos; o uso de espaços produziria erros de sintaxe:

#################################################
#                                               #
# PLEASE BE AWARE OF THE FOLLOWING RULE:        #
#                                               #
# This file requires tabs between elements      #
#                                               #
#################################################

A primeira diretiva que queremos definir no arquivo é snapshot_root. Como o próprio nome sugere, é usado para especificar o diretório onde todos os instantâneos devem ser salvos. No exemplo a seguir, usamos o diretório /snapshotscomo raiz dos snapshots:

# All snapshots will be stored under this root directory.
#
snapshot_root /snapshots/

Se o diretório não existir, ele será criado automaticamente quando o primeiro backup for realizado, a menos que a diretiva no_create_root esteja habilitada (o valor padrão normalmente é 0):

# If no_create_root is enabled, rsnapshot will not automatically create the
# snapshot_root directory. This is particularly useful if you are backing
# up to removable media, such as a FireWire or USB drive.
#
#no_create_root 1

Apontando Rsnapshot para o caminho rsync

Rsnapshot usa rsync para realizar backups, portanto devemos especificar a localização do binário rsync através da diretiva cmd_rsync. Isso é definido como /usr/bin/rsync por padrão e não requer alterações, a menos que instalemos o rsync em algum outro local:

# rsync must be enabled for anything to work. This is the only command that
# must be enabled.
#
cmd_rsync /usr/bin/rsync

Estabelecendo uma política de retenção

Antes de começarmos a criar nossos backups, precisamos estabelecer uma política de retenção: precisamos definir os diferentes tipos de backup e especificar quantos snapshots de um tipo específico devem ser retidos. Para estabelecer a política de retenção usamos a palavra-chave retain seguida pelo nome de um “tipo” de backup (o nome é completamente arbitrário), e por um número inteiro que especifica quantos backups desse tipo devem ser retidos. Aqui está a configuração padrão em um sistema Ubuntu:

#########################################
# BACKUP LEVELS / INTERVALS             #
# Must be unique and in ascending order #
# e.g. alpha, beta, gamma, etc.         #
#########################################
retain alpha 6
retain beta 7
retain gamma 4

Por padrão, “alfa”, “beta” e “gama” são usados como identificadores, no entanto, esses nomes não são realmente indicativos. Podemos querer usar outros mais amigáveis e significativos, por exemplo:

retain daily 6
retain weekly 7 
retain monthly 4

Novamente, lembre-se de que os nomes são completamente arbitrários e o Rsnapshot não sabe o que significam. Especificamos um tipo de backup quando invocamos o rsnapshot: tudo o que ele sabe é quantos backups de um tipo específico ele deve reter.

Especificando o que fazer backup

Para especificar quais arquivos e diretórios devem ser incluídos nos snapshots, usamos a diretiva backup e passamos o caminho que queremos incluir e o host onde ele está localizado. Aqui está uma configuração típica, que inclui os diretórios /home/, /etc/ e /usr/local/ no localhost como parte do cópias de segurança:

backup /home/      localhost/
backup /etc/       localhost/
backup /usr/local/ localhost/

Excluindo e incluindo arquivos de backups

Assim como ao usar o rsync diretamente, podemos querer excluir ou incluir explicitamente arquivos específicos de nossos backups. Para definir padrões de inclusão e exclusão ao usar rsnapshot, usamos as diretivas include e exclude e especificamos um padrão por linha:

exclude <exclude-pattern>

Da mesma forma, para especificar um padrão de inclusão, escreveríamos:

include <include-pattern>

Como estratégia alternativa podemos escrever padrões de inclusão e exclusão em arquivos dedicados e então passar o caminho desses arquivos como valores das diretivas include_file e exclude_file:

include_file /path/to/include/file
exclude_file /path/to/exclude/file

Verificando a configuração do Rsnapshot

Depois de modificarmos o arquivo de configuração do Rsnapshot para atender às nossas necessidades, podemos querer verificar se nossa configuração é sintaticamente válida. Podemos fazer isso usando o comando configtest:

$ sudo rsnapshot configtest

Se tudo correr conforme o esperado, o comando deverá retornar a seguinte mensagem:

Syntax OK

Mais uma vez, observe que apenas guias devem ser usadas no arquivo de configuração do rsnapshot. Espaços não são permitidos: seu uso será considerado um erro de sintaxe.

Testando e criando nosso primeiro backup

Para fazer o Rsnapshot imprimir o comando que ele executaria ao realizar um backup, sem realmente realizá-lo, podemos utilizar a opção -t, como no exemplo abaixo:

$ sudo rsnapshot -t daily

O comando deve retornar uma saída semelhante à abaixo:

echo 6080 > /var/run/rsnapshot.pid 
mkdir -m 0755 -p /snapshots/daily.0/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
    /home/ /snapshots/daily.0/localhost/ 
mkdir -m 0755 -p /snapshots/daily.0/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded /etc/ \
    /snapshots/daily.0/localhost/ 
mkdir -m 0755 -p /snapshots/daily.0/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
    /usr/local/ /snapshots/daily.0/localhost/ 
touch /snapshots/daily.0/

Para realmente criar nosso primeiro backup, apenas omitimos a opção -t, então, para criar nosso primeiro backup diário, executaríamos:

$ sudo rsnapshot daily

Assim que o backup for concluído, um diretório relacionado ao nosso primeiro backup diário será criado na raiz dos snapshots:

/snapshots/
└── daily.0
    └── localhost
        ├── etc
        ├── home
        └── usr

Vamos agora ver o que aconteceria se criássemos nosso segundo backup diário:

$ sudo rsnapshot -t daily

O comando retorna a seguinte saída:

bin/cp -al /snapshots/daily.0 /snapshots/daily.1 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
    /home/ /snapshots/daily.0/localhost/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded /etc/ \
    /snapshots/daily.0/localhost/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
    /usr/local/ /snapshots/daily.0/localhost/ 
touch /snapshots/daily.0/

Como você pode ver, primeiro o backup do diretório daily.0 seria copiado como daily.1, executando cp com o - Opções a e -l: a primeira é necessária para preservar todas as permissões e propriedades dos arquivos, enquanto a última faz com que os arquivos sejam vinculados em vez de copiados, a fim de preservar espaço. O novo backup usará o diretório daily.0 original como destino, portanto, sempre hospedará o snapshot mais recente.

Criando um backup de uma máquina remota

Podemos utilizar o Rsnapshot para realizar backups incrementais de máquinas remotas via SSH, implementando uma estratégia de backup “pull”: em vez de os clientes enviarem arquivos para o servidor de backup, o servidor se conecta aos clientes e realiza os backups “puxando” os arquivos deles.

A primeira coisa que precisamos fazer, para fazer backup de uma máquina remota, é garantir que a diretiva cmd_ssh exista e esteja descomentada no arquivo de configuração rsnapshot. O valor da diretiva é o caminho do executável do cliente ssh, que normalmente é instalado como /usr/bin/ssh:

cmd_ssh /usr/bin/ssh

Agora, suponha que queiramos fazer backup do conteúdo do diretório /etc de uma máquina remota com IP 192.168.122.49, logando-se como usuário “ubuntu”. Aqui está o que escreveríamos no arquivo de configuração do rsnapshot:

backup ubuntu@192.168.122.49:/etc client0

Onde “client0” é apenas o identificador da máquina (pode ser qualquer coisa). Para que o backup seja bem-sucedido, um servidor SSH funcional deve estar instalado e funcionando no destino, e a chave pública que queremos usar para a conexão já deve ter sido autorizada.

Conclusões

Rsnapshot é um utilitário gratuito e de código aberto que funciona como um wrapper em torno do Rsync para realizar backups incrementais. Neste tutorial, aprendemos como instalar e configurar o rsnapshot em algumas das distribuições Linux mais utilizadas. Vimos como especificar os diretórios dos quais queremos fazer backup em máquinas locais e remotas, como estabelecer uma política de retenção e como especificar onde os snapshots devem ser salvos.

Artigos relacionados: