Casos de Uso do Redis: Cache, Filas e Rate Limiting

Você construiu uma aplicação web que está ganhando tração, mas conforme o tráfego cresce, você percebe consultas lentas ao banco de dados e timeouts ocasionais. Seu servidor luta sob a carga e os usuários reclamam da latência. Você precisa de um armazenamento de dados em memória rápido para descarregar tarefas repetitivas e gerenciar picos de tráfego. O Redis é a solução ideal para muitos desafios de backend, e neste artigo, exploraremos três casos de uso práticos: cache, filas e rate limiting.

Por que Redis?

O Redis é um armazenamento de chave-valor em memória de código aberto, conhecido por sua velocidade e versatilidade. Ele suporta estruturas de dados como strings, hashes, listas, conjuntos e conjuntos ordenados, tornando-o adequado para uma ampla variedade de tarefas. Diferente de bancos de dados tradicionais, o Redis mantém os dados na RAM, entregando latência inferior a um milissegundo. Ele também oferece opções de persistência, replicação e clustering para alta disponibilidade.

1. Cache com Redis

O cache é o caso de uso mais comum do Redis. Ao armazenar dados acessados com frequência no Redis, você reduz a carga no banco de dados principal e acelera os tempos de resposta. Por exemplo, se sua aplicação exibe uma lista de produtos populares, você pode armazenar em cache o resultado da consulta por alguns minutos.

Como Implementar o Cache

1. Verifique o cache: Antes de consultar o banco de dados, verifique se os dados existem no Redis.
2. Se encontrado (cache hit): Retorne os dados em cache.
3. Se não encontrado (cache miss): Consulte o banco de dados, armazene o resultado no Redis com um tempo de expiração (TTL) e retorne os dados.

Aqui está um exemplo em Python usando redis-py:

import redis
import json

r = redis.Redis(host='localhost', port=6379, db=0)

def get_products():
    cache_key = 'products:popular'
    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)
    # Simula consulta ao banco de dados
    products = [{'id': 1, 'name': 'Product A'}, {'id': 2, 'name': 'Product B'}]
    r.setex(cache_key, 300, json.dumps(products))  # Cache por 5 minutos
    return products

Boas práticas: Use chaves de cache significativas, defina TTLs apropriados e considere estratégias de invalidação de cache. Para dados que mudam com frequência, use TTLs curtos ou implemente cache write-through.

2. Filas com Redis

Listas e streams do Redis são excelentes para construir filas de mensagens simples. Elas permitem desacoplar tarefas demoradas (como enviar e-mails ou processar imagens) do ciclo de requisição-resposta, melhorando a experiência do usuário e a escalabilidade.

Usando Listas como Fila

Você pode usar LPUSH para adicionar trabalhos a uma lista e BRPOP para remover trabalhos atomicamente da outra extremidade. Isso cria uma fila FIFO.

Produtor:

r.lpush('email_queue', json.dumps({'to': 'user@example.com', 'subject': 'Welcome'}))

Consumidor (em um processo worker):

while True:
    _, job = r.brpop('email_queue', timeout=30)
    if job:
        process_email(json.loads(job))

Considerações: Listas do Redis são simples, mas carecem de recursos avançados como confirmações. Para necessidades mais robustas, considere Redis Streams, que suportam grupos de consumidores e confirmação de mensagens.

3. Rate Limiting com Redis

O rate limiting protege sua API contra abusos e garante uso justo. As operações atômicas do Redis o tornam ideal para implementar limitadores de taxa. Um algoritmo comum é o contador de janela deslizante, mas uma abordagem mais simples de janela fixa também funciona bem.

Limitador de Taxa de Janela Fixa

Incremente um contador para cada usuário e defina uma expiração. Se o contador exceder o limite, negue a requisição.

def is_allowed(user_id, limit=100, window=60):
    key = f'rate_limit:{user_id}'
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current