Erreurs 431 et 494 et coupure silencieuse des en-têtes : guide étape par étape pour diagnostiquer et configurer les limites
Sommaire de l'article
- Introduction
- Préparation préalable
- Notions de base
- Étape 1 : reproduire le problème et consigner les symptômes
- Étape 2 : mesurer la taille réelle des en-têtes et des cookies
- Étape 3 : déterminer quelle couche refuse
- Étape 4 : détecter la coupure silencieuse avec un point de terminaison echo
- Étape 5 : réduire le volume des cookies et des en-têtes
- Étape 6 : configurer les limites sur le serveur web, l'équilibreur et l'application
- Étape 7 : rendre les refus explicites et configurer la surveillance
- Vérification du résultat
- Erreurs typiques et solutions
- Possibilités supplémentaires
- Faq
- Conclusion
Introduction
Ce guide est consacré à un groupe de problèmes étroit mais très sournois : une requête ne passe pas ou ne passe que partiellement parce que ses en-têtes ou ses cookies sont devenus trop volumineux. Extérieurement, cela se manifeste par l'erreur 431 Request Header Fields Too Large, par le code spécifique à nginx 494 Request Header Too Large, par un vague 400 Request Header Or Cookie Too Large, et dans le pire des cas, cela ne se voit pas du tout : un nœud intermédiaire jette silencieusement une partie des en-têtes, et l'application reçoit un utilisateur sans session, sans jeton d'autorisation ou sans les cookies nécessaires.
Il est important de se démarquer immédiatement d'un sujet voisin. Dans un article séparé, nous avons examiné les codes 407, 502 et 504, qui sont émis par la couche proxy elle-même lors de l'établissement du tunnel : l'autorisation sur le proxy a échoué, l'upstream ne s'est pas levé, le délai a expiré. Là, le problème vient de la connexion et du proxy lui-même. Ici, la connexion s'établit normalement, le tunnel existe, mais les données que vous essayez d'envoyer à travers ne rentrent pas dans les tampons de l'un des nœuds de la chaîne. La cause est toujours dans le volume et la composition des en-têtes, et elle se soigne avec des outils complètement différents.
Ce que vous obtiendrez au final
- La capacité de mesurer précisément en quelques minutes la taille des en-têtes et des cookies d'une requête spécifique.
- La compréhension de quel nœud de la chaîne (navigateur ou client, proxy, équilibreur de charge, serveur web, application) refuse ou coupe les données.
- Un point de terminaison echo prêt à l'emploi pour détecter la coupure silencieuse sans aucun code d'erreur.
- Des configurations de limites fonctionnelles pour nginx, Apache, Node.js, HAProxy, Tomcat et Gunicorn avec l'explication de chaque paramètre.
- Une stratégie de réduction des cookies pour que le problème ne revienne pas dans un mois.
- Une surveillance qui signalera l'approche de la limite à l'avance.
Pour qui est ce guide
Pour les développeurs web, les administrateurs système, les spécialistes du scraping et de l'automatisation, ainsi que pour ceux qui travaillent avec un grand nombre de comptes via des proxies et rencontrent régulièrement des refus incompréhensibles. Le niveau de difficulté est moyen : vous n'avez pas besoin d'être un expert du protocole HTTP, mais des compétences de base en terminal et la compréhension de ce qu'est un fichier de configuration seront nécessaires.
Ce qu'il faut savoir à l'avance
- Comment ouvrir un terminal et exécuter une commande.
- Comment ouvrir le panneau de développement dans un navigateur (touche F12).
- Où se trouvent les fichiers de configuration de votre serveur web, si vous l'administrez.
- Une idée générale du fait qu'une requête part du client, passe par des nœuds intermédiaires et arrive au serveur.
Combien de temps cela prendra
Le diagnostic des étapes 1 à 4 prend de 30 à 60 minutes. La correction côté serveur (étapes 5 à 7) prendra encore 1 à 2 heures, en tenant compte des redémarrages et des vérifications. Si vous ne faites que vérifier un service tiers et n'avez pas accès à ses paramètres, les quatre premières étapes et la section sur la réduction des cookies suffiront.
Préparation préalable
Rien d'exotique ne sera nécessaire, mais préparez les outils à l'avance pour ne pas être distrait en cours de route.
Outils nécessaires
- curl version 7.70 ou plus récente. Il est présent sur macOS, dans toutes les distributions Linux et dans Windows 10 et 11 d'origine. Vérifiez avec la commande
curl --version. - Navigateur avec panneau de développement : Chrome, Edge, Firefox ou Yandex Browser. Il faudra l'onglet Network (Réseau) et l'onglet Application ou Storage pour voir les cookies.
- Éditeur de texte avec coloration syntaxique : VS Code, Notepad++ ou nano intégré sur le serveur.
- Accès SSH au serveur, si vous modifiez les limites. Les droits de lecture des logs et de redémarrage des services sont obligatoires.
- Python 3 ou Node.js pour lancer le point de terminaison echo. N'importe quelle version actuelle suffira.
- En option : mitmproxy ou l'analyseur intégré d'un navigateur anti-détection, si vous voulez voir le trafic entre le client et le proxy.
Configuration requise
N'importe quelle machine de travail. Pour le serveur echo, 100 Mo de RAM suffisent. La seule véritable exigence : un accès réseau au service vérifié et, si nécessaire, au proxy utilisé.
Quoi télécharger et configurer
- Assurez-vous que curl fonctionne : exécutez
curl -sI https://example.com. Vous devez voir les lignes d'en-têtes de réponse, commençant parHTTP/2 200ou similaire. - Si vous travaillez via un proxy, préparez son adresse, son port, son login et son mot de passe. Vérifiez la connexion de base avec la commande
curl -x http://login:password@host:port -sI https://example.com. Si vous avez ici une erreur 407 ou que la connexion ne s'établit pas du tout, revenez à l'article sur les codes de la couche proxy : notre sujet ne commence qu'après un tunnel réussi. - Sur le serveur, trouvez le fichier de configuration principal : pour nginx, c'est généralement
/etc/nginx/nginx.confet le dossier/etc/nginx/conf.d/, pour Apache/etc/apache2/apache2.confou/etc/httpd/conf/httpd.conf. - Trouvez les logs :
/var/log/nginx/error.log,/var/log/nginx/access.log,/var/log/apache2/error.log. Assurez-vous de pouvoir les lire avec la commandetail -n 50.
Sauvegardes
Avant toute modification de configuration, faites une copie. Cela prend quelques secondes et en sauve des heures.
- Exécutez
sudo cp /etc/nginx/nginx.conf /etc/nginx/nginx.conf.bak-2026. - Pour le dossier des sites :
sudo cp -r /etc/nginx/conf.d /etc/nginx/conf.d.bak-2026. - Pour Apache de même :
sudo cp /etc/apache2/apache2.conf /etc/apache2/apache2.conf.bak-2026. - Notez les valeurs actuelles des limites dans un fichier de notes séparé, pour savoir d'où vous partez.
Attention : ne modifiez jamais une configuration de production sans vérification préalable de la syntaxe. Pour nginx, c'est sudo nginx -t, pour Apache sudo apachectl configtest. Une erreur dans une seule ligne lors du redémarrage laissera le service à terre.
Notions de base
Avant de traquer le problème, mettons-nous d'accord sur les termes. Il n'y a rien de compliqué ici, mais la confusion dans les mots mène souvent le diagnostic dans la mauvaise direction.
Que sont les en-têtes de requête
Toute requête HTTP se compose d'une ligne de départ (méthode, chemin, version du protocole), d'un bloc d'en-têtes et d'un corps optionnel. Les en-têtes sont des paires de la forme Nom: valeur. Le navigateur les ajoute automatiquement : Host, User-Agent, Accept, Accept-Language, Referer, Authorization et, bien sûr, Cookie. Les applications ajoutent les leurs : jetons, identifiants de traçage, marqueurs d'expérience.
Pourquoi les cookies sont le coupable le plus fréquent
L'en-tête Cookie est constitué de tous les cookies correspondant au domaine et au chemin de la requête. Chaque système d'analyse, chaque widget de chat, chaque réseau publicitaire en ajoute quelques-uns. La valeur d'un cookie peut atteindre 4 Ko, et il y a des dizaines de ces cookies sur un domaine. De plus, le navigateur les envoie avec toutes les requêtes, y compris les images et les polices. En conséquence, l'en-tête Cookie dépasse facilement 8-16 Ko, et ce sont exactement ces seuils qui sont définis par défaut sur la plupart des serveurs.
Code 431
431 Request Header Fields Too Large est un code standard décrit dans la spécification HTTP. Le serveur indique : les en-têtes sont trop volumineux, soit l'un d'eux, soit tous ensemble. Le code est renvoyé par Node.js, Go, Envoy, certains CDN et frameworks modernes. La réponse 431 est correcte selon le protocole et bien visible dans les logs, c'est donc la variante la plus pratique pour le diagnostic.
Code 494
494 Request Header Too Large est un code interne non standard de nginx. Nginx l'utilise dans son code lorsque l'en-tête ne rentre pas dans les tampons définis par la directive large_client_header_buffers. Dans ce cas, le client reçoit par défaut un 400 avec le corps Request Header Or Cookie Too Large. Voir le chiffre 494 lui-même est possible dans deux cas : si l'administrateur a explicitement décrit error_page 494, ou si vous lisez les variables internes et les logs de nginx. Donc si un utilisateur se plaint d'une page blanche avec l'inscription 400 et les mots sur les cookies, sachez : c'est le même 494.
Coupure silencieuse
Le scénario le plus désagréable. Un nœud intermédiaire ne rejette pas la requête, mais coupe l'en-tête selon la taille de son tampon ou rejette une partie des en-têtes entièrement. L'application reçoit des données incomplètes. Les symptômes sont variés : l'utilisateur est soudainement déconnecté, le panier est perdu, le jeton n'est pas lu, l'en-tête avec l'identifiant de région disparaît. Il n'y a pas de code d'erreur, tout est vert dans les logs du serveur web. Un tel comportement se rencontre dans les proxies maison sur des tampons fixes, dans les vieilles passerelles d'entreprise, dans certains WAF en mode traitement doux, dans les bibliothèques clientes qui fragmentent ou tronquent les valeurs longues, ainsi que dans le navigateur lui-même, qui ignore silencieusement les Set-Cookie de plus de 4096 octets.
Où se trouvent les limites
Imaginez la chaîne : navigateur ou script, puis votre proxy sortant (par exemple mobile), puis CDN ou WAF, puis équilibreur de charge, puis serveur web, puis serveur d'application. Chaque maillon a sa propre limite et son propre comportement en cas de dépassement. La tâche du diagnostic est de trouver le maillon le plus étroit. C'est pourquoi il ne suffit souvent pas d'augmenter la limite dans nginx : derrière lui se trouve Node.js avec son propre seuil de 16 Ko.
Frontière avec l'erreur 502 upstream sent too big header
Un cas particulier à la jonction de deux sujets. Si nginx écrit dans error.log la phrase upstream sent too big header while reading response header from upstream et renvoie 502, alors le problème n'est ni dans le tunnel ni dans la chute de l'upstream, mais dans les en-têtes de réponse de l'application qui ne rentrent pas dans proxy_buffer_size. Formellement, c'est un 502, mais cela se soigne avec les paramètres de tampons dont nous parlons ici. Retenez ce marqueur : il vous aidera à ne pas chercher le problème dans la couche proxy.
Étape 1 : Reproduire le problème et consigner les symptômes
Objectif de l'étape : obtenir un scénario stable dans lequel l'erreur se produit, et noter les signes exacts : code, texte de réponse, en-tête Server et heure.
- Ouvrez la page problématique dans le navigateur. Appuyez sur F12, allez dans l'onglet Network (Réseau).
- Cochez Preserve log (Conserver le journal) pour que les entrées ne disparaissent pas lors des navigations.
- Rechargez la page avec F5. Trouvez la requête colorée en rouge, ou la requête avec le statut 400, 431 ou 494. Cliquez dessus.
- Dans l'onglet Headers, notez : le code de statut, la valeur de l'en-tête
Serverdans la réponse (nginx, cloudflare, AkamaiGHost, gunicorn), la valeur deVias'il y en a, et tous les en-têtes avec le préfixeX-ouCF-. - Allez dans l'onglet Response et copiez le corps de la réponse. La phrase Request Header Or Cookie Too Large indique nginx. La phrase Request Header Fields Too Large sans le mot Cookie est typique de Node.js. La phrase Bad Request - Request Too Long est caractéristique d'IIS.
- Faites défiler jusqu'au bloc Request Headers. Estimez la longueur de la ligne
Cookie: si elle occupe plusieurs écrans, c'est déjà un indice. - Ouvrez une fenêtre en mode navigation privée et répétez la requête. Si dans un profil vierge il n'y a pas d'erreur, ce sont les cookies accumulés d'un utilisateur spécifique qui sont en cause.
Si le problème se reproduit dans un script et non dans le navigateur, notez les mêmes données à partir de la réponse de la bibliothèque : statut, corps, en-têtes. En Python requests, c'est response.status_code, response.text et response.headers.
Conseil : exportez toutes les requêtes dans un fichier HAR en cliquant avec le bouton droit sur la liste des requêtes et en choisissant Save all as HAR with content. Ce fichier pourra être ouvert plus tard ou transmis à un collègue, et il conservera les tailles exactes des en-têtes.
Vérification : vous devez avoir une note avec quatre points : code de statut, texte du corps de réponse, valeur de l'en-tête Server et résultat du test en navigation privée. Si le résultat en navigation privée diffère, vous connaissez déjà la cause à 70 %.
Problèmes possibles
- L'erreur ne se manifeste pas toujours. Cela signifie que la taille du cookie fluctue autour du seuil : par exemple, après avoir visité une certaine section, un cookie supplémentaire est ajouté. Notez après quelles actions l'erreur apparaît.
- Pas de requête rouge, mais la page ne fonctionne pas correctement. C'est un signe de coupure silencieuse. Passez à l'étape 4 immédiatement après la mesure.
Étape 2 : Mesurer la taille réelle des en-têtes et des cookies
Objectif de l'étape : obtenir des chiffres exacts en octets : taille totale du bloc d'en-têtes, taille de l'en-tête Cookie, taille de chaque cookie individuel.
Mesure dans le navigateur
- Dans le panneau de développement, ouvrez l'onglet Console (Console).
- Saisissez
document.cookie.lengthet appuyez sur Entrée. Vous verrez un nombre : c'est la longueur en caractères de tous les cookies accessibles aux scripts, sans le flag HttpOnly. L'en-tête réel sera plus grand, car les cookies HttpOnly n'y sont pas inclus. - Saisissez
document.cookie.split('; ').map(c => [c.split('=')[0], c.length]).sort((a, b) => b[1] - a[1]). La console affichera un tableau de paires nom-longueur, trié par ordre décroissant. Les cookies les plus lourds seront en haut. - Allez dans l'onglet Application (dans Firefox Storage), dépliez Cookies, sélectionnez le domaine. Ici, tous les cookies sont visibles, y compris HttpOnly, avec une colonne Size. Cliquez sur l'en-tête de colonne pour trier par taille.
- Additionnez les tailles ou regardez simplement la ligne Cookie dans la requête de l'étape 1 : dans Chrome, en survolant l'en-tête, sa longueur s'affiche.
Mesure via curl
Curl permet d'envoyer des en-têtes de n'importe quelle taille et de savoir exactement à partir de quel volume le serveur commence à refuser. Générons un cookie de longueur contrôlée.
- Créez une chaîne de 8000 caractères. Sous Linux et macOS :
BIG=$(head -c 8000 /dev/zero | tr '\0' 'a'). Si le shell râle sur l'échappement, utilisez la varianteBIG=$(python3 -c "print('a'*8000)"). - Envoyez la requête :
curl -s -o /dev/null -w '%{http_code}' -H "Cookie: test=$BIG" https://votre-site.fr/. Seul le code de réponse s'affichera à l'écran. - Faites varier la taille : 4000, 8000, 12000, 16000, 32000, 64000. Notez à quelle valeur le code passe de 200 à 400 ou 431.
- Si vous travaillez via un proxy, ajoutez
-x http://login:password@host:portet répétez la série. La différence entre les seuils avec et sans proxy montrera s'il y a une limite sur le proxy lui-même.
Exemple de recherche binaire du seuil en une commande 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://votre-site.fr/; echo; doneDans Windows PowerShell, l'équivalent : $big = 'a' * 16000; curl.exe -s -o NUL -w '%{http_code}' -H "Cookie: t=$big" https://votre-site.fr/.
Interprétation des chiffres
- Seuil autour de 8 Ko : typique d'Apache avec les paramètres par défaut, Tomcat, Gunicorn, ainsi que de nginx lorsque l'en-tête ne rentre pas dans un tampon parmi quatre de 8 Ko.
- Seuil autour de 16 Ko : Node.js à partir de la version 13, HAProxy avec le tune.bufsize de base, IIS.
- Seuil autour de 32 Ko : limite totale de certains CDN. Un en-tête individuel y est souvent limité à 16 Ko.
- Seuil autour de 60-64 Ko : Envoy et une partie des équilibreurs cloud.
- Seuil autour de 1 Mo : serveur Go standard.
Conseil : ne mesurez pas seulement Cookie. Répétez la série avec l'en-tête Authorization: Bearer $BIG et avec plusieurs en-têtes plus petits. Certains serveurs limitent séparément la taille d'un champ, séparément leur nombre et séparément le volume total. Nginx, par exemple, ne laissera pas passer par défaut un en-tête de plus de 8 Ko même avec une taille totale modeste, car chaque ligne doit tenir dans un tampon distinct.
Vérification : vos notes doivent contenir le nombre à partir duquel le serveur commence à refuser, et la liste des trois à cinq cookies les plus lourds avec leurs tailles. Si le seuil n'est pas trouvé jusqu'à 64 Ko alors qu'il y a une erreur dans le navigateur, cela signifie que ce n'est pas le serveur qui refuse, mais quelque chose entre le navigateur et le serveur dans votre environnement spécifique. Passez à l'étape suivante.
Étape 3 : Déterminer quelle couche refuse
Objectif de l'étape : nommer précisément le nœud de la chaîne qui renvoie l'erreur ou coupe les données, afin de modifier les paramètres au bon endroit.
Lecture de la signature de réponse
- Exécutez
curl -sv -H "Cookie: t=$BIG" https://votre-site.fr/ 2>&1 | grep -i -E 'server|via|cf-|x-served|x-cache|HTTP/', où BIG dépasse largement le seuil. - Lisez l'en-tête
Server. La valeur nginx avec le corps Request Header Or Cookie Too Large signifie que c'est nginx qui a refusé. La valeur cloudflare signifie que la requête n'a pas atteint votre serveur. Un Server vide et un corps au format JSON indiquent souvent l'application. - Faites attention à la version du protocole dans la première ligne. Si pour les requêtes normales le serveur répond en HTTP/2, mais que l'erreur arrive en HTTP/1.1, c'est le signe que la réponse a été formée par un nœud intermédiaire, et non par le nœud final.
- Comparez les corps des erreurs : la page nginx est laconique et contient son nom en bas ; la page Cloudflare contient un Ray ID ; Node.js renvoie souvent un corps vide avec le statut 431.
Contournement des couches
- Si vous avez l'adresse IP directe du serveur derrière le CDN, répétez la requête avec la clé
--resolve votre-site.fr:443:1.2.3.4. Cela forcera curl à se connecter directement, en conservant le bon Host et SNI. Si en direct la requête passe mais pas via le CDN, la limite est sur le CDN. - Si vous avez accès au serveur, exécutez la requête localement :
curl -s -o /dev/null -w '%{http_code}' -H "Cookie: t=$BIG" -H 'Host: votre-site.fr' http://127.0.0.1:80/. Ainsi, vous excluez tous les nœuds externes. - Ensuite, frappez directement l'application, en contournant nginx :
curl ... http://127.0.0.1:3000/pour Node.js ou le port sur lequel écoute Gunicorn. Si nginx laisse passer mais que l'application répond 431, la limite est dans l'application. - Vérifiez l'influence de votre proxy sortant : une série de requêtes avec
-x, une sans. Pour les requêtes HTTPS via un proxy, la méthode CONNECT est utilisée, et le proxy ne voit pas les en-têtes à l'intérieur du tunnel chiffré, il ne peut donc pas influencer leur taille. Mais pour les requêtes HTTP ordinaires, le proxy analyse les en-têtes lui-même, et une limite propre, voire une coupure, est alors possible.
Lecture des logs sur le serveur
- Exécutez
sudo tail -f /var/log/nginx/error.loget répétez la requête problématique. - La ligne client sent too long header line confirme qu'une ligne d'en-tête individuelle a dépassé le tampon nginx. La ligne client sent too large request indique un dépassement du volume total.
- Pour Apache, dans error.log, cherchez Request header exceeds LimitRequestFieldSize ou Size of a request header field exceeds server limit.
- Pour Node.js, dans les logs de l'application : l'erreur HPE_HEADER_OVERFLOW, c'est un code interne du parseur qui se transforme extérieurement en 431.
- Dans access.log de nginx, regardez le champ avec la taille de la requête. Si vous utilisez le format standard, ajoutez dans log_format la variable
$request_length: elle montrera la taille complète de la requête avec les en-têtes et sera utile pour la surveillance.
Attention : si dans error.log de nginx vous voyez upstream sent too big header, ce n'est pas la requête entrante qui refuse, mais la réponse de votre application, dont les en-têtes ne rentrent pas dans le tampon nginx. Un tel cas ressemble à un 502, mais relève de notre sujet. La cause est généralement un énorme Set-Cookie ou des dizaines d'en-têtes du framework. La solution est à l'étape 6.
Vérification : vous devez dire avec assurance l'un des éléments suivants : c'est le CDN qui refuse ; c'est nginx qui refuse ; c'est Apache qui refuse ; c'est l'application qui refuse ; c'est le proxy de mon côté qui refuse. Si le tableau est ambigu, cela signifie que la limite est dépassée sur plusieurs nœuds à la fois, et il faudra les corriger tous un par un, en répétant à chaque fois le test de l'étape 2.
Étape 4 : Détecter la coupure silencieuse avec un point de terminaison echo
Objectif de l'étape : s'assurer que les en-têtes arrivent à l'application exactement dans l'état où ils ont été envoyés, et attraper le nœud qui les modifie silencieusement.
L'idée est simple. Nous allons lancer un petit serveur qui renvoie dans la réponse tous les en-têtes reçus et leurs tailles. Nous enverrons un en-tête de longueur connue avec une somme de contrôle et comparerons ce qui est arrivé.
Lancement du serveur echo en Python
- Créez un fichier
echo.pyavec le contenu suivant :
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()- Lancez :
python3 echo.py. Le serveur écoute sur le port 8089. - Placez-le là où se trouve votre vraie application, ou redirigez temporairement un location de nginx vers lui :
location /__echo { proxy_pass http://127.0.0.1:8089; }. La requête passera alors par toute la chaîne réelle.
Notez que le HTTPServer Python standard n'a pas de limite stricte sur la longueur des en-têtes, mais limite leur nombre à cent. Pour le test, cela suffit.
Envoi de la requête de contrôle
- Générez une valeur de 12000 caractères, mais pas homogène, avec des marqueurs de position pour voir d'où elle est coupée :
V=$(python3 -c "print(''.join(str(i%10) for i in range(12000)))"). - Calculez le hash de référence :
python3 -c "import hashlib,sys; print(hashlib.sha256(sys.argv[1].encode()).hexdigest()[:12])" "$V". - Envoyez à travers toute la chaîne :
curl -s -H "Cookie: probe=$V" -H "X-Probe-Len: 12000" https://votre-site.fr/__echo. - Comparez dans la réponse le champ len pour Cookie avec le nombre 12006 (le nom probe plus le signe égal plus 12000 caractères) et le hash avec la référence.
- Répétez avec plusieurs en-têtes : ajoutez 30 en-têtes
X-Test-1...X-Test-30et vérifiez le champ _count.
Comment lire le résultat
- La longueur correspond, le hash correspond : il n'y a pas de coupure sur ce chemin.
- La longueur est plus petite, l'en-tête est tronqué : quelqu'un a coupé la queue. Regardez le dernier caractère de la valeur reçue : il indiquera la position de la coupure, souvent une frontière régulière de 4096 ou 8192 octets.
- L'en-tête est complètement absent : le nœud a rejeté le champ qui ne rentrait pas dans le tampon. C'est le comportement de certains WAF et vieilles passerelles.
- _count est inférieur à l'envoi : la limite du nombre d'en-têtes est atteinte. Apache et Gunicorn acceptent par défaut 100 champs, HAProxy 101, et certaines implémentations rejettent silencieusement les excédents.
- La longueur correspond, le hash ne correspond pas : le nœud a modifié le contenu. Cela arrive lors de la normalisation des espaces ou du réencodage ; vérifiez s'il n'y a pas dans la valeur des caractères que le proxy considère comme invalides.
Conseil : si vous travaillez via un proxy mobile ou autre proxy externe, lancez le serveur echo sur un hôte accessible publiquement et faites passer les requêtes via le proxy en HTTP ordinaire sans TLS. C'est précisément dans ce mode que le proxy analyse les en-têtes lui-même et peut montrer ses propres limites. En mode HTTPS via CONNECT, le contenu est opaque pour le proxy, et une coupure à cette couche est physiquement impossible.
Vérification : vous avez un tableau : nœud, octets envoyés, octets reçus, correspondance du hash. Si toutes les lignes correspondent, il n'y a pas de coupure silencieuse, et vos symptômes s'expliquent par les refus explicites des étapes 1 à 3. S'il y a une divergence, vous savez où elle se trouve.
Vérification séparée du navigateur sur Set-Cookie
Le navigateur coupe aussi silencieusement, mais pas la requête, la réponse. Si le serveur envoie un Set-Cookie de plus d'environ 4096 octets, Chrome et Firefox l'ignorent tout simplement, sans aucun avertissement. Vérifiez : dans l'onglet Network, trouvez la réponse avec Set-Cookie, regardez la longueur de la ligne, puis ouvrez l'onglet Application et assurez-vous que le cookie a été enregistré. S'il n'y est pas, divisez la valeur en parties ou déplacez les données côté serveur.
Étape 5 : Réduire le volume des cookies et des en-têtes
Objectif de l'étape : éliminer la racine du problème pour que les requêtes tiennent dans les limites standard et ne dépendent pas de la miséricorde des nœuds intermédiaires.
Augmenter les limites est tentant, mais c'est traiter le symptôme. Chaque kilo-octet de cookie en trop part avec chaque requête de chaque utilisateur, y compris les requêtes pour les images. Commencez par réduire.
Audit des cookies
- Reprenez la liste de l'étape 2, triée par taille.
- Pour chaque cookie, répondez à trois questions : qui le pose, le serveur en a-t-il besoin, en a-t-il besoin sur chaque chemin du site.
- Les cookies des systèmes d'analyse et des pixels publicitaires ne sont presque jamais nécessaires au serveur. Il ne faut pas les supprimer, mais il ne faut pas les envoyer au domaine API.
- Les cookies avec état sérialisé (panier en JSON, paramètres d'interface, historique de navigation) sont candidats à un déplacement vers localStorage ou vers un stockage serveur avec un identifiant court.
Techniques de réduction
- Placez l'API sur un sous-domaine séparé. Les cookies définis sur www.site.fr sans Domain explicite ne sont pas envoyés à api.site.fr. Les cookies marketing lourds resteront sur la vitrine, et l'API ne recevra que la session.
- Définissez l'attribut Path. Un cookie avec
Path=/adminne partira pas dans les requêtes vers/static. Vérifiez que vos frameworks ne posent pas tous les cookies à la racine sans nécessité. - Stockez un identifiant dans le cookie, pas les données. Au lieu d'un JSON de 3 Ko, mettez une clé de 32 caractères et gardez les données dans Redis ou en base. Cela résoudra aussi le problème de falsification du contenu.
- Raccourcissez le JWT. Le jeton dans le cookie ou dans Authorization gonfle à cause des champs superflus dans le payload : liste des rôles, adresse, avatar. Gardez l'identifiant et la durée de vie, le reste se demande par un appel séparé. Un JWT typique doit tenir dans 500-800 octets.
- Supprimez explicitement les cookies obsolètes. Si vous avez renommé un cookie, l'ancien restera chez les utilisateurs jusqu'à expiration. Envoyez un Set-Cookie avec l'ancien nom et Max-Age=0.
- Utilisez un domaine séparé sans cookies pour les statiques. Technique classique : static.site.fr ou un domaine CDN sur lequel aucun cookie n'est posé.
- Vérifiez les doublons. Souvent, le même cookie existe en deux variantes : pour site.fr et pour .site.fr avec un point. Le navigateur enverra les deux.
Pour les scripts et l'automatisation
Si vous gérez de nombreux comptes via des proxies et des navigateurs anti-détection, surveillez les profils. Un profil qui vit six mois accumule les cookies de dizaines de domaines tiers, et les requêtes vers le site cible commencent à être refusées précisément à cause de l'en-tête gonflé. Configurez un nettoyage périodique des cookies de domaines tiers, sans toucher aux cookies d'autorisation du site cible. Dans les bibliothèques comme requests ou httpx, stockez les cookies dans un CookieJar séparé par compte et supprimez une fois par jour les entrées expirées.
Conseil : ajoutez côté client une vérification simple avant la requête : si document.cookie.length dépasse 6000 caractères, envoyez une métrique à votre système d'analyse. Ainsi, vous apprendrez le problème par les premiers utilisateurs, et non par des plaintes massives.
Vérification : répétez la mesure de l'étape 2 sur un profil vierge, parcourez un scénario utilisateur typique (connexion, catalogue, panier, commande) et assurez-vous que la taille totale des en-têtes ne dépasse pas 4 Ko sur l'API et 8 Ko sur la vitrine. C'est une marge confortable par rapport à toutes les limites standard.
Étape 6 : Configurer les limites sur le serveur web, l'équilibreur et l'application
Objectif de l'étape : établir des limites cohérentes sur tous les nœuds que vous contrôlez, afin qu'aucun d'eux ne soit étonnamment plus étroit que ses voisins.
Règle d'or : la limite du nœud externe doit être inférieure ou égale à celle du nœud interne. Sinon, nginx laissera passer 32 Ko, et Node.js derrière refusera avec 431, et vous obtiendrez une erreur venue des profondeurs de la pile, plus difficile à diagnostiquer. Un repère raisonnable pour 2026 : 16 Ko pour tout le bloc d'en-têtes et 8-16 Ko pour un champ individuel. Cela suffit à presque tout le monde, tout en gardant une protection contre les abus.
nginx
- Ouvrez
/etc/nginx/nginx.conf. Trouvez le blochttp { ... }. - Ajoutez ou modifiez trois directives :
http {
client_header_buffer_size 4k;
large_client_header_buffers 4 16k;
proxy_buffer_size 16k;
proxy_buffers 8 16k;
}client_header_buffer_sizeest le premier petit tampon pour les requêtes typiques. La valeur 1k par défaut force nginx à basculer presque toujours sur les grands tampons, ce qui n'est pas grave, mais 4k réduit les allocations inutiles.large_client_header_buffers 4 16ksignifie : jusqu'à quatre tampons de 16 Ko. Chaque ligne d'en-tête doit tenir entièrement dans un tampon, et tout le bloc dans la somme des tampons. Donc, un cookie ou Authorization individuel ne peut pas dépasser 16 Ko, et tous les en-têtes ensemble 64 Ko.proxy_buffer_sizeest responsable de la première portion de la réponse de l'upstream, y compris ses en-têtes. C'est son augmentation qui élimine le 502 avec la phrase upstream sent too big header. La valeur deproxy_buffersdoit être au moins égale à proxy_buffer_size.- Si vous voulez que le client voie une réponse sensée au lieu de la page 400 standard, ajoutez dans server :
error_page 494 =431 /431.html;et placez le fichier 431.html avec un texte clair et un conseil de nettoyer les cookies. Ainsi, vous transformez le 494 non standard en 431 standard. - Vérifiez la syntaxe :
sudo nginx -t. Vous devez voir syntax is ok et test is successful. - Appliquez sans interrompre les connexions :
sudo nginx -s reload.
N'oubliez pas que large_client_header_buffers peut aussi être défini dans le contexte server, mais pour HTTP/2, la valeur du contexte http s'applique, donc modifiez-la là. Pour HTTP/2, il existe en plus une directive http2_max_header_size dans les anciennes versions ; dans les versions actuelles, elle a été supprimée, et large_client_header_buffers suffit.
Apache
- Ouvrez la configuration principale et ajoutez au niveau du serveur ou du VirtualHost :
LimitRequestFieldSize 16384
LimitRequestFields 150
LimitRequestLine 16384LimitRequestFieldSizelimite un champ, par défaut 8190 octets.LimitRequestFieldslimite le nombre de champs, par défaut 100.LimitRequestLinelimite la ligne de départ, ce qui est important pour les URL longs avec paramètres.- Si Apache fonctionne comme proxy inverse via mod_proxy_http, ajoutez
ProxyIOBufferSize 32768pour les réponses avec de grands en-têtes. - Vérifiez :
sudo apachectl configtest, puissudo systemctl reload apache2.
Node.js
- La limite est définie au lancement du processus par le flag
--max-http-header-size. La valeur en octets :node --max-http-header-size=32768 server.js. - Si vous utilisez PM2 ou systemd, indiquez le flag dans le champ node_args ou dans la variable d'environnement
NODE_OPTIONS=--max-http-header-size=32768. - Alternative dans le code :
http.createServer({ maxHeaderSize: 32768 }, app). Ce paramètre est pris en charge dans les versions actuelles de Node et permet de définir la limite sans redémarrer avec de nouveaux flags. - Vérifiez après redémarrage avec une série de curl directement sur le port Node : le seuil doit se décaler.
Tomcat et Spring Boot
- Dans
server.xml, sur l'élément Connector, ajoutez l'attributmaxHttpHeaderSize="16384". Par défaut, il est à 8192. - Dans Spring Boot, une ligne dans application.properties suffit :
server.max-http-request-header-size=16KB. L'ancien nom de propriété server.max-http-header-size fonctionne aussi dans certaines versions, mais est marqué comme obsolète. - Redémarrez l'application et vérifiez le seuil.
Gunicorn et Uvicorn
- Pour Gunicorn, ajoutez dans la configuration ou la ligne de commande :
--limit-request-field_size 16380 --limit-request-fields 150 --limit-request-line 8190. Faites attention à l'orthographe field_size avec un underscore : c'est un artefact historique, et avec un tiret le paramètre ne fonctionnera pas. - La valeur 0 pour limit-request-field_size supprime complètement la limite, mais ne faites pas cela sur des serveurs publics.
- Uvicorn limite la taille des en-têtes via le parseur h11 et autorise par défaut des valeurs assez grandes ; le plus souvent, le goulot d'étranglement se trouve avant lui, dans nginx.
HAProxy
- Dans la section global :
tune.bufsize 32768ettune.http.maxhdr 150. - La requête entière avec tous les en-têtes doit tenir dans un tampon de taille tune.bufsize moins la réserve tune.maxrewrite. Avec 16384 par défaut, le volume réel disponible est d'environ 15 Ko.
- Vérifiez
haproxy -c -f /etc/haproxy/haproxy.cfget redémarrez. Notez que l'augmentation de bufsize accroît la consommation de mémoire par connexion.
IIS
- Les limites se trouvent dans le registre à la branche HTTP.sys : les paramètres MaxFieldLength et MaxRequestBytes dans la clé HKLM SYSTEM CurrentControlSet Services HTTP Parameters. Les valeurs par défaut sont 16384 octets pour les deux, maximum 65534.
- Après modification, un redémarrage du service HTTP ou du serveur est nécessaire.
- Vérifiez en plus
maxAllowedContentLengthetmaxQueryStringdans requestFiltering, si le problème concerne les URL longs.
CDN et WAF
Chez la plupart des CDN cloud, les limites sont fixes sur les offres de base et ne changent que sur les offres entreprise. Si le seuil de l'étape 3 bute sur le CDN, le seul chemin universel est la réduction des cookies de l'étape 5. Vérifiez en plus si le WAF n'est pas configuré en mode où les gros en-têtes ne sont pas bloqués mais découpés : un tel mode crée précisément cette coupure silencieuse, et il vaut mieux le basculer en refus explicite avec code.
Attention : ne mettez pas des limites en mégaoctets pour être tranquille. Chaque kilo-octet de tampon se multiplie par le nombre de connexions simultanées, et un attaquant peut délibérément envoyer des en-têtes géants pour épuiser la mémoire. Gardez une marge raisonnable de deux à trois fois le maximum réel, et pas plus.
Vérification : répétez la série curl de l'étape 2 pour chaque nœud séparément (directement dans l'application, via nginx, de l'extérieur via le CDN). Les seuils doivent soit coïncider, soit décroître de l'interne vers l'externe. Assurez-vous qu'en cas de dépassement, chaque nœud renvoie un code compréhensible, et ne coupe pas la connexion.
Étape 7 : Rendre les refus explicites et configurer la surveillance
Objectif de l'étape : exclure la coupure silencieuse à l'avenir et apprendre la croissance des en-têtes avant qu'ils ne butent sur la limite.
Réponses explicites au lieu du silence
- Assurez-vous que chaque nœud que vous contrôlez renvoie 431 ou au moins 400 avec un texte en cas de dépassement. Dans nginx, c'est déjà fait à l'étape 6 via error_page 494.
- Si vous avez un proxy ou une passerelle maison sur un tampon fixe, ajoutez une vérification : si l'en-tête ne rentre pas, répondez 431 et fermez la connexion. Ne transmettez jamais plus loin une valeur tronquée.
- Dans l'application, ajoutez une validation des en-têtes critiques. Par exemple, si le JWT ne se parse pas ou si le cookie de session est plus court que la longueur attendue, loguez-le comme un événement séparé avec la mention possible truncation. C'est un détecteur de problèmes peu coûteux sur n'importe quel nœud externe.
Journalisation des tailles
- Dans nginx, étendez le format de log. Dans le bloc 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; }- Une variante simple et fiable sans map : loguez seulement
$request_length. Cette variable suffit pour voir la croissance. - Une fois par jour, exécutez
awksur access.log et trouvez le maximum et le 99e percentile de req_len. Si le 99e percentile dépasse la moitié de la limite, il est temps de nettoyer les cookies. - Pour Apache, utilisez dans LogFormat la variable
%Ide mod_logio : elle montre les octets entrants avec les en-têtes.
Alertes
- Mettez en place une métrique du nombre de réponses 431 et 400 avec un corps sur les cookies. Dans Prometheus avec nginx-exporter, ce sont les statuts de access.log ; dans les panneaux de surveillance cloud, il y a généralement une répartition par codes.
- Configurez un seuil : plus de 10 telles réponses en 5 minutes est un signal. Une erreur 431 massive signifie presque toujours que quelqu'un a déployé un nouveau cookie lourd.
- Ajoutez une vérification synthétique : une fois par heure, un script envoie une requête avec un en-tête à 90 % de la limite et vérifie qu'elle passe, et avec un en-tête à 110 %, vérifie qu'un 431 est bien renvoyé. Ainsi, vous attraperez à la fois un durcissement accidentel de la limite et son retrait accidentel.
Conseil : gardez le point de terminaison echo de l'étape 4 en permanence, en le fermant par IP ou par une simple autorisation. Il sera utile à chaque changement d'infrastructure : vous avez ajouté un WAF, changé d'équilibreur, connecté un nouveau pool de proxies, et en une minute vous pouvez vous assurer que les en-têtes arrivent entiers.
Vérification : envoyez une requête volontairement volumineuse et assurez-vous qu'elle est entrée dans le log avec la bonne taille, que le compteur 431 a augmenté et que l'alerte s'est déclenchée lors du dépassement du seuil. Après cela, remettez les seuils aux valeurs de travail.
Vérification du résultat
Parcourez la liste de contrôle. Chaque point doit être satisfait, sinon revenez à l'étape correspondante.
Liste de contrôle
- La page problématique de l'étape 1 s'ouvre sans erreur dans le profil principal du navigateur.
- La taille totale des en-têtes d'une requête typique ne dépasse pas 8 Ko, et sur le domaine API 4 Ko.
- Aucun cookie ne dépasse 2 Ko, les cookies tiers les plus lourds ne sont pas envoyés à l'API.
- Le seuil de refus sur chaque nœud est connu et noté ; les limites décroissent ou coïncident de l'application vers le bord externe.
- En cas de dépassement de la limite, le client reçoit un code 431 ou 400 avec un texte, et non une coupure de connexion ni une requête silencieusement tronquée.
- Le point de terminaison echo montre la correspondance de la longueur et du hash lors de l'envoi à travers toute la chaîne, y compris via vos proxies.
- Dans access.log, la taille de la requête est présente, une alerte sur la croissance des 431 est configurée.
- Les sauvegardes des configurations sont à portée de main, et vous connaissez la commande de restauration.
Comment tester de bout en bout
- Effacez les cookies du domaine de test et parcourez le scénario utilisateur de la connexion à l'action clé. Il ne doit pas y avoir d'erreur.
- Lancez la boucle curl de l'étape 2 depuis l'extérieur. Notez le seuil ; il doit correspondre à vos nouveaux paramètres.
- Envoyez une requête de contrôle au point de terminaison echo via chaque chemin utilisé : directement, via le CDN, via le pool de proxies.
- Envoyez délibérément un en-tête deux fois plus grand que la limite et assurez-vous de recevoir un 431 avec un corps compréhensible.
- Vérifiez que les réponses de l'application avec de grands Set-Cookie ne provoquent pas de 502 chez nginx.
Indicateurs de succès
La part des réponses 431 et 400 avec un texte sur les en-têtes tend vers zéro dans le trafic normal. Le 99e percentile de la taille des requêtes est inférieur à la moitié de la limite la plus étroite. Les déconnexions sans raison et les sessions perdues n'apparaissent plus dans les demandes des utilisateurs.
Erreurs typiques et solutions
On a augmenté la limite dans nginx, mais le 431 persiste
Cause : derrière nginx se trouve Node.js ou Tomcat avec sa propre limite de 8-16 Ko, et c'est maintenant lui qui refuse. Solution : vérifiez le seuil directement sur le port de l'application depuis l'étape 3 et augmentez-le avec le flag --max-http-header-size ou maxHttpHeaderSize. Ensuite, assurez-vous que la limite nginx n'est pas supérieure à celle de l'application.
On a mis large_client_header_buffers dans le bloc server, mais rien n'a changé
Cause : pour HTTP/2, nginx utilise la valeur du contexte http, et la directive ne s'hérite pas comme on l'attend si elle est définie dans plusieurs server pour une même adresse. Solution : déplacez la directive dans le bloc http et rechargez la configuration.
L'erreur n'apparaît que chez une partie des utilisateurs
Cause : la taille du cookie dépend de l'historique d'un utilisateur spécifique : sections visitées, expériences activées, anciens cookies des versions précédentes du site. Solution : collectez des statistiques de tailles via $request_length, trouvez quels cookies grossissent, et supprimez explicitement les obsolètes via Set-Cookie avec Max-Age=0.
Après le nettoyage des cookies tout fonctionne, mais une semaine plus tard ça casse à nouveau
Cause : la source de croissance n'est pas éliminée : par exemple, un script d'analyse ajoute des données à un cookie à chaque visite. Solution : trouvez le cookie qui grossit via le tri par taille à différents jours, et déplacez son contenu vers localStorage ou limitez-le du côté du fournisseur du script.
Nginx renvoie 502 alors que l'application est vivante
Cause : dans error.log, la phrase upstream sent too big header : les en-têtes de réponse de l'application ne rentrent pas dans proxy_buffer_size. Le coupable est généralement un énorme Set-Cookie ou de nombreux en-têtes de débogage. Solution : augmentez proxy_buffer_size à 16k et proxy_buffers à 8 16k, et dans l'application, réduisez les en-têtes de réponse.
Via le proxy, une requête HTTP perd une partie des en-têtes, mais en HTTPS tout passe
Cause : pour HTTP, le proxy analyse lui-même les en-têtes et bute sur son tampon, alors que pour HTTPS via CONNECT, le contenu est opaque et passe intact. Solution : passez au HTTPS pour la ressource cible ou réduisez les en-têtes. Si le proxy est le vôtre, augmentez sa limite et configurez un refus explicite au lieu d'une coupure.
Le navigateur ne conserve pas le cookie après la réponse du serveur
Cause : la ligne Set-Cookie dépasse 4096 octets ou le nombre total de cookies sur le domaine a dépassé la limite du navigateur (environ 180 dans Chrome), et il a silencieusement rejeté le nouveau ou évincé l'ancien. Solution : ne stockez dans le cookie qu'un identifiant, et gardez les données sur le serveur ; ne créez pas des dizaines de petits cookies, fusionnez-les.
Gunicorn ignore le paramètre de limite
Cause : le paramètre est écrit avec un tiret comme limit-request-field-size, alors que le bon nom contient un underscore : limit-request-field_size. Solution : corrigez l'orthographe et redémarrez les workers.
Possibilités supplémentaires
Différentes limites pour différents chemins
Il n'est pas obligatoire d'augmenter la limite pour tout le site. Si des en-têtes lourds ne sont nécessaires que sur un chemin, par exemple lors du téléchargement de fichiers avec de longues métadonnées, dans nginx on peut isoler ce chemin dans un server séparé sur un nom ou un port distinct avec des large_client_header_buffers augmentés, et laisser le site principal strict. Ainsi, vous conservez la protection contre les abus là où elle est plus importante.
Compression des en-têtes en HTTP/2 et HTTP/3
Les protocoles HTTP/2 et HTTP/3 compressent les en-têtes avec les algorithmes HPACK et QPACK. Sur le réseau, les cookies répétitifs passent de manière compacte, mais sur le serveur ils sont décompressés à leur taille complète, et les limites s'appliquent précisément aux données décompressées. Donc, activer HTTP/2 économise du trafic, mais ne sauve pas du 431. Le paramètre SETTINGS_MAX_HEADER_LIST_SIZE, que le serveur annonce au client, définit la borne supérieure de la liste décompressée ; dans nginx, il est calculé automatiquement à partir de large_client_header_buffers.
Cookies fragmentés
Certaines bibliothèques d'autorisation savent diviser une valeur longue en plusieurs cookies avec les suffixes .0, .1, .2 et les rassembler côté serveur. Cela résout le problème de la limite du navigateur sur un cookie de 4 Ko, mais ne réduit pas la taille totale de l'en-tête Cookie. Utilisez cette technique uniquement comme mesure temporaire lors de la transition vers le stockage serveur des sessions.
Sessions sur le serveur au lieu de conteneurs de cookies
La solution architecturale la plus fiable : dans le cookie, il ne reste qu'un identifiant aléatoire de 32 à 64 caractères, et tout l'état est dans Redis avec un TTL. L'en-tête Cookie dépasse alors rarement 200 octets, et tout le sujet des limites cesse d'être pertinent. La migration prend d'un jour pour une petite application à plusieurs semaines pour une grande, mais elle est rentabilisée par la réduction du trafic et la simplification de la sécurité.
Vérification automatique en CI
Ajoutez au pipeline un test : lancez l'application, envoyez une requête avec des en-têtes à 90 % de la limite déclarée et vérifiez le code 200, puis à 120 % et vérifiez le code 431. Le test prend quelques secondes et ne laissera pas réduire accidentellement la limite lors d'une mise à jour du framework, quand les valeurs par défaut changent.
Travail avec un pool de proxies
Si vous utilisez plusieurs serveurs proxy ou un pool mobile avec rotation, faites passer la requête de contrôle vers le point de terminaison echo par chaque sortie en HTTP et en HTTPS. Conservez les résultats dans un tableau. Ainsi, vous identifierez les sorties au comportement non standard et pourrez soit les exclure, soit n'envoyer à travers elles que du trafic HTTPS, où la coupure est impossible.
FAQ
Quelle est la différence entre 431 et 494, si au fond les deux concernent des en-têtes trop volumineux ?
431 est un code standard de la spécification HTTP, compris par tous les clients et outils de surveillance. 494 est un code interne de nginx, qui par défaut se transforme extérieurement en 400 avec le texte Request Header Or Cookie Too Large. Pour l'utilisateur, il n'y a pas de différence, mais pour le diagnostic, un 494 dans les logs ou dans error_page indique sans ambiguïté nginx comme source.
Peut-on simplement mettre une très grande limite et oublier ?
Techniquement oui, mais vous augmenterez la consommation de mémoire par connexion et faciliterez les attaques avec des en-têtes géants. De plus, les limites des CDN et des navigateurs ne sont pas sous votre contrôle, et le problème se déplacera simplement là-bas. L'ordre correct : d'abord réduire les cookies, ensuite fixer une limite modérée avec marge.
Pourquoi tout fonctionne en navigation privée, mais il y a une erreur en mode normal ?
En navigation privée, il n'y a pas de cookies accumulés. C'est un signe presque à cent pour cent que la cause est dans la taille de l'en-tête Cookie d'un utilisateur spécifique. Effacer les cookies du domaine résoudra le problème ponctuellement, et l'étape 5 le résoudra définitivement.
Comment mesurer la taille des en-têtes si je n'ai pas accès au serveur ?
Utilisez le panneau de développement : l'onglet Application montre la taille de chaque cookie, et la commande document.cookie.length dans la console donne la longueur totale des cookies accessibles aux scripts. Pour le seuil exact de refus, envoyez curl avec un en-tête artificiellement volumineux et regardez le code de réponse.
Mon proxy peut-il couper les en-têtes dans les requêtes HTTPS ?
Non. En HTTPS via un proxy, la méthode CONNECT est utilisée, et le proxy transmet un flux d'octets chiffré sans en voir le contenu. Il ne peut physiquement pas couper ou modifier les en-têtes à l'intérieur. En revanche, pour les requêtes HTTP ordinaires, le proxy analyse les en-têtes lui-même, et là, limites et coupures sont possibles.
Comment savoir qu'un en-tête est coupé s'il n'y a pas d'erreur ?
Lancez le point de terminaison echo de l'étape 4, envoyez un en-tête de longueur connue avec des marqueurs de position et comparez la longueur et le hash de la valeur reçue avec l'envoi. La divergence montrera à la fois le fait de la coupure et la position de la coupe.
Nginx laisse passer, mais l'application Node.js répond 431. Que faire ?
Augmenter la limite Node.js avec le flag --max-http-header-size ou le paramètre maxHeaderSize dans createServer, puis aligner la limite nginx à la même valeur ou moins, pour que le refus se produise sur la couche externe avec une page compréhensible.
Qu'est-il plus important de limiter : la taille d'un en-tête ou la taille totale ?
Les deux. La taille totale protège la mémoire, et la limite sur un champ protège les parseurs. Chez nginx, les deux limites découlent de large_client_header_buffers : la taille du tampon est la limite sur la ligne, et le nombre de tampons multiplié par la taille est la limite totale.
Faut-il intercepter le 431 côté client et nettoyer automatiquement les cookies ?
Pour votre propre site, c'est une excellente technique : à la réception d'un 431 ou 400 avec le bon texte, le frontend supprime les cookies manifestement non essentiels et répète la requête. Ne supprimez pas les cookies d'autorisation sans le consentement de l'utilisateur et loguez toujours ces événements pour éliminer la cause racine.
Comment s'assurer que la nouvelle version du framework n'a pas changé la limite par défaut ?
Gardez la vérification synthétique de l'étape 7 et le test en CI de la section des possibilités supplémentaires. Les deux envoient des requêtes à la frontière de la limite et montreront immédiatement si le seuil a bougé dans un sens ou dans l'autre.
Conclusion
Résumons ce que vous avez fait. Vous avez appris à reproduire l'erreur et à distinguer 431, 494 et son visage public de 400 par la signature de réponse. Vous avez mesuré la taille réelle des en-têtes et des cookies et trouvé le seuil de refus par recherche binaire via curl. Vous avez déterminé quel nœud de la chaîne est responsable du refus, et séparé ce problème des codes de la couche proxy comme 407, 502 et 504, en gardant le marqueur utile upstream sent too big header. À l'aide du point de terminaison echo, vous avez attrapé ou exclu la coupure silencieuse qui ne laisse aucune trace dans les logs. Ensuite, vous avez réduit les cookies, déplacé l'API sur un domaine propre, aligné les limites sur nginx, Apache, Node.js, Tomcat, Gunicorn et HAProxy, rendu les refus explicites et connecté la surveillance.
Que faire ensuite. Dans la semaine à venir, surveillez la métrique de taille des requêtes et le compteur 431 : ils montreront s'il reste une source de croissance des cookies. Établissez une règle pour l'équipe : tout nouveau cookie passe en revue avec des questions sur sa taille, son domaine et son chemin. Si le projet utilise des sessions dans un cookie sous forme d'état sérialisé, planifiez une migration vers un stockage serveur avec un identifiant court.
Vers quoi évoluer. Le niveau suivant est la compréhension approfondie de la compression des en-têtes en HTTP/2 et HTTP/3, le réglage fin des tampons sous charge et la construction d'une couche d'observabilité transparente où la taille de chaque requête est visible dans la trace. Il est également utile d'étudier comment se comportent les limites avec différents types de proxies et d'équilibreurs, et de constituer votre propre tableau de seuils pour l'infrastructure avec laquelle vous travaillez. Les outils rassemblés dans ce guide, y compris le point de terminaison echo et la boucle curl, resteront avec vous et vous feront gagner des heures à chaque prochain refus étrange. Vous avez réussi, et maintenant cette catégorie de problèmes a cessé d'être une énigme.