Anwendungen über Dienste verfügbar machen

Auf dieser Seite wird beschrieben, wie Sie Ihre Anwendungen über Ihr internes Netzwerk oder das Internet zugänglich machen, indem Sie Kubernetes-Services in Google Kubernetes Engine (GKE) erstellen, um diese Anwendungen verfügbar zu machen. Es werden fünf Diensttypen behandelt: ClusterIP, NodePort, LoadBalancer, ExternalName und Headless.

Die Anleitung enthält Beispiele für jeden Diensttyp, in denen gezeigt wird, wie Sie Deployments erstellen, sie über Dienste freigeben und darauf zugreifen.

Diese Seite richtet sich an Betreiber und Entwickler, die Cloud-Ressourcen bereitstellen und konfigurieren sowie Apps und Dienste bereitstellen. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die in Google Cloud-Inhalten verwiesen wird, finden Sie unter Häufig verwendete GKE-Nutzerrollen und -Aufgaben.

Machen Sie sich vor dem Lesen dieser Seite mit der Verwendung von kubectl vertraut.

Einführung

Die Idee eines Dienstes besteht darin, eine Gruppe von Pod-Endpunkten in einer einzigen Ressource zu gruppieren. Sie können verschiedene Zugriffsmöglichkeiten für die Gruppierung konfigurieren. Standardmäßig erhalten Sie eine stabile Cluster-IP-Adresse, über die Clients innerhalb des Clusters Pods im Service kontaktieren können. Ein Client sendet eine Anfrage an die stabile IP-Adresse. Die Anfrage wird dann an einen der Pods im Service weitergeleitet.

Es gibt fünf Diensttypen:

  • ClusterIP (Standard)
  • NodePort
  • LoadBalancer
  • ExternalName
  • Headless

Autopilot-Cluster sind standardmäßig öffentlich. Wenn Sie einen privaten Autopilot-Cluster verwenden, müssen Sie Cloud NAT so konfigurieren, dass ausgehende Internetverbindungen hergestellt werden, beispielsweise Images aus DockerHub.

Dieses Thema enthält mehrere Übungen. In jeder Übung erstellen Sie ein Deployment und geben Ihre Pods durch Erstellen eines Service frei. Dann senden Sie eine HTTP-Anfrage an den Service.

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 diesen Task 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.
  • Prüfen Sie, ob Sie einen vorhandenen Autopilot- oder Standardcluster haben. Informationen zum Erstellen eines neuen Clusters finden Sie unter Autopilot-Cluster erstellen.

Service vom Typ ClusterIP erstellen

In diesem Abschnitt erstellen Sie einen Dienst vom Typ ClusterIP.

kubectl apply

Hier ist ein Manifest für ein Deployment:

apiVersion: apps/v1 kind: Deployment metadata:   name: my-deployment spec:   selector:     matchLabels:       app: metrics       department: sales   replicas: 3   template:     metadata:       labels:         app: metrics         department: sales     spec:       containers:       - name: hello         image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"

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

kubectl apply -f my-deployment.yaml

Achten Sie darauf, dass drei Pods ausgeführt werden:

kubectl get pods

Die Ausgabe zeigt drei laufende Pods:

NAME                            READY   STATUS    RESTARTS   AGE my-deployment-dbd86c8c4-h5wsf   1/1     Running   0          7s my-deployment-dbd86c8c4-qfw22   1/1     Running   0          7s my-deployment-dbd86c8c4-wt4s6   1/1     Running   0          7s

Hier ist ein Manifest für einen Service vom Typ ClusterIP:

apiVersion: v1 kind: Service metadata:   name: my-cip-service spec:   type: ClusterIP   # Uncomment the below line to create a Headless Service   # clusterIP: None   selector:     app: metrics     department: sales   ports:   - protocol: TCP     port: 80     targetPort: 8080

Der Service verfügt über einen Selektor, der zwei Labels angibt:

  • app: metrics
  • department: sales

Jeder Pod in dem zuvor erstellten Deployment verfügt über diese beiden Labels. Die Pods im Deployment werden also Mitglieder dieses Service.

Kopieren Sie das Manifest in eine Datei mit dem Namen my-cip-service.yaml und erstellen Sie den Service:

kubectl apply -f my-cip-service.yaml

Warten Sie, bis Kubernetes dem Dienst eine stabile interne Adresse zuweist, und rufen Sie dann den Dienst auf:

kubectl get service my-cip-service --output yaml

Die Ausgabe zeigt einen Wert für clusterIP:

spec:   clusterIP: 10.59.241.241

Notieren Sie sich den Wert von clusterIP für später.

Console

Deployment erstellen

  1. Rufen Sie in der Google Cloud -Console die Seite Arbeitslasten auf.

    Zu Arbeitslasten

  2. Klicken Sie auf Bereitstellen.

  3. Wählen Sie unter Container angeben die Option Vorhandenes Container-Image aus.

  4. Geben Sie us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0 als Image-Pfad ein.

  5. Klicken Sie auf Fertig und dann auf Weiter.

  6. Geben Sie unter Konfiguration für Anwendungsname my-deployment ein.

  7. Erstellen Sie unter Labels die folgenden Labels:

    • Schlüssel: app und Wert: metrics
    • Schlüssel: department und Wert: sales

  8. Wählen Sie unter Cluster den Cluster aus, in dem Sie das Deployment erstellen möchten.

  9. Klicken Sie auf Bereitstellen.

  10. Wenn Ihr Deployment fertig ist, wird die Seite Bereitstellungsdetails geöffnet. Unter Verwaltete Pods können Sie sehen, dass in Ihrem Deployment mindestens ein Pod ausgeführt wird.

Service erstellen, um das Deployment freizugeben

  1. Klicken Sie auf der Seite Bereitstellungsdetails auf Aktionen > Anzeigen.

  2. Legen Sie im Dialogfeld Freigeben unter Portzuordnung die folgenden Werte fest:

    • Port: 80
    • Zielport: 8080
    • Protokoll: TCP

  3. Wählen Sie in der Drop-down-Liste Servicetyp die Option Cluster-IP aus.

  4. Klicken Sie auf Freigeben.

  5. Wenn Ihr Service bereit ist, öffnet sich die Seite Servicedetails und Sie können Details über Ihren Service sehen. Notieren Sie sich unter Cluster-IP die IP-Adresse, die Kubernetes Ihrem Service zugewiesen hat. Dies ist die IP-Adresse, die interne Clients zum Aufrufen des Service verwenden können.

Zugriff auf Ihren Service

Listen Sie Ihre laufenden Pods auf:

kubectl get pods

Kopieren Sie in der Ausgabe einen der Pod-Namen, der mit my-deployment beginnt.

NAME                            READY   STATUS    RESTARTS   AGE my-deployment-dbd86c8c4-h5wsf   1/1     Running   0          2m51s

Rufen Sie eine Shell in einen Ihrer laufenden Container ab:

kubectl exec -it POD_NAME -- sh

Ersetzen Sie POD_NAME durch den Namen eines der Pods in my-deployment.

Installieren Sie curl in Ihrer Shell:

apk add --no-cache curl

Senden Sie in dem Container eine Anfrage an Ihren Service. Verwenden Sie dabei die Cluster-IP-Adresse und den Port 80. Beachten Sie, dass 80 der Wert des Feldes port Ihres Service ist. Das ist der Port, den Sie als Client des Service verwenden.

curl CLUSTER_IP:80

Ersetzen Sie CLUSTER_IP durch den Wert von clusterIP in Ihrem Service.

Ihre Anfrage wird an einen der Mitglieder-Pods an TCP-Port 8080 weitergeleitet, der Wert des Feldes targetPort. Beachten Sie, dass jeder Mitglieds-Pod des Service einen den Port 8080 überwachenden Container benötigt.

Die Antwort zeigt die Ausgabe von hello-app:

Hello, world! Version: 2.0.0 Hostname: my-deployment-dbd86c8c4-h5wsf

Geben Sie zum Verlassen der Shell zu Ihrem Container exit ein.

Service vom Typ NodePort erstellen

In diesem Abschnitt erstellen Sie einen Dienst vom Typ NodePort.

kubectl apply

Hier ist ein Manifest für ein Deployment:

apiVersion: apps/v1 kind: Deployment metadata:   name: my-deployment-50000 spec:   selector:     matchLabels:       app: metrics       department: engineering   replicas: 3   template:     metadata:       labels:         app: metrics         department: engineering     spec:       containers:       - name: hello         image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"         env:         - name: "PORT"           value: "50000"

Beachten Sie das Objekt env im Manifest. Das Objekt env gibt an, dass die Umgebungsvariable PORT für den laufenden Container den Wert 50000 hat. Die Anwendung hello-app überwacht den von der Umgebungsvariablen PORT angegebenen Port. In dieser Übung teilen Sie dem Container mit, dass er Port 50000 überwachen soll.

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

kubectl apply -f my-deployment-50000.yaml

Achten Sie darauf, dass drei Pods ausgeführt werden:

kubectl get pods

Hier ist ein Manifest für einen Service vom Typ NodePort:

apiVersion: v1 kind: Service metadata:   name: my-np-service spec:   type: NodePort   selector:     app: metrics     department: engineering   ports:   - protocol: TCP     port: 80     targetPort: 50000

Kopieren Sie das Manifest in eine Datei mit dem Namen my-np-service.yaml und erstellen Sie den Service:

kubectl apply -f my-np-service.yaml

Lassen Sie den Dienst anzeigen:

kubectl get service my-np-service --output yaml

Die Ausgabe zeigt einen Wert von nodePort:

...   spec:     ...     ports:     - nodePort: 30876       port: 80       protocol: TCP       targetPort: 50000     selector:       app: metrics       department: engineering     sessionAffinity: None     type: NodePort ...

Erstellen Sie eine Firewallregel für den TCP-Traffic an Ihrem Knotenport:

gcloud compute firewall-rules create test-node-port \     --allow tcp:NODE_PORT

Ersetzen Sie NODE_PORT durch den Wert des Felds nodePort Ihres Service.

Console

Deployment erstellen

  1. Rufen Sie in der Google Cloud -Console die Seite Arbeitslasten auf.

    Zu Arbeitslasten

  2. Klicken Sie auf Bereitstellen.

  3. Wählen Sie unter Container angeben die Option Vorhandenes Container-Image aus.

  4. Geben Sie us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0 als Image-Pfad ein.

  5. Klicken Sie auf Umgebungsvariable hinzufügen.

  6. Geben Sie für Schlüssel PORT und für Wert 50000 ein.

  7. Klicken Sie auf Fertig und dann auf Weiter.

  8. Geben Sie unter Konfiguration für Anwendungsname my-deployment-50000 ein.

  9. Erstellen Sie unter Labels die folgenden Labels:

    • Schlüssel: app und Wert: metrics
    • Schlüssel: department und Wert: engineering

  10. Wählen Sie unter Cluster den Cluster aus, in dem Sie das Deployment erstellen möchten.

  11. Klicken Sie auf Bereitstellen.

  12. Wenn Ihr Deployment fertig ist, wird die Seite Bereitstellungsdetails geöffnet. Unter Verwaltete Pods können Sie sehen, dass in Ihrem Deployment mindestens ein Pod ausgeführt wird.

Service erstellen, um das Deployment freizugeben

  1. Klicken Sie auf der Seite Bereitstellungsdetails auf Aktionen > Anzeigen.

  2. Legen Sie im Dialogfeld Freigeben unter Portzuordnung die folgenden Werte fest:

    • Port: 80
    • Zielport: 50000
    • Protokoll: TCP

  3. Wählen Sie in der Drop-down-Liste Servicetyp die Option Knotenport aus.

  4. Klicken Sie auf Freigeben.

  5. Wenn Ihr Service bereit ist, öffnet sich die Seite Servicedetails und Sie können Details über Ihren Service sehen. Notieren Sie sich unter Ports den Knotenport, den Kubernetes Ihrem Service zugeordnet hat.

Firewallregel für Ihren Knotenport erstellen

  1. Rufen Sie in der Google Cloud Console die Seite Firewallrichtlinien auf.

    Zu den Firewall-Richtlinien

  2. Klicken Sie auf Firewallregel erstellen.

  3. Geben Sie für Name test-node-port ein.

  4. Wählen Sie in der Drop-down-Liste Ziele die Option Alle Instanzen im Netzwerk aus.

  5. Geben Sie unter Quell-IPv4-Bereiche den Wert 0.0.0.0/0 ein.

  6. Wählen Sie unter Protokolle und Ports die Option Angegebene Protokolle und Ports aus.

  7. Klicken Sie das Kästchen tcp an und geben Sie den Wert des Knotenports ein, den Sie notiert haben.

  8. Klicken Sie auf Erstellen.

Knoten-IP-Adresse abrufen

Finden Sie die externe IP-Adresse eines Ihrer Knoten.

kubectl get nodes --output wide

Die Ausgabe sieht in etwa so aus:

NAME          STATUS    ROLES     AGE    VERSION        EXTERNAL-IP gke-svc-...   Ready     none      1h     v1.9.7-gke.6   203.0.113.1

Nicht alle Cluster haben externe IP-Adressen für Knoten. Wenn Sie beispielsweise private Knoten aktiviert haben, haben die Knoten keine externen IP-Adressen.

Auf Ihren Dienst zugreifen

Geben Sie Folgendes in die Adressleiste Ihres Browsers ein:

NODE_IP_ADDRESS:NODE_PORT

Dabei gilt:

  • NODE_IP_ADDRESS: die externe IP-Adresse eines Ihrer Knoten, der beim Erstellen des Dienstes in der vorherigen Aufgabe ermittelt wurde.
  • NODE_PORT: der Wert für den Knotenport.

Die Ausgabe sieht etwa so aus:

Hello, world! Version: 2.0.0 Hostname: my-deployment-50000-6fb75d85c9-g8c4f

Service vom Typ LoadBalancer erstellen

In diesem Abschnitt erstellen Sie einen Dienst vom Typ LoadBalancer.

kubectl apply

Hier ist ein Manifest für ein Deployment:

apiVersion: apps/v1 kind: Deployment metadata:   name: my-deployment-50001 spec:   selector:     matchLabels:       app: products       department: sales   replicas: 3   template:     metadata:       labels:         app: products         department: sales     spec:       containers:       - name: hello         image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"         env:         - name: "PORT"           value: "50001"

Die Container in diesem Deployment beobachten Port 50001.

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

kubectl apply -f my-deployment-50001.yaml

Achten Sie darauf, dass drei Pods ausgeführt werden:

kubectl get pods

Hier ist ein Manifest für einen Service vom Typ LoadBalancer:

apiVersion: v1 kind: Service metadata:   name: my-lb-service spec:   type: LoadBalancer   selector:     app: products     department: sales   ports:   - protocol: TCP     port: 60000     targetPort: 50001

Kopieren Sie das Manifest in eine Datei mit dem Namen my-lb-service.yaml, und erstellen Sie den Service:

kubectl apply -f my-lb-service.yaml

Wenn Sie einen Dienst vom Typ LoadBalancer erstellen, wird der Ruhemodus eines Google Cloud-Controllers beendet und ein externer Passthrough-Network-Load-Balancer wird konfiguriert. Warten Sie eine Minute, bis der Controller den externen Passthrough-Network-Load-Balancer konfiguriert und eine stabile IP-Adresse generiert hat.

Lassen Sie den Service anzeigen:

kubectl get service my-lb-service --output yaml

Die Ausgabe zeigt eine stabile externe IP-Adresse unter loadBalancer:ingress an:

... spec:   ...   ports:   - ...     port: 60000     protocol: TCP     targetPort: 50001   selector:     app: products     department: sales   sessionAffinity: None   type: LoadBalancer status:   loadBalancer:     ingress:     - ip: 203.0.113.10

Console

Deployment erstellen

  1. Rufen Sie in der Google Cloud -Console die Seite Arbeitslasten auf.

    Zu Arbeitslasten

  2. Klicken Sie auf Bereitstellen.

  3. Wählen Sie unter Container angeben die Option Vorhandenes Container-Image aus.

  4. Geben Sie us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0 als Image-Pfad ein.

  5. Klicken Sie auf Umgebungsvariable hinzufügen.

  6. Geben Sie für Schlüssel PORT und für Wert 50001 ein.

  7. Klicken Sie auf Fertig und dann auf Weiter.

  8. Geben Sie unter Konfiguration für Anwendungsname my-deployment-50001 ein.

  9. Erstellen Sie unter Labels die folgenden Labels:

    • Schlüssel: app und Wert: products
    • Schlüssel: department und Wert: sales

  10. Wählen Sie unter Cluster den Cluster aus, in dem Sie das Deployment erstellen möchten.

  11. Klicken Sie auf Bereitstellen.

  12. Wenn Ihr Deployment fertig ist, wird die Seite Bereitstellungsdetails geöffnet. Unter Verwaltete Pods können Sie sehen, dass in Ihrem Deployment mindestens ein Pod ausgeführt wird.

Service erstellen, um das Deployment freizugeben

  1. Klicken Sie auf der Seite Bereitstellungsdetails auf Aktionen > Anzeigen.

  2. Legen Sie im Dialogfeld Freigeben unter Portzuordnung die folgenden Werte fest:

    • Port: 60000
    • Zielport: 50001
    • Protokoll: TCP

  3. Wählen Sie im Drop-down-Menü Diensttyp die Option Load-Balancer aus.

  4. Klicken Sie auf Freigeben.

  5. Wenn Ihr Service bereit ist, öffnet sich die Seite Servicedetails und Sie können Details über Ihren Service sehen. Notieren Sie sich unter Load-Balancer die externe IP-Adresse des Load-Balancers.

Auf Ihren Service zugreifen

Warten Sie einige Minuten, bis GKE den Load-Balancer konfiguriert hat.

Geben Sie Folgendes in die Adressleiste Ihres Browsers ein:

LOAD_BALANCER_ADDRESS:60000

Ersetzen Sie LOAD_BALANCER_ADDRESS durch die externe IP-Adresse Ihres Load-Balancers.

Die Antwort zeigt die Ausgabe von hello-app:

Hello, world! Version: 2.0.0 Hostname: my-deployment-50001-68bb7dfb4b-prvct

Beachten Sie, dass der Wert von port in einem Service beliebig ist. Das vorherige Beispiel veranschaulicht dies durch Verwendung eines port-Werts von 60000.

Dienst vom Typ ExternalName erstellen

In diesem Abschnitt erstellen Sie einen Dienst vom Typ ExternalName.

Ein Dienst vom Typ ExternalName stellt einen internen Alias für einen externen DNS-Namen bereit. Interne Clients senden Anfragen unter Verwendung des internen DNS-Namens und die Anfragen werden an den externen Namen umgeleitet.

Hier ist ein Manifest für einen Service vom Typ ExternalName:

apiVersion: v1 kind: Service metadata:   name: my-xn-service spec:   type: ExternalName   externalName: example.com

Im vorherigen Beispiel lautet der DNS-Name "my-xn-service.default.svc.cluster.local". Wenn ein interner Client eine Anfrage an "my-xn-service.default.svc.cluster.local" sendet, wird die Anfrage an "example.com" umgeleitet.

Service mithilfe von kubectl expose erstellen

Als Alternative zum Schreiben eines Servicemanifests können Sie einen Service erstellen. Verwenden Sie dafür kubectl expose, um ein Deployment freizugeben.

Sie können my-deployment, wie weiter oben in diesem Thema gezeigt, mit dem folgenden Befehl freigeben:

kubectl expose deployment my-deployment --name my-cip-service \     --type ClusterIP --protocol TCP --port 80 --target-port 8080

Sie können my-deployment-50000, wie weiter oben in diesem Thema gezeigt, mit dem folgenden Befehl freigeben:

kubectl expose deployment my-deployment-50000 --name my-np-service \     --type NodePort --protocol TCP --port 80 --target-port 50000

Sie können my-deployment-50001, wie weiter oben in diesem Thema gezeigt, mit dem folgenden Befehl freigeben:

kubectl expose deployment my-deployment-50001 --name my-lb-service \     --type LoadBalancer --port 60000 --target-port 50001

Dienste ansehen

Sie können die erstellten Dienste in der Google Cloud Console auf der Seite Dienste aufrufen.

Zu Dienste

Alternativ können Sie Ihre Dienste auch im App Hub im Kontext der Geschäftsfunktionen aufrufen, die sie unterstützen. App Hub bietet eine zentrale Übersicht über alle Ihre Anwendungen und die zugehörigen Dienste.

Wenn Sie Ihre Dienste in App Hub aufrufen möchten, rufen Sie in der Google Cloud Console die Seite App Hub auf.

Zum App Hub

Als verwalteter Kubernetes-Dienst sendet GKE automatisch Dienstmetadaten, insbesondere Ressourcen-URIs, an App Hub, wenn Ressourcen erstellt oder gelöscht werden. Durch die kontinuierliche Aufnahme von Metadaten wird die Entwicklung und Verwaltung von Anwendungen in App Hub verbessert.

Weitere Informationen zu Ressourcen, die von App Hub unterstützt werden, finden Sie unter Unterstützte Ressourcen.

Informationen zum Einrichten von App Hub für Ihr Projekt finden Sie unter App Hub einrichten.

Bereinigen

Wenn Sie mit den Übungen auf dieser Seite fertig sind, entfernen Sie mit den folgenden Schritten die Ressourcen, damit Sie unerwünschte Kosten für Ihr Konto vermeiden:

kubectl apply

Ihre Services löschen

kubectl delete services my-cip-service my-np-service my-lb-service

Ihre Deployments löschen

kubectl delete deployments my-deployment my-deployment-50000 my-deployment-50001

Firewallregeln löschen

gcloud compute firewall-rules delete test-node-port

Console

Ihre Services löschen

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

    Zu Dienste

  2. Wählen Sie die Dienste aus, die Sie in dieser Übung erstellt haben, und klicken Sie dann auf Löschen.

  3. Wenn Sie zur Bestätigung aufgefordert werden, klicken Sie auf Löschen.

Ihre Deployments löschen

  1. Rufen Sie in der Google Cloud -Console die Seite Arbeitslasten auf.

    Zu Arbeitslasten

  2. Wählen Sie die Deployments aus, die Sie in dieser Übung erstellt haben, und klicken Sie dann auf Löschen.

  3. Wenn Sie zur Bestätigung des Vorgangs aufgefordert werden, klicken Sie das Kästchen Horizontale Pod-Autoscalings löschen, die mit ausgewählten Deployments verknüpft sind an und anschließend auf Löschen.

Firewallregeln löschen

  1. Rufen Sie in der Google Cloud Console die Seite Firewallrichtlinien auf.

    Zu den Firewall-Richtlinien

  2. Klicken Sie auf das Kästchen test-node-port und dann auf Löschen.

  3. Wenn Sie zur Bestätigung aufgefordert werden, klicken Sie auf Löschen.

Nächste Schritte