💰💌 Si tu te procures un abonnement d'un an au forfait premium de Oui, mais je LLM d'ici le 30 novembre, je t'offre en prime mes quatre formations autodidactes, une valeur de 276 $ ! Clique ici !" 💰💌

Potion Bottle Icon Manuel d'alchimie du code Potion Bottle Icon

Changer la limite de chargement de fichiers dans PHP

- 1 756 mots - Temps de lecture estimé: 10 minutes

Si tu dois augmenter la limite des fichiers uploadés sur ton serveur suite à un message d’erreur lors de l’envoi, voici comment ajuster ces paramètres.

Ce problème se manifeste généralement par un message comme :
"Erreur de téléchargement: La taille du fichier dépasse la limite autorisée".

La solution dépend des versions PHP et de la configuration mémoire. Voici comment procéder:

🌘 1. Connecte-toi à ton serveur via SSH

ssh [utilisateur]@[adresse_serveur]

Explication détaillée de la commande SSH :

Vérification de la connexion :
Une fois connecté, tu peux vérifier que tu es bien sur le bon serveur avec :

hostname
whoami
pwd

🌘 2. Ouvre le fichier php.ini approprié

Adapte la version selon celle installée sur ton serveur. Il se peut qu’il y en ait plusieurs, alors il faut identifier celle utilisée par ton application web en regardant quel “socket” il utilise dans la configuration de NGINX.

Comment trouver la bonne version PHP :

php -v  # Affiche la version PHP CLI
which php  # Montre le chemin de l'exécutable PHP
systemctl status php*.fpm  # Vérifie les services PHP-FPM en cours d'exécution

Alternative pour trouver tous les fichiers php.ini :

find /etc -name "php.ini" 2>/dev/null

🌘 3. Modifie les paramètres d’upload

Cherche et modifie ces lignes:

; Maximum upload file size in MB ;
upload_max_filesize = [taille]M   ; Ex: 512M

; post_max_size doit être >= upload_max_filesize ;
post_max_size = [meme_taille_que_upload]M   ; Ex: 512M

; Ajustez la limite de mémoire si nécessaire pour traiter les gros fichiers :
memory_limit = [meme_taille_que_upload]M     ; Ex: 512M

Explication détaillée des paramètres :

🌘 upload_max_filesize

🌘 post_max_size

🌘 memory_limit

Comment trouver et modifier ces paramètres :

# Chercher les paramètres actuels dans php.ini
grep -n "upload_max_filesize\|post_max_size\|memory_limit" /etc/php/8.x/fpm/php.ini

# Utiliser sed pour modifier les valeurs (alternative à nano)
sudo sed -i 's/upload_max_filesize = .*/upload_max_filesize = 512M/' /etc/php/8.x/fpm/php.ini
sudo sed -i 's/post_max_size = .*/post_max_size = 512M/' /etc/php/8.x/fpm/php.ini
sudo sed -i 's/memory_limit = .*/memory_limit = 512M/' /etc/php/8.x/fpm/php.ini

🌘 4. Modifie le fichier de configuration Nginx

Dans certains cas, il y a aussi un fichier spécifique à l’application dans la configuration du proxy inversé (Apache ou nginx) qui va passer en priorité sur les paramètre globaux configurés dans PHP.

Pourquoi modifier la configuration Nginx ?

Comment trouver le fichier de configuration Nginx :

# Trouver tous les fichiers de configuration Nginx
find /etc/nginx -name "*.conf" 2>/dev/null

# Vérifier la configuration Nginx actuelle
grep -r "client_max_body_size" /etc/nginx/

# Pour une application spécifique (ex: Castopod)
find /etc/nginx -name "*castopod*" -type f

Voici un exemple de fichier pour l’application Castopod dans Yunohost. Remplace castopod.domaine.com par le nom de domaine de ton application, et castopod.conf par le nom du fichier qui se trouve dans le répertoire.

sudo nano /etc/nginx/conf.d/castopod.domaine.com.d/castopod.conf

Explication du chemin :

Les paramètres qui auront une influence ici sont:

client_max_body_size 512M;

Explication du paramètre Nginx :

Autres paramètres Nginx pertinents :

# Pour les temps d'attente plus longs pour les gros fichiers
client_body_timeout 300s;
client_header_timeout 300s;
keepalive_timeout 300s;
send_timeout 300s;

Il faut ensuite redémarrer le serveur nginx:

sudo systemctl restart nginx

Explication de la commande de redémarrage :

Vérification du service Nginx :

sudo systemctl status nginx  # Vérifier que le service fonctionne
sudo nginx -t              # Tester la configuration syntaxique

🌘 5. Modifie le fichier spécifique à l’application dans PHP

Dans certains cas, il y a aussi un fichier spécifique à l’application dans la configuration du pool de PHP. Ce fichier va toujours passer en priorité sur la configuration globale et est activé lorsqu’il y a une session PHP de démarrée sur le socket en question. Il y a un fichier pour chaque application et pour chaque version de PHP. C’est donc une bonne chose de valider quelle version de PHP est utilisée si tu as de la difficulté à trouver le bon fichier.

Comment trouver les fichiers de pool PHP :

# Lister tous les fichiers de pool PHP
find /etc/php -name "*.conf" -path "*/pool.d/*" 2>/dev/null

# Vérifier les pools PHP actifs
ls -la /etc/php/8.x/fpm/pool.d/

# Vérifier la configuration des pools
systemctl status php*-fpm
sudo nano /etc/php/8.2/fpm/pool.d/castopod.conf

Explication du chemin :

Ce sont les 3 mêmes variables qu’on a modifié précédemment, mais présentées différemment.

php_admin_value[upload_max_filesize] = 512M
php_admin_value[post_max_size] = 512M
php_admin_value[memory_limit] = 512M

Explication de la syntaxe du pool PHP :

Autre paramètres de pool utiles :

; Timeout pour les requêtes
request_terminate_timeout = 300s

🌘 6. Redémarre le service PHP

Pour la plupart des serveurs, utilise:

sudo systemctl restart php*.fpm.service

Explication détaillée de la commande :

Commandes alternatives pour différentes distributions :

Pour les systèmes plus anciens :

sudo /etc/init.d/php[version].fpm reload && restart  ;

Explication des commandes anciennes :

🌘 Conseils d’utilisation selon ta configuration

upload_max_filesize = 512M 
post_max_size       = 512M 
memory_limit        = 512M   # Si mémoire est limitée, augmentez à la volée ces paramètres!

Pourquoi ces valeurs pour les fichiers média :

upload_max_filesize = 1024M # ou même plus selon la RAM disponible 
post_max_size       = 4096M

Pourquoi ces valeurs pour les gros fichiers :

🌘 Précautions

"free -h && df -h /var/www" ; "Pour estimer l'espace disponible"

Explication des commandes de vérification :

Change x pour ta sous-version

cp /etc/php/8.x/fpm/php.ini /etc/php/8.x/fpm/php.ini.backup

Explication de la commande de sauvegarde :

🌘 Vérification des modifications

Après avoir appliqué toutes les modifications, voici comment vérifier qu’elles sont effectives :

🌘 Vérification via ligne de commande

# Vérifier la configuration PHP CLI
php -r "echo 'upload_max_filesize: ' . ini_get('upload_max_filesize') . PHP_EOL;"
php -r "echo 'post_max_size: ' . ini_get('post_max_size') . PHP_EOL;"
php -r "echo 'memory_limit: ' . ini_get('memory_limit') . PHP_EOL;"

# Vérifier la configuration PHP-FPM
sudo php-fpm8.2 -t  # Tester la syntaxe de la configuration

🌘 Vérification de la configuration Nginx

# Tester la syntaxe de la configuration Nginx
sudo nginx -t

# Vérifier la valeur de client_max_body_size
sudo nginx -T 2>/dev/null | grep -A5 -B5 "client_max_body_size"

🌘 Dépannage des problèmes courants

🌘 Problème 1 : Les modifications ne semblent pas prises en compte

# Vérifier que le bon fichier php.ini est utilisé
php -i | grep "Loaded Configuration File"

# Vérifier que le bon pool PHP est utilisé
ps aux | grep "php-fpm"

🌘 Problème 2 : Erreur 413 Request Entity Too Large

C’est une erreur Nginx. Vérifie que client_max_body_size est bien configuré dans la bonne section du fichier Nginx.

🌘 Problème 3 : Erreur de mémoire lors de l’upload

Augmente memory_limit dans le fichier php.ini ou dans le pool spécifique.

🌘 Problème 4 : Le timeout est atteint

# Augmenter les timeouts dans Nginx
client_body_timeout 300s;
client_header_timeout 300s;
keepalive_timeout 300s;
send_timeout 300s;

# Augmenter le timeout dans le pool PHP
request_terminate_timeout = 300s

🌘 Sécurité et bonnes pratiques

🌘 Limites recommandées selon le type d’application

🌘 Mesures de sécurité

🌘 Surveillance

# Surveiller l'utilisation de la mémoire
free -h

# Surveiller l'utilisation du disque
df -h

# Surveiller les processus PHP
ps aux | grep php-fpm

# Surveiller les erreurs PHP
tail -f /var/log/php8.2-fpm.log

🌘 Résumé des commandes essentielles

🌘 Connexion et navigation

ssh [utilisateur]@[serveur]          # Connexion SSH
find /etc -name "php.ini"           # Trouver les fichiers php.ini
php -v                              # Vérifier la version PHP

🌘 Modification des configurations

sudo nano /etc/php/8.x/fpm/php.ini  # Éditer php.ini
sudo nano /etc/nginx/sites-available/ton-site  # Éditer config Nginx
sudo nano /etc/php/8.x/fpm/pool.d/ton-app.conf # Éditer config pool PHP

🌘 Redémarrage des services

sudo systemctl restart nginx         # Redémarrer Nginx
sudo systemctl restart php8.x-fpm    # Redémarrer PHP-FPM
sudo systemctl reload nginx         # Recharger Nginx (en douceur)

🌘 Vérification

sudo nginx -t                       # Tester config Nginx
sudo php-fpm8.x -t                  # Tester config PHP
php -i | grep "upload_max_filesize" # Vérifier config PHP

En suivant ce guide détaillé, tu devrais pouvoir ajuster correctement les limites de chargement de fichiers sur ton serveur PHP et résoudre les problèmes d’upload de fichiers volumineux.

Shooting Stars IconConsultation ExpressShooting Stars Icon

Bénéficie d'une heure de consultation dédiée avec François pour résoudre tes défis informatiques et stratégiques. Que ce soit pour la migration vers des technologies libres, la sécurisation de tes systèmes, la documentation de tes procédures, la conception de petits systèmes ou l'automatisation de tâches, cette session intensive t'offre des solutions concrètes et un plan d'action clair.

Tu seras libre ensuite de poursuivre avec un forfait de consultation sur mesure ou les programmes DéconstruIT ou Pleine Confiance

Découvre la Consultation Express.
Abonne-toi au fil RSS pour ne rien manquer.

Étiquettes

post php chargement fichiers serveur-web autohebergement