Auslastungsbasiertes Load-Balancing für GKE-Dienste konfigurieren

Auf dieser Seite wird beschrieben, wie Sie das nutzungsbasierte Load-Balancing 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 nutzungsbasierten Load-Balancern können Sie die Anwendungsleistung und -verfügbarkeit optimieren, indem Sie den Traffic intelligent auf Grundlage der Echtzeit-Ressourcennutzung Ihrer GKE-Pods verteilen.

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

Preise

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

Kontingente

Beim nutzungsbasierten 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, installieren und dann initialisieren Sie die gcloud CLI. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit dem gcloud components update Befehl ab. Ältere gcloud CLI-Versionen unterstützen möglicherweise nicht die Ausführung der Befehle in diesem Dokument.

Anforderungen für GKE Gateway Controller

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

Das nutzungsbasierte Load-Balancing für GKE-Dienste unterstützt Folgendes:

  • GKE-Dienste mit einem oder mehreren Clustern, die als Back-Ends 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 das nutzungsbasierte Load-Balancing für GKE-Dienste gelten die folgenden Einschränkungen.

  • Die unterstützten Messwerte zur Ressourcennutzung sind:
  • Passthrough- oder Proxy-Network Load Balancer werden nicht unterstützt.
  • Nur die Gateway API wird unterstützt. Die Service- und Ingress-APIs werden nicht unterstützt.
  • Das nutzungsbasierte Load-Balancing funktioniert nicht gut, wenn Ihr Traffic sehr unregelmäßig ist. Die Traffic-Neuausrichtung dauert bis zu 30 Sekunden, wenn Pods ihre maximale Auslastung erreichen. Das Auslastungssignal steigt mit dem eingehenden Traffic, aber diese Verzögerung bedeutet, dass das nutzungsbasierte Load-Balancing Zeit benötigt, um sich anzupassen. Für eine optimale Leistung funktioniert das nutzungsbasierte Load-Balancing am besten in Umgebungen mit gleichmäßigen, vorhersehbaren Traffic-Flüssen.
  • Es kann bis zu 30 Sekunden dauern, bis das nutzungsbasierte Load-Balancing die Traffic-Verteilung nach Konfigurationsänderungen aktualisiert und angepasst hat. Das gilt beispielsweise, wenn Sie das Feld `dryRun` in einer GCPBackendPolicy ändern oder entfernen. Diese Verzögerung ist ein bekanntes systemweites Verhalten. Daher eignet sich diese Funktion am besten für Anwendungen mit relativ stabilen Traffic-Mustern, die diese Aktualisierungslatenz tolerieren können.

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

Ziel der Konfiguration des nutzungsbasierten Load-Balancing 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.

Nutzungsbasiertes Load-Balancing und HPA-Leistungsprofil aktivieren

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

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

Gateway API und HPA-Leistungsprofil aktivieren

Autopilot

Die Gateway API und das HPA-Leistungsprofil sind in einem Autopilot-Cluster standardmäßig verfügbar.

Standard

Führen Sie den folgenden Befehl aus, um einen neuen Standardcluster mit aktiviertem HPA-Leistungsprofil 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:

  • 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 durch die GKE-Version, die 1.33.1-gke.1918000 oder höher sein muss.

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

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-Leistungsprofil finden Sie unter HPA-Leistungsprofil konfigurieren.

Nutzungsbasiertes Load-Balancing konfigurieren

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

Vorbereitung

Bevor Sie das nutzungsbasierte Load-Balancing mit der Gateway API konfigurieren, prüfen Sie, ob Ihr GKE-Cluster die folgenden Anforderungen erfüllt:

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

    Ein typisches Bereitstellungsmanifest enthält beispielsweise einen Ressourcenabschnitt wie diesen:

    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 verfügbar machen: Sie müssen die Anwendung mit einem Kubernetes-Dienst verfügbar machen. Weitere Informationen zur Funktionsweise von Diensten und zur Konfiguration finden Sie unter Kubernetes Dienste.

  3. Application Load Balancer auf Gateway API-Basis verwenden: Machen Sie den Dienst mit einem von GKE verwalteten Application Load Balancer verfügbar, der über die Gateway API konfiguriert ist. Weitere Informationen finden Sie unter Gateways bereitstellen.

GCPBackendPolicy für CPU-basiertes Load-Balancing erstellen

Mit dieser Konfiguration kann GKE den Traffic dynamisch auf Grundlage der Echtzeit-CPU-Auslastung jedes Backend-Pods verteilen.

Wenn Sie das nutzungsbasierte Load-Balancing 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. Wenn Sie Messwerte zur CPU-Auslastung angeben, steuern Sie, wie der Traffic basierend auf der aktuellen Ressourcennutzung auf die Back-Ends 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: Ziel ist ein Standard-Kubernetes-Dienst im selben Cluster.
    • spec.targetRef.kind: ServiceImport: Ziel ist ein Dienst aus einem anderen Cluster in einer Multi-Cluster-Einrichtung. Bei Multi-Cluster-Diensten muss der Wert des Felds group auf net.gke.io gesetzt sein.
    • balancingMode: CUSTOM_METRICS: Aktiviert das Load-Balancing auf Grundlage benutzerdefinierter Messwerte.
    • 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 Standardgrenzwert für die Auslastung 80%. Der Traffic wird neu ausgerichtet, wenn die CPU-Auslastung eines Back-Ends 80% übersteigt.

  2. Wenden Sie das Beispielmanifest auf Ihren Cluster an:

    kubectl apply -f my-backend-policy.yaml

Wenn Sie die Traffic-Verteilung auf der Echtzeit-CPU-Auslastung basieren, optimieren Sie die Leistung automatisch. So können Sie eine Überlastung einzelner Pods verhindern.

Wichtige Hinweise zu dryRun und balancingMode

Wenn Sie GCPBackendPolicy mit benutzerdefinierten Messwerten konfigurieren, beachten Sie die Interaktion zwischen balancingMode und dem Feld dryRun in Ihrer customMetrics-Definition. 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 den Balancing-Modi, finden Sie unter Benutzerdefinierte Messwerte für Cloud Load Balancing.

  • balancingMode: CUSTOM_METRICS

    • Wenn Sie den Traffic auf Grundlage eines benutzerdefinierten Messwerts verteilen möchten, muss für mindestens einen benutzerdefinierten Messwert in der customMetrics Liste die Option dryRun auf false gesetzt sein. Mit dieser Einstellung wird der Load-Balancer angewiesen, diesen Messwert aktiv für Entscheidungen zur Neuausrichtung zu verwenden.
    • Sie können neben Messwerten ohne Probelauf auch andere benutzerdefinierte Messwerte mit dryRun: true einbeziehen. So können Sie neue Messwerte wie die GPU-Auslastung testen oder überwachen, ohne dass sie sich auf den Traffic auswirken. Ein anderer Messwert wie die CPU-Auslastung mit dryRun: false steuert das Balancing.
    • Wenn balancingMode auf CUSTOM_METRICS gesetzt ist und für alle benutzerdefinierten Messwerte dryRun auf true gesetzt ist, wird eine Fehlermeldung angezeigt. 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 einen aktiven Messwert, um Entscheidungen zu treffen.

  • balancingMode ist RATE oder ein anderer Modus ohne benutzerdefinierte Messwerte

    • 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 überwachen, ohne den primären Balancing-Mechanismus zu beeinträchtigen. Das ist nützlich, um neue benutzerdefinierte Messwerte zu testen, bevor Sie balancingMode auf CUSTOM_METRICS umstellen.

  • Benutzerdefinierte Messwerte überwachen

    • Nachdem Sie Ihre GCPBackendPolicy konfiguriert und Traffic an Ihre Anwendung gesendet 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ächlich Traffic durch das Backend fließen, das von der Richtlinie überwacht wird. Wenn kein Traffic vorhanden ist, ist der Messwert möglicherweise nur unter „Inaktive Ressourcen“ im Metrics Explorer sichtbar.

Benutzerdefinierten Grenzwert für die CPU-Auslastung festlegen

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

  1. Wenn Sie einen GKE-Dienst so konfigurieren möchten, dass Back-Ends bis zu 70% der CPU nutzen können, bevor eine Neuausrichtung 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 ausgerichtet wird.
    • Verwenden Sie für latenzempfindliche Arbeitslasten, die frühzeitig ausgelagert werden müssen, einen niedrigeren Grenzwert.
    • Verwenden Sie für Arbeitslasten, die mit nahezu voller Kapazität ausgeführt werden sollen, einen höheren Grenzwert.
    • Bei Multi-Cluster-Diensten muss spec.targetRef.kind auf ServiceImport gesetzt sein und der Wert des Felds group muss net.gke.io sein.

  2. Wenden Sie das Beispielmanifest auf Ihren Cluster an:

    kubectl apply -f my-backend-policy.yaml

Wenn Sie einen benutzerdefinierten Grenzwert für die CPU-Auslastung aktivieren, können Sie die Traffic-Verteilung 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 nach 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 Messwerte zur CPU-Auslastung und verwendet stattdessen das Standardverhalten für das Load-Balancing.

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

Nachdem Sie die Messwerte überprüft haben, entfernen Sie das Feld dryRun aus Ihrer 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 wieder zur Richtlinie hinzufügen.

Richtlinie überprüfen

Führen Sie den folgenden Befehl aus, um zu bestätigen, dass die GCPBackendPolicy auf Ihren GKE-Dienst angewendet wurde, und um zu prüfen, 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:
…

Nutzungsbasiertes 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 Ihre Load-Balancer jedoch lieber direkt mit Compute Engine APIs oder Terraform verwalten. Wenn Sie diesen Ansatz wählen, müssen Sie das nutzungsbasierte Load-Balancing auf BackendService-Ebene aktivieren.

  1. Führen Sie den folgenden Befehl aus, um das nutzungsbasierte Load-Balancing für einen vorhandenen BackendService zu aktivieren und eine Netzwerk-Endpunktgruppe (NEG) anzuhängen:

    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 durch CUSTOM_METRICS.

  2. Führen Sie den folgenden Befehl aus, um die Einstellungen für das nutzungsbasierte Load-Balancing für einen vorhandenen Backend-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 durch CUSTOM_METRICS.

Nutzungsbasiertes 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 sie löschen.
  3. Wenn Sie Compute Engine APIs verwenden, ändern Sie die Flags --balancing-mode und --custom-metrics für Ihren Backend-Dienst wieder.

Nächste Schritte