Redis - Persistência, Backup e Restore em um banco de dados em memória

Há algum tempo buscava informações sobre o tema de persistência de dados no Redis e também como realizar um possível backup dos dados, utilizando um banco de dados em memória. Este artigo irá orientar de forma prática como realizar a persistência em disco dos dados do Redis e também como realizar o Backup e Restore utilizando os padrões de armazenamento da ferramenta.

Introdução a Persistência

Não podemos começar a falar de backup e restore sem mencionar um conceito muito importante relacionado ao Redis, este conceito recebe o nome de Persistência de Dados ou Redis Persistence, esse conceito nada mais é de forma resumida, a forma utilizada para armazenar / persistir os dados que estão em memória. E falando em persistência, temos duas maneiras de realizá-la, que são:

RDB - Com o Redis Database Backup, é possível executar um snapshot periódico dos dados, o RDB cria um arquivo .rdb, com o dump dos dados.

AOF - Append Only Files é responsável por armazenar os comandos em formato de Log sempre que uma operação é disparada para o servidor. O arquivo de Log gerado servirá para o restore, recriando assim as estruturas que estavam em memória em um momento anterior.
Agora que já sabemos o conceito básico de Persistência de dados no Redis, já temos uma idéia de como um Backup-Restore pode ser utilizado na plataforma, abaixo trago um exemplo com cada tipo (RDB e AOF) para praticarmos um pouco e assim poder aplicar nos mais diversos casos de uso.

Então mãos a massa …

Conhecimentos prévios

Pra melhor aproveitamento desse artigo, pressuponho que você leitor já tem um conhecimento básico do Docker e do Redis.

Casos de Uso

1 - Iremos realizar a criação de um container docker com o Redis e também um volume para que os dados sejam persistidos, posteriormente iremos realizar a criação de um Backup utilizando o RDB e também um Restore das informações em um novo ambiente.

2 - O mesmo princípio será abordado com o AOF, criaremos um container docker com o redis e também um volume, posteriormente iremos iniciar o redis no modo de appendonly, gravaremos algumas informações e realizaremos o restore em um novo ambiente.

Configurando o ambiente

Iremos criar dois volumes docker que serão utilizados para armazenar nossos backups

$ docker volume create backup_redis_rdb
$ docker volume create backup_redis_aof

Para listar os volumes criados, podemos utilizar

$ docker volume ls

Para descobrir em qual local "fisíco" o volume está montado, utilizamos:

$ docker volume inspect backup_redis_rdb
[
    {
        "CreatedAt": "2019-11-04T23:45:32Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/backup_redis_rdb/_data",
        "Name": "backup_redis_rdb",
        "Options": {},
        "Scope": "local"
    }
]

$ docker volume inspect backup_redis_aof
[
    {
        "CreatedAt": "2019-11-04T23:45:32Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/backup_redis_aof/_data",
        "Name": "backup_redis_aof",
        "Options": {},
        "Scope": "local"
    }
]

Agora iremos realizar o download de uma imagem Redis com o seguinte comando

$ docker pull redis

Utilizando RDB

Nesse passo iremos realizar a criação de um container do Redis, que utilizará o volume backup_redis_rdb para a persistência, por default a imagem do redis utiliza o diretório /data para armazenamento das informações.

$ docker run -d --name server_redis_rdb -p 6379:6379 -v backup_redis_rdb:/data redis

Acessaremos a console do redis, criaremos ao menos uma chave e executaremos o comando save

$ redis-cli -p 6379
127.0.0.1:6379> SET BD "Redis"
OK
127.0.0.1:6379> save
OK

Executando os passos acima, será gerado no diretório referente ao volume um arquivo binário chamado dump.rdb, esse arquivo contém um snapshot da base de dados. Utilizando o retorno do comando docker volume inspect citado anteriormente, podemos verificar o caminho referente ao arquivo e visualizar se realmente o arquivo foi criado:

O comando save pode ser escrito com mais algumas opções, por exemplo, a cada 60 segundos iremos tirar um snapshot se 500 chaves forem alteradas.

127.0.0.1:6379> save 60 500
OK

Restore RDB

Para restaurarmos em um novo ambiente, basta pegarmos o arquivo dump.rdb e utilizá-lo como base para o servidor em questão, no exemplo abaixo iremos criar um novo container do Redis apontando para o volume que contém o snapshot.

Pare a execução do container rdb

$ docker stop server_redis_rdb

Agora criaremos um novo container para o restore

$ docker run -d --name server_redis_rdb_restore -p 6379:6379 -v backup_redis_rdb:/data redis

Com o Snapshot, o servidor será recriado para o exato momento que o dump foi feito, podemos observar executando a consulta da chave que criamos anteriormente:

$ redis-cli -p 6379
127.0.0.1:6379> GET BD
"Redis"

Utilizando AOF

A opção de Append Only tem por finalidade realizar a gravação de cada comando executado, para isso iremos utilizar o volume backup_redis_aof, e também teremos que iniciar nosso container redis com a opção appendonly habilitada.

$ docker run -d --name server_redis_aof -p 6379:6379 -v backup_redis_aof:/data redis --appendonly yes

Iniciando o Redis dessa maneira, todos os comandos executados estão sendo gravados em um arquivo chamado appendonly.aof por default, para validarmos iremos executar alguns comandos no redis:

$ redis-cli -p 6379
127.0.0.1:6379> SET Banco "Redis"
OK
127.0.0.1:6379> GET Banco
"Redis"

Utilizando o retorno do comando docker volume inspect citado anteriormente, podemos verificar o caminho referente ao arquivo e visualizar se realmente foi criado, assim como seu conteúdo:

Restore AOF

Através desse arquivo conseguimos recriar nosso banco de dados, para tal iremos provisionar mais um container redis, com a opção de appendonly habilitada e apontando para o volume que contém o arquivo appendonly.aof já criado.

Pare a execução do container aof

$ docker stop server_redis_aof

Agora criaremos um novo container para o restore

$ docker run -d --name server_redis_aof_restore -p 6379:6379 -v backup_redis_aof:/data redis --appendonly yes

Dessa maneira, a estrutura será recriada de acordo com os comandos executados, podemos observar acessando o redis e consultando a chave criada anteriormente

$ redis-cli -p 6379
127.0.0.1:6379> GET Banco
"Redis"

Considerações Finais

Como vimos, as duas maneiras são bem interessantes para a realização de persistências e rotinas de backup, mas pode depender muito do seu caso de uso. O que temos que ter em mente é que os snapshots (RDB) são de momentos específicos do seu banco de dados, e que pode acarretar na perda de informações caso seu dump esteja desatualizado em relação ao momento da última gravação.
Já o AOF é uma solução que consegue armazenar praticamente tudo que é realizado no banco de dados, dependendo das configurações aplicadas, porém o tamanho do arquivo é bem superior ao RDB.
A solução recomendada é utilizar um mix das duas maneiras para a garantia e facilidade de transporte e integridade dos dados.

Agradecimentos

Gostaria de agradecer a André Mack Nardy, Ângelo Rafael da Silva, Edivan Olinda de Sousa Júnior, e Samuel Barreto pelo companheirismo de sempre na exploração das mais diversas tecnologias.

Sobre o autor

Henrique Lages Repulho é Especialista em Tecnologia da Informação na TecBan, onde atua com desenvolvimento de softwares e é integrante de um dos times responsáveis em realizar exploração de novas tecnologias dentro da TI.