E-NO
Kubernetes 8 min de lecture

Configuration avancée des pods Kubernetes : commandes, exemples et opérations

calendar_today Publié : 2026-11-16
update Dernière mise à jour : 2026-11-16
analytics Efficacité SEO : 100%
Illustration du guide technique pour « Configuration avancée des pods Kubernetes : commandes, exemples et opérations ».

Introduction

Configurer des pods dans Kubernetes va au-delà de simples définitions de conteneurs. La configuration avancée des pods implique de définir des limites de ressources, des contextes de sécurité, des conteneurs d'initialisation (init containers), des sondes (probes) et des contraintes de planification pour créer des charges de travail fiables et sécurisées. Les opérateurs ont besoin de commandes et de modèles concrets pour inspecter, modifier et vérifier ces configurations sans provoquer d'interruptions de service.

Cet article fournit un guide pratique des commandes de configuration avancée des pods destiné aux développeurs, ingénieurs DevOps et équipes techniques. Il relie les commandes de base, les exemples, un aide-mémoire et les procédures opérationnelles à des scénarios du monde réel. Chaque section inclut des commandes avec leur sortie attendue, les signaux d'échec et les étapes de récupération pour vous aider à passer du problème à une résolution vérifiée.

L'objectif est la sécurité opérationnelle : observer avant de modifier, limiter le rayon d'impact, utiliser des espaces réservés pour les secrets, vérifier les résultats et documenter les chemins de récupération. Que vous déboguiez une boucle de crash ou que vous renforciez un déploiement en production, les sections suivantes offrent une approche structurée.

Inventaire de la version et de l'environnement

Avant d'effectuer toute modification, établissez l'état actuel de votre cluster et des composants impliqués. Cet inventaire évite les corrections mal orientées et garantit la compatibilité.

Tout d'abord, vérifiez la version de Kubernetes :

kubectl version --short

Sortie attendue :

Client Version: v1.28.2
Server Version: v1.28.2

Si les versions ne correspondent pas, notez la différence car elle peut affecter la disponibilité des API. Par exemple, un serveur plus ancien peut ne pas prendre en charge les conteneurs sidecar ou les contextes de sécurité au niveau du pod. Ensuite, vérifiez les nœuds :

kubectl get nodes -o wide

Recherchez les conditions des nœuds telles que Ready, MemoryPressure ou DiskPressure. Un nœud sous pression peut provoquer l'éviction de pods. Pour un pod spécifique, obtenez son état détaillé :

kubectl get pods -o wide

Choisissez un pod et décrivez-le :

kubectl describe pod <nom-du-pod>

Cela affiche les événements, les annotations et la configuration appliquée. Pour un déploiement, confirmez l'état du déploiement avant de supposer le succès :

kubectl rollout status deployment/<nom-du-déploiement>

Si le déploiement est bloqué, inspectez les événements avec kubectl describe deployment. Assurez-vous d'utiliser d'abord des commandes en lecture seule pour éviter des modifications accidentelles. Par exemple, kubectl get et kubectl describe ne modifient pas les ressources.

Vérification pratique

Effectuez une petite validation avant de déployer à grande échelle :

kubectl apply -f pod.yaml --dry-run=client

Cela vérifie la syntaxe du manifeste sans l'appliquer. Ensuite, appliquez et observez le démarrage du pod :

kubectl apply -f pod.yaml
kubectl get pods -w

Le drapeau -w surveille les changements. Si le pod reste en état Pending, décrivez-le pour voir les erreurs de planification.

Question rapide 1 sur 2

Où dans la spécification du Pod configurez-vous les contraintes de sécurité pour le Pod et ses conteneurs ?

Le champ securityContext dans la spécification du Pod offre un contrôle granulaire sur ce qu'un Pod ou les conteneurs individuels peuvent faire.

Chemin de configuration sécurisé

Une configuration sécurisée implique d'apporter des modifications de manière incrémentale et de vérifier chaque étape. Commencez par une modification ciblée, comme l'ajout d'une limite de ressources à un seul pod, plutôt que de modifier tous les pods en même temps.

Limites et demandes de ressources

Définissez les demandes (requests) et les limites (limits) de ressources dans la spécification du pod :

apiVersion: v1
kind: Pod
metadata:
  name: nginx-demo
spec:
  containers:
  - name: nginx
    image: nginx:1.25
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"

Appliquez et vérifiez les paramètres :

kubectl apply -f pod.yaml
kubectl get pod nginx-demo -o jsonpath='{.spec.containers[0].resources}'

Sortie attendue :

{"limits":{"cpu":"500m","memory":"128Mi"},"requests":{"cpu":"250m","memory":"64Mi"}}

Si le pod est tué par manque de mémoire (OOMKilled), augmentez la limite de mémoire ou réduisez la charge de travail. Vérifiez les événements avec kubectl describe pod nginx-demo.

Contexte de sécurité

Définissez un contexte de sécurité pour exécuter les conteneurs en tant qu'utilisateur non root :

apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    runAsUser: 1000
    runAsGroup: 3000
    fsGroup: 2000
  containers:
  - name: app
    image: busybox
    command: ["sleep", "3600"]
    securityContext:
      allowPrivilegeEscalation: false
      capabilities:
        drop: ["ALL"]

Vérifiez qu'il s'exécute avec l'UID 1000 :

kubectl exec secure-pod -- id

Sortie attendue :

uid=1000 gid=3000 groups=2000

Si le conteneur ne démarre pas en raison de problèmes de permissions, vérifiez les exigences de l'utilisateur de l'image. Vous devrez peut-être ajuster runAsUser ou définir fsGroup pour correspondre aux permissions du volume.

Vérification et diagnostics

Après avoir apporté des modifications, recueillez des preuves qu'elles fonctionnent comme prévu. Utilisez des commandes ciblées pour inspecter l'état du pod, les journaux et le comportement interne.

Inspection des pods

Obtenez l'état d'un pod et ses références de propriétaire :

kubectl get pod <nom-du-pod> -o yaml

Recherchez les conditions et les états des conteneurs. Si un conteneur plante à plusieurs reprises, vérifiez les journaux précédents :

kubectl logs <nom-du-pod> --previous

Pour un pod en cours d'exécution, diffusez les journaux actuels :

kubectl logs -f <nom-du-pod>

Si le pod a plusieurs conteneurs, spécifiez le nom du conteneur :

kubectl logs <nom-du-pod> -c <nom-du-conteneur>

Sondes (probes)

Définissez des sondes de préparation (readiness probes) et de vivacité (liveness probes) pour gérer le trafic et les redémarrages :

apiVersion: v1
kind: Pod
metadata:
  name: probe-pod
spec:
  containers:
  - name: web
    image: nginx
    ports:
    - containerPort: 80
    readinessProbe:
      httpGet:
        path: /
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 10
    livenessProbe:
      httpGet:
        path: /healthz
        port: 80
      initialDelaySeconds: 15
      periodSeconds: 20

Vérifiez les résultats des sondes en décrivant le pod :

kubectl describe pod probe-pod

Recherchez la condition Ready et des événements comme Readiness probe succeeded ou Liveness probe failed. Si les sondes échouent, ajustez le timing ou corrigez le point de terminaison. Pour simuler un échec, modifiez temporairement le chemin de la sonde de vivacité et observez l'augmentation du nombre de redémarrages :

kubectl set image pod/probe-pod web=nginx:bad-tag

Mais comme l'image est invalide, le pod ne démarrera pas. À la place, modifiez le déploiement pour changer le chemin de la sonde de vivacité.

Modes d'échec et récupération

Connaître les modes d'échec courants accélère la récupération. Voici les problèmes de pods typiques et les commandes pour les résoudre.

CrashLoopBackOff

Un pod en CrashLoopBackOff redémarre à plusieurs reprises. Diagnostiquez avec :

kubectl describe pod <nom-du-pod>

Recherchez les codes de sortie et les événements. Ensuite, vérifiez les journaux :

kubectl logs <nom-du-pod> --previous

Causes courantes : dépendances manquantes, commande incorrecte ou permissions insuffisantes. Par exemple, si un pod a besoin d'une base de données mais que le service n'est pas encore prêt, ajoutez un conteneur d'initialisation pour attendre :

initContainers:
- name: wait-for-db
  image: busybox
  command: ['sh', '-c', 'until nc -z db 5432; do echo waiting for db; sleep 2; done;']

ImagePullBackOff

Cela indique que l'image ne peut pas être extraite. Vérifiez le nom de l'image et l'authentification au registre :

kubectl describe pod <nom-du-pod> | grep -A 5 Events

Assurez-vous que le tag de l'image existe et que le secret est configuré si nécessaire. Pour les registres privés, créez un secret :

kubectl create secret docker-registry regcred \
  --docker-server=<registre> \
  --docker-username=<utilisateur> \
  --docker-password=<mot-de-passe> \
  --docker-email=<email>

Référencez-le ensuite dans la spécification du pod :

imagePullSecrets:
- name: regcred

Pods en attente (Pending)

Si un pod reste en attente, il ne peut pas être planifié. Les raisons incluent des ressources insuffisantes ou des incohérences de sélecteurs de nœuds. Inspectez les événements :

kubectl describe pod <nom-du-pod>

Recherchez des messages comme "0/3 nodes are available: 3 Insufficient memory." Ajustez les demandes de ressources ou ajoutez des nœuds. Si les sélecteurs de nœuds sont trop restrictifs, élargissez-les ou étiquetez les nœuds appropriés.

Question rapide 2 sur 2

Selon le passage, quel ensemble de champs est pris en charge avec les conteneurs Windows ?

Le passage répertorie toutes ces capacités comme étant prises en charge avec les conteneurs Windows.

Liste de contrôle opérationnelle

Utilisez cette liste de contrôle avant et après tout changement de configuration. Attribuez un responsable unique pour chaque élément afin d'éviter toute ambiguïté. Révisez la liste chaque semaine pendant la période de changement actif, et chaque trimestre pour la santé globale.

ÉtapeActionCommande / VérificationResponsableFréquence de révision
1Vérifier la version du cluster et la santé des nœudskubectl version --short && kubectl get nodesPriya Shah, responsable ingénierieAvant chaque changement
2Valider la syntaxe du manifestekubectl apply --dry-run=client -f pod.yamlPriya ShahAvant chaque changement
3Appliquer la configurationkubectl apply -f pod.yamlPriya ShahSelon les besoins
4Vérifier l'état du pod et les événementskubectl describe pod <nom>David Chen, ingénieur DevOpsAprès l'application
5Vérifier les limites de ressources et le contexte de sécuritékubectl get pod <nom> -o jsonpath='{.spec.containers[0].resources}'David ChenAprès l'application
6Tester les points de terminaison de préparation et de vivacitékubectl exec <nom> -- curl localhost:80/healthzDavid ChenAprès l'application
7Confirmer l'état du déploiement le cas échéantkubectl rollout status deployment/<nom>Priya ShahAprès l'application
8Documenter le plan de retour en arrièreStocker le manifeste précédent dans git ; kubectl apply -f previous.yaml peut annulerPriya ShahPendant le changement
9Surveiller pendant 24 heureskubectl get pods -w et tableaux de bord de métriquesDavid ChenQuotidiennement pendant le changement actif

Ce tableau nomme des responsables individuels et une cadence de révision pour garantir la responsabilisation. Ajustez les responsables en fonction de votre équipe, mais conservez une responsabilité unique par élément.

Pièges courants

Évitez ces erreurs lorsque vous travaillez avec la configuration avancée des pods.

Oublier les demandes de ressources

Définir uniquement des limites sans demandes peut entraîner un comportement inattendu. Kubernetes utilise les demandes pour les décisions de planification. Si les demandes sont absentes, les pods peuvent être planifiés sur des nœuds sans ressources suffisantes, provoquant une éviction sous pression.

Pourquoi cela arrive : Les développeurs se concentrent sur les limites comme plafond, mais les demandes sont le minimum garanti. Comment l'éviter : Définissez toujours à la fois les demandes et les limites. Utilisez kubectl describe nodes pour voir les ressources allouées et ajustez en conséquence.

Contextes de sécurité trop restrictifs

Exécuter des conteneurs en tant que non-root est une bonne pratique, mais si l'application nécessite root dans le conteneur (par exemple, pour se lier à un port inférieur à 1024), cela échouera. Le conteneur peut démarrer mais l'application plante.

Pourquoi cela arrive : Supposer que toutes les images peuvent s'exécuter avec des utilisateurs arbitraires. Comment l'éviter : Testez les images localement avec le même UID/GID. Utilisez securityContext au niveau du pod pour les valeurs par défaut, mais autorisez des surcharges par conteneur si nécessaire. Vérifiez les journaux pour les erreurs de permission.

Sondes mal configurées

Des sondes avec un délai initial trop court ou un mauvais point de terminaison provoquent des boucles de redémarrage. Une sonde de vivacité qui vérifie une dépendance non prête peut tuer un conteneur sain pendant le démarrage.

Pourquoi cela arrive : Régler les sondes sans comprendre le temps de démarrage de l'application et les points de terminaison de santé. Comment l'éviter : Commencez avec des initialDelaySeconds plus longs et des délais d'attente conservateurs. Utilisez des sondes de préparation pour l'indisponibilité temporaire et des sondes de vivacité uniquement pour les états irrécupérables. Testez avec kubectl describe pour voir les événements des sondes.

Ignorer les conteneurs d'initialisation

Les conteneurs d'initialisation s'exécutent avant le conteneur principal. S'ils échouent, le pod reste en Init:Error ou Init:CrashLoopBackOff. De nombreux opérateurs oublient de vérifier les journaux des conteneurs d'initialisation.

Pourquoi cela arrive : Se concentrer sur les journaux du conteneur principal ; les conteneurs d'initialisation ne sont pas visibles par défaut. Comment l'éviter : Vérifiez les journaux des conteneurs d'initialisation avec kubectl logs <nom-du-pod> -c <nom-du-conteneur-d'initialisation>. Décrivez le pod pour voir quel conteneur d'initialisation échoue.

Appliquer des modifications sans contrôle de version

Modifier des pods directement avec kubectl edit ou appliquer des modifications sans conserver une copie rend le retour en arrière difficile. Si l'état du cluster dérive, la récupération est lente.

Pourquoi cela arrive : Les corrections rapides sous pression contournent la gestion normale des changements. Comment l'éviter : Stockez tous les manifestes dans un dépôt git et utilisez un pipeline CI/CD pour appliquer les modifications. Pour les modifications d'urgence, capturez immédiatement le YAML actuel avec kubectl get pod <nom> -o yaml > pod-backup.yaml.

Conclusion

La configuration avancée des pods dans Kubernetes nécessite une approche systématique : inventorier l'environnement, modifier les configurations en toute sécurité, vérifier avec des diagnostics et planifier les échecs. Les commandes et les exemples de cet article fournissent une base pour des opérations fiables, mais ils ne fonctionnent que s'ils sont appliqués avec soin et contexte.

Commencez par une vérification à faible risque : choisissez un pod, enregistrez son état actuel, appliquez un petit changement comme l'ajout d'une demande de ressources, et observez l'impact. Passez en revue les dépendances comme les conteneurs d'initialisation et les contextes de sécurité, et assurez-vous d'avoir un plan de retour en arrière. En rendant les échecs visibles et les modifications réversibles, vous gagnez en confiance et en compétence dans la gestion des charges de travail Kubernetes.

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