Diese Seite wurde von der Cloud Translation API übersetzt.

Backend-Dienst-basierten externen Load-Balancer bereitstellen

Autopilot Standard

Auf dieser Seite erfahren Sie, wie Sie einen externen LoadBalancer-Dienst bereitstellen, der einen Backend-Dienst-basierten externen Passthrough-Network-Load-Balancer erstellt. Bevor Sie diese Seite lesen, sollten Sie mit folgenden Themen vertraut sein:

Weitere Informationen zu externen Passthrough-Network Load Balancern finden Sie unter Backend-Dienst-basierter externer Passthrough-Network Load Balancer.

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 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 gcloud components update ab.
Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI die compute/region- und compute/zone-Attribute fest. Durch das Festlegen von Standardspeicherorten können Sie in der gcloud CLI Fehler wie One of [--zone, --region] must be supplied: Please specify location vermeiden.

Voraussetzungen

Wenn Sie einen externen LoadBalancer-Dienst erstellen möchten, muss in Ihrem GKE-Cluster Version 1.25.5 oder höher verwendet werden. Um das gewichtete Load Balancing zu verwenden, muss in Ihrem Cluster Version 1.31.0-gke.1506000 oder höher ausgeführt werden.
Das HttpLoadBalancing-Add-on muss in Ihrem Cluster aktiviert sein. Dieses Add-on ist standardmäßig aktiviert. Der Cluster kann dann Load-Balancer verwalten, die Backend-Dienste verwenden.

Cluster auswählen

Sie können einen neuen Cluster erstellen oder einen vorhandenen Cluster auswählen, der die Anforderungen erfüllt.

Neuen Cluster erstellen

Autopilot

So erstellen Sie einen neuen Autopilot-Cluster:

gcloud container clusters create-auto CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Ersetzen Sie Folgendes:

CLUSTER_NAME ist der Name des neuen Clusters.
RELEASE_CHANNEL: der Name der GKE-Release-Version für den Cluster.
VERSION: die GKE-Version für den Cluster.
COMPUTE_LOCATION: die Compute Engine-Region des Clusters.

Standard

So erstellen Sie einen neuen Standardcluster:

gcloud container clusters create CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Ersetzen Sie Folgendes:

CLUSTER_NAME ist der Name des neuen Clusters.
RELEASE_CHANNEL: der Name der GKE-Release-Version für den Cluster.
VERSION: die GKE-Version für den Cluster.
COMPUTE_LOCATION: die Compute Engine-Region des Clusters.

Vorhandenen Cluster aktualisieren

Aktualisieren Sie einen vorhandenen Cluster mit der gcloud CLI:

gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION

Ersetzen Sie Folgendes:

CLUSTER_NAME den Namen des vorhandenen Clusters.
VERSION: Die GKE-Version, auf die Sie Ihren Cluster aktualisieren möchten. Weitere Informationen finden Sie unter Manuelles Upgrade der Steuerungsebene.
COMPUTE_LOCATION: die Compute Engine-Region des Clusters.

Beispielarbeitslast bereitstellen

Stellen Sie die folgende Beispielarbeitslast bereit, die die Bereitstellungs-Pods für den externen LoadBalancer-Dienst bereitstellt.

Speichern Sie das folgende Beispiel-Deployment als store-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: store
spec:
  replicas: 20
  selector:
    matchLabels:
      app: store
  template:
    metadata:
      labels:
        app: store
    spec:
      containers:
      - image: gcr.io/google_containers/echoserver:1.10
        imagePullPolicy: Always
        name: echoserver
        ports:
          - name: http
            containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP

Wenden Sie das Manifest auf den Cluster an:
```
kubectl apply -f store-deployment.yaml
```

Prüfen Sie, ob für das Deployment 20 Bereitstellungs-Pods vorhanden sind:

kubectl get pods

Die Ausgabe sieht in etwa so aus:

NAME                     READY   STATUS    RESTARTS   AGE
store-cdb9bb4d6-s25vw      1/1     Running   0          10s
store-cdb9bb4d6-vck6s      1/1     Running   0          10s
....

Externen LoadBalancer-Dienst erstellen

Stellen Sie die Beispielarbeitslast bereit, indem Sie einen externen LoadBalancer-Dienst erstellen.

Speichern Sie das folgende Dienstmanifest als store-v1-lb-svc.yaml:

apiVersion: v1
kind: Service
metadata:
  name: store-v1-lb-svc
  annotations:
    cloud.google.com/l4-rbs: "enabled"
spec:
  type: LoadBalancer
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080

Wenden Sie das Manifest auf den Cluster an:
```
kubectl apply -f store-v1-lb-svc.yaml
```

Beachten Sie Folgendes zu diesem Beispielmanifest:

Das Dienstmanifest muss die cloud.google.com/l4-rbs: "enabled"-Anmerkung enthalten, wenn das Manifest zum ersten Mal auf den Cluster angewendet wird. Dadurch wird GKE angewiesen, einen Backend-Dienst-basierten externen Passthrough-Network Load Balancer zu erstellen. Backend-Dienst-basierte externe Passthrough-Network Load Balancer sind erforderlich, um Funktionen wie IPv6 und gewichtetes Load Balancing zu unterstützen.
Wenn Sie die Annotation cloud.google.com/l4-rbs: "enabled" dem Manifest eines vorhandenen externen LoadBalancer-Dienstes hinzufügen, also nach dem Erstellen des Load Balancers, wird sie von GKE ignoriert. Für externe LoadBalancer-Dienste, die ohne diese Anmerkung in ihren Manifesten erstellt wurden, werden zielpoolbasierte externe Passthrough-Network Load Balancer verwendet. Die Verwendung von zielpoolbasierten externen Passthrough-Network Load Balancern wird nicht empfohlen.

Gewichtetes Load Balancing aktivieren

Wenn Sie neue Verbindungen proportional auf die Knoten verteilen möchten, je nachdem, wie viele Pods auf jedem Knoten bereitgestellt, bereit und nicht beendet werden, aktivieren Sie das gewichtete Load Balancing, indem Sie dem Dienstmanifest die Anmerkung networking.gke.io/weighted-load-balancing: "pods-per-node" hinzufügen.

Fügen Sie dem Dienstmanifest store-v1-lb-svc.yaml die Anmerkung networking.gke.io/weighted-load-balancing: "pods-per-node" hinzu und achten Sie darauf, dass auch externalTrafficPolicy: Local so festgelegt ist:

apiVersion: v1
kind: Service
metadata:
  name: store-v1-lb-svc
  annotations:
    cloud.google.com/l4-rbs: "enabled"
    networking.gke.io/weighted-load-balancing: "pods-per-node"
spec:
  type: LoadBalancer
  externalTrafficPolicy: Local
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080

Wenden Sie das Manifest auf den Cluster an:
```
kubectl apply -f store-v1-lb-svc.yaml
```

Beachten Sie Folgendes zu diesem Beispiel für das gewichtete Load Balancing:

Im Service-Manifest wird externalTrafficPolicy: Local verwendet. Wenn Sie das gewichtete Load Balancing nicht aktivieren müssen, können Sie auch externalTrafficPolicy: Cluster verwenden. Weitere Informationen dazu, wie die externalTrafficPolicy die Knotengruppierung definiert, welche Knoten die Load Balancer-Systemdiagnosen bestehen und wie Pakete verarbeitet werden, finden Sie unter LoadBalancer-Dienstkonzepte.
Wenn Sie das gewichtete Load Balancing aktivieren, können Sie externalTrafficPolicy: Cluster in GKE verwenden. externalTrafficPolicy: Cluster deaktiviert das gewichtete Load Balancing jedoch effektiv, da das Paket nach dem Load Balancer an einen anderen Knoten weitergeleitet werden kann.

Mit kubectl edit svc service-name können Sie auch das gewichtete Load Balancing für einen vorhandenen externen LoadBalancer-Dienst aktivieren. Mit dem Befehl kubectl edit wird das Dienstmanifest des vorhandenen Load Balancers in Ihrem konfigurierten Texteditor geöffnet. Dort können Sie das Manifest ändern und die Änderungen speichern. Beachten Sie beim Bearbeiten eines vorhandenen externen LoadBalancer-Dienstes Folgendes:

Der vorhandene externe LoadBalancer-Dienst muss zur Erstellung eines Backend-Dienst-basierten externen Passthrough-Network Load Balancers geführt haben. Das bedeutet, dass der vorhandene externe LoadBalancer-Dienst die Annotation cloud.google.com/l4-rbs: "enabled" enthalten muss, wenn das Manifest zum ersten Mal auf den Cluster angewendet wurde.

Wenn Sie die Anmerkung networking.gke.io/weighted-load-balancing: "pods-per-node" einem vorhandenen externen LoadBalancer-Dienst hinzufügen, der einen zielpoolbasierten externen Passthrough-Network Load Balancer verwendet, hat das keine Auswirkungen.
Achten Sie beim Aktualisieren des vorhandenen Manifests für externe LoadBalancer-Dienste darauf, externalTrafficPolicy: Local festzulegen. Wenn Sie externalTrafficPolicy: Cluster verwenden, wird das gewichtete Load Balancing effektiv deaktiviert, da das Paket nach dem Load Balancer an einen anderen Knoten weitergeleitet werden kann.

Gewichtetes Load Balancing deaktivieren

Wenn Sie neue Verbindungen unabhängig davon auf Knoten verteilen möchten, wie viele Bereitstellungs-Pods auf jedem Knoten vorhanden sind, deaktivieren Sie das gewichtete Load Balancing, indem Sie die Anmerkung networking.gke.io/weighted-load-balancing: "pods-per-node" aus dem Dienstmanifest entfernen.

Externen LoadBalancer-Dienst und seine Komponenten überprüfen

Prüfen Sie, ob Ihr Dienst ausgeführt wird:
```
kubectl get svc store-v1-lb-svc
```
Die Ausgabe sieht in etwa so aus:
```
NAME               TYPE           CLUSTER-IP        EXTERNAL-IP     PORT(S)          AGE
store-v1-lb-svc   LoadBalancer   10.44.196.160     35.193.28.231   8080:32466/TCP   11m
```
GKE hat EXTERNAL_IP für den externen Passthrough-Network-Load-Balancer zugewiesen.

Hinweis: Es kann einige Minuten dauern, bis GKE eine externe IP-Adresse zugewiesen hat, bevor der Load Balancer für die Bereitstellung Ihrer Anwendung bereit ist.

Testen Sie die Verbindung zum Load-Balancer:

curl EXTERNAL_IP:PORT

Ersetzen Sie Folgendes:

EXTERNAL_IP: die zugewiesene IP-Adresse für den externen Passthrough-Network-Load-Balancer.
PORT: die zugewiesene Portnummer für den externen Passthrough-Network-Load-Balancer.

Die Ausgabe sieht in etwa so aus:

Hostname: store-v1-lb-svc-cdb9bb4d6-hflxd

Pod Information:
  -no pod information available-

Server values:
  server_version=nginx: 1.13.3 - lua: 10008

Request Information:
  client_address=10.128.0.50
  method=GET
  real path=/
  query=
  request_version=1.1
  request_scheme=http
  request_uri=EXTERNAL_IP

Request Headers:
  accept=*/*
  host=EXTERNAL_IP
  user-agent=curl/7.81.0

Request Body:
  -no body in request-

Prüfen Sie den LoadBalancer-Dienst und die Anmerkungen zu den zugehörigenGoogle Cloud -Ressourcen:
```
kubectl describe svc store-v1-lb-svc
```
Die Ausgabe sieht in etwa so aus:
```
Name:                     my-service-external
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/l4-rbs: enabled
                          networking.gke.io/weighted-load-balancing: pods-per-node #This annotation appears in the output only if weighted load balancing is enabled.
                          service.kubernetes.io/backend-service: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/firewall-rule: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/firewall-rule-for-hc: k8s2-qvveq1d8-default-my-service-ext-5s55db85-fw
                          service.kubernetes.io/healthcheck: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/tcp-forwarding-rule: a808124abf8ce406ca51ab3d4e7d0b7d
Selector:                 app=my-app
Type:                     LoadBalancer
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.18.102.23
IPs:                      10.18.102.23
LoadBalancer Ingress:     35.184.160.229
Port:                     tcp-port  8080/TCP
TargetPort:               8080/TCP
NodePort:                 tcp-port  31864/TCP
Endpoints:                10.20.1.28:8080,10.20.1.29:8080
Session Affinity:         None
External Traffic Policy:  Local
HealthCheck NodePort:     30394

Events:
  Type    Reason                Age                    From                     Message
  ----    ------                ----                   ----                     -------
  Normal  ADD                   4m55s                  loadbalancer-controller  default/my-service-ext
```
Es gibt mehrere Felder, die angeben, dass ein Backend-Dienst-basierter externer Passthrough-Network Load Balancer und seine Google Cloud -Ressourcen erfolgreich erstellt wurden:
- Events-Feld. Dieses Feld ist leer, wenn der LoadBalancer-Dienst und seine Ressourcen erfolgreich erstellt wurden. Ein Fehler ist hier aufgeführt.
- Liste der aktivierten Annotations: GKE fügt dem Dienstmanifest die folgende Liste der schreibgeschützten Anmerkungen hinzu. Jede Anmerkung, deren Name mit service.kubernetes.io/ beginnt, gibt den Namen einerGoogle Cloud -Ressource an, die im Rahmen des Load Balancers oder zur Unterstützung des Load Balancers erstellt wurde.
  - Die Anmerkung networking.gke.io/weighted-load-balancing: pods-per-node gibt an, dass gewichtetes Load Balancing angewendet wurde und der Load Balancer den Traffic an Back-End-Pods verteilt, basierend auf der Anzahl der Pods, die auf jedem Knoten ausgeführt werden.
  - Die Annotation service.kubernetes.io/backend-service gibt den Namen des Backend-Dienstes des Load Balancers an.
  - Die Annotation service.kubernetes.io/healthcheck gibt den Namen der Load-Balancer-Systemdiagnose an, die vom Backend-Dienst verwendet wird.
  - Die Anmerkung service.kubernetes.io/tcp-forwarding-rule oder service.kubernetes.io/udp-forwarding-rule gibt den Namen der Weiterleitungsregel des Load Balancers an.
  - Die Anmerkung service.kubernetes.io/firewall-rule gibt den Namen der Firewallregel an, die Traffic zu den Clusterknoten zulässt. Quellbereiche für diese Firewallregel können mit spec.loadBalancerSourceRanges[] angepasst werden. Weitere Informationen zu Firewallregeln für LoadBalancer-Dienste finden Sie unter Firewallregeln und Zulassungsliste für Quell-IP-Adressen.
  - Die Anmerkung service.kubernetes.io/firewall-rule-for-hc gibt den Namen der Firewallregel an, die für die Systemdiagnosen des Load Balancers erforderlich ist.
Prüfen Sie, ob Load Balancer-Ressourcen und Firewallregeln für den externen LoadBalancer-Dienst erstellt wurden:
- Führen Sie den folgenden Befehl aus, um die Weiterleitungsregel aufzurufen:
```
  gcloud compute forwarding-rules describe FWD_RULE_NAME \
    --region=REGION_NAME
```
  Ersetzen Sie Folgendes:
  - FWD_RULE_NAME: der Name der Weiterleitungsregel, der entweder von der schreibgeschützten Anmerkung service.kubernetes.io/tcp-forwarding-rule oder service.kubernetes.io/udp-forwarding-rule bereitgestellt wird. Führen Sie kubectl describe svc SERVICE_NAME aus, um diese Anmerkungen zu prüfen.
  - REGION_NAME: die Google Cloud -Region, in der sich der Cluster befindet. Bei zonalen Clustern enthält die Region die vom Cluster verwendete Zone.
- Führen Sie den folgenden Befehl aus, um den Backend-Dienst anzuzeigen:
```
gcloud compute backend-services describe BACKEND_SERVICE_NAME \
  --region=REGION_NAME
```
  Ersetzen Sie Folgendes:
  - BACKEND_SERVICE_NAME: der Name des Backend-Dienstes, der von der service.kubernetes.io/backend-service-Lesezugriffsanmerkung bereitgestellt wird. Um diese schreibgeschützte Annotation zu prüfen, führen Sie kubectl describe svc SERVICE_NAME aus.
  - REGION_NAME: die Google Cloud -Region, in der sich der Cluster befindet. Bei zonalen Clustern enthält die Region die vom Cluster verwendete Zone.
- Führen Sie den folgenden Befehl aus, um die Systemdiagnose des Load-Balancers anzeigen zu lassen:
```
gcloud compute health-checks describe HEALTH_CHECK_NAME \
  --region=REGION_NAME
```
  Ersetzen Sie Folgendes:
  - HEALTH_CHECK_NAME: der Name der Systemdiagnose des Load Balancers. Der Name der Systemdiagnose wird von der schreibgeschützten Annotation service.kubernetes.io/healthcheck bereitgestellt. Führen Sie kubectl describe svc SERVICE_NAME aus, um diese schreibgeschützte Anmerkung zu prüfen.
  - REGION_NAME: die Google Cloud -Region, in der sich der Cluster befindet. Bei zonalen Clustern enthält die Region die vom Cluster verwendete Zone.
- Führen Sie die folgenden Befehle aus, um die Firewall-Regeln anzeigen zu lassen:
```
gcloud compute firewall-rules describe FIREWALL_RULE_NAME \
gcloud compute firewall-rules describe HEALTH_CHECK_FIREWALL_RULE_NAME
```
  Ersetzen Sie Folgendes:
  - FIREWALL_RULE_NAME: der Name der Firewallregel, die Traffic zum Load Balancer zulässt. Der Name dieser Firewallregel wird von der schreibgeschützten Annotation service.kubernetes.io/firewall-rule bereitgestellt. Um diese schreibgeschützte Annotation zu prüfen, führen Sie kubectl describe svc SERVICE_NAME aus.
  - HEALTH_CHECK_FIREWALL_RULE_NAME: der Name der Firewallregel, die Systemdiagnosen der Backends des Load Balancers (Knoten des Clusters) zulässt. Der Name dieser Firewallregel wird von der schreibgeschützten Anmerkung service.kubernetes.io/firewall-rule-for-hc bereitgestellt. Führen Sie kubectl describe svc SERVICE_NAME aus, um diese schreibgeschützte Anmerkung zu prüfen.

Externen LoadBalancer-Dienst löschen

Führen Sie den folgenden Befehl aus, um den externen LoadBalancer-Dienst store-v1-lb-svc zu löschen:

kubectl delete service store-v1-lb-svc

GKE entfernt automatisch alle Load Balancer-Ressourcen, die für den externen LoadBalancer-Dienst erstellt wurden.

Fehlerbehebung für externen LoadBalancer-Dienst

Wenn Sie externalTrafficPolicy: Local nicht festlegen, erhalten Sie möglicherweise ein Warnereignis, wenn Sie den Dienst mit dem folgenden Befehl beschreiben:

kubectl describe svc store-v1-lb-svc`

Events:
  Type     Reason                   Age      From                     Message
  ----     ------                   ----     ----                     -------
  Warning  UnsupportedConfiguration 4m55s    loadbalancer-controller  Weighted load balancing by pods-per-node has no effect with External Traffic Policy: Cluster.

Um das gewichtete Load Balancing effektiv zu aktivieren, müssen Sie externalTrafficPolicy: Local festlegen.

Nächste Schritte

Eine allgemeine Übersicht über Load-Balancer-Dienste finden Sie unter LoadBalancer-Dienste.
Eine Beschreibung der Parameter für den Load-Balancer-Dienst finden Sie unter Parameter des LoadBalancer-Dienstes.
Fehlerbehebung beim Load-Balancing in GKE.