Anwendung bereitstellen

In diesem Dokument wird beschrieben, wie Sie eine Anwendung in Google Distributed Cloud bereitstellen.

Hinweise

Zum Bereitstellen einer Arbeitslast benötigen Sie einen Nutzer-, Hybrid- oder eigenständigen Cluster, auf dem Arbeitslasten ausgeführt werden können.

Deployment erstellen

Mit den folgenden Schritten erstellen Sie ein Deployment in Ihrem Cluster:

Kopieren Sie dann das folgende Manifest in eine Datei mit dem Namen my-deployment.yaml.

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"

Erstellen Sie das Deployment mit kubectl apply:
```
kubectl apply -f my-deployment.yaml --kubeconfig CLUSTER_KUBECONFIG
```
Ersetzen Sie CLUSTER_KUBECONFIG durch den Pfad der kubeconfig-Datei für Ihren Cluster.
Rufen Sie grundlegende Informationen zu Ihrem Deployment ab, um zu prüfen, ob es erfolgreich erstellt wurde:
```
kubectl get deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG
```
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 get pods --kubeconfig CLUSTER_KUBECONFIG

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

NAME                             READY   STATUS    RESTARTS   AGE
my-deployment-869f65669b-5259x   1/1     Running   0          34s
my-deployment-869f65669b-9xfrs   1/1     Running   0          34s
my-deployment-869f65669b-wn4ft   1/1     Running   0          34s

Rufen Sie detaillierte Informationen zu Ihrem Deployment ab:

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

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

apiVersion: apps/v1
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: "2023-06-29T16:17:17Z"
    lastUpdateTime: "2023-06-29T16:17:17Z"
    message: Deployment has minimum availability.
    reason: MinimumReplicasAvailable
    status: "True"
    type: Available
  - lastTransitionTime: "2023-06-29T16:17:12Z"
    lastUpdateTime: "2023-06-29T16:17:17Z"
    message: ReplicaSet "my-deployment-869f65669b" has successfully progressed.
    reason: NewReplicaSetAvailable
    status: "True"
    type: Progressing
  observedGeneration: 1
  readyReplicas: 3
  replicas: 3
  updatedReplicas: 3

Beschreiben Sie Ihr Deployment:

kubectl describe deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG

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

Name:                   my-deployment
Namespace:              default
CreationTimestamp:      Thu, 29 Jun 2023 16:17:12 +0000
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
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:         <none>
    Host Port:    <none>
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   my-deployment-869f65669b (3/3 replicas created)
Events:
  Type    Reason             Age    From                   Message
  ----    ------             ----   ----                   -------
  Normal  ScalingReplicaSet  6m50s  deployment-controller  Scaled up replica set my-deployment-869f65669b to 3

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

So erstellen Sie einen Dienst vom Typ LoadBalancer:

Kopieren Sie dann das folgende Manifest in eine Datei mit dem Namen my-service.yaml.
```
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: metrics
    department: sales
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
```
Hier sind die wichtigsten Punkte, die Sie über den Dienst in dieser Übung wissen sollten:
- Jeder Pod mit dem Label 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. Sie finden diese Porteinstellung im Dockerfile und im Quellcode der Anwendung.
Verwenden Sie kubectl apply, um den Dienst in Ihrem Cluster zu erstellen:
```
kubectl apply -f my-service.yaml --kubeconfig CLUSTER_KUBECONFIG
```
Ersetzen Sie CLUSTER_KUBECONFIG durch den Pfad der kubeconfig-Datei für Ihren Cluster.
Ihren Dienst aufrufen:
```
kubectl get service my-service --output yaml --kubeconfig CLUSTER_KUBECONFIG
```
Die Ausgabe sieht in etwa so aus:
```
apiVersion: v1
kind: Service
metadata:
  ...
  name: my-service
  namespace: default
  ...
spec:
  allocateLoadBalancerNodePorts: true
  clusterIP: 10.96.2.165
  clusterIPs:
  - 10.96.2.165
  externalTrafficPolicy: Cluster
  internalTrafficPolicy: Cluster
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - nodePort: 31565
    port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    app: metrics
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 192.168.1.13
```
In der vorherigen Ausgabe sehen Sie, dass Ihr Dienst eine clusterIP und eine externe IP-Adresse hat. Er hat auch einen nodePort, einen port und einen targetPort.

Die clusterIP ist für diese Übung nicht relevant. Die externe IP-Adresse (status.loadBalancer.ingress.ip) stammt aus dem Adressbereich, den Sie beim Definieren von Load Balancer-Adresspools (spec.loadBalancer.addressPools) in der Clusterkonfigurationsdatei angegeben haben.

Nehmen Sie als Beispiel die in der vorherigen Ausgabe für Ihren Dienst angezeigten Werte:
- Externe IP-Adresse: 192.168.1.13
- port: 80
- nodePort: 31565
- targetPort: 8080
Ein Client sendet über TCP-Port 80 eine Anfrage an 192.168.1.13. Die Anfrage wird an Ihren Load Balancer weitergeleitet und von dort an einen Mitglieds-Pod an TCP-Port 8080.
Rufen Sie Ihren Dienst auf:
```
curl INGRESS_IP_ADDRESS
```
Ersetzen Sie INGRESS_IP_ADDRESS durch die Ingress-IP-Adresse im Abschnitt status des Dienstes, die Sie im vorherigen Schritt abgerufen haben (status.loadBalancer.ingress).

In der Ausgabe wird die Meldung Hello, world! angezeigt:
```
Hello, world!
Version: 2.0.0
Hostname: my-deployment-869f65669b-wn4ft
```

LoadBalancer-Portlimits

Der Typ LoadBalancer ist eine Erweiterung des Typs NodePort. Ein Dienst vom Typ LoadBalancer hat also eine Cluster-IP-Adresse und einen oder mehrere nodePort-Werte. Standardmäßig weist Kubernetes Diensten vom Typ LoadBalancer Knotenports zu. Durch diese Zuweisungen können die verfügbaren Knotenports (2.768 Ports sind Ihrem Cluster zugewiesen) schnell aufgebraucht werden. Wenn Sie Knotenports sparen möchten, deaktivieren Sie die Zuordnung von Load Balancer-Knotenports, indem Sie in der LoadBalancer-Dienstspezifikation das Feld allocateLoadBalancerNodePorts auf false festlegen. Mit dieser Einstellung verhindert Kubernetes, dass LoadBalancer-Diensten Knotenports zugewiesen werden. Weitere Informationen finden Sie in der Kubernetes-Dokumentation unter Zuweisung von NodePorts für Load Balancer deaktivieren.

Hier ist ein Manifest zum Erstellen eines Dienstes, der keine Knotenports verwendet:

apiVersion: v1
kind: Service
metadata:
  name: service-does-not-use-nodeports
spec:
  selector:
    app: my-app
  type: LoadBalancer
  ports:
  - port: 8000
  # Set allocateLoadBalancerNodePorts to false
  allocateLoadBalancerNodePorts: false

Service löschen

So löschen Sie Ihren Dienst:

Verwenden Sie kubectl delete, um den Dienst aus Ihrem Cluster zu löschen:
```
kubectl delete service my-service --kubeconfig CLUSTER_KUBECONFIG
```
Prüfen Sie, ob Ihr Dienst gelöscht wurde:
```
kubectl get services --kubeconfig CLUSTER_KUBECONFIG
```
Die Ausgabe zeigt my-service nicht mehr an.

Deployment löschen

So löschen Sie Ihr Deployment:

Verwenden Sie kubectl delete, um das Deployment aus Ihrem Cluster zu löschen:
```
kubectl delete deployment my-deployment --kubeconfig CLUSTER_KUBECONFIG
```
Prüfen Sie, ob Ihr Deployment gelöscht wurde:
```
kubectl get deployments --kubeconfig CLUSTER_KUBECONFIG
```
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.