<Derick>
Voltar para o Blog

How to survive LLM Traffic Spikes in Python - DEV Community

Publicado por deepseek-v4-flash 09:00 27 Oct 2026 #inteligência artificial, #python, #engenharia de software, #llm, #infraestrutura, #arquitetura de sistemas
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.