How to survive LLM Traffic Spikes in Python - DEV Community
Como sobreviver a picos de tráfego de LLMs em Python sem quebrar a produção
O que é preciso para rotear, limitar e fazer failover de centenas de chamadas a LLMs por segundo — e o que aprendemos quando o volume explode de repente.
Na Manychat, entregamos automação com IA para milhares de contas de Instagram e mensageria. Por trás dessa experiência existe o nosso Python AI Service: uma camada que fica entre o produto e múltiplos provedores de LLM, processando centenas de chamadas por segundo em produção. Funciona bem. Até o momento em que deixa de funcionar.
Chamadas a modelos de linguagem não se comportam como APIs HTTP tradicionais. Um endpoint REST comum tem latência previsível, limites de requisição claros e erros bem definidos. Já um LLM tem latência que varia de 300 ms a 30 segundos, cobrança e limites baseados em tokens (não em requisições), rate limits que mudam de acordo com o provedor e a região, além de falhas intermitentes que não aparecem no seu dashboard até que o usuário reclame. Quando o tráfego cresce de forma abrupta — um lançamento de feature, um evento viral, um pico sazonal —, cada uma dessas características se multiplica.
Este artigo reúne as estratégias que usamos na prática para manter o serviço de pé: roteamento inteligente entre provedores, limitação de taxa em múltiplas camadas, failover com circuit breakers, backpressure e observabilidade. Tudo com Python — asyncio, httpx, Redis e algumas escolhas de arquitetura que fazem mais diferença do que qualquer biblioteca milagrosa.
Por que chamadas a LLMs são um problema diferente
Antes de falar de soluções, vale entender por que a abordagem tradicional de "cliente HTTP + try/except" fracassa em escala.
- Latência de cauda longa: a média pode ser 1,2 s, mas o p99 estoura 20 s com frequência. Se você dimensiona pools de conexão e workers pela média, o p99 derruba o serviço.
- Limites por token, não por requisição: provedores como OpenAI, Anthropic, Google e Azure contam tokens de entrada e saída por minuto (TPM) e requisições por minuto (RPM). Uma requisição com 8 mil tokens consome o mesmo que dezenas de chamadas curtas — logo, um contador de requisições ingênuo é inútil.
- Respostas em streaming: quando você usa streaming, a maior parte do tempo de vida da conexão é gasta recebendo chunks. Isso mantém sockets ocupados por muito mais tempo do que o "tempo de resposta" sugere.
- Custo por token: um loop de retry mal configurado pode gerar faturas de cinco dígitos em poucas horas. Retry é uma faca de dois gumes.
- Falhas parciais: um provedor pode estar lento, retornando 429 em 30 % das chamadas, mas ainda respondendo em 70 % — o que engana health checks binários.
Ou seja: o problema não é "chamar uma API". O problema é gerenciar capacidade, justiça e degradação em um sistema onde o recurso escasso é externo, caro e instável.
1. Roteamento multi-provedor: nunca dependa de um único fornecedor
O primeiro pilar é a abstração de provedor. Em vez de espalhar chamadas diretas ao SDK da OpenAI pelo código, o AI Service expõe uma interface única — algo como LLMClient.complete(prompt, tenant, priority) — e decide internamente para onde enviar a requisição.
As decisões de roteamento costumam seguir alguns critérios:
- Saúde do provedor: taxa de erro e latência recentes (por janela deslizante) alimentam um score de saúde.
- Capacidade disponível: quanto do limite de RPM/TPM de cada provedor ainda está livre naquele minuto.
- Custo e modelo: tarefas simples vão para modelos menores e mais baratos; tarefas complexas para modelos maiores.
- Isolamento por tenant: clientes grandes ou com SLA diferente podem ter pools dedicados.
Um esboço em Python com asyncio e httpx pode ser assim:
import asyncio, random, httpx
class ProviderPool:
def __init__(self, providers):
# providers: lista de dicts com nome, cliente httpx, limite e health score
self.providers = providers
def _score(self, p):
# penaliza erro e latência, premia capacidade livre
return (1 - p["error_rate"]) * (1 - p["latency_p95"] / 30) * p["free_capacity"]
async def complete(self, payload):
candidates = sorted(self.providers, key=self._score, reverse=True)
for p in candidates:
try:
return await p["client"].post("/v1/chat", json=payload, timeout=25)
except (httpx.TimeoutException, httpx.HTTPStatusError) as e:
p["error_rate"] = min(1.0, p["error_rate"] + 0.1)
continue
raise RuntimeError("todos os provedores falharam")
Esse código é simplificado, mas ilustra a ideia central: a falha de um provedor não é o fim da linha, é apenas um voto de desconfiança no score dele. Em produção, esse mesmo padrão precisa incluir circuit breakers por provedor (mais sobre isso adiante) e métricas por região.
2. Rate limiting em três camadas
Não existe rate limit suficiente se ele for aplicado em um único lugar. A experiência mostra que é preciso limitar em pelo menos três níveis:
Camada 1 — por provedor (respeitando o contrato externo)
É o limite que o fornecedor impõe: RPM e TPM. Aqui a implementação precisa ser um token bucket distribuído, porque múltiplas réplicas do serviço compartilham a mesma cota. Redis com scripts Lua é o padrão de facto:
-- rate_limit.lua: token bucket genérico
local key = KEYS[1]
local rate = tonumber(ARGV[1]) -- tokens por segundo
local burst = tonumber(ARGV[2]) -- capacidade máxima
local now = tonumber(ARGV[3])
local cost = tonumber(ARGV[4]) -- custo da requisição (ex.: nº de tokens)
local data = redis.call("HMGET", key, "tokens", "ts")
local tokens = tonumber(data[1]) or burst
local ts = tonumber(data[2]) or now
tokens = math.min(burst, tokens + (now - ts) * rate)
if tokens < cost then
return 0
end
redis.call("HMSET", key, "tokens", tokens - cost, "ts", now)
return 1
Note o detalhe importante: o custo (ARGV[4]) é estimado em tokens, não em requisições. Use o tokenizer do provedor ou uma aproximação por caracteres para calcular antes do envio.
Camada 2 — por tenant (justiça entre clientes)
Um cliente que dispara 10 mil chamadas em um minuto não pode consumir toda a cota compartilhada. Limites por tenant evitam o clássico "vizinho barulhento" e são fundamentais em produtos B2B multi-tenant. Aqui, o limite pode ser mais simples (sliding window) e a penalidade é enfileirar ou rejeitar com 429 explícito.
Camada 3 — concorrência local (proteção do próprio processo)
Mesmo com cotas externas respeitadas, disparar 5 mil corrotinas simultâneas em um único pod derruba a memória e degrada o event loop. Um asyncio.Semaphore limita a concorrência e é a forma mais barata de impor backpressure:
import asyncio
class ConcurrencyLimiter:
def __init__(self, max_concurrent: int):
self._sem = asyncio.Semaphore(max_concurrent)
async def run(self, coro):
async with self._sem:
return await coro
O tamanho ideal do semáforo raramente é intuitivo: meça com teste de carga. Um valor comum é 2 × número de vCPUs quando o gargalo é o event loop, mas com LLMs o gargalo costuma ser a conexão externa — então o número pode ser bem maior (dezenas ou centenas).
3. Failover com circuit breaker e backoff exponencial com jitter
Retry cego é o caminho mais curto para amplificar um incidente. Se um provedor está sobrecarregado e você reenvia cada requisição três vezes, você acabou de triplicar a carga que ele não está conseguindo atender.
O padrão que funciona combina três elementos:
- Circuit breaker: após N falhas consecutivas em uma janela, o provedor entra em estado aberto e passa a ser ignorado. Depois de um intervalo, entra em half-open e testa uma requisição.
- Backoff exponencial com jitter: espera crescente com ruído aleatório para evitar o efeito manada (thundering herd).
- Respeito ao
Retry-After: quando o provedor responde 429 com esse header, ele sabe mais do que você sobre quando aceitará tráfego novamente.
import asyncio, random
async def with_retry(fn, max_attempts=3, base=0.5, cap=8.0):
for attempt in range(max_attempts):
try:
return await fn()
except RetryableError as e:
if attempt == max_attempts - 1:
raise
delay = min(cap, base * (2 ** attempt))
delay = random.uniform(0, delay) # jitter
retry_after = getattr(e, "retry_after", None)
await asyncio.sleep(retry_after or delay)
Um ponto crítico: retries precisam ser idempotentes do ponto de vista do negócio. Se você está gerando uma resposta para o usuário, um retry é aceitável. Se está executando uma ação a partir da resposta do modelo (enviar uma mensagem, criar um ticket), o retry pode duplicar efeitos colaterais — nesse caso, use chaves de idempotência e registre o estado antes de agir.
4. Backpressure e degradação graciosa
Durante um pico real, o sistema vai receber mais trabalho do que consegue processar. A pergunta não é "como evitar", é "como escolher o que descartar".
Estratégias que adotamos:
- Filas com prioridade: chamadas síncronas do usuário (chat) têm prioridade sobre tarefas em background (resumos, classificação em lote).
- Timeout agressivo no enfileiramento: se a fila está longa, é melhor retornar um erro rápido e claro do que deixar o usuário esperando 40 segundos por uma resposta que talvez nunca venha.
- Fallback determinístico: quando o LLM está indisponível, responda com template, mensagem padrão ou regra heurística. Muitas vezes o usuário nem percebe.
- Load shedding: em picos extremos, rejeite uma porcentagem de requisições de baixa prioridade para preservar a experiência do núcleo.
O ponto de design aqui é que degradar graciosamente é uma feature, não um fracasso. Um serviço que responde 80 % das chamadas com qualidade e 20 % com fallback é infinitamente melhor que um serviço que responde 0 % com timeout.
5. Observabilidade: sem métricas, você está voando às cegas
Nenhuma das estratégias acima funciona sem instrumentação. As métricas mínimas:
- Latência por provedor, modelo e faixa de tokens (p50, p95, p99).
- Taxa de erro por código HTTP, incluindo 429 e 5xx separadamente.
- Tokens consumidos por minuto versus cota disponível — o "orçamento de capacidade".
- Ocupação do semáforo de concorrência e tempo de espera na fila.
- Estado dos circuit breakers (fechado / aberto / half-open).
- Custo estimado por tenant e por feature.
Tudo isso deve estar ligado a traces distribuídos, para que você consiga responder à pergunta "por que essa resposta demorou 12 segundos" olhando para um trace e não para cinco dashboards diferentes. OpenTelemetry resolve bem esse caso em Python, com instrumentação automática para httpx e asyncio.
6. Otimizações que reduzem o pico antes que ele aconteça
Boa parte do trabalho de resiliência é, na verdade, reduzir a demanda. Algumas alavancas com alto retorno:
- Cache semântico: prompts similares recebem respostas cacheadas (por hash exato ou similaridade de embeddings). Em cargas de atendimento, a taxa de acerto pode passar de 30 %.
- Batching: agrupe chamadas independentes em uma única requisição quando o provedor suportar, reduzindo overhead de rede e de rate limit.
- Prompts enxutos: cada 1.000 tokens de system prompt desnecessário multiplica custo e latência em todas as chamadas.
- Modelos menores para tarefas simples: classificação e extração raramente exigem o modelo topo de linha.
- Streaming com timeout de primeira resposta: detecte falhas cedo, antes de esperar 30 segundos por uma resposta completa.
Conclusão: resiliência é arquitetura, não biblioteca
Sobreviver a picos de tráfego de LLM em Python não é sobre instalar a biblioteca da moda. É sobre assumir, desde o primeiro commit, que o provedor vai falhar, que a latência vai variar, que o custo vai crescer e que o volume vai oscilar de forma imprevisível.
Isso se traduz em uma arquitetura com camadas claras: uma abstração de provedor que permite roteamento e failover; rate limiting distribuído por provedor, por tenant e por concorrência local; circuit breakers com retries idempotentes e backoff com jitter; backpressure explícito com degradação graciosa; e observabilidade que permita agir em segundos, não em horas.
A Manychat aprendeu isso na prática, operando centenas de chamadas por segundo em produção. A boa notícia é que nenhuma dessas peças é exótica: asyncio, httpx, Redis, OpenTelemetry e um pouco de disciplina de engenharia resolvem 90 % dos casos. O difícil não é a tecnologia — é a decisão de projeto de tratar resiliência como requisito de primeira classe, e não como um try/except adicionado depois do primeiro incidente.
Porque o próximo pico de tráfego não é uma questão de "se". É uma questão de quando.