Anthos Clusters on Bare Metal sind jetzt Google Distributed Cloud (nur Software) für Bare Metal. Weitere Informationen finden Sie in der Produktübersicht.

Diese Seite wurde von der Cloud Translation API übersetzt.

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, der Arbeitslasten ausführen kann.

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"

Verwenden Sie kubectl apply, um das Deployment zu erstellen:
```
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 Service 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 Dinge, die Sie in dieser Übung über den Dienst verstehen 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 über den TCP-Port 80 an den Dienst sendet, wird die Anfrage an einen Mitglieds-Pod am TCP-Port 8080 weitergeleitet.
- Jeder Mitglieds-Pod muss einen Container haben, der den TCP-Port 8080 überwacht.
Standardmäßig überwacht der Container hello-app den TCP-Port 8080. Sie können sich diese Porteinstellung im Dockerfile und im Quellcode der Anwendung ansehen.
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. Es hat auch ein nodePort, ein port und ein targetPort.

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

Nehmen Sie als Beispiel die Werte, die in der vorherigen Ausgabe für Ihren Dienst angezeigt werden:
- Externe IP-Adresse: 192.168.1.13
- port: 80
- nodePort: 31565
- targetPort: 8080
Ein Client sendet über den 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 am TCP-Port 8080 weitergeleitet.
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 schnell von den 2.768 zugewiesenen Ports Ihres Clusters aufgebraucht werden. Wenn Sie Knotenports speichern möchten, deaktivieren Sie die Portzuweisung für Load-Balancer. Dazu setzen Sie das Feld allocateLoadBalancerNodePorts in der LoadBalancer-Dienstspezifikation auf false. Diese Einstellung verhindert, dass Kubernetes LoadBalancer-Diensten Knotenports zuweist. Weitere Informationen finden Sie unter NodePort-Zuweisung des Load-Balancers deaktivieren in der Kubernetes-Dokumentation.

Hier ist ein Manifest zum Erstellen eines Service, 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

Dienst 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 ein Deployment:

Löschen Sie mit kubectl delete das Deployment aus dem Cluster:
```
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