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 ID de proceso

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 por Kube y los reservados por el sistema. La cantidad total de PID asignables es el máximo del kernel menos los PID reservados por kube, menos los PID reservados por el sistema y menos los PID del umbral de expulsión:

Límites de ID máximo del kernel
    - Reservado por Kube
    - Reservado por el sistema
    - Umbral de expulsión
= Asignable
  • Límites de ID máximo del kernel: El sistema operativo y su configuración de kernel determinan estos límites. 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 4194304.
  • Kube-reserved y system-reserved: Para la reserva de recursos de Kubernetes o daemons del sistema del SO.
  • Umbral de expulsión: Es el límite que indica la presión sobre el nodo. El nodo se desalojará cuando se alcance el umbral. Consulta Expulsión basada en PID para obtener más detalles.
  • Asignable: Es la cantidad de PIDs disponibles. Consulta Kubernetes: Nodos asignables para obtener más información. Kube-reserved y system-reserved se pueden configurar con la configuración del límite de PID de nodos.

El límite de PID del pod se puede configurar para el nodo y compartirse 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 de tu plataforma.

  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 del resultado del paso anterior. Ejecuta el siguiente paso primero 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 de PID del nodo. Usa los siguientes comandos para verificar los valores reservados. Si el valor es nulo, significa que no está 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. 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, significa que no se estableció el límite: 
    kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.podPidsLimit'

Administra los límites de ID de proceso

Administra los límites de 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 que los configures. Puedes ver la capacidad y los recursos asignables actuales en Recursos asignables del nodo en la documentación de Google Kubernetes Engine.

Para plataformas que no son de GKE, consulta la documentación de Kubernetes correspondiente. Si el clúster o el nodo está administrado por el usuario (en lugar de estar completamente administrado), el límite de PID reservado por kube y el límite de PID reservado por 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 pods y contenedores que se aseguran de que se ejecuten de acuerdo con su PodSpec. Si necesitas instalar Kubelet, sigue las instrucciones de la documentación de Kubernetes: Instalación de 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

Administra los límites de PID del 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 comportamientos incorrectos 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 GKE Platforms, puedes ver el estado de tus cuentas de servicio de Kubernetes en el Google Cloud console Explorador de métricas. Selecciona las métricas Nodo de Kubernetes: Uso de PID y aplica los filtros. Esta métrica muestra el uso reciente de los IDs de proceso y se puede consultar cuando se elige un límite de PID.

Explorador de métricas

En 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 grupos 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 del 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 PIDs requerida en todos los Pods de Apigee. El límite de PID de Pod de Apigee requerido es 1,000, que es inferior a la cantidad mínima requerida para las plataformas de GKE.

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

Plataforma Límite mínimo de PID del 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 los pods son diferentes para las plataformas de GKE y de terceros.

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 del pod está controlado por 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 el límite de PID del 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 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 el caso de las plataformas que no son de GKE, Kubelet controla el límite de PID del Pod. El campo podPidsLimit en el archivo de configuración de Kubelet establece el límite.

  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 establecer podPidsLimit, se debe reiniciar el nodo afectado, lo que podría generar un 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 de PID del pod y las recomendaciones de herramientas son diferentes en varias plataformas. Consulta la documentación de las plataformas correspondientes para ver los comandos detallados. A continuación, se incluyen algunos vínculos de documentación de plataformas que no son de GKE como referencia. Ten en cuenta que están sujetos a cambios:

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

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

Pod atascado en el estado Pending con un error FailedScheduling

Cuando el límite de PIDs del nodo o del pod expulsa o restringe el inicio de un pod, este se quedará atascado 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. Verifica 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 tiene el mismo prefijo que el pod con 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 el límite de PID es la causa, sigue los pasos que se indican en Cómo administrar 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 establezcas el límite para GKE, si podPidsLimit supera el límite, se mostrará el siguiente 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.