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. Ciò è anche coerente con le best practice di Kubernetes.

Definizioni dei limiti dell'ID processo

I limiti dell'ID processo includono i limiti PID del nodo e i limiti PID del pod.

I limiti PID nodo 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 espulsione:

Limiti massimi di ID kernel
    - Kube reserved
    - Riservato al sistema
    - Soglia di sfratto
= 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 per i nodi Kubernetes. Il numero massimo di limiti di ID processo per un kernel Linux è 4194304.
  • Kube-reserved e system-reserved: per la prenotazione delle risorse per i daemon di sistema di Kubernetes o del sistema operativo.
  • Soglia di espulsione: il limite che segnala la pressione sul nodo. Il nodo verrà espulso quando viene raggiunta la soglia. Per maggiori dettagli, consulta la sezione Eviction basata sul PID.
  • Allocabile: il numero di PID disponibili. Per ulteriori informazioni, consulta Kubernetes: Node Allocatable. Kube-reserved e system-reserved 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 degli 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 accesso alla modifica dei cluster Kubernetes.

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

  1. Controlla se disponi di roles/container.clusterAdmin nel criterio 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. Recupera un nodo dal cluster per controllare i valori. Dovrai controllare i nodi dei node pool apigee-data e 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 prima questo passaggio successivo 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 dei nodi. 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 comando seguente 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 degli 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 la sezione 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 kube-reserved e il limite PID system-reserved possono essere configurati con Kubelet. Consulta la sezione 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 siano in esecuzione in base alla specifica del pod. Se devi installare Kubelet, segui le istruzioni riportate nella documentazione di Kubernetes: Installing kubeadm, kubelet and 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 di Kubelet: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML

Gestisci i limiti PID del 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 elevato, potrebbe non rilevare comportamenti anomali delle risorse. Quando selezioni il limite appropriato, è importante considerare il comportamento precedente del nodo e qualsiasi requisito specifico del servizio.

GKE ha un intervallo obbligatorio per il valore: [1024, 4194304]. Sulle piattaforme GKE puoi visualizzare lo stato dei tuoi service account Kubernetes in Google Cloud console Esplora metriche. Seleziona le metriche Nodo Kubernetes - Utilizzo PID e applica i filtri. Questa metrica mostra l'utilizzo recente degli ID processo e può essere utilizzata come riferimento per la scelta di un limite PID.

Esplora metriche

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

Requisiti dell'ID processo per i pod Apigee

Apigee Hybrid utilizza due pool di nodi, apigee-data e apigee-runtime. Poiché alcuni componenti di Apigee vengono implementati in entrambi i node pool, il limite PID dei pod deve essere lo stesso per i due node pool. Il limite PID del pod deve essere superiore anche 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 di PID del pod, nel qual caso viene selezionato il requisito di valore minimo.

Piattaforma Limite PID min pod
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 saperne di più, consulta NodeKubeletConfig.

  1. Crea una configurazione del sistema di nodi denominata node-config.yaml con un limite PID del pod designato con i seguenti contenuti: 
    kubeletConfig:
 podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Applica la configurazione a entrambi i pool di nodi apigee apigee-data e apigee-runtime. Quando applichi la configurazione, il nodo inizierà l'implementazione 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 di 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 causare 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 suggerimenti per gli strumenti variano a seconda delle piattaforme. Per i comandi dettagliati, consulta la documentazione delle rispettive piattaforme. Di seguito sono riportati alcuni link alla documentazione di 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 di ID processo più elevati per i pod Red Hat OpenShift Service su AWS
Rancher Kubernetes Engine (RKE) Accedere a un cluster con kubectl e kubeconfig

Risoluzione dei problemi relativi ai limiti degli ID processo

Pod bloccato nello stato Pending con un errore FailedScheduling

Quando il limite di PID del nodo o del pod espelle o impedisce l'avvio di un pod, quest'ultimo rimane bloccato nello stato Pending e genera l'errore FailedScheduling.

  1. Recupera la colonna Nodo: 
    kubectl get pods -n ${APIGEE_NAMESPACE} ${POD_NAME} -o wide
  2. Controlla 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. Controlla se il recente Events contiene messaggi di errore relativi al PID: 
    kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
  5. Se viene confermato che la causa è il 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 il seguente messaggio di errore: 

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

Aggiorna il valore di podPidsLimit in modo che rientri nell'intervallo richiesto.