Erros 431 e 494 e o truncamento silencioso de cabeçalhos: guia passo a passo para diagnosticar e configurar limites
Sumário do artigo
- Introdução
- Preparação inicial
- Conceitos básicos
- Passo 1: reproduzir o problema e registrar os sintomas
- Passo 2: medir o tamanho real dos cabeçalhos e cookies
- Passo 3: identificar qual camada está recusando
- Passo 4: detectar truncamento silencioso com um endpoint de eco
- Passo 5: reduzir o volume de cookies e cabeçalhos
- Passo 6: configurar limites no servidor web, balanceador e aplicação
- Passo 7: tornar as recusas explícitas e configurar o monitoramento
- Verificação do resultado
- Erros típicos e soluções
- Recursos adicionais
- Faq
- Conclusão
Introdução
Este guia é dedicado a um grupo restrito, mas muito traiçoeiro, de problemas: a requisição não passa ou passa parcialmente porque seus cabeçalhos ou cookies ficaram grandes demais. Externamente, isso aparece como o erro 431 Request Header Fields Too Large, como o código específico do nginx 494 Request Header Too Large, como o obscuro 400 Request Header Or Cookie Too Large e, no pior caso, não aparece de forma alguma: algum nó intermediário descarta silenciosamente parte dos cabeçalhos, e a aplicação recebe o usuário sem sessão, sem token de autorização ou sem os cookies necessários.
É importante desde já distinguir esse tema de um tópico vizinho. Em um artigo separado, analisamos os códigos 407, 502 e 504, que a própria camada de proxy emite ao estabelecer o túnel: falha de autenticação no proxy, upstream não subiu, timeout expirou. Ali o problema está na conexão e no próprio proxy. Aqui, a conexão é estabelecida normalmente, o túnel existe, mas os dados que você tenta enviar por ele não cabem nos buffers de algum nó da cadeia. A causa está sempre no volume e na composição dos cabeçalhos, e o tratamento usa ferramentas completamente diferentes.
O que você vai obter ao final
- Capacidade de medir com precisão, em poucos minutos, o tamanho dos cabeçalhos e cookies de uma requisição específica.
- Entendimento de qual nó da cadeia (navegador ou cliente, proxy, balanceador, servidor web, aplicação) está recusando ou truncando os dados.
- Um endpoint de eco pronto para revelar truncamento silencioso sem nenhum código de erro.
- Configurações de limites funcionais para nginx, Apache, Node.js, HAProxy, Tomcat e Gunicorn, com explicação de cada parâmetro.
- Estratégia de redução de cookies para que o problema não volte depois de um mês.
- Monitoramento que sinaliza aproximação do limite com antecedência.
Para quem é este guia
Para desenvolvedores web, administradores de sistemas, especialistas em scraping e automação, e também para quem trabalha com muitos perfis através de proxies e enfrenta regularmente recusas incompreensíveis. O nível de dificuldade é médio: você não precisa ser especialista no protocolo HTTP, mas vai precisar de habilidades básicas de terminal e saber o que é um arquivo de configuração.
O que você precisa saber antes
- Como abrir o terminal e executar um comando.
- Como abrir o painel de desenvolvedor no navegador (tecla F12).
- Onde ficam os arquivos de configuração do seu servidor web, se você o administra.
- Noção geral de que a requisição vai do cliente, passa por nós intermediários e chega ao servidor.
Quanto tempo vai levar
O diagnóstico nos passos 1 a 4 leva de 30 a 60 minutos. A correção do lado do servidor (passos 5 a 7) leva mais 1 a 2 horas, considerando reinicializações e verificações. Se você está apenas verificando um serviço de terceiros e não tem acesso às configurações dele, os quatro primeiros passos e a seção sobre redução de cookies serão suficientes.
Preparação inicial
Nada exótico é necessário, mas prepare as ferramentas com antecedência para não se distrair no meio do processo.
Ferramentas necessárias
- curl versão 7.70 ou mais recente. Está disponível no macOS, em todas as distribuições Linux e no Windows 10 e 11 de fábrica. Verifique com o comando
curl --version. - Navegador com painel de desenvolvedor: Chrome, Edge, Firefox ou Yandex Browser. Você vai precisar da aba Network (Rede) e da aba Application ou Storage para visualizar cookies.
- Editor de texto com realce de sintaxe: VS Code, Notepad++ ou o nano embutido no servidor.
- Acesso SSH ao servidor, se você for alterar limites. Permissões de leitura de logs e reinício de serviços são obrigatórias.
- Python 3 ou Node.js para rodar o endpoint de eco. Qualquer versão atual serve.
- Opcional: mitmproxy ou o analisador integrado em um navegador antidetect, se você quiser observar o tráfego entre cliente e proxy.
Requisitos de sistema
Qualquer máquina de trabalho. Para o servidor de eco, 100 MB de memória RAM bastam. O único requisito real é acesso de rede ao serviço verificado e, se necessário, ao proxy utilizado.
O que baixar e configurar
- Verifique se o curl funciona: execute
curl -sI https://example.com. Você deve ver as linhas de cabeçalho da resposta, começando comHTTP/2 200ou algo parecido. - Se trabalhar através de proxy, prepare endereço, porta, login e senha. Teste a conexão básica com o comando
curl -x http://login:senha@host:port -sI https://example.com. Se aqui aparecer o erro 407 ou a conexão nem for estabelecida, volte ao artigo sobre os códigos da camada de proxy: nosso tema começa apenas após o túnel ser bem-sucedido. - No servidor, localize o arquivo de configuração principal: para nginx geralmente é
/etc/nginx/nginx.confe a pasta/etc/nginx/conf.d/; para Apache,/etc/apache2/apache2.confou/etc/httpd/conf/httpd.conf. - Localize os logs:
/var/log/nginx/error.log,/var/log/nginx/access.log,/var/log/apache2/error.log. Confirme que consegue lê-los com o comandotail -n 50.
Backups
Antes de qualquer alteração em configurações, faça uma cópia. Isso leva segundos e economiza horas.
- Execute
sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak-2026. - Para a pasta dos sites:
sudo cp -r /etc/nginx/conf.d /etc/nginx/conf.d.bak-2026. - Para Apache, o mesmo:
sudo cp /etc/apache2/apache2.conf /etc/apache2/apache2.conf.bak-2026. - Anote os valores atuais dos limites em um arquivo de notas, para saber de onde você partiu.
Atenção: nunca edite a configuração de produção sem antes verificar a sintaxe. Para nginx, é sudo nginx -t; para Apache, sudo apachectl configtest. Um erro em uma linha, ao reiniciar, deixará o serviço fora do ar.
Conceitos básicos
Antes de caçar o problema, vamos combinar os termos. Não há nada complicado aqui, mas a confusão nas palavras muitas vezes leva o diagnóstico para o caminho errado.
O que são cabeçalhos de requisição
Toda requisição HTTP consiste em uma linha inicial (método, caminho, versão do protocolo), um bloco de cabeçalhos e um corpo opcional. Cabeçalhos são pares no formato Nome: valor. O navegador os adiciona automaticamente: Host, User-Agent, Accept, Accept-Language, Referer, Authorization e, claro, Cookie. As aplicações adicionam os seus: tokens, identificadores de rastreamento, marcadores de experimentos.
Por que os cookies são o vilão mais frequente
O cabeçalho Cookie é montado a partir de todos os cookies que se encaixam no domínio e caminho da requisição. Cada sistema de analytics, cada widget de chat, cada rede de anúncios adiciona alguns. O valor de um único cookie pode chegar a 4 KB, e existem dezenas desses cookies no domínio. Além disso, o navegador os envia em todas as requisições, incluindo imagens e fontes. Como resultado, o cabeçalho Cookie facilmente ultrapassa 8-16 KB, que são exatamente os limites padrão da maioria dos servidores.
O código 431
431 Request Header Fields Too Large é um código padrão descrito na especificação HTTP. O servidor comunica: os cabeçalhos são grandes demais, seja um deles ou todos juntos. Esse código é retornado por Node.js, Go, Envoy, algumas CDNs e frameworks modernos. A resposta 431 é correta pelo protocolo e bem visível nos logs, o que a torna a variante mais fácil de diagnosticar.
O código 494
494 Request Header Too Large é um código interno não padronizado do nginx. O nginx usa esse código internamente quando um cabeçalho não cabe nos buffers definidos pela diretiva large_client_header_buffers. Para o cliente, por padrão, é enviado um 400 com o corpo Request Header Or Cookie Too Large. Ver o número 494 em si só é possível em dois casos: se o administrador declarou explicitamente error_page 494, ou se você está lendo variáveis internas e logs do nginx. Por isso, se um usuário reclama de uma página branca com o texto 400 e menção a cookie, saiba: é o mesmo 494.
Truncamento silencioso
O cenário mais desagradável. O nó intermediário não rejeita a requisição, mas trunca o cabeçalho pelo tamanho do seu buffer ou descarta parte dos cabeçalhos por completo. A aplicação recebe dados incompletos. Os sintomas variam: o usuário é desconectado de repente, o carrinho se perde, o token não é lido, o cabeçalho com o identificador de região desaparece. Não há código de erro, e nos logs do servidor web tudo aparece em verde. Esse comportamento ocorre em proxies caseiros com buffers fixos, em gateways corporativos antigos, em alguns WAFs em modo de tratamento suave, em bibliotecas de cliente que dividem ou cortam valores longos e no próprio navegador, que ignora silenciosamente Set-Cookie com mais de 4096 bytes.
Onde ficam os limites afinal
Imagine a cadeia: navegador ou script, depois seu proxy de saída (por exemplo, móvel), depois CDN ou WAF, depois balanceador, depois servidor web, depois servidor de aplicação. Cada elo tem seu próprio limite e seu próprio comportamento ao ser excedido. A tarefa do diagnóstico é encontrar o elo mais estreito. É exatamente por isso que simplesmente aumentar o limite no nginx muitas vezes não basta: atrás dele está o Node.js com seu próprio limiar de 16 KB.
Fronteira com o erro 502 upstream sent too big header
Um caso separado na fronteira entre dois temas. Se o nginx escreve no error.log a frase upstream sent too big header while reading response header from upstream e retorna 502, o problema não está no túnel nem em queda do upstream, mas nos cabeçalhos de resposta da aplicação que não couberam em proxy_buffer_size. Formalmente é um 502, mas se resolve com parâmetros de buffer, sobre os quais falamos aqui. Memorize esse marcador: ele ajuda a não procurar o problema na camada de proxy.
Passo 1: Reproduzir o problema e registrar os sintomas
Objetivo desta etapa: obter um cenário estável em que o erro ocorre e registrar os sinais exatos: código, texto da resposta, cabeçalho Server e horário.
- Abra a página problemática no navegador. Pressione F12 e vá para a aba Network (Rede).
- Marque a caixa Preserve log (Preservar registro), para que as entradas não desapareçam ao navegar.
- Recarregue a página com F5. Encontre a requisição marcada em vermelho, ou a requisição com status 400, 431 ou 494. Clique nela.
- Na aba Headers, anote: o código de status, o valor do cabeçalho
Serverna resposta (nginx, cloudflare, AkamaiGHost, gunicorn), o valor deVia, se houver, e quaisquer cabeçalhos com prefixoX-ouCF-. - Vá para a aba Response e copie o corpo da resposta. A frase Request Header Or Cookie Too Large indica nginx. A frase Request Header Fields Too Large sem a palavra Cookie é típica do Node.js. A frase Bad Request - Request Too Long é característica do IIS.
- Role até o bloco Request Headers. Estime o comprimento da linha
Cookie: se ela ocupa várias telas, já é uma pista. - Abra uma janela anônima e repita a requisição. Se no perfil limpo não houver erro, a culpa é dos cookies acumulados daquele usuário específico.
Se o problema se reproduz em um script e não no navegador, registre os mesmos dados a partir da resposta da biblioteca: status, corpo, cabeçalhos. Em Python requests, isso é response.status_code, response.text e response.headers.
Dica: exporte todas as requisições para um arquivo HAR, com o botão direito na lista de requisições e a opção Save all as HAR with content. Esse arquivo pode ser aberto depois ou enviado a um colega, e preserva os tamanhos exatos dos cabeçalhos.
Verificação: você deve ter uma anotação com quatro itens: código de status, texto do corpo da resposta, valor do cabeçalho Server e resultado do teste em janela anônima. Se o resultado em anônima for diferente, você já sabe 70 por cento da causa.
Possíveis problemas
- O erro aparece só às vezes. Então o tamanho do cookie oscila perto do limiar: por exemplo, após visitar uma seção específica, mais um cookie é adicionado. Anote após quais ações o erro surge.
- Não há requisição vermelha, mas a página funciona mal. Isso é sinal de truncamento silencioso. Vá direto ao passo 4 logo após a medição.
Passo 2: Medir o tamanho real dos cabeçalhos e cookies
Objetivo desta etapa: obter números exatos em bytes: o tamanho total do bloco de cabeçalhos, o tamanho do cabeçalho Cookie e o tamanho de cada cookie individual.
Medição no navegador
- No painel de desenvolvedor, abra a aba Console.
- Digite
document.cookie.lengthe pressione Enter. Você verá um número: é o comprimento em caracteres de todos os cookies acessíveis a scripts, sem a flag HttpOnly. O cabeçalho real será maior, porque cookies HttpOnly não entram aqui. - Digite
document.cookie.split('; ').map(c => [c.split('=')[0], c.length]).sort((a, b) => b[1] - a[1]). O console mostrará um array de pares nome-comprimento, ordenado de forma decrescente. Os cookies mais pesados ficarão no topo. - Vá para a aba Application (no Firefox, Storage), expanda Cookies e selecione o domínio. Aqui você vê todos os cookies, inclusive HttpOnly, com a coluna Size. Clique no cabeçalho da coluna para ordenar por tamanho.
- Some os tamanhos ou simplesmente olhe a linha Cookie na requisição do passo 1: no Chrome, ao passar o mouse sobre o cabeçalho, o comprimento dele é exibido.
Medição via curl
O curl permite enviar cabeçalhos de qualquer tamanho e descobrir exatamente a partir de que volume o servidor começa a recusar. Vamos gerar um cookie de comprimento controlado.
- Crie uma string de 8000 caracteres. No Linux e macOS:
BIG=$(head -c 8000 /dev/zero | tr '\0' 'a'). Se o shell reclamar do escape, use a varianteBIG=$(python3 -c "print('a'*8000)"). - Envie a requisição:
curl -s -o /dev/null -w '%{http_code}' -H "Cookie: test=$BIG" https://seu-site.com.br/. Na tela aparecerá apenas o código de resposta. - Varie o tamanho: 4000, 8000, 12000, 16000, 32000, 64000. Anote em qual valor o código muda de 200 para 400 ou 431.
- Se trabalhar através de proxy, adicione
-x http://login:senha@host:porte repita a série. A diferença entre os limiares com e sem proxy mostrará se existe limite no próprio proxy.
Exemplo de busca binária pelo limiar em um único comando para bash:
for n in 4000 8000 12000 16000 24000 32000 64000; do BIG=$(python3 -c "print('a'*$n)"); echo -n "$n: "; curl -s -o /dev/null -w '%{http_code}' -H "Cookie: t=$BIG" https://seu-site.com.br/; echo; doneNo Windows PowerShell, o equivalente: $big = 'a' * 16000; curl.exe -s -o NUL -w '%{http_code}' -H "Cookie: t=$big" https://seu-site.com.br/.
Interpretação dos números
- Limiar em torno de 8 KB: típico do Apache com configurações padrão, Tomcat, Gunicorn, e também do nginx quando o cabeçalho não cabe em um único buffer dentre quatro de 8 KB.
- Limiar em torno de 16 KB: Node.js a partir da versão 13, HAProxy com tune.bufsize básico, IIS.
- Limiar em torno de 32 KB: limite total de algumas CDNs. Um cabeçalho individual nelas geralmente é limitado a 16 KB.
- Limiar em torno de 60-64 KB: Envoy e parte dos balanceadores de nuvem.
- Limiar em torno de 1 MB: servidor Go padrão.
Dica: não meça apenas o Cookie. Repita a série com o cabeçalho Authorization: Bearer $BIG e com vários cabeçalhos menores. Alguns servidores limitam separadamente o tamanho de um campo, a quantidade deles e o volume total. O nginx, por exemplo, por padrão não deixa passar um cabeçalho individual maior que 8 KB mesmo que o total seja pequeno, porque cada linha deve caber em um buffer separado.
Verificação: em suas anotações deve aparecer o número a partir do qual o servidor começa a recusar, e a lista de três a cinco cookies mais pesados com seus tamanhos. Se o limiar não foi encontrado até 64 KB, mas o erro ocorre no navegador, então quem recusa não é o servidor, mas algo entre o navegador e o servidor no seu ambiente específico. Vá para o próximo passo.
Passo 3: Identificar qual camada está recusando
Objetivo desta etapa: nomear com precisão o nó da cadeia que retorna o erro ou corta os dados, para alterar configurações exatamente ali.
Leitura da assinatura da resposta
- Execute
curl -sv -H "Cookie: t=$BIG" https://seu-site.com.br/ 2>&1 | grep -i -E 'server|via|cf-|x-served|x-cache|HTTP/', onde BIG com certeza excede o limiar. - Leia o cabeçalho
Server. O valor nginx com o corpo Request Header Or Cookie Too Large significa que o nginx recusou. O valor cloudflare significa que a requisição nem chegou ao seu servidor. Server vazio e corpo em formato JSON geralmente apontam para a aplicação. - Observe a versão do protocolo na primeira linha. Se, em requisições normais, o servidor responde por HTTP/2, mas o erro vem por HTTP/1.1, é sinal de que a resposta foi gerada por um nó intermediário, e não pelo nó final.
- Compare os corpos dos erros: a página do nginx é concisa e contém o nome dele embaixo; a página do Cloudflare contém Ray ID; o Node.js frequentemente retorna corpo vazio com status 431.
Contornando camadas
- Se você tem o endereço IP direto do servidor atrás da CDN, repita a requisição com a chave
--resolve seu-site.com.br:443:1.2.3.4. Isso faz o curl conectar diretamente, mantendo Host e SNI corretos. Se diretamente a requisição passa, mas pela CDN não, o limite está na CDN. - Se você tem acesso ao servidor, faça a requisição localmente:
curl -s -o /dev/null -w '%{http_code}' -H "Cookie: t=$BIG" -H 'Host: seu-site.com.br' http://127.0.0.1:80/. Assim você exclui todos os nós externos. - Depois bata direto na aplicação, sem passar pelo nginx:
curl ... http://127.0.0.1:3000/para Node.js, ou a porta em que o Gunicorn escuta. Se o nginx deixa passar, mas a aplicação responde 431, o limite está na aplicação. - Verifique a influência do seu proxy de saída: uma série de requisições com
-x, outra sem. Para requisições HTTPS via proxy, usa-se o método CONNECT, e o proxy não vê os cabeçalhos dentro do túnel criptografado, então não pode influenciar o tamanho deles. Mas para requisições HTTP comuns, o proxy analisa os cabeçalhos por conta própria, e aí já pode existir limite próprio e até truncamento.
Leitura dos logs no servidor
- Execute
sudo tail -f /var/log/nginx/error.loge repita a requisição problemática. - A linha client sent too long header line confirma que uma linha de cabeçalho individual excedeu o buffer do nginx. A linha client sent too large request fala de estouro do volume total.
- Para Apache, no error.log procure por Request header exceeds LimitRequestFieldSize ou Size of a request header field exceeds server limit.
- Para Node.js, nos logs da aplicação: erro HPE_HEADER_OVERFLOW, um código interno do parser que externamente se transforma em 431.
- No access.log do nginx, veja o campo com o tamanho da requisição. Se você usa o formato padrão, adicione no log_format a variável
$request_length: ela mostrará o tamanho completo da requisição incluindo cabeçalhos e será útil para monitoramento.
Atenção: se no error.log do nginx você vê upstream sent too big header, quem recusa não é a requisição de entrada, mas a resposta da sua aplicação, cujos cabeçalhos não cabem no buffer do nginx. Esse caso aparece como 502, mas pertence ao nosso tema. A causa geralmente está em um Set-Cookie gigantesco ou em dezenas de cabeçalhos do framework. A solução está no passo 6.
Verificação: você deve afirmar com segurança uma das opções: a CDN recusa; o nginx recusa; o Apache recusa; a aplicação recusa; o proxy do meu lado recusa. Se o quadro for ambíguo, significa que o limite foi excedido em vários nós ao mesmo tempo, e você terá que corrigi-los um por um, repetindo o teste do passo 2 a cada vez.
Passo 4: Detectar truncamento silencioso com um endpoint de eco
Objetivo desta etapa: confirmar que os cabeçalhos chegam à aplicação exatamente como foram enviados e pegar o nó que os altera silenciosamente.
A ideia é simples. Vamos subir um pequeno servidor que retorna na resposta todos os cabeçalhos recebidos e seus tamanhos. Enviaremos um cabeçalho de comprimento conhecido com uma soma de verificação e compararemos o que chegou.
Iniciando o servidor de eco em Python
- Crie o arquivo
echo.pycom o seguinte conteúdo:
import hashlib, json
from http.server import BaseHTTPRequestHandler, HTTPServer
class H(BaseHTTPRequestHandler):
def do_GET(self):
out = {}
total = 0
for k, v in self.headers.items():
total += len(k) + len(v) + 4
out[k] = {"len": len(v), "sha": hashlib.sha256(v.encode()).hexdigest()[:12]}
out["_total"] = total
out["_count"] = len(self.headers)
body = json.dumps(out, indent=1).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
HTTPServer(("0.0.0.0", 8089), H).serve_forever()- Execute:
python3 echo.py. O servidor escuta na porta 8089. - Coloque-o onde está sua aplicação real, ou aponte temporariamente um location do nginx para ele:
location /__echo { proxy_pass http://127.0.0.1:8089; }. Assim a requisição passará por toda a cadeia real.
Considere que o HTTPServer padrão do Python não tem limite rígido de comprimento de cabeçalhos, mas limita a quantidade deles a cem. Para o teste, isso é suficiente.
Enviando a requisição de controle
- Gere um valor de 12000 caracteres, mas não uniforme, e sim com marcadores de posição, para ver de onde foi cortado:
V=$(python3 -c "print(''.join(str(i%10) for i in range(12000)))"). - Calcule o hash de referência:
python3 -c "import hashlib,sys; print(hashlib.sha256(sys.argv[1].encode()).hexdigest()[:12])" "$V". - Envie através de toda a cadeia:
curl -s -H "Cookie: probe=$V" -H "X-Probe-Len: 12000" https://seu-site.com.br/__echo. - No campo len da resposta, compare o valor do Cookie com o número 12006 (nome probe mais sinal de igual mais 12000 caracteres) e o hash com a referência.
- Repita com vários cabeçalhos: adicione 30 cabeçalhos
X-Test-1...X-Test-30e verifique o campo _count.
Como ler o resultado
- Comprimento bateu, hash bateu: não há truncamento nesse caminho.
- Comprimento menor, cabeçalho cortado: alguém cortou o final. Veja o último caractere do valor recebido: ele sugere a posição do corte, muitas vezes uma fronteira redonda de 4096 ou 8192 bytes.
- Cabeçalho ausente por completo: o nó descartou o campo que não cabia no buffer. É assim que alguns WAFs e gateways antigos se comportam.
- _count menor que o enviado: atingiu-se o limite de quantidade de cabeçalhos. Apache e Gunicorn por padrão aceitam 100 campos, HAProxy 101, e algumas implementações descartam os excedentes silenciosamente.
- Comprimento bateu, hash não bateu: o nó alterou o conteúdo. Isso acontece com normalização de espaços ou recodificação; verifique se o valor contém caracteres que o proxy considera inválidos.
Dica: se você trabalha através de proxy móvel ou outro proxy externo, suba o servidor de eco em um host publicamente acessível e faça as requisições através do proxy em HTTP simples, sem TLS. É exatamente nesse modo que o proxy analisa os cabeçalhos por conta própria e pode revelar seus limites. No modo HTTPS via CONNECT, o conteúdo é opaco para o proxy, e o truncamento nessa camada é fisicamente impossível.
Verificação: você tem uma tabela: nó, bytes enviados, bytes recebidos, correspondência de hash. Se todas as linhas coincidem, não há truncamento silencioso, e seus sintomas se explicam pelas recusas explícitas dos passos 1 a 3. Se houver divergência, você sabe exatamente onde ela está.
Verificação separada do navegador quanto ao Set-Cookie
O navegador também corta silenciosamente, mas não a requisição e sim a resposta. Se o servidor envia um Set-Cookie com mais de aproximadamente 4096 bytes, o Chrome e o Firefox simplesmente o ignoram, sem nenhum aviso. Verifique: na aba Network, encontre a resposta com Set-Cookie, veja o comprimento da linha, depois abra a aba Application e confirme se o cookie foi salvo. Se não estiver lá, divida o valor em partes ou mova os dados para o servidor.
Passo 5: Reduzir o volume de cookies e cabeçalhos
Objetivo desta etapa: eliminar a raiz do problema, para que as requisições caibam nos limites padrão e não dependam da boa vontade dos nós intermediários.
Aumentar os limites é tentador, mas isso é tratar o sintoma. Cada kilobyte extra de cookie vai junto com cada requisição de cada usuário, incluindo as requisições de imagens. Comece pela redução.
Auditoria de cookies
- Pegue a lista do passo 2, ordenada por tamanho.
- Para cada cookie, responda a três perguntas: quem o define, o servidor precisa dele, ele é necessário em todos os caminhos do site.
- Cookies de sistemas de analytics e pixels de publicidade quase nunca são necessários ao servidor. Não precisam ser removidos, mas não precisam ser enviados ao domínio da API.
- Cookies com estado serializado (carrinho em JSON, preferências de interface, histórico de visualizações) são candidatos a migrar para o localStorage ou para armazenamento no servidor com um identificador curto.
Técnicas de redução
- Mova a API para um subdomínio separado. Cookies definidos em www.site.com.br sem Domain explícito não são enviados para api.site.com.br. Cookies pesados de marketing ficam na vitrine, e a API recebe apenas a sessão.
- Defina o atributo Path. Um cookie com
Path=/adminnão vai em requisições para/static. Verifique se seus frameworks não colocam todos os cookies na raiz sem necessidade. - Armazene no cookie um identificador, não os dados. Em vez de JSON de 3 KB, coloque uma chave de 32 caracteres e mantenha os dados em Redis ou no banco. De quebra, resolve-se o problema de falsificação de conteúdo.
- Encurte os JWT. Um token no cookie ou no Authorization infla por causa de campos desnecessários no payload: lista de papéis, endereço, avatar. Deixe o identificador e o tempo de vida, o resto peça em uma chamada separada. Um JWT típico deve caber em 500-800 bytes.
- Exclua cookies obsoletos explicitamente. Se você renomeou um cookie, o antigo ficará com os usuários até expirar. Envie Set-Cookie com o nome antigo e Max-Age=0.
- Use um domínio separado sem cookies para estáticos. Técnica clássica: static.site.com.br ou um domínio de CDN no qual cookies não são definidos de forma alguma.
- Verifique duplicação. Muitas vezes o mesmo cookie existe em duas variantes: para site.com.br e para .site.com.br com ponto. O navegador enviará os dois.
Para scripts e automação
Se você gerencia muitos perfis através de proxies e navegadores antidetect, fique de olho nos perfis. Um perfil que existe há meio ano acumula cookies de dezenas de domínios de terceiros, e as requisições ao site alvo começam a ser recusadas justamente por causa do cabeçalho inflado. Configure uma limpeza periódica dos cookies de domínios de terceiros, sem mexer nos cookies de autorização do site alvo. Em bibliotecas como requests ou httpx, guarde os cookies em um CookieJar separado por conta e, uma vez por dia, remova os registros expirados.
Dica: adicione no cliente uma verificação simples antes da requisição: se document.cookie.length ultrapassar 6000 caracteres, envie uma métrica para o seu sistema de analytics. Assim você saberá do problema pelos primeiros usuários, e não por reclamações em massa.
Verificação: repita a medição do passo 2 em um perfil limpo, percorra um cenário típico de usuário (login, catálogo, carrinho, checkout) e confirme que o tamanho total dos cabeçalhos não ultrapassa 4 KB na API e 8 KB na vitrine. Essa é uma margem confortável em relação a qualquer limite padrão.
Passo 6: Configurar limites no servidor web, balanceador e aplicação
Objetivo desta etapa: estabelecer limites consistentes em todos os nós que você controla, de modo que nenhum deles seja inesperadamente mais estreito que os vizinhos.
Regra de ouro: o limite do nó externo deve ser menor ou igual ao do nó interno. Caso contrário, o nginx deixará passar 32 KB, e o Node.js atrás dele recusará com 431, e você receberá um erro das profundezas da pilha, mais difícil de diagnosticar. Um bom referencial para 2026: 16 KB para todo o bloco de cabeçalhos e 8-16 KB para um campo individual. Isso basta para quase todos, e mantém a proteção contra abusos.
nginx
- Abra
/etc/nginx/nginx.conf. Localize o blocohttp { ... }. - Adicione ou altere três diretivas:
http {
client_header_buffer_size 4k;
large_client_header_buffers 4 16k;
proxy_buffer_size 16k;
proxy_buffers 8 16k;
}client_header_buffer_sizeé o primeiro buffer pequeno para requisições típicas. O valor padrão de 1k faz o nginx mudar para buffers grandes quase sempre, o que não é grave, mas 4k reduz alocações extras.large_client_header_buffers 4 16ksignifica: até quatro buffers de 16 KB. Cada linha de cabeçalho deve caber inteira em um buffer, e o bloco todo deve caber na soma dos buffers. Isso quer dizer que um cookie individual ou o Authorization não pode ultrapassar 16 KB, e todos os cabeçalhos juntos não podem ultrapassar 64 KB.proxy_buffer_sizeresponde pela primeira porção da resposta do upstream, incluindo seus cabeçalhos. É o aumento dele que elimina o 502 com a frase upstream sent too big header. O valor deproxy_buffersdeve ser no mínimo igual ao de proxy_buffer_size.- Se você quiser que o cliente veja uma resposta com sentido em vez da página padrão 400, adicione dentro do server:
error_page 494 =431 /431.html;e coloque o arquivo 431.html com um texto claro e a sugestão de limpar cookies. Assim você converte o 494 não padronizado em um 431 padrão. - Verifique a sintaxe:
sudo nginx -t. Deve aparecer syntax is ok e test is successful. - Aplique sem interromper conexões:
sudo nginx -s reload.
Lembre-se de que large_client_header_buffers pode ser definido também no contexto server, mas para HTTP/2 vale o valor do contexto http, então edite exatamente lá. Para HTTP/2 existe ainda a diretiva http2_max_header_size em versões antigas; nas compilações atuais ela foi removida, e large_client_header_buffers é suficiente.
Apache
- Abra o arquivo de configuração principal e adicione no nível do servidor ou do VirtualHost:
LimitRequestFieldSize 16384
LimitRequestFields 150
LimitRequestLine 16384LimitRequestFieldSizelimita um campo individual, por padrão 8190 bytes.LimitRequestFieldslimita a quantidade de campos, por padrão 100.LimitRequestLinelimita a linha inicial, o que é importante em URLs longas com parâmetros.- Se o Apache atua como proxy reverso via mod_proxy_http, adicione
ProxyIOBufferSize 32768para respostas com cabeçalhos grandes. - Verifique:
sudo apachectl configtest, depoissudo systemctl reload apache2.
Node.js
- O limite é definido ao iniciar o processo com a flag
--max-http-header-size. O valor é em bytes:node --max-http-header-size=32768 server.js. - Se você usa PM2 ou systemd, indique a flag no campo node_args ou na variável de ambiente
NODE_OPTIONS=--max-http-header-size=32768. - Alternativa no código:
http.createServer({ maxHeaderSize: 32768 }, app). Esse parâmetro é suportado em versões atuais do Node e permite definir o limite sem reiniciar com novas flags. - Após reiniciar, verifique com uma série de curl direto na porta do Node: o limiar deve mudar.
Tomcat e Spring Boot
- No
server.xml, no elemento Connector, adicione o atributomaxHttpHeaderSize="16384". Por padrão, lá está 8192. - No Spring Boot, basta uma linha em application.properties:
server.max-http-request-header-size=16KB. O nome antigo da propriedade server.max-http-header-size também funciona em várias versões, mas está marcado como obsoleto. - Reinicie a aplicação e verifique o limiar.
Gunicorn e Uvicorn
- Para Gunicorn, adicione na configuração ou na linha de comando:
--limit-request-field_size 16380 --limit-request-fields 150 --limit-request-line 8190. Repare na grafia field_size com underscore: é um artefato histórico, e com hífen o parâmetro não funciona. - O valor 0 em limit-request-field_size remove a limitação completamente, mas não faça isso em servidores públicos.
- O Uvicorn limita o tamanho de cabeçalhos por meio do parser h11 e, por padrão, admite valores bastante grandes; geralmente o gargalo está antes dele, no nginx.
HAProxy
- Na seção global:
tune.bufsize 32768etune.http.maxhdr 150. - A requisição inteira, com todos os cabeçalhos, deve caber em um único buffer de tamanho tune.bufsize menos a reserva tune.maxrewrite. Com 16384 padrão, o volume realmente disponível é de cerca de 15 KB.
- Verifique com
haproxy -c -f /etc/haproxy/haproxy.cfge reinicie. Note que aumentar bufsize eleva o consumo de memória por conexão.
IIS
- Os limites ficam no registro, na ramificação HTTP.sys: os parâmetros MaxFieldLength e MaxRequestBytes, na chave HKLM SYSTEM CurrentControlSet Services HTTP Parameters. Os valores padrão são 16384 bytes para ambos, máximo 65534.
- Após a alteração, é necessário reiniciar o serviço HTTP ou o servidor.
- Verifique também
maxAllowedContentLengthemaxQueryStringem requestFiltering, caso o problema envolva URLs longas.
CDN e WAF
Na maioria das CDNs em nuvem, os limites são fixos nos planos básicos e só mudam nos planos corporativos. Se o limiar do passo 3 esbarra na CDN, o único caminho universal é a redução de cookies do passo 5. Além disso, verifique se no WAF não está configurado um modo em que cabeçalhos grandes não são bloqueados, mas recortados: esse modo cria exatamente o truncamento silencioso, e é melhor mudá-lo para uma recusa explícita com código.
Atenção: não defina limites em megabytes por tranquilidade. Cada kilobyte de buffer se multiplica pelo número de conexões simultâneas, e um atacante pode enviar cabeçalhos gigantes de propósito para esgotar a memória. Mantenha uma margem razoável de duas a três vezes o máximo real, e não mais.
Verificação: repita a série de curl do passo 2 para cada nó separadamente (direto na aplicação, através do nginx, de fora através da CDN). Os limiares devem coincidir ou diminuir do interno para o externo. Confirme que, ao exceder, cada nó retorna um código claro, e não rompe a conexão.
Passo 7: Tornar as recusas explícitas e configurar o monitoramento
Objetivo desta etapa: eliminar o truncamento silencioso no futuro e saber do crescimento dos cabeçalhos antes que eles esbarrem no limite.
Respostas explícitas em vez de silêncio
- Confirme que cada nó seu, ao exceder o limite, retorna 431 ou pelo menos 400 com texto. No nginx isso já foi feito no passo 6 via error_page 494.
- Se você tem um proxy próprio ou gateway com buffer fixo, adicione uma verificação: se o cabeçalho não coube, responda 431 e encerre a conexão. Nunca repasse adiante um valor truncado.
- Na aplicação, adicione validação de cabeçalhos críticos. Por exemplo, se o JWT não faz parsing ou se o cookie de sessão é mais curto que o comprimento esperado, registre isso em um evento separado com a marca possible truncation. Esse é um detector barato de problemas em qualquer nó externo.
Registro dos tamanhos em log
- No nginx, amplie o formato de log. No bloco http:
log_format withsize '$remote_addr - $status "$request" req_len=$request_length cookie_len=$cookie_len';
map $http_cookie $cookie_len { default 0; ~^(?<c>.*)$ $c; }- Uma variante simples e confiável sem map: registre apenas
$request_length. Essa variável já basta para ver o crescimento. - Uma vez por dia, execute um
awkno access.log e encontre o máximo e o 99º percentil de req_len. Se o 99º percentil ultrapassar metade do limite, é hora de limpar os cookies. - Para Apache, use no LogFormat a variável
%Ido mod_logio: ela mostra os bytes de entrada junto com os cabeçalhos.
Alertas
- Crie uma métrica de quantidade de respostas 431 e 400 com corpo sobre cookies. No Prometheus com nginx-exporter, são os status do access.log; em painéis de monitoramento em nuvem, geralmente há a divisão por códigos.
- Configure um limiar: mais de 10 dessas respostas em 5 minutos é um sinal. Um erro 431 em massa quase sempre significa que alguém lançou um novo cookie pesado.
- Adicione uma verificação sintética: uma vez por hora, um script envia uma requisição com um cabeçalho de 90 por cento do limite e verifica que ela passa, e com um cabeçalho de 110 por cento verifica que retorna exatamente 431. Assim você pega tanto um endurecimento acidental do limite quanto sua remoção acidental.
Dica: mantenha o endpoint de eco do passo 4 de forma permanente, restringindo-o por IP ou com autenticação simples. Ele será útil a cada mudança de infraestrutura: você adicionou um WAF, trocou o balanceador, conectou um novo pool de proxies, e em um minuto é possível confirmar que os cabeçalhos chegam inteiros.
Verificação: envie uma requisição propositalmente grande e confirme que ela entrou no log com o tamanho correto, que o contador de 431 aumentou e que o alerta disparou ao forçar o limiar. Depois, retorne os limiares aos valores de produção.
Verificação do resultado
Percorra o checklist. Cada item deve ser atendido, caso contrário volte ao passo correspondente.
Checklist
- A página problemática do passo 1 abre sem erros no perfil principal do navegador.
- O tamanho total dos cabeçalhos de uma requisição típica não ultrapassa 8 KB, e no domínio da API, 4 KB.
- Nenhum cookie ultrapassa 2 KB, e os cookies de terceiros mais pesados não são enviados à API.
- O limiar de recusa em cada nó é conhecido e anotado; os limites diminuem ou coincidem da aplicação até a borda externa.
- Ao exceder o limite, o cliente recebe 431 ou 400 com texto, e não uma conexão interrompida nem uma requisição silenciosamente truncada.
- O endpoint de eco mostra correspondência de comprimento e hash ao enviar por toda a cadeia, inclusive através dos seus proxies.
- No access.log consta o tamanho da requisição, e há alerta configurado para o crescimento de 431.
- Os backups das configurações estão guardados por perto, e você sabe o comando de rollback.
Como testar de ponta a ponta
- Limpe os cookies do domínio de teste e percorra o cenário do usuário, do login até a ação principal. Não deve haver erros.
- Execute o ciclo de curl do passo 2 a partir de fora. Anote o limiar; ele deve corresponder às suas novas configurações.
- Envie a requisição de controle ao endpoint de eco por cada caminho utilizado: diretamente, pela CDN, pelo pool de proxies.
- Envie de propósito um cabeçalho com o dobro do limite e confirme o recebimento de 431 com um corpo claro.
- Verifique que as respostas da aplicação com Set-Cookie grandes não provocam 502 no nginx.
Indicadores de sucesso
A proporção de respostas 431 e 400 com texto sobre cabeçalhos tende a zero no tráfego normal. O 99º percentil do tamanho da requisição é menor que a metade do limite mais estreito. Desconexões sem motivo e sessões perdidas não aparecem mais nas reclamações dos usuários.
Erros típicos e soluções
Aumentamos o limite no nginx, mas o 431 continua
Causa: atrás do nginx está o Node.js ou o Tomcat com seu próprio limite de 8-16 KB, e agora é ele que recusa. Solução: verifique o limiar direto na porta da aplicação conforme o passo 3 e eleve-o com a flag --max-http-header-size ou maxHttpHeaderSize. Depois confirme que o limite do nginx não é maior que o da aplicação.
Definimos large_client_header_buffers no bloco server, mas nada mudou
Causa: para HTTP/2, o nginx usa o valor do contexto http, e a diretiva também não é herdada como se espera quando definida em vários server para o mesmo endereço. Solução: mova a diretiva para o bloco http e recarregue a configuração.
O erro aparece só para parte dos usuários
Causa: o tamanho do cookie depende do histórico do usuário específico: seções visitadas, experimentos ativados, cookies antigos de versões anteriores do site. Solução: colete estatísticas de tamanho via $request_length, descubra quais cookies crescem e exclua os obsoletos explicitamente via Set-Cookie com Max-Age=0.
Depois de limpar os cookies tudo funciona, mas uma semana depois quebra de novo
Causa: a fonte do crescimento não foi eliminada: por exemplo, um script de analytics adiciona dados a um cookie a cada visita. Solução: encontre o cookie que cresce, ordenando por tamanho em dias diferentes, e mova seu conteúdo para o localStorage ou limite isso no lado do fornecedor do script.
O nginx retorna 502, embora a aplicação esteja viva
Causa: no error.log há a frase upstream sent too big header: os cabeçalhos de resposta da aplicação não couberam em proxy_buffer_size. Geralmente a culpa é de um Set-Cookie enorme ou de muitos cabeçalhos de depuração. Solução: aumente proxy_buffer_size para 16k e proxy_buffers para 8 16k, e na aplicação reduza os cabeçalhos de resposta.
Através do proxy, a requisição HTTP perde parte dos cabeçalhos, mas por HTTPS passa
Causa: para HTTP, o proxy mesmo analisa os cabeçalhos e esbarra no seu buffer; para HTTPS via CONNECT, o conteúdo é opaco e passa intacto. Solução: migre para HTTPS no recurso alvo ou reduza os cabeçalhos. Se o proxy for seu, eleve o limite dele e configure recusa explícita em vez de truncamento.
O navegador não salva o cookie após a resposta do servidor
Causa: a linha Set-Cookie tem mais de 4096 bytes, ou o número total de cookies no domínio ultrapassou o limite do navegador (cerca de 180 no Chrome), e ele descartou silenciosamente o novo ou expulsou o antigo. Solução: guarde no cookie apenas um identificador e mantenha os dados no servidor; não crie dezenas de cookies pequenos, combine-os.
O Gunicorn ignora o parâmetro de limite
Causa: o parâmetro foi escrito com hífen como limit-request-field-size, mas o nome correto contém underscore: limit-request-field_size. Solução: corrija a grafia e reinicie os workers.
Recursos adicionais
Limites diferentes para caminhos diferentes
Não é obrigatório elevar o limite para o site inteiro. Se cabeçalhos pesados são necessários apenas em um caminho, por exemplo no upload de arquivos com metadados longos, no nginx você pode isolar esse caminho em um server separado, em um nome ou porta distinta, com large_client_header_buffers ampliados, e deixar o site principal rigoroso. Assim você preserva a proteção contra abusos onde ela é mais importante.
Compressão de cabeçalhos em HTTP/2 e HTTP/3
Os protocolos HTTP/2 e HTTP/3 comprimem cabeçalhos com os algoritmos HPACK e QPACK. Pela rede, cookies repetidos vão de forma compacta, mas no servidor eles são descomprimidos ao tamanho completo, e os limites se aplicam exatamente aos dados descomprimidos. Por isso, ativar HTTP/2 economiza tráfego, mas não salva do 431. O parâmetro SETTINGS_MAX_HEADER_LIST_SIZE, que o servidor anuncia ao cliente, define o limite superior da lista descomprimida; no nginx ele é calculado automaticamente a partir de large_client_header_buffers.
Cookies fragmentados
Algumas bibliotecas de autorização conseguem dividir um valor longo em vários cookies com sufixos .0, .1, .2 e recompor no servidor. Isso resolve o problema do limite do navegador de 4 KB por cookie, mas não reduz o tamanho total do cabeçalho Cookie. Use essa técnica apenas como medida temporária durante a migração para armazenamento de sessões no servidor.
Sessões no servidor em vez de cookies-contêineres
A solução arquitetural mais confiável: no cookie fica apenas um identificador aleatório de 32-64 caracteres, e todo o estado fica em Redis com TTL. O cabeçalho Cookie, assim, raramente ultrapassa 200 bytes, e todo o tema de limites deixa de ser relevante. A migração leva de um dia, para uma aplicação pequena, a várias semanas, para uma grande, mas se paga com a redução de tráfego e a simplificação da segurança.
Verificação automática em CI
Adicione ao pipeline um teste: suba a aplicação, envie uma requisição com cabeçalhos a 90 por cento do limite declarado e verifique o código 200; depois a 120 por cento e verifique o código 431. O teste leva segundos e evita que o limite seja estreitado acidentalmente ao atualizar o framework, quando os valores padrão mudam.
Trabalho com pool de proxies
Se você usa vários servidores proxy ou um pool móvel com rotação, faça a requisição de controle ao endpoint de eco através de cada saída, por HTTP e por HTTPS. Salve os resultados em uma tabela. Assim você identifica saídas com comportamento não padronizado e pode excluí-las ou enviar por elas apenas tráfego HTTPS, onde o truncamento é impossível.
FAQ
Qual é a diferença entre 431 e 494, se no fundo ambos são sobre cabeçalhos grandes?
431 é o código padrão da especificação HTTP, compreendido por todos os clientes e ferramentas de monitoramento. 494 é um código interno do nginx, que por padrão é transformado externamente em 400 com o texto Request Header Or Cookie Too Large. Para o usuário não há diferença, mas para o diagnóstico, o 494 nos logs ou em error_page indica inequivocamente o nginx como origem.
Não dá para simplesmente definir um limite enorme e esquecer?
Tecnicamente sim, mas isso aumentará o consumo de memória por conexão e facilitará ataques com cabeçalhos gigantes. Além disso, os limites das CDNs e dos navegadores você não controla, e o problema simplesmente migrará para lá. A ordem correta: primeiro reduzir os cookies, depois definir um limite moderado com margem.
Por que em janela anônima tudo funciona, mas no modo normal dá erro?
Em janela anônima não há cookies acumulados. É um indício quase certo de que a causa está no tamanho do cabeçalho Cookie daquele usuário específico. Limpar os cookies do domínio resolve o problema pontualmente, e o passo 5 resolve para sempre.
Como medir o tamanho dos cabeçalhos se não tenho acesso ao servidor?
Use o painel de desenvolvedor: a aba Application mostra o tamanho de cada cookie, e o comando document.cookie.length no console dá o comprimento total dos cookies acessíveis a scripts. Para o limiar exato de recusa, envie curl com um cabeçalho artificialmente grande e observe o código de resposta.
Meu proxy pode truncar cabeçalhos em requisições HTTPS?
Não. Em HTTPS via proxy, usa-se o método CONNECT, e o proxy transmite o fluxo criptografado de bytes sem ver seu conteúdo. Truncar ou alterar cabeçalhos dentro dele é fisicamente impossível. Já em requisições HTTP comuns, o proxy analisa os cabeçalhos por conta própria, e aí são possíveis tanto limites quanto truncamento.
Como saber que um cabeçalho foi truncado, se não há erro?
Suba o endpoint de eco do passo 4, envie um cabeçalho de comprimento conhecido com marcadores de posição e compare o comprimento e o hash do valor recebido com o enviado. A divergência mostrará tanto o fato do truncamento quanto a posição do corte.
O nginx deixa passar, mas a aplicação em Node.js responde 431. O que fazer?
Elevar o limite do Node.js com a flag --max-http-header-size ou o parâmetro maxHeaderSize em createServer, e depois igualar o limite do nginx ao mesmo valor ou a um menor, para que a recusa ocorra na camada externa com uma página compreensível.
O que é mais importante limitar: o tamanho de um cabeçalho ou o total?
Ambos. O tamanho total protege a memória, e o limite por campo protege os parsers. No nginx, os dois limites derivam de large_client_header_buffers: o tamanho do buffer é o limite por linha, e a quantidade de buffers multiplicada pelo tamanho é o limite total.
Vale a pena interceptar 431 no cliente e limpar cookies automaticamente?
Para o seu próprio site, é uma ótima técnica: ao receber 431 ou 400 com o texto adequado, o front-end remove cookies sabidamente não obrigatórios e repete a requisição. Não remova cookies de autorização sem o consentimento do usuário e sempre registre esses eventos, para eliminar a raiz do problema.
Como confirmar que uma nova versão do framework não alterou o limite padrão?
Mantenha a verificação sintética do passo 7 e o teste em CI da seção de recursos adicionais. Ambos enviam requisições na fronteira do limite e mostrarão imediatamente se o limiar se deslocou em qualquer direção.
Conclusão
Vamos resumir o que você fez. Você aprendeu a reproduzir o erro e a distinguir 431, 494 e sua face pública como 400 pela assinatura da resposta. Você mediu o tamanho real dos cabeçalhos e cookies e encontrou o limiar de recusa com busca binária via curl. Você identificou qual nó da cadeia é responsável pela recusa e separou esse problema dos códigos da camada de proxy, como 407, 502 e 504, guardando para si o marcador útil sobre upstream sent too big header. Com o endpoint de eco, você pegou ou descartou o truncamento silencioso, que não deixa rastro nos logs. Depois, você reduziu os cookies, moveu a API para um domínio limpo, harmonizou limites no nginx, Apache, Node.js, Tomcat, Gunicorn e HAProxy, tornou as recusas explícitas e conectou o monitoramento.
O que fazer agora. Na próxima semana, observe a métrica de tamanho das requisições e o contador de 431: eles mostrarão se ainda resta alguma fonte de crescimento de cookies. Estabeleça uma regra para a equipe: todo cookie novo passa por revisão com perguntas sobre tamanho, domínio e caminho. Se o projeto usa sessões em cookie como estado serializado, planeje a migração para armazenamento no servidor com um identificador curto.
Para onde evoluir. O próximo nível é o entendimento profundo da compressão de cabeçalhos em HTTP/2 e HTTP/3, o ajuste fino de buffers sob carga e a construção de uma camada transparente de observabilidade, na qual o tamanho de cada requisição aparece no trace. Também é útil estudar como os limites se comportam ao trabalhar com diferentes tipos de proxies e balanceadores, e montar sua própria tabela de limiares para a infraestrutura com a qual você trabalha. As ferramentas reunidas neste guia, incluindo o endpoint de eco e o ciclo de curl, ficarão com você e economizarão horas a cada próxima recusa estranha. Você conseguiu, e agora essa categoria de problemas deixou de ser um mistério.