Les secrets Kubernetes avancés : techniques et astuces d'experts

Ton cluster tourne, mais tient-il un pic de trafic ? Sept réglages YAML qui séparent un cluster de démo d'une plateforme stable.

Les secrets Kubernetes avancés : techniques et astuces d'experts

Ton cluster tourne, tes pods sont verts, et pourtant ta dernière mise en production a mis quarante minutes à revenir en arrière. Le coupable n'est presque jamais Kubernetes lui-même. Dans la majorité des audits que je mène, je retrouve les mêmes lignes de YAML copiées d'un tutoriel de 2019 : requests: 100m, les mêmes limits, aucune probe.

Un manifest qui passe la revue de code n'est pas un manifest qui survit à une montée de trafic. Kubernetes accepte sans broncher un pod qui demande 100 millicores et qui en consomme 900 en pic. Le scheduler empile alors quinze réplicas sur un nœud de 4 vCPU, le kubelet étrangle les conteneurs, et l'autoscaler ne voit rien venir.

Voici les sept réglages qui font la différence entre un cluster de démo et une plateforme qui encaisse un pic sans que personne ne soit réveillé.

Requests et limits : arrête de coller les mêmes valeurs partout

Les requests ne sont pas une recommandation polie, c'est le contrat que tu signes avec le scheduler. Un pod qui demande 100m réserve 100m, même s'il consomme un demi-cœur. Ton nœud est plein à 20 % et refuse pourtant de nouvelles réplicas.

Le second réglage qui coûte cher, c'est la limit CPU. Poser limit: 500m sur une API Java active le CFS throttling : le conteneur se fait geler par tranches de 100 ms et la latence p99 explose alors que le CPU du nœud est à 30 %.

La règle que j'applique : une limit mémoire, jamais de limit CPU sur les services sensibles à la latence.

resources:
  requests:
    cpu: "500m"
    memory: "512Mi"
  limits:
    memory: "768Mi"
    # pas de limit cpu : on laisse le nœud arbitrer

Le ratio 512Mi/768Mi n'est pas décoratif. Un dépassement de la limit mémoire tue le conteneur avec un OOMKilled, alors qu'un dépassement de request le laisse respirer tant que le nœud a de la marge. Cette asymétrie est exactement celle que tu veux.

Pour mesurer l'écart entre ce que tu déclares et ce que tu consommes vraiment, un seul chiffre suffit :

kubectl get pods -A -o json | jq -r '
  .items[] | [.metadata.namespace, .metadata.name,
  (.spec.containers[0].resources.requests.cpu // "none"),
  (.status.containerStatuses[0].state.running != null | tostring)] | @tsv' | head

Compare cette sortie avec ce que renvoie kubectl top pods sur deux semaines. Si l'écart dépasse 3× de façon stable, tu sur-réserve et tu paies des nœuds vides.

Comprendre les classes QoS avant de toucher au reste

Kubernetes classe chaque pod dans l'une des trois catégories de QoS, et cette classe décide de qui se fait tuer le premier quand un nœud manque de mémoire.

ClasseConditionComportement sous pression
Guaranteedrequests = limits sur CPU et mémoire, tous les conteneursÉviction en dernier recours
Burstablerequests < limits, ou requests seulsÉviction selon l'usage au-dessus de la request
BestEffortAucune request, aucune limitÉviction en premier

Conséquence pratique : tes workloads d'arrière-plan (cron, workers batch) doivent rester en Burstable, et tes bases de données en Guaranteed. Mettre tout en Guaranteed coûte 40 % de facture en plus pour rien.

HPA : trois réglages qui empêchent les oscillations

Un HPA brut sur CPU a un défaut connu et systématiquement oublié : il monte vite et redescend immédiatement, ce qui crée des allers-retours de pods et des connexions coupées.

Par défaut, la fenêtre de stabilisation descendante est de 300 secondes, mais le moindre déploiement qui écrase ton manifest la remet à zéro. Écris-la explicitement :

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-gateway
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-gateway
  minReplicas: 3
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 30
      policies:
        - type: Percent
          value: 100
          periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: 600
      policies:
        - type: Pods
          value: 1
          periodSeconds: 120

Le scaleDown à un pod toutes les deux minutes évite l'effet yoyo. Le scaleUp à 100 % par minute te donne une réponse rapide sans créer de tempête de création de pods.

Deuxième piège : la cible d'utilisation CPU est calculée en pourcentage des requests. Si tes requests sont à 100m alors que ton service consomme 60m au repos, ton HPA considère déjà être à 60 % et scale pour rien. Aligne tes requests sur la réalité avant de toucher aux seuils.

Troisième piège : un HPA sur CPU ne réagit pas à une file d'attente saturée si le service attend en I/O. Pour ça, il faut une métrique métier, on y revient plus bas.

PDB et topologySpreadConstraints : la haute dispo qui tient vraiment

Une réplica sur trois nœuds du même datacenter n'est pas de la haute disponibilité, c'est de la chance. topologySpreadConstraints force le scheduler à répartir tes pods par zone :

topologySpreadConstraints:
  - maxSkew: 1
    topologyKey: topology.kubernetes.io/zone
    whenUnsatisfiable: DoNotSchedule
    labelSelector:
      matchLabels:
        app: api-gateway

Avec DoNotSchedule, un pod reste en Pending plutôt que d'accepter un déséquilibre. C'est brutal, mais c'est exactement le comportement que tu veux pour un service critique.

Le PodDisruptionBudget vient compléter le tableau, et c'est là que je vois le plus d'erreurs. Un PDB en minAvailable: 3 sur un deployment à 3 réplicas bloque définitivement tout drain de nœud : le rolling update de ton cluster reste suspendu jusqu'à ce que quelqu'un le remarque, souvent des semaines plus tard.

La bonne formulation, c'est de raisonner en pods indisponibles autorisés :

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: api-gateway
spec:
  maxUnavailable: 1
  selector:
    matchLabels:
      app: api-gateway

Ce réglage garantit qu'un drain peut toujours avancer d'un pod à la fois. Pour les workloads à état, ce raisonnement change : sur un StatefulSet avec volumes persistants, la disponibilité se joue au niveau du storage, et j'ai détaillé ce point dans l'article sur les volumes persistants.

NetworkPolicy en default-deny, sans casser le DNS

Par défaut, tous les pods d'un cluster communiquent entre eux. Une seule image compromise peut alors scanner l'ensemble du réseau interne. La parade tient en un objet :

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: production
spec:
  podSelector: {}
  policyTypes:
    - Ingress
    - Egress

Applique-la dans un namespace de test avant la production, parce qu'elle coupe tout, y compris la résolution DNS. Le symptôme classique est un service qui répond en 200 sur /healthz et qui échoue sur chaque appel sortant avec un no such host.

Il faut donc rouvrir explicitement le DNS et les flux légitimes :

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns-egress
  namespace: production
spec:
  podSelector: {}
  policyTypes:
    - Egress
  egress:
    - to:
        - namespaceSelector:
            matchLabels:
              kubernetes.io/metadata.name: kube-system
      ports:
        - protocol: UDP
          port: 53
        - protocol: TCP
          port: 53

Le champ kubernetes.io/metadata.name est posé automatiquement par le control plane depuis la 1.21, pas besoin de labelliser kube-system à la main. C'est le détail qui fait perdre une demi-journée à ceux qui suivent un tutoriel plus ancien.

Note au passage : NetworkPolicy n'a d'effet que si ton CNI l'implémente. Sur un cluster monté en Flannel nu, tu appliqueras ces objets sans aucun effet, sans aucun message d'erreur.

KEDA : scaler sur ce qui compte vraiment

Un HPA sur CPU ne voit pas une file RabbitMQ qui grossit alors que le CPU reste à 15 % parce que les consumers attendent des acknowledgements. KEDA comble ce trou en branchant l'autoscaler sur des métriques externes.

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: worker-import
spec:
  scaleTargetRef:
    name: worker-import
  minReplicaCount: 1
  maxReplicaCount: 30
  cooldownPeriod: 180
  triggers:
    - type: rabbitmq
      metadata:
        protocol: amqp
        queueName: imports
        mode: QueueLength
        value: "50"
      authenticationRef:
        name: rabbitmq-auth

La valeur 50 signifie un pod par tranche de cinquante messages en attente. Avec un cooldownPeriod à 180 secondes, tu évites de détruire des workers entre deux lots.

Le piège de KEDA, c'est la remise à zéro : en minReplicaCount: 0, ton service est complètement éteint et le premier appel du matin paie le démarrage à froid. Garde au moins une réplica pour tout ce qui est exposé à un utilisateur.

La documentation officielle de KEDA 2.16 liste les quelque soixante scalers disponibles, de Kafka à CloudWatch en passant par Prometheus.

Les pièges qui coûtent une nuit blanche

Ces cinq points reviennent dans presque tous les incidents que je traite, et aucun ne se voit dans un kubectl get pods.

  • Pas de readiness probe : le pod reçoit du trafic avant d'être prêt et renvoie des 502 pendant trente secondes à chaque déploiement.
  • Une liveness probe identique à la readiness : quand la base de données ralentit, le kubelet redémarre tous tes pods en boucle et aggrave la panne.
  • Pas de startupProbe sur une application lente à démarrer : la liveness tue le conteneur avant la fin du warm-up.
  • preStop sans terminationGracePeriodSeconds : le pod est retiré des endpoints et tué dans la même seconde, les requêtes en vol sont perdues.
  • imagePullPolicy: Always sur un tag immuable : un latest écrasé côté registry rend tes rollbacks imprévisibles.

Le correctif du quatrième point tient en deux blocs, et c'est celui que je vérifie en premier :

spec:
  terminationGracePeriodSeconds: 45
  containers:
    - name: api
      lifecycle:
        preStop:
          exec:
            command: ["sh", "-c", "sleep 10"]

Les dix secondes de preStop laissent le temps au Service de retirer l'endpoint avant que le conteneur ne s'arrête. Sans ça, chaque déploiement produit une poignée d'erreurs 502 côté utilisateurs.

Côté livraison, la même logique s'applique aux canary deploys : j'ai détaillé les APIs à brancher dans le guide des APIs pour canary deploys, et les idées reçues qui font rater ces migrations dans les mythes des déploiements en production.

Questions qu'on me pose en audit

Faut-il toujours mettre une limit mémoire ?

Oui pour tout ce qui tourne en production avec plusieurs réplicas. Une limit mémoire évite qu'une fuite de mémoire dans un conteneur emporte le nœud entier et provoque des évictions en cascade. Le prix est un OOMKilled : surveille container_memory_working_set_bytes pour calibrer.

Guaranteed partout, c'est plus sûr ?

Non. Tu réserves la totalité de la mémoire déclarée même quand le pod en utilise le tiers, et le scheduler refuse des pods sur des nœuds à moitié vides. Réserve Guaranteed à ce qui ne peut pas être évincé : bases de données, Ingress controller, DNS.

NetworkPolicy default-deny, ça casse les readiness probes ?

Le kubelet joint le pod depuis le nœud, et ce trafic n'est pas filtré par les NetworkPolicy de la même manière que le trafic pod-à-pod selon ton CNI. Teste toujours dans un namespace de préproduction avant de basculer la production.

Comment détecter un HPA mal calibré ?

Regarde le ratio entre kube_horizontalpodautoscaler_status_current_replicas et la consommation CPU réelle. Si les réplicas bougent mais que le CPU moyen ne descend pas, tes requests sont trop basses et la cible est inatteignable.

Ce que tu peux appliquer ce soir

Trois changements, une heure de travail, et ton cluster devient nettement plus prévisible. D'abord, remesure les requests sur les cinq services les plus critiques à partir de kubectl top sur sept jours. Ensuite, retire les limits CPU des services sensibles à la latence. Enfin, ajoute un maxUnavailable: 1 sur chaque PDB et vérifie qu'un kubectl drain --dry-run passe.

Le reste, HPA fin, KEDA, NetworkPolicy, se fait service par service, sans big bang. Les références utiles pour creuser : la page sur l'autoscaling horizontal, celle sur les interruptions de pods, et les standards de sécurité de pods.