Passos para Criar um Cluster Redis em Contêineres Docker

25/06/2024

Um cluster Redis no Docker oferece uma solução escalável e de alta disponibilidade para armazenar dados em cache e gerenciar sessões em aplicações. Ao distribuir os dados entre múltiplos nós Redis em contêineres Docker, o cluster garante que, mesmo com a falha de um nó, os dados permaneçam acessíveis, evitando interrupções no serviço. Essa configuração permite lidar com grandes volumes de dados e tráfego intenso, ideal para aplicações que exigem desempenho e confiabilidade. O uso de contêineres Docker simplifica a implantação e o gerenciamento do cluster, proporcionando portabilidade e isolamento entre os nós, além de facilitar a escalabilidade horizontal para atender às demandas crescentes da aplicação. Com o cluster Redis no Docker, você garante a resiliência dos dados, melhora o desempenho da aplicação e simplifica a gestão da infraestrutura, tornando-se uma escolha eficiente para lidar com dados em cache em ambientes modernos e dinâmicos.

O uso de dados em cache oferece diversas vantagens significativas, especialmente em termos de desempenho e eficiência:

1. Melhora do desempenho:

Acesso mais rápido aos dados: Os dados em cache são armazenados em locais de acesso rápido, como a memória RAM, que é muito mais rápida do que o armazenamento em disco ou a busca em bancos de dados. Isso permite que a aplicação acesse informações com muito mais agilidade, reduzindo o tempo de resposta e melhorando a experiência do usuário.
Redução da carga do servidor: Ao armazenar dados em cache, a aplicação evita a necessidade de buscar informações repetidamente de fontes mais lentas, como bancos de dados ou APIs externas. Isso reduz a carga no servidor, permitindo que ele atenda a mais solicitações e melhore a escalabilidade da aplicação.

2. Redução do consumo de recursos:

Economia de banda: Ao armazenar dados em cache, a aplicação evita a necessidade de baixar informações repetidamente da internet, economizando banda e reduzindo o consumo de dados.
Otimização do uso de disco: O cache pode reduzir a necessidade de acessar o disco rígido, que é mais lento do que a memória RAM. Isso pode prolongar a vida útil do disco e melhorar o desempenho geral do sistema.

3. Aumento da disponibilidade:

Funcionamento offline: Em alguns casos, o cache pode permitir que a aplicação continue funcionando mesmo quando a conexão com a internet ou com o banco de dados está indisponível, garantindo a continuidade do serviço.

4. Escalabilidade aprimorada:

Distribuição da carga: Em sistemas distribuídos, o cache pode ser usado para distribuir a carga de trabalho entre vários servidores, melhorando a escalabilidade e a resiliência da aplicação.

Exemplos de uso de cache:

Armazenamento de resultados de consultas: Em aplicações que fazem consultas frequentes a bancos de dados, o cache pode armazenar os resultados dessas consultas, evitando a necessidade de reexecutá-las a cada solicitação.
Cache de páginas web: Navegadores web armazenam em cache páginas web, imagens e outros recursos para que possam ser carregados mais rapidamente em visitas subsequentes.
Cache de dados em aplicativos móveis: Aplicativos móveis podem armazenar em cache dados para que possam funcionar offline ou para reduzir o consumo de dados.

A utilização de dados em cache é uma estratégia fundamental para melhorar o desempenho, a eficiência e a escalabilidade de aplicações, proporcionando uma experiência mais rápida e responsiva para os usuários.

O uso de cache impacta positivamente na redução de custos da aplicação sob diversos aspectos financeiros:

Redução dos custos de infraestrutura:

Menos servidores: Ao melhorar o desempenho e a escalabilidade da aplicação, o cache permite que você utilize menos servidores para atender à mesma demanda. Isso se traduz em economia nos custos de hardware, energia e manutenção.
Menor necessidade de upgrades: Com o cache otimizando o uso dos recursos existentes, a necessidade de realizar upgrades de hardware para lidar com o aumento da carga de trabalho é reduzida, adiando investimentos em novos equipamentos.

Redução dos custos de banda:

Menos tráfego de dados: O cache reduz a quantidade de dados transferidos entre a aplicação e os servidores de banco de dados ou APIs externas, resultando em economia nos custos de banda, especialmente em aplicações que utilizam serviços em nuvem com cobrança por transferência de dados.

Melhora da eficiência operacional:

Menos tempo de inatividade: O cache pode ajudar a manter a aplicação funcionando mesmo durante falhas temporárias nos servidores de banco de dados ou APIs externas, reduzindo o tempo de inatividade e os custos associados a interrupções no serviço.
Manutenção simplificada: Ao reduzir a carga nos servidores de banco de dados, o cache pode simplificar a manutenção e otimizar o desempenho do banco de dados, resultando em economia de tempo e recursos.

Aumento da receita:

Melhor experiência do usuário: A melhoria no desempenho proporcionada pelo cache resulta em uma experiência mais rápida e responsiva para os usuários, o que pode aumentar o engajamento, a retenção e, consequentemente, a receita da aplicação.

Passos para Criar um Cluster Redis em Contêineres Docker

Baixar a Imagem Oficial do Redis:

docker pull redis:latest

Criar Arquivos de Configuração para os Nós do Redis:

Crie seis arquivos de configuração, um para cada nó do cluster (exemplo: redis-node-1.conf, redis-node-2.conf, etc.).

Use o VisualStudio Code ou outra ide, crie um arquivo de configuração pra cada nó, modificando apenas o número das portas:

port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

Criar o Arquivo docker-compose.yml:

Abra o Visual Studio Code e crie uma pasta. Dentro dela, adicione o arquivo docker-compose.yml com o seguinte conteúdo:

version: '3'
services:
redis-node-1:
image: redis:latest
container_name: redis-node-1
ports:
- "7000:7000"
volumes:
- ./redis-config/redis-node-1.conf:/usr/local/etc/redis/redis.conf
command: redis-server /usr/local/etc/redis/redis.conf
redis-node-2:
image: redis:latest
container_name: redis-node-2
ports:
- "7001:7001"
volumes:
- ./redis-config/redis-node-2.conf:/usr/local/etc/redis/redis.conf
command: redis-server /usr/local/etc/redis/redis.conf
redis-node-3:
image: redis:latest
container_name: redis-node-3
ports:
- "7002:7002"
volumes:
- ./redis-config/redis-node-3.conf:/usr/local/etc/redis/redis.conf
command: redis-server /usr/local/etc/redis/redis.conf
redis-node-4:
image: redis:latest
container_name: redis-node-4
ports:
- "7003:7003"
volumes:
- ./redis-config/redis-node-4.conf:/usr/local/etc/redis/redis.conf
command: redis-server /usr/local/etc/redis/redis.conf
redis-node-5:
image: redis:latest
container_name: redis-node-5
ports:
- "7004:7004"
volumes:
- ./redis-config/redis-node-5.conf:/usr/local/etc/redis/redis.conf
command: redis-server /usr/local/etc/redis/redis.conf
redis-node-6:
image: redis:latest
container_name: redis-node-6
ports:
- "7005:7005"
volumes:
- ./redis-config/redis-node-6.conf:/usr/local/etc/redis/redis.conf
command: redis-server /usr/local/etc/redis/redis.conf

Subir os Contêineres:

No terminal, navegue até a pasta criada e execute:

docker-compose up -d

Criar o Cluster Redis:

Após os contêineres estarem em execução, acesse um dos contêineres e crie o cluster:

docker exec -it redis-node-1 redis-cli --cluster create \
127.0.0.1:7000 \
127.0.0.1:7001 \
127.0.0.1:7002 \
127.0.0.1:7003 \
127.0.0.1:7004 \
127.0.0.1:7005 \
--cluster-replicas 1

Verificar o Estado do Cluster:

Verifique o estado do cluster acessando qualquer nó e usando o comando:

docker exec -it redis-node-1 redis-cli -p 7000 cluster nodes

Obter os IPs dos Contêineres:

Para saber os IPs dos contêineres Redis em execução, use

docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis-node-1
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis-node-2
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis-node-3
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis-node-4
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis-node-5
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis-node-6

Criar o Cluster com os IPs Obtidos:

Supondo que você obteve os seguintes IPs:

redis-node-1: 172.18.0.2
redis-node-2: 172.18.0.3
redis-node-3: 172.18.0.4
redis-node-4: 172.18.0.5
redis-node-5: 172.18.0.6
redis-node-6: 172.18.0.7

Crie o cluster Redis usando esses IPs:

redis-cli --cluster create \
172.18.0.2:7000 \
172.18.0.3:7001 \
172.18.0.4:7002 \
172.18.0.5:7003 \
172.18.0.6:7004 \
172.18.0.7:7005 \
--cluster-replicas 1

Verificar o Estado do Cluster:

Após criar o cluster, você pode verificar o estado do cluster com o comando:

redis-cli -h 172.18.0.2 -p 7000 cluster nodes

Reiniciar os Contêineres:

Use o comando para reiniciar os contêineres:

docker-compose restart

Verificação do Estado do Cluster:

Verifique o estado do cluster e os nós com:

redis-cli -p 7000 cluster nodes

Verificar Conectividade e Slots:

Verifique se todos os slots estão devidamente alocados e se todos os nós estão conectados corretamente:

redis-cli -p 7000 cluster info

Testar o Cluster:

Teste inserindo e recuperando dados no cluster

redis-cli -p 7000
SET key1 "value1"
GET key1

Próximos Passos:

Insira e recupere dados no cluster:

redis-cli -p 7000 set mykey "Hello Redis Cluster"
redis-cli -p 7000 get mykey

Para habilitar o redirecionamento automático de comandos no cluster Redis, use a opção -c:

redis-cli -c -p 7000 set mykey "Hello Redis Cluster"
redis-cli -c -p 7000 get mykey

Requisitos Mínimos para Redis Cluster

Três Nós Principais (Masters):
- Redistribui os slots de hash entre os três nós.
- Proporciona a funcionalidade básica de um cluster.
Nós Replicados (Slaves) (Opcional mas recomendável):
- Adicione pelo menos um nó replicado para cada nó principal para alta disponibilidade.
- No caso de falha de um nó principal, um dos nós replicados pode assumir seu lugar.

Exemplo de Configuração com Seis Nós

3 Nós Principais (Masters):
- Node1 (172.18.0.2)
- Node2 (172.18.0.3)
- Node3 (172.18.0.4)
3 Nós Replicados (Slaves):
- Node4 (172.18.0.5) -> Réplica de Node1
- Node5 (172.18.0.6) -> Réplica de Node2
- Node6 (172.18.0.7) -> Réplica de Node3

Verificar o Estado do Cluster

Conecte-se a qualquer nó do cluster e execute:

redis-cli -c -h 172.18.0.2 -p 6379
cluster nodes

Pontos de Verificação

Verifique se o Arquivo de Configuração do Redis Está Correto:
- Certifique-se de que cada arquivo de configuração está corretamente configurado.
Certifique-se de que as Portas Estão Disponíveis:
- Certifique-se de que as portas 6379, 6380, 6381, 6382, 6383, e 6384 não estão sendo usadas por outros serviços no seu host.
Iniciar o Cluster Redis:
- Após iniciar os contêineres, configure o cluster Redis usando o redis-cli com a opção --cluster.

Correção Recomendada

Adicione a configuração depends_on no docker-compose.yml para garantir que os contêineres Redis sejam iniciados na ordem correta.

Seguindo esses passos, você conseguirá configurar e gerenciar um cluster Redis em contêineres Docker de maneira eficaz.

Autor: José Darci Rodrigues Junior