Errores 431 y 494 y el recorte silencioso de encabezados: guía paso a paso para diagnosticar y configurar límites
Contenido del artículo
- Introducción
- Preparación previa
- Conceptos básicos
- Paso 1: reproducir el problema y fijar los síntomas
- Paso 2: medir el tamaño real de los encabezados y las cookies
- Paso 3: determinar qué capa rechaza
- Paso 4: detectar el recorte silencioso con un endpoint de eco
- Paso 5: reducir el volumen de cookies y encabezados
- Paso 6: configurar los límites en el servidor web, el balanceador y la aplicación
- Paso 7: hacer explícitos los rechazos y configurar el monitoreo
- Verificación del resultado
- Errores típicos y soluciones
- Posibilidades adicionales
- Faq
- Conclusión
Introducción
Esta guía está dedicada a un grupo de problemas estrecho pero muy traicionero: la solicitud no pasa o pasa parcialmente porque sus encabezados o cookies se volvieron demasiado grandes. Externamente se ve como el error 431 Request Header Fields Too Large, como el código específico de nginx 494 Request Header Too Large, como el poco claro 400 Request Header Or Cookie Too Large y, en el peor de los casos, no se ve de ninguna manera: algún nodo intermedio descarta los encabezados en silencio y la aplicación recibe al usuario sin sesión, sin token de autorización o sin las cookies necesarias.
Es importante distanciarse de inmediato del tema vecino. En un artículo aparte analizamos los códigos 407, 502 y 504, que devuelve la propia capa de proxy al establecer el túnel: no pasó la autorización en el proxy, no se levantó el upstream, venció el tiempo de espera. Ahí el problema está en la conexión y en el proxy mismo. Aquí, en cambio, la conexión se establece normalmente, el túnel existe, pero los datos que intentas enviar a través de él no caben en los búferes de uno de los nodos de la cadena. La causa siempre está en el volumen y la composición de los encabezados, y se cura con herramientas completamente distintas.
Qué obtendrás al final
- La habilidad de medir con precisión en pocos minutos el tamaño de los encabezados y las cookies de una solicitud concreta.
- Entender qué nodo exacto de la cadena (navegador o cliente, proxy, balanceador, servidor web, aplicación) rechaza o recorta los datos.
- Un endpoint de eco listo para detectar el recorte silencioso sin un solo código de error.
- Configuraciones funcionales de límites para nginx, Apache, Node.js, HAProxy, Tomcat y Gunicorn con la explicación de cada parámetro.
- Una estrategia para reducir las cookies y que el problema no regrese en un mes.
- Monitoreo que avisará de la cercanía al límite con anticipación.
Para quién es esta guía
Para desarrolladores web, administradores de sistemas, especialistas en scraping y automatización, y también para quienes trabajan con muchas cuentas a través de proxies y se topan regularmente con rechazos incomprensibles. El nivel de dificultad es medio: no necesitas ser experto en el protocolo HTTP, pero sí contar con habilidades básicas de terminal y entender qué es un archivo de configuración.
Qué necesitas saber de antemano
- Cómo abrir la terminal y ejecutar un comando.
- Cómo abrir el panel de desarrollador en el navegador (tecla F12).
- Dónde están los archivos de configuración de tu servidor web, si lo administras.
- Una idea general de que la solicitud va del cliente pasando por nodos intermedios hasta el servidor.
Cuánto tiempo tomará
El diagnóstico de los pasos 1-4 toma entre 30 y 60 minutos. La corrección del lado del servidor (pasos 5-7) tomará otras 1-2 horas considerando reinicios y verificaciones. Si solo estás revisando un servicio ajeno y no tienes acceso a su configuración, te bastarán los primeros cuatro pasos y la sección sobre reducción de cookies.
Preparación previa
No hará falta nada exótico, pero prepara las herramientas con anticipación para no distraerte durante el proceso.
Herramientas necesarias
- curl versión 7.70 o superior. Está en macOS, en todas las distribuciones de Linux y en Windows 10 y 11 de fábrica. Verifícalo con el comando
curl --version. - Navegador con panel de desarrollador: Chrome, Edge, Firefox o Yandex Browser. Necesitarás la pestaña Network (Red) y la pestaña Application o Storage para ver las cookies.
- Editor de texto con resaltado: VS Code, Notepad++ o el nano integrado en el servidor.
- Acceso por SSH al servidor, si vas a cambiar los límites. Se requieren permisos de lectura de logs y de reinicio de servicios.
- Python 3 o Node.js para levantar el endpoint de eco. Cualquier versión actual sirve.
- Opcional: mitmproxy o el analizador integrado del navegador antidetect, si quieres ver el tráfico entre el cliente y el proxy.
Requisitos del sistema
Cualquier máquina de trabajo. Para el servidor de eco bastan 100 MB de memoria RAM. El único requisito real es el acceso de red al servicio que estás revisando y, si hace falta, al proxy que uses.
Qué descargar y configurar
- Confirma que curl funciona: ejecuta
curl -sI https://example.com. Deberías ver las líneas de encabezados de la respuesta, empezando conHTTP/2 200o similar. - Si trabajas a través de un proxy, prepara su dirección, puerto, usuario y contraseña. Verifica la conexión básica con el comando
curl -x http://usuario:contraseña@host:puerto -sI https://example.com. Si aquí hay un error 407 o la conexión no se establece en absoluto, regresa al artículo sobre los códigos de la capa de proxy: nuestro tema empieza solo después de un túnel exitoso. - En el servidor, encuentra el archivo de configuración principal: para nginx suele ser
/etc/nginx/nginx.confy la carpeta/etc/nginx/conf.d/, para Apache/etc/apache2/apache2.confo/etc/httpd/conf/httpd.conf. - Localiza los logs:
/var/log/nginx/error.log,/var/log/nginx/access.log,/var/log/apache2/error.log. Asegúrate de poder leerlos con el comandotail -n 50.
Copias de seguridad
Antes de cualquier cambio en la configuración, haz una copia. Toma segundos y salva horas.
- Ejecuta
sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak-2026. - Para la carpeta de sitios:
sudo cp -r /etc/nginx/conf.d /etc/nginx/conf.d.bak-2026. - Para Apache de la misma forma:
sudo cp /etc/apache2/apache2.conf /etc/apache2/apache2.conf.bak-2026. - Anota los valores actuales de los límites en un archivo de notas aparte para entender desde dónde partiste.
Atención: nunca edites la configuración de producción sin verificar antes la sintaxis. Para nginx es sudo nginx -t, para Apache sudo apachectl configtest. Un error en una sola línea al reiniciar dejará el servicio caído.
Conceptos básicos
Antes de cazar el problema, pongamos de acuerdo los términos. Aquí no hay nada complicado, pero la confusión en las palabras a menudo lleva el diagnóstico por el camino equivocado.
Qué son los encabezados de solicitud
Cualquier solicitud HTTP consta de una línea inicial (método, ruta, versión del protocolo), un bloque de encabezados y un cuerpo opcional. Los encabezados son pares del tipo Nombre: valor. El navegador los agrega automáticamente: Host, User-Agent, Accept, Accept-Language, Referer, Authorization y, por supuesto, Cookie. Las aplicaciones agregan los suyos: tokens, identificadores de rastreo, marcas de experimentos.
Por qué las cookies son el culpable más frecuente
El encabezado Cookie se arma con todas las cookies que coinciden con el dominio y la ruta de la solicitud. Cada sistema analítico, cada widget de chat, cada red publicitaria agrega varias. El valor de una cookie puede llegar a 4 KB, y en un dominio hay decenas. Además, el navegador las envía con todas las solicitudes, incluidas imágenes y fuentes. Como resultado, el encabezado Cookie supera fácilmente los 8-16 KB, y precisamente esos umbrales están por defecto en la mayoría de los servidores.
Código 431
431 Request Header Fields Too Large es un código estándar descrito en la especificación HTTP. El servidor comunica: los encabezados son demasiado grandes, ya sea uno de ellos o todos juntos. El código lo devuelven Node.js, Go, Envoy, algunas CDN y frameworks modernos. La respuesta con 431 es correcta según el protocolo y se ve bien en los logs, por eso es la variante más cómoda para diagnosticar.
Código 494
494 Request Header Too Large es un código interno no estándar de nginx. Nginx lo usa en su código cuando el encabezado no cabe en los búferes definidos por la directiva large_client_header_buffers. En ese caso, al cliente se le envía por defecto un 400 con el cuerpo Request Header Or Cookie Too Large. Ver exactamente el número 494 se puede en dos casos: si el administrador describió explícitamente error_page 494, o si estás leyendo variables internas y logs de nginx. Por eso, si un usuario se queja de una página en blanco con el texto 400 y palabras sobre cookies, sabe que es el mismo 494.
Recorte silencioso
El escenario más desagradable. El nodo intermedio no rechaza la solicitud, sino que recorta el encabezado según el tamaño de su búfer o descarta parte de los encabezados por completo. La aplicación recibe datos incompletos. Los síntomas son variados: el usuario de repente pierde la sesión, se pierde el carrito, no se lee el token, desaparece el encabezado con el identificador de región. No hay código de error, en los logs del servidor web todo está en verde. Este comportamiento aparece en proxies hechos a mano con búferes fijos, en pasarelas corporativas antiguas, en algunos WAF en modo de procesamiento suave, en bibliotecas cliente que fragmentan o recortan valores largos y también en el propio navegador, que ignora en silencio un Set-Cookie de más de 4096 bytes.
Dónde están los límites en general
Imagina la cadena: navegador o script, luego tu proxy de salida (por ejemplo, móvil), luego CDN o WAF, luego el balanceador, luego el servidor web, luego el servidor de aplicaciones. Cada eslabón tiene su propio límite y su propio comportamiento al excederlo. La tarea del diagnóstico es encontrar el punto más estrecho. Por eso, a menudo no basta con aumentar el límite en nginx: detrás está Node.js con su propio umbral de 16 KB.
Frontera con el error 502 upstream sent too big header
Un caso aparte en el cruce de dos temas. Si nginx escribe en error.log la frase upstream sent too big header while reading response header from upstream y devuelve 502, el asunto no está en el túnel ni en la caída del upstream, sino en los encabezados de la respuesta de la aplicación que no caben en proxy_buffer_size. Formalmente es un 502, pero se cura con parámetros de búferes de los que hablamos aquí. Recuerda este marcador: te ayudará a no buscar el problema en la capa de proxy.
Paso 1: Reproducir el problema y fijar los síntomas
Objetivo de la etapa: obtener un escenario estable en el que el error ocurra y anotar los signos exactos: código, texto de la respuesta, encabezado Server y hora.
- Abre la página problemática en el navegador. Presiona F12, ve a la pestaña Network (Red).
- Marca la casilla Preserve log (Conservar registro) para que los registros no desaparezcan al navegar.
- Recarga la página con la tecla F5. Encuentra la solicitud marcada en rojo o con estado 400, 431 o 494. Haz clic en ella.
- En la pestaña Headers anota: el código de estado, el valor del encabezado
Serveren la respuesta (nginx, cloudflare, AkamaiGHost, gunicorn), el valor deVia, si existe, y cualquier encabezado con prefijoX-oCF-. - Ve a la pestaña Response y copia el cuerpo de la respuesta. La frase Request Header Or Cookie Too Large apunta a nginx. La frase Request Header Fields Too Large sin la palabra Cookie es típica de Node.js. La frase Bad Request - Request Too Long es característica de IIS.
- Desplázate hacia abajo hasta el bloque Request Headers. Estima la longitud de la línea
Cookie: si ocupa varias pantallas, ya es una pista. - Abre una ventana en modo incógnito y repite la solicitud. Si en un perfil limpio no hay error, las culpables son las cookies acumuladas de un usuario concreto.
Si el problema se reproduce en un script y no en el navegador, registra los mismos datos de la respuesta de la biblioteca: estado, cuerpo, encabezados. En Python requests es response.status_code, response.text y response.headers.
Consejo: exporta todas las solicitudes a un archivo HAR con el botón derecho sobre la lista de solicitudes y la opción Save all as HAR with content. Ese archivo se puede abrir después o pasar a un colega, y conservará los tamaños exactos de los encabezados.
Verificación: debes tener una nota con cuatro puntos: código de estado, texto del cuerpo de la respuesta, valor del encabezado Server y resultado de la prueba en incógnito. Si el resultado en incógnito es distinto, ya conoces al 70 por ciento la causa.
Posibles problemas
- El error no se manifiesta siempre. Entonces el tamaño de la cookie fluctúa cerca del umbral: por ejemplo, tras visitar cierta sección se agrega una cookie más. Anota después de qué acciones aparece el error.
- No hay solicitud en rojo, pero la página funciona mal. Es señal de recorte silencioso. Pasa al paso 4 inmediatamente después de medir.
Paso 2: Medir el tamaño real de los encabezados y las cookies
Objetivo de la etapa: obtener cifras exactas en bytes: el tamaño total del bloque de encabezados, el tamaño del encabezado Cookie y el tamaño de cada cookie individual.
Medición en el navegador
- En el panel de desarrollador abre la pestaña Console (Consola).
- Escribe
document.cookie.lengthy presiona Enter. Verás un número: es la longitud en caracteres de todas las cookies accesibles para los scripts, sin la marca HttpOnly. El encabezado real será mayor, porque las cookies HttpOnly no entran aquí. - Escribe
document.cookie.split('; ').map(c => [c.split('=')[0], c.length]).sort((a, b) => b[1] - a[1]). La consola mostrará un arreglo de pares nombre-longitud, ordenado de mayor a menor. Las cookies más pesadas quedarán arriba. - Ve a la pestaña Application (en Firefox Storage), despliega Cookies, elige el dominio. Aquí se ven todas las cookies, incluidas las HttpOnly, con la columna Size. Haz clic en el encabezado de la columna para ordenar por tamaño.
- Suma los tamaños o simplemente mira la línea Cookie en la solicitud del paso 1: en Chrome, al pasar el cursor sobre el encabezado se muestra su longitud.
Medición con curl
Curl permite enviar encabezados de cualquier tamaño y averiguar con precisión a partir de qué volumen el servidor empieza a rechazar. Generemos una cookie de longitud controlada.
- Crea una cadena de 8000 caracteres. En Linux y macOS:
BIG=$(head -c 8000 /dev/zero | tr '\0' 'a'). Si el shell se queja del escape, usa la varianteBIG=$(python3 -c "print('a'*8000)"). - Envía la solicitud:
curl -s -o /dev/null -w '%{http_code}' -H "Cookie: test=$BIG" https://tu-sitio.com/. En pantalla solo aparecerá el código de respuesta. - Cambia el tamaño: 4000, 8000, 12000, 16000, 32000, 64000. Anota a partir de qué valor el código cambia de 200 a 400 o 431.
- Si trabajas a través de proxy, agrega
-x http://usuario:contraseña@host:puertoy repite la serie. La diferencia entre los umbrales con y sin proxy mostrará si hay un límite en el propio proxy.
Ejemplo de búsqueda binaria del umbral en un solo 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://tu-sitio.com/; echo; doneEn Windows PowerShell, el equivalente: $big = 'a' * 16000; curl.exe -s -o NUL -w '%{http_code}' -H "Cookie: t=$big" https://tu-sitio.com/.
Interpretación de las cifras
- Umbral cercano a 8 KB: típico de Apache con configuración por defecto, Tomcat, Gunicorn y también de nginx cuando el encabezado no cabe en un búfer de cuatro de 8 KB.
- Umbral cercano a 16 KB: Node.js desde la versión 13, HAProxy con tune.bufsize básico, IIS.
- Umbral cercano a 32 KB: límite total de algunas CDN. Un encabezado individual allí suele estar limitado a 16 KB.
- Umbral cercano a 60-64 KB: Envoy y parte de los balanceadores en la nube.
- Umbral cercano a 1 MB: el servidor estándar de Go.
Consejo: mide no solo Cookie. Repite la serie con el encabezado Authorization: Bearer $BIG y con varios encabezados más pequeños. Algunos servidores limitan por separado el tamaño de un campo, por separado su cantidad y por separado el volumen total. Nginx, por ejemplo, por defecto no deja pasar un encabezado de más de 8 KB ni siquiera con un tamaño total pequeño, porque cada línea debe caber en un búfer aparte.
Verificación: en las notas debe aparecer el número a partir del cual el servidor empieza a rechazar y la lista de las tres a cinco cookies más pesadas con sus tamaños. Si no se encontró el umbral hasta 64 KB, pero en el navegador hay error, entonces no es el servidor el que rechaza, sino algo entre el navegador y el servidor en tu entorno concreto. Pasa al siguiente paso.
Paso 3: Determinar qué capa rechaza
Objetivo de la etapa: nombrar con precisión el nodo de la cadena que devuelve el error o corta los datos, para cambiar la configuración justo ahí.
Lectura de la firma de la respuesta
- Ejecuta
curl -sv -H "Cookie: t=$BIG" https://tu-sitio.com/ 2>&1 | grep -i -E 'server|via|cf-|x-served|x-cache|HTTP/', donde BIG supera con certeza el umbral. - Lee el encabezado
Server. El valor nginx con el cuerpo Request Header Or Cookie Too Large significa que nginx rechazó. El valor cloudflare significa que la solicitud no llegó a tu servidor. Un Server vacío y un cuerpo en formato JSON a menudo indica la aplicación. - Presta atención a la versión del protocolo en la primera línea. Si con solicitudes normales el servidor responde por HTTP/2, pero el error llega por HTTP/1.1, es señal de que la respuesta la generó un nodo intermedio, no el final.
- Compara los cuerpos de los errores: la página de nginx es escueta y contiene su nombre al pie; la página de Cloudflare contiene Ray ID; Node.js suele devolver un cuerpo vacío con estado 431.
Rodeo de capas
- Si tienes la dirección IP directa del servidor detrás de la CDN, repite la solicitud con la clave
--resolve tu-sitio.com:443:1.2.3.4. Esto obligará a curl a conectarse directamente, conservando el Host y el SNI correctos. Si directamente pasa y a través de la CDN no, el límite está en la CDN. - Si tienes acceso al servidor, ejecuta la solicitud localmente:
curl -s -o /dev/null -w '%{http_code}' -H "Cookie: t=$BIG" -H 'Host: tu-sitio.com' http://127.0.0.1:80/. Así excluyes todos los nodos externos. - Luego golpea directamente la aplicación, omitiendo nginx:
curl ... http://127.0.0.1:3000/para Node.js o el puerto donde escuche Gunicorn. Si nginx deja pasar y la aplicación responde 431, el límite está en la aplicación. - Verifica la influencia de tu proxy de salida: una serie de solicitudes con
-x, otra sin. Para solicitudes HTTPS a través de proxy se usa el método CONNECT, y el proxy no ve los encabezados dentro del túnel cifrado, por lo que no puede influir en su tamaño. Pero para solicitudes HTTP normales el proxy analiza los encabezados por su cuenta, y aquí ya es posible un límite propio e incluso el recorte.
Lectura de los logs en el servidor
- Ejecuta
sudo tail -f /var/log/nginx/error.logy repite la solicitud problemática. - La línea client sent too long header line confirma que una línea de encabezado individual superó el búfer de nginx. La línea client sent too large request indica un desbordamiento del volumen total.
- Para Apache en error.log busca Request header exceeds LimitRequestFieldSize o Size of a request header field exceeds server limit.
- Para Node.js en los logs de la aplicación: error HPE_HEADER_OVERFLOW, este es el código interno del parser que hacia afuera se convierte en 431.
- En access.log de nginx mira el campo con el tamaño de la solicitud. Si usas el formato estándar, agrega al log_format la variable
$request_length: mostrará el tamaño total de la solicitud junto con los encabezados y será útil para el monitoreo.
Atención: si en error.log de nginx ves upstream sent too big header, lo que rechaza no es la solicitud entrante, sino la respuesta de tu aplicación, cuyos encabezados no caben en el búfer de nginx. Este caso se ve como 502, pero pertenece a nuestro tema. La causa suele ser un Set-Cookie gigante o decenas de encabezados del framework. La solución está en el paso 6.
Verificación: debes poder decir con seguridad una de estas: rechaza la CDN; rechaza nginx; rechaza Apache; rechaza la aplicación; rechaza el proxy de mi lado. Si el panorama es ambiguo, significa que el límite se superó en varios nodos a la vez, y habrá que corregirlos todos por turno, repitiendo cada vez la prueba del paso 2.
Paso 4: Detectar el recorte silencioso con un endpoint de eco
Objetivo de la etapa: asegurarte de que los encabezados llegan a la aplicación exactamente como se enviaron y atrapar al nodo que los cambia en silencio.
La idea es simple. Levantaremos un pequeño servidor que devuelve en la respuesta todos los encabezados recibidos y sus tamaños. Enviaremos un encabezado de longitud conocida con suma de control y compararemos qué llegó.
Arranque del servidor de eco en Python
- Crea el archivo
echo.pycon el siguiente contenido:
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()- Arranca:
python3 echo.py. El servidor escucha en el puerto 8089. - Ubícalo donde está tu aplicación real o redirige temporalmente hacia él un location en nginx:
location /__echo { proxy_pass http://127.0.0.1:8089; }. Entonces la solicitud pasará por toda la cadena real.
Ten en cuenta que el HTTPServer estándar de Python no tiene un límite estricto de longitud de encabezados, pero limita su cantidad a cien. Para la prueba, esto es suficiente.
Envío de la solicitud de control
- Genera un valor de 12000 caracteres, pero no homogéneo, sino con marcadores de posición, para ver desde dónde se cortó:
V=$(python3 -c "print(''.join(str(i%10) for i in range(12000)))"). - Calcula el hash de referencia:
python3 -c "import hashlib,sys; print(hashlib.sha256(sys.argv[1].encode()).hexdigest()[:12])" "$V". - Envía a través de toda la cadena:
curl -s -H "Cookie: probe=$V" -H "X-Probe-Len: 12000" https://tu-sitio.com/__echo. - En la respuesta, compara el campo len para Cookie con el número 12006 (el nombre probe más el signo igual más 12000 caracteres) y el hash con el de referencia.
- Repite con varios encabezados: agrega 30 encabezados
X-Test-1...X-Test-30y verifica el campo _count.
Cómo leer el resultado
- La longitud coincide, el hash coincide: no hay recorte en esta ruta.
- La longitud es menor, el encabezado está cortado: alguien cortó la cola. Mira el último carácter del valor recibido: te indicará la posición del corte, a menudo es un límite exacto de 4096 u 8192 bytes.
- El encabezado falta por completo: el nodo descartó el campo que no cabía en el búfer. Así se comportan algunos WAF y pasarelas antiguas.
- _count es menor que lo enviado: se alcanzó el límite de cantidad de encabezados. Apache y Gunicorn aceptan por defecto 100 campos, HAProxy 101, y parte de las implementaciones descarta los sobrantes en silencio.
- La longitud coincide, el hash no: el nodo cambió el contenido. Esto pasa con la normalización de espacios o la recodificación; verifica si hay en el valor caracteres que el proxy considera inválidos.
Consejo: si trabajas a través de un proxy móvil u otro proxy externo, levanta el servidor de eco en un host de acceso público y ejecuta las solicitudes a través del proxy en HTTP normal sin TLS. Justo en este modo el proxy analiza los encabezados por su cuenta y puede mostrar sus límites. En modo HTTPS a través de CONNECT el contenido es opaco para el proxy y el recorte en esa capa es físicamente imposible.
Verificación: tienes una tabla: nodo, bytes enviados, bytes recibidos, coincidencia del hash. Si todas las filas coinciden, no hay recorte silencioso y tus síntomas se explican por los rechazos explícitos de los pasos 1-3. Si hay discrepancia, ya sabes dónde está.
Verificación aparte del navegador sobre Set-Cookie
El navegador también corta en silencio, pero no la solicitud, sino la respuesta. Si el servidor envía un Set-Cookie de más de aproximadamente 4096 bytes, Chrome y Firefox simplemente lo ignoran, sin una sola advertencia. Verifícalo: en la pestaña Network encuentra la respuesta con Set-Cookie, mira la longitud de la línea, luego abre la pestaña Application y asegúrate de que la cookie se guardó. Si no está, divide el valor en partes o traslada los datos al servidor.
Paso 5: Reducir el volumen de cookies y encabezados
Objetivo de la etapa: eliminar la raíz del problema para que las solicitudes quepan en los límites estándar y no dependan de la voluntad de los nodos intermedios.
Aumentar los límites es tentador, pero es tratar el síntoma. Cada kilobyte extra de cookies se va con cada solicitud de cada usuario, incluidas las solicitudes de imágenes. Empieza por reducir.
Auditoría de cookies
- Toma la lista del paso 2, ordenada por tamaño.
- Para cada cookie responde tres preguntas: quién la pone, la necesita el servidor, se necesita en cada ruta del sitio.
- Las cookies de sistemas analíticos y píxeles publicitarios casi nunca las necesita el servidor. No hay que eliminarlas, pero sí evitar enviarlas al dominio de la API.
- Las cookies con estado serializado (carrito en JSON, ajustes de interfaz, historial de vistas) son candidatas a trasladarse a localStorage o al almacenamiento del servidor con un identificador corto.
Técnicas de reducción
- Saca la API a un subdominio aparte. Las cookies puestas en www.sitio.com sin un Domain explícito no se envían a api.sitio.com. Las cookies pesadas de marketing se quedarán en la vitrina y la API recibirá solo la sesión.
- Define el atributo Path. Una cookie con
Path=/adminno se irá en solicitudes a/static. Verifica que tus frameworks no pongan todas las cookies en la raíz sin necesidad. - Guarda en la cookie un identificador, no los datos. En lugar de un JSON de 3 KB, pon una clave de 32 caracteres y mantén los datos en Redis o en la base. De paso se resolverá el problema de la falsificación del contenido.
- Acorta los JWT. El token en la cookie o en Authorization se infla por campos sobrantes en el payload: lista de roles, dirección, avatar. Deja el identificador y el tiempo de vida; el resto solicítalo con una llamada aparte. Un JWT típico debe caber en 500-800 bytes.
- Elimina las cookies obsoletas de forma explícita. Si renombraste una cookie, la vieja permanecerá en los usuarios hasta que venza. Envía un Set-Cookie con el nombre viejo y Max-Age=0.
- Usa un dominio aparte sin cookies para los estáticos. El truco clásico: static.sitio.com o un dominio de CDN en el que no se ponen cookies en absoluto.
- Verifica la duplicación. A menudo la misma cookie existe en dos variantes: para sitio.com y para .sitio.com con punto. El navegador enviará ambas.
Para scripts y automatización
Si administras muchas cuentas a través de proxies y navegadores antidetect, vigila los perfiles. Un perfil que vive medio año acumula cookies de decenas de dominios de terceros, y las solicitudes al sitio objetivo empiezan a ser rechazadas precisamente por el encabezado inflado. Configura una limpieza periódica de las cookies de dominios de terceros, sin tocar las cookies de autorización del sitio objetivo. En bibliotecas como requests o httpx, guarda las cookies en un CookieJar aparte por cuenta y una vez al día elimina los registros vencidos.
Consejo: agrega en el cliente una verificación simple antes de la solicitud: si document.cookie.length supera los 6000 caracteres, envía una métrica a tu sistema de analítica. Así te enterarás del problema por los primeros usuarios, no por quejas masivas.
Verificación: repite la medición del paso 2 en un perfil limpio, recorre un escenario típico de usuario (inicio de sesión, catálogo, carrito, compra) y asegúrate de que el tamaño total de los encabezados no supere 4 KB en la API y 8 KB en la vitrina. Es un margen cómodo respecto a cualquier límite estándar.
Paso 6: Configurar los límites en el servidor web, el balanceador y la aplicación
Objetivo de la etapa: establecer límites coherentes en todos los nodos que administras, de modo que ninguno sea inesperadamente más estrecho que sus vecinos.
Regla de oro: el límite del nodo externo debe ser no mayor que el límite del interno. De lo contrario, nginx dejará pasar 32 KB, y Node.js detrás lo rechazará con 431, y obtendrás un error desde lo profundo de la pila, más difícil de diagnosticar. Una referencia razonable para 2026: 16 KB para todo el bloque de encabezados y 8-16 KB para un campo individual. Esto alcanza para casi todos, y a la vez queda protección contra abusos.
nginx
- Abre
/etc/nginx/nginx.conf. Encuentra el bloquehttp { ... }. - Agrega o modifica tres directivas:
http {
client_header_buffer_size 4k;
large_client_header_buffers 4 16k;
proxy_buffer_size 16k;
proxy_buffers 8 16k;
}client_header_buffer_sizees el primer búfer pequeño para solicitudes típicas. El valor 1k por defecto obliga a nginx a cambiar a búferes grandes casi siempre, lo que no es grave, pero 4k reduce asignaciones innecesarias.large_client_header_buffers 4 16ksignifica: hasta cuatro búferes de 16 KB. Cada línea de encabezado debe caber por completo en un búfer, y todo el bloque en la suma de los búferes. Es decir, una cookie o un Authorization individuales no pueden superar 16 KB, y todos los encabezados juntos 64 KB.proxy_buffer_sizese encarga de la primera porción de la respuesta del upstream, incluidos sus encabezados. Justamente su aumento elimina el 502 con la frase upstream sent too big header. El valor deproxy_buffersdebe ser no menor que proxy_buffer_size.- Si quieres que el cliente vea una respuesta sensata en lugar de la página 400 estándar, agrega dentro de server:
error_page 494 =431 /431.html;y coloca el archivo 431.html con un texto claro y el consejo de limpiar las cookies. Así conviertes el 494 no estándar en un 431 estándar. - Verifica la sintaxis:
sudo nginx -t. Debe aparecer syntax is ok y test is successful. - Aplica sin cortar conexiones:
sudo nginx -s reload.
Recuerda que large_client_header_buffers también se puede definir en el contexto server, pero para HTTP/2 rige el valor del contexto http, así que edítalo justo ahí. Para HTTP/2 existe además la directiva http2_max_header_size en versiones antiguas; en las compilaciones actuales fue eliminada y basta con large_client_header_buffers.
Apache
- Abre el archivo principal de configuración y agrega a nivel de servidor o VirtualHost:
LimitRequestFieldSize 16384
LimitRequestFields 150
LimitRequestLine 16384LimitRequestFieldSizelimita un campo, por defecto 8190 bytes.LimitRequestFieldslimita la cantidad de campos, por defecto 100.LimitRequestLinelimita la línea inicial, lo que importa con URL largas con parámetros.- Si Apache funciona como proxy inverso a través de mod_proxy_http, agrega
ProxyIOBufferSize 32768para respuestas con encabezados grandes. - Verifica:
sudo apachectl configtest, luegosudo systemctl reload apache2.
Node.js
- El límite se define al arrancar el proceso con la bandera
--max-http-header-size. El valor en bytes:node --max-http-header-size=32768 server.js. - Si usas PM2 o systemd, indica la bandera en el campo node_args o en la variable de entorno
NODE_OPTIONS=--max-http-header-size=32768. - Alternativa en el código:
http.createServer({ maxHeaderSize: 32768 }, app). Este parámetro se admite en versiones actuales de Node y permite definir el límite sin reiniciar con nuevas banderas. - Verifica tras el reinicio con una serie de curl directamente al puerto de Node: el umbral debe desplazarse.
Tomcat y Spring Boot
- En
server.xml, al elemento Connector agrega el atributomaxHttpHeaderSize="16384". Por defecto allí hay 8192. - En Spring Boot basta una línea en application.properties:
server.max-http-request-header-size=16KB. El nombre antiguo de la propiedad server.max-http-header-size también funciona en varias versiones, pero está marcado como obsoleto. - Reinicia la aplicación y verifica el umbral.
Gunicorn y Uvicorn
- Para Gunicorn agrega en la configuración o en la línea de comandos:
--limit-request-field_size 16380 --limit-request-fields 150 --limit-request-line 8190. Presta atención a la escritura field_size con guion bajo: es un artefacto histórico, y con guion el parámetro no funcionará. - El valor 0 en limit-request-field_size elimina la restricción por completo, pero no lo hagas en servidores públicos.
- Uvicorn limita el tamaño de los encabezados a través del parser h11 y por defecto admite valores bastante grandes; el punto estrecho suele estar delante, en nginx.
HAProxy
- En la sección global:
tune.bufsize 32768ytune.http.maxhdr 150. - La solicitud completa junto con todos los encabezados debe caber en un búfer del tamaño de tune.bufsize menos la reserva tune.maxrewrite. Con 16384 por defecto, el volumen real disponible es de unos 15 KB.
- Verifica
haproxy -c -f /etc/haproxy/haproxy.cfgy reinicia. Ten en cuenta que aumentar bufsize eleva el consumo de memoria por cada conexión.
IIS
- Los límites viven en el registro, en la rama HTTP.sys: los parámetros MaxFieldLength y MaxRequestBytes en la clave HKLM SYSTEM CurrentControlSet Services HTTP Parameters. Los valores por defecto son 16384 bytes para ambos, máximo 65534.
- Tras el cambio se requiere reiniciar el servicio HTTP o el servidor.
- Adicionalmente verifica
maxAllowedContentLengthymaxQueryStringen requestFiltering, si el problema toca URL largas.
CDN y WAF
En la mayoría de las CDN en la nube los límites son fijos en los planes básicos y solo cambian en los corporativos. Si el umbral del paso 3 choca con la CDN, el único camino universal es la reducción de cookies del paso 5. Adicionalmente verifica si en el WAF no está configurado un modo en el que los encabezados grandes no se bloquean, sino que se recortan: ese modo crea el mismísimo recorte silencioso, y es mejor cambiarlo a un rechazo explícito con código.
Atención: no pongas límites en megabytes para quedarte tranquilo. Cada kilobyte de búfer se multiplica por el número de conexiones simultáneas, y un atacante puede enviar a propósito encabezados gigantes para agotar la memoria. Mantén un margen razonable de dos a tres veces el máximo real y no más.
Verificación: repite la serie de curl del paso 2 para cada nodo por separado (directamente a la aplicación, a través de nginx, desde afuera a través de la CDN). Los umbrales deben coincidir o disminuir del interno al externo. Asegúrate de que al excederlos cada nodo devuelva un código claro y no corte la conexión.
Paso 7: Hacer explícitos los rechazos y configurar el monitoreo
Objetivo de la etapa: excluir el recorte silencioso en el futuro y enterarte del crecimiento de los encabezados antes de que choquen con el límite.
Respuestas explícitas en lugar de silencio
- Asegúrate de que cada nodo tuyo, al exceder el límite, devuelva 431 o al menos 400 con texto. En nginx ya está hecho en el paso 6 a través de error_page 494.
- Si tienes un proxy o pasarela hechos a mano con búfer fijo, agrega una verificación: si el encabezado no cabía, responde 431 y cierra la conexión. Nunca transmitas más allá un valor truncado.
- En la aplicación agrega validación de encabezados críticos. Por ejemplo, si el JWT no se parsea o la cookie de sesión es más corta que la longitud esperada, registra esto como un evento aparte con la marca possible truncation. Es un detector barato de problemas en cualquier nodo externo.
Registro de tamaños
- En nginx amplía el formato del log. En el bloque 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; }- La variante simple y confiable sin map: registra solo
$request_length. Esa variable basta para ver el crecimiento. - Una vez al día ejecuta
awksobre access.log y encuentra el máximo y el percentil 99 de req_len. Si el percentil 99 superó la mitad del límite, es hora de limpiar cookies. - Para Apache usa en LogFormat la variable
%Ide mod_logio: muestra los bytes entrantes junto con los encabezados.
Alertas
- Crea una métrica de la cantidad de respuestas 431 y 400 con cuerpo sobre cookies. En Prometheus con nginx-exporter son los estados de access.log; en los paneles de monitoreo en la nube suele haber desglose por códigos.
- Configura un umbral: más de 10 de esas respuestas en 5 minutos es señal. Un error 431 masivo casi siempre significa que alguien desplegó una nueva cookie pesada.
- Agrega una verificación sintética: una vez por hora un script envía una solicitud con un encabezado al 90 por ciento del límite y verifica que pase, y con un encabezado al 110 por ciento verifica que se devuelva justamente 431. Así atraparás tanto un endurecimiento accidental del límite como su eliminación accidental.
Consejo: mantén el endpoint de eco del paso 4 de forma permanente, cerrado por IP o con una autorización simple. Será útil en cada cambio de infraestructura: agregaste un WAF, cambiaste el balanceador, conectaste un nuevo pool de proxies, y en un minuto puedes confirmar que los encabezados llegan completos.
Verificación: envía una solicitud deliberadamente grande y asegúrate de que entró al log con el tamaño correcto, de que el contador de 431 aumentó y de que la alerta se disparó al forzar el umbral. Después devuelve los umbrales a los valores de trabajo.
Verificación del resultado
Recorre la lista de control. Cada punto debe cumplirse; si no, vuelve al paso correspondiente.
Lista de control
- La página problemática del paso 1 se abre sin errores en el perfil principal del navegador.
- El tamaño total de los encabezados de una solicitud típica no supera 8 KB, y en el dominio de la API 4 KB.
- Ninguna cookie supera 2 KB, las cookies de terceros más pesadas no se envían a la API.
- El umbral de rechazo en cada nodo se conoce y está anotado; los límites disminuyen o coinciden desde la aplicación hacia el borde externo.
- Al exceder el límite el cliente recibe el código 431 o 400 con texto, y no un corte de conexión ni una solicitud recortada en silencio.
- El endpoint de eco muestra coincidencia de longitud y hash al enviar a través de toda la cadena, incluidos tus proxies.
- En access.log está presente el tamaño de la solicitud, y hay una alerta configurada para el crecimiento de 431.
- Las copias de seguridad de las configuraciones están a mano y conoces el comando de reversión.
Cómo probar todo de punta a punta
- Limpia las cookies del dominio de prueba y recorre el escenario de usuario desde el inicio de sesión hasta la acción clave. No debe haber errores.
- Ejecuta el ciclo de curl del paso 2 desde afuera. Anota el umbral; debe corresponder a tu nueva configuración.
- Envía una solicitud de control al endpoint de eco por cada ruta que uses: directamente, a través de la CDN, a través del pool de proxies.
- Envía a propósito un encabezado del doble del límite y confirma que recibes 431 con un cuerpo claro.
- Verifica que las respuestas de la aplicación con Set-Cookie grandes no provoquen 502 en nginx.
Indicadores de éxito
La proporción de respuestas 431 y 400 con texto sobre encabezados tiende a cero en el tráfico normal. El percentil 99 del tamaño de la solicitud es menor que la mitad del límite más estrecho. Los cierres de sesión sin motivo y las sesiones perdidas ya no aparecen en los reclamos de los usuarios.
Errores típicos y soluciones
Aumentamos el límite en nginx y el 431 permaneció
Causa: detrás de nginx está Node.js o Tomcat con su propio límite de 8-16 KB, y ahora rechaza él. Solución: verifica el umbral directamente en el puerto de la aplicación desde el paso 3 y súbelo con la bandera --max-http-header-size o maxHttpHeaderSize. Luego asegúrate de que el límite de nginx no sea mayor que el de la aplicación.
Pusimos large_client_header_buffers en el bloque server, pero nada cambió
Causa: para HTTP/2 nginx usa el valor del contexto http, y además la directiva no se hereda como se espera si está definida en varios server para una misma dirección. Solución: traslada la directiva al bloque http y recarga la configuración.
El error aparece solo en parte de los usuarios
Causa: el tamaño de las cookies depende del historial de cada usuario: secciones visitadas, experimentos activados, cookies viejas de versiones anteriores del sitio. Solución: reúne estadísticas de tamaños a través de $request_length, encuentra qué cookies crecen y elimina explícitamente las obsoletas con Set-Cookie y Max-Age=0.
Después de limpiar las cookies todo funciona, pero al cabo de una semana se rompe otra vez
Causa: la fuente del crecimiento no se eliminó: por ejemplo, un script de analítica agrega datos a una misma cookie en cada visita. Solución: encuentra la cookie que crece ordenando por tamaño en días distintos y traslada su contenido a localStorage o limítalo del lado del proveedor del script.
Nginx devuelve 502 aunque la aplicación está viva
Causa: en error.log la frase upstream sent too big header: los encabezados de la respuesta de la aplicación no cabían en proxy_buffer_size. Por lo general el culpable es un Set-Cookie enorme o multitud de encabezados de depuración. Solución: aumenta proxy_buffer_size a 16k y proxy_buffers a 8 16k, y en la aplicación reduce los encabezados de respuesta.
A través del proxy, la solicitud por HTTP pierde parte de los encabezados, y por HTTPS pasa
Causa: para HTTP el proxy mismo analiza los encabezados y choca con su búfer, mientras que para HTTPS a través de CONNECT el contenido es opaco y pasa intacto. Solución: pasa a HTTPS para el recurso objetivo o reduce los encabezados. Si el proxy es tuyo, sube su límite y configura un rechazo explícito en lugar del recorte.
El navegador no guarda la cookie después de la respuesta del servidor
Causa: la línea Set-Cookie supera los 4096 bytes o el número total de cookies en el dominio superó el límite del navegador (unos 180 en Chrome), y este descartó la nueva en silencio o expulsó la vieja. Solución: guarda en la cookie solo un identificador y mantén los datos en el servidor; no crees decenas de cookies pequeñas, únelas.
Gunicorn ignora el parámetro de límite
Causa: el parámetro está escrito con guion como limit-request-field-size, y el nombre correcto lleva guion bajo: limit-request-field_size. Solución: corrige la escritura y reinicia los workers.
Posibilidades adicionales
Límites distintos para rutas distintas
No es obligatorio subir el límite para todo el sitio. Si los encabezados pesados se necesitan solo en una ruta, por ejemplo al subir archivos con metadatos largos, en nginx se puede sacar esa ruta a un server aparte en un nombre o puerto distintos con large_client_header_buffers aumentados, y dejar el sitio principal estricto. Así conservas la protección contra abusos donde es más importante.
Compresión de encabezados en HTTP/2 y HTTP/3
Los protocolos HTTP/2 y HTTP/3 comprimen los encabezados con los algoritmos HPACK y QPACK. Por la red, las cookies repetidas viajan de forma compacta, pero en el servidor se descomprimen a su tamaño completo, y los límites se aplican justamente a los datos descomprimidos. Por eso activar HTTP/2 ahorra tráfico, pero no salva del 431. El parámetro SETTINGS_MAX_HEADER_LIST_SIZE, que el servidor le declara al cliente, define el límite superior de la lista descomprimida; en nginx se calcula automáticamente a partir de large_client_header_buffers.
Cookies fragmentadas
Algunas bibliotecas de autorización saben dividir un valor largo en varias cookies con sufijos .0, .1, .2 y reensamblarlas en el servidor. Esto resuelve el problema del límite del navegador de 4 KB por cookie, pero no reduce el tamaño total del encabezado Cookie. Usa el truco solo como medida temporal durante la transición al almacenamiento de sesiones en el servidor.
Sesiones en el servidor en lugar de contenedores de cookies
La solución arquitectónica más confiable: en la cookie queda solo un identificador aleatorio de 32-64 caracteres, y todo el estado vive en Redis con TTL. El encabezado Cookie así rara vez supera los 200 bytes, y todo el tema de los límites deja de ser relevante. La migración toma desde un día para una aplicación pequeña hasta varias semanas para una grande, pero se amortiza con la reducción del tráfico y la simplificación de la seguridad.
Verificación automática en CI
Agrega al pipeline una prueba: levanta la aplicación, envía una solicitud con encabezados al 90 por ciento del límite declarado y verifica el código 200, luego al 120 por ciento y verifica el código 431. La prueba toma segundos y no dejará que se estreche accidentalmente el límite al actualizar el framework, cuando cambian los valores por defecto.
Trabajo con un pool de proxies
Si usas varios servidores proxy o un pool móvil con rotación, ejecuta la solicitud de control al endpoint de eco a través de cada salida por HTTP y por HTTPS. Guarda los resultados en una tabla. Así identificarás las salidas con comportamiento no estándar y podrás excluirlas o enviar a través de ellas solo tráfico HTTPS, donde el recorte es imposible.
FAQ
¿En qué se diferencia 431 de 494, si en esencia ambos son sobre encabezados grandes?
431 es un código estándar de la especificación HTTP, lo entienden todos los clientes y herramientas de monitoreo. 494 es un código interno de nginx que por defecto hacia afuera se convierte en 400 con el texto Request Header Or Cookie Too Large. Para el usuario no hay diferencia, pero para el diagnóstico el 494 en los logs o en error_page indica inequívocamente a nginx como la fuente.
¿Se puede simplemente poner un límite muy grande y olvidarse?
Técnicamente sí, pero así aumentarás el consumo de memoria por cada conexión y facilitarás los ataques con encabezados gigantes. Además, los límites de las CDN y de los navegadores no los controlas, y el problema simplemente se mudará allí. El orden correcto: primero reducir las cookies, después poner un límite moderado con margen.
¿Por qué en incógnito todo funciona y en modo normal hay error?
En incógnito no hay cookies acumuladas. Es una señal casi al cien por ciento de que la causa está en el tamaño del encabezado Cookie de un usuario concreto. Limpiar las cookies del dominio resolverá el problema una vez, y el paso 5 lo resolverá para siempre.
¿Cómo medir el tamaño de los encabezados si no hay acceso al servidor?
Usa el panel de desarrollador: la pestaña Application muestra el tamaño de cada cookie, y el comando document.cookie.length en la consola da la longitud total de las cookies accesibles para los scripts. Para el umbral exacto de rechazo envía curl con un encabezado artificialmente grande y mira el código de respuesta.
¿Mi proxy puede recortar encabezados en solicitudes HTTPS?
No. Con HTTPS a través de proxy se usa el método CONNECT, y el proxy transmite un flujo cifrado de bytes sin ver su contenido. Recortar o modificar los encabezados dentro es físicamente imposible. En cambio, para solicitudes HTTP normales el proxy analiza los encabezados por su cuenta, y aquí sí son posibles tanto los límites como el recorte.
¿Cómo entender que el encabezado está recortado si no hay error?
Levanta el endpoint de eco del paso 4, envía un encabezado de longitud conocida con marcadores de posición y compara la longitud y el hash del valor recibido con el enviado. La discrepancia mostrará tanto el hecho del recorte como la posición del corte.
Nginx deja pasar, pero la aplicación en Node.js responde 431. ¿Qué hacer?
Subir el límite de Node.js con la bandera --max-http-header-size o el parámetro maxHeaderSize en createServer, y luego llevar el límite de nginx al mismo valor o a uno menor, para que el rechazo ocurra en la capa externa con una página clara.
¿Qué es más importante limitar: el tamaño de un encabezado o el tamaño total?
Ambos. El tamaño total protege la memoria, y el límite por campo protege a los parsers. En nginx ambos límites se derivan de large_client_header_buffers: el tamaño del búfer es el límite por línea, y el número de búferes multiplicado por el tamaño es el límite total.
¿Vale la pena interceptar el 431 en el cliente y limpiar cookies automáticamente?
Para tu propio sitio es una gran técnica: al recibir 431 o 400 con el texto adecuado, el frontend elimina las cookies claramente opcionales y repite la solicitud. No elimines las cookies de autorización sin consentimiento del usuario y registra obligatoriamente esos eventos para eliminar la raíz del problema.
¿Cómo asegurarse de que la nueva versión del framework no cambió el límite por defecto?
Mantén la verificación sintética del paso 7 y la prueba en CI de la sección de posibilidades adicionales. Ambas envían solicitudes en el borde del límite y mostrarán de inmediato si el umbral se movió en cualquier dirección.
Conclusión
Resumamos lo que hiciste. Aprendiste a reproducir el error y a distinguir 431, 494 y su apariencia pública en forma de 400 por la firma de la respuesta. Mediste el tamaño real de los encabezados y las cookies y encontraste el umbral de rechazo con búsqueda binaria a través de curl. Determinaste qué nodo de la cadena es responsable del rechazo y separaste este problema de los códigos de la capa de proxy como 407, 502 y 504, quedándote con un marcador útil sobre upstream sent too big header. Con el endpoint de eco atrapaste o descartaste el recorte silencioso, que no deja rastro en los logs. Luego redujiste las cookies, sacaste la API a un dominio limpio, coordinaste los límites en nginx, Apache, Node.js, Tomcat, Gunicorn y HAProxy, hiciste explícitos los rechazos y conectaste el monitoreo.
Qué hacer a continuación. En la próxima semana observa la métrica del tamaño de las solicitudes y el contador de 431: mostrarán si quedó alguna fuente de crecimiento de cookies. Establece una regla para el equipo: cualquier cookie nueva pasa por una revisión con preguntas sobre tamaño, dominio y ruta. Si el proyecto usa sesiones en cookie en forma de estado serializado, planifica la migración al almacenamiento en el servidor con un identificador corto.
Hacia dónde desarrollarse. El siguiente nivel es el entendimiento profundo de la compresión de encabezados en HTTP/2 y HTTP/3, la configuración fina de los búferes bajo carga y la construcción de una capa transparente de observabilidad donde el tamaño de cada solicitud se vea en la traza. También es útil estudiar cómo se comportan los límites al trabajar a través de distintos tipos de proxies y balanceadores, y armar tu propia tabla de umbrales para la infraestructura con la que trabajas. Las herramientas reunidas en esta guía, incluido el endpoint de eco y el ciclo de curl, se quedarán contigo y te ahorrarán horas en cada próximo rechazo extraño. Lo lograste, y ahora esta categoría de problemas dejó de ser un misterio.