Gestionar los límites de ID de proceso

Información general

Un límite de ID de proceso (PID) es una restricción de recursos de Kubernetes en nodos y pods para evitar la creación excesiva de procesos, lo que puede afectar a la estabilidad de los nodos. Apigee Hybrid admite la función de Kubernetes para definir límites de ID de proceso. En este documento se explica cómo definir estos límites y se ofrecen recomendaciones de valores para los servicios de Apigee en plataformas específicas.

Cuando los usuarios de Apigee hybrid gestionan sus propios clústeres, definir límites de PID en Kubernetes puede mejorar la estabilidad, la seguridad y la gestión de recursos del sistema. Esto también se ajusta a las prácticas recomendadas de Kubernetes.

Definiciones de los límites de ID de proceso

Los límites de ID de proceso incluyen límites de PID de nodo y límites de PID de pod.

Los límites de PID de los nodos incluyen los PIDs reservados para Kube y los PIDs reservados para el sistema. El número total de PIDs asignables es el máximo del kernel menos los PIDs reservados para kube, menos los PIDs reservados para el sistema y menos los PIDs del umbral de desalojo:

Límites máximos de ID de kernel
    - Reservado por Kube
    - Reservado por el sistema
    - Umbral de desalojo
= Asignable
  • Límites de ID máximo del kernel: determinados por el sistema operativo y su configuración del kernel. Como Apigee Hybrid se ejecuta exclusivamente en un kernel de Linux, en esta guía se describen los límites basados en Linux en los nodos de Kubernetes. El número máximo de límites de ID de proceso de un kernel de Linux es 4194304.
  • Kube-reserved y system-reserved: para la reserva de recursos para los daemons del sistema de Kubernetes o del SO.
  • Umbral de desalojo: el límite que indica la presión sobre el nodo. El nodo se expulsará cuando se alcance el umbral. Consulta Desalojo basado en PID para obtener más información.
  • Asignables: número de PIDs disponibles. Consulta Kubernetes: Node Allocatable para obtener más información. Kube-reserved y system-reserved se pueden configurar con los ajustes de límite de PID de nodo.

El límite de PID de los pods se puede configurar en el nodo y se comparte entre todos los pods del nodo.

Prepararse para gestionar los límites de ID de proceso

En estos procedimientos se usan las siguientes variables de entorno:

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

Verificar acceso

Antes de configurar el límite de ID de proceso, asegúrate de que tienes acceso para editar clústeres de Kubernetes.

Los siguientes pasos son para instalaciones en GKE. Para obtener información sobre otras plataformas, consulta la documentación correspondiente.

  1. Comprueba si tienes roles/container.clusterAdmin en la política de gestión de identidades y accesos: 
    gcloud projects get-iam-policy ${PROJECT_ID}  \
 --flatten="bindings[].members" \
 --format='table(bindings.role)' \
 --filter="bindings.members:your_account_email"
  2. Si no tienes acceso, añade el rol a tu cuenta: 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
 --member user:your_account_email \
 --role roles/container.clusterAdmin

Verificar los límites de PID actuales

Verifica si el nodo tiene límites de PID antes de configurar nuevos límites.

  1. Obtén un nodo del clúster para comprobar los valores. Deberás comprobar los nodos de los grupos de nodos apigee-data y apigee-runtime: 
    kubectl get nodes -n ${APIGEE_NAMESPACE}

    La salida debería ser similar a la siguiente:

    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. Exporta el nombre del nodo del resultado del paso anterior. Ejecuta este paso primero para un nodo apigee-data y, después, para un nodo apigee-runtime:

    Código

    export NODE_NAME=MY_NODE_NAME

    Ejemplo

    export NODE_NAME="gke-my-hybrid-apigee-data-0a1b2c3d-efgh"
  3. Consulta los límites de PID de los nodos. Usa los siguientes comandos para comprobar los valores reservados. Si el valor es nulo, no se ha configurado: 
    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. Comprueba el límite de PID del pod. Usa el siguiente comando para comprobar el límite de PID de los pods. Si el valor devuelto es -1 o está vacío, el límite no se ha definido: 
    kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.podPidsLimit'

Gestionar los límites de ID de proceso

Gestionar los límites de PID de los nodos

En las instalaciones en GKE, los recursos de infraestructura de los nodos de Kubernetes se gestionan internamente y no es necesario configurarlos. La capacidad actual y los recursos asignables se pueden consultar en la sección Recursos asignables de los nodos de la documentación de Google Kubernetes Engine.

En el caso de las plataformas que no sean de GKE, consulta la documentación de Kubernetes correspondiente a la plataforma. Si el clúster o el nodo los gestiona el usuario (en lugar de estar totalmente gestionados), los límites de PID reservados para kube y para el sistema se pueden configurar con Kubelet. Consulta Límites de PID de nodos en la documentación de Kubernetes.

Herramientas

En este procedimiento se usa Kubelet para gestionar el límite de ID de proceso. Kubelet es el agente que se ejecuta en pods y contenedores, y se asegura de que se ejecuten de acuerdo con su PodSpec. Si necesitas instalar Kubelet, sigue las instrucciones de la documentación de Kubernetes: Instalar kubeadm, kubelet y kubectl.

Procedimiento

  1. Crea un archivo de configuración de Kubelet llamado kubelet-config.yaml. 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
kubeReserved:
 pid: PID_VALUE # Example: 1000

    Consulta más información sobre las configuraciones Kube Reserved en la documentación de Kubernetes.

  2. Aplica la configuración de Kubelet: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML

Gestionar los límites de PID de los pods

Elegir el límite

Si el límite de PID es demasiado bajo, puede impedir que se inicie un pod. Si se define un valor demasiado alto, es posible que no se detecten comportamientos incorrectos de los recursos. Al seleccionar el límite adecuado, es importante tener en cuenta el comportamiento anterior del nodo y los requisitos específicos de cada servicio.

GKE tiene un intervalo obligatorio para el valor: [1024, 4194304]. En las plataformas de GKE, puedes ver el estado de tus cuentas de servicio de Kubernetes en el Google Cloud console Explorador de métricas. Seleccione las métricas Nodo de Kubernetes - Uso de PID y aplique filtros. Esta métrica muestra el uso reciente de los IDs de proceso y se puede consultar al elegir un límite de PID.

Explorador de métricas

En plataformas que no sean de GKE, puede que haya otras opciones de monitorización disponibles. Consulta la documentación de Kubernetes de la plataforma correspondiente para comprobar las métricas.

Requisitos de ID de proceso para pods de Apigee

Apigee Hybrid usa dos grupos de nodos: apigee-data y apigee-runtime. Como algunos de los componentes de Apigee se implementan en ambos grupos de nodos, el límite de PID de pods será el mismo para los dos grupos de nodos. El límite de PID de los pods también debe ser superior al número máximo de PIDs necesarios en todos los pods de Apigee. El límite de PID de pods de Apigee es de 1000, que es inferior al número mínimo necesario para las plataformas de GKE.

Algunas plataformas aplican un requisito de valor mínimo para el límite de PIDs de Pod, en cuyo caso se selecciona el requisito de valor mínimo.

Plataforma Límite mínimo de PID de pod
GKE en Google Cloud 1024
GKE en AWS 1024
GKE en Azure 1024
Google Distributed Cloud (solo software) en VMware 1024
Google Distributed Cloud (solo software) en bare metal 1024
EKS 1000
AKS 1000
OpenShift 1000
Rancher Kubernetes Engine (RKE) 1000

Procedimiento

Los procedimientos para gestionar los límites de PID de los pods son diferentes en las plataformas de GKE y en las que no son de GKE.

Plataforma de GKE

La plataforma GKE que admite la actualización del límite de PID incluye lo siguiente:

El límite de PID de los pods se controla mediante las configuraciones del sistema de nodos. GKE tiene un intervalo obligatorio para el valor: [1024, 4194304]. Para obtener más información, consulta NodeKubeletConfig.

  1. Crea una configuración del sistema de nodos llamada node-config.yaml con un límite de PID de pod designado con el siguiente contenido: 
    kubeletConfig:
 podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Aplica la configuración a los grupos de nodos apigee-data y apigee-runtime de Apigee. Cuando apliques la configuración, el nodo empezará el lanzamiento con una de las estrategias de actualización de nodos sin tiempo de inactividad. 
    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

Plataformas que no son de GKE

En las plataformas que no son de GKE, Kubelet controla el límite de PID de los pods. El límite se define en el campo podPidsLimit del archivo de configuración de Kubelet.

  1. Crea un archivo de configuración de Kubelet llamado kubelet-config.yaml con el siguiente contenido: 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Aplica la configuración. Para definir el valor de podPidsLimit, es necesario reiniciar el nodo afectado, lo que podría provocar un tiempo de inactividad: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML
  3. Verifica la configuración. Consulta las instrucciones en Verificar los límites de PID actuales.

Los comandos de configuración de límites de PID de pods y las recomendaciones de herramientas varían en función de la plataforma. Consulta la documentación de las plataformas correspondientes para ver los comandos detallados. A continuación, se incluyen algunos enlaces a la documentación de plataformas que no son de GKE como referencia. Ten en cuenta que están sujetos a cambios:

Plataforma Documentación
EKS Personalizar nodos gestionados con plantillas de inicio
AKS Personalizar la configuración de los nodos de los grupos de nodos de Azure Kubernetes Service (AKS)
OpenShift Riesgos de establecer límites de ID de proceso más altos para los pods de Red Hat OpenShift Service en AWS
Rancher Kubernetes Engine (RKE) Acceder a un clúster con kubectl y kubeconfig

Solucionar problemas con los límites de ID de proceso

El pod se queda en el estado Pending con un error FailedScheduling

Cuando el límite de PIDs de nodos o pods expulsa o restringe el inicio de un pod, este se quedará en el estado Pending y fallará con el error FailedScheduling.

  1. Obtén la columna Nodo: 
    kubectl get pods -n ${APIGEE_NAMESPACE} ${POD_NAME} -o wide
  2. Comprueba si hay una condición PIDPressure: 
    kubectl describe node -n apigee ${NODE_NAME} | grep PIDPressure
  3. También puedes consultar ApigeeDeployment del pod correspondiente. Obtén el ApigeeDeployment del resultado que tenga el mismo prefijo que el pod que ha devuelto un error. 
    kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
  4. Comprueba si el Events reciente tiene mensajes de error relacionados con el PID: 
    kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
  5. Si se confirma que la causa es el límite de PID, siga los pasos que se indican en Gestionar los límites de PID de los nodos para aumentar el valor del límite de PID.

El campo podPidsLimit no es válido

Al definir el límite de GKE, si el podPidsLimit supera el límite, se mostrará un error: 

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

Actualiza el valor de podPidsLimit para que esté dentro del intervalo necesario.