Configurer PodDisruptionBudget pour les déploiements Dynamic Engine

Last updated: 07/08/2026

Activez, désactivez et affinez les paramètres PodDisruptionBudget dans les charts d'instance et d'environnement Helm.

Dans Kubernetes, un objet PodDisruptionBudget définit la manière dont de nombreux pods peuvent être volontairement perturbés en même temps. Pour des informations générales, consultez Perturbations de pods (en anglais).

PodDisruptionBudget permet de maintenir les services disponibles lors de perturbations volontaires telles que la maintenance des nœuds ou la mise à échelle de clusters. Appliquez cette procédure lors d'un déploiement initial ou lorsque vous mettez une version existante à niveau.

Le support de PodDisruptionBudget Kubernetes a été lancé dans Dynamic Engine v1.6.0.

Avant de commencer

Les définitions des ressources personnalisées dynamic-engine-crd doivent avoir été installées à l'aide du chart Helm oci://ghcr.io/talend/helm/dynamic-engine-crd. Si ce n'est pas le cas, exécutez les commandes suivantes pour l'installation :
1. Trouvez la version du chart à utiliser :
  - Exécutez la commande Helm suivante :
    helm show chart oci://ghcr.io/talend/helm/dynamic-engine-crd --version <engine_version>
  - Visualisez la version directement depuis Talend Management Console ou consultez le Dynamic Engine journal de modification de la version du chart dans votre version de Dynamic Engine.
  - Utilisez un appel d'API pour l'endpoint de version de Dynamic Engine (en anglais).
2. Exécutez la commande suivante pour installer le chart Helm dans une version donnée :
```
helm install dynamic-engine-crd oci://ghcr.io/talend/helm/dynamic-engine-crd --version <helm_chart_version>
```
  Remplacez <helm_chart_version> par la version du chart supportée par votre version du Dynamic Engine.
  Si vous ne spécifiez pas la version, vous installez la dernière version disponible du chart dynamic-engine-crd.
Votre cluster Kubernetes supporte les ressources PodDisruptionBudget.
Vous avez des connaissances de base de Kubernetes PodDisruptionBudget (en anglais).

Pourquoi et quand exécuter cette tâche

Important :

Si vous planifiez d'utiliser EKS Auto Mode ou GKE Autopilot, il est recommandé de commencer par configurer PodDisruptionBudget avant de passer au déploiement. Utilisez-le avec global.profile: minimal et configuration.persistence.enabled=false.

Les Jobs d'intégration de données utilisent le paramètre PodDisruptionBudget général par défaut et n'exposent pas un paramètre au niveau de la tâche séparé. La personnalisation au niveau de la tâche est disponible uniquement pour les tâches de services de données et de Routes.

Un Pod Disruption Budget (PDB) s'avère généralement utile pour :

Protéger les services essentiels des risques d'éviction lors de la maintenance des clusters
Garantir des quotas minimaux de disponibilité des pods (nombres de pods indisponibles minimal et maximal)
Obtenir un équilibre entre disponibilité et flexibilité opérationnelle des clusters
Éviter les échecs en cascade lors de perturbations de pods coordonnées

Procédure

Définissez les variables de déploiement de l'exemple.
```
DYNAMIC_ENGINE_VERSION=1.6.0
DYNAMIC_ENGINE_ID=c-m-sjufu4qy
DYNAMIC_ENGINE_ENVIRONMENT_ID=684c3baec6a6f88f61e9d59d
```
Remplacez les valeurs de l'exemple par les identificateurs de votre déploiement.
Créez un fichier de valeurs personnalisé qui active PodDisruptionBudget globalement.

Par défaut, les charts ne créent pas de ressources PodDisruptionBudget. Définissez global.pdb.enabled sur true pour créer les ressources PDB par défaut pour les deux charts.

Définissez global.pdb.enabled sur true avant de personnaliser configuration.dataServiceRouteDeployment.podDisruptionBudget. Le chart d'environnement lit ces valeurs uniquement lorsque l'indicateur global est activé.
```
cat <<EOF > custom-pdb-values.yaml
global:
  pdb:
    enabled: true
EOF
```
Ce fichier active les ressources PDB par défaut pour l'instance de Dynamic Engine et ses environnements. Cette configuration globale a une contrainte quant au nombre maximal de pods indisponibles définie sur 0. Il s'agit également de la règle PDB par défaut pour les tâches de services de données et de Routes du chart d'environnement. Les Jobs d'intégration de données utilisent uniquement cette règle PDB globale.

Installez ou mettez à niveau les charts d'environnement et d'instance Dynamic Engine avec le fichier de valeurs PDB global.

helm upgrade --install dynamic-engine-$DYNAMIC_ENGINE_ID \
 -f $DYNAMIC_ENGINE_ID-values.yaml  \
 -f custom-pdb-values.yaml \
 oci://ghcr.io/talend/helm/dynamic-engine \
 --version $DYNAMIC_ENGINE_VERSION

helm upgrade --install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID \
 -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml  \
 -f custom-pdb-values.yaml \
 oci://ghcr.io/talend/helm/dynamic-engine-environment \
 --version $DYNAMIC_ENGINE_VERSION

Définissez des règles PodDisruptionBudget personnalisées pour les tâches de services de données et de Routes, si nécessaire.
1. Créez un fichier de valeurs personnalisé avec vos règles PDB de services de données et de Routes.
```
cat <<EOF > custom-pdb-data-services-routes-values.yaml
global:
  pdb:
    enabled: true
configuration:
  dataServiceRouteDeployment:
    podDisruptionBudget:
      maxUnavailable: 1
      minAvailable: ~
      unhealthyPodEvictionPolicy: AlwaysAllow # or IfHealthyBudget
EOF
```
  - Les propriétés maxUnavailable et minAvailable sont mutuellement exclusives. Définissez minAvailable sur ~ lorsque vous définissez maxUnavailable.
    Si vous préférez conserver un nombre minimal de pods disponibles, définissez minAvailable à la place et laissez maxUnavailable défini sur ~.
  - Utilisez unhealthyPodEvictionPolicy pour contrôler quand Kubernetes peut détruire des pods manquant d'intégrité. Les valeurs acceptées sont AlwaysAllow et IfHealthyBudget.
    
    Pour des informations détaillées sur la politique de destruction des pods manquant d'intégrité, consultez la section Politique de destruction des pods manquant d'intégrité (en anglais) dans la documentation Kubernetes.
2. Mettez à niveau le chart d'environnement avec les règles PDB personnalisées des services de données et des Routes.
```
helm upgrade --install dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID \
 -f $DYNAMIC_ENGINE_ENVIRONMENT_ID-values.yaml  \
 -f custom-pdb-values.yaml \
 -f custom-pdb-data-services-routes-values.yaml \
 oci://ghcr.io/talend/helm/dynamic-engine-environment \
 --version $DYNAMIC_ENGINE_VERSION
```

Désactivez temporairement PodDisruptionBudget lorsque vous devez procéder à une maintenance sans restriction.

Exécutez les commandes suivantes pour désactiver PDB sans modifier le reste des valeurs de la version.

helm upgrade dynamic-engine-$DYNAMIC_ENGINE_ID \
oci://ghcr.io/talend/helm/dynamic-engine --version $DYNAMIC_ENGINE_VERSION \
--reuse-values --set global.pdb.enabled=false

helm upgrade dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID \
oci://ghcr.io/talend/helm/dynamic-engine-environment --version $DYNAMIC_ENGINE_VERSION \
--reuse-values --set global.pdb.enabled=false

Résultats

L'instance de Dynamic Engine et son environnement utilisent maintenant les paramètres PodDisruptionBudget sélectionnés. Utilisez les commandes suivantes pour confirmer les valeurs Helm actives :

helm get values dynamic-engine-$DYNAMIC_ENGINE_ID --output json | jq -r '.global.pdb'
helm get values dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID --output json | jq -r '.global.pdb'

Si null est renvoyé, le chart utilise les valeurs par défaut et aucune ressource PodDisruptionBudget n'est créée.

Résolution de problèmes :

Si des perturbations de pods sont rejetées ou si des erreurs PDB apparaissent, vérifiez les points suivants :

Vérifiez que les ressources PDB ont correctement été créées via
```
kubectl get pdb -A -l 'app.kubernetes.io/part-of=qlik-dynamic-engine'
```
Recherchez les ressources PDB dans les espaces de noms qlik-dynamic-engine et qlik-processing-env-<env-id>.
Consultez l'état d'une ressource PDB via
```
kubectl describe pdb <pdb-name> -n <namespace>
```
Vérifiez les champs Disruptions Allowed (Perturbations autorisées), Current Healthy (Intégrité actuelle) et Desired Healthy (Intégrité souhaitée).
Vérifiez que le nombre de pods est suffisant pour satisfaire les contraintes PDB via
```
kubectl get pods -n <namespace> -l app=<service-name>
```
Si vous avez défini minAvailable: 1 alors qu'il n'existe qu'un seul pod, le PDB n'autorise aucune perturbation. Pensez à ajuster les contraintes PDB ou à augmenter le nombre de répliques.

Examinez les événements associés aux rejets de perturbations via

kubectl get events -n <namespace> --sort-by=.lastTimestamp | grep -i disruption

Que faire ensuite

Si vous devez temporairement autoriser toutes les perturbations à des fins de maintenance et que vous ne souhaitez pas réduire le nombre de répliques en cours, désactivez PDB via les commandes suivantes :

# for dynamic engine
helm upgrade dynamic-engine-$DYNAMIC_ENGINE_ID \
oci://ghcr.io/talend/helm/dynamic-engine --version $DYNAMIC_ENGINE_VERSION \
--reuse-values --set global.pdb.enabled=false

# for dynamic engine environment
helm upgrade dynamic-engine-environment-$DYNAMIC_ENGINE_ENVIRONMENT_ID \
oci://ghcr.io/talend/helm/dynamic-engine-environment --version $DYNAMIC_ENGINE_VERSION \
--reuse-values --set global.pdb.enabled=false

Ces commandes désactivent les règles PDB sans modifier les valeurs Helm existantes.

Cette page vous a-t-elle aidé ?

Si vous rencontrez des problèmes sur cette page ou dans son contenu – une faute de frappe, une étape manquante ou une erreur technique – faites-le-nous savoir.

Laissez vos commentaires ici