Prozess-ID-Limits verwalten

Übersicht

Ein Prozess-ID-Limit (PID) ist eine Kubernetes-Ressourcenbeschränkung für Knoten und Pods, um die Erstellung einer übermäßigen Anzahl von Prozessen zu verhindern, die sich auf die Knotenstabilität auswirken kann. Apigee Hybrid unterstützt die Kubernetes-Funktion zum Festlegen von Prozess-ID-Limits. In diesem Dokument finden Sie eine Anleitung zum Festlegen dieser Limits sowie Empfehlungen für Werte für Apigee-Dienste auf bestimmten Plattformen.

Wenn Apigee Hybrid-Nutzer ihre eigenen Cluster verwalten, kann das Festlegen von PID-Limits in Kubernetes die Systemstabilität, Sicherheit und Ressourcenverwaltung verbessern. Dies entspricht auch den Best Practices für Kubernetes.

Definitionen von Prozess-ID-Limits

Zu den Prozess-ID-Limits gehören Knoten-PID-Limits und Pod-PID-Limits.

Die Knoten-PID-Limits umfassen Kube-reservierte und systemreservierte PIDs. Die Gesamtzahl der zuweisbaren PIDs ist die maximale Anzahl von PIDs des Kernels minus die Kube-reservierten PIDs minus die systemreservierten PIDs minus die PIDs des Schwellenwerts für die Bereinigung:

Maximale ID-Anzahl des Kernels
    – Kube-reserviert
    – Systemreserviert
    - Schwellenwert für die Bereinigung
= Zuweisbar
  • Maximale ID-Anzahl des Kernels: Werden durch das Betriebssystem und seine Kerneleinstellungen bestimmt. Da Apigee Hybrid ausschließlich auf einem Linux-Kernel ausgeführt wird, werden in diesem Leitfaden Linux-basierte Grenzwerte für Kubernetes-Knoten behandelt. Die maximale Anzahl der Prozess-ID-Limits für einen Linux-Kernel beträgt 4.194.304.
  • Kube-reserviert und systemreserviert: Für die Ressourcenreservierung für Kubernetes- oder Betriebssystem-System-Daemons.
  • Schwellenwert für die Bereinigung: Das Limit, das den Druck auf den Knoten signalisiert. Der Knoten wird entfernt, wenn der Grenzwert erreicht ist. Weitere Informationen finden Sie unter PID-basierte Bereinigung.
  • Zuweisbar: Die Anzahl der verfügbaren PIDs. Weitere Informationen finden Sie unter Kubernetes: Knoten zuweisbar. „Kube-reserviert“ und „systemreserviert“ können mit Einstellungen für das Knoten-PID-Limit konfiguriert werden.

Das Pod-PID-Limit kann für den Knoten konfiguriert und von allen Pods auf dem Knoten gemeinsam genutzt werden.

Vorbereiten der Verwaltung der Prozess-ID-Limits

Bei diesen Verfahren werden die folgenden Umgebungsvariablen verwendet:

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

Zugriff überprüfen

Bevor Sie das Prozess-ID-Limit konfigurieren, müssen Sie Zugriff zum Bearbeiten von Kubernetes-Clustern haben.

Die folgenden Schritte gelten für Installationen in GKE. Informationen zu anderen Plattformen finden Sie in der Dokumentation für Ihre Plattform.

  1. Prüfen Sie, ob Sie die Rolle „roles/container.clusterAdmin“ in der IAM-Richtlinie haben: 
    gcloud projects get-iam-policy ${PROJECT_ID}  \
 --flatten="bindings[].members" \
 --format='table(bindings.role)' \
 --filter="bindings.members:your_account_email"
  2. Wenn Sie keinen Zugriff haben, fügen Sie Ihrem Konto die Rolle hinzu: 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
 --member user:your_account_email \
 --role roles/container.clusterAdmin

Vorhandene PID-Limits prüfen

Prüfen Sie, ob für den Knoten bereits PID-Limits festgelegt sind, bevor Sie neue Limits konfigurieren.

  1. Rufen Sie einen Knoten aus dem Cluster ab, um Werte zu prüfen. Sie müssen Knoten aus den Knotenpools apigee-data und apigee-runtime prüfen: 
    kubectl get nodes -n ${APIGEE_NAMESPACE}

    Die Ausgabe sollte in etwa so aussehen:

    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. Exportieren Sie den Knotennamen aus der Ausgabe des vorherigen Schritts. Führen Sie diesen Schritt zuerst für einen apigee-data-Knoten und dann noch einmal für einen apigee-runtime-Knoten aus:

    Code

    export NODE_NAME=MY_NODE_NAME

    Beispiel

    export NODE_NAME="gke-my-hybrid-apigee-data-0a1b2c3d-efgh"
  3. Prüfen Sie die PID-Limits des Knotens. Verwenden Sie die folgenden Befehle, um die reservierten Werte zu prüfen. Wenn der Wert null ist, ist er nicht konfiguriert: 
    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. Prüfen Sie das PID-Limit des Pods. Mit dem folgenden Befehl können Sie das vorhandene PID-Limit des Pods prüfen. Wenn der zurückgegebene Wert -1 oder leer ist, ist das Limit nicht festgelegt: 
    kubectl get --raw "/api/v1/nodes/${NODE_NAME}/proxy/configz" | jq '.kubeletconfig.podPidsLimit'

Prozess-ID-Limits verwalten

Knoten-PID-Limits verwalten

Bei Installationen in GKE werden die Infrastrukturressourcen von Kubernetes-Knoten intern verwaltet und Sie müssen sie nicht konfigurieren. Die aktuelle Kapazität und die zuweisbaren Ressourcen können gemäß Zuweisbare Ressourcen für Knoten in der Google Kubernetes Engine-Dokumentation eingesehen werden.

Informationen zu Nicht-GKE-Plattformen finden Sie in der entsprechenden Kubernetes-Dokumentation für die Plattform. Wenn der Cluster/Knoten vom Nutzer verwaltet wird (im Gegensatz zu „vollständig verwaltet“), können das Kube-reservierte PID-Limit und das systemreservierte PID-Limit mit Kubelet konfiguriert werden. Weitere Informationen finden Sie in der Kubernetes-Dokumentation unter Knoten-PID-Limits.

Tools

In diesem Verfahren wird Kubelet verwendet, um das Prozess-ID-Limit zu verwalten. Kubelet ist der Agent, der auf Pods und Containern ausgeführt wird und dafür sorgt, dass sie gemäß ihrer PodSpec ausgeführt werden. Wenn Sie Kubelet installieren müssen, folgen Sie der Anleitung in der Kubernetes-Dokumentation: kubeadm, kubelet und kubectl installieren.

Prozedur

  1. Erstellen Sie eine Kubelet-Konfigurationsdatei mit dem Namen kubelet-config.yaml. 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
kubeReserved:
 pid: PID_VALUE # Example: 1000

    Weitere Informationen zu den Konfigurationen finden Sie in der Kubernetes-Dokumentation unter Kube-reserviert.

  2. Wenden Sie die Kubelet-Konfiguration an: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML

Pod-PID-Limits verwalten

Limit auswählen

Wenn das PID-Limit zu niedrig eingestellt ist, kann dies verhindern, dass ein Pod gestartet wird. Wenn es zu hoch eingestellt ist, werden Ressourcenfehler möglicherweise nicht erkannt. Bei der Auswahl des geeigneten Limits ist es wichtig, das bisherige Verhalten des Knotens und alle dienstspezifischen Anforderungen zu berücksichtigen.

Für den Wert ist in GKE ein erforderlicher Bereich festgelegt: [1024, 4194304]. Auf GKE-Plattformen können Sie den Status Ihrer Kubernetes-Dienstkonten im Google Cloud console Metrics Explorer sehen. Wählen Sie die Messwerte Kubernetes-Knoten – PID-Nutzung aus und wenden Sie Filter an. Dieser Messwert zeigt die aktuelle Nutzung von Prozess-IDs und kann als Referenz bei der Auswahl eines PID-Limits dienen.

Metrics Explorer

Auf Nicht-GKE-Plattformen sind möglicherweise andere Monitoring-Optionen verfügbar. Informationen zum Prüfen der Messwerte finden Sie in der Kubernetes-Dokumentation der entsprechenden Plattform.

Anforderungen an die Prozess-ID für Apigee-Pods

Apigee Hybrid verwendet zwei Knotenpools: „apigee-data“ und „apigee-runtime“. Da einige der Apigee-Komponenten in beiden Knotenpools bereitgestellt werden, muss das Pod-PID-Limit für die beiden Knotenpools gleich sein. Das Pod-PID-Limit sollte auch höher sein als die maximale Anzahl von PIDs, die für alle Apigee-Pods erforderlich sind. Das erforderliche PID-Limit für Apigee-Pods beträgt 1.000 und liegt damit unter der Mindestanzahl für GKE-Plattformen.

Auf einigen Plattformen gilt eine Mindestwertanforderung für die Pod-PID-Limits. In diesem Fall wird die Mindestwertanforderung ausgewählt.

Plattform Mindest-Pod-PID-Limit
GKE in Google Cloud 1.024
GKE on AWS 1.024
GKE on Azure 1.024
Google Distributed Cloud (nur Software) in VMware 1.024
Google Distributed Cloud (nur Software) in Bare Metal 1.024
EKS 1.000
AKS 1.000
OpenShift 1.000
Rancher Kubernetes Engine (RKE) 1.000

Prozedur

Die Verfahren zum Verwalten der Pod-PID-Limits sind für GKE- und Nicht-GKE-Plattformen unterschiedlich.

GKE-Plattform

GKE-Plattformen, die das Aktualisieren des PID-Limits unterstützen, umfassen:

Das Pod-PID-Limit wird über Knotensystemkonfigurationen gesteuert. Für den Wert ist in GKE ein erforderlicher Bereich festgelegt: [1024, 4194304]. Weitere Informationen finden Sie unter NodeKubeletConfig.

  1. Erstellen Sie eine Knotensystemkonfiguration mit dem Namen node-config.yaml mit dem angegebenen Pod-PID-Limit und folgendem Inhalt: 
    kubeletConfig:
 podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Wenden Sie die Konfiguration auf die Knotenpools apigee-data und apigee-runtime von Apigee an. Wenn Sie die Konfiguration anwenden, startet der Knoten das Roll-out mit einer der Strategien für Knotenupgrades ohne Ausfallzeit. 
    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

Nicht-GKE-Plattformen

Auf Nicht-GKE-Plattformen wird das Pod-PID-Limit von Kubelet gesteuert. Das Limit wird durch das Feld podPidsLimit in der Kubelet-Konfigurationsdatei festgelegt.

  1. Erstellen Sie eine Kubelet-Konfigurationsdatei mit dem Namen kubelet-config.yaml und folgendem Inhalt: 
    apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
podPidsLimit: POD_PID_VALUE # Example: 1024
  2. Wenden Sie die Konfiguration an. Wenn Sie „podPidsLimit“ festlegen, muss der betroffene Knoten neu gestartet werden, was zu Ausfallzeiten führen kann: 
    kubelet --config PATH_TO_KUBELET_CONFIG_YAML
  3. Prüfen Sie die Konfiguration. Eine Anleitung finden Sie unter Vorhandene PID-Limits prüfen.

Die Konfigurationsbefehle für Pod-PID-Limits und die Empfehlungen für Tools sind auf den verschiedenen Plattformen unterschiedlich. Ausführliche Befehle finden Sie in der Dokumentation der jeweiligen Plattformen. Nachfolgend finden Sie einige Dokumentationslinks zu Nicht-GKE-Plattformen. Beachten Sie, dass sich diese ändern können:

Plattform Dokumentation
EKS Verwaltete Knoten mit Startvorlagen anpassen
AKS Anpassen der Knotenkonfiguration für Azure Kubernetes Service-Knotenpools (AKS)
OpenShift Risiken beim Festlegen höherer Prozess-ID-Limits für Red Hat OpenShift Service in AWS-Pods
Rancher Kubernetes Engine (RKE) Mit Kubectl und kubeconfig auf einen Cluster zugreifen

Probleme mit Prozess-ID-Limits beheben

Pod hängt im Status Pending mit dem Fehler FailedScheduling fest

Wenn das Knoten- oder Pod-PID-Limit dazu führt, dass ein Pod entfernt oder der Start eines Pods verhindert wird, bleibt der Pod im Status Pending hängen und schlägt mit dem Fehler FailedScheduling fehl.

  1. Rufen Sie die Spalte „Knoten“ ab: 
    kubectl get pods -n ${APIGEE_NAMESPACE} ${POD_NAME} -o wide
  2. Prüfen Sie, ob die Bedingung PIDPressure vorliegt: 
    kubectl describe node -n apigee ${NODE_NAME} | grep PIDPressure
  3. Alternativ können Sie das ApigeeDeployment des entsprechenden Pods prüfen. Rufen Sie das ApigeeDeployment aus dem Ergebnis ab, das dasselbe Präfix wie der Pod mit dem Fehler hat. 
    kubectl get ApigeeDeployment -n ${APIGEE_NAMESPACE}
  4. Prüfen Sie, ob im letzten Events PID-bezogene Fehlermeldungen enthalten sind: 
    kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
  5. Wenn sich bestätigt, dass die Ursache das PID-Limit ist, folgen Sie der Anleitung unter Knoten-PID-Limits verwalten, um das PID-Limit auf einen höheren Wert zu aktualisieren.

„podPidsLimit“ ist ungültig

Wenn Sie das Limit für GKE festlegen, sollte podPidsLimit das Limit überschreiten, wird der folgende Fehler angezeigt: 

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

Aktualisieren Sie den Wert von „podPidsLimit“ auf einen Wert innerhalb des erforderlichen Bereichs.