Diese Seite wurde von der Cloud Translation API übersetzt.

Batchjob mit Workflows ausführen

Batch ist ein vollständig verwalteter Dienst, mit dem Sie Batchverarbeitungs-Arbeitslasten auf Compute Engine-VM-Instanzen planen, in die Warteschlange stellen und ausführen können. Batch stellt Ressourcen bereit und verwaltet die Kapazität für Sie, sodass Ihre Batcharbeitslasten in großem Maßstab ausgeführt werden können.

Mit Workflows können Sie die benötigten Dienste in einer von Ihnen definierten Reihenfolge ausführen, die mit der Workflows-Syntax beschrieben wird.

In dieser Anleitung verwenden Sie den Workflows-Connector für Batch, um einen Batch-Job zu planen und auszuführen, der sechs Aufgaben parallel auf zwei Compute Engine-VMs ausführt. Wenn Sie sowohl Batch als auch Workflows verwenden, können Sie die Vorteile beider Tools kombinieren und den gesamten Prozess effizient bereitstellen und orchestrieren.

Artifact Registry-Repository erstellen

Erstellen Sie ein Repository zum Speichern Ihres Docker-Container-Images.

Console

Rufen Sie in der Google Cloud Console die Seite Repositories auf.

Zu Repositories
Klicken Sie auf Repository erstellen.
Geben Sie containers als Repository-Namen ein.
Wählen Sie als Format die Option Docker aus.
Wählen Sie als Standorttyp die Option Region aus.
Wählen Sie in der Liste Region die Option us-central1 aus.
Klicken Sie auf Erstellen.

gcloud

Führen Sie dazu diesen Befehl aus:

  gcloud artifacts repositories create containers \
    --repository-format=docker \
    --location=us-central1

Sie haben ein Artifact Registry-Repository mit dem Namen containers in der Region us-central1 erstellt. Weitere Informationen zu unterstützten Regionen finden Sie unter Artifact Registry-Standorte.

Codebeispiele abrufen

Google Cloud speichert den Anwendungsquellcode für diese Anleitung in GitHub. Sie können das Repository klonen oder die Beispiele herunterladen.

Klonen Sie das Repository der Beispiel-App auf Ihren lokalen Computer:
```
git clone https://github.com/GoogleCloudPlatform/batch-samples.git
```
Alternativ können Sie die Beispiele in der Datei main.zip herunterladen und extrahieren.
Wechseln Sie zu dem Verzeichnis, das den Beispielcode enthält:
```
cd batch-samples/primegen
```

Sie haben nun den Quellcode für die Anwendung in Ihrer Entwicklungsumgebung.

Docker-Image mit Cloud Build erstellen

Das Dockerfile enthält die Informationen, die zum Erstellen eines Docker-Images mit Cloud Build erforderlich sind. Führen Sie den folgenden Befehl aus, um es zu erstellen:

gcloud builds submit \
  -t us-central1-docker.pkg.dev/PROJECT_ID/containers/primegen-service:v1 PrimeGenService/

Ersetzen Sie PROJECT_ID durch Ihre Google CloudProjekt-ID.

Nach Abschluss des Builds sollten Sie in etwa folgende Ausgabe sehen:

DONE
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID: a54818cc-5d14-467b-bfda-5fc9590af68c
CREATE_TIME: 2022-07-29T01:48:50+00:00
DURATION: 48S
SOURCE: gs://project-name_cloudbuild/source/1659059329.705219-17aee3a424a94679937a7200fab15bcf.tgz
IMAGES: us-central1-docker.pkg.dev/project-name/containers/primegen-service:v1
STATUS: SUCCESS

Sie haben mithilfe eines Dockerfile ein Docker-Image mit dem Namen primegen-service erstellt und das Image in ein Artifact Registry-Repository mit dem Namen containers hochgeladen.

Workflow bereitstellen, der einen Batch-Job plant und ausführt

Im folgenden Workflow wird ein Batch-Job geplant und ausgeführt, der einen Docker-Container als sechs parallele Aufgaben auf zwei Compute Engine-VMs ausführt. Das Ergebnis ist die Generierung von sechs Batches mit Primzahlen, die in einem Cloud Storage-Bucket gespeichert werden.

Console

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

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

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

YAML

main:
  params: [args]
  steps:
    - init:
        assign:
          - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
          - region: "us-central1"
          - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
          - jobId: ${"job-primegen-" + string(int(sys.now()))}
          - bucket: ${projectId + "-" + jobId}
    - createBucket:
        call: googleapis.storage.v1.buckets.insert
        args:
          query:
            project: ${projectId}
          body:
            name: ${bucket}
    - logCreateBucket:
        call: sys.log
        args:
          data: ${"Created bucket " + bucket}
    - logCreateBatchJob:
        call: sys.log
        args:
          data: ${"Creating and running the batch job " + jobId}
    - createAndRunBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.create
        args:
            parent: ${"projects/" + projectId + "/locations/" + region}
            jobId: ${jobId}
            body:
              taskGroups:
                taskSpec:
                  runnables:
                    - container:
                        imageUri: ${imageUri}
                      environment:
                        variables:
                          BUCKET: ${bucket}
                # Run 6 tasks on 2 VMs
                taskCount: 6
                parallelism: 2
              logsPolicy:
                destination: CLOUD_LOGGING
        result: createAndRunBatchJobResponse
    # You can delete the batch job or keep it for debugging
    - logDeleteBatchJob:
        call: sys.log
        args:
          data: ${"Deleting the batch job " + jobId}
    - deleteBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.delete
        args:
            name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
        result: deleteResult
    - returnResult:
        return:
          jobId: ${jobId}
          bucket: ${bucket}

JSON

{
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "init": {
          "assign": [
            {
              "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
            },
            {
              "region": "us-central1"
            },
            {
              "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
            },
            {
              "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
            },
            {
              "bucket": "${projectId + \"-\" + jobId}"
            }
          ]
        }
      },
      {
        "createBucket": {
          "call": "googleapis.storage.v1.buckets.insert",
          "args": {
            "query": {
              "project": "${projectId}"
            },
            "body": {
              "name": "${bucket}"
            }
          }
        }
      },
      {
        "logCreateBucket": {
          "call": "sys.log",
          "args": {
            "data": "${\"Created bucket \" + bucket}"
          }
        }
      },
      {
        "logCreateBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Creating and running the batch job \" + jobId}"
          }
        }
      },
      {
        "createAndRunBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.create",
          "args": {
            "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
            "jobId": "${jobId}",
            "body": {
              "taskGroups": {
                "taskSpec": {
                  "runnables": [
                    {
                      "container": {
                        "imageUri": "${imageUri}"
                      },
                      "environment": {
                        "variables": {
                          "BUCKET": "${bucket}"
                        }
                      }
                    }
                  ]
                },
                "taskCount": 6,
                "parallelism": 2
              },
              "logsPolicy": {
                "destination": "CLOUD_LOGGING"
              }
            }
          },
          "result": "createAndRunBatchJobResponse"
        }
      },
      {
        "logDeleteBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Deleting the batch job \" + jobId}"
          }
        }
      },
      {
        "deleteBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.delete",
          "args": {
            "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
          },
          "result": "deleteResult"
        }
      },
      {
        "returnResult": {
          "return": {
            "jobId": "${jobId}",
            "bucket": "${bucket}"
          }
        }
      }
    ]
  }
}

Klicken Sie auf Bereitstellen.

gcloud

Erstellen Sie eine Quellcodedatei für Ihren Workflow:
```
touch batch-workflow.JSON_OR_YAML
```
Ersetzen Sie JSON_OR_YAML durch yaml oder json, je nach Format Ihres Workflows.

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

YAML

main:
  params: [args]
  steps:
    - init:
        assign:
          - projectId: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
          - region: "us-central1"
          - imageUri: ${region + "-docker.pkg.dev/" + projectId + "/containers/primegen-service:v1"}
          - jobId: ${"job-primegen-" + string(int(sys.now()))}
          - bucket: ${projectId + "-" + jobId}
    - createBucket:
        call: googleapis.storage.v1.buckets.insert
        args:
          query:
            project: ${projectId}
          body:
            name: ${bucket}
    - logCreateBucket:
        call: sys.log
        args:
          data: ${"Created bucket " + bucket}
    - logCreateBatchJob:
        call: sys.log
        args:
          data: ${"Creating and running the batch job " + jobId}
    - createAndRunBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.create
        args:
            parent: ${"projects/" + projectId + "/locations/" + region}
            jobId: ${jobId}
            body:
              taskGroups:
                taskSpec:
                  runnables:
                    - container:
                        imageUri: ${imageUri}
                      environment:
                        variables:
                          BUCKET: ${bucket}
                # Run 6 tasks on 2 VMs
                taskCount: 6
                parallelism: 2
              logsPolicy:
                destination: CLOUD_LOGGING
        result: createAndRunBatchJobResponse
    # You can delete the batch job or keep it for debugging
    - logDeleteBatchJob:
        call: sys.log
        args:
          data: ${"Deleting the batch job " + jobId}
    - deleteBatchJob:
        call: googleapis.batch.v1.projects.locations.jobs.delete
        args:
            name: ${"projects/" + projectId + "/locations/" + region + "/jobs/" + jobId}
        result: deleteResult
    - returnResult:
        return:
          jobId: ${jobId}
          bucket: ${bucket}

JSON

{
  "main": {
    "params": [
      "args"
    ],
    "steps": [
      {
        "init": {
          "assign": [
            {
              "projectId": "${sys.get_env(\"GOOGLE_CLOUD_PROJECT_ID\")}"
            },
            {
              "region": "us-central1"
            },
            {
              "imageUri": "${region + \"-docker.pkg.dev/\" + projectId + \"/containers/primegen-service:v1\"}"
            },
            {
              "jobId": "${\"job-primegen-\" + string(int(sys.now()))}"
            },
            {
              "bucket": "${projectId + \"-\" + jobId}"
            }
          ]
        }
      },
      {
        "createBucket": {
          "call": "googleapis.storage.v1.buckets.insert",
          "args": {
            "query": {
              "project": "${projectId}"
            },
            "body": {
              "name": "${bucket}"
            }
          }
        }
      },
      {
        "logCreateBucket": {
          "call": "sys.log",
          "args": {
            "data": "${\"Created bucket \" + bucket}"
          }
        }
      },
      {
        "logCreateBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Creating and running the batch job \" + jobId}"
          }
        }
      },
      {
        "createAndRunBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.create",
          "args": {
            "parent": "${\"projects/\" + projectId + \"/locations/\" + region}",
            "jobId": "${jobId}",
            "body": {
              "taskGroups": {
                "taskSpec": {
                  "runnables": [
                    {
                      "container": {
                        "imageUri": "${imageUri}"
                      },
                      "environment": {
                        "variables": {
                          "BUCKET": "${bucket}"
                        }
                      }
                    }
                  ]
                },
                "taskCount": 6,
                "parallelism": 2
              },
              "logsPolicy": {
                "destination": "CLOUD_LOGGING"
              }
            }
          },
          "result": "createAndRunBatchJobResponse"
        }
      },
      {
        "logDeleteBatchJob": {
          "call": "sys.log",
          "args": {
            "data": "${\"Deleting the batch job \" + jobId}"
          }
        }
      },
      {
        "deleteBatchJob": {
          "call": "googleapis.batch.v1.projects.locations.jobs.delete",
          "args": {
            "name": "${\"projects/\" + projectId + \"/locations/\" + region + \"/jobs/\" + jobId}"
          },
          "result": "deleteResult"
        }
      },
      {
        "returnResult": {
          "return": {
            "jobId": "${jobId}",
            "bucket": "${bucket}"
          }
        }
      }
    ]
  }
}

Stellen Sie den Workflow bereit. Geben Sie hierzu den folgenden Befehl ein:

gcloud workflows deploy batch-workflow \
  --source=batch-workflow.yaml \
  --location=us-central1 \
  --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Ersetzen Sie SERVICE_ACCOUNT_NAME durch den Namen des Dienstkontos, das Sie zuvor erstellt haben.

Workflow ausführen

Bei der Ausführung eines Workflows wird die aktuelle Workflowdefinition ausgeführt, die dem Workflow zugeordnet ist.

Console

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

Zur Seite "Workflows"
Klicken Sie auf der Seite Workflows auf den Workflow batch-workflow, um die Detailseite aufzurufen.
Klicken Sie auf der Seite Workflow-Details auf Ausführen.
Klicken Sie noch einmal auf Ausführen.

Die Ausführung des Workflows sollte einige Minuten dauern.

Hinweis :Wenn im Schritt createBucket ein IAM permission denied for service account-Fehler auftritt, liegt das wahrscheinlich an einer Verzögerung bei der Weitergabe. Warten Sie ein bis zwei Minuten und versuchen Sie dann noch einmal, den Workflow auszuführen.
Sehen Sie sich die Ergebnisse des Workflows im Bereich Ausgabe an.

Die Antwort sollte in etwa so aussehen:
```
{
  "bucket": "project-name-job-primegen-TIMESTAMP",
  "jobId": "job-primegen-TIMESTAMP"
}
```

gcloud

Führen Sie den Workflow aus:
```
gcloud workflows run batch-workflow \
  --location=us-central1
```
Die Ausführung des Workflows sollte einige Minuten dauern.

Hinweis :Wenn im Schritt createBucket ein IAM permission denied for service account-Fehler auftritt, liegt das wahrscheinlich an einer Verzögerung bei der Weitergabe. Warten Sie ein bis zwei Minuten und versuchen Sie dann noch einmal, den Workflow auszuführen.
Sie können den Status einer lang andauernden Ausführung prüfen.

Führen Sie den folgenden Befehl aus, um den Status der letzten abgeschlossenen Ausführung abzurufen:

gcloud workflows executions describe-last

Die Ergebnisse sollten in etwa so aussehen:

name: projects/PROJECT_NUMBER/locations/us-central1/workflows/batch-workflow/executions/EXECUTION_ID
result: '{"bucket":"project-name-job-primegen-TIMESTAMP","jobId":"job-primegen-TIMESTAMP"}'
startTime: '2022-07-29T16:08:39.725306421Z'
state: SUCCEEDED
status:
  currentSteps:
  - routine: main
    step: returnResult
workflowRevisionId: 000001-9ba

Objekte im Ausgabebucket auflisten

Sie können überprüfen, ob die Ergebnisse wie erwartet sind, indem Sie die Objekte in Ihrem Cloud Storage-Ausgabe-Bucket auflisten.

Console

Wechseln Sie in der Google Cloud Console unter „Cloud Storage“ zur Seite Buckets.

Buckets aufrufen
Klicken Sie in der Bucket-Liste auf den Namen des Buckets, dessen Inhalt Sie sehen möchten.

Die Ergebnisse sollten in etwa so aussehen, mit insgesamt sechs Dateien, in denen jeweils 10.000 Primzahlen aufgeführt sind:
```
primes-1-10000.txt
primes-10001-20000.txt
primes-20001-30000.txt
primes-30001-40000.txt
primes-40001-50000.txt
primes-50001-60000.txt
```

gcloud

Rufen Sie den Namen Ihres Ausgabebuckets ab:
```
gcloud storage ls
```
Die entsprechende Ausgabe sieht etwa so aus:
```
gs://PROJECT_ID-job-primegen-TIMESTAMP/
```

Objekte in Ihrem Bucket auflisten:

gcloud storage ls gs://PROJECT_ID-job-primegen-TIMESTAMP/** --recursive

Ersetzen Sie TIMESTAMP durch den Zeitstempel, der vom vorherigen Befehl zurückgegeben wurde.

Die Ausgabe sollte in etwa so aussehen, mit insgesamt sechs Dateien, in denen jeweils 10.000 Primzahlen aufgeführt sind:

gs://project-name-job-primegen-TIMESTAMP/primes-1-10000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-10001-20000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-20001-30000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-30001-40000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-40001-50000.txt
gs://project-name-job-primegen-TIMESTAMP/primes-50001-60000.txt

Batchjob mit Workflows ausführen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Artifact Registry-Repository erstellen

Console

gcloud

Codebeispiele abrufen

Docker-Image mit Cloud Build erstellen

Workflow bereitstellen, der einen Batch-Job plant und ausführt

Console

YAML

JSON

gcloud

YAML

JSON

Workflow ausführen

Console

gcloud

Objekte im Ausgabebucket auflisten

Console

gcloud

Batchjob mit Workflows ausführen