Aller au contenu
  • Accueil
  • Infrastructure
  • Datacenter
  • Services
    Nos services
    InfogéranceCloudHébergementIABare MetalHousingTransit IP
  • Blog
Contactez-nous
  1. Accueil
  2. /
  3. Blog
  4. /
  5. Apache prefork et MaxRequestWorkers : calcul sur la mémoire mesurée

Web
Performance
Linux

Apache prefork et MaxRequestWorkers : calcul sur la mémoire mesurée

20 novembre 2026

11 min de lecture

Sommaire
Le banc : prefork et mod_php dans 2 Gio
Étape 1 : lire le vrai plafond mémoire
Étape 2 : obtenir le droit de lire la PSS
Étape 3 : relever sous charge, chaque seconde
Étape 4 : saturer pour voir le pire instant
Étape 5 : diviser le budget par la PSS d'un worker lourd
Étape 6 : compter les OOM à chaque valeur
Poser la valeur dans le fichier qui l'emporte
Ce que le journal d'Apache ne dira pas
Quand 24 ne suffit pas
Sources

Cent cinquante workers : c'est ce que Debian 13 installe, sans connaître ni votre mémoire ni le poids de vos pages.

$ grep -v '^#' /etc/apache2/mods-enabled/mpm_prefork.conf

StartServers            5
MinSpareServers         5
MaxSpareServers         10
MaxRequestWorkers       150
MaxConnectionsPerChild  0

La documentation Apache donne 256 pour prefork, et Debian descend à 150. Sur le banc décrit plus bas, un worker chargé pèse 67,7 Mio : 150 workers demanderaient près de 10 Gio à une machine qui en a 2.

MaxRequestWorkers vaut le budget mémoire d'Apache divisé par la PSS d'un worker lourd, relevée pendant que le serveur sature. Un test de charge qui compte les oom_kill vérifie ensuite le résultat. Sur notre banc, la moyenne donne 54 workers, le RSS 14, une mesure à vide plus de mille. La valeur qui tient : 24.

L'incident qui rend ce calcul concret est raconté dans la lecture d'un dump d'OOM killer ; ici, aucun chiffre ne vient d'un dump.

Le banc : prefork et mod_php dans 2 Gio

Le serveur est un debian:stable-slim (Debian 13.7) avec Apache 2.4.69 et PHP 8.4.27 installés par apt ; libapache2-mod-php y fait basculer Apache de mpm_event à mpm_prefork. La charge vient d'un second conteneur, pour rester hors de la mémoire mesurée.

docker run -d --rm --name blog-apache-prefork-srv \
  --network blog-apache-prefork-net \
  --memory=2g --memory-swap=2g --cpus=4 \
  debian:stable-slim sleep infinity

La page PHP est synthétique : elle charge 1 500 classes par opcache, remplit 16 ou 64 Mio selon un paramètre, puis attend 300 ms. Quatre clients sur cinq demandent la page légère. Ces chiffres valent pour cette page : sur votre site, refaites les relevés.

ab -q -r -s 180 -t 60 -n 1000000 -c 120 'http://blog-apache-prefork-srv/app.php?mb=16' &
ab -q -r -s 180 -t 60 -n 1000000 -c 30  'http://blog-apache-prefork-srv/app.php?mb=64' &
wait

Étape 1 : lire le vrai plafond mémoire

Dans un conteneur, free répond pour l'hôte.

$ free -m | head -2
               total        used        free      shared  buff/cache   available
Mem:           32029        8071       19421         104        5018       23958

$ cat /sys/fs/cgroup/memory.max
2147483648

La limite qui compte est la seconde : 2 048 Mio. Sur un serveur nu, partez de free, et retirez-en base de données, cron et tout le reste.

Étape 2 : obtenir le droit de lire la PSS

La PSS (Proportional Set Size), que l'article sur l'OOM killer détaille, se lit dans /proc/PID/smaps_rollup. C'est la bonne unité pour une addition : la somme ne compte chaque page partagée qu'une fois.

Dans un conteneur Docker aux réglages par défaut, le refus ne se voit pas. Voici smem en root sur un Apache démarré, cinq workers actifs :

$ docker exec blog-apache-prefork-srv sh -c 'smem -k -P "apache2 -k"'
  PID User     Command                         Swap      USS      PSS      RSS
 9777 root     sh -c smem -k -P "apache2 -        0   228.0K   373.0K     1.4M
 9784 root     /usr/bin/python3 /usr/bin/s        0    12.0M    12.3M    13.8M
 9770 root     /usr/sbin/apache2 -k start         0    12.6M    13.9M    20.9M

Aucun worker, aucune erreur. Lire le fichier directement donne la raison :

head: cannot open '/proc/9772/smaps_rollup' for reading: Permission denied

Les workers tournent sous www-data, et le root du conteneur n'a pas CAP_SYS_PTRACE. docker exec --privileged débloque le relevé, le temps de cette seule commande : les workers apparaissent alors à 1,3 Mio de PSS pour 8 Mio de RSS. Chiffre juste et inutile, puisqu'ils n'ont encore rien servi. --cap-add SYS_PTRACE donne le même droit de lecture (root lisant un processus d'un autre utilisateur : refusé sans l'option, accepté avec), mais pour toute la vie du conteneur : gardez-le au banc, pas sur un conteneur web en production.

Étape 3 : relever sous charge, chaque seconde

Ce script, lancé en root pendant le test, résume les workers en une ligne, en Mio :

#!/bin/bash
# Run as root while the server is under load. One line per call, in MiB.
parent=$(cat /var/run/apache2/apache2.pid)
for pid in $(pgrep -P "$parent" apache2); do
  awk '/^Rss:/{r=$2} /^Pss:/{p=$2} END{print p, r}' "/proc/$pid/smaps_rollup"
done | sort -n | awk '{p[NR]=$1; sp+=$1; sr+=$2}
END{i=int(NR*.95); if(i<1)i=1;
printf "workers=%d pss_total=%.0f rss_total=%.0f pss_mean=%.1f pss_median=%.1f pss_p95=%.1f pss_max=%.1f\n",
NR, sp/1024, sr/1024, sp/NR/1024, p[int((NR+1)/2)]/1024, p[i]/1024, p[NR]/1024}'

Premier relevé, 40 workers pour 40 clients, donc sans file d'attente. On garde l'instant où le total de PSS culmine sur 25 échantillons :

workers=40 pss_total=1201 rss_total=3060 pss_mean=30.0 pss_median=18.5 pss_p95=66.9 pss_max=66.9

Ce relevé règle la question du RSS : le cumul atteint 3 060 Mio dans un conteneur limité à 2 048 Mio, sans aucun OOM. Le RSS recompte dans chaque worker les pages partagées.

La médiane à 18,5 Mio et le 95e percentile à 66,9 Mio montrent deux populations, et la moyenne de 30,0 Mio n'en décrit aucune. La documentation Apache conseille pourtant de diviser par la taille moyenne d'un processus lue dans top : sur des pages de poids inégal, ce conseil trompe.

Étape 4 : saturer pour voir le pire instant

Même relevé, avec 24 workers et 150 clients, donc une file d'attente :

workers=24 pss_total=1579 rss_total=2679 pss_mean=65.8 pss_median=67.7 pss_p95=67.7 pss_max=69.5

La médiane bondit de 18,5 à 67,7 Mio, mais c'est un pic. Sur 35 relevés d'une autre passe, elle oscille de 20,3 à 67,6 Mio, médiane des médianes à 25,4. Elle touche le haut quand la file aligne les pages lourdes : 20 en cours sur 24 au relevé le plus chargé, aucune au relevé suivant. Hors file, c'est l'inverse : les 8 clients lourds retombent sur les mêmes workers, et 10 workers sur 40 ne servent presque aucune page lourde. D'où les deux populations.

PHP ajoute une traîne : en fin de requête, zend_alloc.c ne rend ses blocs que jusqu'à une moyenne glissante, demi-somme de l'ancienne moyenne et du dernier pic. Un worker unique le montre, après une page de 64 Mio suivie de pages de 1 Mio :

after mb=1:
Rss: 56424 kB Pss: 48972 kB
after one mb=64:
Rss: 88420 kB Pss: 80968 kB
after 1 more mb=1:
Rss: 71912 kB Pss: 64460 kB
after 2 more mb=1:
Rss: 63660 kB Pss: 56208 kB

L'excédent se divise à peu près par deux à chaque requête : la rétention prolonge un pic déjà là. Le relâchement attend la requête suivante : sans plus aucun client, la médiane valait encore 43,5 Mio juste après une passe, 23,3 Mio après une autre. Le budget doit tenir quand tous les workers sont lourds en même temps : 67,7 Mio ici.

La PSS dépend aussi du nombre de processus. Les 39 Mio de mémoire partagée du cgroup se répartissent : 2,7 Mio par worker quand ils sont 14, 0,8 Mio quand ils sont 48. Relevez à nouveau après chaque changement de valeur.

Étape 5 : diviser le budget par la PSS d'un worker lourd

  1. Plafond mémoire : 2 048 Mio (memory.max).
  2. Réserve de 20 % pour le parent (14 Mio de PSS), le cache de fichiers et l'imprévu : 410 Mio.
  3. Budget d'Apache : 1 638 Mio.
  4. Poids d'un worker : 67,7 Mio, 95e percentile sous saturation.
  5. MaxRequestWorkers : 1 638 divisé par 67,7 donne 24,2. On retient 24.

La moyenne hors file aurait donné 54, le RSS maximal (116,6 Mio) 14. Contrôlez aussi memory_limit dans /etc/php/8.4/apache2/php.ini : 128 Mio chez Debian, quand php -i affiche -1 en lisant le fichier de la ligne de commande. Si une page peut approcher cette limite, votre relevé doit l'avoir croisée.

Étape 6 : compter les OOM à chaque valeur

Chaque ligne sort du même test : 150 clients, 60 secondes, 2 Gio sans swap. La valeur 48 reste sous celle que donne la moyenne.

MaxRequestWorkersRequêtes/sp95 page légèrePic mémoire relevéoom_killRéponses en échec
150 (défaut Debian)70,63 478 ms2 048 Mio601590
48 (sous la moyenne)147,51 150 ms2 021 Mio1919
24 (calculé)76,22 053 ms1 507 Mio00
2062,92 688 ms1 384 Mio00
14 (RSS maximal)44,63 346 ms1 012 Mio00

À 150, le service s'effondre sur les pages lourdes : 586 sur 737 reviennent incomplètes, contre 4 pages légères sur 3 503. Le score de l'OOM killer additionne la mémoire du processus, donc les gros workers partent en premier.

La ligne à 48 a le meilleur débit et trompe le plus : 19 tués en une minute, sans que le relevé à la seconde voie le plafond. Passez toutes les pages à 64 Mio et elle monte à 493 oom_kill, quand 24 workers restent à zéro avec un pic à 1 676 Mio. Ce test sur le profil le plus lourd valide le calcul.

Ces chiffres ne valent que pour une passe. Une première campagne le même jour donnait 652, 15 et 0 oom_kill pour 150, 48 et 24 workers, et 93,6 requêtes/s à 150 : l'hôte faisait tourner d'autres charges, les débits bougent. Le classement des oom_kill, lui, n'a pas changé.

La ligne à 14 donne le prix du RSS, borne prudente mais chère : 41 % de débit perdu par rapport à 24. Quant aux 2 secondes à 24 workers, c'est 150 clients divisés par 76,2 requêtes par seconde, soit le calcul de concurrence du capacity planning pris à l'envers. Derrière un CDN, cette attente a un plafond : l'erreur 524.

Poser la valeur dans le fichier qui l'emporte

Un réglage modifié à la main dans un conteneur disparaît à la recréation. Deux options tiennent : un COPY dans le Dockerfile, ou un montage en lecture seule depuis l'hôte. Ciblez le fichier réellement chargé : sous Debian, mods-enabled/mpm_prefork.conf est un lien vers mods-available/.

Vérifiez par le comportement, car apache2.conf lit conf-enabled/ après mods-enabled/ et l'emporte : avec 24 dans mods-available et 10 dans conf-enabled/zz-mrw.conf, le banc compte 10 enfants sous charge.

ps --ppid "$(cat /var/run/apache2/apache2.pid)" --no-headers | wc -l

Ce test prouve le plafond de processus, pas la tenue mémoire. Au-delà de 256, il faut aussi monter ServerLimit, sinon Apache rabote à 256 et le dit au démarrage (AH00180).

Ce que le journal d'Apache ne dira pas

Sur la passe à 150 workers : 601 processus tués, et un error.log resté à ses deux lignes de démarrage, AH00163 et AH00094. Dans mpm_unix.c, ap_process_child_status passe sur SIGKILL sans rien journaliser. AH00161 manque aussi : au relevé, on comptait 135 enfants, le plafond n'a pas été signalé. Un error.log propre ne dit rien des OOM : lisez le compteur.

$ grep '^oom' /sys/fs/cgroup/memory.events
oom 124089
oom_kill 607
oom_group_kill 0

oom_kill compte les processus tués. Il est cumulatif et monte encore juste après la fin de ab, d'où 607 ici pour 601 dans le tableau : lisez la différence entre deux relevés. Sur une machine sans cgroup dédié, cherchez oom-kill dans journalctl -k.

À l'inverse, AH00161: server reached MaxRequestWorkers setting est apparu sur toutes les passes sans OOM, et prefork ne l'écrit qu'une fois par processus parent. Une fois le dimensionnement fait, il indique seulement des clients en file (jusqu'à ListenBackLog, 511 par défaut, souvent moins selon l'OS).

Quand 24 ne suffit pas

Si le besoin dépasse le budget, il reste à ajouter de la mémoire ou alléger les pages. Remonter le plafond n'est pas une réponse, et le swap non plus : pour la documentation Apache, un serveur web ne doit jamais swapper.

Regardez aussi le keep-alive, activé par Debian avec KeepAliveTimeout 5. Vingt connexions ouvertes, une requête chacune puis plus rien, relevé deux secondes après, 24 workers au plafond :

BusyWorkers: 21
IdleWorkers: 1
Scoreboard: KKKKKKKKKKKKKKKKKKKKW_SS

Chaque K est un processus complet, avec toute sa mémoire, qui attend un client muet. C'est la limite de fond du couple prefork et mod_php. La sortie durable est PHP-FPM derrière le MPM event, dont le fil d'écoute prend en charge les connexions inactives. Nous ne l'avons pas mesuré ici.

En exploitation, la règle qu'on en tire : pas de valeur posée sans relevé de PSS sous charge sur le site réel, et un test qui regarde oom_kill plutôt que le journal d'Apache. Une extension ou une page plus lourde change le chiffre : le relevé se refait alors, sur la machine qui sert vraiment.

Sources

  • Apache, directives communes des MPM : défaut de 256 pour prefork, ServerLimit, ListenBackLog
  • Apache, réglage des performances : jamais de swap, méthode par la taille moyenne
  • Apache, MPM event : keep-alive confié au fil d'écoute
  • Debian, mpm_prefork.conf : valeur de 150
  • httpd, prefork.c : limite de 256, messages AH00180 et AH00161
  • httpd, mpm_unix.c : SIGKILL non journalisé
  • PHP 8.4, zend_alloc.c : conservation des blocs selon avg_chunks_count
  • Noyau Linux, /proc : définition de la PSS et de smaps_rollup, CAP_SYS_PTRACE pour lire /proc/PID d'un autre processus
  • Noyau Linux, cgroup v2 : memory.max et compteurs de memory.events
  • Noyau Linux, oom_kill.c : calcul du score de sélection

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

Optimiser les performances de Nginx avec la mise en cache
Linux
Performance
Web
Linux
Performance
Web

Optimiser les performances de Nginx avec la mise en cache

Découvrez comment configurer la mise en cache dans Nginx afin d'accélérer vos sites web et réduire la charge serveur.

7 oct. 2025
Lire plus
OOM killer Linux : lire le dump pour trouver qui a rempli la mémoire
Linux
Performance
Administration
Linux
Performance
Administration

OOM killer Linux : lire le dump pour trouver qui a rempli la mémoire

La victime de l'OOM killer n'est pas forcément la cause. Le tableau du dump lu colonne par colonne, avec un cas de 8,6 Go de RSS cumulés sur 6 Go de RAM.

13 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

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 365CPS - HousingAccord 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