Diese Seite wurde von der Cloud Translation API übersetzt.

Über einen Connector auf Kubernetes API-Objekte zugreifen

Ein GKE-Cluster (Google Kubernetes Engine) besteht aus einer Steuerungsebene und Worker-Maschinen, die Knoten genannt werden. Sie können Ihre containerisierten Kubernetes-Arbeitslasten GKE-Cluster. Knoten sind die Worker-Maschinen, auf denen Ihre Containeranwendungen und anderen 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 interagieren mit Kubernetes-Objekten im Cluster über Kubernetes API-Aufrufe. Objekte sind persistente Entitäten im Kubernetes-System und stellen den Status Ihrer Cluster. Weitere Informationen finden Sie in der Kubernetes-Dokumentation unter Objekte in Kubernetes und in der API-Übersicht, die Links zu den Seiten der Kubernetes API-Referenz enthält.

In diesem Dokument erfahren Sie, 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 Kubernetes API-Connector

Hinweis

Bevor Sie mit den Aufgaben in diesem Dokument fortfahren, vergewissern Sie sich, dass Sie bestimmte Voraussetzungen erfüllt.

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 von containerbasierten Anwendungen mit GKE
Workflows APIs: zur Verwaltung von Workflowdefinitionen und executions; Wenn Sie die Workflows API aktivieren, Workflow Executions API

Console

APIs aktivieren:

APIs aktivieren

gcloud

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.

APIs aktivieren:

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

Dienstkonto erstellen

Ein nutzerverwaltetes Dienstkonto erstellen, das die Identität Ihres Workflows ist, und gewähren Sie ihm die Kubernetes Engine-Entwickler (roles/container.developer) Rolle, damit der Workflow auf Kubernetes zugreifen kann API-Objekte in Clustern.

Console

Rufen Sie in der Google Cloud Console die Seite Dienstkonten auf:

Zur Seite „Dienstkonten“
Wählen Sie ein Projekt aus und klicken Sie auf Dienstkonto erstellen.
Geben Sie im Feld Dienstkontoname einen Namen ein. Die Google Cloud Console füllt das Feld Dienstkonto-ID anhand dieses Namens aus.

Geben Sie im Feld Dienstkontobeschreibung eine Beschreibung ein. Beispiel: Service account for Kubernetes API
Klicken Sie auf Erstellen und fortfahren.
Filtern Sie in der Liste Rolle auswählen nach dem Kubernetes-Objekt und wählen Sie es aus. Engine-Entwickler haben.
Klicken Sie auf Weiter.
Klicken Sie zum Abschließen der Erstellung des Kontos auf Fertig.

gcloud

Erstellen Sie das Dienstkonto:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
Ersetzen Sie SERVICE_ACCOUNT_NAME durch den Namen des Dienstkontos.

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 die Google Cloud-Projekt-ID.

Sie können sowohl IAM als auch Kubernetes verwenden. Rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) zum Steuern des Zugriffs auf die GKE Cluster:

IAM ist nicht spezifisch für Kubernetes. Sie schafft Identität, Verwaltung mehrerer Google Cloud-Produkte und hauptsächlich auf Ebene des Google Cloud-Projekts.
Kubernetes RBAC ist eine Kernkomponente von Kubernetes, mit der Sie Rollen (Sätze von Berechtigungen) für jedes Objekt oder jeden Objekttyp gewähren innerhalb des Clusters. Wenn Sie hauptsächlich 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

Um den Kubernetes API-Connector verwenden zu können, müssen Sie bereits einen öffentlichen oder privaten GKE-Cluster. 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, ein Betriebsmodus in GKE in und Google verwaltet Ihre Clusterkonfiguration, einschließlich Knoten, Skalierung, Sicherheit und andere vorkonfigurierte Einstellungen. Weitere Informationen finden Sie unter GKE-Betriebsmodus auswählen

Wenn Sie noch keinen GKE-Cluster erstellt haben, können Sie Webserver-Containeranwendung bereitstellen zu einem GKE-Cluster. Wenn Sie die Anleitung in diesem Dokument ausprobieren möchten, können Sie auch einen Autopilot-Cluster erstellen. Gehen Sie dazu so vor:

Console

Rufen Sie in der Google Cloud Console die Seite mit den Kubernetes-Clustern auf.

Zur Seite „Kubernetes-Cluster“
Klicken Sie auf Erstellen.
Wenn Sie aufgefordert werden, einen Clustermodus auszuwählen, wählen Sie Autopilot aus.
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.
Klicken Sie auf Weiter: Netzwerk.
Erstellen Sie im Bereich IPv4-Netzwerkzugriff einen Cluster mit einem öffentlichen Endpunkt zugänglich machen möchten, wählen Sie Öffentlicher Cluster aus.
Übernehmen Sie für alle anderen Einstellungen die Standardeinstellungen.
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: 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

Über den Connector eine HTTP-Anfrage senden

Mit dem Kubernetes API-Connector können Sie eine HTTP-Anfrage an eine Steuerungsebene des GKE-Cluster. 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 ist es erforderlich, drei Pods mit dem nginx:1.14.2-Image auszuführen und den Dienst über Port 80 verfügbar zu machen. Wenn keine Angabe erfolgt, werden project und location standardmäßig auf die Werte des Workflows festgelegt.

Weitere Informationen finden Sie auf der Referenzseite für die Kubernetes API-Connectorfunktion gke.request.

Wichtige Hinweise:

Das Feld path entspricht dem Kubernetes API-Methodenpfad. Weitere Informationen finden Sie in der Kubernetes-Dokumentation API-Übersicht mit Link zu die Kubernetes API-Referenz Seiten.
Sie können HTTP-Anfragefehler in Ihrem Workflow abfangen und verarbeiten. Weitere Informationen finden Sie unter Workflowfehler:

Workflow bereitstellen

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

Console

Öffnen Sie in der Google Cloud Console die Seite Workflows.

Zur Seite "Workflows"
Klicken Sie auf Erstellen.
Geben Sie einen Namen für den neuen Workflow ein, z. B. kubernetes-api-request.
Wählen Sie in der Liste Region die Option us-central1 aus.
Wählen Sie das zuvor erstellte Dienstkonto aus.
Klicken Sie auf Weiter.

Geben Sie im Workflow-Editor die folgende Definition für den 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: 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

Klicken Sie auf Bereitstellen.

gcloud

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 des Workflows.

Kopieren Sie den folgenden Workflow in einen Texteditor und fügen Sie ihn in die Quellcodedatei 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: Name Ihres GKE-Clusters, z. B. hello-cluster
LOCATION: die Region für Ihren Cluster, z. B. us-central1

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 den Workflow 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

Öffnen Sie in der Google Cloud Console die Seite Workflows.

Zur Seite "Workflows"
Wählen Sie auf der Seite Workflows den gewünschten Workflow aus, um die Detailseite aufzurufen.
Klicken Sie auf der Seite Workflow-Details auf Ausführen.
Klicken Sie noch einmal auf Ausführen.
Sehen Sie sich die Ergebnisse des Workflows im Bereich Ausgabe an.

Bei Erfolg sollte der Ausführungsstatus Succeeded sein und der Antworttext 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.

Kubernetes-Job mit dem Connector ausführen

Mit dem Kubernetes API-Connector können Sie Kubernetes-Jobs in einem GKE-Cluster. Im folgenden Workflow wird ein Kubernetes-Job erstellt, der ein Bash-Script ausführt, das eine Zahlensequenz 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 folgende Kubernetes API Connector-Funktionen:

Workflow bereitstellen

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

Console

Öffnen Sie in der Google Cloud Console die Seite Workflows.

Zur Seite "Workflows"
Klicken Sie auf Erstellen.
Geben Sie einen Namen für den neuen Workflow ein, z. B. kubernetes-api-job.
Wählen Sie in der Liste Region die Option us-central1 aus.
Wählen Sie das zuvor erstellte Dienstkonto aus.
Klicken Sie auf Weiter.

Geben Sie im Workflow-Editor die folgende Definition für den 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: Name Ihres GKE-Clusters, z. B. hello-cluster
JOB_NAME: der Name des Kubernetes-Jobs, z. B. hello-job

Klicken Sie auf Bereitstellen.

gcloud

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 des Workflows.

Kopieren Sie den folgenden Workflow in einen Texteditor und fügen Sie ihn in die Quellcodedatei 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: Name Ihres GKE-Clusters, z. B. hello-cluster
JOB_NAME: der Name des Kubernetes-Jobs, z. B. als hello-job

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 den Workflow 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

Öffnen Sie in der Google Cloud Console die Seite Workflows.

Zur Seite "Workflows"
Wählen Sie auf der Seite Workflows den Workflow aus, um die zugehörige Detailseite aufzurufen.
Klicken Sie auf der Seite Workflow-Details auf Ausführen.
Klicken Sie noch einmal auf Ausführen.

Die Workflowausführung kann einige Minuten dauern.

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": {}
  }
}

Über einen Connector auf Kubernetes API-Objekte zugreifen

Hinweis

APIs aktivieren

Console

gcloud

Dienstkonto erstellen

Console

gcloud

GKE-Cluster erstellen

Console

gcloud

Über den Connector eine HTTP-Anfrage senden

Workflow bereitstellen

Console

YAML

JSON

gcloud

YAML

JSON

Workflow ausführen

Console

gcloud

Kubernetes-Job mit dem Connector ausführen

Workflow bereitstellen

Console

YAML

JSON

gcloud

YAML

JSON

Workflow ausführen

Console

gcloud

Nächste Schritte