Déploiement de Kubernetes en production
Six chantiers séparent un cluster qui démarre d'une plateforme qui tient la charge. Voici la check-list, avec le code et les calculs.
Ton cluster de staging tourne depuis six mois sans un incident. Le jour de la bascule, un pic à 400 requêtes par seconde fait redémarrer trois pods sur cinq, et l'API renvoie des 502 pendant onze minutes. La cause n'est pas le code : personne n'avait déclaré de requests, et le kubelet a commencé à évincer des pods dès que le nœud a saturé.
Kubernetes en production, ce n'est pas un kubectl apply de plus. C'est six chantiers qui n'ont rien à voir avec le développement applicatif, et qui décident si ta plateforme tient un mardi à 3 h du matin.
Les six chantiers d'un cluster qui doit tenir la charge
Voici la liste que je vérifie avant d'ouvrir le trafic public. Chaque ligne correspond à une panne que j'ai déjà vue en conditions réelles.
| Chantier | Ce qui casse sans lui | Effort réel |
|---|---|---|
| Plan de contrôle en haute dispo | API server unique : chaque mise à jour du cluster coupe le service 20 à 40 min | 2 h |
| Sauvegarde etcd testée | Une corruption du store et tu reconstruis tout à la main | 1 h + un test par trimestre |
requests / limits | Évictions et OOMKill au premier pic de charge | 3 h de mesure |
| Probes correctement réglées | Trafic routé vers des pods qui ne savent pas encore répondre | 1 h |
| Stratégie de déploiement + budget | 100 % des réplicas indisponibles pendant un rollout | 1 h |
| Observabilité minimale | Tu apprends la panne par un client mécontent | 4 h |
Les quatre premières heures de travail sur cette liste rapportent plus que trois semaines de fonctionnalités. Le reste peut attendre.
Erreur 1 — Confondre un cluster qui démarre avec un cluster qui sert
kubeadm init sur une seule machine te donne un cluster fonctionnel, pas une plateforme de production. Sans second plan de contrôle, la moindre montée de version de l'API server est une interruption planifiée que tu ne peux pas planifier.
Le minimum défendable : trois nœuds de contrôle, etcd sur un disque dédié (SSD NVMe, latence d'écriture sous 10 ms), et un endpoint stable devant l'API. Si tu remplaces un nœud, les certificats doivent survivre — d'où l'option --upload-certs.
# Premier nœud de contrôle, derrière un VIP ou un load balancer TCP
kubeadm init \
--control-plane-endpoint "k8s-api.exemple.fr:6443" \
--upload-certs \
--pod-network-cidr "10.244.0.0/16"
# Les deux suivants : la clé de certificat est valable 2 h
kubeadm join k8s-api.exemple.fr:6443 \
--token <token> \
--discovery-token-ca-cert-hash sha256:<hash> \
--control-plane \
--certificate-key <certificate-key>Trois nœuds de contrôle, c'est aussi le minimum pour qu'etcd garde son quorum après la perte d'une machine. Avec deux nœuds, tu perds l'écriture dès qu'un seul tombe : un quorum de 1 sur 1 est pire que pas de cluster du tout.
La procédure officielle de création de cluster avec kubeadm détaille l'ordre des opérations, notamment le rôle du CNI avant le join des workers.
Erreur 2 — Déployer sans requests, puis s'étonner des OOMKill
Un pod sans requests est un pod que le scheduler place au hasard. Le nœud le plus chargé est aussi crédible que le plus vide, et tu te retrouves avec trois réplicas empilés sur la même machine physique.
La règle que j'applique : mesurer le RSS au p95 sur 48 h de trafic réaliste, poser un request légèrement au-dessus, et un limit mémoire à 1,5 fois cette valeur. Pour le CPU, je pose un request et je laisse le limit absent ou très large, parce qu'un throttle CPU se traduit directement en latence.
apiVersion: apps/v1
kind: Deployment
metadata:
name: api-paiement
spec:
replicas: 4
template:
spec:
containers:
- name: api
image: registry.exemple.fr/api-paiement:2.14.3@sha256:9f2c…
resources:
requests:
cpu: 250m
memory: 512Mi
limits:
memory: 768Mi # 1,5 x RSS p95 mesuré
ports:
- containerPort: 8080Un limit mémoire est une sentence de mort : le noyau tue le processus, le pod redémarre, et tu perds les connexions en cours. À l'inverse, un limit CPU trop bas produit des pics de latence à 40 ms de throttling sur des requêtes qui prenaient 8 ms. Retirer le limit CPU et garder le request règle 90 % des cas.
| Classe QoS | Condition | Comportement sous pression |
|---|---|---|
| Guaranteed | requests = limits sur CPU et mémoire | Évincé en dernier, aucune marge de burst |
| Burstable | requests < limits | Burst possible, évincé après les BestEffort |
| BestEffort | Aucune ressource déclarée | Premier évincé, aucune garantie de placement |
Le détail des calculs d'allocation est dans la documentation sur la gestion des ressources des conteneurs. Lis-la une fois avec un vrai pod devant les yeux, pas en survol.
Erreur 3 — Des probes copiées d'un tutoriel de 2019
Une livenessProbe qui interroge la base de données est le meilleur moyen de transformer une latence PostgreSQL en redémarrage généralisé. La liveness doit répondre à une seule question : ce processus est-il encore capable de servir ? Si la réponse est « je ne sais pas », le redémarrage n'aidera pas.
Le trio qui marche : startupProbe pour laisser le temps au démarrage (migrations, cache froid), readinessProbe pour retirer le pod du service, livenessProbe très permissive en dernier recours.
startupProbe:
httpGet: { path: /healthz, port: 8080 }
periodSeconds: 5
failureThreshold: 24 # tolérance : 120 s de démarrage
readinessProbe:
httpGet: { path: /ready, port: 8080 }
periodSeconds: 3
timeoutSeconds: 2
failureThreshold: 2
livenessProbe:
httpGet: { path: /healthz, port: 8080 }
periodSeconds: 10
failureThreshold: 6 # ~60 s avant redémarrage
terminationGracePeriodSeconds: 40Fais le calcul à chaque fois : periodSeconds × failureThreshold = temps maximum avant que Kubernetes agisse. Un failureThreshold: 3 avec periodSeconds: 10 te donne 30 s, ce qui est déjà trop long pour une probe de readiness sur une API à 200 ms de latence.
Le terminationGracePeriodSeconds à 40 s n'est pas décoratif : le pod reçoit SIGTERM, mais il reste dans les endpoints jusqu'à ce que le contrôleur et le load balancer se resynchronisent. Sans un petit sleep en preStop, tu perds les requêtes arrivées dans cette fenêtre.
Erreur 4 — Un rolling update sans budget de disruption
La stratégie par défaut (maxSurge: 25 %, maxUnavailable: 25 %) fait tomber un réplica sur quatre à chaque déploiement. Sur un service à quatre réplicas, tu acceptes de servir avec trois pendant tout le rollout, et avec deux si la nouvelle version met du temps à démarrer.
Pour un service critique, je passe à maxUnavailable: 0 et maxSurge: 1. Coût : le rollout prend plus longtemps et demande un nœud de marge. Bénéfice : aucune requête servie par moins de réplicas qu'avant.
spec:
strategy:
type: RollingUpdate
rollingUpdate:
maxUnavailable: 0
maxSurge: 1
minReadySeconds: 15 # un pod doit tenir 15 s avant d'être compté prêtAttention à une confusion répandue : un PodDisruptionBudget ne protège pas d'un rolling update. Il ne s'applique qu'aux évictions volontaires — kubectl drain, mise à jour d'un nœud, déschedule. Pour un rollout, c'est maxUnavailable qui décide.
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
name: api-paiement
spec:
minAvailable: 3
selector:
matchLabels:
app: api-paiementLes deux se complètent : le PDB garantit que kubectl drain attendra sagement, la stratégie garantit que le Deployment ne descendra pas trop bas. Si tu veux comparer les approches de bascule, mon article sur les stratégies blue-green et canary détaille quand un rollout progressif vaut mieux qu'un simple remplacement.
Erreur 5 — Des secrets en base64 et des images en :latest
Un Secret Kubernetes est encodé, pas chiffré. Quiconque a le droit de lire le namespace lit tes mots de passe en clair avec une commande. Deux mesures valent le détour : activer le chiffrement au repos dans etcd, et séparer les secrets du dépôt Git qui décrit les manifests.
Côté images, :latest en production est un pari sur l'avenir. Un pod redémarré peut tirer une version différente de celle qui tourne à côté de lui. Épingle par digest — c'est la seule référence immuable — et laisse la traçabilité au pipeline CI.
Le chiffrement au repos se configure côté API server, via un fichier EncryptionConfiguration référencé par --encryption-provider-config, puis une réécriture de tous les secrets existants pour qu'ils soient effectivement chiffrés. Les secrets doivent être relus puis réécrits : la clé ne s'applique qu'aux nouvelles écritures. Pour la gestion des secrets à proprement parler, l'article sur les secrets Kubernetes et la productivité couvre les alternatives externalisées.
Erreur 6 — Exposer directement, sans ingress controller ni TLS géré
Un Service en type: LoadBalancer par application, c'est un load balancer cloud facturé à l'heure pour chaque service, et des certificats à renouveler à la main. Un ingress controller unique règle le routage, la terminaison TLS et le rate limiting au même endroit.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: api-paiement
annotations:
cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
ingressClassName: nginx
tls:
- hosts: [api.exemple.fr]
secretName: api-exemple-tls
rules:
- host: api.exemple.fr
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: api-paiement
port:
number: 8080Avec cert-manager et un ClusterIssuer Let's Encrypt, le renouvellement devient un problème résolu. La mise en place complète est décrite dans mon guide pour implémenter les Ingress dans tes projets Kubernetes.
Sauvegarder etcd, parce que c'est le seul point de non-retour
Tout l'état du cluster vit dans etcd : les objets, les secrets chiffrés, les ServiceAccounts. Perdre etcd, c'est perdre la cartographie de ce qui tourne. Un snapshot toutes les six heures est le strict minimum, et un snapshot que tu n'as jamais restauré ne compte pas comme une sauvegarde.
ETCDCTL_API=3 etcdctl snapshot save /var/backups/etcd-$(date +%F-%H%M).db \
--endpoints=https://127.0.0.1:2379 \
--cacert=/etc/kubernetes/pki/etcd/ca.crt \
--cert=/etc/kubernetes/pki/etcd/server.crt \
--key=/etc/kubernetes/pki/etcd/server.key
ETCDCTL_API=3 etcdctl snapshot status /var/backups/etcd-$(date +%F-%H%M).dbLe snapshot status te donne la taille et le nombre de clés : c'est le contrôle qui détecte un fichier vide ou tronqué. Programme la restauration une fois par trimestre sur un cluster jetable, sinon tu découvriras le problème le jour où tu en auras besoin. La procédure officielle est documentée dans la sauvegarde et la restauration d'etcd.
Ordre de mise à jour à retenir : etcd d'abord, puis les nœuds de contrôle un par un, puis les workers. Jamais de saut de version mineure, et jamais deux nœuds de contrôle en même temps hors de la fenêtre de maintenance.
Le jour J : ordre de bascule
- Vérifier la santé du plan de contrôle :
kubectl get --raw='/readyz?verbose'etkubectl get nodes -o wide. Un nœud enNotReadydisqualifie la bascule. - Snapshot etcd juste avant, et vérifier sa taille. C'est ton point de retour arrière.
- Tester un drain sur un worker non critique :
kubectl drain --ignore-daemonsets --delete-emptydir-data. Si les pods ne se replacent pas, tu ne sais pas encore faire de maintenance. - Vérifier les probes sur un pod réel :
kubectl describe poddoit montrer trois probes vertes et un nombre de redémarrages à zéro. - Basculer 5 % du trafic via le poids de l'ingress ou du DNS, observer 15 min, puis monter par paliers de 25 %.
- Surveiller les signaux utiles : latence p99, taux de 5xx, redémarrages de conteneurs, saturation mémoire des nœuds. Pas le CPU moyen, qui ne dit rien.
Le palier à 5 % attrape la majorité des erreurs de configuration — mauvais port, secret manquant, règle d'affinité impossible — sans exposer l'ensemble de tes utilisateurs.
Ce que je ferais différemment aujourd'hui
Pour une équipe de deux ou trois développeurs, je ne self-host plus le plan de contrôle. Le coût caché n'est pas l'installation, c'est l'astreinte : un upgrade tous les trois mois, un etcd à surveiller, des certificats qui expirent à 1 an. Un cluster managé coûte quelques dizaines d'euros par mois et supprime cette charge.
En revanche, pour une équipe plateforme existante avec des contraintes de souveraineté ou de coût à l'échelle, kubeadm reste parfaitement défendable. La vraie erreur est de choisir par principe plutôt que par capacité d'exploitation. Et avant tout ça : si tu as trois microservices, Kubernetes est probablement surdimensionné — l'article sur l'intégration de Terraform dans une stack existante montre comment garder l'infra déclarative sans imposer un orchestrateur à toute l'équipe.
FAQ
Combien de nœuds faut-il au minimum en production ?
Trois nœuds de contrôle et trois workers, ou trois workers seulement si le plan de contrôle est managé. En dessous, tu n'as pas de quorum etcd ni de marge pour un drain sans interruption.
Faut-il un service mesh dès le premier jour ?
Non. Un ingress controller, des probes correctes et de la télémétrie couvrent 80 % des besoins. Le mesh devient utile quand tu veux du mTLS systématique, du retry par service ou du trafic splitting fin — pas avant.
Comment valider la montée en charge avant la bascule ?
Rejoue le trafic réel avec k6 ou Locust sur un environnement de préproduction de même dimension, et regarde les évictions plutôt que le CPU. Si un nœud commence à évincer des pods à 70 % de charge simulée, ta marge réelle est nulle.
Kubernetes est-il rentable pour trois services ?
Rarement. Le temps d'exploitation dépasse l'économie de mutualisation. Docker Compose ou un PaaS managé fait le travail pour un dixième de la complexité.