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 /snapshots
como 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.