Anwendung bereitstellen

In diesem Dokument wird beschrieben, wie Sie eine Anwendung in GKE on Bare Metal 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 können Sie ein Deployment in Ihrem Cluster erstellen:

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

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

  3. Rufen Sie grundlegende Informationen zu Ihrem Deployment ab, um zu bestätigen, dass 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

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

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

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

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.

So erstellen Sie einen Service vom Typ LoadBalancer:

  1. 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 in Bezug auf den Dienst in dieser Übung berücksichtigen 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 diese Porteinstellung im Dockerfile und im Quellcode der Anwendung sehen.

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

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

    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 Load-Balancer-Adresspools (spec.loadBalancer.addressPools) in der Clusterkonfigurationsdatei angegeben haben.

    Nehmen Sie als Beispiel die Werte, die in der vorherigen Ausgabe für Ihren Dienst angezeigt wurden:

    • 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 und von dort an einen Mitglieds-Pod am TCP-Port 8080 weitergeleitet.

  4. 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 (status.loadBalancer.ingress) abgerufen haben.

    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. Diese Zuweisungen können die verfügbaren Knotenports von den 2.768, die Ihrem Cluster zugewiesen sind, schnell erschöpfen. Wenn Sie Knotenports speichern möchten, deaktivieren Sie die Portzuweisung für Load-Balancer-Knoten. 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 in der Kubernetes-Dokumentation unter Load-Balancer-NodePort-Zuweisung deaktivieren.

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:

  1. Löschen Sie mit kubectl delete Ihren Service aus Ihrem Cluster:

    kubectl delete service my-service --kubeconfig CLUSTER_KUBECONFIG

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

    kubectl get services --kubeconfig CLUSTER_KUBECONFIG

    Die Ausgabe zeigt my-service nicht mehr an.

Bereitstellung löschen

So löschen Sie Ihr Deployment:

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