Gérer les limites d'ID de processus

Présentation

Une limite d'ID de processus (PID) est une contrainte de ressource Kubernetes sur les nœuds et les pods pour empêcher la création excessive de processus, 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 fournit 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, la définition de limites de PID dans Kubernetes peut améliorer la stabilité, la sécurité et la gestion des ressources du système. Cela correspond également aux bonnes pratiques de Kubernetes.

Définitions des limites d'ID de processus

Les limites d'ID de processus incluent les limites d'ID de processus de nœud et 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 correspond au 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 du kernel
    - Kube réservé
    - Réservé au système
    - Seuil d'expulsion
= Allouable
  • 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 aborde 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 4 194 304.
  • kube-reserved et system-reserved : pour la réservation de ressources pour les daemons système Kubernetes ou 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é : nombre de PID disponibles. Pour en savoir plus, consultez Kubernetes : capacité allouable des nœuds. Les paramètres de limite de PID de nœud permettent de configurer kube-reserved et system-reserved.

La limite de PID de 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

Cette procédure utilise 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 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 devrez 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 à nouveau 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, cela signifie qu'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 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. Vous pouvez consulter la capacité actuelle et les ressources pouvant être allouées en suivant Ressources pouvant être allouées aux nœuds dans la documentation de Google Kubernetes Engine.

Pour les plates-formes autres que GKE, consultez la documentation Kubernetes correspondante. Si le cluster/nœud est géré par l'utilisateur (par opposition à "entièrement géré"), les limites de PID kube-reserved et system-reserved peuvent être configurées avec Kubelet. Consultez Limites de PID des nœuds 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 fonctionnent 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 dans la documentation de 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, un pod peut ne pas démarrer. S'il est défini sur une valeur trop élevée, il peut ne pas détecter les comportements inappropriés 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 des exigences spécifiques à chaque service.

GKE possède une plage de valeurs requise : [1024, 4194304]. 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 et appliquez des filtres. Cette métrique indique l'utilisation récente des ID de processus et peut être consulté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 consulter 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 le nombre de PID de pod. Dans ce cas, la valeur minimale requise est sélectionnée.

Plate-forme Limite minimale du PID du pod
GKE sur Google Cloud 1 024
GKE sur AWS 1 024
GKE sur Azure 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 de pod sont différentes pour les plates-formes GKE et non-GKE.

Plate-forme GKE

Voici les plates-formes GKE qui permettent de mettre à jour la limite de PID :

La limite de PID de pod est contrôlée par les configurations de système de nœud. GKE possède une plage de valeurs requise : [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, avec 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 autres que GKE, la limite de PID de pod est contrôlée par Kubelet. Cette 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 de pod et les recommandations d'outils varient selon les plates-formes. Pour obtenir des commandes détaillées, consultez la documentation des plates-formes concernées. Vous trouverez ci-dessous des liens vers la documentation de plates-formes autres que GKE pour référence. Notez qu'elles sont susceptibles d'être modifiées :

Plate-forme Documentation
EKS Personnaliser les 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 on 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 évince 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 consulter ApigeeDeployment du pod correspondant. Obtenez le ApigeeDeployment à partir du résultat qui a le même préfixe que le pod en erreur. 
    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. Si la limite de PID est confirmée comme étant la cause, suivez les étapes décrites dans 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 podPidsLimit dépasse la limite, l'erreur suivante 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.