Gérer les limites d'ID de processus

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Présentation

Une limite d'ID de processus (PID) est une contrainte de ressources Kubernetes appliquée aux nœuds et aux pods pour éviter la création excessive de processus, ce qui peut affecter la stabilité des nœuds. Apigee Hybrid est compatible avec la fonctionnalité Kubernetes permettant de définir des limites d'ID de processus. Ce document explique comment définir ces limites, avec des recommandations de valeurs pour les services Apigee sur des plates-formes spécifiques.

Lorsque les utilisateurs d'Apigee hybrid gèrent leurs propres clusters, définir des limites de PID dans Kubernetes peut améliorer la stabilité, la sécurité et la gestion des ressources du système. Cela est également conforme aux bonnes pratiques Kubernetes.

Définitions des limites d'ID de processus

Les limites d'ID de processus incluent les limites de PID de nœud et de PID de pod.

Les limites de PID de nœud incluent les PID réservés par Kube et les PID réservés par le système. Le nombre total de PID allouables correspond au nombre maximal de kernel moins les PID réservés par kube, moins les PID réservés par le système, moins les PID du seuil d'éviction:

• Limites d'ID maximal du noyau: déterminées par le système d'exploitation et ses paramètres de noyau. Étant donné qu'Apigee Hybrid s'exécute exclusivement sur un noyau Linux, ce guide décrit les limites basées sur Linux sur les nœuds Kubernetes. Le nombre maximal de limites d'ID de processus pour un noyau Linux est de 4194304.
• Kube-reserved et system-reserved: pour la réservation de ressources pour les daemons système Kubernetes ou d'OS.
• Seuil d'éviction: limite qui signale la pression sur le nœud. Le nœud sera supprimé lorsque le seuil sera atteint. Pour en savoir plus, consultez la section Éviction basée sur le PID.
• Pouvant être alloué: nombre de PID disponibles. Pour en savoir plus, consultez Kubernetes: Node Allocatable. Les valeurs Kube-reserved et system-reserved peuvent être configurées avec les paramètres de limite de PID de nœud.

La limite de PID du pod peut être configurée pour le nœud et partagée entre tous les pods du nœud.

Préparer la gestion des limites d'ID de processus

Ces procédures utilisent les variables d'environnement suivantes:

export PROJECT_ID=MY_PROJECT_ID
export CLUSTER_NAME=MY_CLUSTER_NAME
export LOCATION=MY_CLUSTER_LOCATION
export APIGEE_NAMESPACE=MY_APIGEE_NAMESPACE # Default: apigee

Vérifier l'accès

Avant de configurer la limite d'ID de processus, assurez-vous d'avoir accès à la modification des clusters Kubernetes.

Les étapes suivantes concernent les installations sur GKE. Pour les autres plates-formes, consultez la documentation de votre plate-forme.

1. Vérifiez si roles/container.clusterAdmin figure dans la stratégie IAM:

   gcloud projects get-iam-policy ${PROJECT_ID}  \
    --flatten="bindings[].members" \
    --format='table(bindings.role)' \
    --filter="bindings.members:your_account_email"
   

2. Si vous n'avez pas accès à ce rôle, ajoutez-le à votre compte:

   gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member user:your_account_email \
    --role roles/container.clusterAdmin

Vérifier les limites de PID existantes

Vérifiez si le nœud dispose déjà de limites de PID avant de configurer de nouvelles limites.

1. Obtenez un nœud du cluster pour vérifier les valeurs. Vous devez vérifier les nœuds des pools de nœuds apigee-data et apigee-runtime:

   kubectl get nodes -n ${APIGEE_NAMESPACE}
   

   Vous devriez obtenir un résultat semblable à celui-ci :

   NAME                                      STATUS   ROLES    AGE    VERSION
   gke-my-hybrid-apigee-data-0a1b2c3d-efgh      Ready       2d8h   v1.31.5-gke.1169000
   gke-my-hybrid-apigee-runtime-1b2c3d4e-fghi   Ready       2d8h   v1.31.5-gke.1169000
   

2. Exportez le nom du nœud à partir de la sortie de l'étape précédente. Exécutez l'étape suivante d'abord pour un nœud apigee-data, puis pour un nœud apigee-runtime :

   Code

   export NODE_NAME=MY_NODE_NAME
   

   Exemple

   export NODE_NAME="gke-my-hybrid-apigee-data-0a1b2c3d-efgh"
   

3. Vérifiez les limites de PID du nœud. Utilisez les commandes suivantes pour vérifier les valeurs réservées. Si la valeur est nulle, elle n'est pas configurée:

   kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.kubeReserved'
   kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.systemReserved'
   kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.evictionHard'
   

4. Vérifiez la limite de PID du pod. Exécutez la commande suivante pour vérifier la limite de PID de pod existante. Si la valeur renvoyée est -1 ou vide, la limite n'est pas définie:

   kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.podPidsLimit'
   

Gérer les limites d'ID de processus

Gérer les limites de PID de nœud

Pour les installations sur GKE, les ressources d'infrastructure des nœuds Kubernetes sont gérées en interne et vous n'avez pas besoin de les configurer. Pour consulter la capacité et les ressources allouables actuelles, consultez la section Ressources allouables de nœud dans la documentation de Google Kubernetes Engine.

Pour les plates-formes autres que GKE, consultez la documentation Kubernetes correspondante pour la plate-forme. Si le cluster/nœud est géré par l'utilisateur (par opposition à "Géré entièrement"), la limite de PID réservée à Kube et la limite de PID réservée au système peuvent être configurées avec Kubelet. Consultez la section Limites de PID de nœud dans la documentation Kubernetes.

Outils

Cette procédure utilise Kubelet pour gérer la limite d'ID de processus. Kubelet est l'agent qui s'exécute sur les pods et les conteneurs pour s'assurer qu'ils s'exécutent conformément à leur PodSpec. Si vous devez installer Kubelet, suivez les instructions de la documentation Kubernetes: Installer kubeadm, Kubelet et kubectl.

Procédure

1. Créez un fichier de configuration Kubelet appelé kubelet-config.yaml.

   apiVersion: kubelet.config.k8s.io/v1beta1
   kind: KubeletConfiguration
   kubeReserved:
    pid: PID_VALUE # Example: 1000
   

   Pour en savoir plus sur les configurations, consultez Kube Reserved (Réservé par Kube) dans la documentation Kubernetes.

2. Appliquez la configuration du Kubelet:

   kubelet --config PATH_TO_KUBELET_CONFIG_YAML
   

Gérer les limites de PID des pods

Choisir la limite

Si la limite de PID est définie trop bas, elle peut empêcher le démarrage d'un pod. Si elle est définie trop haut, elle risque de ne pas détecter les comportements incorrects des ressources. Lorsque vous sélectionnez la limite appropriée, il est important de tenir compte du comportement précédent du nœud et de toute exigence spécifique au service.

GKE impose une plage de valeurs obligatoire: [1 024, 419 4304]. Sur les plates-formes GKE, vous pouvez consulter l'état de vos comptes de service Kubernetes dans l' Google Cloud console explorateur de métriques. Sélectionnez les métriques Nœud Kubernetes - Utilisation du PID, puis appliquez des filtres. Cette métrique indique l'utilisation récente des ID de processus et peut être utilisée comme référence lors du choix d'une limite de PID.

Explorateur de métriques

Sur les plates-formes autres que GKE, différentes options de surveillance peuvent être disponibles. Veuillez consulter la documentation Kubernetes de la plate-forme correspondante pour vérifier les métriques.

Exigences concernant l'ID de processus pour les pods Apigee

Apigee hybrid utilise deux pools de nœuds, apigee-data et apigee-runtime. Étant donné que certains des composants Apigee sont déployés dans les deux pools de nœuds, la limite de PID de pod doit être la même pour les deux pools de nœuds. La limite de PID du pod doit également être supérieure au nombre maximal de PID requis pour tous les pods Apigee. La limite de PID de pod Apigee requise est de 1 000, ce qui est inférieur au nombre minimal requis pour les plates-formes GKE.

Limite de PID de pod recommandée

Certaines plates-formes appliquent une valeur minimale pour le nombre de PID de pod. Dans ce cas, la valeur minimale est sélectionnée.

Procédure

Les procédures de gestion des limites de PID de pod sont différentes pour les plates-formes GKE et non-GKE.

Résoudre les problèmes liés aux limites d'ID de processus

Pod bloqué à l'état Pending avec une erreur FailedScheduling

Lorsque la limite des PID du nœud ou du pod expulse ou empêche le démarrage d'un pod, celui-ci reste bloqué à l'état Pending et échoue avec l'erreur FailedScheduling.

1. Obtenez la colonne "Nœud" :

   kubectl get pods -n ${APIGEE_NAMESPACE} ${POD_NAME} -o wide
   

2. Vérifiez si une condition PIDPressure est définie:

   kubectl describe node -n apigee ${NODE_NAME} | grep PIDPressure
   

3. Vous pouvez également vérifier ApigeeDeployment du pod correspondant. Obtenez le ApigeeDeployment du résultat qui a le même préfixe que le pod à l'origine de l'erreur.

   kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
   

4. Vérifiez si l'Events récente contient des messages d'erreur liés au PID:

   kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
   

5. Si la limite de PID est confirmée comme étant la cause du problème, suivez la procédure décrite dans Gérer les limites de PID du nœud pour définir une valeur plus élevée pour la limite de PID.

Champ podPidsLimit non valide

Lorsque vous définissez la limite pour GKE, si podPidsLimit dépasse la limite, une erreur s'affiche:

ERROR: (gcloud.container.node-pools.update) ResponseError: code=400, message=Invalid podPidsLimit : value must be 1024 <= podPidsLimit <= 4194304.

Modifiez la valeur podPidsLimit pour qu'elle se situe dans la plage requise.