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 in Ihrem Namen Ressourcen bereit und verwaltet Kapazitäten, sodass Ihre Batcharbeitslasten in großem Maßstab ausgeführt werden können.

Mit Workflows können Sie die benötigten Dienste in einer Reihenfolge ausführen, die Sie über die Workflows-Syntax beschrieben definieren.

In dieser Anleitung verwenden Sie den Workflow-Connector für Batch, um einen Batchjob zu planen und auszuführen, der sechs Aufgaben parallel auf zwei Compute Engine-VMs ausführt. Durch die Verwendung von Batch und Workflows können Sie die Vorteile kombinieren und den gesamten Prozess effizient bereitstellen und orchestrieren.

Lernziele

In dieser Anleitung werden Sie:

Artifact Registry-Repository für ein Docker-Container-Image erstellen.
Rufen Sie den Code für die Batchverarbeitungslast von GitHub ab: einem Beispielprogramm,das Primzahlen in Batches von 10.000 generiert.
Erstellen Sie das Docker-Image für die Arbeitslast.
Stellen Sie einen Workflow bereit, der folgende Aufgaben ausführt:
1. Erstellt einen Cloud Storage-Bucket zum Speichern der Ergebnisse des Primzahlengenerators.
2. Planung und Ausführung eines Batchjobs, der den Docker-Container als sechs Aufgaben parallel auf zwei Compute Engine-VMs ausführt.
3. Löscht optional den Batchjob, nachdem er abgeschlossen ist.
Prüfen Sie, ob die Ergebnisse wie erwartet sind und die Batches generierter Prime-Nummern in Cloud Storage gespeichert sind.

Sie können die meisten der folgenden Befehle in der Google Cloud Console oder über die Google Cloud CLI in Ihrem Terminal oder in Cloud Shell ausführen.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweise

Von Ihrer Organisation definierte Sicherheitsbeschränkungen verhindern möglicherweise, dass die folgenden Schritte ausgeführt werden. Informationen zur Fehlerbehebung finden Sie unter Anwendungen in einer eingeschränkten Google Cloud-Umgebung entwickeln.

Console

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit ihm verknüpften Ressourcen entfernen.

Zur Projektauswahl
Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.
Aktivieren Sie die Artifact Registry, Batch, Cloud Build, Compute Engine, Workflow Executions und Workflows APIs.

Aktivieren Sie die APIs
Erstellen Sie ein Dienstkonto für Ihren Workflow, das Sie zur Authentifizierung bei anderen Google Cloud-Diensten verwenden möchten, und weisen Sie ihm die entsprechenden Rollen zu:
1. Wechseln Sie in der Google Cloud Console zur Seite Dienstkonto erstellen.
  
  Zur Seite „Dienstkonto erstellen“
2. Wählen Sie Ihr Projekt aus.
3. 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 tutorial
4. Klicken Sie auf Erstellen und fortfahren.
5. Filtern Sie in der Liste Rolle auswählen nach den folgenden Rollen, die dem nutzerverwalteten Dienstkonto zugewiesen werden sollen, das Sie im vorherigen Schritt erstellt haben:
  - Batchjob-Editor: zum Bearbeiten von Batchjobs.
  - Log-Autor: Zum Schreiben von Logs.
  - Storage-Administrator: zum Steuern von Cloud Storage-Ressourcen.
  Klicken Sie auf Weitere Rolle hinzufügen, um weitere Rollen hinzuzufügen.
  
  Hinweis: Das Feld Rolle wirkt sich darauf aus, auf welche Ressourcen in Ihrem Projekt das Dienstkonto zugreifen kann. Sie können diese Rollen später widerrufen oder zusätzliche Rollen zuweisen. In Produktionsumgebungen sollten Sie die Rollen „Inhaber“, „Bearbeiter“ oder „Betrachter“ nicht zuweisen. Weisen Sie stattdessen eine vordefinierte Rolle oder eine benutzerdefinierte Rolle zu, die Ihren Anforderungen entspricht.
6. Klicken Sie auf Weiter.
7. Klicken Sie zum Abschließen der Erstellung des Kontos auf Fertig.
Weisen Sie dem im vorherigen Schritt erstellten nutzerverwalteten Dienstkonto die IAM-Rolle „Dienstkontonutzer“ für das Standarddienstkonto zu. Nachdem Sie die Compute Engine API aktiviert haben, ist das Standarddienstkonto das Compute Engine-Standarddienstkonto (PROJECT_NUMBER-compute@developer.gserviceaccount.com). Die Berechtigung wird normalerweise über die Rolle roles/iam.serviceAccountUser zugewiesen.

Achtung: Wenn Sie die Rolle Dienstkontonutzer zuweisen, wird dem Nutzer indirekt die Rolle zugewiesen, die mit dem Standarddienstkonto verknüpft ist. Wenn das Standarddienstkonto beispielsweise die Rolle „Bearbeiter“ hat, kann der Nutzer dann als Bearbeiter „fungieren“. Wir empfehlen, das Standarddienstkonto nach dem Prinzip der geringsten Berechtigung zu konfigurieren, um die Auswirkungen dieser Rollenzuweisungen zu minimieren. Weitere Informationen finden Sie unter Automatische Rollenzuweisungen für Standarddienstkonten deaktivieren.
1. Klicken Sie auf der Seite Dienstkonten auf die E-Mail-Adresse des Standarddienstkontos (PROJECT_NUMBER-compute@developer.gserviceaccount.com).
2. Klicken Sie auf den Tab Berechtigungen.
3. Klicken Sie auf die Schaltfläche Zugriff gewähren.
4. Geben Sie die E-Mail-Adresse Ihres Dienstkontos ein (SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com), um ein neues Hauptkonto hinzuzufügen.
5. Wählen Sie in der Liste Rolle auswählen die Rolle Dienstkonten > Dienstkontonutzer aus.
6. Klicken Sie auf Speichern.

gcloud

Aktivieren Sie Cloud Shell in der Google Cloud Console.

Cloud Shell aktivieren

Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.
Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

Aktivieren Sie die APIs Artifact Registry, Batch, Cloud Build, Compute Engine-Workflowausführungen und Workflows.

gcloud services enable artifactregistry.googleapis.com \
  batch.googleapis.com \
  cloudbuild.googleapis.com \
  compute.googleapis.com \
  workflowexecutions.googleapis.com \
  workflows.googleapis.com

Erstellen Sie ein Dienstkonto für Ihren Workflow, das Sie für die Authentifizierung bei anderen Google Cloud-Diensten verwenden möchten, und weisen Sie ihm die entsprechenden Rollen zu.
1. Erstellen Sie das Dienstkonto:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
  Ersetzen Sie SERVICE_ACCOUNT_NAME durch einen Namen für das Dienstkonto.
2. Weisen Sie dem vom Nutzer verwalteten Dienstkonto, das Sie im vorherigen Schritt erstellt haben, Rollen zu. Führen Sie den folgenden Befehl einmal für jede der folgenden IAM-Rollen aus:
  - roles/batch.jobsEditor: zum Bearbeiten von Batchjobs.
  - roles/logging.logWriter: zum Schreiben von Logs.
  - roles/storage.admin: zum Steuern von Cloud Storage-Ressourcen.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=ROLE
```
  Ersetzen Sie Folgendes:
  - PROJECT_ID: die ID des Projekts, in dem Sie das Dienstkonto erstellt haben
  - ROLE: die zu gewährende Rolle
  Hinweis: Das Flag --role beeinflusst, auf welche Ressourcen in Ihrem Projekt das Dienstkonto zugreifen kann. Sie können diese Rollen später widerrufen oder zusätzliche Rollen zuweisen. In Produktionsumgebungen sollten Sie die Rollen „Inhaber“, „Bearbeiter“ oder „Betrachter“ nicht zuweisen. Weisen Sie stattdessen eine vordefinierte Rolle oder eine benutzerdefinierte Rolle zu, die Ihren Anforderungen entspricht.
Weisen Sie dem im vorherigen Schritt erstellten nutzerverwalteten Dienstkonto die IAM-Rolle „Dienstkontonutzer“ für das Standarddienstkonto zu. Nachdem Sie die Compute Engine API aktiviert haben, ist das Standarddienstkonto von Compute Engine (PROJECT_NUMBER-compute@developer.gserviceaccount.com) das Standarddienstkonto. Die Berechtigung wird normalerweise über die Rolle roles/iam.serviceAccountUser zugewiesen.

Achtung: Wenn Sie die Rolle Dienstkontonutzer zuweisen, wird dem Nutzer indirekt die Rolle zugewiesen, die mit dem Standarddienstkonto verknüpft ist. Wenn das Standarddienstkonto beispielsweise die Rolle „Bearbeiter“ hat, kann der Nutzer dann als Bearbeiter „fungieren“. Wir empfehlen, das Standarddienstkonto nach dem Prinzip der geringsten Berechtigung zu konfigurieren, um die Auswirkungen dieser Rollenzuweisungen zu minimieren. Weitere Informationen finden Sie unter Automatische Rollenzuweisungen für Standarddienstkonten deaktivieren.
```
PROJECT_NUMBER=$(gcloud projects describe PROJECT_ID --format='value(projectNumber)')
gcloud iam service-accounts add-iam-policy-binding \
  $PROJECT_NUMBER-compute@developer.gserviceaccount.com \
  --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.serviceAccountUser
```

Artifact Registry-Repository erstellen

Erstellen Sie ein Repository, um Ihr Docker-Container-Image zu speichern.

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 dieses 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 in das 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

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

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

Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.

Wenn der Build fertig ist, sollte die Ausgabe in etwa so aussehen:

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 mit einem Dockerfile ein Docker-Image mit dem Namen primegen-service erstellt und das Image per Push in ein Artifact Registry-Repository namens containers übertragen.

Workflow bereitstellen, mit dem ein Batchjob geplant und ausgeführt wird

Mit dem folgenden Workflow wird ein Batchjob geplant und ausgeführt, der einen Docker-Container in Form von sechs Aufgaben parallel auf zwei Compute Engine-VMs ausführt. Das Ergebnis ist die Generierung von sechs Batches von Primzahlen, die in einem Cloud Storage-Bucket gespeichert werden.

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. batch-workflow.
Wählen Sie in der Liste Region die Option us-central1 aus.
Wählen Sie das zuvor erstellte Dienstkonto aus.
Klicken Sie auf Next (Weiter).

Geben Sie im Workflow-Editor die folgende Definition für den 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 je nach Format Ihres Workflows durch yaml oder json.

Kopieren Sie in einem Texteditor den folgenden Workflow 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 zuvor erstellten Dienstkontos.

Workflow 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"
Klicken Sie auf der Seite Workflows auf den Batchworkflow-Workflow, um die zugehörige Detailseite aufzurufen.
Klicken Sie auf der Seite Workflowdetails auf Ausführen.
Klicken Sie noch einmal auf Ausführen.

Die Workflowausführung sollte einige Minuten dauern.

Hinweis: Wenn im Schritt createBucket der Fehler IAM permission denied for service account auftritt, ist dies wahrscheinlich auf eine Verspätung der Übertragung zurückzuführen. 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 Workflowausführung sollte einige Minuten dauern.

Hinweis: Wenn im Schritt createBucket der Fehler IAM permission denied for service account auftritt, ist dies wahrscheinlich auf eine Verspätung der Übertragung zurückzuführen. 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 Ausgabe-Bucket auflisten

Sie können bestätigen, dass die Ergebnisse Ihren Erwartungen entsprechen, indem Sie die Objekte im Cloud Storage-Ausgabe-Bucket auflisten.

Console

Wechseln Sie in der Cloud Console zur Seite Cloud Storage-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, die jeweils einen Batch von 10.000 Primzahlen aufführen:
```
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 des Ausgabe-Buckets ab:
```
gsutil ls
```
Die Ausgabe sieht in etwa so aus:
```
gs://PROJECT_ID-job-primegen-TIMESTAMP/
```

Objekte in Ihrem Bucket auflisten:

gsutil ls -r gs://PROJECT_ID-job-primegen-TIMESTAMP/**

Ersetzen Sie TIMESTAMP durch den vom vorherigen Befehl zurückgegebenen Zeitstempel.

Die Ausgabe sollte in etwa so aussehen, mit insgesamt sechs Dateien, die jeweils einen Batch von 10.000 Primzahlen auflisten:

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

Bereinigen

Wenn Sie ein neues Projekt für diese Anleitung erstellt haben, löschen Sie das Projekt. Wenn Sie ein vorhandenes Projekt verwendet haben und es beibehalten möchten, ohne die Änderungen in dieser Anleitung hinzuzufügen, löschen Sie die für die Anleitung erstellten Ressourcen.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten durch Löschen des für die Anleitung erstellten Projekts.

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

In dieser Anleitung erstellte Ressourcen löschen

Löschen Sie den Batchjob:

Rufen Sie zuerst den Jobnamen ab:

gcloud batch jobs list --location=us-central1

Die Ausgabe sollte in etwa so aussehen:

NAME: projects/project-name/locations/us-central1/jobs/job-primegen-TIMESTAMP
STATE: SUCCEEDED

Dabei ist job-primegen-TIMESTAMP der Name des Batch-Jobs.

Löschen Sie den Job:

gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

Löschen Sie den Workflow:
```
gcloud workflows delete WORKFLOW_NAME
```

Löschen Sie das Container-Repository:

gcloud artifacts repositories delete REPOSITORY_NAME --location=us-central1

Cloud Build verwendet Cloud Storage zum Speichern von Build-Ressourcen. Informationen zum Löschen eines Cloud Storage-Bucket finden Sie unter Buckets löschen.

Batchjob mit Workflows ausführen

Lernziele

Kosten

Hinweise

Console

gcloud

Artifact Registry-Repository erstellen

Console

gcloud

Codebeispiele abrufen

Docker-Image mit Cloud Build erstellen

Workflow bereitstellen, mit dem ein Batchjob geplant und ausgeführt wird

Console

YAML

JSON

gcloud

YAML

JSON

Workflow ausführen

Console

gcloud

Objekte im Ausgabe-Bucket auflisten

Console

gcloud

Bereinigen

Projekt löschen

In dieser Anleitung erstellte Ressourcen löschen

Nächste Schritte