Aller au contenu
  • Accueil
  • Infrastructure
  • Datacenter
  • Services
    Nos services
    InfogéranceCloudHébergementIABare MetalHousingTransit IP
  • Blog
Contactez-nous
  1. Accueil
  2. /
  3. Blog
  4. /
  5. Erreur 413 Request Entity Too Large : quelle couche, quelle limite

Web
Administration

Erreur 413 Request Entity Too Large : quelle couche, quelle limite

17 novembre 2026

11 min de lecture

Sommaire
Savoir qui répond avant de toucher à une limite
CDN : un plafond lié à l'offre
Proxy : client_max_body_size et la location qui ne s'applique pas
Application : le 413 absent du journal d'erreurs
PHP : pas de 413, un 200 sans fichier
Aligner les couches pour garder un 413 lisible
Sources
$ curl -sS -o /dev/null -w "code=%{http_code} sent=%{size_upload} total=%{time_total}\n" \
    --data-binary @/tmp/2m http://blog-413-origin/upload.php
code=413 sent=0 total=0.000998

Sur un corps de 2 Mio, aucun octet n'est parti et le refus arrive en une milliseconde. curl a annoncé Content-Length: 2097152 et Expect: 100-continue, et nginx a répondu sans attendre le corps, avec sa limite par défaut.

Une erreur 413 signifie qu'un composant sur le trajet de la requête a refusé son corps parce qu'il dépasse sa limite. Ce composant peut être le CDN, le proxy (nginx et son client_max_body_size, 1 Mio par défaut), un WAF ou l'application. Les limites PHP upload_max_filesize et post_max_size relèvent d'un autre mécanisme : php.net ne décrit aucun 413 pour elles, et notre banc rend un 200 avec un upload perdu. Un upload WordPress qui tombe en 413 ne se corrige donc pas d'abord dans php.ini. On identifie la couche qui répond, on relève sa limite, puis on aligne les autres.

Les sorties viennent d'un banc en conteneurs du 2 novembre 2026 : nginx 1.30.6, PHP-FPM 8.5.12, curl 8.22.0, et un second nginx devant, pour jouer la couche de tête. Aucun CDN réel n'est passé au banc.

Savoir qui répond avant de toucher à une limite

Le texte du statut ne renseigne pas. La RFC 9110 nomme ce code Content Too Large et nginx envoie toujours Request Entity Too Large. L'en-tête Server ne suffit pas non plus dès que deux nginx se suivent : notre tête et notre origine rendent la même page de 183 octets, signée nginx/1.30.6.

Trois mesures tranchent, à commencer par les journaux. nginx écrit une ligne explicite quand il refuse, ici abrégée :

[error] 54#54: *1 client intended to send too large body: 2097152 bytes, client: 172.19.0.2

Ce que chaque couche a journalisé selon celle qui refuse :

Qui refusenginx de têtenginx d'originePHP-FPM
nginx de têteaccès 413, erreur too large bodyaucune ligneaucune ligne
nginx d'origineaccès 413, pas d'erreur de tailleaccès 413, erreur too large bodyaucune ligne
applicationaccès 413, pas d'erreur de tailleaccès 413, pas d'erreur de tailleaccès 413

La lecture part de l'extérieur : la première couche qui porte too large body a refusé. Si aucune ne le porte et que le 413 descend jusqu'à FPM, l'application a parlé. Si le journal d'accès de votre premier serveur n'a aucune ligne pour la requête, le refus s'est produit plus haut : au banc, un nginx qui refuse laisse toujours sa ligne d'accès, et le guide de Netdata signale le même indice.

Vient ensuite un en-tête par couche. add_header ne s'applique qu'aux codes de succès et de redirection, sauf avec le paramètre always, nécessaire pour marquer un 413. Avec add_header X-Couche edge always; sur la tête et la même directive sur l'origine, en-têtes abrégés :

# 9 Mio, plafond de 5 Mio sur la tête
HTTP/1.1 413 Request Entity Too Large
Server: nginx/1.30.6
X-Couche: edge

# 2 Mio, plafond de 1 Mio sur l'origine
HTTP/1.1 413 Request Entity Too Large
Server: nginx/1.30.6
X-Couche: origine
X-Couche: edge

Un seul marqueur, la tête a refusé. Deux marqueurs, la réponse vient de plus loin et la tête l'a relayée.

Reste le contournement : la même requête envoyée à la tête puis à l'origine, avec F="code=%{http_code} sent=%{size_upload} total=%{time_total}\n" :

$ curl -sS -o /dev/null -H "Expect:" -w "$F" --data-binary @/tmp/9m http://blog-413-edge/upload.php
code=413 sent=130910 total=0.000719
$ curl -sS -o /dev/null -w "$F" --data-binary @/tmp/9m http://blog-413-origin:81/upload.php
code=200 sent=9437184 total=0.009528

Devant un vrai CDN, l'option --resolve de curl force l'adresse sans toucher au DNS. Le nom et l'adresse ci-dessous sont des exemples :

curl -sS -o /dev/null -w "$F" --data-binary @/tmp/9m \
  --resolve site.example:443:203.0.113.10 https://site.example/upload.php

Si l'origine n'accepte que les adresses du CDN, il reste son journal d'accès. Et ce 200 ne prouve pas que l'upload a abouti, PHP peut encore le perdre.

CDN : un plafond lié à l'offre

La documentation de Cloudflare, relue le 2 novembre 2026, donne 100 Mo sur les offres Free et Pro, 200 Mo sur Business, et jusqu'à 5 Go sur Enterprise. Le réglage s'appelle Maximum Upload Size et se trouve sur la page Network de la zone. La même page cite aussi le passage en DNS seul, à écarter : l'adresse de l'origine devient publique, Cloudflare ne protège plus ces requêtes et sa documentation réserve ce mode aux enregistrements sans trafic web.

Cette page ne dit pas si la requête refusée atteint l'origine, et nous n'avons pas de banc Cloudflare. Le contrôle se fait donc sur l'origine : aucune ligne dans son journal d'accès au moment du 413 désigne l'amont. Une fois la taille acceptée, un traitement lent rencontre une autre limite du même CDN, celle du délai : l'erreur Cloudflare 524.

Proxy : client_max_body_size et la location qui ne s'applique pas

La directive vaut 1m par défaut, se pose dans http, server ou location, et 0 désactive le contrôle. La documentation de nginx ajoute un détail qui trompe le support : les navigateurs n'affichent pas correctement cette erreur. L'utilisateur peut donc décrire un envoi coupé plutôt qu'un 413, et la RFC 9110 autorise le serveur à fermer la connexion.

La valeur de sent dépend de ce que le client annonce. Pour le même corps de 2 Mio :

Content-Length avec Expect: 100-continue   code=413 sent=0
Content-Length sans Expect                 code=413 sent=589660
Transfer-Encoding: chunked                 code=413 sent=2097420

Les deux dernières valeurs changent d'un essai à l'autre. Avec une longueur annoncée, nginx décide sur l'annonce. En chunked, il compte en lisant, et le journal change de forme : client intended to send too large chunked body: 983884+65524 bytes. On cherche donc le motif too large, plus court.

La limite peut aussi être posée sur une location que la requête n'atteint pas :

server {
  location /upload/ { client_max_body_size 64m; }
  location ~ \.php$ { fastcgi_pass php:9000; }
}

Un POST /upload/x.php de 2 Mio rend code=413 sent=0. nginx retient le préfixe le plus long, puis teste les expressions régulières, et la première qui correspond l'emporte. La requête finit donc dans le bloc PHP, avec la limite par défaut. Imbriquer le bloc PHP dans location /upload/ a fait passer le corps au banc, et le reste du site est resté à 1 Mio. Ce bloc exécute du PHP sous /upload/ : les fichiers reçus doivent être rangés ailleurs, sinon un script envoyé par un client devient exécutable.

Pour voir ce qui est réellement chargé, plutôt que ce que le dépôt prétend :

nginx -T 2>/dev/null | grep -nE "client_max_body_size|^# configuration file"
nginx -t && nginx -s reload

Sans ligne de directive dans le contexte de la requête, c'est 1 Mio.

Une limite plus haute écrit sur le disque : au banc, chaque gros corps accepté a produit a client request body is buffered to a temporary file /var/cache/nginx/client_temp/.... On pose une valeur précise sur la location d'upload, pas de 0 global tant qu'aucune couche derrière ne tient la limite, et on surveille la place sur ce volume, sinon l'incident change de nom et devient un disque plein.

ModSecurity, non testé ici, a son plafond : SecRequestBodyLimit, 134 217 728 octets par défaut selon le manuel, avec un refus en 413. Le réglage de notre article sur ModSecurity pose 13 107 200 octets avec SecRequestBodyLimitAction Reject, soit 12,5 Mio : un envoi plus gros s'arrête là, quelle que soit la valeur de nginx.

Application : le 413 absent du journal d'erreurs

Une application renvoie le code qu'elle veut. Au banc, un script de quatre lignes qui pose http_response_code(413), en-têtes abrégés :

HTTP/1.1 413 Request Entity Too Large
Server: nginx/1.30.6
Content-Type: application/json
X-Powered-By: PHP/8.5.12

{"message":"artifact too large"}

Le Server et le statut imitent un refus de nginx, seuls le type de contenu et le corps changent. Le journal d'erreurs de nginx ne contient aucune ligne de taille, et sent=2097152 montre que le corps est parti en entier.

Sur notre forge GitLab, un job a reçu un 413 Request Entity Too Large en envoyant un artefact d'environ 155 Mo. client_max_body_size valait 0 sur les locations rails et registry : nginx ne contrôlait rien. La cause était le réglage applicatif max_artifacts_size, lu par GET /application/settings, resté à 100, le défaut documenté de 100 Mo. Le relèvement à 500 Mo s'est fait par PUT /application/settings, sans toucher à nginx. Ce réglage existe aussi par groupe et par projet.

Un framework PHP peut aussi fabriquer ce code. Dans la branche 12.x de Laravel, le middleware ValidatePostSize compare CONTENT_LENGTH à post_max_size et lève PostTooLargeException, construite avec le statut 413. La limite est celle de PHP, le 413 est celui de l'application : le journal d'erreurs de nginx ne portera pas de too large body, et le correctif reste dans la configuration PHP.

PHP : pas de 413, un 200 sans fichier

La page ini.core de php.net donne upload_max_filesize à 2M et post_max_size à 8M, valeurs utilisées quand php.ini n'est pas chargé. Au-delà de post_max_size, $_POST et $_FILES sont vides. Aucun code HTTP n'y figure, mais la page n'écrit pas non plus que PHP n'envoie jamais de 413. D'où le test, avec client_max_body_size 64m pour laisser passer nginx et le php.ini-production de l'image officielle :

# 3 Mio en multipart, au-dessus de upload_max_filesize
{"content_length":"3145931","post":0,"files":1,"error":1,"size":0}
code=200 sent=3145931

# 9 Mio en multipart, au-dessus de post_max_size
{"content_length":"9437387","post":0,"files":0,"error":null,"size":null}
code=200 sent=9437387

Le script décrit ce qu'il reçoit. Dans le premier cas, error vaut 1, soit UPLOAD_ERR_INI_SIZE, et la taille 0. Dans le second, le fichier n'existe plus pour le script, et le seul message d'erreur vient de PHP, relevé ici dans le journal de FPM :

PHP message: PHP Warning:  PHP Request Startup: POST Content-Length of 9437387 bytes exceeds the limit of 8388608 bytes in Unknown on line 0

Monter client_max_body_size sans toucher à PHP remplace donc le 413 par un envoi qui échoue en silence, avec un statut de succès. Un 413, au moins, se voit.

WordPress hérite de ce fonctionnement. Sa fonction wp_max_upload_size() prend le minimum de upload_max_filesize et de post_max_size, sans connaître la limite de nginx : WordPress peut annoncer 64 Mio alors que le proxy refuse au-delà de 1 Mio.

Le correctif passe par la configuration de PHP, et le banc a montré trois façons de le rater. La ligne de commande ment : fichier posé et FPM non rechargé, php -i affichait déjà upload_max_filesize => 64M, alors que le même envoi de 3 Mio rendait encore error: 1. La valeur qui compte se lit dans une requête web, avec ini_get().

FPM doit donc être rechargé. Après USR2 au processus maître, le même envoi rendait "error":0,"size":3145728, et celui de 9 Mio arrivait entier.

Quant à ini_set(), il ne peut rien : ces directives sont en mode INI_PERDIR, l'appel rend false et la valeur ne change pas. Sans accès au fichier principal, .user.ini fonctionne sous CGI et FastCGI, relu toutes les 300 secondes par défaut.

Aligner les couches pour garder un 413 lisible

Un dépassement sur nginx laisse un 413 et une ligne de journal, alors qu'un dépassement de post_max_size rend un 200 et perd l'upload. On préfère donc que nginx refuse avant PHP, avec client_max_body_size égal à post_max_size, et upload_max_filesize un peu dessous, car le multipart ajoute une enveloppe (203 octets au banc, pour un seul champ). Pour des fichiers de 64 Mio :

upload_max_filesize = 64M
post_max_size = 68M
client_max_body_size 68m;   # sur la location d'upload, tête et origine

Au banc, à travers la tête et l'origine, un fichier de 64 Mio arrive avec error à 0, un de 66 Mio rend un 200 avec error à 1, et un de 68 Mio rend un 413, l'enveloppe faisant dépasser le corps : le code d'upload doit lire ce champ. Le plafond du CDN et celui du WAF doivent être au moins égaux, sinon leur 413 sort le premier.

On contrôle par le nom public, avec un fichier juste sous la limite et un juste au-dessus, en vérifiant le code et ce que l'application a reçu.

Une fois l'envoi accepté, les pannes suivantes sont le 504 nginx si le traitement dépasse le délai du proxy, et le 502 si FPM tombe pendant ce traitement.

Sources

  • nginx, ngx_http_core_module : client_max_body_size et sélection des location
  • nginx, ngx_http_headers_module : add_header et always
  • RFC 9110 : section 15.5.14, 413 Content Too Large
  • PHP, directives du noyau : limites, défauts, superglobales vides
  • PHP, constantes d'upload : UPLOAD_ERR_INI_SIZE vaut 1
  • PHP, fichiers .user.ini : SAPI et relecture
  • Cloudflare, Error 413 : plafonds par offre
  • Cloudflare, Proxy status : risques du DNS seul
  • ModSecurity, manuel v3.x : SecRequestBodyLimit
  • GitLab, limites CI/CD : taille des artefacts, 100 Mo par défaut
  • GitLab, API des réglages : max_artifacts_size
  • Laravel, ValidatePostSize : contrôle de post_max_size
  • Laravel, PostTooLargeException : statut 413
  • WordPress, wp_max_upload_size() : calcul de la limite affichée
  • curl, manuel : --resolve et size_upload
  • Netdata, nginx 413 : signal du journal d'accès vide

Besoin d'aide sur ce sujet ?

Notre équipe d'experts est là pour vous accompagner dans vos projets d'infrastructure et d'infogérance.

Contactez-nous

Articles similaires

Migrer un serveur sans coupure quand la base écrit
Infrastructure
Web
Administration
Infrastructure
Web
Administration

Migrer un serveur sans coupure quand la base écrit

Baisse du TTL, réplication logique, bascule mesurée sous 1,3 s et retour arrière après écritures : la migration d'un serveur actif, de J-7 au retour final.

12 nov. 2026
Lire plus
Erreur 524 Cloudflare : trouver sur le serveur la requête trop lente
Web
Administration
Performance
Web
Administration
Performance

Erreur 524 Cloudflare : trouver sur le serveur la requête trop lente

Cloudflare coupe à 125 secondes. La requête fautive se retrouve dans les logs de l'origine, en filtrant sur la durée et en lisant la cascade des délais.

10 nov. 2026
Lire plus
Stalwart : un serveur mail moderne tout-en-un en Rust
Administration
Sécurité
Web
Administration
Sécurité
Web

Stalwart : un serveur mail moderne tout-en-un en Rust

Stalwart est un serveur mail open source écrit en Rust qui parle SMTP, IMAP, JMAP, POP3, CalDAV, CardDAV et WebDAV dans un seul binaire. Architecture, déploiement, comparaison avec Postfix/Dovecot.

15 mai 2026
Lire plus

SHPV, votre partenaire de confiance en infrastructure et infogérance informatique en France.

SHPV
Contactez-nousNous contacterBlog
Expertise
InfrastructureDatacenterInfogéranceCloudHébergementTransit IPIABare MetalHousing
Légales
Conditions Générales de VenteCPS - Contrat de ServicesCPS - Hébergement CloudCPS - Microsoft 365Accord sous-traitance RGPDTarifs interventions

SHPV © 2026 - Tous droits réservés

Mentions légalesPolitiques de confidentialité
SHPV FRANCE - SAS au capital de 16 000 € - 52 Rue Romain Rolland, 71230 Saint-Vallier - SIRET n°80886287400035 - R.C.S. Chalon-sur-Saône. Par téléphone 09 72 310 818 - Email: support@shpv.fr