Diese Seite wurde von der Cloud Translation API übersetzt.

Anwendung bereitstellen

In diesem Dokument wird anhand eines Beispiels gezeigt, wie Sie eine Anwendung in einem Nutzercluster bereitstellen, der mit Google Distributed Cloud (nur Software) für VMware erstellt wurde.

Vorbereitung

Für das hier gezeigte Beispiel benötigen Sie einen Nutzercluster, der gebündeltes MetalLB-Load Balancing verwendet. Eine Anleitung zum Erstellen eines minimalen Nutzerclusters, der MetalLB verwendet, finden Sie unter Einfache Cluster erstellen.

Sie können die Anwendung entweder über die Google Cloud -Konsole oder über das Befehlszeilentool kubectl auf Ihrer Administrator-Workstation bereitstellen.

Console

Rufen Sie in der Console die Seite Google Kubernetes Engine-Cluster – Übersicht auf.

Zu GKE-Clustern
Klicken Sie in der Liste der Cluster auf Ihren Nutzercluster und prüfen Sie, ob Sie im Cluster angemeldet sind.

Wenn Sie noch nicht in Ihrem Nutzercluster angemeldet sind, folgen Sie der Anleitung unter Cluster über die Google Cloud -Konsole verwalten, um sich anzumelden.

Container

Wählen Sie unter Neuer Container die Option Vorhandenes Container-Image aus.
Geben Sie us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0 als Image-Pfad ein.
Klicken Sie auf Weiter.

Configuration

Geben Sie unter Bereitstellungsname my-deployment ein.
Geben Sie für Namespace default ein.
Geben Sie die folgenden beiden Labels ein:
- Schlüssel 1: app, Wert 1: metrics
- Schlüssel 2: department, Wert 2 sales
Wählen Sie im Drop-down-Menü Kubernetes-Cluster Ihren Cluster aus.
Klicken Sie auf Weiter.

Freigeben

Markieren Sie Deployment als neuen Dienst freigeben.
Geben Sie für Port 1 80 ein.
Geben Sie für Zielport 1 8080 ein. Das ist der korrekte Wert, da der hello-app-Container standardmäßig den TCP-Port 8080 überwacht. Sehen Sie sich das Dockerfile und den Quellcode für die Anwendung an.
Wählen Sie für Protokoll 1 die Option TCP aus.
Wählen Sie für Diensttyp LoadBalancer aus.

Klicken Sie unten auf der Seite auf die Schaltfläche Bereitstellen.

Bereitstellungs- und Dienstdetails ansehen

Wenn Ihr Deployment fertig ist, wird die Seite Bereitstellungsdetails im Bereich Kubernetes-Arbeitslasten der Google Cloud -Konsole geöffnet. Auf dieser Seite sehen Sie Details zum Deployment und dessen drei Pods.
Klicken Sie unter Dienste verfügbar machen auf den Namen des Dienstes, über den Ihr Deployment freigegeben wird. In dieser Übung lautet der Name my-deployment-service.
Die Seite Dienstdetails wird geöffnet. Auf dieser Seite finden Sie Details zum Dienst. Sie können beispielsweise sehen, dass jeder Pod mit den Labels app: metrics und department: sales ein Mitglied des Dienstes ist. Denken Sie daran: Die Pods in my-deployment haben diese Labels.

Möglicherweise wird auch ein Wert für die Load Balancer-IP angezeigt. Die Load-Balancer-IP wurde automatisch auf dem Cluster-Load-Balancer konfiguriert.

Weiterleitung für den Dienst

Angenommen, ein Client außerhalb des Clusters sendet eine Anfrage an die Load Balancer-IP-Adresse über den TCP-Port 80. Die Anfrage wird an den Cluster-Load-Balancer weitergeleitet. Der Load Balancer leitet die Anfrage an einen Mitglieds-Pod am TCP-Port 8080 weiter. Beachten Sie, dass jeder Pod in my-deployment einen Container hat, der den TCP-Port 8080 überwacht.

Testen Sie Ihren Service

Rufen Sie einen Computer auf, auf dem die Load-Balancer-IP geroutet werden kann.

Um Ihren Dienst aufzurufen, geben Sie die IP-Adresse des Load-Balancers in einen Browser ein oder verwenden Sie einen Befehl wie curl. Beispiel:

curl [LOAD_BALANCER_IP]:80

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

curl 203.0.113.1:80
Hello, world!
Version: 2.0.0
Hostname: my-deployment-dbd86c8c4-9wpbv

Deployment löschen

Rufen Sie in der Console im Bereich Kubernetes Engine die Seite Arbeitslasten auf.

Zur Seite „Arbeitslasten“

Wählen Sie in der Liste der Deployments my-deployment aus.

Klicken Sie oben auf der Seite auf Löschen. Dadurch werden sowohl das Deployment als auch der freigebende Dienst gelöscht.

Befehlszeile

Verbindung zu Ihrer Administrator-Workstation herstellen

Rufen Sie eine SSH-Verbindung zu Ihrer Administrator-Workstation ab: Führen Sie die folgenden Schritte auf Ihrer Administrator-Workstation aus.

Deployment erstellen

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 --kubeconfig USER_CLUSTER_KUBECONFIG -f my-deployment.yaml

Dabei ist USER_CLUSTER_KUBECONFIG der Pfad der kubeconfig-Datei für Ihren Nutzercluster.

Grundlegende Informationen zu Ihrem Deployment abrufen:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get deployment my-deployment

Die Ausgabe zeigt, dass das Deployment über drei Pods verfügt, die alle verfügbar sind:

NAME            READY   UP-TO-DATE   AVAILABLE   AGE
my-deployment   3/3     3            3           27s

Listen Sie die Pods in Ihrem Deployment auf:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get pods

Die Ausgabe zeigt, dass in Ihrem Deployment drei Pods ausgeführt werden:

NAME                             READY   STATUS    RESTARTS   AGE
my-deployment-54944c8d55-4srm2   1/1     Running   0          6s
my-deployment-54944c8d55-7z5nn   1/1     Running   0          6s
my-deployment-54944c8d55-j62n9   1/1     Running   0          6s

Rufen Sie detaillierte Informationen zu Ihrem Deployment ab:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get deployment my-deployment --output yaml

Die Ausgabe enthält Details zur Deployment-Spezifikation und zum Status des Deployments:

kind: Deployment
metadata:
  ...
  generation: 1
  name: my-deployment
  namespace: default
  ...
spec:
  ...
  replicas: 3
  revisionHistoryLimit: 10
  selector:
    matchLabels:
      app: metrics
      department: sales
  ...
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
        imagePullPolicy: IfNotPresent
        name: hello
        resources: {}
        terminationMessagePath: /dev/termination-log
        terminationMessagePolicy: File
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      schedulerName: default-scheduler
      securityContext: {}
      terminationGracePeriodSeconds: 30
status:
  availableReplicas: 3
  conditions:
  ‑ lastTransitionTime: "2019-11-11T18:44:02Z"
    lastUpdateTime: "2019-11-11T18:44:02Z"
    message: Deployment has minimum availability.
    reason: MinimumReplicasAvailable
    status: "True"
    type: Available
  ‑ lastTransitionTime: "2019-11-11T18:43:58Z"
    lastUpdateTime: "2019-11-11T18:44:02Z"
    message: ReplicaSet "my-deployment-54944c8d55" has successfully progressed.
    reason: NewReplicaSetAvailable
    status: "True"
    type: Progressing
  observedGeneration: 1
  readyReplicas: 3
  replicas: 3
  updatedReplicas: 3

Beschreiben Sie Ihr Deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG describe deployment my-deployment

Die Ausgabe enthält schön formatierte Details zum Deployment, einschließlich des zugehörigen ReplicaSet:

Name:                   my-deployment
Namespace:              default
CreationTimestamp:      Mon, 11 Nov 2019 10:43:58 -0800
Labels:                 
...
Selector:               app=metrics,department=sales
Replicas:               3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=metrics
           department=sales
  Containers:
    hello:
    Image:        us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
    Port:         
    Host Port:    
    Environment:  
    Mounts:       
  Volumes:        
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  
NewReplicaSet:   my-deployment-54944c8d55 (3/3 replicas created)

Service vom Typ LoadBalancer erstellen

Eine Möglichkeit, Ihr Deployment für Clients außerhalb des Clusters bereitzustellen, besteht darin, einen Kubernetes-Dienst des Typs LoadBalancer zu erstellen.

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

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: metrics
    department: sales
  type: LoadBalancer
  ports:
  ‑ port: 80
    targetPort: 8080

Zum Zweck dieser Übung sollten Sie diese wichtigen Punkte in Bezug auf den Dienst berücksichtigen:

Jeder Pod mit den Labeln app: metrics und department: sales ist ein Mitglied des Dienstes. Die Pods in my-deployment haben diese Labels.
Wenn ein Client eine Anfrage an den Dienst über TCP-Port 80 sendet, wird die Anfrage an einen Mitglieds-Pod am TCP-Port 8080 weitergeleitet.
Jeder Mitglieds-Pod muss über einen Container verfügen, der TCP-Port 8080 überwacht.

Standardmäßig überwacht der Container hello-app den TCP-Port 8080. Sehen Sie sich das Dockerfile und den Quellcode für die Anwendung an.

Speichern Sie das Manifest in einer Datei mit dem Namen my-service.yaml und erstellen Sie den Dienst:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG apply -f my-service.yaml

Dabei ist USER_CLUSTER_KUBECONFIG der Pfad der kubeconfig-Datei für Ihren Nutzercluster.

Wenn Sie den Dienst erstellen, konfiguriert Google Distributed Cloud automatisch die loadBalancerIP-Adresse auf dem Cluster-Load-Balancer.

Ihren Dienst aufrufen:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get service my-service --output yaml

Die Ausgabe sieht etwa so aus:

kind: Service
metadata:
  ...
  name: my-service
  namespace: default
  ...
spec:
  allocateLoadBalancerNodePorts: true
  clusterIP: 10.96.1.39
  clusterIPs:
  - 10.96.1.39
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 31184
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: metrics
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.1

In der vorherigen Ausgabe sehen Sie, dass Ihr Dienst eine clusterIP und eine loadBalancerIP hat. Er hat auch eine port und eine targetPort.

Die clusterIP ist für diese Übung nicht relevant. loadBalancerIP ist die IP-Adresse, die Clients außerhalb des Clusters zum Aufrufen des Service verwenden können.

Nehmen Sie als Beispiel die in der vorherigen Ausgabe angezeigten Werte. Angenommen, Ihr Dienst hat loadBalancerIP = 203.0.113.1, port = 80 und targetPort = 8080.

Ein Client sendet über TCP-Port 80 eine Anfrage an 203.0.113.1. Die Anfrage wird an den Cluster-Load-Balancer weitergeleitet. Der Load-Balancer leitet die Anfrage an einen Mitglieds-Pod am TCP-Port 8080 weiter.

Rufen Sie Ihren Dienst auf:

curl LOAD_BALANCER_IP

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

curl 203.0.113.1
Hello, world!
Version: 2.0.0
Hostname: my-deployment-dbd86c8c4-9wpbv

Service löschen

Löschen Sie den Service:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete service my-service

Prüfen Sie, ob Ihr Dienst gelöscht wurde:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get services

Die Ausgabe zeigt my-service nicht mehr an.

Deployment löschen

Löschen Sie Ihr Deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete deployment my-deployment

Prüfen Sie, ob Ihr Deployment gelöscht wurde:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get deployments

Die Ausgabe zeigt my-deployment nicht mehr an.

Nächste Schritte

Service und Ingress erstellen

Anwendung bereitstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.