Gérer les limites d'ID de processus

Présentation

Une limite d'ID de processus (PID) est une contrainte de ressources Kubernetes sur les nœuds et les pods qui empêche la création excessive de processus, ce qui peut avoir un impact sur 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 et recommande des 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é du système, la sécurité et la gestion des ressources. Cette approche 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 les limites de PID de pod.

Les limites de PID de nœud incluent les PID réservés à Kube et les PID réservés au système. Le nombre total de PID pouvant être alloués est le nombre maximal de PID du noyau moins les PID réservés à kube, moins les PID réservés au système, moins les PID du seuil d'éviction :

Limites maximales d'ID de noyau
    - Kube réservé
    - Réservé au système
    - Seuil d'éviction
= Allouable
  • Limites d'ID maximales 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 traite des limites basées sur Linux sur les nœuds Kubernetes. Le nombre maximal d'ID de processus pour un noyau Linux est de 4 194 304.
  • kube-reserved et system-reserved : pour la réservation de ressources pour les daemons système Kubernetes ou de l'OS.
  • Seuil d'éviction : limite qui signale une pression sur le nœud. Le nœud sera expulsé lorsque le seuil sera atteint. Pour en savoir plus, consultez Éviction basée sur le PID.
  • Pouvant être alloués : nombre de PID disponibles. Pour en savoir plus, consultez Kubernetes : Node Allocatable. Vous pouvez configurer les ressources réservées à Kubernetes et au système 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 correspondante.

  1. Vérifiez si vous disposez du rôle roles/container.clusterAdmin 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'y avez pas accès, ajoutez le rô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 possède des limites de PID existantes avant de configurer de nouvelles limites.

  1. Récupérez 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 du résultat de l'étape précédente. Exécutez d'abord l'étape suivante 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. Exécutez 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 existante pour les pods. 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 des nœuds

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 afficher la capacité actuelle et les ressources pouvant être allouées, consultez Ressources de nœud pouvant être allouées dans la documentation de Google Kubernetes Engine.

Pour les plates-formes non GKE, consultez la documentation Kubernetes correspondante. Si le cluster/nœud est géré par l'utilisateur (et non entièrement géré), 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 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 nommé 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 dans la documentation Kubernetes.

  2. Appliquez la configuration 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 trop basse, elle peut empêcher le démarrage d'un pod. Si elle est définie sur une valeur trop élevée, elle risque de ne pas détecter les comportements incorrects des ressources. Lorsque vous sélectionnez la limite appropriée, il est important de prendre en compte le comportement précédent du nœud et les exigences spécifiques au service.

GKE exige une plage de valeurs comprise entre [1024, 4194304]. Sur les plates-formes GKE, vous pouvez consulter l'état de vos comptes de service Kubernetes dans l'explorateur de métriques Google Cloud console . Sélectionnez les métriques Nœud Kubernetes - Utilisation du PID et appliquez des filtres. Cette métrique indique l'utilisation récente des ID de processus et peut être référencée 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 vous reporter à la documentation Kubernetes de la plate-forme correspondante pour vérifier les métriques.

Exigences concernant les ID de processus pour les pods Apigee

Apigee hybrid utilise deux pools de nœuds : apigee-data et apigee-runtime. Étant donné que certains 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 de 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.

Certaines plates-formes imposent une valeur minimale pour la limite du nombre de PID de pod. Dans ce cas, la valeur minimale requise est sélectionnée.

Plate-forme Limite minimale de PID par pod
GKE sur Google Cloud 1 024
Google Distributed Cloud (logiciel uniquement) sur VMware 1 024
Google Distributed Cloud (logiciel uniquement) sur solution Bare Metal 1 024
EKS 1000
AKS 1000
OpenShift 1000
Rancher Kubernetes Engine (RKE) 1000

Procédure

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

Plate-forme GKE

La plate-forme GKE compatible avec la mise à jour de la limite de PID inclut :

La limite de PID des pods est contrôlée par les configurations du système de nœuds. GKE requiert une plage de valeurs : [1024, 4194304]. Pour en savoir plus, consultez NodeKubeletConfig.

  1. Créez une configuration de système de nœuds appelée node-config.yaml avec une limite de PID de pod désignée et le contenu suivant : 
    kubeletConfig:
 podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Appliquez la configuration aux pools de nœuds apigee apigee-data et apigee-runtime. Lorsque vous appliquez la configuration, le nœud commence le déploiement avec l'une des stratégies de mise à niveau de nœud sans temps d'arrêt. 
    gcloud container OPTIONAL_HOST_PLATFORM node-pools update NODE_POOL_NAME \
   --cluster CLUSTER_NAME \
   --region CLUSTER_LOCATION \
   --system-config-from-file=node-config.yaml \
   --project PROJECT_ID

Plates-formes non GKE

Pour les plates-formes non GKE, la limite de PID des pods est contrôlée par Kubelet. La limite est définie par le champ podPidsLimit dans le fichier de configuration Kubelet.

  1. Créez un fichier de configuration Kubelet nommé kubelet-config.yaml avec le contenu suivant : 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Appliquez la configuration. La définition de podPidsLimit nécessite le redémarrage du nœud concerné, ce qui peut entraîner un temps d'arrêt : 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML
  3. Vérifiez la configuration. Pour obtenir des instructions, consultez Vérifier les limites de PID existantes.

Les commandes de configuration des limites de PID des pods et les recommandations d'outils diffèrent selon les plates-formes. Pour connaître les commandes détaillées, consultez la documentation des plates-formes respectives. Vous trouverez ci-dessous des liens vers la documentation de plates-formes autres que GKE. Notez qu'ils sont susceptibles d'être modifiés :

Plate-forme Documentation
EKS Personnaliser des nœuds gérés avec des modèles de lancement
AKS Personnaliser la configuration des nœuds pour les pools de nœuds Azure Kubernetes Service (AKS)
OpenShift Risques liés à la définition de limites d'ID de processus plus élevées pour les pods Red Hat OpenShift Service sur AWS
Rancher Kubernetes Engine (RKE) Accéder à un cluster avec Kubectl et kubeconfig

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 de PID de nœud ou de pod expulse un pod ou l'empêche de démarrer, le pod reste bloqué à l'état Pending et échoue avec l'erreur FailedScheduling.

  1. Obtenez la colonne "Node" : 
    kubectl get pods -n ${APIGEE_NAMESPACE} ${POD_NAME} -o wide
  2. Vérifiez s'il existe une condition PIDPressure : 
    kubectl describe node -n apigee ${NODE_NAME} | grep PIDPressure
  3. Vous pouvez également vérifier le ApigeeDeployment du pod correspondant. Récupérez le ApigeeDeployment du résultat qui a le même préfixe que le pod défaillant. 
    kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
  4. Vérifiez si le Events récent contient des messages d'erreur liés au PID : 
    kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
  5. S'il est confirmé que la cause est la limite de PID, suivez les étapes de la section Gérer les limites de PID des nœuds pour augmenter la limite de PID.

Champ podPidsLimit non valide

Lorsque vous définissez la limite pour GKE, si la valeur de podPidsLimit dépasse la limite, un message d'erreur s'affiche : 

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

Mettez à jour la valeur podPidsLimit pour qu'elle se situe dans la plage requise.