Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

GKE-Arbeitslasten mit HPA auf null skalieren und von null skalieren

Autopilot Standard

In dieser Anleitung erfahren Sie, wie Sie die Ressourcennutzung in Google Kubernetes Engine (GKE) optimieren, indem Sie Arbeitslasten so konfigurieren, dass sie bei Inaktivität automatisch auf null Replikate skaliert und bei steigender Nachfrage wieder hochskaliert werden. Bei diesem Ansatz wird das horizontale Pod-Autoscaling (HPA) in die verwaltete Autoscaling-Infrastruktur von GKE integriert, um die Skalierung basierend auf externen Messwerten zu verwalten.

Konfigurieren Sie die Bereitstellung so, dass sie auf null skaliert wird. Setzen Sie dazu den Wert des Felds minReplicas auf 0 und definieren Sie einen Messwert mit dem Typ External oder Object im HPA-Manifest. GKE überwacht diese Messwerte über die benutzerdefinierte Ressource AutoscalingMetric, um eine effiziente Ressourcenverwaltung für Ihre Anwendungen zu gewährleisten.

Bei dieser Konfiguration müssen Sie keine Drittanbieter-Messwertadapter wie KEDA verwenden, um GKE-Arbeitslasten zu skalieren. Bei dieser Lösung werden die Aufnahme von Messwerten und die Empfehlungen zur Skalierung direkt in der GKE-Steuerungsebene verwaltet, wodurch der Aufwand für die Clusterverwaltung reduziert wird.

In dieser Anleitung stellen Sie eine asynchrone Beispiel-Worker-Anwendung bereit, die Nachrichten aus einer Pub/Sub-Warteschlange verarbeitet. Sie konfigurieren ein horizontales Pod-Autoscaling, um die Warteschlangentiefe (pubsub.googleapis.com:num_undelivered_messages) mit einer benutzerdefinierten AutoscalingMetric-Ressource zu überwachen:

Wenn Nachrichten im Abo eingehen:GKE skaliert Worker-Pods hoch, um die Warteschlange zu verarbeiten.
Wenn die Warteschlange leer ist:GKE skaliert die Worker-Bereitstellung automatisch auf null Replikate herunter.

Diese Anleitung richtet sich an Anwendungsentwickler, Plattformadministratoren und ‑operatoren sowie DevOps-Experten, die die Ressourcennutzung in GKE optimieren möchten, indem sie Arbeitslasten auf null skalieren, wenn sie im Leerlauf sind.

Hinweise

Bevor Sie Arbeitslasten für die Skalierung auf null konfigurieren, sollten Sie die folgenden Hinweise lesen:

Wenn Sie Arbeitslasten mit HPA auf null und von null skalieren möchten, muss auf der Steuerungsebene und den Knoten des GKE-Clusters Version 1.37 oder höher ausgeführt werden. Dies gilt sowohl für neue als auch für aktualisierte vorhandene Cluster. Wenn Sie einen vorhandenen Cluster verwenden, prüfen Sie seine Version oder führen Sie ein Upgrade des Clusters oder seiner Knoten auf Version 1.37 oder höher durch.
In Ihrem HPA-Manifest muss die apiVersion: autoscaling/v2-Konfiguration verwendet werden, um die Einstellung minReplicas: 0 und externe Messwerte zu unterstützen.
Bevor Sie Knotenpools auf eine Version vor 1.37 downgraden, aktualisieren Sie alle HPA-Manifeste, die für das Skalieren auf und von null konfiguriert sind, indem Sie das Feld minReplicas auf 1 oder höher festlegen. Versionen vor 1.37 unterstützen die Einstellung minReplicas: 0 nicht. Das kann dazu führen, dass Arbeitslasten bei null Replikaten hängen bleiben.
Sie müssen mindestens einen External- oder Object-Messwert (z. B. eine Warteschlangentiefe) in Ihrem horizontalen Pod-Autoscaler konfigurieren. GKE kann keine Messwerte für CPU oder Arbeitsspeicher (Resource) erfassen, wenn eine Arbeitslast keine Pods hat. Daher kann das Hochskalieren von null nicht allein durch Ressourcenmesswerte ausgelöst werden.
Die AutoscalingMetric, der HorizontalPodAutoscaler und die Zielbereitstellung müssen sich im selben Kubernetes-Namespace befinden.

Hinweis

Installieren Sie die Google Cloud CLI.
Konfigurieren Sie die gcloud CLI für die Verwendung Ihrer föderierten Identität.

Weitere Informationen finden Sie unter Mit Ihrer föderierten Identität in der gcloud CLI anmelden.
Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:
```
gcloud init
```
Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.
Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind
- Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
- Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen
Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.
- So erstellen Sie ein Google Cloud Projekt:
```
gcloud projects create PROJECT_ID
```
  Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.
- Wählen Sie das von Ihnen erstellte Google Cloud Projekt aus:
```
gcloud config set project PROJECT_ID
```
  Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .
Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.
Aktivieren Sie die GKE API und die Pub/Sub API:
Rollen, die zum Aktivieren von APIs erforderlich sind
Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Rolle „Inhaber“ (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen
```
gcloud services enable container.googleapis.com pubsub.googleapis.com
```

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen dieser Anleitung benötigen:

GKE-Clusteradministrator (roles/container.clusterAdmin)
Pub/Sub-Administrator (roles/pubsub.admin)
Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
Service Account User (roles/iam.serviceAccountUser)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Umgebung einrichten

Der Einfachheit halber werden in dieser Anleitung mit den Befehlen alle Ressourcen (den GKE-Cluster sowie das Pub/Sub-Thema und das Abo) in einem einzigen Google Cloud ProjektPROJECT_IDerstellt.

So richten Sie Ihre Umgebung ein:

Legen Sie Umgebungsvariablen fest:
```
export PROJECT_ID=PROJECT_ID
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format 'get(projectNumber)')
export LOCATION=LOCATION
```
Ersetzen Sie Folgendes:
- PROJECT_ID: Ihre Google Cloud Projekt-ID.
- LOCATION: die Region oder Zone, in der Sie Ihren GKE-Cluster erstellen möchten, z. B. us-central1. Geben Sie für Autopilot-Cluster eine Region an.
Hinweis :Diese Umgebungsvariablen werden in dieser Anleitung verwendet. Wenn Sie eine neue Shell-Sitzung öffnen oder die Verbindung trennen, führen Sie diese Befehle noch einmal aus, um die Variablen festzulegen.
Erstellen Sie einen GKE-Cluster mit Version 1.37 oder höher und aktivierter Workload Identity Federation for GKE. Für eine vollständig verwaltete Kubernetes-Umgebung empfehlen wir die Verwendung eines Autopilot-Clusters. So können Sie die Kosteneinsparungen maximieren, wenn Arbeitslasten auf null skaliert werden. Informationen zum Auswählen des Betriebsmodus, der für Ihre Arbeitslasten am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen:
Autopilot
Autopilot-Cluster erstellen:
gcloud container clusters create-auto scale-to-zero \ --project=${PROJECT_ID} \ --location=${LOCATION}
Die Workload Identity-Föderation für GKE ist in Autopilot-Clustern standardmäßig aktiviert.
Standard
Erstellen Sie einen Standard-Cluster mit aktivierter Workload Identity Federation for GKE:
gcloud container clusters create scale-to-zero \ --project=${PROJECT_ID} \ --location=${LOCATION} \ --workload-pool=${PROJECT_ID}.

Konfigurieren Sie kubectl für die Kommunikation mit Ihrem Cluster:

gcloud container clusters get-credentials scale-to-zero \
    --project=${PROJECT_ID} \
    --location=${LOCATION}

Pub/Sub-Ressourcen erstellen

In dieser Anleitung wird die Pub/Sub-Warteschlangentiefe als Beispiel für eine externe Messwertquelle verwendet.

So erstellen Sie ein Pub/Sub-Thema und -Abo:

Pub/Sub-Thema erstellen

gcloud pubsub topics create my-worker-topic \
    --project=${PROJECT_ID}

Erstellen Sie ein Abo, das mit dem Thema verknüpft ist:

gcloud pubsub subscriptions create my-worker-subscription \
    --topic=my-worker-topic \
    --project=${PROJECT_ID}

Workload Identity Federation für GKE einrichten

Konfigurieren Sie Workload Identity Federation for GKE, damit sich Ihre Worker-Anwendung bei Google Cloud -APIs authentifizieren und Nachrichten aus Pub/Sub empfangen kann.

GKE übernimmt automatisch die Authentifizierung bei Cloud Monitoring für AutoscalingMetric-Ressourcen im selben Projekt. Weitere Informationen zum Definieren von Messwerten für das Autoscaling finden Sie unter Benutzerdefinierte oder externe Messwerte aus Cloud Monitoring abrufen.

So konfigurieren Sie die Workload Identity Federation for GKE für Ihre Worker-Arbeitslast:

Erstellen Sie ein Kubernetes-Dienstkonto für Ihre Worker-Anwendung im Namespace default:
```
kubectl create serviceaccount async-worker-sa \
    --namespace default
```

Weisen Sie dem Kubernetes-Dienstkonto die Rolle roles/pubsub.subscriber zu, damit die Anwendung Nachrichten aus Ihrem Pub/Sub-Abo empfangen kann:

gcloud projects add-iam-policy-binding projects/${PROJECT_ID} \
    --role=roles/pubsub.subscriber \
    --member=principal://iam.googleapis.com/projects/${PROJECT_NUMBER}/locations/global/workloadIdentityPools/${PROJECT_ID}./subject/ns/default/sa/async-worker-sa

Weitere Informationen finden Sie unter Anwendungen für die Verwendung von Workload Identity Federation for GKE konfigurieren.

Beispiel-Deployment erstellen

Bevor Sie ein HPA-Objekt erstellen können, müssen Sie die Arbeitslast erstellen, die überwacht werden soll.

So erstellen Sie das Beispiel-Deployment:

Speichern Sie das folgende Manifest als async-worker.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: async-worker
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: async-worker
  template:
    metadata:
      labels:
        app: async-worker
    spec:
      containers:
      - name: async-worker
        image: nginx:latest
        ports:
        - containerPort: 80
        resources:
          limits:
            memory: 100Mi
          requests:
            cpu: 50m
            memory: 100Mi

Wenden Sie das Deployment async-worker.yaml an:
```
kubectl apply -f async-worker.yaml
```

Arbeitslast für das Skalieren auf und von null konfigurieren

In diesem Abschnitt konfigurieren Sie die async-worker-Bereitstellung so, dass sie auf null skaliert wird, wenn die Pub/Sub-Warteschlange leer ist, und wieder hochskaliert wird, wenn neue Nachrichten eingehen.

AutoscalingMetric-Ressource erstellen

Erstellen Sie die benutzerdefinierte Ressource „AutoscalingMetric“, um das von GKE überwachte externe Signal zu definieren. Im folgenden Beispielmanifest wird mit dem Messwert die Anzahl der nicht zugestellten Pub/Sub-Nachrichten im Abo my-worker-subscription von Cloud Monitoring abgefragt.

So erstellen Sie die Ressource „AutoscalingMetric“:

Speichern Sie das folgende Manifest als Datei pubsub-metric.yaml:

apiVersion: autoscaling.gke.io/v1beta1
kind: AutoscalingMetric
metadata:
  name: pubsub-queue-depth
  namespace: default
spec:
  metrics:
  - promql:
      name: pubsub-undelivered
      query: >
          {
            "pubsub.googleapis.com/subscription/num_undelivered_messages",
            subscription_id="my-worker-subscription"
          }

Wenden Sie das pubsub-metric.yaml-Manifest an:
```
kubectl apply -f pubsub-metric.yaml
```
Prüfen Sie den Messwertstatus und rufen Sie die Messwert-ID ab:
```
kubectl describe autoscalingmetric pubsub-queue-depth
```
Prüfen Sie im Abschnitt Status der Ausgabe, ob Fehler aufgeführt sind, und notieren Sie sich den Wert Hpa Name im Format autoscaling.gke.io|CUSTOM_RESOURCE_NAME|METRIC_NAME. Sie verweisen auf diese Kennung für externe Messwerte, wenn Sie im nächsten Abschnitt das HorizontalPodAutoscaler-Objekt erstellen. Wenn im Abschnitt Status Konfigurationsfehler gemeldet werden oder Messwerte nicht wie erwartet abgerufen werden, lesen Sie den Abschnitt Fehlerbehebung bei Messwerten, die für die automatische Skalierung abgerufen werden.

Horizontales Pod-Autoscaling konfigurieren

Wenn Sie das Autoscaling-Verhalten konfigurieren möchten, erstellen Sie eine HorizontalPodAutoscaler-Ressource, die auf das Deployment ausgerichtet ist.

So konfigurieren Sie das horizontale Pod-Autoscaling:

Speichern Sie das folgende Manifest als Datei worker-hpa.yaml:
```
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: async-worker-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: async-worker
  minReplicas: 0
  maxReplicas: 20
  metrics:
  - type: External
    external:
      metric:
        name: autoscaling.gke.io|pubsub-queue-depth|pubsub-undelivered
      target:
        type: AverageValue
        averageValue: "10"
```
In diesem Manifest werden die folgenden Schlüsselfelder konfiguriert:
- minReplicas: 0: Ermöglicht die Skalierung auf null, indem der Controller das Deployment auf 0 Replikate herunterskalieren kann, wenn die Nachfrage auf null sinkt.
- type: External: Konfiguriert eine externe Messwertquelle, damit das HPA eine Aufskalierung auslösen kann, wenn die Arbeitslast keine Pods hat.
- name: autoscaling.gke.io|pubsub-queue-depth|pubsub-undelivered: ordnet die HPA-Ressource direkt der im vorherigen Schritt erstellten AutoscalingMetric-Ressource zu, indem das autoscaling.gke.io|CUSTOM_RESOURCE_NAME|METRIC_NAME-Format für die Kennung verwendet wird.
Wenden Sie das worker-hpa.yaml-Manifest an:
```
kubectl apply -f worker-hpa.yaml
```

Verhalten und Bedingungen für das Herunterskalieren auf null prüfen

Wenn alle Nachrichten im Pub/Sub-Abo verarbeitet wurden, wertet der horizontale Pod-Autoscaler die Nachfrage von null aus und skaliert das Deployment auf 0 Replikate herunter.

Prüfen Sie mit dem folgenden Befehl die Statusbedingungen der async-worker-hpa-Ressource, um zu bestätigen, dass der horizontale Pod-Autoscaler den Status „0“ aktiviert hat:

kubectl describe hpa async-worker-hpa

Die Ausgabe sieht etwa so aus:

Name:             async-worker-hpa
Namespace:        default
Reference:        Deployment/async-worker
Metrics:          ( current / target )
  "autoscaling.gke.io|pubsub-queue-depth|pubsub-undelivered" (external metric):  0 / 10
Min replicas:     0
Max replicas:     20
Deployment pods:  0 current / 0 desired
Conditions:
  Type            Status  Reason               Message
  ----            ------  ------               -------
  AbleToScale     True    SucceededGetScale    the HPA controller was able to get the target's current scale
  ScalingActive   True    ValidMetricFound     the HPA was able to successfully calculate a replica count from external metric
  ScaledToZero    True    ScaledToZero         the HPA has scaled the target resource to 0 replicas due to zero metric demand

`ScaledToZero`-Bedingung

Die Bedingung ScaledToZero gibt an, ob der horizontale Pod-Autoscaler die Arbeitslast auf null Replikate skaliert hat:

ScaledToZero: True (Reason: ScaledToZero): Gibt an, dass der HPA-Controller Ihre Arbeitslast erfolgreich auf 0 Replikate skaliert hat, da die Nachfrage nach externen Messwerten auf null gesunken ist. Der HPA bleibt aktiv (ScalingActive: True) und fragt GKE kontinuierlich ab, um zu erkennen, wann die Workload-Anforderungen steigen.
ScaledToZero: False: Gibt an, dass die Arbeitslast auf ein oder mehrere Replikate skaliert wurde.

Wenn Sie eine Bereitstellung manuell auf null Replikate skalieren, z. B. mit dem Befehl kubectl scale --replicas=0, pausiert das HPA-Objekt das Autoscaling (ScalingActive: False), um widersprüchliche Änderungen zu vermeiden. Wenn Sie das Autoscaling fortsetzen möchten, skalieren Sie das Deployment wieder auf ein oder mehrere Replikate (kubectl scale deployment async-worker --replicas=1).

Informationen zur Fehlerbehebung bei Szenarien, in denen Arbeitslasten nicht auf null skaliert werden oder nicht von null aufskaliert werden, finden Sie unter Fehlerbehebung bei der Skalierung von GKE-Arbeitslasten auf und von null mit HPA. Wenn das horizontale Pod-Autoscaling fehlende oder ungültige externe Messwerte meldet, lesen Sie den Abschnitt Fehlerbehebung bei Messwerten, die für das Autoscaling abgerufen werden.

Bereinigen

So vermeiden Sie, dass Ihrem Google Cloud Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

Löschen Sie den GKE-Cluster:

gcloud container clusters delete scale-to-zero \
    --project=${PROJECT_ID} \
    --location=${LOCATION}

Löschen Sie das Pub/Sub-Abo und -Thema:

gcloud pubsub subscriptions delete my-worker-subscription \
    --project=${PROJECT_ID}
gcloud pubsub topics delete my-worker-topic \
    --project=${PROJECT_ID}