Limits für Prozess-IDs verwalten

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Übersicht

Ein Prozess-ID-Limit (PID-Limit) ist eine Kubernetes-Ressourcenbeschränkung für Knoten und Pods, die die übermäßige Erstellung von Prozessen verhindert, was 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, können sie durch 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 Limits für Knoten-PIDs umfassen von Kube reservierte PIDs und vom System reservierte PIDs. Die Gesamtzahl der zuweisbaren PIDs ist die maximale Anzahl von PIDs im Kernel abzüglich der von Kubernetes reservierten PIDs, der vom System reservierten PIDs und der PIDs für den Auslagerungsgrenzwert:

• Maximale Kernel-ID-Grenzwerte: Werden vom Betriebssystem und seinen Kernel-Einstellungen bestimmt. Da Apigee Hybrid ausschließlich auf einem Linux-Kernel ausgeführt wird, werden in diesem Leitfaden Linux-basierte Limits für Kubernetes-Knoten behandelt. Die maximale Anzahl von Prozess-IDs für einen Linux-Kernel beträgt 4194304.
• Kube-reserved und system-reserved: Für die Ressourcenreservierung für Kubernetes- oder Betriebssystem-System-Daemons.
• Auslagerungsgrenzwert: Das Limit, das einen Druck auf den Knoten signalisiert. Der Knoten wird entfernt, wenn der Grenzwert erreicht ist. Weitere Informationen finden Sie unter PID-basierte Auslagerung.
• Zuweisbar: Die Anzahl der verfügbaren PIDs. Weitere Informationen finden Sie unter Kubernetes: Node Allocatable. Kube-reserviert und systemreserviert können mit den Einstellungen für die PID-Begrenzung von Knoten konfiguriert werden.

Das PID-Limit für Pods kann für den Knoten konfiguriert und für alle Pods innerhalb des Knotens freigegeben werden.

Limits für Prozess-IDs verwalten

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 Limit für Prozess-IDs 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 Ihrer Plattform.

1. Prüfen Sie, ob die Rolle „roles/container.clusterAdmin“ in der IAM-Richtlinie enthalten ist:

   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 die Rolle Ihrem Konto 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 vorhanden 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 den nächsten 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 Pod-PID-Limit. Mit dem folgenden Befehl können Sie das vorhandene PID-Limit für 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'
   

Limits für Prozess-IDs verwalten

PID-Limits für Knoten verwalten

Bei Installationen in GKE werden die Infrastrukturressourcen von Kubernetes-Knoten intern verwaltet und müssen nicht konfiguriert werden. Die aktuelle Kapazität und die zuweisbaren Ressourcen finden Sie in der Google Kubernetes Engine-Dokumentation unter Zuweisbare Ressourcen für Knoten.

Für andere Plattformen als GKE lesen Sie die entsprechende Kubernetes-Dokumentation für die Plattform. Wenn der Cluster/Knoten vom Nutzer verwaltet wird (im Gegensatz zu „Vollständig verwaltet“), können die von Kube reservierten PID-Grenzwerte und die vom System reservierten PID-Grenzwerte mit Kubelet konfiguriert werden. Weitere Informationen finden Sie in der Kubernetes-Dokumentation unter PID-Limits für Knoten.

Tools

Bei diesem Verfahren wird Kubelet verwendet, um das Limit für Prozess-IDs zu verwalten. Kubelet ist der Agent, der auf Pods und Containern ausgeführt wird und dafür sorgt, dass sie gemäß ihrer Pod-Spezifikation 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 Reserved.

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 ist, kann das den Start eines Pods verhindern. Wenn der Wert zu hoch ist, werden möglicherweise keine Ressourcenverstöße erkannt. Bei der Auswahl des geeigneten Limits ist es wichtig, das bisherige Verhalten des Knotens und alle dienstspezifischen Anforderungen zu berücksichtigen.

In GKE ist der zulässige Bereich für den Wert [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 gibt die aktuelle Nutzung von Prozess-IDs an und kann bei der Auswahl eines PID-Limits verwendet werden.

Metrics Explorer

Auf anderen Plattformen sind möglicherweise andere Monitoring-Optionen verfügbar. Informationen zu den Messwerten 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 beide Knotenpools gleich sein. Das Pod-PID-Limit sollte außerdem höher sein als die maximale Anzahl von PIDs, die für alle Apigee-Pods erforderlich ist. Das erforderliche PID-Limit für Apigee-Pods beträgt 1.000, was unter der Mindestanzahl für GKE-Plattformen liegt.

Empfohlene Begrenzung für Pod-PIDs

Einige Plattformen erzwingen einen Mindestwert für die Anzahl der Pod-PIDs. In diesem Fall wird die Mindestwertanforderung ausgewählt.

Prozedur

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

Fehlerbehebung bei Limits für Prozess-IDs

Pod bleibt im Status Pending mit dem Fehler FailedScheduling hängen

Wenn die Begrenzung der Knoten- oder Pod-PIDs den Start eines Pods verhindert oder einschränkt, bleibt der Pod im Status Pending 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 eine PIDPressure-Bedingung vorliegt:

   kubectl describe node -n apigee ${NODE_NAME} | grep PIDPressure
   

3. Alternativ können Sie auch ApigeeDeployment des entsprechenden Pods prüfen. Rufen Sie die 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 die letzte Events PID-bezogene Fehlermeldungen enthält:

   kubectl describe ApigeeDeployment -n ${APIGEE_NAMESPACE} ${APIGEE_DEPLOYMENT_NAME}
   

5. Wenn das PID-Limit die Ursache ist, folgen Sie der Anleitung unter PID-Limits für Knoten verwalten, um das PID-Limit auf einen höheren Wert zu aktualisieren.

"podPidsLimit" ist ungültig

Wenn Sie beim Festlegen des Limits für GKE den Wert für podPidsLimit über dem Limit festlegen, wird folgende Fehlermeldung angezeigt:

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

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