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.

Performance et scalabilité : les secrets de Kubernetes

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.

ClasseConditionComportement sous pression mémoire
Guaranteedrequests == limits sur CPU et mémoire, pour tous les conteneursÉvincé en dernier
BurstableAu moins un conteneur avec requests < limitsÉvincé selon l'usage au-dessus des requests
BestEffortAucun 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 -20

Ensuite, 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: 300

Les pannes que je vois le plus souvent, et leur correctif :

SymptômeCause probableCorrectif
Le HPA affiche <unknown>metrics-server absent ou en erreurVérifier l'APIService v1beta1.metrics.k8s.io
Scale-up alors que la charge est plateRequests trop bas : l'utilisation relative exploseRéaligner les requests sur le P95
Latence en dents de scie après scale-upPods comptés prêts avant d'avoir chargé leur cachestartupProbe + readiness honnête
Oscillation entre 3 et 8 réplicasFenêtre de descente trop courtestabilizationWindowSeconds: 300
Scale-up systématiquement en retardMétrique CPU moyennée sur 15 sMé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: 3

Un 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: api

Avec 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érificationCommandeSeuil attendu
Requests alignées sur le réelkubectl top pods + VPAP95 + 20 %
Throttling CPU maîtrisératio CFS throttled/periods< 1 % sur service sensible
HPA sur la bonne métriquekubectl get hpa -n prod50–75 % d'utilisation en régime stable
Pas de redémarrage en bouclekubectl get pods0 restart sur les dernières 24 h
Disruption budgétéekubectl get pdb -n prodminAvailable ≥ 2
Réplicas réellement disperséeskubectl get pods -o wide≥ 2 nœuds distincts
Latence suivie après chaque changementtableau SLOp99 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.