Skalierung von Containerressourcenanfragen und -limits

Autopilot Standard

Auf dieser Seite wird erläutert, wie Sie die CPU-Anfragen und Speicheranfragen eines Containers in einem Google Kubernetes Engine-Cluster analysieren und anpassen können mithilfe vertikalem Pod-Autoscaling.

Sie können Containerressourcen manuell über die Google Cloud Console skalieren, Ressourcen mit einem VerticalPodAutoscaler-Objekt analysieren oder die automatische Skalierung mit vertikalem Pod-Autoscaling konfigurieren.

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

• Aktivieren Sie die Google Kubernetes Engine API.
Google Kubernetes Engine API aktivieren
• Wenn Sie die Google Cloud CLI für diesen Task verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem Befehl gcloud components update ab. In früheren gcloud CLI-Versionen werden die Befehle in diesem Dokument möglicherweise nicht unterstützt.
  Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI das compute/region-Attribut fest. Wenn Sie hauptsächlich zonale Cluster verwenden, legen Sie stattdessen compute/zone fest. Wenn Sie einen standardmäßigen Speicherort festlegen, können Sie in der gcloud CLI Fehler wie diesen vermeiden: One of [--zone, --region] must be supplied: Please specify location. Bei bestimmten Befehlen müssen Sie möglicherweise den Speicherort angeben, wenn er sich von dem von Ihnen festgelegten Standard unterscheidet.

Ressourcenanfragen analysieren

Das vertikale Pod-Autoscaling analysiert automatisch Ihre Container und stellt vorgeschlagene Ressourcenanfragen bereit. Sie können diese Ressourcenanfragen mit derGoogle Cloud Console, Cloud Monitoring oder der Google Cloud CLI aufrufen.

Achtung :Wenn Sie auf die Empfehlungen für vertikales Pod-Autoscaling zugreifen, initialisiert GKE den vertikalen Pod-Autoscaling-Controller. Dies kann zu einer Neuerstellung der Steuerungsebene führen.

Console

Wenn Sie die vorgeschlagenen Ressourcenanfragen in der Google Cloud Console aufrufen möchten, muss eine vorhandene Arbeitslast bereitgestellt sein, die mindestens 24 Stunden alt ist. Einige Vorschläge sind möglicherweise für bestimmte Arbeitslasten wie die in den letzten 24 Stunden erstellten Arbeitslasten, eigenständige Pods und in JAVA geschriebene Anwendungen nicht verfügbar oder nicht relevant.

1. Rufen Sie in der Google Cloud -Console die Seite Arbeitslasten auf.

   Zu Arbeitslasten

2. Klicken Sie in der Liste der Arbeitslasten auf den Namen der Arbeitslast, die Sie skalieren möchten.

3. Klicken Sie auf Aktionen > Skalieren > Ressourcenanfragen bearbeiten.

   Im Abschnitt "Daten zur Ressourcenauslastung analysieren" werden Verlaufsdaten zur Nutzung angezeigt, die der vertikale Pod-Autoscaling-Controller analysiert hat, um die vorgeschlagenen Ressourcenanfragen im Abschnitt "Ressourcenanfragen und -limits anpassen" zu erstellen.

Cloud Monitoring

Wenn Sie die vorgeschlagenen Ressourcenanfragen in Cloud Monitoring aufrufen möchten, muss eine vorhandene Arbeitslast bereitgestellt sein.

1. Rufen Sie in der Google Cloud Console die Seite Metrics Explorer auf.

   Zum Metrics Explorer

2. Klicken Sie auf Konfiguration.

3. Maximieren Sie das Menü Messwert auswählen.

4. Wählen Sie im Menü Ressource die Option Kubernetes-Skalierung aus.

5. Wählen Sie im Menü Messwertkategorie die Option Autoscaling aus.

6. Wählen Sie im Menü Messwert die Option Empfohlen pro Replikatanfragebyte und Empfohlen pro Replikatanfragekern aus.

7. Klicken Sie auf Anwenden.

gcloud-CLI

Wenn Sie vorgeschlagene Ressourcenanfragen aufrufen möchten, müssen Sie ein VerticalPodAutoscaler-Objekt und ein Deployment erstellen.

1. Aktivieren Sie für Standardcluster das vertikale Pod-Autoscaling für Ihren Cluster. Bei Autopilot-Clustern ist vertikales Pod-Autoscaling standardmäßig aktiviert.

   gcloud container clusters update CLUSTER_NAME --enable-vertical-pod-autoscaling
   

   Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Clusters.

2. Speichern Sie das folgende Manifest als my-rec-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-rec-deployment
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: my-rec-deployment
     template:
       metadata:
         labels:
           app: my-rec-deployment
       spec:
         containers:
         - name: my-rec-container
           image: nginx
   

   Dieses Manifest beschreibt ein Deployment, das keine CPU- oder Speicheranforderungen hat. Der Wert containers.name von my-rec-deployment gibt an, dass alle Pods im Deployment zum VerticalPodAutoscaler gehören.

3. Wenden Sie das Manifest auf den Cluster an:

   kubectl create -f my-rec-deployment.yaml
   

4. Speichern Sie das folgende Manifest als my-rec-vpa.yaml:

   apiVersion: autoscaling.k8s.io/v1
   kind: VerticalPodAutoscaler
   metadata:
     name: my-rec-vpa
   spec:
     targetRef:
       apiVersion: "apps/v1"
       kind:       Deployment
       name:       my-rec-deployment
     updatePolicy:
       updateMode: "Off"
   

   Dieses Manifest beschreibt einen VerticalPodAutoscaler. DieupdateMode Wert von Off bedeutet, dass der vertikale Pod-Autoscaling-Controller beim Erstellen der Pods die CPU- und Speicheranforderungen der Container analysiert und diese Empfehlungen im Feld status der Ressource speichert. Der vertikale Pod-Autoscaling-Controller aktualisiert die Ressourcenanfragen für die Ausführung von Containern nicht automatisch.

5. Wenden Sie das Manifest auf den Cluster an:

   kubectl create -f my-rec-vpa.yaml
   

6. Sehen Sie sich nach einiger Zeit VerticalPodAutoscaler an:

   kubectl get vpa my-rec-vpa --output yaml
   

   Die Ausgabe sieht etwa so aus:

   ...
     recommendation:
       containerRecommendations:
       - containerName: my-rec-container
         lowerBound:
           cpu: 25m
           memory: 262144k
         target:
           cpu: 25m
           memory: 262144k
         upperBound:
           cpu: 7931m
           memory: 8291500k
   ...
   

   Diese Ausgabe zeigt Empfehlungen für CPU- und Speicheranforderungen:

Pod-Ressourcenanfragen manuell festlegen

Sie können Pod-Ressourcenanfragen manuell über die Google Cloud Console oder kubectl festlegen. Beachten Sie die folgenden Best Practices zum Festlegen von Ressourcenanfragen und ‑limits für Container:

• Arbeitsspeicher: Legen Sie für die Anfrage und das Limit dieselbe Menge an Arbeitsspeicher fest.
• CPU: Geben Sie für die Anfrage die Mindest-CPU an, die für einen korrekten Betrieb gemäß Ihren eigenen SLOs erforderlich ist. Legen Sie ein unbegrenztes CPU-Limit fest.

Achtung: Die Anwendung von vertikalen Pod-Autoscaling-Empfehlungen führt zu Unterbrechungen der Arbeitslast.

Console

1. Rufen Sie in der Google Cloud -Console die Seite Arbeitslasten auf.

   Zu Arbeitslasten

2. Klicken Sie in der Liste der Arbeitslasten auf den Namen der Arbeitslast, die Sie skalieren möchten.

3. Klicken Sie auf Aktionen > Skalieren > Ressourcenanfragen bearbeiten.

   1. Im Abschnitt Ressourcenanfragen und -limits anpassen werden die aktuellen CPU- und Speicheranfragen für jeden Container sowie vorgeschlagene CPU- und Speicheranfragen angezeigt.

4. Klicken Sie auf Neueste Vorschläge anwenden, um vorgeschlagene Anfragen für jeden Container aufzurufen.

5. Klicken Sie auf Änderungen speichern.

6. Klicken Sie auf Bestätigen.

kubectl

Arbeitslasten mit minimalen Unterbrechungen vertikal skalieren

Vorschau

Diese Funktion unterliegt den Bedingungen für Pre‑GA-Angebote im Abschnitt „Allgemeine Dienstbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA-Funktionen sind „wie gesehen“ verfügbar und bieten möglicherweise nur eingeschränkten Support. Weitere Informationen finden Sie in den Beschreibungen der Produkteinführungsphasen.

Ab Kubernetes-Version 1.33 können Sie den Befehl kubectl patch verwenden, um Ihre Arbeitslast vertikal zu skalieren. Dazu aktualisieren Sie die Ressourcen, die einem Container zugewiesen sind, ohne den Pod neu zu erstellen. Weitere Informationen, einschließlich Einschränkungen, finden Sie in der Kubernetes-Dokumentation zum Anpassen der Größe von CPU- und Speicherressourcen.

Wenn Sie den Befehl kubectl patch verwenden möchten, geben Sie die aktualisierte Ressourcenanfrage mit dem Flag --patch an. Wenn Sie beispielsweise my-app auf 800 mCPUs skalieren möchten, führen Sie den folgenden Befehl aus:

kubectl patch pod my-app --subresource resize --patch \
  '{"spec":{"containers":[{"name":"pause", "resources":{"requests":{"cpu":"800m"}, "limits":{"cpu":"800m"}}}]}}'

Arbeitslast vertikal skalieren

Wenn Sie Ressourcenanfragen für einen Pod festlegen möchten, legen Sie die Werte „requests.cpu“ und „memory.cpu“ in Ihrem Deployment-Manifest fest. In diesem Beispiel ändern Sie das Deployment in Ressourcenanforderungen analysieren mit vorgeschlagenen Ressourcenanfragen.

1. Speichern Sie das folgende Beispielmanifest als my-adjusted-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-rec-deployment
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: my-rec-deployment
     template:
       metadata:
         labels:
           app: my-rec-deployment
       spec:
         containers:
         - name: my-rec-container
           image: nginx
           resources:
             requests:
               cpu: 25m
               memory: 256Mi
   

   Dieses Manifest beschreibt ein Deployment mit zwei Pods. Jeder Pod hat einen Container, der 25 MilliCPU und 256 MiB Speicher anfordert.

2. Wenden Sie das Manifest auf den Cluster an:

   kubectl apply -f my-adjusted-deployment.yaml
   

Pod-Ressourcenanfragen automatisch festlegen

Vertikales Pod-Autoscaling verwendet das Objekt VerticalPodAutoscaler, um Ressourcenanfragen für Pods automatisch festzulegen, wenn der updateMode auf den Wert Auto gesetzt ist. Sie können ein VerticalPodAutoscaler über die gcloud CLI oder dieGoogle Cloud -Konsole konfigurieren.

Achtung: Das Aktivieren oder Deaktivieren des vertikalen Pod-Autoscalings kann zu Unterbrechungen der Arbeitslast führen, da Pods neu erstellt werden.

Console

Damit Sie Ressourcenanforderungen automatisch festlegen können, müssen Sie einen Cluster mit aktivierter vertikaler Pod-Autoscaling-Funktion haben. Bei Autopilot-Clustern ist das Feature für vertikales Pod-Autoscaling standardmäßig aktiviert.

Vertikales Pod-Autoscaling aktivieren

1. Öffnen Sie in der Google Cloud Console die Seite Google Kubernetes Engine.

   Zur Seite "Google Kubernetes Engine"

2. Klicken Sie in der Clusterliste auf den Namen des Clusters, den Sie ändern möchten.

3. Klicken Sie im Abschnitt Automatisierung für die Option Vertikales Pod-Autoscaling auf Bearbeiten.

4. Klicken Sie das Kästchen Vertikales Pod-Autoscaling aktivieren an.

5. Klicken Sie auf Änderungen speichern.

Vertikales Pod-Autoscaling konfigurieren

1. Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf.

   Zu Arbeitslasten

2. Klicken Sie in der Liste der Arbeitslasten auf den Namen des Deployments, für das Sie vertikales Pod-Autoscaling konfigurieren möchten.

3. Klicken Sie auf Aktionen > Automatisch skalieren > Vertikales Pod-Autoscaling.

4. Wählen Sie einen Autoscaling-Modus aus:

   • Automatisch: Vertikales Pod-Autoscaling aktualisiert CPU- und Speicheranfragen während der Lebensdauer eines Pods.
   • Anfänglich: Vertikales Pod-Autoscaling weist Ressourcenanfragen nur bei der Pod-Erstellung zu und ändert sie später nie mehr.

5. (Optional) Legen Sie Containerrichtlinien fest. Mit dieser Option können Sie dafür sorgen, dass die Empfehlung nie über oder unter einer bestimmten Ressourcenanfrage festgelegt wird.

   1. Klicken Sie auf Richtlinie hinzufügen.
   2. Wählen Sie unter Containermodus bearbeiten die Option Automatisch aus.
   3. Wählen Sie unter Gesteuerte Ressourcen die Ressourcen aus, für die Sie den Container automatisch skalieren möchten.
   4. Klicken Sie auf Regel hinzufügen, um einen oder mehrere Mindest- oder Höchstwerte für die Ressourcenanfragen des Containers festzulegen:
      • Min. Zugelassener Arbeitsspeicher: Die minimale Speichermenge, die der Container immer haben soll, in MiB.
      • Min. Zulässige CPU: Die Mindest-CPU, die der Container immer haben soll, in mCPU.
      • Max. zulässiger Arbeitsspeicher: Die maximale Speichermenge, die der Container immer haben soll, in MiB.
      • Maximal zulässige CPU: Die maximale CPU-Menge, die der Container immer haben soll, in mCPU.

6. Klicken Sie auf Fertig.

7. Klicken Sie auf Speichern.

gcloud

Wenn Sie Ressourcenanfragen automatisch festlegen möchten, müssen Sie einen Cluster verwenden, für den das vertikale Pod-Autoscaling aktiviert ist. Für Autopilot-Cluster ist die Funktion standardmäßig aktiviert.

1. Aktivieren Sie für Standardcluster das vertikale Pod-Autoscaling für Ihren Cluster:

   gcloud container clusters update CLUSTER_NAME --enable-vertical-pod-autoscaling
   

   Ersetzen Sie CLUSTER_NAME durch den Namen Ihres Clusters.

2. Speichern Sie das folgende Manifest als my-auto-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-auto-deployment
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: my-auto-deployment
     template:
       metadata:
         labels:
           app: my-auto-deployment
       spec:
         containers:
         - name: my-container
           image: registry.k8s.io/ubuntu-slim:0.14
           resources:
             requests:
               cpu: 100m
               memory: 50Mi
           command: ["/bin/sh"]
           args: ["-c", "while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done"]
   

   Dieses Manifest beschreibt ein Deployment mit zwei Pods. Jeder Pod hat einen Container, der 100 MilliCPU und 50 MiB Speicher anfordert.

3. Wenden Sie das Manifest auf den Cluster an:

   kubectl create -f my-auto-deployment.yaml
   

4. Listen Sie die aktiven Pods auf:

   kubectl get pods
   

   Die Ausgabe zeigt die Namen der Pods in my-deployment an:

   NAME                            READY     STATUS             RESTARTS   AGE
   my-auto-deployment-cbcdd49fb-d6bf9   1/1       Running            0          8s
   my-auto-deployment-cbcdd49fb-th288   1/1       Running            0          8s
   

5. Speichern Sie das folgende Manifest als my-vpa.yaml:

   apiVersion: autoscaling.k8s.io/v1
   kind: VerticalPodAutoscaler
   metadata:
     name: my-vpa
   spec:
     targetRef:
       apiVersion: "apps/v1"
       kind:       Deployment
       name:       my-auto-deployment
     updatePolicy:
       updateMode: "Recreate"
   

   Dieses Manifest beschreibt einen VerticalPodAutoscaler mit folgenden Attributen:

   • targetRef.name: gibt an, dass jeder Pod, der von einem Deployment mit dem Namen my-deployment gesteuert wird, zu diesem VerticalPodAutoscaler gehört.
   • updateMode: "Recreate": gibt an, dass der vertikale Pod-Autoscaling-Controller einen Pod löschen, die CPU- und Speicheranforderungen anpassen und dann einen neuen Pod starten kann. Dies ist das Standardverhalten, wenn kein Modus angegeben ist (auch als Auto-Modus bezeichnet). Sie können den Aktualisierungsmodus auch auf einen der folgenden Werte ändern:
     • updateMode: "Initial": Vertikales Pod-Autoscaling weist Ressourcenanfragen nur bei der Pod-Erstellung zu.
     • updateMode: "InPlaceOrRecreate" (Vorabversion): Das vertikale Pod-Autoscaling versucht, Ressourcen zu aktualisieren, ohne den Pod neu zu erstellen. Falls erforderlich, wird der Pod neu erstellt.

6. Wenden Sie das Manifest auf den Cluster an:

   kubectl create -f my-vpa.yaml
   

7. Warten Sie einige Minuten und rufen Sie dann wieder die aktiven Pods auf:

   kubectl get pods
   

   Die Ausgabe zeigt, dass sich die Pod-Namen geändert haben:

   NAME                                 READY     STATUS             RESTARTS   AGE
   my-auto-deployment-89dc45f48-5bzqp   1/1       Running            0          8s
   my-auto-deployment-89dc45f48-scm66   1/1       Running            0          8s
   

   Sollten sich die Namen der Pods noch nicht geändert haben, warten Sie etwas länger und listen Sie die aktiven Pods noch einmal auf.

Informationen zu vertikalem Pod-Autoscaling ansehen

So rufen Sie Details zu vertikalem Pod-Autoscaling auf:

1. Rufen Sie detaillierte Informationen zu einem der aktiven Pods ab:

   kubectl get pod POD_NAME --output yaml
   

   Ersetzen Sie POD_NAME durch den Namen eines Ihrer Pods, die Sie im vorherigen Schritt abgerufen haben.

   Die Ausgabe sieht in etwa so aus:

   apiVersion: v1
   kind: Pod
   metadata:
     annotations:
       vpaUpdates: 'Pod resources updated by my-vpa: container 0: cpu capped to node capacity, memory capped to node capacity, cpu request, memory request'
   ...
   spec:
     containers:
     ...
       resources:
         requests:
           cpu: 510m
           memory: 262144k
       ...
   

   Diese Ausgabe zeigt, dass der vertikale Pod-Autoscaling-Controller eine Speicheranfrage von 26.2144 KB und eine CPU-Anfrage von 510 MilliCPU hat.

2. Rufen Sie detaillierte Informationen zum VerticalPodAutoscaler ab:

   kubectl get vpa my-vpa --output yaml
   

   Die Ausgabe sieht in etwa so aus:

   ...
     recommendation:
       containerRecommendations:
       - containerName: my-container
         lowerBound:
           cpu: 536m
           memory: 262144k
         target:
           cpu: 587m
           memory: 262144k
         upperBound:
           cpu: 27854m
           memory: "545693548"
   

   Diese Ausgabe enthält Empfehlungen für CPU- und Speicheranforderungen und enthält die folgenden Attribute:

   • target: gibt an, dass der Container für die optimale Ausführung 587 MilliCPU und 26.2144 Kilobyte an Arbeitsspeicher anfordern sollte.
   • lowerBound und upperBound: Vertikales Pod-Autoscaling verwendet diese Attribute, um zu entscheiden, ob ein Pod gelöscht und durch einen neuen Pod ersetzt werden soll. Wenn die Anforderungen eines Pods unter der Untergrenze oder über der Obergrenze liegen, wird er vom vertikalen Pod-Autoscaling gelöscht und durch einen Pod ersetzt, der mit dem Zielattribut übereinstimmt.

Bestimmte Container deaktivieren

Sie können bestimmte Container mithilfe der gcloud CLI oder der Google Cloud -Konsole vom vertikalen Pod-Autoscaling deaktivieren.

Console

Wenn Sie bestimmte Container aus dem vertikalen Pod-Autoscaling deaktivieren möchten, benötigen Sie einen Cluster mit aktivierter Funktion für das vertikale Pod-Autoscaling. Bei Autopilot-Clustern ist das Feature für vertikales Pod-Autoscaling standardmäßig aktiviert.

Vertikales Pod-Autoscaling aktivieren

1. Öffnen Sie in der Google Cloud Console die Seite Google Kubernetes Engine.

   Zur Seite "Google Kubernetes Engine"

2. Klicken Sie in der Clusterliste auf den Namen des Clusters, den Sie ändern möchten.

3. Klicken Sie im Abschnitt Automatisierung für die Option Vertikales Pod-Autoscaling auf Bearbeiten.

4. Klicken Sie das Kästchen Vertikales Pod-Autoscaling aktivieren an.

5. Klicken Sie auf Änderungen speichern.

Vertikales Pod-Autoscaling konfigurieren

1. Rufen Sie in der Google Cloud Console die Seite Arbeitslasten auf.

   Zu Arbeitslasten

2. Klicken Sie in der Liste der Arbeitslasten auf den Namen des Deployments, für das Sie vertikales Pod-Autoscaling konfigurieren möchten.

3. Klicken Sie auf Aktionen > Automatisch skalieren > Vertikales Pod-Autoscaling.

4. Wählen Sie einen Autoscaling-Modus aus:

   • Automatisch: Vertikales Pod-Autoscaling aktualisiert CPU- und Speicheranfragen während der Lebensdauer eines Pods.
   • Anfänglich: Vertikales Pod-Autoscaling weist Ressourcenanfragen nur bei der Pod-Erstellung zu und ändert sie später nie mehr.

5. Klicken Sie auf Richtlinie hinzufügen.

6. Wählen Sie den Container aus, den Sie deaktivieren möchten.

7. Wählen Sie für Containermodus bearbeiten die Option Aus aus.

8. Klicken Sie auf Fertig.

9. Klicken Sie auf Speichern.

gcloud

Wenn Sie bestimmte Container für das vertikale Pod-Autoscaling deaktivieren möchten, führen Sie die folgenden Schritte aus:

1. Speichern Sie das folgende Manifest als my-opt-vpa.yaml:

   apiVersion: autoscaling.k8s.io/v1
   kind: VerticalPodAutoscaler
   metadata:
     name: my-opt-vpa
   spec:
     targetRef:
       apiVersion: "apps/v1"
       kind:       Deployment
       name:       my-opt-deployment
     updatePolicy:
       updateMode: "Recreate"
     resourcePolicy:
       containerPolicies:
       - containerName: my-opt-sidecar
         mode: "Off"
   

   Dieses Manifest beschreibt einen VerticalPodAutoscaler. Der Wert mode: "Off" deaktiviert Empfehlungen für den Container my-opt-sidecar.

2. Wenden Sie das Manifest auf den Cluster an:

   kubectl apply -f my-opt-vpa.yaml
   

3. Speichern Sie das folgende Manifest als my-opt-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-opt-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: my-opt-deployment
     template:
       metadata:
         labels:
           app: my-opt-deployment
       spec:
         containers:
         - name: my-opt-container
           image: nginx
         - name: my-opt-sidecar
           image: busybox
           command: ["sh","-c","while true; do echo Doing sidecar stuff!; sleep 60; done"]
   

4. Wenden Sie das Manifest auf den Cluster an:

   kubectl apply -f my-opt-deployment.yaml
   

5. Nach einiger Zeit können Sie vertikales Pod-Autoscaling aufrufen:

   kubectl get vpa my-opt-vpa --output yaml
   

   Die Ausgabe zeigt Empfehlungen für CPU- und Speicheranforderungen:

   ...
     recommendation:
       containerRecommendations:
       - containerName: my-opt-container
   ...
   

   In dieser Ausgabe gibt es nur Empfehlungen für einen Container. Es gibt keine Empfehlungen für my-opt-sidecar.

   Vertikales Pod-Autoscaling aktualisiert niemals Ressourcen für deaktivierte Container. Wenn Sie einige Minuten warten, erstellt der Pod Container zwar neu, aber nur ein Container enthält aktualisierte Ressourcenanforderungen.

Arbeitslasten ohne Ressourcenanforderungen oder ‑limits identifizieren

Es kann sinnvoll sein, Arbeitslasten ohne konfigurierte Ressourcenanfragen und ‑limits zu identifizieren, da GKE empfiehlt, Ressourcenanfragen und ‑limits für alle Arbeitslasten als Best Practice festzulegen, um einen abrupten Pod-Abschluss bei Ressourcenengpässen auf dem Knoten zu vermeiden und die Genauigkeit der Kostenzuweisung zu verbessern. Das Definieren von BestEffort-Pods oder Pods mit Burstable-Arbeitsspeicher kann zu Zuverlässigkeitsproblemen führen, wenn bei einem Knoten Arbeitsspeicher ausgelastet ist. Beachten Sie die folgenden Best Practices zum Festlegen von Ressourcenanfragen und ‑limits für Container:

• Arbeitsspeicher: Legen Sie für die Anfrage und das Limit dieselbe Menge an Arbeitsspeicher fest.
• CPU: Geben Sie für die Anfrage die Mindest-CPU an, die für einen korrekten Betrieb gemäß Ihren eigenen SLOs erforderlich ist. Legen Sie ein unbegrenztes CPU-Limit fest.

GKE generiert Statistiken und Empfehlungen für Arbeitslasten, die ohne Ressourcenanforderungen und ‑limits ausgeführt werden.

In der folgenden Tabelle werden die von GKE erkannten Szenarien für die Ressourcenkonfiguration und die Kriterien für jedes Szenario beschrieben.

Statistikuntertyp	Szenario mit fehlenden Einstellungen	Details
REQUEST_OR_LIMIT_NOT_SET	Es wurden keine Arbeitsspeicheranfrage und kein Arbeitsspeicherlimit konfiguriert. (MEMORY_REQUEST_AND_LIMIT_NOT_SET)	Pods werden ohne für deren Container festgelegte Arbeitsspeicheranfragen und ‑limits ausgeführt. GKE kann die Arbeitsspeichernutzung nicht drosseln und solche Pods möglicherweise abrupt beenden, wenn bei einem Knoten der Arbeitsspeicher ausgelastet ist. Dies kann zu Zuverlässigkeitsproblemen führen.
REQUEST_OR_LIMIT_NOT_SET	Keine konfigurierten Speicherlimits. (MEMORY_LIMIT_NOT_SET)	Pods werden ohne für deren Container festgelegte Arbeitsspeicherlimits ausgeführt. GKE kann die Arbeitsspeichernutzung nicht drosseln und solche Pods möglicherweise abrupt beenden, wenn bei einem Knoten der Arbeitsspeicher ausgelastet ist und die Arbeitsspeichernutzung der Pods die Anforderungen überschreitet. Dies kann zu Zuverlässigkeitsproblemen führen. Sie sollten für Anfragen und Limits die gleiche Arbeitsspeichermenge festlegen, um zu vermeiden, dass Pods mehr Arbeitsspeicher verwenden als angefordert.
REQUEST_OR_LIMIT_NOT_SET	Es sind keine CPU-Anfrage und kein CPU-Limit konfiguriert. (CPU_REQUEST_AND_LIMIT_NOT_SET)	Pods werden ohne für Container festgelegte CPU-Anfragen und ‑Limits ausgeführt. Dies erhöht die Wahrscheinlichkeit, dass Knotenressourcen ausgehen. Außerdem werden Pods eher gedrosselt, wenn die CPU-Auslastung des Knotens nahe am Limit ist. Möglicherweise treten dann Leistungsprobleme auf.

Weitere Informationen zu diesen Statistiken

Ressourcenanfragen und ‑limits manuell prüfen

Möglicherweise möchten Sie manuell prüfen, welche Ressourcenanfragen und ‑limits für eine bestimmte Arbeitslast fehlen und angegeben werden müssen, damit Sie die Konfiguration wie empfohlen aktualisieren können.

So rufen Sie die Konfiguration für Ressourcenanfragen und ‑limits für eine bestimmte Arbeitslast auf oder aktualisieren sie:

1. Rufen Sie in der Google Cloud -Console die Seite Arbeitslasten auf.

   Zu Arbeitslasten

2. Klicken Sie in der Arbeitslastliste auf den Namen der Arbeitslast, die Sie untersuchen möchten.

3. Klicken Sie auf Aktionen > Skalieren > Ressourcenanfragen bearbeiten.

   1. Im Abschnitt Ressourcenanfragen und ‑limits anpassen werden die aktuellen CPU- und Speicheranfragen für jeden Container angezeigt.

Nächste Schritte

• Weitere Informationen zu vertikalem Pod-Autoscaling
• Best Practices zum Ausführen kostenoptimierter Kubernetes-Anwendungen in GKE
• Informationen zum Optimieren der Nutzung von GKE mit Statistiken und Empfehlungen