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
- Plafond mémoire : 2 048 Mio (
memory.max). - Réserve de 20 % pour le parent (14 Mio de PSS), le cache de fichiers et l'imprévu : 410 Mio.
- Budget d'Apache : 1 638 Mio.
- Poids d'un worker : 67,7 Mio, 95e percentile sous saturation.
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.
MaxRequestWorkers | Requêtes/s | p95 page légère | Pic mémoire relevé | oom_kill | Réponses en échec |
| 150 (défaut Debian) | 70,6 | 3 478 ms | 2 048 Mio | 601 | 590 |
| 48 (sous la moyenne) | 147,5 | 1 150 ms | 2 021 Mio | 19 | 19 |
| 24 (calculé) | 76,2 | 2 053 ms | 1 507 Mio | 0 | 0 |
| 20 | 62,9 | 2 688 ms | 1 384 Mio | 0 | 0 |
| 14 (RSS maximal) | 44,6 | 3 346 ms | 1 012 Mio | 0 | 0 |
À 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
AH00180etAH00161 - httpd, mpm_unix.c :
SIGKILLnon 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_PTRACEpour lire/proc/PIDd'un autre processus - Noyau Linux, cgroup v2 :
memory.maxet compteurs dememory.events - Noyau Linux, oom_kill.c : calcul du score de sélection


