Anwendungen über Dienste verfügbar machen

Autopilot Standard

---

Diese Seite zeigt, wie Sie Kubernetes-Services in einem Cluster von Google Kubernetes Engine (GKE) erstellen. Eine Erläuterung des Servicekonzepts und eine Erläuterung der verschiedenen Servicetypen finden Sie unter Service.

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.

Vorbereitung

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.

* GKE-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. Öffnen Sie in der Google Cloud Console die Seite Arbeitslasten.

   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.

Hinweis: Das Erstellen eines monitorlosen Dienstes ist über die Console derzeit nicht verfügbar.

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.

Hinweis: Sie sollten vorab prüfen, ob jeder Ihrer Mitglieds-Pods einen Container hat, der den TCP-Port 8080 überwacht. In dieser Übung haben Sie nichts unternommen, damit die Container Port 8080 überwachen. Sie können sehen, dass hello-app Port 8080 überwacht, wenn Sie das Dockerfile und den Quellcode für die Anwendung betrachten.

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. Öffnen Sie in der Google Cloud Console die Seite Arbeitslasten.

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

IP-Adresse eines Knotens 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. Beispielsweise haben die Knoten in privaten Clustern keine externen IP-Adressen.

Auf Ihren Service 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 Service 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. Öffnen Sie in der Google Cloud Console die Seite Arbeitslasten.

   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

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. Öffnen Sie in der Google Cloud Console die Seite Arbeitslasten.

   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

• Dienste
• StatefulSets
• Eingehender Traffic
• HTTP-Load-Balancing mit Ingress