API travando? Como criar Rate Limiting distribuído com Redis

O perigo invisível dos picos repentinos de tráfego

Imagine que sua aplicação receba de repente dez vezes mais acessos do que o normal. Na prática, isso significa que servidores criados para lidar com uma carga previsível agora precisam processar milhares de requisições simultâneas. Se o sistema não possuir barreiras, os bancos de dados começam a acumular filas intermináveis, a memória se esgota rapidamente e os serviços downstream começam a falhar um após o outro, criando um efeito cascata desastroso.

Em arquiteturas modernas baseadas em microsserviços, esse problema se multiplica porque dezenas de pequenos serviços conversam entre si o tempo todo. Quando um único endpoint sofre abuso ou um cliente envia requisições em looping, toda a infraestrutura compartilha o impacto negativo. É exatamente nesse cenário crítico que entra o conceito de rate limiting, que funciona como um porteiro inteligente controlando o fluxo de pessoas que podem entrar em uma sala lotada.

Para entender melhor como estruturar defesas robustas contra sobrecargas em ambientes complexos, vale a pena conferir estratégias complementares de estabilidade, como o guia sobre microsserviços instáveis e o uso de circuit breaker e fallbacks. Afinal, controlar o tráfego que entra é apenas o primeiro passo para garantir que a arquitetura inteira continue respondendo mesmo sob pressão extrema.

Por que limitar requisições em ambientes distribuídos

Quando rodamos aplicações em apenas um servidor, controlar quantas vezes um usuário executa uma ação é algo simples de resolver guardando os dados na própria memória do processo. Contudo, na prática da engenharia moderna, aplicações rodam em dezenas ou centenas de instâncias simultâneas atrás de balanceadores de carga. Se cada instância decidir contar o número de acessos por conta própria, o limite perde o sentido e usuários maliciosos conseguem burlar a restrição facilmente.

É por isso que precisamos de um mecanismo centralizado e extremamente rápido para armazenar os contadores de acesso. Se esse armazenamento centralizado for lento, o remédio acaba se tornando pior do que a doença, adicionando latência perceptível a cada requisição legítima feita pelos seus usuários. O desafio central de engenharia consiste em encontrar uma tecnologia que consiga responder a milhões de leituras e escritas por segundo sem engasgar.

A escolha do Redis como motor de controle

O Redis é um banco de dados em memória que se tornou o padrão de mercado para resolver problemas rápidos de contagem, cache e mensageria. Na prática, ele funciona guardando tudo diretamente na memória RAM do computador em vez de gravar em discos rígidos lentos, o que permite responder a consultas em frações de microssegundos. Essa velocidade absurda é o ingrediente secreto que torna viável verificar o limite de uma API antes mesmo de deixar a requisição tocar no banco de dados principal.

Outro ponto forte do Redis é o suporte nativo a operações atômicas, que evitam condições de corrida quando várias requisições chegam no exato milissegundo. Condições de corrida acontecem quando dois processos leem o mesmo valor ao mesmo tempo, modificam e salvam de volta, apagando a contagem um do outro. Com comandos específicos do Redis, como incremento de valores de forma segura, garantimos que nenhum acesso passe desapercebido pelos filtros de segurança.

Implementando a estratégia de contagem deslizante

Existem várias formas matemáticas de calcular limites de taxa, sendo a janela fixa e a janela deslizante as mais populares. Na janela fixa, reiniciamos a contagem a cada minuto cego, o que abre brechas perigosas caso um usuário esgote o limite no último segundo do minuto atual e repita a dose logo no primeiro segundo do minuto seguinte. Para resolver essa falha clássica, a janela deslizante calcula a média de acessos considerando o fluxo contínuo do tempo.

Abaixo temos um exemplo prático utilizando estruturas de dados em memória e comandos do Redis para validar se uma chave ultrapassou o limite permitido de requisições em uma janela de tempo:

import timeimport redisclient = redis.Redis(host='localhost', port=6379, decode_responses=True)def check_rate_limit(user_id, limit=5, window=60):    current_time = int(time.time())    key = f'rate_limit:{user_id}'    pipe = client.pipeline()    pipe.zremrangebyscore(key, 0, current_time - window)    pipe.zcard(key)    pipe.zadd(key, {current_time: current_time})    pipe.expire(key, window)    results = pipe.execute()    request_count = results[1]    if request_count >= limit:        return False    return True

Protegendo serviços pesados de inteligência artificial

Sistemas modernos frequentemente integram modelos pesados de Inteligência Artificial que consomem muita memória e poder de processamento gráfico. Deixar que qualquer cliente envie requisições ilimitadas para esses endpoints pode paralisar toda a infraestrutura em poucos minutos. Conforme discutido em reflexões sobre como otimizar a inferência com vLLM em produção, o uso inteligente de limites de taxa é indispensável para evitar gargalos operacionais e manter custos sob controle rigoroso.

Quando aplicamos limites estritos nas rotas de IA, garantimos que os recursos computacionais caros sejam distribuídos de forma justa entre todos os usuários ativos. Isso evita que um único script mal configurado consuma toda a capacidade de processamento, garantindo estabilidade e previsibilidade financeira para a empresa.

Considerações finais sobre resiliência e operação

Implementar rate limiting distribuído com Redis não é apenas uma questão de segurança contra ataques de negação de serviço, mas uma decisão fundamental de arquitetura para a saúde de qualquer sistema corporativo. Ao isolar falhas, proteger serviços downstream e garantir tempos de resposta estáveis, sua equipe ganha tranquilidade para escalar produtos sem medo de surpresas desagradáveis durante picos de acesso.