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.
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.
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.
| Étape | Action | Commande / Vérification | Responsable | Fréquence de révision |
|---|---|---|---|---|
| 1 | Vérifier la version du cluster et la santé des nœuds | kubectl version --short && kubectl get nodes | Priya Shah, responsable ingénierie | Avant chaque changement |
| 2 | Valider la syntaxe du manifeste | kubectl apply --dry-run=client -f pod.yaml | Priya Shah | Avant chaque changement |
| 3 | Appliquer la configuration | kubectl apply -f pod.yaml | Priya Shah | Selon les besoins |
| 4 | Vérifier l'état du pod et les événements | kubectl describe pod <nom> | David Chen, ingénieur DevOps | Après l'application |
| 5 | Vérifier les limites de ressources et le contexte de sécurité | kubectl get pod <nom> -o jsonpath='{.spec.containers[0].resources}' | David Chen | Après l'application |
| 6 | Tester les points de terminaison de préparation et de vivacité | kubectl exec <nom> -- curl localhost:80/healthz | David Chen | Après l'application |
| 7 | Confirmer l'état du déploiement le cas échéant | kubectl rollout status deployment/<nom> | Priya Shah | Après l'application |
| 8 | Documenter le plan de retour en arrière | Stocker le manifeste précédent dans git ; kubectl apply -f previous.yaml peut annuler | Priya Shah | Pendant le changement |
| 9 | Surveiller pendant 24 heures | kubectl get pods -w et tableaux de bord de métriques | David Chen | Quotidiennement 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.