Gestire i limiti per gli ID processo

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Panoramica

Un limite di ID processo (PID) è un vincolo delle 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 di 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 in linea con le best practice di Kubernetes.

Definizioni dei limiti di ID processo

I limiti per gli ID processo includono i limiti per i PID dei nodi e i limiti per i PID dei pod.

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

• Limiti ID kernel massimi: 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 di ID processo per un kernel Linux è 4194304.
• Kube-reserved e system-reserved: per la prenotazione di risorse per i demoni di sistema Kubernetes o OS.
• Soglia di espulsione: il limite che segnala la pressione sul nodo. Il nodo verrà espulso quando viene raggiunta la soglia. Per ulteriori dettagli, consulta la sezione Eviction basato su PID.
• Allocatable (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 di 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 di ID processo, assicurati di avere accesso alla modifica dei cluster Kubernetes.

I passaggi riportati di seguito riguardano le installazioni su GKE. Per altre piattaforme, consulta la documentazione della tua piattaforma.

1. Verifica se nel criterio IAM è presente roles/container.clusterAdmin:

   gcloud projects get-iam-policy ${PROJECT_ID}  \
    --flatten="bindings[].members" \
    --format='table(bindings.role)' \
    --filter="bindings.members:your_account_email"
   

2. Se non disponi dell'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 di entrambi i 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 il passaggio successivo per un nodo apigee-data e 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 dei PID del nodo. Utilizza i seguenti comandi per controllare i valori riservati. Se il valore è null, 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 di PID del pod. Utilizza il comando seguente per controllare il limite di 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 per gli ID processo

Gestire i limiti PID del nodo

Per le installazioni su GKE, le risorse di infrastruttura dei nodi Kubernetes sono gestite internamente e non è necessario configurarle. La capacità e le risorse allocabili attuali possono essere visualizzate nella sezione Risorse allocabili del nodo della documentazione di Google Kubernetes Engine.

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

Strumenti

Questa procedura utilizza Kubelet per gestire il limite di ID processo. Kubelet è l'agente che viene eseguito su pod e container per assicurarsi che vengano eseguiti in base al relativo PodSpec. Se devi installare Kubelet, segui le istruzioni riportate nella documentazione di Kubernetes: Installazione di 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 di Kubelet:

   kubelet --config PATH_TO_KUBELET_CONFIG_YAML
   

Gestire 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 alto, potrebbe non rilevare comportamenti errati delle risorse. Quando selezioni il limite appropriato, è importante considerare il comportamento precedente del nodo e eventuali requisiti specifici del servizio.

GKE ha un intervallo obbligatorio per il valore: [1024, 4194304]. Nelle piattaforme GKE puoi vedere lo stato dei tuoi account di servizio Kubernetes in Google Cloud console Metric Explorer. 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

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

Requisiti per l'ID processo per i pod Apigee

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

Limite consigliato per i PID del pod

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.

Procedura

Le procedure per gestire i limiti di PID dei pod sono diverse per le piattaforme GKE e non GKE.

Risolvere i problemi relativi ai limiti di ID processo

Pod bloccato nello stato Pending con un errore FailedScheduling

Quando il limite dei PID del nodo o del pod impedisce o limita l'avvio di un pod, il pod rimarrà bloccato nello stato Pending e non riuscirà a completare l'avvio con 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. Recupera il ApigeeDeployment dal risultato che ha lo stesso prefisso del pod con errore.

   kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
   

4. Controlla se il Events recente contiene 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 del nodo per aggiornare il limite PID a un valore superiore.

podPidsLimit non valido

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

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

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