Qual e a diferenca entre a persistencia RDB e AOF do Redis?

RDB (Redis Database) cria snapshots pontuais do seu conjunto de dados em intervalos especificados, resultando em arquivos binarios compactos ideais para backups. AOF (Append Only File) registra cada operacao de escrita, proporcionando melhor durabilidade ja que voce perde no maximo um segundo de dados. Voce pode usar ambos simultaneamente para maxima seguranca de dados.

Quanta memoria o Redis precisa para producao?

O Redis armazena todos os dados na RAM, entao voce precisa de memoria suficiente para conter todo o seu conjunto de dados mais overhead. Uma regra geral e alocar pelo menos 25% mais memoria do que o tamanho esperado do seu conjunto de dados. Configure a diretiva maxmemory no redis.conf para evitar que o Redis consuma toda a RAM do sistema.

O Redis e single-threaded?

O Redis processa comandos usando uma unica thread para seu loop de eventos principal, o que evita overhead de troca de contexto e complexidade de locks. No entanto, a partir do Redis 6.0, threading de E/S foi introduzido para lidar com leituras e escritas de rede em paralelo. Tarefas em segundo plano como persistencia e exclusao lazy tambem rodam em threads separadas.

O Redis pode substituir um banco de dados tradicional?

O Redis pode servir como banco de dados principal para casos de uso especificos, mas e mais adequado como camada de cache, armazenamento de sessoes ou message broker junto a um banco de dados tradicional. Como o Redis armazena dados na RAM, o custo por gigabyte e significativamente maior que bancos de dados baseados em disco. Use o Redis para acelerar leituras e descarregar seu banco de dados principal.

Redis Caching: Instalar, Configurar e Otimizar para Producao

O Redis e um armazenamento de estruturas de dados em memoria de codigo aberto que funciona como banco de dados, cache, message broker e motor de streaming. Sua capacidade de servir dados diretamente da RAM o torna extraordinariamente rapido, com tempos de resposta tipicos inferiores a um milissegundo. Este guia orienta voce na implantacao do Redis no Ubuntu Server, configurando-o para cargas de trabalho de producao, protegendo-o contra ameacas comuns e monitorando seu desempenho com ferramentas integradas.

Pre-requisitos

Antes de comecar, certifique-se de ter:

Ubuntu Server 20.04, 22.04 ou 24.04
Acesso ao terminal com privilegios sudo
Pelo menos 1 GB de RAM disponivel (mais para conjuntos de dados de producao)
Familiaridade basica com a linha de comando do Linux
Um firewall configurado para restringir acesso (consulte nosso guia UFW)

O Que E o Redis?

Redis significa Remote Dictionary Server (Servidor de Dicionario Remoto). Criado por Salvatore Sanfilippo em 2009, tornou-se um dos armazenamentos de dados em memoria mais amplamente utilizados no mundo. Diferente de bancos de dados tradicionais que leem e escrevem em disco, o Redis mantem todo o conjunto de dados na memoria, o que permite entregar latencia inferior a um milissegundo tanto para operacoes de leitura quanto de escrita.

Caracteristicas principais do Redis:

Armazenamento em memoria — todos os dados residem na RAM para velocidade maxima
Estruturas de dados ricas — suporta strings, hashes, listas, conjuntos, conjuntos ordenados, streams e mais
Persistencia opcional — pode gravar dados em disco para durabilidade
Replicacao — suporta arquitetura master-replica para alta disponibilidade
Operacoes atomicas — todos os comandos sao executados atomicamente
Mensageria Pub/Sub — sistema de publicacao/assinatura integrado para comunicacao em tempo real
Scripting Lua — execute scripts do lado do servidor para operacoes complexas

Casos de Uso do Redis

O Redis se destaca em cenarios onde a velocidade e critica:

Camada de cache: Coloque o Redis entre sua aplicacao e o banco de dados principal para servir dados frequentemente solicitados da memoria. Isso reduz a carga do banco de dados e melhora os tempos de resposta drasticamente.

Armazenamento de sessoes: Armazene sessoes de usuarios no Redis em vez de armazenamentos baseados em disco. Isso permite o compartilhamento de sessoes entre multiplos servidores de aplicacao e fornece acesso rapido de leitura/escrita.

Filas de mensagens: Use listas ou streams do Redis como filas de mensagens leves para processamento assincrono de tarefas. Workers podem consumir mensagens de forma confiavel usando pops bloqueantes ou grupos de consumidores.

Mensageria Pub/Sub: Transmita eventos em tempo real para multiplos assinantes. Comum para aplicacoes de chat, notificacoes ao vivo e dashboards em tempo real.

Limitacao de taxa: Implemente limitacao de taxa de API usando contadores do Redis com expiracao automatica. Os recursos de incremento atomico e TTL tornam isso direto.

Placar e rankings: Conjuntos ordenados fornecem suporte natural para dados classificados com insercao e recuperacao O(log N) por pontuacao.

Instalando o Redis no Ubuntu

A abordagem recomendada e instalar o Redis a partir do repositorio APT oficial para obter a ultima versao estavel.

Adicionar o Repositorio Oficial do Redis

sudo apt update
sudo apt install -y lsb-release curl gpg
curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
sudo apt update

Instalar o Redis

sudo apt install -y redis-server

Verificar a Instalacao

redis-cli ping

Voce deve receber:

PONG

Verifique a versao instalada:

redis-server --version

Verifique o status do servico:

sudo systemctl status redis-server

Habilite o Redis para iniciar na inicializacao:

sudo systemctl enable redis-server

Conceitos Basicos de Configuracao

O arquivo principal de configuracao do Redis esta localizado em /etc/redis/redis.conf. Antes de fazer alteracoes, crie um backup:

sudo cp /etc/redis/redis.conf /etc/redis/redis.conf.backup

Abra o arquivo de configuracao:

sudo nano /etc/redis/redis.conf

Binding de Rede

Por padrao, o Redis faz bind em 127.0.0.1 (somente localhost). Para uma camada de cache acessada por aplicacoes locais, esta e a configuracao mais segura:

bind 127.0.0.1 ::1

Se clientes remotos precisam de acesso, adicione o IP privado do servidor:

bind 127.0.0.1 192.168.1.100

Aviso: Nunca faca bind do Redis em 0.0.0.0 em um servidor voltado ao publico sem autenticacao adequada e regras de firewall. Instancias Redis expostas sao um alvo frequente de ataques automatizados.

Configuracao de Porta

A porta padrao e 6379. Altere-a se quiser reduzir varreduras automatizadas:

port 6379

Memoria Maxima

Defina um limite rigido de memoria para evitar que o Redis consuma toda a RAM do sistema:

maxmemory 256mb

Ajuste este valor com base na memoria disponivel do seu servidor. Uma regra comum e nao alocar mais que 75% da RAM total para o Redis se ele for a carga de trabalho principal no servidor.

Politicas de Eviction

Quando o Redis atinge o limite de maxmemory, ele usa uma politica de eviction para decidir quais chaves remover. Defina a politica com:

maxmemory-policy allkeys-lru

Politicas de eviction disponiveis:

Politica	Descricao
`noeviction`	Retorna erros quando o limite de memoria e atingido (padrao)
`allkeys-lru`	Remove as chaves menos recentemente usadas de todas as chaves
`allkeys-lfu`	Remove as chaves menos frequentemente usadas de todas as chaves
`volatile-lru`	Remove as chaves menos recentemente usadas com expiracao definida
`volatile-lfu`	Remove as chaves menos frequentemente usadas com expiracao definida
`allkeys-random`	Remove chaves aleatorias de todas as chaves
`volatile-random`	Remove chaves aleatorias com expiracao definida
`volatile-ttl`	Remove chaves com o tempo de expiracao mais proximo

Para um cache de proposito geral, allkeys-lru e a escolha mais comum. Para cargas de trabalho onde a frequencia de acesso importa mais que a recencia, use allkeys-lfu.

Apos modificar a configuracao, reinicie o Redis:

sudo systemctl restart redis-server

Opcoes de Persistencia

O Redis fornece dois mecanismos para persistir dados em disco.

Snapshots RDB

RDB cria snapshots pontuais em intervalos configurados. Isto esta habilitado por padrao:

save 3600 1 300 100 60 10000

Isso significa:

Salvar se pelo menos 1 chave mudou em 3600 segundos (1 hora)
Salvar se pelo menos 100 chaves mudaram em 300 segundos (5 minutos)
Salvar se pelo menos 10000 chaves mudaram em 60 segundos (1 minuto)

O arquivo de snapshot e armazenado em:

dbfilename dump.rdb
dir /var/lib/redis

Vantagens do RDB:

Representacao compacta de arquivo unico dos seus dados
Perfeito para backups e recuperacao de desastres
Impacto minimo no desempenho durante operacoes normais
Reinicializacoes mais rapidas comparado ao AOF

Desvantagens do RDB:

Perda de dados entre snapshots (ate varios minutos)
A operacao de fork pode ser lenta em conjuntos de dados grandes

AOF (Append Only File)

AOF registra cada operacao de escrita para melhor durabilidade:

appendonly yes
appendfilename "appendonly.aof"

Configure a politica de sincronizacao:

# appendfsync always   # Sincronizar apos cada escrita (mais seguro, mais lento)
appendfsync everysec    # Sincronizar uma vez por segundo (recomendado)
# appendfsync no        # Deixar o SO lidar com a sincronizacao (mais rapido, menos seguro)

Vantagens do AOF:

Melhor durabilidade (no maximo 1 segundo de perda de dados com everysec)
Formato append-only e resistente a corrupcao
Reescreve automaticamente para compactar o log

Desvantagens do AOF:

Maior tamanho de arquivo comparado ao RDB
Reinicializacoes mais lentas para conjuntos de dados grandes

Usando Ambos

Para maxima seguranca de dados, habilite tanto RDB quanto AOF:

save 3600 1 300 100 60 10000
appendonly yes
appendfsync everysec

Quando ambos estao habilitados, o Redis usa o arquivo AOF para restaurar dados na inicializacao, pois tipicamente e mais completo.

Hardening de Seguranca

Uma instancia Redis sem seguranca e um risco significativo. Aplique as seguintes medidas para implantacoes em producao.

Definir uma Senha

Configure a autenticacao com uma senha forte:

requirepass sua-senha-muito-forte-aqui

Clientes devem se autenticar antes de executar comandos:

redis-cli
AUTH sua-senha-muito-forte-aqui

Ou conecte com a senha inline:

redis-cli -a sua-senha-muito-forte-aqui

Renomear Comandos Perigosos

Desabilite ou renomeie comandos que podem causar danos:

rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command DEBUG ""
rename-command CONFIG "ADMIN_CONFIG_b4f8e2a1"

Definir um comando como uma string vazia "" o desabilita completamente. Renomea-lo para uma string aleatoria longa o torna acessivel apenas para administradores que conhecem o novo nome.

Restringir Acesso de Rede

Sempre faca bind do Redis em interfaces especificas e use um firewall:

bind 127.0.0.1 192.168.1.100
protected-mode yes

Adicione uma regra UFW para restringir o acesso ao Redis:

sudo ufw allow from 192.168.1.0/24 to any port 6379

Habilitar TLS (Redis 6+)

Para conexoes criptografadas, configure TLS:

tls-port 6380
port 0
tls-cert-file /etc/redis/tls/redis.crt
tls-key-file /etc/redis/tls/redis.key
tls-ca-cert-file /etc/redis/tls/ca.crt

Gere certificados para testes:

sudo mkdir -p /etc/redis/tls
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout /etc/redis/tls/redis.key \
  -out /etc/redis/tls/redis.crt \
  -subj "/CN=redis-server"
sudo cp /etc/redis/tls/redis.crt /etc/redis/tls/ca.crt
sudo chown redis:redis /etc/redis/tls/*

Conecte com TLS:

redis-cli --tls --cert /etc/redis/tls/redis.crt --key /etc/redis/tls/redis.key --cacert /etc/redis/tls/ca.crt -p 6380

Desabilitar o Usuario Padrao (ACLs do Redis 6+)

O Redis 6 introduziu Listas de Controle de Acesso para permissoes granulares:

redis-cli
ACL SETUSER admin on >senha-forte ~* +@all
ACL SETUSER default off

Isso cria um usuario admin com acesso completo e desabilita o usuario padrao.

Tipos de Dados e Operacoes

O Redis suporta varias estruturas de dados, cada uma otimizada para casos de uso especificos.

Strings

O tipo mais basico. Armazene texto, numeros ou dados serializados:

SET user:1:name "Alice"
GET user:1:name
# "Alice"

SET counter 100
INCR counter
# 101

SET session:abc123 "session_data" EX 3600
# Expira em 3600 segundos

Hashes

Armazene objetos como pares campo-valor:

HSET user:1 name "Alice" email "alice@example.com" age 30
HGET user:1 name
# "Alice"

HGETALL user:1
# 1) "name"
# 2) "Alice"
# 3) "email"
# 4) "alice@example.com"
# 5) "age"
# 6) "30"

Listas

Colecoes ordenadas (listas encadeadas) ideais para filas:

LPUSH tasks "send_email"
LPUSH tasks "process_payment"
RPOP tasks
# "send_email"

LRANGE tasks 0 -1
# 1) "process_payment"

Conjuntos

Colecoes desordenadas de elementos unicos:

SADD tags:post:1 "redis" "caching" "nosql"
SMEMBERS tags:post:1
# 1) "redis"
# 2) "caching"
# 3) "nosql"

SISMEMBER tags:post:1 "redis"
# 1

Conjuntos Ordenados

Conjuntos ordenados por uma pontuacao, perfeitos para placares:

ZADD leaderboard 100 "player1" 250 "player2" 175 "player3"
ZREVRANGE leaderboard 0 -1 WITHSCORES
# 1) "player2"
# 2) "250"
# 3) "player3"
# 4) "175"
# 5) "player1"
# 6) "100"

ZRANK leaderboard "player3"
# 1

Gerenciamento de Memoria e Politicas de Eviction

O gerenciamento eficaz de memoria e critico para o desempenho e estabilidade do Redis.

Monitorando o Uso de Memoria

redis-cli INFO memory

Metricas principais a observar:

Metrica	Descricao
`used_memory`	Total de bytes alocados pelo Redis
`used_memory_human`	Memoria usada em formato legivel
`used_memory_rss`	Resident Set Size (RAM real utilizada)
`used_memory_peak`	Pico de uso de memoria
`mem_fragmentation_ratio`	Razao de RSS para used_memory

Um mem_fragmentation_ratio significativamente acima de 1.5 indica fragmentacao de memoria. Valores abaixo de 1.0 significam que o Redis esta usando swap em disco, o que degrada severamente o desempenho.

Reduzindo o Uso de Memoria

Use nomes de chave mais curtos onde for pratico:

# Em vez de
SET user:session:authentication:token:abc123 "data"

# Use
SET u:s:t:abc123 "data"

Defina TTL em chaves de cache para garantir que dados obsoletos sejam removidos:

SET cache:product:42 "product_data" EX 300

Use hashes para objetos pequenos — o Redis otimiza hashes pequenos com codificacao ziplist:

HSET user:1 name "Alice" email "alice@example.com"

Habilite a liberacao lazy para evitar bloqueios durante exclusoes de chaves grandes:

lazyfree-lazy-eviction yes
lazyfree-lazy-expire yes
lazyfree-lazy-server-del yes

Desfragmentacao de Memoria (Redis 4+)

Habilite a desfragmentacao ativa para recuperar memoria fragmentada:

activedefrag yes
active-defrag-ignore-bytes 100mb
active-defrag-threshold-lower 10
active-defrag-threshold-upper 100

Monitoramento com redis-cli e o Comando INFO

O Redis fornece varias ferramentas integradas para monitoramento.

O Comando INFO

O comando INFO retorna informacoes abrangentes do servidor:

redis-cli INFO

Solicite secoes especificas:

redis-cli INFO server
redis-cli INFO memory
redis-cli INFO stats
redis-cli INFO replication
redis-cli INFO clients
redis-cli INFO keyspace

Monitoramento em Tempo Real

Observe todos os comandos processados pelo Redis em tempo real:

redis-cli MONITOR

Cuidado: O comando MONITOR introduz overhead e nao deve ser deixado rodando em producao. Use-o apenas para sessoes de depuracao.

Log de Consultas Lentas

Identifique comandos que excedem um tempo de execucao especificado:

redis-cli SLOWLOG GET 10

Configure o limiar do slow log (em microssegundos):

slowlog-log-slower-than 10000
slowlog-max-len 128

Isso registra qualquer comando que leve mais de 10 milissegundos.

Conexoes de Clientes

Liste todos os clientes conectados:

redis-cli CLIENT LIST

Verifique o numero total de conexoes:

redis-cli INFO clients

Metricas principais de clientes:

connected_clients:15
blocked_clients:0
maxclients:10000

Monitoramento de Latencia

Habilite o monitoramento de latencia e meca-o:

redis-cli CONFIG SET latency-monitor-threshold 100
redis-cli LATENCY LATEST
redis-cli LATENCY HISTORY event-name

Redis como Armazenamento de Sessoes

O Redis e uma excelente escolha para armazenar sessoes de aplicacao, permitindo o compartilhamento de sessoes entre multiplos servidores.

Exemplo com Node.js e Express

const express = require('express');
const session = require('express-session');
const RedisStore = require('connect-redis').default;
const { createClient } = require('redis');

const redisClient = createClient({
  url: 'redis://127.0.0.1:6379',
  password: 'your-redis-password'
});
redisClient.connect();

const app = express();

app.use(session({
  store: new RedisStore({ client: redisClient }),
  secret: 'your-session-secret',
  resave: false,
  saveUninitialized: false,
  cookie: {
    secure: true,
    httpOnly: true,
    maxAge: 1800000 // 30 minutes
  }
}));

app.get('/', (req, res) => {
  req.session.views = (req.session.views || 0) + 1;
  res.send(`Views: ${req.session.views}`);
});

app.listen(3000, () => console.log('Server running on port 3000'));

Exemplo com Python e Flask

from flask import Flask, session
from flask_session import Session
import redis

app = Flask(__name__)
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.Redis(
    host='127.0.0.1',
    port=6379,
    password='your-redis-password'
)
app.config['SESSION_PERMANENT'] = True
app.config['PERMANENT_SESSION_LIFETIME'] = 1800  # 30 minutes

Session(app)

@app.route('/')
def index():
    session['views'] = session.get('views', 0) + 1
    return f"Views: {session['views']}"

if __name__ == '__main__':
    app.run()

Referencia de Comandos Essenciais do redis-cli

Comando	Descricao
`redis-cli ping`	Testar a conectividade do servidor
`redis-cli INFO`	Exibir informacoes e estatisticas do servidor
`redis-cli INFO memory`	Exibir detalhes de uso de memoria
`redis-cli MONITOR`	Observar todos os comandos em tempo real
`redis-cli DBSIZE`	Retornar o numero de chaves no banco de dados atual
`redis-cli KEYS pattern`	Encontrar chaves correspondentes a um padrao (usar com cautela em producao)
`redis-cli SCAN 0 MATCH pattern COUNT 100`	Varrer chaves iterativamente (alternativa segura para producao ao KEYS)
`redis-cli SET key value EX seconds`	Definir uma chave com expiracao
`redis-cli GET key`	Recuperar o valor de uma chave
`redis-cli DEL key`	Excluir uma ou mais chaves
`redis-cli TTL key`	Verificar o tempo de vida restante de uma chave
`redis-cli EXPIRE key seconds`	Definir um tempo de expiracao em uma chave
`redis-cli FLUSHDB`	Remover todas as chaves do banco de dados atual
`redis-cli SLOWLOG GET 10`	Ver as 10 consultas lentas mais recentes
`redis-cli CLIENT LIST`	Listar todos os clientes conectados
`redis-cli CONFIG GET maxmemory`	Recuperar um parametro de configuracao
`redis-cli CONFIG SET maxmemory 512mb`	Alterar um parametro de configuracao em tempo de execucao
`redis-cli BGSAVE`	Acionar um snapshot RDB em segundo plano
`redis-cli BGREWRITEAOF`	Acionar uma reescrita do AOF
`redis-cli SHUTDOWN SAVE`	Parar o servidor e salvar dados em disco

Solucao de Problemas

Redis Nao Inicia

Verifique os logs em busca de erros:

sudo journalctl -u redis-server -n 50
sudo cat /var/log/redis/redis-server.log

Causas comuns:

Erro de sintaxe no redis.conf — valide o arquivo de configuracao
Porta ja em uso — verifique com sudo ss -tlnp | grep 6379
Memoria insuficiente — verifique a RAM disponivel com free -h

Alto Uso de Memoria

redis-cli INFO memory
redis-cli MEMORY DOCTOR

Se mem_fragmentation_ratio estiver acima de 1.5:

Habilite a desfragmentacao ativa
Reinicie o Redis para recuperar memoria fragmentada

Se used_memory estiver proximo de maxmemory:

Revise e ajuste a politica de eviction
Defina valores TTL em chaves de cache
Aumente o limite de maxmemory

Erros de Conexao Recusada

Verifique se o Redis esta escutando na interface esperada:

sudo ss -tlnp | grep redis

Verifique a diretiva bind no redis.conf e certifique-se de que seu firewall permite conexoes:

sudo ufw status | grep 6379

Desempenho Lento

Investigue com o slow log:

redis-cli SLOWLOG GET 25

Procure chaves grandes que possam estar bloqueando:

redis-cli --bigkeys

Evite usar KEYS * em producao. Use SCAN em vez disso:

redis-cli SCAN 0 MATCH "user:*" COUNT 100

Erros de Persistencia

Se os snapshots RDB falharem:

redis-cli INFO persistence

Procure rdb_last_bgsave_status:err. Correcoes comuns:

Certifique-se de que o diretorio de dados do Redis e gravavel: sudo chown redis:redis /var/lib/redis
Verifique se ha espaco em disco suficiente: df -h /var/lib/redis
Verifique as configuracoes de overcommit: sudo sysctl vm.overcommit_memory=1

Resumo

O Redis e um poderoso armazenamento de dados em memoria que pode melhorar drasticamente o desempenho da sua aplicacao quando usado como camada de cache, armazenamento de sessoes ou message broker. Ao configurar corretamente os limites de memoria, politicas de eviction, persistencia e configuracoes de seguranca, voce pode executar o Redis de forma confiavel em ambientes de producao.

Pontos principais:

Instale o Redis a partir do repositorio oficial para obter a ultima versao estavel
Sempre defina maxmemory e uma politica de eviction apropriada para prevenir crescimento descontrolado de memoria
Escolha sua estrategia de persistencia com base nos requisitos de durabilidade — RDB para snapshots periodicos, AOF para durabilidade quase em tempo real, ou ambos
Proteja o Redis com autenticacao por senha, restricoes de binding de rede e comandos perigosos renomeados
Monitore o desempenho com INFO, SLOWLOG e redis-cli --bigkeys para detectar problemas cedo
Use SCAN em vez de KEYS em producao para evitar bloquear o servidor

Para uma configuracao abrangente de seguranca do servidor, consulte nossos guias sobre Configuracao de Firewall UFW e a Lista de Verificacao de Seguranca para Servidores Linux.