Gestire i limiti per gli ID processo

Panoramica

Un limite di ID processo (PID) è un vincolo di risorse Kubernetes su nodi e pod per impedire la creazione eccessiva di processi, che può influire sulla stabilità dei nodi. Apigee Hybrid supporta la funzionalità Kubernetes per impostare i limiti dell'ID processo. Questo documento fornisce istruzioni su come impostare questi limiti, con consigli sui valori per i servizi Apigee su piattaforme specifiche.

Quando gli utenti di Apigee hybrid gestiscono i propri cluster, l'impostazione dei limiti PID in Kubernetes può migliorare la stabilità, la sicurezza e la gestione delle risorse del sistema. Questo è anche coerente con le best practice di Kubernetes.

Definizioni dei limiti dell'ID processo

I limiti dell'ID processo includono i limiti PID dei nodi e i limiti PID dei pod.

I limiti PID dei nodi includono i PID riservati a Kube e i PID riservati al sistema. Il numero totale di PID allocabili è il massimo del kernel meno i PID riservati a Kube meno i PID riservati al sistema meno i PID della soglia di rimozione:

Limiti ID massimi del kernel
    - Kube riservato
    - Sistema riservato
    - Soglia di rimozione
= Allocabile
  • Limiti ID massimi del kernel: determinati dal sistema operativo e dalle relative impostazioni del kernel. Poiché Apigee Hybrid viene eseguito esclusivamente su un kernel Linux, questa guida illustra i limiti basati su Linux sui nodi Kubernetes. Il numero massimo di limiti dell'ID processo per un kernel Linux è 4194304.
  • Kube-reserved e system-reserved: per la prenotazione delle risorse per i daemon di sistema Kubernetes o del sistema operativo.
  • Soglia di rimozione: il limite che segnala la pressione sul nodo. Il nodo verrà rimosso quando viene raggiunta la soglia. Per ulteriori dettagli, consulta Rimozione basata su PID.
  • Allocabile: il numero di PID disponibili. Per ulteriori informazioni, consulta Kubernetes: Node Allocatable. I valori riservati a Kube e al sistema possono essere configurati con le impostazioni del limite PID del nodo.

Il limite PID del pod può essere configurato per il nodo e condiviso tra tutti i pod all'interno del nodo.

Prepararsi a gestire i limiti dell'ID processo

Queste procedure utilizzano le seguenti variabili di ambiente:

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 l'accesso

Prima di configurare il limite dell'ID processo, assicurati di avere l'accesso per modificare i cluster Kubernetes.

I passaggi riportati di seguito si riferiscono alle installazioni su GKE. Per altre piattaforme, consulta la documentazione relativa alla tua piattaforma.

  1. Verifica se hai il ruolo roles/container.clusterAdmin nella policy IAM: 
    gcloud projects get-iam-policy ${PROJECT_ID}  \
 --flatten="bindings[].members" \
 --format='table(bindings.role)' \
 --filter="bindings.members:your_account_email"
  2. Se non hai l'accesso, aggiungi il ruolo al tuo account: 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
 --member user:your_account_email \
 --role roles/container.clusterAdmin

Verificare i limiti PID esistenti

Verifica se il nodo ha limiti PID esistenti prima di configurare nuovi limiti.

  1. Ottieni un nodo dal cluster per controllare i valori. Dovrai controllare i nodi sia dai node pool apigee-data sia da quelli apigee-runtime: 
    kubectl get nodes -n ${APIGEE_NAMESPACE}

    Dovresti vedere un output simile al seguente:

    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. Esporta il nome del nodo dall'output del passaggio precedente. Esegui questo passaggio successivo prima per un nodo apigee-data e poi di nuovo per un nodo apigee-runtime:

    Codice

    export NODE_NAME=MY_NODE_NAME

    Esempio

    export NODE_NAME="gke-my-hybrid-apigee-data-0a1b2c3d-efgh"
  3. Controlla i limiti PID del nodo. Utilizza i seguenti comandi per controllare i valori riservati. Se il valore è null, il valore non è configurato: 
    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. Controlla il limite PID del pod. Utilizza il seguente comando per controllare il limite PID del pod esistente. Se il valore restituito è -1 o è vuoto, il limite non è impostato: 
    kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.podPidsLimit'

Gestire i limiti dell'ID processo

Gestire i limiti PID dei nodi

Per le installazioni su GKE, le risorse dell'infrastruttura dei nodi Kubernetes vengono gestite internamente e non è necessario configurarle. La capacità attuale e le risorse allocabili possono essere visualizzate seguendo le risorse allocabili dei nodi nella documentazione di Google Kubernetes Engine.

Per le piattaforme non GKE, consulta la documentazione di Kubernetes corrispondente per la piattaforma. Se il cluster/nodo è gestito dall'utente (anziché completamente gestito), il limite PID riservato a Kube e il limite PID riservato al sistema possono essere configurati con Kubelet. Consulta Limiti PID dei nodi nella documentazione di Kubernetes.

Strumenti

Questa procedura utilizza Kubelet per gestire il limite dell'ID processo. Kubelet è l'agente che viene eseguito su pod e container e garantisce che vengano eseguiti in base alla relativa PodSpec. Se devi installare Kubelet, segui le istruzioni nella documentazione di Kubernetes: Installare kubeadm, kubelet e kubectl.

Procedura

  1. Crea un file di configurazione Kubelet denominato kubelet-config.yaml. 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
kubeReserved:
 pid: PID_VALUE # Example: 1000

    Per ulteriori informazioni sulle configurazioni, consulta Kube Reserved nella documentazione di Kubernetes.

  2. Applica la configurazione Kubelet: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML

Gestire i limiti PID dei pod

Scegliere il limite

Se il limite PID è impostato su un valore troppo basso, può impedire l'avvio di un pod. Se è impostato su un valore troppo alto, potrebbe non rilevare comportamenti errati delle risorse. Quando selezioni il limite appropriato, è importante considerare il comportamento precedente del nodo e i requisiti specifici del servizio.

GKE ha un intervallo obbligatorio per il valore: [1024, 4194304]. Sulle piattaforme GKE puoi visualizzare lo stato degli account di servizio Kubernetes in Google Cloud console Esplora metriche. Seleziona le metriche Nodo Kubernetes - Utilizzo PID e applica i filtri. Queste metriche mostrano l'utilizzo recente degli ID processo e possono essere utilizzate come riferimento quando scegli un limite PID.

Esplora metriche

Sulle piattaforme non GKE potrebbero essere disponibili diverse opzioni di monitoraggio. Consulta la documentazione di Kubernetes della piattaforma corrispondente per controllare le metriche.

Requisiti dell'ID processo per i pod Apigee

Apigee Hybrid utilizza 2 node pool, apigee-data e apigee-runtime. Poiché alcuni componenti Apigee vengono sottoposti a deployment in entrambi i node pool, il limite PID del pod deve essere lo stesso per i due node pool. Il limite PID del pod deve essere anche superiore al numero massimo di PID richiesti in tutti i pod Apigee. Il limite PID del pod Apigee richiesto è 1000, che è inferiore al numero minimo richiesto per le piattaforme GKE.

Alcune piattaforme applicano un requisito di valore minimo per il numero del limite PID del pod, nel qual caso viene selezionato il requisito di valore minimo.

Piattaforma Limite PID del pod minimo
GKE su Google Cloud 1024
GKE su AWS 1024
GKE su Azure 1024
Google Distributed Cloud (solo software) su VMware 1024
Google Distributed Cloud (solo software) su bare metal 1024
EKS 1000
AKS 1000
OpenShift 1000
Rancher Kubernetes Engine (RKE) 1000

Procedura

Le procedure per la gestione dei limiti PID dei pod sono diverse per le piattaforme GKE e non GKE.

Piattaforma GKE

La piattaforma GKE che supporta l'aggiornamento del limite PID include:

Il limite PID del pod è controllato dalle configurazioni del sistema di nodi. GKE ha un intervallo obbligatorio per il valore: [1024, 4194304]. Per ulteriori informazioni, consulta NodeKubeletConfig.

  1. Crea una configurazione del sistema di nodi denominata node-config.yaml con il limite PID del pod designato con i seguenti contenuti: 
    kubeletConfig:
 podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Applica la configurazione sia ai node pool apigee-data sia a quelli apigee-runtime di Apigee. Quando applichi la configurazione, il nodo inizierà il rollout con una delle strategie di upgrade dei nodi senza tempi di inattività. 
    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

Piattaforme non GKE

Per le piattaforme non GKE, il limite PID del pod è controllato da Kubelet. Il limite è impostato dal campo podPidsLimit nel file di configurazione Kubelet.

  1. Crea un file di configurazione Kubelet denominato kubelet-config.yaml con i seguenti contenuti: 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Applica la configurazione. L'impostazione di podPidsLimit richiede il riavvio del nodo interessato, il che potrebbe comportare tempi di inattività: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML
  3. Verifica la configurazione. Per istruzioni, consulta Verificare i limiti PID esistenti.

I comandi di configurazione dei limiti PID dei pod e i consigli sugli strumenti variano a seconda delle piattaforme. Per i comandi dettagliati, consulta la documentazione delle rispettive piattaforme. Di seguito sono riportati alcuni link alla documentazione delle piattaforme non GKE per riferimento. Tieni presente che sono soggetti a modifiche:

Piattaforma Documentazione
EKS Personalizzare i nodi gestiti con i modelli di avvio
AKS Personalizzare la configurazione dei nodi per i node pool di Azure Kubernetes Service (AKS)
OpenShift Rischi di impostare limiti dell'ID processo più elevati per i pod di Red Hat OpenShift Service su AWS
Rancher Kubernetes Engine (RKE) Accedere a un cluster con Kubectl e kubeconfig

Risolvere i problemi relativi ai limiti dell'ID processo

Pod bloccato nello stato Pending con un errore FailedScheduling

Quando il limite PID del nodo o del pod rimuove o impedisce l'avvio di un pod, il pod rimane bloccato nello stato Pending e non riesce a essere avviato con l'errore FailedScheduling.

  1. Ottieni la colonna Nodo: 
    kubectl get pods -n ${APIGEE_NAMESPACE} ${POD_NAME} -o wide
  2. Verifica se è presente una condizione PIDPressure: 
    kubectl describe node -n apigee ${NODE_NAME} | grep PIDPressure
  3. In alternativa, controlla ApigeeDeployment del pod corrispondente. Ottieni ApigeeDeployment dal risultato che ha lo stesso prefisso del pod con errori. 
    kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
  4. Verifica se gli Events recenti contengono messaggi di errore relativi al PID: 
    kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
  5. Se la causa è confermata come limite PID, segui i passaggi descritti in Gestire i limiti PID dei nodi per aggiornare il limite PID a un valore più alto.

podPidsLimit non valido

Quando imposti il limite per GKE, se podPidsLimit supera il limite, viene visualizzato un errore: 

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

Aggiorna il valore di podPidsLimit all'interno dell'intervallo richiesto.