Anwendungen über Dienste verfügbar machen

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

Ein Dienst dient dazu, eine Reihe von Pod-Endpunkten in einer 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:

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

Dienst vom Typ ClusterIP erstellen

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 Cloud Console die Seite Arbeitslasten auf.

    Zu "Arbeitslasten"

  2. Klicken Sie auf Bereitstellen.

  3. Wählen Sie unter Container 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 Deploy.

  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

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

Wenn die Knoten in Ihrem Cluster eine externe IP-Adresse haben, ermitteln Sie die externe IP-Adresse eines Ihrer Knoten:

kubectl get nodes --output wide

Die Ausgabe zeigt die externen IP-Adressen Ihrer Knoten:

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.

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 Cloud Console die Seite Arbeitslasten auf.

    Zu "Arbeitslasten"

  2. Klicken Sie auf Bereitstellen.

  3. Wählen Sie unter Container 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 Deploy.

  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 Cloud Console die Seite Firewall auf.

    Zur Firewall

  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 für Quell-IP-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.

Externe IP-Adresse eines Ihrer Clusterknoten suchen

  1. Rufen Sie in der Cloud Console die Seite Google Kubernetes Engine auf:

    Zur Seite "Google Kubernetes Engine"

  2. Klicken Sie auf den Namen des Clusters für diese Übung.

  3. Klicken Sie auf der Seite Clusterdetails auf den Tab Knoten.

  4. Klicken Sie unter Knotenpools auf den Namen eines Knotenpools, um die Seite Details zum Knotenpool zu öffnen.

  5. Klicken Sie unter Instanzgruppen auf den Namen einer Instanzgruppe.

  6. Notieren Sie sich in der Liste der Knoten eine der 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

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 Netzwerk-Load-Balancer konfiguriert. Warten Sie eine Minute, bis der Controller den Netzwerklastenausgleich konfiguriert und eine stabile IP-Adresse generiert hat.

Lassen Sie den Dienst 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 Cloud Console die Seite Arbeitslasten auf.

    Zu "Arbeitslasten"

  2. Klicken Sie auf Bereitstellen.

  3. Wählen Sie unter Container 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 Deploy.

  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.

Service vom Typ ExternalName erstellen

Ein Service 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 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 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 Cloud Console die Seite Firewall auf.

    Zur Firewall

  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