LLM gateway, não só API gateway: a política que decide quem atende cada request • Fogo na Caixa d'Água
LLM gateway, não só API gateway: a política que decide quem atende cada request
Existe uma pergunta que praticamente toda equipe de plataforma fez em 2024 e que, dois anos depois, mudou de forma. Antes era “qual modelo vamos usar?”. Hoje é “qual modelo atende este request, agora, sob estas condições?”.
A diferença é sutil na frase e brutal na engenharia. Trocar de provedor por preço é o argumento de venda fácil — o slide bonito da apresentação comercial. Mas quem opera de verdade descobre rapidamente que o problema não é escolher um fornecedor: é decidir, milhares de vezes por minuto, quem atende cada chamada quando o provedor principal começa a devolver 429, quando a latência do modelo barato sobe 40%, quando o orçamento trimestral daquela squad apertou ou quando o prompt contém dado pessoal que não pode sair do país.
É aí que o conceito de LLM gateway se separa definitivamente do API gateway. Não é o mesmo produto com outro nome no slide. É outra camada de decisão.
Por que um API gateway tradicional não resolve
Um API gateway clássico — Kong, NGINX, Envoy, Traefik, Istio — foi desenhado em torno de um contrato muito claro: o payload é opaco. Ele roteia por host, path, header, método, peso e health check. Latência de decisão na casa dos microssegundos, e isso é uma virtude: ele não deve saber o que está passando.
Com LLMs, essa premissa quebra em pelo menos cinco pontos:
- O corpo importa. A política precisa saber quantos tokens de entrada chegaram, qual o tamanho do contexto e, frequentemente, se há PII ou segredo no prompt. Roteamento sem inspecionar conteúdo é roteamento cego.
- O custo é variável e assimétrico. Um request de 400 tokens pode custar 300 vezes menos que um de 120 mil. Balanceamento por número de requisições é uma métrica inútil aqui — a unidade é token, não RPS.
- Streaming muda o jogo. Respostas via SSE ou chunked começam antes de terminar. Se o provider morre no meio do stream, você não pode simplesmente “tentar outro”: o cliente já recebeu metade da resposta. Fallback precisa de política de checkpoint, não de
try/except. - A semântica de falha é diferente.
429de rate limit,503de capacidade, timeout de TTFT (time to first token), resposta truncada por limite de contexto — cada uma pede uma reação distinta. - A qualidade é uma dimensão de rota. Dois modelos podem responder, mas um deles alucina em 12% dos casos naquele domínio. Isso não aparece em nenhum health check de gateway tradicional.
O LLM gateway, portanto, não é um proxy. É um motor de política que eventualmente também proxya.
A política de roteamento com gatilho
A arquitetura que se consolidou na prática usa três mecanismos combinados: balanceamento ponderado, roteamento por prioridade e gatilhos de desvio. Implementações como o plugin ai-proxy-multi deixaram isso explícito na configuração: distribuir tráfego entre múltiplas instâncias de modelo com pesos ajustáveis, failover automático e prioridade por instância.
O que interessa de verdade é a lista de gatilhos — as condições que fazem a política mudar de rota. Em produção, os que aparecem com mais frequência são:
- Gatilho de erro: taxa de
429ou5xxacima de um limiar em janela deslizante (ex.: 5% em 60s). Desvia imediatamente para o secundário. - Gatilho de latência: p95 de TTFT ou de tempo total acima do SLO contratado. É o gatilho mais ignorado e o que mais destrói experiência de usuário.
- Gatilho de cota: consumo de TPM (tokens por minuto) do provider acima de X%. Roteia preventivamente antes do
429chegar. - Gatilho de orçamento: gasto da classe ou do tenant acima do teto definido. Degrada para modelo mais barato em vez de falhar.
- Gatilho de conteúdo: detecção de PII, segredo ou dado regulado. Força rota para provider com residência de dados adequada — ou para modelo self-hosted.
- Gatilho de qualidade: queda em métricas de avaliação contínua (evals rodando em amostra de tráfego) ou aumento de taxa de recusa/refusal.
- Gatilho de forma do request: contexto maior que N tokens vai obrigatoriamente para o modelo com janela suficiente; request com tool calling vai para quem suporta o formato.
Repare que os gatilhos não são todos técnicos. Orçamento é financeiro. Residência de dado é jurídico. Qualidade é produto. Um LLM gateway maduro é, na prática, uma superfície onde times distintos negociam regras — e isso muda o desenho, porque a política precisa ser versionada, auditável e reversível como qualquer outro artefato de infraestrutura.
Fallback não é try/except — é trava
O erro clássico de primeira implementação é tratar fallback como uma cascata de tentativas dentro do handler da aplicação. Isso funciona em demo e cobra caro em produção, por três motivos.
Primeiro, tempestade de retry. Se o provider primário cai, todos os clientes tentam o primário, falham e migram para o secundário ao mesmo tempo. O secundário recebe um pico que ele não dimensionou — e cai também. O efeito é uma falha em cascata que começa em um provedor e termina em todos.
Segundo, custo fantasma. Retry cego em LLM significa pagar duas vezes por tokens que ninguém vai ler. Em escala, isso aparece no extrato antes de aparecer no dashboard.
Terceiro, duplicação de efeito. Se o request disparou uma tool call com efeito colateral (criar ticket, enviar e-mail, mover dinheiro) e o fallback repete a chamada, você tem um bug de negócio, não de infraestrutura.
A solução é a trava de fallback: um estado compartilhado, fora do processo da aplicação, que registra a saúde de cada rota. Quando o gatilho dispara, a rota entra em open e o gateway para de mandar tráfego para ela — sem tentar, sem esperar timeout. Depois de um cooldown, entra em half-open e recebe uma fração pequena do tráfego para teste. Se responder bem, volta a closed. Se não, volta para open com cooldown maior (backoff exponencial).
Além do circuit breaker, três decisões de política precisam estar escritas antes de qualquer incidente:
- Ordem de degradação. A sequência típica é: modelo caro de alta qualidade → modelo intermediário → modelo menor/mais rápido → cache semântico → resposta degradada explícita ao usuário. Cada degrau tem um custo de qualidade conhecido.
- Streaming. Se o primeiro token já foi enviado, a política é terminal: não há fallback. A decisão precisa ser tomada antes do primeiro byte, com timeout de TTFT agressivo. Depois disso, o máximo que se faz é encerrar o stream com um marcador de erro.
- Idempotência. Requests com efeito colateral só podem ter fallback se carregarem uma chave de idempotência que o gateway propague e o backend respeite.
Teto de gasto por classe: o controle que ninguém configura até a fatura chegar
Um dos maiores mal-entendidos sobre LLM gateway é tratá-lo como camada puramente técnica. Ele é também o único ponto onde é possível impor orçamento de forma uniforme, sem depender de cada aplicação implementar o próprio contador.
A modelagem que funciona é por classe de tráfego, não por aplicação. Classes típicas:
- Interativo (chat, autocomplete, copiloto): latência crítica, tolerância baixa a degradação, orçamento por usuário/sessão.
- Batch (sumarização, classificação, enriquecimento de dados): latência irrelevante, sensível a preço, aceita modelo menor e fila.
- Agêntico (loops de agente com tool calling): o mais perigoso financeiramente, porque um loop mal projetado multiplica tokens sem limite. Precisa de teto por execução, não só por dia.
- Auxiliar (embeddings, reranking, moderação): volume alto, custo unitário baixo, mas que soma. Candidato natural a self-hosting.
Com classes definidas, o teto de gasto deixa de ser um número único e vira uma matriz: classe × tenant × janela temporal. E o comportamento ao estourar precisa ser política, não exceção. As opções honestas são três:
Degradar — trocar para modelo mais barato naquela classe, mantendo o serviço vivo com qualidade menor. É a escolha certa para batch e auxiliar.
Enfileirar — segurar o request até a janela de orçamento renovar. Aceitável para batch, inaceitável para interativo.
Rejeitar com clareza — devolver 429 ou 402 com mensagem explícita. Parece ruim, mas é melhor que uma fatura surpresa: um time que recebe erro aprende a ajustar o consumo; um time que só vê a conta no fim do mês não tem como reagir.
Do gateway ao pod: onde a política encontra o Kubernetes
Vale lembrar que o LLM gateway não é o único ponto de decisão no caminho de um request. Em ambientes Kubernetes, a jornada costuma ser em camadas — e entender quem decide o quê evita duplicar regras.
Em uma demo apresentada no KCD São Paulo 2026, sobre Kubernetes Networking na era da IA, o caminho de uma chamada de inferência é descrito assim: a requisição entra por um Gateway Istio, encontra um InferencePool e chega a um dos pods que simulam o modelo. O InferencePool, parte da extensão de inferência da Gateway API, é responsável por escolher o endpoint — e faz isso com informação que um balanceador comum não tem, como estado do cache de KV e carga real da GPU.
A divisão de responsabilidade que emerge daí é elegante:
- O LLM gateway decide a política de negócio: qual provedor, qual classe, qual orçamento, qual regra de dado, quando abrir a trava de fallback.
- O InferencePool decide a execução: qual pod, dentro do pool já escolhido, tem capacidade de atender com menor custo de inferência.
Misturar as duas camadas gera o anti-padrão mais comum: regra de negócio codificada em configuração de roteamento L7, impossível de auditar e de testar. O gateway precisa ter opinião sobre quem atende; a malha precisa ter opinião sobre onde aquilo roda.
Observabilidade: a política só é boa se for medida
Não existe política de roteamento confiável sem telemetria granular. As métricas mínimas, por rota e por classe, são:
- Tokens de entrada e saída — separados, porque têm preços diferentes e padrões de consumo diferentes.
- Custo por request e por classe — em moeda, não em token. Times de produto entendem dinheiro; engenharia entende token. O gateway precisa falar as duas línguas.
- TTFT e TPOT (time per output token) — as duas métricas que realmente descrevem percepção de velocidade em LLM.
- Taxa de fallback por gatilho — não basta saber que houve fallback; é preciso saber qual gatilho disparou. Um gatilho que dispara sempre é um gatilho mal calibrado.
- Taxa de sucesso por rota — incluindo respostas semanticamente inválidas, não só HTTP 200.
- Decisão de rota registrada — para auditoria. “Por que este request foi para o provedor B?” precisa ter resposta em log estruturado, não em arqueologia.
Com esse conjunto, aparecem oportunidades que a configuração inicial não previa: cache semântico como degrau explícito da cadeia de degradação, shadow traffic para avaliar um modelo novo sem arriscar produção, canary de modelo com 1% do tráfego, e quality gates que promovem ou rebaixam uma rota automaticamente com base em evals contínuos.
Governança: o gateway como ponto de auditoria
Há um bônus não óbvio em centralizar a decisão: conformidade. Se toda chamada a LLM passa pelo gateway, ele é o único lugar onde dá para garantir, de forma verificável, que dado sensível não saiu para um provedor sem contrato adequado, que a residência de dados foi respeitada e que o log de auditoria contém a trilha completa — quem pediu, qual classe, qual modelo respondeu, quanto custou.
Isso é especialmente relevante sob LGPD. Não basta declarar que “usamos IA com segurança”; é preciso demonstrar que a política existe, está versionada no Git, foi testada e é aplicada uniformemente. Um gateway com política declarativa entrega exatamente esse artefato.
Conclusão
A troca de provedor de LLM por preço é o argumento de venda. A realidade operacional é outra: o que sustenta produção é a política — o conjunto de gatilhos que decide quem atende cada request, a trava que impede que um provedor em falha derrube os outros, e o teto de gasto que impede que um loop de agente consuma o orçamento trimestral em uma tarde.
Um LLM gateway que se limita a ser API gateway com outro nome vai rotear bem e falhar mal. Vai distribuir carga, mas não vai saber degradar. Vai ter métricas de RPS, mas não de custo por classe. Vai ter health check de endpoint, mas não circuit breaker com estado compartilhado.
A diferença entre os dois é a mesma diferença entre um balanceador e um sistema de decisão. E, em 2026, a parte difícil da infraestrutura de IA deixou de ser servir o modelo. Passou a ser decidir, com critério, quem serve cada request — e saber explicar por quê.