Administra los límites de ID de proceso

Descripció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 la estabilidad del nodo. Apigee Hybrid admite la función de Kubernetes para establecer límites de ID de proceso. En este documento, se proporcionan instrucciones para establecer estos límites, con recomendaciones de valores para los servicios de Apigee en plataformas específicas.

Cuando los usuarios de Apigee hybrid administran sus propios clústeres, establecer límites de PID en Kubernetes puede mejorar la estabilidad, la seguridad y la administración de recursos del sistema. Esto también es coherente con las prácticas recomendadas de Kubernetes.

Definiciones de los límites de IDs de procesos

Los límites de ID de proceso incluyen los límites de PID de nodos y los límites de PID de Pods.

Los límites de PID del nodo incluyen los PID reservados para Kube y los PID reservados para el sistema. La cantidad total de PID asignables es la cantidad máxima del kernel menos los PID reservados para kube, los PID reservados para el sistema y los PID del umbral de desalojo:

Límites máximos de ID del kernel
    - Kube reserved
    - Reservado por el sistema
    - Umbral de desalojo
= Asignable
  • Límites de ID máximos del kernel: Están determinados por el sistema operativo y la configuración del kernel. Dado que Apigee Hybrid se ejecuta exclusivamente en un kernel de Linux, en esta guía se analizan los límites basados en Linux en los nodos de Kubernetes. La cantidad máxima de límites de ID de proceso para un kernel de Linux es de 4194304.
  • Kube-reserved y system-reserved: Se usan para la reserva de recursos para los daemons del sistema operativo o de Kubernetes.
  • Umbral de desalojo: Es el límite que indica presión en el nodo. El nodo se desalojará cuando se alcance el umbral. Consulta Expulsión basada en el PID para obtener más detalles.
  • Asignable: Es la cantidad de PIDs disponibles. Consulta Kubernetes: Node Allocatable para obtener más información. Kube-reserved y system-reserved se pueden configurar con la configuración del límite de PID del nodo.

El límite de PID del Pod se puede configurar para el nodo y se comparte entre todos los Pods dentro del nodo.

Prepárate para administrar 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

Verifica el acceso

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

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

  1. Verifica si tienes roles/container.clusterAdmin en la política de IAM: 
    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, agrega el rol a tu cuenta: 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
 --member user:your_account_email \
 --role roles/container.clusterAdmin

Verifica los límites de PID existentes

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

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

    El resultado debería ser similar al 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 desde el resultado del paso anterior. Primero, ejecuta este paso para un nodo apigee-data y, luego, 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. Verifica los límites del PID del nodo. Usa los siguientes comandos para verificar los valores reservados. Si el valor es nulo, no se configuró el valor: 
    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. Verifica el límite de PID del pod. Usa el siguiente comando para verificar el límite de PID del pod existente. Si el valor que se muestra es -1 o está vacío, no se establece el límite: 
    kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.podPidsLimit'

Administra los límites de IDs de proceso

Administra los límites del PID del nodo

En el caso de las instalaciones en GKE, los recursos de infraestructura de los nodos de Kubernetes se administran de forma interna y no es necesario configurarlos. La capacidad actual y los recursos asignables se pueden consultar en Recursos asignables del nodo en la documentación de Google Kubernetes Engine.

En el caso de las plataformas que no son de GKE, consulta la documentación de Kubernetes correspondiente a la plataforma. Si el clúster o el nodo son administrados por el usuario (en lugar de estar completamente administrados), el límite de PID reservado para kubelet y el límite de PID reservado para el sistema se pueden configurar con Kubelet. Consulta Límites de PID del nodo en la documentación de Kubernetes.

Herramientas

En este procedimiento, se usa Kubelet para administrar el límite de ID de proceso. Kubelet es el agente que se ejecuta en los Pods y los contenedores, y garantiza que se ejecuten según su PodSpec. Si necesitas instalar Kubelet, sigue las instrucciones de la documentación de Kubernetes: Cómo 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

    Para obtener más información sobre las configuraciones, consulta Kube Reserved en la documentación de Kubernetes.

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

Administra los límites del PID de Pod

Cómo elegir el límite

Si el límite de PID se establece demasiado bajo, puede impedir que se inicie un pod. Si se establece demasiado alto, es posible que no detecte los problemas de comportamiento de los recursos. Cuando selecciones el límite adecuado, es importante tener en cuenta el comportamiento anterior del nodo y los requisitos específicos del servicio.

GKE tiene un rango 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. Selecciona las métricas de Nodo de Kubernetes: uso del PID y aplica filtros. Esta métrica muestra el uso reciente de los IDs de procesos y se puede consultar cuando se elige un límite de PID.

Explorador de métricas

En las plataformas que no son de GKE, es posible que haya diferentes opciones de supervisión disponibles. Consulta la documentación de Kubernetes de la plataforma correspondiente para verificar las métricas.

Requisitos de ID de proceso para los Pods de Apigee

Apigee Hybrid usa 2 grupos de nodos: apigee-data y apigee-runtime. Dado que algunos de los componentes de Apigee se implementan en ambos grupos de nodos, el límite de PID de Pod debe ser el mismo para los dos grupos de nodos. El límite de PID del Pod también debe ser superior a la cantidad máxima de PID requeridas en todos los Pods de Apigee. El límite de PID de Pod de Apigee requerido es de 1,000, que es inferior a la cantidad mínima requerida para las plataformas de GKE.

Algunas plataformas exigen un valor mínimo para la cantidad de PIDs del 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 equipos físicos 1024
EKS 1000
AKS 1000
OpenShift 1000
Rancher Kubernetes Engine (RKE) 1000

Procedimiento

Los procedimientos para administrar los límites de PID de Pod son diferentes para las plataformas de GKE y las que no son de GKE.

Plataforma de GKE

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

El límite de PID de Pod se controla con las configuraciones del sistema de nodos. GKE tiene un rango 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 apigee-data y apigee-runtime. Cuando aplicas la configuración, el nodo comenzará 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 del Pod. El límite se establece con el campo podPidsLimit en el 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. Establecer el parámetro podPidsLimit requiere reiniciar el nodo afectado, lo que podría generar tiempo de inactividad: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML
  3. Verifica la configuración Consulta Cómo verificar los límites de PID existentes para obtener instrucciones.

Los comandos de configuración de límites del PID del Pod y las recomendaciones de herramientas varían según las diferentes plataformas. Consulta la documentación de las plataformas correspondientes para obtener los comandos detallados. A continuación, se incluyen algunos vínculos a la documentación de plataformas que no son de GKE para que los consultes. Ten en cuenta que están sujetos a cambios:

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

Soluciona problemas relacionados con los límites de IDs de proceso

Pod atascado en el estado Pending con un error FailedScheduling

Cuando el límite de PID de nodos o Pods expulsa o restringe el inicio de un Pod, este quedará atascado en el estado Pending y fallará con el error FailedScheduling.

  1. Obtén la columna Node: 
    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. Como alternativa, verifica ApigeeDeployment del Pod correspondiente. Obtén el ApigeeDeployment del resultado que tenga el mismo prefijo que el pod que generó el error. 
    kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
  4. Verifica 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, sigue los pasos que se indican en Administra los límites de PID del nodo para actualizar el límite de PID a un valor más alto.

podPidsLimit no es válido

Cuando se establece el límite para GKE, si podPidsLimit supera el límite, se mostrará el siguiente mensaje de error: 

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

Actualiza el valor de podPidsLimit dentro del rango requerido.