Introduction
Les clusters Kubernetes sont des environnements dynamiques où les pods sont régulièrement évincés ou terminés pour de nombreuses raisons, notamment la maintenance des nœuds, l'autoscaling du cluster et la pression sur les ressources. Bien que ces perturbations soient souvent nécessaires, elles peuvent nuire à la disponibilité des applications si les charges de travail critiques perdent trop de répliques en même temps. Un budget de perturbation de pods (Pod Disruption Budget, PDB) est un objet de stratégie Kubernetes qui limite le nombre de perturbations simultanées qu'une charge de travail peut subir, garantissant qu'un nombre minimum de pods reste disponible pendant les perturbations volontaires.
Ce guide fournit une plongée pratique dans l'architecture des PDB. Vous apprendrez comment les PDB fonctionnent sous le capot, comment les configurer en toute sécurité, comment vérifier leur comportement avec des commandes concrètes et des sorties attendues, comment diagnostiquer et récupérer des modes de défaillance courants, et comment intégrer les PDB dans vos flux de travail opérationnels. Que vous vous prépariez à un drainage de nœud, à une mise à niveau de cluster ou simplement à renforcer votre déploiement, ce guide vous donne les outils pour utiliser les PDB efficacement.
Qu'est-ce qu'un budget de perturbation de pods ?
Un budget de perturbation de pods est un objet d'API Kubernetes qui spécifie le nombre ou le pourcentage minimum de pods d'une application donnée qui doivent rester disponibles pendant les perturbations volontaires. Les perturbations volontaires sont des actions délibérées initiées par les administrateurs de cluster ou les contrôleurs automatisés, telles que :
- Drainer un nœud pour la maintenance (
kubectl drain) - Mettre à niveau un nœud de cluster
- Supprimer un nœud du cluster
- Réduire automatiquement un pool de nœuds
- Supprimer directement un pod (bien que cela ne soit pas toujours considéré comme volontaire)
Les PDB n'empêchent pas les perturbations involontaires comme les pannes matérielles, les paniques du noyau ou les plantages de nœuds. Ils s'appliquent uniquement aux perturbations volontaires qui passent par l'API Eviction, qui respecte les PDB.
Le PDB n'est pas un contrôleur ; il ne gère pas activement les pods. Au lieu de cela, c'est un objet de stratégie que le plan de contrôle Kubernetes consulte lorsqu'une demande d'éviction est effectuée. Si l'éviction d'un pod entraînerait une baisse du nombre de pods disponibles en dessous du budget, l'éviction est rejetée.
Inventaire des versions et de l'environnement
Avant de mettre en œuvre les PDB, établissez un inventaire clair de votre environnement Kubernetes et de la topologie de vos applications.
Version de Kubernetes
Les PDB sont disponibles depuis Kubernetes v1.5 en version bêta et sont devenus stables dans la v1.21. La version de l'API PDB est policy/v1 pour les clusters v1.21 et ultérieurs. Pour les clusters plus anciens, utilisez policy/v1beta1. Vérifiez la version de votre cluster :
kubectl version --short
Sortie attendue (exemple) :
Client Version: v1.27.3
Server Version: v1.27.3
Si votre cluster est plus ancien que la v1.21, vous devrez peut-être utiliser la version bêta de l'API et ajuster vos manifestes en conséquence. Pour ce guide, nous supposons un cluster v1.21+ avec policy/v1.
Topologie de l'application
Identifiez les charges de travail qui nécessitent des PDB. Il s'agit généralement de Deployments, StatefulSets ou ReplicaSets exécutant des applications sans état ou avec état. Pour chaque charge de travail, notez le nombre de répliques souhaité et le nombre minimum de pods qui doivent rester disponibles pendant les perturbations. Le tableau suivant illustre un exemple d'inventaire :
| Nom de la charge de travail | Type | Répliques | Minimum disponible | Propriétaire |
|---|---|---|---|---|
| web-frontend | Deployment | 5 | 3 | Priya Shah, responsable plateforme |
| db-stateful | StatefulSet | 3 | 2 | Marcus Chen, administrateur BD |
| cache | Deployment | 4 | 2 | Elena Rodriguez, SRE |
Attribuer un propriétaire pour chaque PDB garantit la responsabilité de sa configuration et de sa révision périodique. Nous recommandons de réviser les PDB trimestriellement ou chaque fois que le nombre de répliques change.
Prérequis
- Un cluster Kubernetes en cours d'exécution (v1.21+ recommandé).
- kubectl configuré pour accéder au cluster.
- Autorisations RBAC appropriées pour créer des PDB (généralement create et update sur la ressource
poddisruptionbudgets). - Compréhension des exigences de disponibilité de votre application.
Architecture des PDB et composants fondamentaux
Pour utiliser les PDB efficacement, il est utile de comprendre l'architecture sous-jacente et les composants impliqués.
L'objet PDB
Un PDB est défini par trois champs principaux :
spec.minAvailable: Le nombre ou le pourcentage minimum de pods qui doivent rester disponibles après les évictions. Peut être un entier ou une chaîne de pourcentage (par exemple, « 60% »).spec.maxUnavailable: Le nombre ou le pourcentage maximum de pods pouvant être indisponibles après les évictions. Peut être un entier ou une chaîne de pourcentage.spec.selector: Un sélecteur d'étiquettes qui identifie l'ensemble de pods auquel le PDB s'applique. Ce sélecteur doit correspondre aux étiquettes des pods gérés par la charge de travail cible.
Vous ne pouvez spécifier qu'un seul des deux : minAvailable ou maxUnavailable ; ils sont mutuellement exclusifs. L'utilisation de pourcentages est souvent plus facile à maintenir lorsque le nombre de répliques change, mais les nombres absolus fournissent des garanties plus claires.
Comment fonctionnent les évictions
Lorsqu'une perturbation volontaire est demandée (par exemple, via kubectl drain), la séquence suivante se produit :
- La commande drain ou le contrôleur appelle l'API Eviction pour chaque pod sur le nœud.
- Le serveur d'API vérifie si le pod est couvert par un PDB en faisant correspondre les étiquettes du pod au sélecteur du PDB.
- Si un PDB s'applique, le serveur d'API calcule si l'éviction du pod violerait le budget. Il examine le nombre actuel de pods disponibles (pods qui sont Ready) et le minimum ou le maximum souhaité.
- Si l'éviction violerait le budget, le serveur d'API renvoie une erreur 429 Too Many Requests, et l'éviction n'est pas effectuée. La commande drain réessaie plus tard.
- Si l'éviction est autorisée, le pod est supprimé et le pod de remplacement est planifié sur un autre nœud (si possible).
Ce mécanisme garantit que la disponibilité globale de l'application est maintenue pendant les opérations de maintenance.
Flux de données et flux de contrôle
Le flux de données implique les composants suivants :
- API Eviction : Fait partie de l'API Kubernetes, utilisée par
kubectl drainet les contrôleurs comme le Cluster Autoscaler. - Contrôleur PDB : Un contrôleur dans le kube-controller-manager qui surveille les objets PDB et maintient leur statut, y compris le nombre de perturbations autorisées.
- État Ready des pods : Le contrôleur PDB ne considère que les pods Ready comme disponibles. Les pods qui ne sont pas Ready (par exemple, en attente, en échec ou en cours de terminaison) ne sont pas comptés.
Flux de contrôle :
- L'administrateur initie le drainage ou l'éviction.
- L'API Eviction reçoit la demande.
- Le serveur d'API interroge le contrôleur d'admission PDB.
- Le contrôleur d'admission évalue les contraintes du PDB.
- Si autorisé, l'éviction se poursuit ; sinon, elle est rejetée.
Champs de statut
Le statut d'un PDB comprend :
currentHealthy: Nombre de pods sains (Ready) actuellement dans l'ensemble sélectionné.desiredHealthy: Nombre minimum de pods sains requis par le budget.disruptionsAllowed: Nombre de pods pouvant être évincés simultanément sans violer le budget.expectedPods: Nombre total de pods comptés par le contrôleur PDB.
Ces champs de statut sont visibles via kubectl get pdb et kubectl describe pdb.
Chemin de configuration sûr
La configuration des PDB doit suivre une approche ciblée et incrémentale pour éviter des impacts involontaires sur la disponibilité. Les étapes suivantes offrent un chemin sûr.
Étape 1 : Définir les exigences de disponibilité
Déterminez le nombre minimum de pods qui doivent être disponibles. Vous pouvez l'exprimer comme un nombre absolu (minAvailable) ou un pourcentage du total des répliques (minAvailable: "60%"). Alternativement, utilisez maxUnavailable pour définir le nombre maximum de pods pouvant être indisponibles.
- Pour un Deployment avec 5 répliques, exigeant au moins 3 pods disponibles :
minAvailable: 3 - Pour un StatefulSet avec 3 répliques, autorisant au plus 1 pod indisponible :
maxUnavailable: 1
Considérez la tolérance de votre application à une capacité réduite. Pour les frontaux web sans état, minAvailable: 60% peut être acceptable. Pour une base de données avec état, minAvailable: 2 sur 3 répliques garantit le quorum si un protocole de consensus est utilisé.
Étape 2 : Créer le manifeste PDB
Créez un fichier YAML pour le PDB. Voici un exemple utilisant minAvailable :
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
name: web-frontend-pdb
spec:
minAvailable: 3
selector:
matchLabels:
app: web-frontend
Vous pouvez créer le PDB en utilisant soit la commande impérative soit le manifeste YAML ci-dessus.
Création impérative avec la commande documentée :
kubectl create poddisruptionbudget web-frontend-pdb --selector=app=web-frontend --min-available=3
Ou appliquez le manifeste :
kubectl apply -f web-frontend-pdb.yaml
Sortie attendue pour l'une ou l'autre commande :
poddisruptionbudget.policy/web-frontend-pdb created
Voici un exemple utilisant maxUnavailable pour un StatefulSet :
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
name: db-stateful-pdb
spec:
maxUnavailable: 1
selector:
matchLabels:
app: db
Étape 3 : Valider la correspondance du sélecteur
Assurez-vous que le sélecteur PDB correspond exactement aux pods de la charge de travail cible. Une non-correspondance rendra le PDB inefficace ou provoquera des conflits. Vérifiez les pods :
kubectl get pods -l app=web-frontend
Sortie attendue (exemple) :
NAME READY STATUS RESTARTS AGE
web-frontend-6d4b7c9f8-2x7kq 1/1 Running 0 5m
web-frontend-6d4b7c9f8-6m4fj 1/1 Running 0 5m
web-frontend-6d4b7c9f8-8t5np 1/1 Running 0 5m
web-frontend-6d4b7c9f8-k9x2b 1/1 Running 0 5m
web-frontend-6d4b7c9f8-p4j6m 1/1 Running 0 5m
Si aucun pod n'est listé, votre sélecteur est incorrect. Vérifiez également que les étiquettes sur les pods correspondent au sélecteur de votre YAML PDB.
Étape 4 : Surveiller le statut du PDB
Vérifiez le statut du PDB pour voir les perturbations autorisées actuelles :
kubectl get pdb web-frontend-pdb
Sortie attendue (exemple) :
NAME MIN AVAILABLE MAX UNAVAILABLE ALLOWED DISRUPTIONS AGE
web-frontend-pdb 3 N/A 2 1m
La colonne ALLOWED DISRUPTIONS indique combien de pods peuvent être perturbés simultanément sans violer le budget. Dans cet exemple, avec 5 pods sains et minAvailable: 3, vous pouvez évincer jusqu'à 2 pods à la fois.
Étape 5 : Tester avec une simulation
Avant d'effectuer un vrai drainage, utilisez une simulation pour voir si les évictions seraient autorisées :
kubectl drain <node-name> --dry-run=server
Cela simule l'éviction et signale toute violation du PDB sans réellement évincer les pods.
Vérification et diagnostics
Après avoir appliqué un PDB, vérifiez son application et résolvez les problèmes courants.
Vérifier les détails du PDB
Utilisez describe pour voir les événements et le statut :
kubectl describe pdb web-frontend-pdb
Extrait de sortie attendu :
Name: web-frontend-pdb
Namespace: default
Min available: 3
Selector: app=web-frontend
Status:
Allowed disruptions: 2
Current: 5
Desired: 3
Total: 5
Events: <none>
Interprétation : 5 pods sains, désiré 3, donc 2 perturbations autorisées.
Tester le comportement d'éviction
Simulez une perturbation volontaire (par exemple, un drainage de nœud) et observez si l'API d'éviction respecte le PDB. Pour une éviction de pod unique :
kubectl drain <node-name> --ignore-daemonsets --delete-emptydir-data
Si le drainage ferait tomber le nombre de pods disponibles en dessous de minAvailable, l'éviction est bloquée et la commande drain signalera une erreur comme :
error when evicting pods/"web-frontend-6d4b7c9f8-2x7kq" -n "default" (will retry): Cannot evict pod as it would violate the pod's disruption budget.
La commande drain réessaiera jusqu'à ce que le budget permette l'éviction (par exemple, après que les pods de remplacement deviennent prêts).
Diagnostiquer les mauvaises configurations
Les problèmes courants incluent :
- Non-correspondance du sélecteur : Le sélecteur PDB ne correspond à aucun pod, ce qui fait que
ALLOWED DISRUPTIONSest 0 ou N/A. Vérifiez aveckubectl get pods -l <selector>. - Pourcentage invalide : Un pourcentage
minAvailablesupérieur à 100 % est invalide et rejeté. Les pourcentages doivent être compris entre 0 % et 100 %. - PDB conflictuels : Plusieurs PDB ciblant les mêmes pods peuvent provoquer un comportement imprévisible. Évitez les sélecteurs qui se chevauchent sauf si c'est intentionnel.
- PDB dans le mauvais espace de noms : Les PDB sont limités à un espace de noms ; assurez-vous que le PDB est dans le même espace de noms que les pods.
Flux de dépannage
- Vérifiez que les pods existent et sont Ready :
kubectl get pods -l <selector> - Vérifiez le statut du PDB :
kubectl get pdb <name> -o yamlpour voir les champs de statut. - Testez l'éviction avec une simulation :
kubectl drain <node> --dry-run=server. - Examinez les événements :
kubectl describe pdb <name>.
Modes de défaillance et récupération
Comprendre les modes de défaillance vous aide à réagir rapidement et à récupérer des problèmes liés aux PDB.
Mode de défaillance 1 : Le PDB bloque la maintenance
Les PDB peuvent empêcher les drainages de nœuds, provoquant des retards de maintenance. Si un PDB est trop strict, vous devrez peut-être l'ajuster temporairement.
Récupération :
- Modifiez le PDB pour augmenter
maxUnavailableou diminuerminAvailabletemporairement. Par exemple, changezminAvailable: 3enminAvailable: 1. - Ou supprimez le PDB pendant la fenêtre de maintenance et recréez-le ensuite. À utiliser avec prudence.
Supprimer un PDB :
kubectl delete pdb web-frontend-pdb
Sortie attendue :
poddisruptionbudget.policy "web-frontend-pdb" deleted
Réappliquez après la maintenance en utilisant soit la commande impérative soit le manifeste :
kubectl create poddisruptionbudget web-frontend-pdb --selector=app=web-frontend --min-available=3
ou
kubectl apply -f web-frontend-pdb.yaml
Mode de défaillance 2 : PDB inefficace en raison d'un mauvais sélecteur
Si le sélecteur ne correspond pas aux pods prévus, le PDB ne les protégera pas et les perturbations peuvent dépasser le seuil souhaité.
Récupération :
- Corrigez le sélecteur dans le YAML et réappliquez.
- Vérifiez avec
kubectl get pdb <name>queALLOWED DISRUPTIONSest comme prévu.
Mode de défaillance 3 : Conflit du PDB avec d'autres contrôleurs
Si vous avez plusieurs PDB ou que la charge de travail utilise un opérateur qui gère les perturbations (par exemple, StatefulSet avec podManagementPolicy: Parallel), des interactions inattendues peuvent se produire.
Récupération :
- Passez en revue tous les PDB dans l'espace de noms :
kubectl get pdb -n <namespace>. - Assurez-vous qu'un seul PDB cible un ensemble donné de pods, sauf intention contraire.
Stratégie de retour en arrière
Si un PDB cause des problèmes, revenez en arrière en supprimant le PDB ou en appliquant une version précédente. Conservez les manifestes PDB dans un contrôle de version pour faciliter le retour en arrière. Utilisez kubectl apply -f previous-pdb.yaml pour restaurer.
Pièges courants et comment les éviter
De nombreuses mauvaises configurations de PDB proviennent de quelques erreurs courantes. Voici les pièges les plus fréquents, pourquoi ils se produisent et comment les éviter ou en récupérer.
Piège 1 : Définir minAvailable trop haut
Pourquoi cela arrive : Les opérateurs surestiment souvent les exigences de disponibilité ou copient les paramètres d'un environnement différent sans ajustement.
Conséquence : Le PDB bloque toutes ou la plupart des évictions, rendant les drainages de nœuds impossibles et retardant la maintenance.
Comment l'éviter : Commencez par un budget conservateur qui permet au moins une perturbation. Pour un déploiement à 3 répliques, minAvailable: 2 ou maxUnavailable: 1 est raisonnable. Testez avec des drainages simulés. Revisitez trimestriellement.
Récupération : Abaissez temporairement minAvailable ou augmentez maxUnavailable, puis effectuez la maintenance, puis restaurez.
Piège 2 : Ignorer la disponibilité des pods
Pourquoi cela arrive : Méconnaissance que le PDB ne compte que les pods Ready. Si les pods ne sont pas Ready en raison du démarrage ou d'échecs de vérification de santé, le PDB peut permettre plus de perturbations que prévu.
Conséquence : Pendant une mise à jour progressive ou après une panne partielle, le PDB peut ne pas protéger comme prévu, entraînant des baisses de disponibilité.
Comment l'éviter : Assurez-vous que les sondes de disponibilité sont correctement configurées. Surveillez la disponibilité des pods avant la maintenance.
Récupération : Ajustez les sondes de disponibilité ou marquez manuellement les pods comme prêts si sûr.
Piège 3 : Ne pas mettre à jour les PDB après la mise à l'échelle
Pourquoi cela arrive : Les PDB sont statiques ; lorsque vous mettez à l'échelle un déploiement, le PDB ne s'ajuste pas automatiquement. Un minAvailable: 3 sur un déploiement à 5 répliques devient trop restrictif après une réduction à 3 répliques (tous les pods doivent rester disponibles, donc aucune perturbation autorisée).
Conséquence : La maintenance devient impossible jusqu'à ce que le PDB soit mis à jour.
Comment l'éviter : Utilisez des pourcentages lorsque cela est approprié, ou mettez à jour les spécifications du PDB lors de la mise à l'échelle. Incorporez la révision du PDB dans le processus de mise à l'échelle. Propriétaire : Priya Shah, responsable plateforme, révise mensuellement.
Récupération : Mettez à jour le PDB pour correspondre au nouveau nombre de répliques.
Piège 4 : Chevauchement des sélecteurs
Pourquoi cela arrive : Plusieurs équipes créent des PDB pour les mêmes étiquettes sans coordination.
Conséquence : Des budgets conflictuels peuvent conduire à des décisions d'éviction imprévisibles ou un PDB prenant le pas sur un autre.
Comment l'éviter : Utilisez des sélecteurs uniques et spécifiques à la charge de travail. Documentez la propriété des PDB. Auditez régulièrement avec kubectl get pdb --all-namespaces.
Récupération : Identifiez les PDB qui se chevauchent et consolidez ou divisez les sélecteurs.
Piège 5 : Oublier que les PDB bloquent le Cluster Autoscaler
Pourquoi cela arrive : Le Cluster Autoscaler essaie de supprimer les nœuds sous-utilisés mais ne peut pas évincer les pods si le PDB l'en empêche.
Conséquence : Les nœuds restent, augmentant les coûts.
Comment l'éviter : Assurez-vous que les PDB permettent au moins une perturbation de pod. Pour les charges de travail sans état, envisagez de définir minAvailable à replicas - 1.
Récupération : Ajustez le PDB ou drainez manuellement le nœud après un changement temporaire du PDB.
Liste de contrôle opérationnelle
Utilisez cette liste de contrôle pour exploiter les PDB efficacement de manière continue. Attribuez chaque élément à un seul propriétaire responsable et une fréquence de révision.
| Vérification | Commande/Action | Résultat attendu | Propriétaire | Fréquence de révision |
|---|---|---|---|---|
| Vérifier le statut du PDB | kubectl get pdb --all-namespaces | Tous les PDB affichent les perturbations autorisées attendues | Priya Shah, responsable plateforme | Hebdomadaire |
| Tester l'éviction des pods | kubectl drain <node> --dry-run=server | Aucune violation du PDB | Marcus Chen, administrateur BD | Avant chaque maintenance |
| Réviser les sélecteurs PDB | Inspecter le YAML ou kubectl describe pdb | Le sélecteur correspond aux pods prévus | Elena Rodriguez, SRE | Mensuel |
| Surveiller pendant la maintenance | Exécuter le drainage et surveiller les évictions bloquées | Aucune éviction bloquée inattendue | SRE de garde | Pendant la maintenance |
| Sauvegarder les manifestes PDB | Stocker dans le contrôle de version | Pouvoir restaurer la configuration précédente | Priya Shah, responsable plateforme | Continu |
| Auditer la couverture PDB | Comparer les charges de travail à la liste PDB | Chaque charge de travail critique a un PDB | Elena Rodriguez, SRE | Trimestriel |
Révision périodique
- Révisez les PDB trimestriellement ou après des changements d'application. Ajustez les budgets à mesure que le nombre de répliques évolue.
- Assurez-vous que les PDB ne sont pas trop restrictifs, provoquant des goulots d'étranglement de maintenance.
- Confirmez que toutes les charges de travail critiques ont des PDB et que les sélecteurs sont exacts.
- Suivez les changements dans le contrôle de version et documentez la justification de chaque budget.
Intégration des PDB dans CI/CD et GitOps
Pour garder les PDB cohérents avec les changements d'application, incluez-les dans vos pipelines de déploiement.
Exemple : Dans une configuration GitOps utilisant Argo CD ou Flux, stockez les manifestes PDB aux côtés des manifestes de Deployment dans le même référentiel. Utilisez Kustomize ou Helm pour modéliser les budgets en fonction du nombre de répliques.
Par exemple, un chart Helm peut définir :
podDisruptionBudget:
enabled: true
minAvailable: {{ .Values.replicaCount | sub 1 }}
Cela ajuste automatiquement le budget lorsque le nombre de répliques change (en supposant que replicaCount > 1).
Dans CI/CD, incluez une étape pour valider les PDB :
kubectl apply --dry-run=client -f pdb.yaml
Ou utilisez un moteur de politiques comme OPA ou Kyverno pour imposer que chaque Deployment ait un PDB correspondant.
Conclusion
Les budgets de perturbation de pods sont essentiels pour maintenir la disponibilité des applications pendant les perturbations volontaires dans Kubernetes. En comprenant l'architecture, en configurant les PDB en toute sécurité, en vérifiant leur comportement et en vous préparant aux modes de défaillance, vous pouvez exploiter vos clusters avec plus de confiance.
Commencez par un PDB étroitement ciblé pour une charge de travail critique, surveillez son comportement et étendez progressivement à d'autres services. Révisez régulièrement les budgets pour les aligner sur les exigences de disponibilité de votre application et les besoins opérationnels. N'oubliez pas d'attribuer la propriété et la fréquence de révision pour garder les PDB pertinents à mesure que votre environnement évolue.
Avec les étapes pratiques et les exemples de ce guide, vous êtes équipé pour mettre en œuvre les PDB efficacement et éviter les pièges courants.