Redis na prática: cache, sessões e filas

O que é Redis?

Redis é um banco de dados em memória que armazena dados no formato chave-valor. Ele é extremamente rápido porque trabalha diretamente na RAM, sem precisar acessar o disco para cada operação. Redis é usado por empresas como Twitter, GitHub e Stack Overflow para cache, gerenciamento de sessões e filas de mensagens.

Para instalar a biblioteca Python:

pip install redis

E para conectar:

import redis

r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)

# Testando a conexao
r.ping()  # True

Cache: a principal utilidade

O caso de uso mais comum do Redis é cache. Em vez de buscar dados no banco de dados relacional a cada requisição, você armazena o resultado no Redis e serve de lá:

import json

def buscar_produto(produto_id):
    chave = f"produto:{produto_id}"

    # Tenta buscar no cache
    cache = r.get(chave)
    if cache:
        print("Dados vindos do cache")
        return json.loads(cache)

    # Se nao estiver no cache, busca no banco
    produto = banco_de_dados.buscar(produto_id)

    # Armazena no cache por 5 minutos (300 segundos)
    r.setex(chave, 300, json.dumps(produto))
    print("Dados vindos do banco")
    return produto

O método setex define um tempo de expiração automático. Depois de 300 segundos, o Redis remove a chave sozinho.

Sessões de usuário

Em aplicações web, as sessões armazenam dados temporários do usuário (como o carrinho de compras). Usar Redis para sessões é mais rápido e escalável do que armazenar em arquivos no servidor:

import uuid

def criar_sessao(usuario_id, dados):
    sessao_id = str(uuid.uuid4())
    chave = f"sessao:{sessao_id}"

    r.hset(chave, mapping={
        "usuario_id": usuario_id,
        "nome": dados["nome"],
        "email": dados["email"],
    })
    # Sessao expira em 30 minutos
    r.expire(chave, 1800)
    return sessao_id

def buscar_sessao(sessao_id):
    chave = f"sessao:{sessao_id}"
    dados = r.hgetall(chave)
    if not dados:
        return None
    # Renova a expiracao a cada acesso
    r.expire(chave, 1800)
    return dados

# Uso
sid = criar_sessao("42", {"nome": "Maria", "email": "maria@email.com"})
dados = buscar_sessao(sid)
print(dados)  # {'usuario_id': '42', 'nome': 'Maria', 'email': 'maria@email.com'}

O hash do Redis (hset/hgetall) é ideal para sessões porque permite armazenar múltiplos campos em uma única chave.

Filas de tarefas

Redis funciona como uma fila simples e eficiente. Isso é útil para processar tarefas em segundo plano, como enviar e-mails ou gerar relatórios:

import json
import time

# Produtor: adiciona tarefas na fila
def enfileirar_tarefa(tipo, dados):
    tarefa = json.dumps({"tipo": tipo, "dados": dados})
    r.lpush("fila:tarefas", tarefa)
    print(f"Tarefa enfileirada: {tipo}")

# Consumidor: processa tarefas da fila
def processar_fila():
    print("Aguardando tarefas...")
    while True:
        resultado = r.brpop("fila:tarefas", timeout=5)
        if resultado is None:
            continue

        _, tarefa_json = resultado
        tarefa = json.loads(tarefa_json)
        print(f"Processando: {tarefa['tipo']}")

        if tarefa["tipo"] == "enviar_email":
            enviar_email(tarefa["dados"])
        elif tarefa["tipo"] == "gerar_relatorio":
            gerar_relatorio(tarefa["dados"])

# Exemplo de uso
enfileirar_tarefa("enviar_email", {"para": "ana@email.com", "assunto": "Bem-vinda!"})
enfileirar_tarefa("gerar_relatorio", {"mes": "janeiro", "ano": 2026})

O comando brpop é bloqueante: ele espera até que uma nova tarefa apareça na fila, sem consumir CPU em um loop vazio.

Monitorando o Redis

Para verificar o que está armazenado no Redis, use os comandos de inspeção:

# Listar todas as chaves que comecam com "produto:"
chaves = r.keys("produto:*")
print(chaves)

# Verificar o tempo restante de uma chave
ttl = r.ttl("produto:1")
print(f"Expira em {ttl} segundos")

# Ver o uso de memoria
info = r.info("memory")
print(f"Memoria usada: {info['used_memory_human']}")

Conclusão

Redis é uma ferramenta versátil que resolve três problemas comuns em aplicações Python: cache para reduzir carga no banco de dados, sessões para escalar aplicações web e filas para processar tarefas em segundo plano. A biblioteca redis-py torna a integração com Python simples e direta. Comece usando Redis para cache e, conforme sua aplicação crescer, explore sessões e filas.