Blog · SRE et observabilité · · 5 min de lecture
Autoscaling sur le CPU : pourquoi il ne voit pas la saturation d’Apache et PHP-FPM
Un HPA réglé sur le CPU ne réagit pas quand tous les workers PHP attendent un backend lent : ils sont occupés, mais ne calculent rien. Il faut scaler sur l’occupation des workers, et surtout traiter la cause de l’attente.
Sur un réseau de sites WordPress hébergé sur Kubernetes, nous avons vu des 503 et des 504 s’accumuler pendant de longues minutes. Le HorizontalPodAutoscaler était en place, réglé sur le CPU et la mémoire. Il n’a pas ajouté un seul pod. En regardant les graphes, le CPU des pods était quasi nul.
Ce n’est pas un défaut du HPA. C’est une métrique qui ne mesure pas le bon mode de panne.
Un worker qui attend ne consomme pas de CPU
Apache et PHP-FPM traitent les requêtes avec un nombre fixe de workers. Côté Apache, la limite s’appelle MaxRequestWorkers. Côté PHP-FPM, c’est pm.max_children. Quand tous les workers sont pris, les nouvelles requêtes attendent dans une file, puis finissent en erreur.
Un worker peut être occupé de deux façons très différentes :
- il calcule : rendu d’une page, exécution de PHP. Le CPU monte, le HPA le voit ;
- il attend : une réponse d’une base, d’une API, d’un autre service derrière un reverse proxy. Le CPU reste bas.
Dans notre cas, WordPress appelait, à travers un proxy, une application front qui elle-même rappelait WordPress. Une dépendance circulaire. Dès que l’un des deux ralentissait, les workers de l’autre restaient bloqués en attente réseau. Tous occupés, aucun ne calculait.
La signature à reconnaître dans un incident : des erreurs 5xx avec un CPU des pods proche de zéro. Ce n’est pas un manque de puissance. C’est une saturation des workers.
Mesurer la saturation, pas l’effort
Le CPU mesure l’effort. Il faut une métrique de charge ou de saturation. Trois sources sont utilisables :
| Signal | Ce qu’il mesure | Mise en place |
|---|---|---|
Requêtes par cible (ALB RequestCountPerTarget, CloudWatch) | La charge reçue par chaque pod, avant la saturation | La plus simple : la métrique existe déjà |
Page de statut PHP-FPM (pm.status_path) | Workers actifs, file d’attente, limite atteinte | Un exporter et une collecte Prometheus |
Apache mod_status | Workers occupés et libres | Un exporter et une collecte Prometheus |
La page de statut de PHP-FPM donne directement les bons indicateurs :
listen queue: 12
active processes: 10
total processes: 10
max children reached: 37
Une listen queue non nulle signifie que des requêtes attendent un worker. active processes égal au nombre total de workers signifie qu’il n’en reste aucun de libre. max children reached compte les fois où la limite a été atteinte depuis le démarrage. Ce sont ces chiffres qui annoncent les 503, bien avant le CPU.
Les requêtes par cible ont un autre avantage : elles montent dès que la charge arrive, donc l’autoscaler peut réagir avant que les workers soient pleins.
Brancher ces métriques sur l’autoscaler
Le HPA natif, alimenté par metrics-server, ne connaît que le CPU et la mémoire. Pour lui faire lire une autre métrique, il faut une couche de plus : KEDA, avec ses scalers CloudWatch ou Prometheus, ou prometheus-adapter. KEDA crée et pilote lui-même le HPA correspondant.
Exemple avec le scaler Prometheus de KEDA, sur l’occupation des workers PHP-FPM :
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: wordpress-front
spec:
scaleTargetRef:
name: wordpress-front
minReplicaCount: 2
maxReplicaCount: 10
triggers:
- type: prometheus
metadata:
serverAddress: http://prometheus.monitoring.svc:9090
# Nom de métrique à adapter à l’exporter PHP-FPM utilisé
query: sum(phpfpm_active_processes{app="wordpress-front"})
threshold: "7"
La requête renvoie le total des workers actifs. KEDA divise ce total par le threshold pour calculer le nombre de pods voulu. Avec 10 workers par pod, une cible de 7 garde une marge d’environ 30 % sur chaque pod.
KEDA est léger : quelques pods et peu de mémoire. Mais ce n’est pas une raison pour l’installer en premier.
Avant l’autoscaler, la cause
Ajouter des pods quand un backend est lent, c’est ajouter des workers qui vont attendre le même backend. Chaque nouveau pod se remplit aussi vite que les autres. Dans le pire cas, ces pods en plus envoient encore plus de requêtes au service déjà lent. L’autoscaling est un filet, pas la solution.
Soigner le symptôme
Ajouter des pods qui attendent le même backend
La file se vide un moment, puis se remplit à nouveau
L’autoscaler masque une dépendance circulaire
Traiter la cause
Un timeout court sur le proxy libère le worker
Le cache évite l’appel coûteux à la source
La dépendance est cassée, l’autoscaler reste un filet
Notre ordre de priorité :
- Échouer vite. Par défaut, Apache attend une réponse pendant 60 secondes. Un timeout court sur le proxy rend le worker au lieu de le garder bloqué une minute. Mieux vaut une erreur rapide sur un fragment de page qu’un site entier indisponible.
- Casser la dépendance ou mettre en cache. Dans notre cas, l’appel en boucle servait à construire un menu. Le mettre en cache a supprimé l’essentiel du trafic circulaire.
- Puis, si la saturation persiste, et si les métriques le prouvent, scaler sur l’occupation des workers avec KEDA.
Le CPU ment aussi dans d’autres cas
Le même biais existe ailleurs. Un service Node.js n’exécute son code que sur un seul cœur. Sur une tâche ou un pod de 2 vCPU, l’utilisation CPU plafonne donc vers 50 % alors que le service est déjà saturé. Un seuil d’autoscaling placé au-dessus ne se déclenche jamais.
Dans les deux cas, la question est la même : la métrique d’autoscaling monte-t-elle vraiment quand le service sature ? Si la réponse n’est pas évidente, rejouez un incident passé et regardez la courbe.
À retenir
- Des 5xx avec un CPU des pods proche de zéro signalent des workers saturés en attente, pas un manque de puissance.
- Suivez la file d’attente et les workers actifs de PHP-FPM ou d’Apache, ou les requêtes par pod.
- Le HPA natif ne lit pas ces métriques : KEDA ou prometheus-adapter sont nécessaires.
- Corrigez d’abord l’attente, avec un timeout court et du cache. L’autoscaling vient ensuite.
Nous mettons en place ces métriques et ces garde-fous dans nos missions d’observabilité et de SRE et d’exploitation Kubernetes. Votre autoscaling reste immobile pendant les incidents ? Parlons-en.