Acesse o painel da sua conta

Não tem uma conta? Registrar

Entrar em contato

Visite também nosso site craftxp.com.br

  • img
  • img
  • img
  • img
  • img
  • img

Entre em contato

Redis na Prática: Cache, Filas e Sessões em Aplicações Modernas

Redis na Prática: Cache, Filas e Sessões em Aplicações Modernas

O que é o Redis e por que ele é tão rápido?

Redis (Remote Dictionary Server) é um banco de dados NoSQL open-source que armazena dados em memória RAM, permitindo operações de leitura e escrita extremamente rápidas — na casa dos microssegundos. Diferente de bancos relacionais como PostgreSQL ou MySQL, o Redis opera com estruturas de dados simples como strings, listas, conjuntos, hashes e sorted sets.

Sua arquitetura single-threaded baseada em eventos elimina a sobrecarga de locks e concorrência, o que o torna ideal para cenários onde a latência importa mais do que a capacidade de armazenamento.

Quando usar Redis no seu projeto?

O Redis brilha em casos de uso específicos. Veja os principais:

  • Cache de banco de dados — Reduza a carga no banco principal armazenando consultas frequentes em memória
  • Gerenciamento de sessões — Armazene sessões de usuário com expiração automática (TTL)
  • Filas de tarefas (message broker) — Implemente filas com listas e pub/sub para processamento assíncrono
  • Rate limiting — Controle requisições por IP ou usuário em APIs
  • Leaderboards e contadores — Sorted sets para rankings em tempo real
  • Cache de API — Armazene respostas de APIs externas para reduzir latência e custos

Instalação e primeiros passos com Docker

A forma mais rápida de começar com Redis é usando Docker:

docker run --name meu-redis -p 6379:6379 -d redis:7-alpine

# Verificar se está rodando
docker ps | grep meu-redis

Para acessar o CLI interativo:

docker exec -it meu-redis redis-cli

Comandos fundamentais do Redis

Antes de integrar com sua aplicação, conheça os comandos essenciais:

# Strings (o tipo mais básico)
SET usuario:1 "João Silva"
GET usuario:1          # "João Silva"
EXPIRE usuario:1 3600  # Expira em 1 hora
TTL usuario:1          # Segundos restantes

# Listas (perfeitas para filas)
LPUSH fila:tarefas "enviar-email"
RPUSH fila:tarefas "gerar-relatorio"
LPOP fila:tarefas      # Remove e retorna o primeiro
LRANGE fila:tarefas 0 -1  # Lista todos

# Hashes (como objetos JSON)
HSET usuario:100 nome "Maria" email "maria@email.com" idade 28
HGETALL usuario:100
HGET usuario:100 nome

# Sorted Sets (leaderboards)
ZADD ranking 100 "jogador1"
ZADD ranking 85 "jogador2"
ZADD ranking 95 "jogador3"
ZREVRANGE ranking 0 2 WITHSCORES  # Top 3

Cache de banco de dados com Node.js

Vamos implementar um cache prático usando Node.js com Redis para evitar consultas repetitivas ao banco:

import { createClient } from 'redis';
import { prisma } from './database';

const redis = createClient({ url: 'redis://localhost:6379' });
await redis.connect();

async function buscarUsuarioComCache(id) {
  const CACHE_KEY = `usuario:${id}`;
  
  // 1. Tentar buscar no cache primeiro
  const cached = await redis.get(CACHE_KEY);
  if (cached) {
    console.log('✅ Cache hit!');
    return JSON.parse(cached);
  }

  // 2. Se não encontrar, buscar no banco de dados
  console.log('❌ Cache miss — consultando banco...');
  const usuario = await prisma.usuario.findUnique({ where: { id } });
  
  if (usuario) {
    // 3. Armazenar no cache por 10 minutos (600 segundos)
    await redis.setEx(CACHE_KEY, 600, JSON.stringify(usuario));
  }

  return usuario;
}

Filas de tarefas com Redis e Python

O Redis também funciona como um sistema de filas robusto. Veja um exemplo com Python e a biblioteca rq (Redis Queue):

# worker.py — Processador de tarefas
import redis
from rq import Worker, Queue, Connection

redis_conn = redis.Redis(host='localhost', port=6379)

with Connection(redis_conn):
    worker = Worker(Queue('alta-prioridade'))
    worker.work()

# tasks.py — Definição das tarefas
def gerar_miniatura(video_id):
    print(f'Gerando miniatura para vídeo {video_id}...')
    # Lógica de processamento aqui
    time.sleep(3)  # Simula processamento
    return f'✅ Miniatura do vídeo {video_id} gerada com sucesso'

# enqueue.py — Enfileirando tarefas
from redis import Redis
from rq import Queue

q = Queue('alta-prioridade', connection=Redis())
job = q.enqueue(gerar_miniatura, 42)
print(f'Tarefa enfileirada: {job.id}')

Pub/Sub: Mensagens em tempo real

O padrão Publish/Subscribe do Redis é excelente para notificações em tempo real entre microsserviços:

# Publisher (Node.js)
import { createClient } from 'redis';
const pub = createClient();
await pub.connect();

await pub.publish('notificacoes', JSON.stringify({
  tipo: 'novo-pedido',
  pedidoId: 1234,
  cliente: 'Carlos'
}));

# Subscriber (Python)
import redis

r = redis.Redis()
pubsub = r.pubsub()
pubsub.subscribe('notificacoes')

for mensagem in pubsub.listen():
    if mensagem['type'] == 'message':
        dados = json.loads(mensagem['data'])
        print(f"📦 Novo pedido: {dados['pedidoId']}")

Rate Limiting com Redis

Uma aplicação clássica do Redis é limitar requisições a APIs. O comando INCR combinado com EXPIRE torna isso trivial:

async function rateLimit(ip, limite = 10, janela = 60) {
  const chave = `rate:${ip}`;
  const atual = await redis.incr(chave);

  // Primeira requisição — define expiração
  if (atual === 1) {
    await redis.expire(chave, janela);
  }

  return {
    permitido: atual <= limite,
    requisoes_restantes: Math.max(0, limite - atual),
    reset_em: await redis.ttl(chave)
  };
}

// Uso no middleware Express
app.use(async (req, res, next) => {
  const { permitido, requisoes_restantes } = await rateLimit(req.ip);
  if (!permitido) {
    return res.status(429).json({ erro: 'Muitas requisições' });
  }
  next();
});

Boas práticas e armadilhas comuns

  • Sempre defina TTL — Dados sem expiração podem consumir toda a RAM. Use EXPIRE ou o comando SETEX
  • Não use Redis como banco primário — Ele não tem as garantias de persistência de bancos relacionais. Use como cache + banco secundário
  • Cuidado com chaves grandes — Strings acima de 10MB impactam performance. Para blobs grandes, use S3/MinIO e guarde a URL no Redis
  • Monitoramento — Use INFO e MONITOR (apenas em dev) para acompanhar métricas
  • Redis Cluster para produção — Em escala, distribua os dados com Redis Cluster para alta disponibilidade

Conclusão

O Redis é uma ferramenta indispensável no stack de qualquer desenvolvedor moderno. Seja para cache de banco de dados, filas de tarefas assíncronas, gerenciamento de sessões, rate limiting ou comunicação em tempo real entre microsserviços, sua simplicidade e performance fazem dele uma escolha certeira.

Comece pequeno: instale com Docker, implemente um cache simples e, aos poucos, explore os recursos avançados como Pub/Sub, Streams e Redis Stack com módulos de busca e JSON.

Craft XP
Craft XP