Performance et scalabilité : les secrets de Kubernetes
Requests, limits, HPA, VPA, probes : la méthode concrète pour rendre un déploiement Kubernetes rapide et scalable sans exploser la facture.
Trois réplicas sur un nœud de 4 vCPU, et l'API tombe à 300 ms de latence dès 40 requêtes par seconde. Le code n'a pas bougé d'une ligne : c'est le dimensionnement Kubernetes qui plafonne. Dans les clusters que j'audite, le goulot est presque toujours le même — des requests copiés-collés, un HPA branché sur la mauvaise métrique et des probes qui redémarrent des pods parfaitement sains.
Le scheduler ne devine rien : sans requests, il est aveugle
Un pod sans requests.cpu est compté à zéro par le scheduler. Il peut donc atterrir sur un nœud déjà plein, consommer quatre cœurs sur une machine qui en annonce deux, et faire tomber ses voisins par contention.
Le diagnostic prend dix secondes : kubectl describe node <nom> | grep -A6 "Allocated resources". Si la colonne Requests affiche 12 % pendant que tes graphes CPU montrent 70 %, tu as un problème de déclaration, pas de capacité.
Conséquence directe : le cluster autoscaler raisonne lui aussi sur les requests. Un nœud à moitié vide mais saturé en apparence déclenchera l'ajout de machines inutiles, facturées à l'heure.
Requests et limits : le couple qui décide de ta classe QoS
Kubernetes range chaque pod dans une des trois classes QoS, et cette classe décide qui se fait tuer en premier quand un nœud manque de mémoire. La règle complète est dans la documentation Pod QoS.
| Classe | Condition | Comportement sous pression mémoire |
|---|---|---|
| Guaranteed | requests == limits sur CPU et mémoire, pour tous les conteneurs | Évincé en dernier |
| Burstable | Au moins un conteneur avec requests < limits | Évincé selon l'usage au-dessus des requests |
| BestEffort | Aucun request ni limit | Évincé en premier |
Une limit CPU ne ralentit pas, elle hache
Le noyau applique un quota CFS par tranches de 100 ms. Avec limits.cpu: 200m, ton conteneur dispose de 20 ms de CPU par tranche, soit 200 ms de calcul par seconde.
Un pic de 25 ms suffit à saturer la tranche : le thread est gelé jusqu'à la suivante. Résultat, une latence p99 qui explose alors que le CPU moyen affiché reste à 30 %.
La métrique qui le prouve est container_cpu_cfs_throttled_seconds_total exposée par cAdvisor. Compare-la à container_cpu_cfs_periods_total : au-delà de quelques pourcents de périodes throttlées sur un service sensible à la latence, la limit est trop basse ou la charge trop bursty.
# ratio de throttling par conteneur sur les 30 dernières minutes
rate(container_cpu_cfs_throttled_periods_total[30m])
/ rate(container_cpu_cfs_periods_total[30m])Mon avis tranché : sur une API qui doit répondre en moins de 200 ms, je ne mets pas de limit CPU. Je garde un request réaliste et je surveille le throttling. La limit devient un coupe-circuit réservé aux charges batch et aux voisins bruyants.
La memory limit, elle, tue sans prévenir
Il n'existe pas de throttle mémoire : au-delà de la limit, le noyau déclenche un OOM-kill du conteneur. Le pod redémarre, kubectl get pods affiche OOMKilled et le compteur de restarts monte.
Les seuils d'éviction par défaut du kubelet (memory.available < 100Mi, nodefs.available < 10 %) sont calibrés pour des nœuds de test. Sur une machine de 64 Go, 100 Mi de marge est une plaisanterie.
Le détail des règles requests/limits et de leurs effets est documenté dans Manage Resources for Containers.
Dimensionne sur le P95 de sept jours, pas sur le pic de la démo
La méthode qui tient en production : collecter l'usage réel, prendre le P95, ajouter 20 à 30 % de marge, arrondir à la taille de pod la plus proche.
Commence par la photo instantanée, en triant par consommation :
kubectl top pods -n prod --containers --sort-by=cpu | head -20
kubectl top pods -n prod --containers --sort-by=memory | head -20Ensuite, laisse un VPA en mode observation calculer pour toi. Le recommender utilise jusqu'à huit jours d'historique et a besoin d'au moins 24 h de données pour produire une estimation crédible.
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
name: api-vpa
namespace: prod
spec:
targetRef:
apiVersion: apps/v1
kind: Deployment
name: api
updatePolicy:
updateMode: "Off"Avec updateMode: "Off", le VPA écrit ses chiffres dans status.recommendation sans redémarrer un seul pod. Tu lis, tu compares à ton manifeste, tu appliques à la main.
kubectl get vpa api-vpa -n prod -o jsonpath='{.status.recommendation.containerRecommendations[*]}'HPA : trois chiffres à relire avant de l'activer
Un HPA sur CPU calcule un ratio entre l'usage observé et la somme des requests du déploiement. Change les requests, et tu déplaces le point de déclenchement sans toucher une ligne au HPA.
Trois valeurs décident du comportement réel : minReplicas, la fenêtre de stabilisation descendante (300 s par défaut) et la période de synchronisation du contrôleur (15 s). Le fonctionnement exact est décrit dans la doc HPA.
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: api-hpa
namespace: prod
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: api
minReplicas: 3
maxReplicas: 20
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 65
behavior:
scaleUp:
stabilizationWindowSeconds: 30
policies:
- type: Percent
value: 100
periodSeconds: 30
scaleDown:
stabilizationWindowSeconds: 300Les pannes que je vois le plus souvent, et leur correctif :
| Symptôme | Cause probable | Correctif |
|---|---|---|
Le HPA affiche <unknown> | metrics-server absent ou en erreur | Vérifier l'APIService v1beta1.metrics.k8s.io |
| Scale-up alors que la charge est plate | Requests trop bas : l'utilisation relative explose | Réaligner les requests sur le P95 |
| Latence en dents de scie après scale-up | Pods comptés prêts avant d'avoir chargé leur cache | startupProbe + readiness honnête |
| Oscillation entre 3 et 8 réplicas | Fenêtre de descente trop courte | stabilizationWindowSeconds: 300 |
| Scale-up systématiquement en retard | Métrique CPU moyennée sur 15 s | Métrique custom : RPS, profondeur de file |
Ma règle : CPU pour un service qui calcule, requêtes par seconde ou taille de file pour un service qui attend des entrées-sorties. Un HPA sur CPU pour une API bloquée sur PostgreSQL ne scalera jamais au bon moment, parce que le CPU ne monte pas quand la base rame.
VPA et HPA sur la même métrique : la boucle qui n'en finit pas
Le VPA ajuste les requests, le HPA s'en sert comme dénominateur. Si les deux visent le CPU, chaque recommandation du VPA déplace le seuil du HPA, qui modifie la charge, qui change la recommandation.
Trois combinaisons tiennent en production. VPA sur la mémoire uniquement, avec HPA sur CPU. VPA en mode Initial, qui fixe les requests au démarrage sans y revenir. VPA en Off, utilisé comme outil de conseil.
En mode Auto ou Recreate, le VPA redémarre les pods pour appliquer une nouvelle request. Sur un service à trois réplicas et 60 s de démarrage, ça se remarque immédiatement. Le dépôt de référence est kubernetes/autoscaler.
Les probes sont un levier de scalabilité, pas un détail de santé
Une readiness qui répond 200 dès que le process écoute fait entrer du trafic dans un pod qui n'a pas fini de charger son cache. Le HPA compte alors des pods « prêts » qui ne servent à rien, et la latence moyenne se dégrade à chaque scale-up.
J'ai détaillé le diagnostic dans les enseignements des readiness probes. Ici, ne retiens que le dimensionnement.
startupProbe:
httpGet:
path: /healthz
port: 8080
periodSeconds: 3
failureThreshold: 30
readinessProbe:
httpGet:
path: /ready
port: 8080
periodSeconds: 5
timeoutSeconds: 2
failureThreshold: 2
livenessProbe:
httpGet:
path: /healthz
port: 8080
periodSeconds: 10
failureThreshold: 3Un démarrage de 90 s se couvre avec un startupProbe à 30 tentatives espacées de 3 s : la liveness ne commence à surveiller qu'après. Sans ce garde-fou, le conteneur se fait tuer en boucle pendant son initialisation.
Ajoute un preStop et un délai de grâce correct. Sinon, chaque scale-down coupe des connexions en vol, et les 502 apparaissent exactement au moment où la charge baisse.
terminationGracePeriodSeconds: 30
lifecycle:
preStop:
exec:
command: ["sh", "-c", "sleep 8"]Ce sleep laisse le temps au kube-proxy et à l'ingress de retirer le pod des endpoints avant que le process ne s'arrête.
Sortir l'état du pod est la vraie condition de la scalabilité
Un service qui garde ses sessions en mémoire se scale en apparence : dix pods, dix caches, et un utilisateur qui perd son panier une fois sur dix.
Le test est brutal et efficace. kubectl scale deploy/api --replicas=5, puis recharge la même session plusieurs fois de suite sur des connexions différentes. Si le comportement change, l'état est dans le pod.
Trois déplacements règlent la majorité des cas : sessions vers Redis, fichiers uploadés vers un bucket objet, verrous vers un mécanisme distribué. Pour les traitements par lots, SELECT ... FOR UPDATE SKIP LOCKED sur PostgreSQL suffit souvent à remplacer une file maison.
BEGIN;
SELECT id, payload FROM jobs
WHERE status = 'pending'
ORDER BY id
FOR UPDATE SKIP LOCKED
LIMIT 1;
UPDATE jobs SET status = 'running' WHERE id = $1;
COMMIT;Chaque worker prend une ligne différente sans se marcher dessus. Tu peux alors passer de 1 à 20 réplicas sans coordination applicative.
La topologie réseau que personne ne regarde avant la facture
Deux pods du même service sur le même nœud échangent en local. Répartis sur deux zones de disponibilité, chaque appel traverse le réseau de l'infrastructure — et se facture au gigaoctet chez tous les grands fournisseurs.
topologySpreadConstraints remplace un podAntiAffinity rigide et tolère une zone en maintenance, comme expliqué dans la doc Topology Spread Constraints.
topologySpreadConstraints:
- maxSkew: 1
topologyKey: topology.kubernetes.io/zone
whenUnsatisfiable: ScheduleAnyway
labelSelector:
matchLabels:
app: apiAvec ScheduleAnyway, le scheduler équilibre sans bloquer un déploiement quand une zone tombe. Avec DoNotSchedule, tu obtiens une garantie stricte mais un déploiement bloqué dès qu'un nœud manque.
Le corollaire coûteux : un service bavard qui appelle la base 40 fois par requête utilisateur double sa facture réseau en passant de une à trois zones. Mesure avant de répartir.
La checklist que je passe avant chaque mise en prod
| Vérification | Commande | Seuil attendu |
|---|---|---|
| Requests alignées sur le réel | kubectl top pods + VPA | P95 + 20 % |
| Throttling CPU maîtrisé | ratio CFS throttled/periods | < 1 % sur service sensible |
| HPA sur la bonne métrique | kubectl get hpa -n prod | 50–75 % d'utilisation en régime stable |
| Pas de redémarrage en boucle | kubectl get pods | 0 restart sur les dernières 24 h |
| Disruption budgétée | kubectl get pdb -n prod | minAvailable ≥ 2 |
| Réplicas réellement dispersées | kubectl get pods -o wide | ≥ 2 nœuds distincts |
| Latence suivie après chaque changement | tableau SLO | p99 sous le budget d'erreur |
Un dernier point qui revient souvent : les tableaux de bord de SLA. J'en parle dans les alternatives au monitoring, parce qu'un HPA bien réglé sans mesure de latence revient à conduire phares éteints.
FAQ
Pourquoi mon HPA reste-t-il à <unknown> ? Le contrôleur n'arrive pas à lire les métriques. Vérifie que metrics-server tourne, que l'APIService v1beta1.metrics.k8s.io est Available et que kubectl top pods répond.
Faut-il une limit mémoire égale au request ? Sur un service critique, oui pour la mémoire : tu obtiens un pod Guaranteed pour ce conteneur et un comportement prévisible. Sur un batch qui peut gonfler, garde une limit plus haute et accepte le risque d'OOM-kill.
Combien de réplicas minimum pour un service critique ? Trois, réparties sur au moins deux zones, avec un PDB à minAvailable: 2. Deux réplicas tombent ensemble dès qu'un nœud redémarre pendant un drain.
HPA ou KEDA ? HPA suffit quand ta charge se traduit en CPU ou en mémoire. Dès qu'il faut scaler sur une file (SQS, RabbitMQ), sur des événements Cron ou jusqu'à zéro, KEDA fait le travail que le HPA ne sait pas exprimer.