Ingress für externes Load-Balancing konfigurieren

Auf dieser Seite erfahren Sie, wie Sie einen externen HTTP(S)-Load-Balancer durch Erstellen eines Kubernetes-Ingress-Objekts konfigurieren. Ein Ingress-Objekt ist einem oder mehreren Dienstobjekten zugeordnet. Diesen wiederum ist jeweils ein Pod-Satz zugeordnet.

Ein Dienstobjekt verfügt über eine oder mehrere Strukturen vom Typ servicePort. Jeder servicePort, der das Ziel von eingehendem Traffic ist, ist einer Back-End-Dienstressource der Google Cloud zugeordnet.

Vorbereitung

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

Mit den folgenden Methoden können Sie die gcloud-Einstellungen festlegen:

  • Verwenden Sie gcloud init, wenn Sie die Standardeinstellungen ansehen möchten.
  • Verwenden Sie gcloud config, um Ihre Projekt-ID, Zone und Region individuell festzulegen.

gcloud init verwenden

Wenn Sie die Fehlermeldung One of [--zone, --region] must be supplied: Please specify location erhalten, führen Sie diesen Abschnitt aus.

  1. Führen Sie gcloud init aus und folgen Sie der Anleitung:

    gcloud init

    Wenn Sie SSH auf einem Remote-Server verwenden, können Sie mit dem Flag --console-only verhindern, dass mit dem Befehl ein Browserfenster geöffnet wird:

    gcloud init --console-only
  2. Folgen Sie der Anleitung, um gcloud zur Verwendung Ihres Google Cloud-Kontos zu autorisieren.
  3. Erstellen Sie eine neue Konfiguration oder wählen Sie eine vorhandene aus.
  4. Wählen Sie ein Google Cloud-Projekt aus.
  5. Wählen Sie eine Compute Engine-Standardzone für zonale Cluster oder eine Region für regionale oder Autopilot-Cluster aus.

gcloud config verwenden

  • Legen Sie Ihre standardmäßige Projekt-ID fest:
    gcloud config set project PROJECT_ID
  • Wenn Sie mit zonalen Clustern arbeiten, legen Sie die Standardzone für Compute Engine fest:
    gcloud config set compute/zone COMPUTE_ZONE
  • Wenn Sie mit Autopilot oder regionalen Clustern arbeiten, legen Sie die Compute-Standardregion fest:
    gcloud config set compute/region COMPUTE_REGION
  • Aktualisieren Sie gcloud auf die neueste Version:
    gcloud components update

In Ihrem Projekt muss ein GKE-Cluster mit aktiviertem HTTP(S)-Load-Balancing aktiviert sein:

Console

  1. Rufen Sie in der Cloud Console das Google Kubernetes Engine-Menü auf.

    Zum Google Kubernetes Engine-Menü

  2. Klicken Sie auf den Namen des Clusters, den Sie ändern möchten.

  3. Klicken Sie unter Netzwerk im Feld HTTP-Load-Balancing auf HTTP-Load-Balancing bearbeiten.

  4. Klicken Sie das Kästchen HTTP-Load-Balancing aktivieren an.

  5. Klicken Sie auf Änderungen speichern.

gcloud

gcloud container clusters update cluster-name --update-addons=HttpLoadBalancing=ENABLED

Dabei ist cluster-name der Name Ihres Clusters.

Mehrere Back-End-Dienste

Ein externer HTTP(S)-Load-Balancer stellt eine stabile IP-Adresse bereit, mit der Sie Anfragen an verschiedene Back-End-Dienste weiterleiten können.

In dieser Übung konfigurieren Sie einen externen HTTP(S)-Load-Balancer, um Anfragen je nach URL-Pfad an verschiedene Back-End-Dienste weiterzuleiten. Anfragen mit dem Pfad / werden an einen anderen Back-End-Dienst weitergeleitet als Anfragen mit dem Pfad /kube.

Hier ist eine Übersicht über die Schritte in dieser Übung:

  1. Erstellen Sie ein Deployment und geben Sie es mit dem Dienst namens hello-world frei.
  2. Erstellen Sie ein zweites Deployment und geben Sie es mit dem Dienst namens hello-kubernetes frei.
  3. Sie erstellen ein Ingress-Objekt, das Regeln festlegt, sodass Anfragen je nach enthaltenem URL-Pfad an unterschiedliche Dienste weitergeleitet werden. Wenn Sie das Ingress-Objekt erstellt haben, erstellt und konfiguriert der GKE-Ingress-Controller einen HTTP(S)-Load-Balancer.
  4. Testen Sie den externen HTTP(S)-Load-Balancer.

Deployment erstellen

Dies ist ein Manifest für das erste Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-deployment
spec:
  selector:
    matchLabels:
      greeting: hello
      department: world
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
        department: world
    spec:
      containers:
      - name: hello
        image: "gcr.io/google-samples/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50000"

Kopieren Sie das Manifest in eine Datei mit dem Namen hello-world-deployment.yaml und erstellen Sie das Deployment:

kubectl apply -f hello-world-deployment.yaml

Dienst erstellen

Dies ist ein Manifest für den Dienst, der das erste Deployment freigibt:

apiVersion: v1
kind: Service
metadata:
  name: hello-world
spec:
  type: NodePort
  selector:
    greeting: hello
    department: world
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50000

Zum Zweck dieser Übung sollten Sie diese wichtigen Punkte in Bezug auf diesen Dienst im Hinterkopf behalten:

  • Jeder Pod mit dem Label greeting: hello und dem Label department: world ist ein Mitglied des Dienstes.

  • Wenn an den Dienst eine Anfrage an TCP-Port 60000 gesendet wird, wird sie an einen der Mitglieds-Pods an TCP-Port 50000 weitergeleitet.

Kopieren Sie das Manifest in eine Datei mit dem Namen hello-world-service.yaml und erstellen Sie den Dienst:

kubectl apply -f hello-world-service.yaml

Ein zweites Deployment erstellen

Dies ist ein Manifest für das zweite Deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-kubernetes-deployment
spec:
  selector:
    matchLabels:
      greeting: hello
      department: kubernetes
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
        department: kubernetes
    spec:
      containers:
      - name: hello-again
        image: "gcr.io/google-samples/node-hello:1.0"
        env:
        - name: "PORT"
          value: "8080"

Kopieren Sie das Manifest in eine Datei mit dem Namen hello-kubernetes-deployment.yaml und erstellen Sie das Deployment:

kubectl apply -f hello-kubernetes-deployment.yaml

Zweiten Dienst erstellen

Dies ist ein Manifest für den Dienst, der das zweite Deployment freigibt:

apiVersion: v1
kind: Service
metadata:
  name: hello-kubernetes
spec:
  type: NodePort
  selector:
    greeting: hello
    department: kubernetes
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

Zum Zweck dieser Übung sollten Sie diese wichtigen Punkte in Bezug auf diesen Dienst im Hinterkopf behalten:

  • Jeder Pod mit dem Label greeting: hello und dem Label department: kubernetes ist ein Mitglied des Dienstes.

  • Wenn an den Dienst eine Anfrage an TCP-Port 80 gesendet wird, wird sie an einen der Mitglieds-Pods an TCP-Port 8080 weitergeleitet.

Kopieren Sie das Manifest in eine Datei mit dem Namen hello-kubernetes-service.yaml und erstellen Sie den Dienst:

kubectl apply -f hello-kubernetes-service.yaml

Ingress erstellen

Hier ist ein Manifest für ein Ingress:

apiVersion: networking.k8s.io/v1beta1
kind: Ingress
metadata:
  name: my-ingress
  annotations:
    # If the class annotation is not specified it defaults to "gce".
    kubernetes.io/ingress.class: "gce"
spec:
  rules:
  - http:
      paths:
      - path: /*
        backend:
          serviceName: hello-world
          servicePort: 60000
      - path: /kube
        backend:
          serviceName: hello-kubernetes
          servicePort: 80

Zum Zweck dieser Übung sollten Sie diese wichtigen Punkte in Bezug auf dieses Ingress-Manifest beachten:

  • Für GKE Ingress sind zwei Ingress-Klassen verfügbar. Die Klasse gce stellt einen externen Load-Balancer bereit und die Klasse gce-internal stellt einen internen Load-Balancer bereit. Ingress-Ressourcen ohne Klasse, für die gce angegeben ist.

  • 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.

  • Das Ingress-Manifest hat zwei Paare (serviceName, servicePort). Jedes Paar (serviceName, servicePort) ist einem Google Cloud-Back-End-Dienst zugeordnet.

Kopieren Sie das Manifest in eine Datei mit dem Namen my-ingress.yaml und erstellen Sie das Ingress-Objekt:

kubectl apply -f my-ingress.yaml

Wenn Sie das Ingress-Objekt erstellt haben, erstellt der GKE-Ingress-Controller einen externen HTTP(S)-Load-Balancer und konfiguriert diesen so:

  • Wenn ein Client eine Anfrage mit dem URL-Pfad / an den Load-Balancer sendet, wird die Anfrage an den Dienst hello-world auf Port 60000 weitergeleitet.

  • Wenn ein Client eine Anfrage mit dem URL-Pfad /kube an den Load-Balancer sendet, wird die Anfrage an den Dienst hello-kubernetes auf Port 80 weitergeleitet.

Warten Sie etwa fünf Minuten, bis der Load-Balancer konfiguriert wurde.

Externen HTTP(S)-Load-Balancer testen

So testen Sie den externen HTTP(S)-Load-Balancer:

  1. Sehen Sie sich das Ingress-Objekt an:

    kubectl get ingress my-ingress --output yaml
    

    Die Ausgabe zeigt die IP-Adresse des externen HTTP(S)-Load-Balancers:

    status:
      loadBalancer:
        ingress:
        - ip: 203.0.113.1
    
  2. Testen Sie den Pfad /:

    curl load-balancer-ip/
    

    Ersetzen Sie load-balancer-ip durch die externe IP-Adresse Ihres Load-Balancers.

    In der Ausgabe wird die Meldung Hello, world! angezeigt:

    Hello, world!
    Version: 2.0.0
    Hostname: ...
    
  3. Testen Sie den Pfad /kube:

    curl load-balancer-ip/kube
    

    In der Ausgabe wird die Meldung Hello Kubernetes! angezeigt:

    Hello Kubernetes!
    

HTTPS zwischen Client und Load-Balancer

Ein externer HTTP(S)-Load-Balancer fungiert als Proxy zwischen Ihren Clients und Ihrer Anwendung. Wenn HTTPS-Anfragen von den Clients angenommen werden sollen, benötigt der Load-Balancer ein Zertifikat, damit er seine Identität gegenüber den Clients nachweisen kann. Der Load-Balancer benötigt außerdem einen privaten Schlüssel, um den HTTPS-Handshake abzuschließen. Weitere Informationen

HTTP deaktivieren

Wenn der gesamte Traffic zwischen dem Client und dem Load-Balancer HTTPS verwenden soll, können Sie HTTP deaktivieren.

HTTPS zwischen Load-Balancer und Anwendung

Wenn Ihre in einem GKE-Pod ausgeführte Anwendung HTTPS-Anfragen empfangen kann, können Sie den Load-Balancer so konfigurieren, dass er bei der Weiterleitung von Anfragen an die Anwendung HTTPS verwendet. Weitere Informationen finden Sie unter HTTPS (TLS) zwischen dem Load-Balancer und Ihrer Anwendung.

HTTP/2 zwischen Client und Load-Balancer

Clients können HTTP/2 verwenden, um Anfragen an den Load-Balancer zu senden. Es ist keine Konfiguration erforderlich.

HTTP/2 zwischen Load-Balancer und Anwendung

Wenn Ihre in einem GKE-Pod ausgeführte Anwendung HTTP/2-Anfragen empfangen kann, können Sie den Load-Balancer so konfigurieren, dass bei der Weiterleitung von Anfragen an die Anwendung HTTP/2 verwendet wird. Weitere Informationen finden Sie unter HTTP/2 für Load-Balancing mit Ingress.

Netzwerk-Endpunktgruppen

Wenn Ihr Cluster Containernatives Load-Balancing unterstützt, empfehlen wir die Verwendung von Netzwerk-Endpunktgruppen (NEGs). Für GKE-Cluster 1.17 und höher und unter bestimmten Bedingungen ist containernatives Load-Balancing standardmäßig nicht erforderlich. Daher ist keine explizite cloud.google.com/neg: '{"ingress": true}'-Dienstannotation erforderlich.

Zusammenfassung der externen Ingress-Annotationen

Ingress-Annotationen

Annotation Beschreibung
kubernetes.io/ingress.allow-http Gibt an, ob HTTP-Traffic zwischen dem Client und dem HTTP(S)-Load-Balancer zugelassen wird. Mögliche Werte sind "true" und "false". Der Standardwert ist "true". Weitere Informationen finden Sie unter HTTP deaktivieren.
ingress.gcp.kubernetes.io/pre-shared-cert Sie können Zertifikate und Schlüssel in Ihr Google Cloud-Projekt hochladen. Verwenden Sie diese Annotation, um die Zertifikate und Schlüssel zu referenzieren. Weitere Informationen finden Sie unter Mehrere SSL-Zertifikate beim HTTP(S)-Load-Balancing verwenden.
kubernetes.io/ingress.global-static-ip-name Mit dieser Annotation können Sie festlegen, dass der Load-Balancer eine statische externe IP-Adresse verwenden soll, die Sie zuvor erstellt haben. Weitere Informationen finden Sie unter Statische IP-Adressen für HTTP(S)-Load-Balancer.
networking.gke.io/v1beta1.FrontendConfig Mit dieser Annotation können Sie die clientseitige Konfiguration des Load-Balancers anpassen. Weitere Informationen finden Sie unter Ingress-Features.
Annotation Beschreibung
service.alpha.kubernetes.io/app-protocols Mit dieser Annotation können Sie das Protokoll für die Kommunikation zwischen dem Load-Balancer und der Anwendung festlegen. Die Protokolle HTTP, HTTPS und HTTP/2 stehen zur Wahl. Weitere Informationen finden Sie unter HTTPS zwischen Load-Balancer und Ihrer Anwendung und HTTP/2 für Load-Balancing mit Ingress.
beta.cloud.google.com/backend-config Mit dieser Annotation können Sie den einem ServicePort zugeordneten Back-End-Dienst konfigurieren. Weitere Informationen finden Sie unter Ingress-Features.
cloud.google.com/neg Mit dieser Annotation legen Sie fest, dass der Load-Balancer Netzwerk-Endpunktgruppen verwenden soll. Weitere Informationen finden Sie unter Containernatives Load-Balancing verwenden.

Nächste Schritte