E-NO
Kubernetes 7 min de lecture

Optimisation des performances de l'architecture Kubernetes avec exemples pratiques

calendar_today Publié : 2026-11-17
update Dernière mise à jour : 2026-11-17
analytics Efficacité SEO : 100%
Illustration du guide technique pour « Optimisation des performances de l'architecture Kubernetes avec exemples pratiques ».

Introduction

Kubernetes est devenu le standard de facto pour l'orchestration de conteneurs, mais à mesure que les clusters grandissent et que les charges de travail deviennent plus exigeantes, des goulots d'étranglement de performance peuvent apparaître. Ces goulots d'étranglement se manifestent souvent par des réponses API lentes, des délais d'ordonnancement, une latence réseau ou une contention des ressources. L'optimisation de l'architecture Kubernetes elle-même – et pas seulement des applications qui y tournent – est essentielle pour maintenir la fiabilité et l'efficacité.

Cet article fournit un guide pratique pour identifier et résoudre les problèmes de performance courants de Kubernetes. Nous verrons comment inventorier votre cluster, effectuer des modifications de configuration en toute sécurité, vérifier l'impact et récupérer en cas de problème. L'objectif est de vous aider à passer d'un dépannage réactif à une optimisation proactive avec des commandes et des exemples concrets.

Inventaire des versions et de l'environnement

Avant toute modification, vous devez établir une image claire de votre environnement Kubernetes. Cela inclut les versions exactes des composants du plan de contrôle et des nœuds, la topologie du cluster et les prérequis pour l'optimisation.

Vérifier la version du cluster et des composants

Commencez par vérifier la version du plan de contrôle Kubernetes et des nœuds. Utilisez kubectl version pour voir à la fois les versions client et serveur :

kubectl version --short

La sortie attendue doit montrer la version du serveur, par exemple :

Client Version: v1.21.0
Server Version: v1.21.0

Si vous avez accès au nœud du plan de contrôle, vous pouvez également vérifier les versions des composants individuels en examinant les processus en cours d'exécution ou leurs images de conteneur. Par exemple, pour le serveur API :

kubectl get pods -n kube-system -l component=kube-apiserver -o jsonpath='{.items[0].spec.containers[0].image}'

Cela affichera le tag de l'image, tel que :

k8s.gcr.io/kube-apiserver:v1.21.0

Comprendre la topologie

Documentez la topologie : combien de nœuds maîtres et de nœuds travailleurs, leurs rôles et toute configuration de haute disponibilité. Utilisez kubectl get nodes avec l'option -o wide pour voir les adresses IP, le système d'exploitation et les versions du runtime de conteneur :

kubectl get nodes -o wide

Exemple de sortie :

NAME       STATUS   ROLES                  AGE   VERSION   INTERNAL-IP   EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION      CONTAINER-RUNTIME
master-1   Ready    control-plane,master   30d   v1.21.0   10.0.0.1      <none>        Ubuntu 20.04.2 LTS   5.4.0-72-generic   docker://20.10.7
worker-1   Ready    <none>                 30d   v1.21.0   10.0.0.2      <none>        Ubuntu 20.04.2 LTS   5.4.0-72-generic   docker://20.10.7
worker-2   Ready    <none>                 30d   v1.21.0   10.0.0.3      <none>        Ubuntu 20.04.2 LTS   5.4.0-72-generic   docker://20.10.7

Vérifier les prérequis

Assurez-vous d'avoir les autorisations nécessaires pour effectuer des modifications. Vous devez disposer du rôle cluster-admin ou au moins d'un accès en écriture aux configurations que vous prévoyez de modifier. Confirmez également que etcd est en bonne santé, car il est central pour les performances de Kubernetes. Sur un nœud du plan de contrôle avec etcdctl installé, vous pouvez vérifier la santé :

ETCDCTL_API=3 etcdctl --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 \
  endpoint health

La sortie attendue indique que chaque endpoint est en bonne santé :

https://127.0.0.1:2379 is healthy: successfully committed proposal: took = 2.1ms

Si l'un de ces contrôles révèle des problèmes, résolvez-les avant de procéder à l'optimisation.

Question rapide 1 sur 2

Quels sont deux paramètres clés pour le réglage du serveur API ?

L'article indique que les paramètres clés pour le réglage du serveur API sont --max-requests-inflight et --max-mutating-requests-inflight, qui limitent les requêtes simultanées en lecture et en écriture.

Chemin de configuration sûr

Apporter directement des modifications à un cluster en cours d'exécution peut être risqué. L'approche sûre consiste à effectuer des modifications ciblées et réversibles une à la fois, idéalement dans un environnement de test d'abord. Cette section décrit les domaines d'optimisation courants et comment les ajuster en toute sécurité.

Optimisation du serveur API

Le serveur API est le point d'entrée de toutes les opérations Kubernetes. Les problèmes courants incluent la latence des requêtes sous charge et une utilisation excessive de la mémoire. Les paramètres clés à considérer sont --max-requests-inflight et --max-mutating-requests-inflight, qui limitent respectivement le nombre de requêtes de lecture et d'écriture simultanées. Augmenter ces valeurs peut améliorer le débit si le serveur API a du CPU et de la mémoire disponibles, mais une valeur trop élevée peut le submerger.

Pour les modifier, vous éditez généralement le manifeste du serveur API sur le nœud du plan de contrôle. Pour un cluster kubeadm, le fichier est généralement /etc/kubernetes/manifests/kube-apiserver.yaml. Ajoutez ou modifiez la spécification du conteneur :

spec:
  containers:
  - command:
    - kube-apiserver
    - --max-requests-inflight=400
    - --max-mutating-requests-inflight=200

Après l'enregistrement, le kubelet redémarrera automatiquement le serveur API. Vérifiez les nouveaux arguments du processus avec :

ps aux | grep kube-apiserver | grep max-requests-inflight

La sortie attendue inclut les nouvelles valeurs.

Optimisation du contrôleur de gestion et du planificateur

Le gestionnaire de contrôleurs et le planificateur s'exécutent comme des pods statiques. Leurs performances peuvent être ajustées en modifiant les drapeaux --kube-api-qps et --kube-api-burst, qui contrôlent la fréquence des requêtes API qu'ils effectuent. Augmenter ces valeurs peut accélérer la réconciliation mais augmente également la charge sur le serveur API. Par exemple, dans le manifeste du gestionnaire de contrôleurs (/etc/kubernetes/manifests/kube-controller-manager.yaml), vous pouvez ajouter :

spec:
  containers:
  - command:
    - kube-controller-manager
    - --kube-api-qps=50
    - --kube-api-burst=100

De même pour le planificateur dans /etc/kubernetes/manifests/kube-scheduler.yaml.

Optimisation du kubelet

Le kubelet sur chaque nœud gère les cycles de vie des pods. L'ajustement de son paramètre --max-pods peut aider si vous avez de nombreux petits pods. La valeur par défaut est de 110 pods par nœud. Si vos nœuds disposent de ressources suffisantes, vous pouvez l'augmenter. Le paramètre se trouve dans le fichier de configuration du kubelet, généralement /var/lib/kubelet/config.yaml :

maxPods: 110

Modifiez-le pour une valeur plus élevée, comme 250, et redémarrez le kubelet :

systemctl restart kubelet

Vérifiez les journaux du kubelet pour confirmer que la nouvelle valeur est chargée :

journalctl -u kubelet | grep maxPods

Optimisation de kube-proxy

Kube-proxy est responsable du routage réseau. Son mode (iptables ou IPVS) a un impact important sur les performances. IPVS est généralement plus efficace pour les grands clusters. Pour passer d'iptables à IPVS, vous devez vous assurer que les modules du noyau IPVS sont chargés, puis modifier la configuration de kube-proxy. Pour kubeadm, la configuration se trouve dans une ConfigMap dans l'espace de noms kube-system. Tout d'abord, vérifiez le mode actuel :

kubectl get configmap kube-proxy -n kube-system -o yaml | grep mode

Sortie attendue : mode: "" (ce qui correspond par défaut à iptables). Pour passer à IPVS, modifiez la ConfigMap :

kubectl edit configmap kube-proxy -n kube-system

Définissez mode: "ipvs" dans la section appropriée, enregistrez, puis redémarrez les pods kube-proxy :

kubectl delete pods -n kube-system -l k8s-app=kube-proxy

Les pods seront recréés avec la nouvelle configuration.

Pratiques de mise en œuvre sûres

  • Effectuez toujours une modification à la fois, puis observez avant d'en faire une autre.
  • Conservez des sauvegardes des fichiers manifestes d'origine. Par exemple :
cp /etc/kubernetes/manifests/kube-apiserver.yaml /etc/kubernetes/manifests/kube-apiserver.yaml.bak
  • Utilisez un système de contrôle de version pour les modifications de configuration.
  • Testez dans un cluster de préproduction si possible.

Vérification et diagnostic

Après avoir effectué des modifications, vous devez vérifier qu'elles fonctionnent comme prévu et ne provoquent pas de régressions. Cette section couvre les métriques et vérifications clés.

Latence et débit du serveur API

Vous pouvez utiliser kubectl pour mesurer les temps de réponse du serveur API. Par exemple, chronométrez une requête de liste :

time kubectl get pods --all-namespaces

Comparez le temps avant et après l'optimisation. Un serveur API bien réglé devrait répondre en bien moins d'une seconde pour un petit nombre d'objets, mais cela dépend de l'échelle.

Pour des métriques plus détaillées, si vous avez Prometheus configuré, interrogez les percentiles de apiserver_request_duration_seconds. Sinon, vous pouvez consulter les journaux du serveur API pour les requêtes lentes :

kubectl logs -n kube-system kube-apiserver-master-1 | grep 'apiserver_request_total' | tail

Débit du planificateur

Le planificateur traite les pods en attente. Vérifiez s'il y a des pods en attente qui ne sont pas ordonnancés rapidement. Utilisez kubectl get pods --all-namespaces --field-selector=status.phase=Pending pour voir s'il y en a de bloqués. Consultez également les journaux du planificateur :

kubectl logs -n kube-system kube-scheduler-master-1 | tail

Si vous avez augmenté le QPS API du planificateur, vous devriez observer moins de retards dans les horodatages des journaux entre les tentatives d'ordonnancement.

Pression sur les ressources des nœuds

Vérifiez les conditions des nœuds pour la pression sur les ressources, telles que MemoryPressure ou DiskPressure :

kubectl describe nodes | grep -A5 Conditions

La sortie attendue montre MemoryPressure False et DiskPressure False. Si l'une d'elles devient True, le kubelet peut expulser des pods, provoquant des perturbations.

Performances réseau

Si vous êtes passé à IPVS, vérifiez que kube-proxy utilise IPVS en consultant les journaux :

kubectl logs -n kube-system kube-proxy-xxxxx | grep 'Using ipvs Proxier'

Vous devriez voir une ligne comme Using ipvs Proxier. De plus, vous pouvez vérifier les règles IPVS sur le nœud :

sudo ipvsadm -L -n | head

La sortie attendue montre les IP de service et les backends.

Santé de etcd

Les performances de Kubernetes dépendent fortement de etcd. Surveillez les métriques etcd telles que etcd_disk_wal_fsync_duration_seconds et etcd_network_peer_round_trip_time_seconds. Si vous avez etcdctl, vous pouvez vérifier le statut de l'endpoint :

ETCDCTL_API=3 etcdctl endpoint status --cluster -w table

Exemple de sortie :

+------------------+------------------+---------+---------+-----------+-----------+------------+
| ENDPOINT         | ID               | VERSION | DB SIZE | IS LEADER | RAFT TERM | RAFT INDEX |
+------------------+------------------+---------+---------+-----------+-----------+------------+
| 10.0.0.1:2379   | 8e9e05c52164694d | 3.4.13  | 25 MB   | true      | 3         | 12345      |
+------------------+------------------+---------+---------+-----------+-----------+------------+

Les déviations par rapport à la normale (par exemple, une durée de fsync élevée) indiquent des problèmes potentiels.

Modes de défaillance et récupération

Même avec une planification minutieuse, les modifications d'optimisation peuvent causer des problèmes inattendus. Cette section décrit les modes de défaillance courants et comment récupérer.

CrashLoopBackOff du serveur API

Si vous augmentez trop --max-requests-inflight, le serveur API peut manquer de mémoire et planter. Cela peut conduire à un CrashLoopBackOff. Les symptômes incluent le redémarrage répété du pod du serveur API et le cluster devenant insensible aux commandes kubectl. Pour récupérer, rétablissez le manifeste aux valeurs d'origine. Comme le serveur API est en panne, vous devez accéder directement au nœud du plan de contrôle et restaurer la sauvegarde :

sudo cp /etc/kubernetes/manifests/kube-apiserver.yaml.bak /etc/kubernetes/manifests/kube-apiserver.yaml

Le kubelet redémarrera le serveur API avec la configuration précédente. Après la récupération, vérifiez les journaux du serveur API pour les erreurs de mémoire insuffisante et ajustez les valeurs de manière plus prudente.

Le planificateur ne parvient pas à ordonnancer les pods

Si vous modifiez incorrectement les drapeaux du planificateur, celui-ci peut ne pas démarrer ou planter. Cela entraîne que les nouveaux pods restent indéfiniment en état Pending. Pour diagnostiquer, vérifiez le statut du pod du planificateur :

kubectl get pods -n kube-system -l component=kube-scheduler

S'il n'est pas en cours d'exécution, inspectez les journaux (si possible) ou le fichier manifeste pour des erreurs de syntaxe. Corrigez le manifeste et enregistrez ; le planificateur sera redémarré. Si le planificateur fonctionne mais n'ordonnance toujours pas, vérifiez ses journaux pour des erreurs comme des échecs de connexion API et assurez-vous que les valeurs --kube-api-qps et --kube-api-burst ne sont pas définies à zéro.

Le kubelet ne démarre pas après la modification de maxPods

Si vous définissez maxPods à une valeur qui dépasse la capacité du nœud (par exemple, trop élevée pour la plage CIDR des pods), le kubelet peut ne pas démarrer. Le nœud apparaîtra comme NotReady. Vérifiez le statut du kubelet :

systemctl status kubelet

En cas d'échec, examinez les journaux pour l'erreur spécifique :

journalctl -u kubelet -n 50 --no-pager

Erreur courante : failed to reserve container for pod: invalid maxPods value. Pour récupérer, éditez /var/lib/kubelet/config.yaml et remettez maxPods à une valeur valide (par exemple, 110), puis redémarrez le kubelet et vérifiez que le nœud redevient Ready :

kubectl get nodes

Problèmes de kube-proxy après le passage à IPVS

Si les modules IPVS ne sont pas chargés, kube-proxy peut ne pas démarrer, laissant les services inaccessibles. Vérifiez les journaux du pod kube-proxy pour des erreurs comme can't initialize ipvs module. Pour récupérer, chargez les modules du noyau nécessaires ou revenez au mode iptables dans la ConfigMap. Pour une récupération rapide, modifiez la ConfigMap pour remettre mode: "" et redémarrez kube-proxy :

kubectl edit configmap kube-proxy -n kube-system
kubectl delete pods -n kube-system -l k8s-app=kube-proxy

Stratégie générale de retour en arrière

Conservez toujours des sauvegardes de tout fichier ou ConfigMap que vous modifiez. Pour les fichiers sur les nœuds, utilisez cp pour créer un fichier .bak. Pour les objets Kubernetes, vous pouvez exporter le YAML d'origine avant modification :

kubectl get configmap kube-proxy -n kube-system -o yaml > kube-proxy-original.yaml

Si une modification cause des problèmes, restaurez l'original en utilisant kubectl apply -f kube-proxy-original.yaml ou en copiant le fichier de sauvegarde. Documentez toute modification dans un journal des changements avec la date, ce qui a été modifié et pourquoi, pour faciliter le dépannage.

Question rapide 2 sur 2

Selon l'article, quelle est la valeur par défaut de maxPods dans la configuration du kubelet ?

L'article mentionne que la valeur par défaut pour --max-pods est de 110 pods par nœud.

Pièges courants et comment les éviter

L'optimisation de Kubernetes peut être délicate, et de nombreux opérateurs tombent dans les mêmes pièges. Voici quelques erreurs fréquentes et comment les éviter.

Effectuer plusieurs modifications à la fois

Lorsque vous modifiez plusieurs paramètres simultanément, il devient difficile d'identifier quelle modification a causé une amélioration ou une régression. Par exemple, augmenter les requêtes en vol du serveur API tout en passant kube-proxy à IPVS pourrait masquer un problème avec l'un des changements. Pour éviter cela, effectuez une modification à la fois, testez soigneusement et observez pendant au moins quelques heures avant de passer à la suivante.

Ignorer la marge de ressources

Définir des limites trop élevées sans s'assurer que les nœuds du plan de contrôle disposent de suffisamment de CPU et de mémoire peut entraîner des plantages. Par exemple, augmenter --max-requests-inflight à 1000 sur un nœud avec seulement 2 Go de RAM disponibles pour le serveur API provoquera probablement des arrêts pour mémoire insuffisante. Vérifiez toujours l'utilisation actuelle des ressources avec kubectl top nodes et kubectl top pods -n kube-system avant d'ajuster les limites, et utilisez des incréments prudents.

Ne pas tester dans un environnement de préproduction

Appliquer directement l'optimisation à la production est risqué. Une configuration qui fonctionne dans un petit cluster de test peut échouer sous la charge de production. Par exemple, IPVS peut fonctionner correctement avec 10 services mais rencontrer des problèmes avec 1000 services en raison des limites du noyau. Si possible, reproduisez votre topologie de production dans un cluster de préproduction et exécutez des tests de charge avant de déployer les modifications.

Sauter les sauvegardes

Ne pas sauvegarder les manifestes et les ConfigMaps signifie qu'une mauvaise modification pourrait vous laisser en difficulté. Créez toujours un fichier de sauvegarde ou exportez l'objet d'origine avant de le modifier. Pour les manifestes, utilisez cp fichier.yaml fichier.yaml.bak ; pour les objets Kubernetes, utilisez kubectl get -o yaml > original.yaml. Stockez également les sauvegardes dans un système de contrôle de version.

Ne pas surveiller après les modifications

Après une modification, certains opérateurs passent immédiatement à autre chose sans vérifier l'impact. Cela peut laisser des régressions de performance passer inaperçues. Par exemple, après avoir augmenté le QPS du planificateur, vous devriez surveiller la latence du planificateur et le nombre de pods en attente pendant au moins une journée. Configurez des alertes pour les métriques clés comme la durée des requêtes du serveur API et la durée de fsync de etcd pour détecter les problèmes tôt.

Liste de contrôle des opérations

Pour maintenir de bonnes performances de votre architecture Kubernetes, suivez cette liste de contrôle régulièrement. Attribuez un responsable pour chaque élément et définissez une fréquence de révision. Le responsable doit être une seule personne imputable, comme un ingénieur plateforme ou un administrateur de cluster.

ÉlémentResponsableFréquence
Vérifier que les versions du cluster et des composants sont cohérentes et prises en chargeIngénieur plateforme (ex. Priya Shah)Mensuelle
Vérifier la santé de etcd et les métriques de performance (durée fsync, changements de leader)Administrateur de base de données (ex. Carlos Gomez)Hebdomadaire
Surveiller la durée des requêtes du serveur API et les taux d'erreur ; alerter en cas de latence élevéeSRE (ex. Alex Chen)Quotidienne (alertes automatisées)
Examiner les journaux du planificateur et du gestionnaire de contrôleurs pour des erreurs ou retards répétésIngénieur plateformeHebdomadaire
Vérifier les conditions des nœuds et l'utilisation des ressources (CPU, mémoire, disque) pour la pressionSREQuotidienne (alertes automatisées)
Valider les performances réseau ; si IPVS est utilisé, s'assurer que les règles sont correctesIngénieur réseau (ex. Maria Rossi)Mensuelle
Tester les procédures de reprise après sinistre pour chaque composant (par exemple, restaurer le manifeste du serveur API)Ingénieur plateformeTrimestrielle
Maintenir les fichiers de configuration sous contrôle de version et conserver les sauvegardesIngénieur plateformeContinue
Planifier des tests de performance après tout changement ou mise à niveau significatif du clusterIngénieur performance (ex. David Kim)Après chaque changement
Documenter toutes les modifications d'optimisation avec la justification et les effets observésIngénieur plateformeContinue

Les responsables doivent réviser leurs éléments à la fréquence spécifiée. Par exemple, l'ingénieur plateforme examine les conditions des nœuds chaque semaine et ajuste les alertes si nécessaire. Cela garantit la responsabilisation et maintient le cluster en bonne santé.

Conclusion

L'optimisation des performances de l'architecture Kubernetes est un processus continu de mesure, d'ajustement et de vérification. En suivant les étapes pratiques de ce guide, vous pouvez identifier systématiquement les goulots d'étranglement et appliquer des modifications sûres et réversibles. N'oubliez pas de commencer par un inventaire complet, de modifier un paramètre à la fois et d'avoir toujours un plan de retour en arrière. La liste de contrôle des opérations vous aidera à maintenir des performances optimales à mesure que votre cluster évolue. Avec une optimisation minutieuse, vous pouvez obtenir une latence plus faible, un débit plus élevé et une plateforme plus fiable pour vos charges de travail.

Recherches connexes

Score de qualité de l’article

Utilité pour le lecteur 100%
  • check_circle Guide prêt à lire
  • check_circle Exemples pratiques inclus
  • check_circle URL d’article optimisée pour le SEO