Auslastungsbasiertes Load-Balancing für GKE-Dienste konfigurieren

Auf dieser Seite wird beschrieben, wie Sie die nutzungsbasierte Lastverteilung für GKE-Dienste konfigurieren. Diese Seite richtet sich an Infrastruktur- und Anwendungsteams sowie an GKE-Administratoren, die für die Konfiguration und Verwaltung der Traffic-Verteilung für ihre GKE-Dienste verantwortlich sind.

Mit auslastungsbasierten Load Balancern können Sie die Anwendungsleistung und -verfügbarkeit optimieren, indem Sie den Traffic intelligent auf der Grundlage der Echtzeit-Ressourcennutzung Ihrer GKE-Pods verteilen.

Bevor Sie diese Seite lesen, sollten Sie sich mit dem nutzungsbasierten Load-Balancing für GKE-Dienste und der Funktionsweise des nutzungsbasierten Load-Balancing vertraut machen.

Preise

Auslastungsbasiertes Load-Balancing ist eine GKE Gateway-Funktion, die ohne zusätzliche Kosten verfügbar ist. Es gelten weiterhin die Preise für Cloud Load Balancing und GKE.

Kontingente

Beim auslastungsbasierten Load Balancing werden keine neuen Kontingente eingeführt. Es gelten jedoch weiterhin alle Kontingente von Cloud Load Balancing und anderen abhängigen Diensten.

Hinweis

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 diese Aufgabe 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.

Anforderungen für GKE Gateway Controller

Für das auslastungsbasierte Load Balancing für GKE-Dienste ist Folgendes erforderlich:

Die nutzungsbasierte Lastverteilung für GKE-Dienste unterstützt Folgendes:

  • Einzelne und Multi-Cluster-GKE-Dienste, die als Backends für einen Google Cloud-verwalteten Load Balancer dienen.
  • Alle GKE-Versionen (Standard, Autopilot und Enterprise).
  • Alle Google Cloud Application Load Balancer, mit Ausnahme der klassischen Application Load Balancer.

Beschränkungen

Für die nutzungsbasierte Lastverteilung für GKE-Dienste gelten die folgenden Einschränkungen.

  • Die folgenden Messwerte zur Ressourcennutzung werden unterstützt:
  • Passthrough- oder Proxy-Network Load Balancer werden nicht unterstützt.
  • Nur die Gateway API wird unterstützt. Service- und Ingress-APIs werden nicht unterstützt.
  • Das auslastungsbasierte Load Balancing funktioniert nicht gut, wenn der Traffic sehr unregelmäßig ist. Das Neuausgleichen des Traffics dauert bis zu 30 Sekunden, wenn Pods ihre maximale Auslastung erreichen. Das Auslastungssignal sollte mit dem eingehenden Traffic ansteigen. Diese Verzögerung bedeutet jedoch, dass die auslastungsbasierte Lastverteilung Zeit für die Anpassung benötigt. Für eine optimale Leistung eignet sich die nutzungsbasierte Lastverteilung am besten in Umgebungen mit gleichmäßigen, vorhersehbaren Traffic-Flüssen.
  • Die Aktualisierung und Anpassung der Trafficverteilung beim nutzungsbasierten Load-Balancing kann nach Konfigurationsänderungen, z. B. beim Ändern oder Entfernen des Felds „dryRun“ in einem GCPBackendPolicy, bis zu 30 Sekunden dauern. Diese Verzögerung ist ein bekanntes systemweites Verhalten. Daher eignet sich diese Funktion am besten für Anwendungen mit relativ stabilen Traffic-Mustern, bei denen diese Aktualisierungslatenz toleriert werden kann.

Standardmäßig ist das nutzungsbasierte Load-Balancing für Ihre GKE-Dienste deaktiviert. Sie müssen sie explizit aktivieren. Wenn Sie keinen Schwellenwert für die maximale Auslastung festlegen, verwendet das System standardmäßig eine Auslastung von 80% pro Endpunkt.

Ziel der Konfiguration des nutzungsbasierten Load Balancings ist es, die Traffic-Verteilung so zu optimieren, dass Backend-Pods ihre Arbeitslast effizient verwalten können. Dadurch werden die Anwendungsleistung und die Ressourcennutzung verbessert.

Auslastungsbasiertes Load-Balancing und das HPA-Profil „Leistung“ aktivieren

Bevor Sie das auslastungsbasierte Load Balancing konfigurieren, müssen Sie prüfen, ob Ihr GKE-Cluster die erforderlichen Funktionen unterstützt. Beim auslastungsbasierten Load-Balancing werden benutzerdefinierte Messwerte wie die CPU verwendet, um intelligentere Routing-Entscheidungen zu treffen. Diese Entscheidungen hängen von Folgendem ab:

  • Gateway API, die Richtlinien auf Dienstebene über GCPBackendPolicy ermöglicht.
  • Das HPA-Profil „Leistung“, mit dem Arbeitslasten mithilfe von CPU-Signalen schneller und aggressiver skaliert werden können.

Gateway API und HPA-Profil für Leistung aktivieren

Autopilot

Die Gateway API und das HPA-Profil für die Leistung sind in einem Autopilot-Cluster standardmäßig verfügbar.

Standard

Führen Sie den folgenden Befehl aus, um einen neuen Standardcluster mit dem HPA-Profil „Performance“ und aktivierter Gateway API zu erstellen:

gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --cluster-version=CLUSTER_VERSION \
    --gateway-api=standard \
    --hpa-profile=performance \
    --release-channel=rapid

Ersetzen Sie Folgendes:

  • Ersetzen Sie CLUSTER_NAME durch den Namen Ihres neuen Clusters.
  • LOCATION durch die Compute Engine-Region oder -Zone für Ihren Cluster.
  • PROJECT_ID durch Ihre Projekt-ID,
  • CLUSTER_VERSION mit der GKE-Version, die mindestens 1.33.1-gke.1918000 sein muss.

So aktivieren Sie das HPA-Leistungsprofil und die Gateway API in einem vorhandenen GKE Standard-Cluster:

gcloud container clusters update CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID \
    --gateway-api=standard \
    --hpa-profile=performance \
    --release-channel=rapid

Ersetzen Sie Folgendes:

Weitere Informationen zum HPA-Profil „Leistung“ finden Sie unter HPA-Profil „Leistung“ konfigurieren.

Auslastungsbasiertes Load-Balancing konfigurieren

Nachdem Ihr Cluster bereit ist, definieren Sie eine Richtlinie, die festlegt, wie der Traffic basierend auf der Back-End-Auslastung weitergeleitet wird. Sie müssen die Kubernetes Gateway API über GCPBackendPolicy für die Konfiguration verwenden.

Vorbereitung

Bevor Sie die nutzungsbasierte Lastverteilung mit der Gateway API konfigurieren, muss Ihr GKE-Cluster die folgenden Anforderungen erfüllen:

  1. Anwendung bereitstellen: Stellen Sie sicher, dass Sie eine Kubernetes-Anwendung mit einer Deployment-Ressource bereitstellen. Weitere Informationen finden Sie unter Anwendung in einem GKE-Cluster bereitstellen.

    Ein typisches Deployment-Manifest könnte beispielsweise einen Ressourcenabschnitt wie diesen enthalten:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: store-v1
spec:
  # ... other deployment configurations ...
  template:
    # ... other template configurations ...
    spec:
      containers:
        - name: your-container-name
          image: your-image
          ports:
            - containerPort: 8080
          resources:
            limits:
              cpu: 100m
              memory: 45Mi
            requests:
              cpu: 100m
              memory: 45Mi

  2. Anwendung mit einem Dienst freigeben: Sie müssen die Anwendung mit einem Kubernetes-Dienst freigeben. Weitere Informationen zur Funktionsweise von Services und zur Konfiguration finden Sie unter Kubernetes-Services.

  3. Gateway API-basierten Application Load Balancer verwenden: Stellen Sie den Dienst über einen von GKE verwalteten Application Load Balancer bereit, der über die Gateway API konfiguriert wird. Weitere Informationen finden Sie unter Gateways bereitstellen.

GCPBackendPolicy für CPU-basiertes Load Balancing erstellen

Mit dieser Konfiguration kann die GKE den Traffic dynamisch basierend auf der Echtzeit-CPU-Auslastung der einzelnen Backend-Pods verteilen.

Wenn Sie die nutzungsbasierte Lastverteilung für GKE-Dienste aktivieren möchten, verwenden Sie die benutzerdefinierte Ressource GCPBackendPolicy aus der Kubernetes Gateway API.

Mit der benutzerdefinierten Ressource GCPBackendPolicy können Sie das Load-Balancing-Verhalten in Ihrem Kubernetes-Cluster deklarativ definieren. Durch die Angabe von Messwerten zur CPU-Auslastung steuern Sie, wie Traffic basierend auf der aktuellen Ressourcennutzung auf Backends verteilt wird. Dieser Ansatz trägt dazu bei, die Anwendungsleistung aufrechtzuerhalten, eine Überlastung einzelner Pods zu verhindern und die Zuverlässigkeit und Nutzerfreundlichkeit der Anwendung zu verbessern.

  1. Speichern Sie das folgende Beispielmanifest als my-backend-policy.yaml:

    kind: GCPBackendPolicy
apiVersion: networking.gke.io/v1
metadata:
  name: my-backend-policy
  namespace: team-awesome
spec:
  targetRef:
    group: ""
    kind: Service
    name: super-service
  default:
    balancingMode: CUSTOM_METRICS
    customMetrics:
    - name: gke.cpu
      dryRun: false

    Wichtige Hinweise:

    • spec.targetRef.kind: Service: Zielt auf einen Kubernetes-Standarddienst im selben Cluster ab.
    • spec.targetRef.kind: ServiceImport: Richtet sich in einer Multi-Cluster-Konfiguration an einen Dienst aus einem anderen Cluster. Bei Multi-Cluster-Diensten muss der Wert des Felds group auf net.gke.io gesetzt werden.
    • balancingMode: CUSTOM_METRICS: Aktiviert benutzerdefiniertes messwertbasiertes Load Balancing.
    • name: gke.cpu: Gibt die CPU-Auslastung als Messwert für die Traffic-Verteilung an.

    Wenn das Feld maxUtilizationPercent nicht angegeben ist, beträgt der Standard-Auslastungsschwellenwert 80%. Der Traffic wird neu verteilt, wenn ein Backend die CPU-Auslastung von 80% überschreitet.

  2. Wenden Sie das Beispielmanifest auf Ihren Cluster an:

    kubectl apply -f my-backend-policy.yaml

Wenn Sie die Trafficverteilung auf der Echtzeit-CPU-Auslastung basieren, optimieren Sie automatisch die Leistung. So wird eine Überlastung einzelner Pods verhindert.

Wichtige Hinweise zu dryRun und balancingMode

Wenn Sie GCPBackendPolicy mit benutzerdefinierten Messwerten konfigurieren, sollten Sie die Interaktion zwischen balancingMode und dem Feld dryRun in Ihrer customMetrics-Definition berücksichtigen. Diese Interaktion bestimmt, wie der Load Balancer Ihre benutzerdefinierten Messwerte verwendet. Weitere Informationen zu benutzerdefinierten Messwerten und ihren Einschränkungen, einschließlich der Einschränkungen im Zusammenhang mit Balancing-Modi, finden Sie unter Benutzerdefinierte Messwerte für Cloud Load Balancing.

  • balancingMode: CUSTOM_METRICS

    • Wenn Sie Traffic anhand eines benutzerdefinierten Messwerts verteilen möchten, muss für mindestens einen benutzerdefinierten Messwert in der Liste customMetrics dryRun auf false gesetzt sein. Mit dieser Einstellung wird der Load Balancer angewiesen, diesen Messwert aktiv für Entscheidungen zur Neugewichtung zu verwenden.
    • Sie können neben Messwerten, die sich nicht im Probelauf befinden, auch andere benutzerdefinierte Messwerte mit dryRun: true einfügen. So können Sie neue Messwerte wie die GPU-Auslastung testen oder beobachten, ohne dass sie sich auf den Traffic auswirken, während ein anderer Messwert wie die CPU-Auslastung mit dryRun: false das Balancing steuert.
    • Wenn balancingMode gleich CUSTOM_METRICS ist und für alle benutzerdefinierten Messwerte dryRun auf true festgelegt ist, wird ein Fehler ausgegeben. Beispiel: gceSync: generic::invalid_argument: Update: Invalid value for field 'resource.backends[0]': '...'. CUSTOM_METRICS BalancingMode requires at least one non-dry-run custom metric. Der Load Balancer benötigt eine aktive Messwert, um Entscheidungen zu treffen.

  • balancingMode ist RATE oder ein anderer Modus, der nicht auf benutzerdefinierten Messwerten basiert

    • Wenn das Load-Balancing auf anderen Kriterien als benutzerdefinierten Messwerten basiert, z. B. RATE für Anfragen pro Sekunde, können Sie dryRun: true für alle benutzerdefinierten Messwerte festlegen. So können Sie benutzerdefinierte Messwerte im Blick behalten, ohne den primären Ausgleichsmechanismus zu beeinträchtigen. Das ist nützlich, um neue benutzerdefinierte Messwerte zu testen, bevor Sie von balancingMode zu CUSTOM_METRICS wechseln.

  • Benutzerdefinierte Messwerte überwachen

    • Nachdem Sie GCPBackendPolicy konfiguriert und mit dem Senden von Traffic an Ihre Anwendung begonnen haben, dauert es einige Zeit, bis die benutzerdefinierten Messwerte wie gke.cpu im Metrics Explorer angezeigt werden.
    • Damit benutzerdefinierte Messwerte im Metrics Explorer sichtbar und aktiv sind, muss tatsächlicher Traffic über das Backend fließen, das von der Richtlinie überwacht wird. Wenn kein Traffic vorhanden ist, ist der Messwert im Metrics Explorer möglicherweise nur unter „Inaktive Ressourcen“ sichtbar.

Benutzerdefinierten Schwellenwert für die CPU-Auslastung festlegen

Standardmäßig leitet GKE Traffic von Back-Ends weg, deren CPU-Auslastung 80% überschreitet. Bestimmte Arbeitslasten können jedoch eine höhere oder niedrigere CPU-Auslastung tolerieren, bevor eine Umverteilung des Traffics erforderlich ist. Sie können diesen Grenzwert mit dem Feld maxUtilizationPercent in der GCPBackendPolicy-Ressource anpassen.

  1. Wenn Sie einen GKE-Dienst so konfigurieren möchten, dass Backends bis zu 70% der CPU nutzen können, bevor ein Lastenausgleich ausgelöst wird, speichern Sie das folgende Beispielmanifest als my-backend-policy.yaml:

    kind: GCPBackendPolicy
apiVersion: networking.gke.io/v1
metadata:
  name: my-backend-policy
  namespace: team-awesome
spec:
  targetRef:
    group: ""
    kind: Service
    name: super-service
  default:
    balancingMode: CUSTOM_METRICS
    customMetrics:
    - name: gke.cpu
      maxUtilizationPercent: 70

    Wichtige Hinweise:

    • Das Feld maxUtilizationPercent akzeptiert Werte von 0 bis 100. Ein Wert von 100 bedeutet, dass ein Backend seine volle CPU-Kapazität nutzen kann, bevor der Traffic neu verteilt wird.
    • Verwenden Sie für latenzempfindliche Arbeitslasten, die ein frühes Offloading erfordern, einen niedrigeren Schwellenwert.
    • Verwenden Sie für Arbeitslasten, die nahe der vollen Kapazität ausgeführt werden sollen, einen höheren Schwellenwert.
    • Bei Multi-Cluster-Diensten muss der spec.targetRef.kind ServiceImport sein und der Wert des Felds group muss auf net.gke.io festgelegt werden.

  2. Wenden Sie das Beispielmanifest auf Ihren Cluster an:

    kubectl apply -f my-backend-policy.yaml

Wenn Sie einen benutzerdefinierten Schwellenwert für die CPU-Auslastung aktivieren, können Sie die Trafficverteilung basierend auf der CPU-Auslastung des Back-Ends steuern.

(Optional) Probelaufmodus aktivieren

Im Probelaufmodus wird die Ressourcennutzung Ihrer Pods überwacht, ohne die Traffic-Verteilung zu ändern. Wenn der Probelaufmodus aktiviert ist, werden die Messwerte in Cloud Monitoring exportiert. Cloud Load Balancing ignoriert diese Messwerte jedoch und verwendet das Standardverhalten für das Load-Balancing.

  1. Wenn Sie den Probelaufmodus für Ihren GKE-Dienst aktivieren möchten, speichern Sie das folgende Beispielmanifest als my-backend-policy.yaml:

    kind: GCPBackendPolicy
apiVersion: networking.gke.io/v1
metadata:
  name: my-backend-policy
spec:
  targetRef:
    group: ""
    kind: Service
    name: store-v1
  default:
    balancingMode: RATE
    maxRatePerEndpoint: 10
    customMetrics:
    - name: gke.cpu
      dryRun: true

  2. Wenden Sie das Beispielmanifest auf Ihren Cluster an:

    kubectl apply -f my-backend-policy.yaml

Wenn Sie den Probelaufmodus aktivieren, geschieht Folgendes:

  • Cloud Load Balancing ignoriert CPU-Auslastungsmesswerte und verwendet stattdessen das Standardverhalten für das Load Balancing.

  • Messwerte werden weiterhin unter network.googleapis.com/loadbalancer/backend/lb_custom_metric in Cloud Monitoring exportiert.

Entfernen Sie nach der Überprüfung der Messwerte das Feld dryRun aus GCPBackendPolicy und wenden Sie die Konfiguration noch einmal an. Wenn nach dem Deaktivieren des Probelaufs Probleme auftreten, aktivieren Sie ihn wieder, indem Sie dryRun: true in die Richtlinie einfügen.

Richtlinie prüfen

Führen Sie den folgenden Befehl aus, um zu prüfen, ob GCPBackendPolicy auf Ihren GKE-Dienst angewendet wurde und ob die GKE-Controller die Richtlinie erkennen:

kubectl describe gcpbackendpolicy POLICY_NAME -n NAMESPACE

Die Ausgabe sieht etwa so aus:

Name:         <your policy name>
Namespace:    <your namespace>
Labels:       <none>
Annotations:  <none>
API Version:  networking.gke.io/v1
Kind:         GCPBackendPolicy
Metadata:
  Creation Timestamp:  ...
  Generation:          1
  Resource Version:    …
  UID:                 …
Spec:
  Default:
    Balancing Mode:  CUSTOM_METRICS
    Custom Metrics:
      Dry Run:  false
      Name:     gke.cpu
  Target Ref:
    Group:
    Kind:   Service
    Name:   super-service
Status:
  Conditions:
    Last Transition Time:  …
    Message:
    Reason:                Attached
    Status:                True
    Type:                  Attached
Events:
…

Auslastungsbasiertes Load Balancing mit Compute Engine APIs konfigurieren

Wir empfehlen, die Kubernetes Gateway API zu verwenden, um das nutzungsbasierte Load-Balancing für Ihre GKE-Dienste zu konfigurieren.

Möglicherweise möchten Sie jedoch Compute Engine APIs oder Terraform verwenden, um Ihre Load Balancer direkt zu verwalten. Wenn Sie diesen Ansatz wählen, müssen Sie das nutzungsbasierte Load-Balancing auf BackendService-Ebene aktivieren.

  1. Aktivieren Sie für einen vorhandenen BackendService das nutzungsbasierte Load-Balancing und hängen Sie eine Netzwerk-Endpunktgruppe (NEG) an, my-lb-neg, indem Sie den folgenden Befehl ausführen:

    gcloud compute backend-services add-backend MY_BACKEND_SERVICE \
  --network-endpoint-group my-lb-neg \
  --network-endpoint-group-zone=asia-southeast1-a \
  --global \
  --balancing-mode=CUSTOM_METRICS \
  --custom-metrics 'name="gke.cpu",maxUtilization=0.8'

    ersetzen Sie Folgendes:

    • MY_BACKEND_SERVICE durch den Namen Ihres BackendService.
    • CUSTOM_METRICS mit CUSTOM_METRICS.

  2. Führen Sie den folgenden Befehl aus, um die einrichtungsbasierte Load-Balancing-Konfiguration für einen vorhandenen Back-End-Eintrag in Ihrem BackendService zu aktualisieren, an den bereits eine NEG angehängt ist:

    gcloud compute backend-services update-backend MY_BACKEND_SERVICE \
  --network-endpoint-group my-lb-neg \
  --network-endpoint-group-zone=asia-southeast1-a \
  --global \
  --balancing-mode=CUSTOM_METRICS \
  --custom-metrics 'name="gke.cpu",maxUtilization=0.8'

    Ersetzen Sie Folgendes:

    • MY_BACKEND_SERVICE durch den Namen Ihres BackendService.
    • CUSTOM_METRICS mit CUSTOM_METRICS.

Auslastungsbasiertes Load-Balancing für einen GKE-Dienst deaktivieren

So deaktivieren Sie das nutzungsbasierte Load-Balancing für Ihre GKE-Dienste:

  1. Wenn Sie die Richtlinie für andere Einstellungen beibehalten möchten, entfernen Sie die Felder balancingMode und customMetrics aus Ihrer GCPBackendPolicy.
  2. Wenn Sie GCPBackendPolicy nicht mehr benötigen, können Sie es löschen.
  3. Wenn Sie Compute Engine APIs verwenden, ändern Sie die Flags --balancing-mode und --custom-metrics in Ihrem Backend-Dienst wieder.

Nächste Schritte