Über einen Connector auf Kubernetes API-Objekte zugreifen

Ein Google Kubernetes Engine-Cluster (GKE-Cluster) besteht aus einer Steuerungsebene und Worker-Maschinen, die Knoten genannt werden. Sie können Ihre containerisierten Kubernetes-Arbeitslasten in einem GKE-Cluster ausführen. Knoten sind die Worker-Maschinen, auf denen Ihre Containeranwendungen und andere Arbeitslasten ausgeführt werden. Die Steuerungsebene ist der einheitliche Endpunkt für Ihren Cluster. Weitere Informationen finden Sie unter GKE-Clusterarchitektur.

Der Kubernetes API-Server wird auf der Steuerungsebene ausgeführt. So können Sie über Kubernetes API-Aufrufe mit Kubernetes-Objekten im Cluster interagieren. Objekte sind persistente Einheiten im Kubernetes-System und stellen den Status Ihres Clusters dar. Weitere Informationen finden Sie in der Kubernetes-Dokumentation unter Objects in Kubernetes und in der API-Übersicht, in der auf die Seiten der „Kubernetes API-Referenz“ verwiesen wird.

In diesem Dokument wird beschrieben, wie Sie den Kubernetes API-Connector in einem Workflow verwenden, um Anfragen an den Kubernetes-Dienstendpunkt zu senden, der auf der Steuerungsebene eines GKE-Clusters gehostet wird. Sie können den Connector beispielsweise verwenden, um Kubernetes-Deployments zu erstellen, Jobs auszuführen, Pods zu verwalten oder über einen Proxy auf bereitgestellte Apps zuzugreifen. Weitere Informationen finden Sie in der Übersicht über den Kubernetes API Connector.

Hinweise

Bevor Sie mit den Aufgaben in diesem Dokument fortfahren, müssen Sie bestimmte Voraussetzungen erfüllen.

APIs aktivieren

Bevor Sie mit dem Kubernetes API-Connector auf Kubernetes API-Objekte zugreifen können, müssen Sie die folgenden APIs aktivieren:

  • Google Kubernetes Engine API: zum Erstellen und Verwalten containerbasierter Anwendungen mit GKE

  • Workflows APIs: zum Verwalten von Workflowdefinitionen und -ausführungen. Wenn Sie die Workflows API aktivieren, wird die Workflow Executions API automatisch aktiviert.

Console

APIs aktivieren:

APIs aktivieren

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. APIs aktivieren:

    gcloud services enable container.googleapis.com workflows.googleapis.com

Dienstkonto erstellen

Erstellen Sie ein vom Nutzer verwaltetes Dienstkonto, das als Identität Ihres Workflows dient, und weisen Sie ihm die Rolle Kubernetes Engine-Entwickler (roles/container.developer) zu, damit der Workflow auf Kubernetes API-Objekte in Clustern zugreifen kann.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Dienstkonten auf.

    Zur Seite „Dienstkonten“

  2. Wählen Sie ein Projekt aus und klicken Sie auf Dienstkonto erstellen.

  3. Geben Sie im Feld Dienstkontoname einen Namen ein. Die Google Cloud-Konsole füllt das Feld Dienstkonto-ID anhand dieses Namens aus.

    Geben Sie im Feld Dienstkontobeschreibung eine Beschreibung ein. Beispiel: Service account for Kubernetes API

  4. Klicken Sie auf Erstellen und fortfahren.

  5. Filtern Sie in der Liste Rolle auswählen nach der Rolle Kubernetes Engine-Entwickler und wählen Sie sie aus.

  6. Klicken Sie auf Weiter.

  7. Klicken Sie zum Abschließen der Erstellung des Kontos auf Fertig.

gcloud

  1. Erstellen Sie das Dienstkonto:

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

    Ersetzen Sie SERVICE_ACCOUNT_NAME durch den Namen des Dienstkontos.

  2. Weisen Sie Ihrem Dienstkonto die Rolle container.developer zu:

    gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --role=roles/container.developer

    Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID. Google Cloud

Sie können sowohl IAM als auch die rollenbasierte Zugriffssteuerung von Kubernetes (Role-based Access Control, RBAC) verwenden, um den Zugriff auf Ihren GKE-Cluster zu steuern:

  • IAM ist kein spezifisches Kubernetes-Produkt. Es bietet eine Identitätsverwaltung für mehrere Google Cloud -Produkte und wird hauptsächlich auf Ebene des Google Cloud -Projekts verwendet.

  • Kubernetes RBAC ist eine Kernkomponente von Kubernetes, die es Ihnen ermöglicht, Rollen (spezifische Berechtigungen) für jedes Objekt oder jeden Objekttyp im Cluster zu erstellen und zu gewähren. Wenn Sie überwiegend GKE verwenden und für jedes Objekt und jeden Vorgang innerhalb des Clusters detaillierte Berechtigungen benötigen, ist Kubernetes RBAC die beste Wahl.

Weitere Informationen finden Sie unter Zugriffssteuerung.

GKE-Cluster erstellen

Wenn Sie den Kubernetes API-Connector verwenden möchten, müssen Sie bereits einen öffentlichen oder privaten GKE-Cluster erstellt haben. In einem privaten Cluster haben Knoten nur interne IP-Adressen. Das heißt, Knoten und Pods sind standardmäßig vom Internet isoliert. Weitere Informationen finden Sie unter Private Cluster.

Sie können auch den Betriebsmodus angeben, der Ihnen unterschiedliche Flexibilität, Verantwortung und Kontrolle bietet. Sie können beispielsweise einen Autopilot-Cluster erstellen. Das ist ein Betriebsmodus in GKE, in dem Google Ihre Clusterkonfiguration verwaltet, einschließlich Knoten, Skalierung, Sicherheit und anderer vorkonfigurierter Einstellungen. Weitere Informationen finden Sie unter GKE-Betriebsmodus auswählen.

Wenn Sie noch keinen GKE-Cluster erstellt haben, können Sie eine containerisierte Webserveranwendung in einem GKE-Cluster bereitstellen. Wenn Sie die Anleitung in diesem Dokument ausprobieren möchten, können Sie einen Autopilot-Cluster erstellen, indem Sie die folgenden Schritte ausführen.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Kubernetes-Cluster auf.

    Zur Seite "Kubernetes-Cluster"

  2. Klicken Sie auf Erstellen.

  3. Wenn Sie aufgefordert werden, einen Clustermodus auszuwählen, wählen Sie Autopilot aus.

  4. Geben Sie im Bereich Clustergrundlagen Folgendes ein:

    1. Geben Sie den Namen für den Cluster ein, z. B. hello-cluster.
    2. Wählen Sie eine Region für den Cluster aus, z. B. us-central1.

  5. Klicken Sie auf Weiter: Netzwerk.

  6. Wählen Sie im Bereich IPv4-Netzwerkzugriff die Option Öffentlicher Cluster aus, um einen Cluster mit einem öffentlich zugänglichen Endpunkt zu erstellen.

  7. Übernehmen Sie für alle anderen Einstellungen die Standardwerte.

  8. Klicken Sie auf Erstellen.

Es kann einige Minuten dauern, bis der Cluster erstellt ist. Nachdem der Cluster erstellt wurde, weist ein Häkchen  darauf hin, dass er ausgeführt wird.

gcloud

Führen Sie dazu diesen Befehl aus:

gcloud container clusters create-auto CLUSTER_NAME \
    --location=LOCATION \
    --project=PROJECT_ID

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: Der Name Ihres GKE-Clusters, z. B. hello-cluster
  • LOCATION: Die Region für Ihren Cluster, z. B. us-central1.
  • PROJECT_ID: Ihre Google Cloud -Projekt-ID

Es kann einige Minuten dauern, bis der Cluster erstellt ist. Nachdem der Cluster erstellt wurde, sollte die Ausgabe in etwa so aussehen:

Creating cluster hello-cluster...done.
Created [https://container.googleapis.com/v1/projects/MY_PROJECT/zones/us-central1/clusters/hello-cluster].
[...]
STATUS: RUNNING

Connector zum Senden einer HTTP-Anfrage verwenden

Mit dem Kubernetes API-Connector können Sie eine HTTP-Anfrage an die Steuerungsebene eines GKE-Cluster senden. Mit dem folgenden Workflow wird beispielsweise ein Deployment mit dem Namen nginx-deployment im angegebenen Kubernetes-Cluster erstellt. Das Deployment beschreibt einen erforderlichen Status. In diesem Fall sollen drei Pods mit dem nginx:1.14.2-Image ausgeführt und ihr Dienst an Port 80 bereitgestellt werden. Wenn nicht angegeben, werden die Standardwerte für project und location aus dem Workflow übernommen.

Weitere Informationen finden Sie auf der Referenzseite für die Funktion „Kubernetes API-Connector“ gke.request.

Wichtige Hinweise:

Workflow bereitstellen

Bevor Sie einen Workflow ausführen können, müssen Sie ihn erstellen und bereitstellen.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Workflows auf.

    Zur Seite "Workflows"

  2. Klicken Sie auf  Erstellen.

  3. Geben Sie einen Namen für den neuen Workflow ein, z. B. kubernetes-api-request.

  4. Wählen Sie in der Liste Region die Option us-central1 aus.

  5. Wählen Sie das Dienstkonto aus, das Sie zuvor erstellt haben.

  6. Klicken Sie auf Weiter.

  7. Geben Sie im Workflow-Editor die folgende Definition für Ihren Workflow ein:

    YAML

    main:
  steps:
    - create_deployment:
        call: gke.request
        args:
          cluster_id: "CLUSTER_NAME"
          project: "PROJECT_ID"
          location: "LOCATION"
          method: "POST"
          path: "/apis/apps/v1/namespaces/default/deployments"
          body:
            kind: Deployment
            metadata:
              name: nginx-deployment
              labels:
                app: nginx
            spec:
              replicas: 3
              selector:
                matchLabels:
                  app: nginx
              template:
                metadata:
                  labels:
                    app: nginx
                spec:
                  containers:
                    - name: nginx
                      image: nginx:1.14.2
                      ports:
                        - containerPort: 80
        result: result
    - returnResult:
        return: '${result}'

    JSON

    {
  "main": {
    "steps": [
      {
        "create_deployment": {
          "call": "gke.request",
          "args": {
            "cluster_id": "CLUSTER_NAME",
            "project": "PROJECT_ID",
            "location": "LOCATION",
            "method": "POST",
            "path": "/apis/apps/v1/namespaces/default/deployments",
            "body": {
              "kind": "Deployment",
              "metadata": {
                "name": "nginx-deployment",
                "labels": {
                  "app": "nginx"
                }
              },
              "spec": {
                "replicas": 3,
                "selector": {
                  "matchLabels": {
                    "app": "nginx"
                  }
                },
                "template": {
                  "metadata": {
                    "labels": {
                      "app": "nginx"
                    }
                  },
                  "spec": {
                    "containers": [
                      {
                        "name": "nginx",
                        "image": "nginx:1.14.2",
                        "ports": [
                          {
                            "containerPort": 80
                          }
                        ]
                      }
                    ]
                  }
                }
              }
            }
          },
          "result": "result"
        }
      },
      {
        "returnResult": {
          "return": "${result}"
        }
      }
    ]
  }
}

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres GKE-Clusters, z. B. hello-cluster
    • PROJECT_ID: Ihre Google Cloud -Projekt-ID
    • LOCATION: Die Region für Ihren Cluster, z. B. us-central1.

  8. Klicken Sie auf Bereitstellen.

gcloud

  1. Erstellen Sie eine Quellcodedatei für Ihren Workflow:

    touch kubernetes-api-request.JSON_OR_YAML

    Ersetzen Sie JSON_OR_YAML durch yaml oder json, je nach Format Ihres Workflows.

  2. Kopieren Sie den folgenden Workflow in einem Texteditor in Ihre Quellcodedatei:

    YAML

    main:
  steps:
    - create_deployment:
        call: gke.request
        args:
          cluster_id: "CLUSTER_NAME"
          project: "PROJECT_ID"
          location: "LOCATION"
          method: "POST"
          path: "/apis/apps/v1/namespaces/default/deployments"
          body:
            kind: Deployment
            metadata:
              name: nginx-deployment
              labels:
                app: nginx
            spec:
              replicas: 3
              selector:
                matchLabels:
                  app: nginx
              template:
                metadata:
                  labels:
                    app: nginx
                spec:
                  containers:
                    - name: nginx
                      image: nginx:1.14.2
                      ports:
                        - containerPort: 80
        result: result
    - returnResult:
        return: '${result}'

    JSON

    {
  "main": {
    "steps": [
      {
        "create_deployment": {
          "call": "gke.request",
          "args": {
            "cluster_id": "CLUSTER_NAME",
            "project": "PROJECT_ID",
            "location": "LOCATION",
            "method": "POST",
            "path": "/apis/apps/v1/namespaces/default/deployments",
            "body": {
              "kind": "Deployment",
              "metadata": {
                "name": "nginx-deployment",
                "labels": {
                  "app": "nginx"
                }
              },
              "spec": {
                "replicas": 3,
                "selector": {
                  "matchLabels": {
                    "app": "nginx"
                  }
                },
                "template": {
                  "metadata": {
                    "labels": {
                      "app": "nginx"
                    }
                  },
                  "spec": {
                    "containers": [
                      {
                        "name": "nginx",
                        "image": "nginx:1.14.2",
                        "ports": [
                          {
                            "containerPort": 80
                          }
                        ]
                      }
                    ]
                  }
                }
              }
            }
          },
          "result": "result"
        }
      },
      {
        "returnResult": {
          "return": "${result}"
        }
      }
    ]
  }
}

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres GKE-Clusters, z. B. hello-cluster
    • LOCATION: Die Region für Ihren Cluster, z. B. us-central1.

  3. Stellen Sie den Workflow bereit:

    gcloud workflows deploy kubernetes-api-request \
    --source=kubernetes-api-request.JSON_OR_YAML \
    --location=LOCATION \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Workflow ausführen

Nachdem Sie Ihren Workflow erfolgreich bereitgestellt haben, können Sie ihn ausführen. Bei der Ausführung eines Workflows wird die aktuelle Workflowdefinition ausgeführt, die dem Workflow zugeordnet ist.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Workflows auf.

    Zur Seite "Workflows"

  2. Wählen Sie auf der Seite Workflows Ihren Workflow aus, um die zugehörige Detailseite aufzurufen.

  3. Klicken Sie auf der Seite Workflow-Details auf  Ausführen.

  4. Klicken Sie noch einmal auf Ausführen.

  5. Sehen Sie sich die Ergebnisse des Workflows im Bereich Ausgabe an.

    Wenn der Vorgang erfolgreich ist, sollte der Ausführungsstatus Succeeded sein und der Text der Antwort wird zurückgegeben.

gcloud

Führen Sie den Workflow aus:

gcloud workflows run kubernetes-api-request \
    --location=LOCATION

Bei Erfolg sollte der Status SUCCEEDED sein und der Antworttext wird zurückgegeben.

Connector zum Ausführen eines Kubernetes-Jobs verwenden

Mit dem Kubernetes API-Connector können Sie einen Kubernetes-Job in einem GKE-Cluster bereitstellen und ausführen. Im folgenden Workflow wird ein Kubernetes-Job erstellt, der ein Bash-Script ausführt, das eine Reihe von Zahlen durchläuft. Der Workflow wartet bis zu 90 Sekunden, bis der Kubernetes-Job abgeschlossen ist. Andernfalls wird ein Fehler ausgegeben. Wenn der Job abgeschlossen ist, wird er gelöscht.

Ein Job gilt als abgeschlossen, wenn sein Status den Bedingungstyp Complete enthält. Beispiel:

  "status": {
    "conditions": [
      {
        "type": "Complete",
        "status": "True"
      }
    ]
  }

Wenn der Job fehlschlägt, wird ein FailedJobError-Tag zurückgegeben. Beispiel: 

{
  "tags": ["FailedJobError"]
  "job": {...}
  "message":"Kubernetes job failed"
}

Weitere Informationen finden Sie auf den Referenzseiten für die folgenden Kubernetes API-Connector-Funktionen:

Workflow bereitstellen

Bevor Sie einen Workflow ausführen können, müssen Sie ihn erstellen und bereitstellen.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Workflows auf.

    Zur Seite "Workflows"

  2. Klicken Sie auf  Erstellen.

  3. Geben Sie einen Namen für den neuen Workflow ein, z. B. kubernetes-api-job.

  4. Wählen Sie in der Liste Region die Option us-central1 aus.

  5. Wählen Sie das Dienstkonto aus, das Sie zuvor erstellt haben.

  6. Klicken Sie auf Weiter.

  7. Geben Sie im Workflow-Editor die folgende Definition für Ihren Workflow ein:

    YAML

    main:
  steps:
    - init:
        assign:
          - project: "PROJECT_ID"
          - location: "LOCATION"
          - cluster_id: "CLUSTER_NAME"
          - job_name: "JOB_NAME"
          - namespace: "default"
    - create_job:
        call: gke.create_job
        args:
          cluster_id: '${cluster_id}'
          location: '${location}'
          project: '${project}'
          namespace: '${namespace}'
          job:
            apiVersion: batch/v1
            kind: Job
            metadata:
              name: "${job_name}"
            spec:
              template:
                spec:
                  containers:
                    - name: counter
                      image: centos:7
                      command:
                        - "bin/bash"
                        - "-c"
                        - "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                  restartPolicy: Never
        result: job
    - wait_for_job:  # if job fails, raise error with "FailedJobError" tag and "job" field
        call: gke.await_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          timeout: 90  # 90 seconds
        result: completed_job
    - cleanup_job:
        call: gke.delete_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          query:
            propagationPolicy: "Foreground"  # delete child Pods
    - return_job:
        return: '${completed_job}'

    JSON

    {
  "main": {
    "steps": [
      {
        "init": {
          "assign": [
            {
              "project": "PROJECT_ID"
            },
            {
              "location": "LOCATION"
            },
            {
              "cluster_id": "CLUSTER_NAME"
            },
            {
              "job_name": "JOB_NAME"
            },
            {
              "namespace": "default"
            }
          ]
        }
      },
      {
        "create_job": {
          "call": "gke.create_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "location": "${location}",
            "project": "${project}",
            "namespace": "${namespace}",
            "job": {
              "apiVersion": "batch/v1",
              "kind": "Job",
              "metadata": {
                "name": "${job_name}"
              },
              "spec": {
                "template": {
                  "spec": {
                    "containers": [
                      {
                        "name": "counter",
                        "image": "centos:7",
                        "command": [
                          "bin/bash",
                          "-c",
                          "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                        ]
                      }
                    ],
                    "restartPolicy": "Never"
                  }
                }
              }
            }
          },
          "result": "job"
        }
      },
      {
        "wait_for_job": {
          "call": "gke.await_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "timeout": 90
          },
          "result": "completed_job"
        }
      },
      {
        "cleanup_job": {
          "call": "gke.delete_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "query": {
              "propagationPolicy": "Foreground"
            }
          }
        }
      },
      {
        "return_job": {
          "return": "${completed_job}"
        }
      }
    ]
  }
}

    Ersetzen Sie Folgendes:

    • LOCATION: Die Region für Ihren Cluster, z. B. us-central1.
    • CLUSTER_NAME: Der Name Ihres GKE-Clusters, z. B. hello-cluster
    • JOB_NAME: der Name des Kubernetes-Jobs, z. B. hello-job

  8. Klicken Sie auf Bereitstellen.

gcloud

  1. Erstellen Sie eine Quellcodedatei für Ihren Workflow:

    touch kubernetes-api-job.JSON_OR_YAML

    Ersetzen Sie JSON_OR_YAML durch yaml oder json, je nach Format Ihres Workflows.

  2. Kopieren Sie den folgenden Workflow in einem Texteditor in Ihre Quellcodedatei:

    YAML

    main:
  steps:
    - init:
        assign:
          - project: "PROJECT_ID"
          - location: "LOCATION"
          - cluster_id: "CLUSTER_NAME"
          - job_name: "JOB_NAME"
          - namespace: "default"
    - create_job:
        call: gke.create_job
        args:
          cluster_id: '${cluster_id}'
          location: '${location}'
          project: '${project}'
          namespace: '${namespace}'
          job:
            apiVersion: batch/v1
            kind: Job
            metadata:
              name: "${job_name}"
            spec:
              template:
                spec:
                  containers:
                    - name: counter
                      image: centos:7
                      command:
                        - "bin/bash"
                        - "-c"
                        - "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                  restartPolicy: Never
        result: job
    - wait_for_job:  # if job fails, raise error with "FailedJobError" tag and "job" field
        call: gke.await_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          timeout: 90  # 90 seconds
        result: completed_job
    - cleanup_job:
        call: gke.delete_job
        args:
          cluster_id: '${cluster_id}'
          job_name: '${job_name}'
          location: '${location}'
          project: '${project}'
          query:
            propagationPolicy: "Foreground"  # delete child Pods
    - return_job:
        return: '${completed_job}'

    JSON

    {
  "main": {
    "steps": [
      {
        "init": {
          "assign": [
            {
              "project": "PROJECT_ID"
            },
            {
              "location": "LOCATION"
            },
            {
              "cluster_id": "CLUSTER_NAME"
            },
            {
              "job_name": "JOB_NAME"
            },
            {
              "namespace": "default"
            }
          ]
        }
      },
      {
        "create_job": {
          "call": "gke.create_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "location": "${location}",
            "project": "${project}",
            "namespace": "${namespace}",
            "job": {
              "apiVersion": "batch/v1",
              "kind": "Job",
              "metadata": {
                "name": "${job_name}"
              },
              "spec": {
                "template": {
                  "spec": {
                    "containers": [
                      {
                        "name": "counter",
                        "image": "centos:7",
                        "command": [
                          "bin/bash",
                          "-c",
                          "for i in 9 8 7 6 5 4 3 2 1 ; do echo $i ; done"
                        ]
                      }
                    ],
                    "restartPolicy": "Never"
                  }
                }
              }
            }
          },
          "result": "job"
        }
      },
      {
        "wait_for_job": {
          "call": "gke.await_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "timeout": 90
          },
          "result": "completed_job"
        }
      },
      {
        "cleanup_job": {
          "call": "gke.delete_job",
          "args": {
            "cluster_id": "${cluster_id}",
            "job_name": "${job_name}",
            "location": "${location}",
            "project": "${project}",
            "query": {
              "propagationPolicy": "Foreground"
            }
          }
        }
      },
      {
        "return_job": {
          "return": "${completed_job}"
        }
      }
    ]
  }
}

    Ersetzen Sie Folgendes:

    • LOCATION: Die Region für Ihren Cluster, z. B. us-central1.
    • CLUSTER_NAME: Der Name Ihres GKE-Clusters, z. B. hello-cluster
    • JOB_NAME: der Name des Kubernetes-Jobs, z. B. hello-job

  3. Stellen Sie den Workflow bereit:

    gcloud workflows deploy kubernetes-api-job \
    --source=kubernetes-api-job.JSON_OR_YAML \
    --location=LOCATION \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Workflow ausführen

Nachdem Sie Ihren Workflow erfolgreich bereitgestellt haben, können Sie ihn ausführen. Bei der Ausführung eines Workflows wird die aktuelle Workflowdefinition ausgeführt, die dem Workflow zugeordnet ist.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Workflows auf.

    Zur Seite "Workflows"

  2. Wählen Sie auf der Seite Workflows Ihren Workflow aus, um die zugehörige Detailseite aufzurufen.

  3. Klicken Sie auf der Seite Workflow-Details auf  Ausführen.

  4. Klicken Sie noch einmal auf Ausführen.

    Die Ausführung des Workflows kann einige Minuten dauern.

  5. Sehen Sie sich die Ergebnisse des Workflows im Bereich Ausgabe an.

    Die Ergebnisse sollten in etwa so aussehen:

    {
...
  },
  "status": {
    "completionTime": "2023-10-31T17:04:32Z",
    "conditions": [
      {
        "lastProbeTime": "2023-10-31T17:04:33Z",
        "lastTransitionTime": "2023-10-31T17:04:33Z",
        "status": "True",
        "type": "Complete"
      }
    ],
    "ready": 0,
    "startTime": "2023-10-31T17:04:28Z",
    "succeeded": 1,
    "uncountedTerminatedPods": {}
  }
}

gcloud

Führen Sie den Workflow aus:

gcloud workflows run kubernetes-api-job \
    --location=LOCATION

Die Ausführung des Workflows kann einige Minuten dauern. Die Ergebnisse sollten in etwa so aussehen:

{
...
  },
  "status": {
    "completionTime": "2023-10-31T17:04:32Z",
    "conditions": [
      {
        "lastProbeTime": "2023-10-31T17:04:33Z",
        "lastTransitionTime": "2023-10-31T17:04:33Z",
        "status": "True",
        "type": "Complete"
      }
    ],
    "ready": 0,
    "startTime": "2023-10-31T17:04:28Z",
    "succeeded": 1,
    "uncountedTerminatedPods": {}
  }
}

Nächste Schritte