Externen Application Load Balancer mit Ingress einrichten

In dieser Anleitung erfahren Sie, wie Sie eine Webanwendung hinter einem externen Application Load Balancer durch Konfiguration der Ingress-Ressource ausführen.

Diese Seite richtet sich an Netzwerkexperten, die das Netzwerk für ihre Organisation entwerfen und einrichten sowie Netzwerkgeräte installieren, konfigurieren und unterstützen. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir in Google Cloud-Inhalten verweisen, finden Sie unter Häufig verwendete GKE Enterprise-Nutzerrollen und -Aufgaben.

Hintergrund

Google Kubernetes Engine (GKE) bietet integrierte Unterstützung für zwei Arten von Cloud Load Balancing für eine öffentlich zugängliche Anwendung:

  1. Eingehender Traffic

  2. Externer Passthrough Network Load Balancer

In dieser Anleitung verwenden Sie Ingress-Instanzen.

Eingehender Traffic

Wenn Sie kind: Ingress im Ressourcenmanifest angeben, wird GKE angewiesen, eine Ingress-Ressource zu erstellen. Durch Hinzufügen von Annotationen und Unterstützen von Arbeitslasten und Diensten können Sie einen benutzerdefinierten Ingress-Controller erstellen. Andernfalls führt GKE entsprechende Google Cloud API-Aufrufe aus, um einen externen Application Load Balancer zu erstellen. Die Hostregeln und Pfad-Matcher des Load-Balancers verweisen auf einen oder mehrere Backend-Dienste, wobei jeder Backend-Dienst einem GKE-Dienst vom Typ NodePort entspricht, auf den in Ingress verwiesen wird. Die Back-Ends für jeden Back-End-Dienst sind entweder Instanzgruppen oder Netzwerk-Endpunktgruppen (NEGs). NEGs werden erstellt, wenn Sie containernatives Load-Balancing als Teil der Ingress-Konfiguration konfigurieren. Für jeden Back-End-Dienst erstellt GKE eine Google Cloud-Systemdiagnose gemäß den Einstellungen für Bereitschaftsprüfungen der Arbeitslast, auf die der entsprechende GKE-Dienst verweist.

Für in GKE gehostete HTTP(S)-Dienste wird die Verwendung eines HTTP(S)-Load-Balancings empfohlen.

Ziele

  • Einen GKE-Cluster installieren
  • Beispielwebanwendung im Cluster bereitstellen
  • Die Beispielanwendung hinter einem externen Application Load Balancer im Internet verfügbar machen

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

Führen Sie folgende Schritte aus, um die Kubernetes Engine API zu aktivieren:
  1. Rufen Sie in der Google Cloud Console die Seite "Kubernetes Engine" auf.
  2. Erstellen Sie ein Projekt oder wählen Sie eines aus.
  3. Warten Sie, bis die API und die zugehörigen Dienste aktiviert worden sind. Dieser Vorgang kann einige Minuten dauern.

  4. Make sure that billing is enabled for your Google Cloud project.

Installieren Sie die folgenden Befehlszeilentools, die in dieser Anleitung verwendet werden:

  • Mit gcloud werden Kubernetes Engine-Cluster erstellt und gelöscht. gcloud ist in der gcloud CLI enthalten.
  • kubectl wird zur Verwaltung von Kubernetes verwendet, dem Cluster-Orchestrierungssystem von Kubernetes Engine. Sie können kubectl mit gcloud installieren: 
    gcloud components install kubectl

Klonen Sie den Beispielcode aus GitHub:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/networking/load-balancing

Standards für das gcloud-Befehlszeilentool festlegen

Wenn Sie die Projekt-ID und die Optionen für die Compute Engine-Zone nicht immer wieder neu in das gcloud-Befehlszeilentool eingeben möchten, können Sie die Standardwerte festlegen: 
gcloud config set project project-id
gcloud config set compute/zone compute-zone

GKE-Cluster erstellen

Erstellen Sie einen GKE Autopilot-Cluster:

gcloud container clusters create-auto loadbalancedcluster

Webanwendung bereitstellen

Das folgende Manifest beschreibt ein Deployment, mit dem das Container-Image der Beispielwebanwendung auf einem HTTP-Server an Port 8080 ausgeführt wird:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  namespace: default
spec:
  selector:
    matchLabels:
      run: web
  template:
    metadata:
      labels:
        run: web
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        imagePullPolicy: IfNotPresent
        name: web
        ports:
        - containerPort: 8080
          protocol: TCP

Wenden Sie die Ressource auf den Cluster an:

kubectl apply -f web-deployment.yaml

Deployment im Cluster verfügbar machen

Das folgende Manifest beschreibt einen Dienst, der das web-Deployment in Ihrem Container-Cluster zugänglich macht:

apiVersion: v1
kind: Service
metadata:
  name: web
  namespace: default
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    run: web
  type: NodePort

  1. Wenden Sie die Ressource auf den Cluster an:

    kubectl apply -f web-service.yaml

    Wenn Sie mit diesem Befehl einen Dienst vom Typ NodePort erstellen, stellt GKE diesen an einer zufällig ausgewählten Portnummer im hohen Bereich (z. B. 32640) auf allen Knoten in Ihrem Cluster zur Verfügung.

  2. Prüfen Sie, ob der Dienst erstellt und ein Knotenport zugewiesen wurde:

    kubectl get service web
    Ausgabe: 
    NAME      TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
web       NodePort   10.35.245.219   <none>        8080:32640/TCP   5m

    In der Beispielausgabe hat der web-Dienst den Knotenport 32640. Außerdem ist dem Dienst keine externe IP-Adresse zugewiesen. GKE-Knoten sind standardmäßig nach außen hin abgeschottet. Ihre Anwendung ist auch mit diesem Dienst nicht über das Internet zugänglich.

Damit Ihre HTTP(S)-Webserveranwendung öffentlich zugänglich ist, müssen Sie eine Ingress-Ressource erstellen.

Ingress-Ressource erstellen

Ingress ist eine Kubernetes-Ressource, die eine Sammlung von Regeln und die Konfiguration für die Weiterleitung von externem HTTP(S)-Traffic an interne Dienste beinhaltet.

Auf GKE ist Ingress über das Cloud-Load-Balancing implementiert. Wenn Sie eine Ingress-Ressource im Cluster anlegen, erstellt GKE einen HTTP(S)-Load-Balancer und konfiguriert ihn so, dass Traffic an die Anwendung weitergeleitet wird.

Das folgende Manifest beschreibt eine Ingress-Ressource, die Traffic an Ihren web-Dienst weiterleitet:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: basic-ingress
spec:
  defaultBackend:
    service:
      name: web
      port:
        number: 8080

Wenden Sie die Ressource auf den Cluster an:

kubectl apply -f basic-ingress.yaml

Nach der Bereitstellung dieses Manifests erstellt Kubernetes eine Ingress-Ressource auf dem Cluster. Der GKE-Ingress-Controller erstellt und konfiguriert einen HTTP(S)-Load-Balancer entsprechend den Informationen im Ingress-Objekt und leitet den gesamten externen HTTP-Traffic (auf Port 80) an den von Ihnen freigegebenen web-NodePort-Service weiter.

Anwendung aufrufen

Mit dem folgenden Befehl ermitteln Sie die externe IP-Adresse des Lastenausgleichsmoduls, das für Ihre Anwendung zuständig ist:

kubectl get ingress basic-ingress
Ausgabe: 
NAME            HOSTS     ADDRESS         PORTS     AGE
basic-ingress   *         203.0.113.12    80        2m

Öffnen Sie die externe IP-Adresse der Anwendung in einem Browser und sehen Sie eine HTTP-Antwort im Klartext wie die folgende:

Hello, world!
Version: 1.0.0
Hostname: web-6498765b79-fq5q5

In der Google Cloud Console können Sie unter Load-Balancing die vom GKE Ingress-Controller erstellten Netzwerkressourcen prüfen.

(Optional) Statische IP-Adresse konfigurieren

Wenn Sie einen Webserver über einen Domainnamen freigeben, muss die externe IP-Adresse der Anwendung statisch, also unveränderlich sein.

Standardmäßig weist GKE über einen Ingress freigegebenen HTTP-Anwendungen sitzungsspezifische externe IP-Adressen zu. Sitzungsspezifische Adressen können sich ändern. Wenn Sie Ihre Anwendung über einen längeren Zeitraum ausführen möchten, müssen Sie eine statische externe IP-Adresse verwenden.

Beachten Sie, dass nach dem Konfigurieren einer statischen IP-Adresse durch das Löschen der Ingress-Ressource die statische IP-Adresse, die mit ihr verknüpft ist, nicht gelöscht wird. Achten Sie daher immer darauf, nicht mehr benötigte statische IP-Adressen zu löschen.

Um eine statische IP-Adresse zu konfigurieren, führen Sie die folgenden Schritte aus:

  1. Reservieren Sie eine statische externe IP-Adresse namens web-static-ip:

    gcloud

    gcloud compute addresses create web-static-ip --global

    Config Connector

    Hinweis: Für diesen Schritt ist Config Connector erforderlich. Folgen Sie der Installationsanleitung, um Config Connector in Ihrem Cluster zu installieren.

    apiVersion: compute.cnrm.cloud.google.com/v1beta1
kind: ComputeAddress
metadata:
  name: web-static-ip
spec:
  location: global
    Laden Sie dieses Manifest zur Bereitstellung als Datei compute-address.yaml auf Ihren Computer herunter und führen Sie folgenden Befehl aus: 
    kubectl apply -f compute-address.yaml

  2. Das Manifest basic-ingress-static.yaml fügt der Ingress-Ressource eine Annotation hinzu, um die statische IP-Ressource namens web-static-ip zu verwenden:

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: basic-ingress
  annotations:
    kubernetes.io/ingress.global-static-ip-name: "web-static-ip"
spec:
  defaultBackend:
    service:
      name: web
      port:
        number: 8080

    Rufen Sie die Anzeige des Manifests auf:

    cat basic-ingress-static.yaml

  3. Wenden Sie die Ressource auf den Cluster an:

    kubectl apply -f basic-ingress-static.yaml

  4. Prüfen Sie die externe IP-Adresse:

    kubectl get ingress basic-ingress

    Warten Sie, bis die IP-Adresse Ihrer Anwendung die reservierte IP-Adresse der Ressource web-static-ip verwendet.

    Es kann einige Minuten dauern, bis die vorhandene Ingress-Ressource aktualisiert, der Load-Balancer neu konfiguriert und die neuen Load-Balancing-Regeln weltweit übertragen wurden. Nach Abschluss dieses Vorgangs gibt GKE die der Anwendung zuvor zugeteilte sitzungsspezifische IP-Adresse frei.

(Optional) Mehrere Anwendungen auf einem Load-Balancer bereitstellen

Auf einem Load-Balancer mit öffentlicher IP-Adresse können mehrere Dienste ausgeführt werden. Dazu müssen Sie in Ingress Weiterleitungsregeln konfigurieren. Wenn Sie mehrere Dienste auf einer Ingress-Ressource hosten, müssen Sie nicht für jeden im Internet veröffentlichten Dienst einen zusätzlichen Load-Balancer erstellen. Dadurch sparen Sie dafür anfallende Kosten.

Das folgende Manifest beschreibt ein Deployment mit der Version 2.0 derselben Webanwendung:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web2
  namespace: default
spec:
  selector:
    matchLabels:
      run: web2
  template:
    metadata:
      labels:
        run: web2
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
        imagePullPolicy: IfNotPresent
        name: web2
        ports:
        - containerPort: 8080
          protocol: TCP

Wenden Sie die Ressource auf den Cluster an:

kubectl apply -f web-deployment-v2.yaml

Das folgende Manifest beschreibt einen Dienst, der web2 intern für den Cluster in einem NodePort-Dienst namens web2 verfügbar macht:

apiVersion: v1
kind: Service
metadata:
  name: web2
  namespace: default
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    run: web2
  type: NodePort

Wenden Sie die Ressource auf den Cluster an:

kubectl apply -f web-service-v2.yaml

Das folgende Manifest beschreibt eine Ingress-Ressource, die

  • Sie leitet die Anfragen mit Pfaden, die mit /v2/ beginnen, an den web2-Dienst weiter.
  • Sie leitet alle anderen Anfragen an den web-Dienst weiter.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: fanout-ingress
spec:
  rules:
  - http:
      paths:
      - path: /*
        pathType: ImplementationSpecific
        backend:
          service:
            name: web
            port:
              number: 8080
      - path: /v2/*
        pathType: ImplementationSpecific
        backend:
          service:
            name: web2
            port:
              number: 8080

Wenden Sie die Ressource auf den Cluster an:

kubectl create -f fanout-ingress.yaml

Nachdem die Ingress-Ressource bereitgestellt wurde, führen Sie kubectl get ingress fanout-ingress aus, um die öffentliche IP-Adresse des Clusters zu ermitteln.

Rufen Sie dann die IP-Adresse auf, um zu prüfen, ob beide Anwendungen über den gleichen Load-Balancer erreichbar sind:

  • Rufen Sie http://<IP_ADDRESS>/ auf. Die Antwort enthält Version: 1.0.0, da die Anfrage an den web-Dienst weitergeleitet wird.
  • Rufen Sie http://<IP_ADDRESS>/v2/ auf. Die Antwort enthält Antwort Version: 2.0.0, da an den web2-Dienst weitergeleitet wird.

Das einzige unterstützte Platzhalterzeichen für das Feld path eines Ingress ist das Zeichen *. Das Zeichen * muss auf einen Schrägstrich (/) folgen und das letzte Zeichen des Musters sein. Beispielsweise sind /*, /foo/* und /foo/bar/* gültige Muster, *, /foo/bar* und /foo/*/bar jedoch nicht.

Ein spezifischeres Muster hat Vorrang vor einem weniger spezifischen Muster. Wenn sowohl /foo/* als auch /foo/bar/* vorhanden sind, wird /foo/bar/bat für den Abgleich mit /foo/bar/* herangezogen.

Weitere Informationen zu Pfadeinschränkungen und zum Musterabgleich finden Sie in der Dokumentation zu URL-Zuordnungen.

(Optional) Verfügbarkeit und Latenz des Dienstes überwachen

Die Verfügbarkeitsdiagnosen von Google Cloud führen ein Blackbox-Monitoring von Anwendungen aus Sicht des Nutzers durch. Dabei werden die Latenz und die Verfügbarkeit von mehreren externen IP-Adressen für die IP-Adresse des Load-Balancers bestimmt. Im Vergleich dazu führen Google Cloud-Systemdiagnosen eine interne Prüfung der Pod-IPs durch, um die Verfügbarkeit auf Instanzebene zu ermitteln. Die Diagnosen ergänzen sich und bieten ein ganzheitliches Bild des Anwendungszustands.

Sie können eine Verfügbarkeitsdiagnose über die Google Cloud Console, die Cloud Monitoring API oder die Cloud Monitoring-Clientbibliotheken erstellen. Weitere Informationen finden Sie unter Verfügbarkeitsdiagnosen verwalten. So erstellen Sie eine Verfügbarkeitsdiagnose mithilfe der Google Cloud Console:

  1. Rufen Sie in der Google Cloud Console die Seite Dienste und Ingress auf.

    Zu "Dienste & Ingress"

  2. Klicken Sie auf den Namen des Dienstes, für den Sie eine Verfügbarkeitsdiagnose erstellen möchten.

  3. Klicken Sie auf Verfügbarkeitsdiagnose erstellen.

  4. Geben Sie im Bereich Verfügbarkeitsdiagnose erstellen einen Titel für die Verfügbarkeitsdiagnose ein und klicken Sie dann auf Weiter, um zu den Einstellungen für Ziel zu gelangen.

    Die Ziel-Felder der Verfügbarkeitsdiagnose werden automatisch mit den Informationen aus dem Dienst-Load-Balancer ausgefüllt.

    Eine vollständige Beschreibung aller Felder einer Verfügbarkeitsdiagnose finden Sie unter Verfügbarkeitsdiagnose erstellen.

  5. Klicken Sie auf Weiter, um zu den Einstellungen für die Antwortvalidierung zu gelangen.

  6. Klicken Sie auf Weiter, um zum Abschnitt Benachrichtigungen zu gelangen.

    Zur Überwachung einer Verfügbarkeitsdiagnose können Sie eine Benachrichtigungsrichtlinie erstellen oder das Dashboard für die Verfügbarkeitsdiagnose aufrufen. Eine Benachrichtigungsrichtlinie kann Sie per E-Mail oder über einen anderen Kanal benachrichtigen, wenn die Verfügbarkeitsdiagnose fehlschlägt. Allgemeine Informationen zu Benachrichtigungsrichtlinien finden Sie unter Einführung in Benachrichtigungen.

  7. Klicken Sie auf Erstellen.

Anmerkungen

Ingress führt standardmäßig eine regelmäßige Systemdiagnose durch. Dazu wird eine GET-Anfrage im Pfad / gesendet, um den Status der Anwendung zu ermitteln, und auf eine entsprechende HTTP 200-Antwort gewartet. Wenn Sie einen anderen Pfad prüfen möchten oder einen anderen Antwortcode erwarten, können Sie einen benutzerdefinierten Systemdiagnosepfad verwenden.

Ingress unterstützt auch komplexere Anwendungsfälle, zum Beispiel:

  • Namensbasiertes virtuelles Hosting: Mit Ingress können Sie den Load-Balancer für mehrere Domainnamen und Subdomains verwenden und unter derselben IP-Adresse und demselben Load-Balancer mehrere Dienste veröffentlichen. Prüfen Sie die Beispiele für ein einfaches Fanout und für ein namensbasiertes virtuelles Hosting. Diese enthalten Informationen zur Konfiguration von Ingress für diese Aufgaben.

  • HTTPS-Beendigung: Sie können Ingress so konfigurieren, dass HTTPS-Traffic über den Cloud-Load-Balancer beendet wird.

Wenn ein Ingress gelöscht wird, bereinigt der GKE Ingress-Controller die zugehörigen Ressourcen automatisch (ausgenommen reservierte statische IP-Adressen).

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

  1. Löschen Sie alle manuell erstellten Weiterleitungsregeln und Zielproxys, die auf den Ingress verweisen.

    Bei einem defekten Zielproxy, der auf eine vom GKE Ingress-Controller verwaltete URL-Zuordnung verweist, schlägt das Löschen des Ingress in GKE ab Version 1.15.4-gke.22 fehl. Prüfen Sie die Ingress-Ressource, um ein Ereignis mit einer Fehlermeldung zu finden, die in etwa so aussieht:

     Error during GC: error running load balancer garbage collection routine: googleapi: Error 400: The url_map resource 'projects/project-id/global/urlMaps/k8s2-um-tlw9rhgp-default-my-ingress-9ifnni82' is already being used by 'projects/project-id/global/targetHttpsProxies/k8s2-um-tlw9rhgp-default-my82-target-proxy', resourceInUseByAnotherResource

    In der obigen Fehlermeldung ist k8s2-um-tlw9rhgp-default-my82-target-proxy ein manuell erstellter Ziel-HTTPS-Proxy, der noch immer auf die von einem Ingress-Controller erstellte und verwaltete URL-Zuordnung k8s2-um-tlw9rhgp-default-my-ingress-9ifnni82 verweist.

    Diese manuell erstellten Frontend-Ressourcen (sowohl Weiterleitungsregel als auch Zielproxy) müssen gelöscht werden, bevor Ingress gelöscht werden kann.

  2. Löschen Sie Ingress: Mit diesem Schritt werden die sitzungsspezifische externe IP-Adresse und die der Anwendung zugeteilten Load-Balancing-Ressourcen freigegeben:

    kubectl delete ingress basic-ingress

    Wenn Sie den optionalen Schritt ausgeführt haben, um eine Ingress-Ressource zum Weiterleiten von Anfragen nach Pfad zu erstellen, dann löschen Sie die Ingress-Ressource:

    kubectl delete ingress fanout-ingress

  3. Löschen Sie die statische IP-Adresse: Führen Sie diesen Schritt nur aus, wenn Sie den optionalen Schritt zum Erstellen einer statischen IP-Adresse ausgeführt haben.

    • Wenn Sie „Option 1“ ausgeführt haben, um eine vorhandene sitzungsspezifische IP-Adresse in eine statische IP-Adresse umzuwandeln, rufen Sie die Google Cloud Console auf, um die statische IP-Adresse zu löschen.

    • Wenn Sie „Option 2“ ausgeführt haben, um eine neue statische IP-Adresse zu erstellen, führen Sie den folgenden Befehl aus, um die statische IP-Adresse zu löschen:

      gcloud compute addresses delete web-static-ip --global

  4. Löschen Sie den Cluster: Mit diesem Schritt werden die Compute-Knoten des Container-Clusters sowie weitere Ressourcen wie z. B. die Deployments im Cluster gelöscht:

    gcloud container clusters delete loadbalancedcluster

Nächste Schritte