Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Montée en charge

PHP monte en charge comme son modèle d’exécution le laisse prévoir : horizontalement, en ajoutant derrière un répartiteur de charge des workers identiques et interchangeables, parce qu’un processus shared-nothing n’a aucun état interne à réconcilier avec un autre processus. Tout le mécanisme est là. Il n’a rien d’exotique et, sur le principe, rien de propre à PHP, mais le modèle d’exécution par défaut de PHP, décrit dans Le runtime, en fait presque la seule option, ce qui se révèle plus souvent un atout qu’une contrainte.

Pourquoi le shared-nothing passe facilement à l’échelle dans un sens

PHP-FPM repose sur des workers : un pool de processus, chacun traitant une seule requête à la fois, sans aucune mémoire en commun. Comme aucun worker ne sait quoi que ce soit que ses voisins ne puissent reconstruire aussi bien que lui, un répartiteur de charge peut envoyer n’importe quelle requête à n’importe quel worker, sur n’importe quelle machine, sans étape de coordination. Doubler la capacité revient à ajouter une seconde machine identique qui fait tourner un second pool identique, pas à repenser la manière dont la première partage son état, puisqu’il n’y a jamais eu d’état à partager. C’est cette propriété précise qui rend simples à faire monter en charge les services HTTP sans état, l’essentiel de ce qu’on construit avec PHP, sans toute la famille de bugs qui naît quand deux processus ne sont pas d’accord sur ce qu’ils croient vrai tous les deux.

Qui fait tourner PHP présente déjà la démonstration la plus nette de ce principe à grande échelle, appuyée sur une source primaire : MediaWiki, le logiciel de Wikimedia, écrit à environ 70 % en PHP selon le projet lui-même, tourne dans sept centres de données sur trois continents. Chacun peut répondre seul à une requête, parce que rien dans le modèle d’exécution de PHP ne les oblige à se coordonner au-delà de ce que les couches de cache et de routage décident explicitement de partager.

Datacenters de Wikimedia qui font tourner MediaWiki, par région Datacenters de Wikimedia qui font tourner MediaWiki, par région États-Unis 3 Europe 2 Asie 1 Amérique du Sud 1 Wikimedia, wikitech.wikimedia.org/wiki/Wikimedia_infrastructure, consulté le 17/09/2026

La leçon de cette répartition ne tient pas au nombre de centres de données. Elle tient au fait qu’aucun n’a besoin de savoir ce que font les autres pour répondre correctement à une requête. Ajoutez un huitième centre dans une nouvelle région, et le changement se résume à une décision de routage et à un déploiement, pas à une réécriture de l’architecture, parce que chaque worker, partout, fait déjà tourner la même unité autonome de PHP shared-nothing. Une architecture avec état devrait régler la réplication et la cohérence pour faire le même pas. Celle-ci n’en a pas besoin, puisqu’elle n’a jamais eu d’état partagé à répliquer.

Ce qui doit sortir du processus pour que ça marche

La montée en charge shared-nothing a une condition, simple à énoncer et facile à violer par mégarde : rien de ce qui doit survivre d’une requête à l’autre ne peut vivre dans le processus PHP. La session d’un utilisateur, une donnée mise en cache pour éviter de relancer une requête coûteuse, un fichier envoyé qui attend son traitement : tout cela doit vivre hors du worker qui l’a manipulé en premier, dans une base de données, une couche de cache à part ou un stockage partagé, parce que rien ne garantit que la requête suivante du même utilisateur arrivera sur le même worker, ni même sur la même machine. Ce n’est pas une limite propre à PHP, c’est la forme habituelle de toute couche web sans état. Je la nomme ici sans détour parce qu’une équipe qui découvre les réglages par défaut de PHP l’apprend parfois à ses dépens : elle range quelque chose dans une simple variable ou dans un cache interne au processus, puis s’étonne de le voir disparaître dès la requête suivante.

Une rangée de cinq étals de marché identiques, un éléphant à chacun, avec un seul entrepôt commun derrière eux ; une personne amène un sixième étal, encore plié, pour l'ajouter à la rangée.

Monter en charge dans un worker, pas seulement en en ajoutant

Ajouter des workers n’est pas le seul levier. Le runtime a déjà présenté quatre façons, pour du code PHP, de garder beaucoup de choses ouvertes à la fois dans un seul processus : AMPHP, ReactPHP, Swoole ou OpenSwoole, et les Fibers au niveau du langage. Pour une charge dominée par l’attente, comme de nombreuses connexions ouvertes vers des services lents, un relais de messagerie instantanée ou la diffusion d’un webhook vers de multiples destinataires, ces outils permettent à un processus de traiter bien plus de travail concurrent qu’avec une requête par worker, parce que le processus n’est pas bloqué pendant qu’il attend : il avance sur autre chose et revient ensuite. Cela ne remplace pas la montée en charge horizontale, et cela ne donne pas à PHP de parallélisme au niveau du système d’exploitation, la limite nommée clairement dans Le runtime. Mais la question qui se pose à vous n’est plus seulement « combien de workers ? ». Elle devient aussi « quelle concurrence un worker peut-il absorber avant qu’il en faille un autre ? », et la réponse dépend de celui de ces outils qui se trouve sous votre application, s’il y en a un.

Les conteneurs changent l’emballage, pas le modèle

La plupart des nouveaux déploiements PHP tournent aujourd’hui dans des conteneurs plutôt que directement sur une machine, et il vaut la peine d’être précis sur ce que cela change et ce que cela ne change pas. Un conteneur donne à chaque pool de workers son propre système de fichiers isolé et son propre jeu de dépendances, ce qui rend le déploiement reproductible. Il ne touche pas au modèle shared-nothing qui tourne dessous : dans un conteneur, PHP-FPM démarre, exécute et détruit une requête à la fois, exactement comme en dehors. Faire monter en charge un service PHP conteneurisé reste la même opération horizontale, confiée à un orchestrateur au lieu d’être faite à la main : davantage de pods identiques derrière le même genre de répartiteur de charge, chacun aussi interchangeable que le précédent. Je n’ai pas de chiffre propre, tiré d’une source primaire et indépendant des fournisseurs, pour comparer la taille d’une image de conteneur PHP ou son temps de démarrage à froid à ceux d’un autre langage, donc je n’en imprime pas. L’affirmation d’architecture qui compte, à savoir qu’aucune couche d’orchestration propriétaire n’est nécessaire pour faire tourner PHP ainsi, se vérifie directement dans la documentation de PHP-FPM, sans passer par un benchmark.

La limite. Sortir l’état du processus PHP ne fait pas disparaître le coût de cet état : le problème de montée en charge se déplace vers la base de données et le cache, qui doivent désormais encaisser la charge cumulée de tous les workers de toutes les machines. Une application PHP dont la couche web monte proprement en charge peut rester entièrement bridée par une base de données qu’on n’a pas fait grandir en même temps, et je ne prétendrai pas que la montée en charge de PHP s’étend à une brique d’infrastructure que PHP ne contrôle pas. Les serveurs en mode worker, qui restent démarrés longtemps et que décrit Le runtime, réintroduisent aussi un souci que PHP-FPM en shared-nothing n’a pas : un worker démarré depuis des heures accumule de la mémoire comme n’importe quel processus de longue durée. C’est précisément pour cela que la documentation de FrankenPHP recommande des redémarrages périodiques au lieu de prétendre que le problème n’existe pas.

À vérifier vous-même. Si vous utilisez PHP-FPM aujourd’hui, regardez dans la configuration du pool la valeur de pm.max_children, le réglage qui plafonne le nombre de processus workers qu’un pool fait tourner en même temps, et comparez-la à la mémoire disponible sur la machine. Un pool dimensionné sans ce calcul est un plafond de montée en charge courant, que l’on s’impose soi-même et qui n’a rien à voir avec le langage. Si vous évaluez plutôt un serveur en mode worker, demandez précisément comment et à quel rythme il redémarre ses workers, et traitez la réponse comme une donnée de dimensionnement, pas comme un détail à régler plus tard.

Faire monter en charge une couche web et constituer l’équipe qui la maintient sont deux problèmes distincts, et le second se laisse beaucoup moins facilement réduire à un chiffre. Qui fait vivre PHP se tourne vers les compétences disponibles, les pratiques de test et la question des personnes.