Batchjob mit Workflows ausführen

Batch ist ein vollständig verwalteter Dienst, mit dem Sie Batchverarbeitungsarbeitslasten 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 erforderlichen 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, bei dem sechs Aufgaben parallel auf zwei Compute Engine-VMs ausgeführt werden. Wenn Sie sowohl Batch- als auch Workflows verwenden, können Sie die Vorteile beider kombinieren und den gesamten Prozess effizient bereitstellen und orchestrieren.

Lernziele

In dieser Anleitung werden Sie:

  1. Erstellen Sie ein Artifact Registry-Repository für ein Docker-Container-Image.
  2. Code für die Batchverarbeitungslast von GitHub abrufen: Beispielprogramm,das Primzahlen in Blöcken von 10.000 generiert
  3. Erstellen Sie das Docker-Image für die Arbeitslast.
  4. Stellen Sie einen Workflow bereit und führen Sie ihn aus, der Folgendes tut:
    1. Erstellt einen Cloud Storage-Bucket zum Speichern der Ergebnisse der Primzahlgeneratoren.
    2. Hier wird ein Batchjob geplant und ausgeführt, bei dem der Docker-Container als sechs Aufgaben parallel auf zwei Compute Engine-VMs ausgeführt wird.
    3. Optional wird der Batchjob nach Abschluss gelöscht.
  5. Prüfen Sie, ob die Ergebnisse wie erwartet sind und ob die Batches der generierten Primzahlen in Cloud Storage gespeichert werden.

Sie können die meisten der folgenden Befehle in der Google Cloud Console oder alle Befehle ü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.

Vorbereitung

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

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

    Zur Projektauswahl

  2. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

  3. Aktivieren Sie die Artifact Registry API, die Batch API, die Cloud Build API, die Compute Engine API, die Workflow Executions API und die Workflows API.

    Aktivieren Sie die APIs

  4. Erstellen Sie ein Dienstkonto für Ihren Workflow, das zur Authentifizierung bei anderen Google Cloud-Diensten verwendet werden soll, 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 Sie dem nutzerverwalteten Dienstkonto zuweisen möchten, das Sie im vorherigen Schritt erstellt haben:

      • Bearbeiter von Batchjobs: zum Bearbeiten von Batchjobs.
      • Log-Autor: zum Schreiben von Protokollen.
      • Storage Admin: Damit können Sie Cloud Storage-Ressourcen verwalten.

      Klicken Sie auf Weitere Rolle hinzufügen, um weitere Rollen hinzuzufügen.

    6. Klicken Sie auf Weiter.

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

  5. Weisen Sie dem nutzerverwalteten Dienstkonto, das Sie im vorherigen Schritt erstellt haben, die Rolle „IAM-Dienstkontonutzer“ für das Standarddienstkonto zu. Nachdem Sie die Compute Engine API aktiviert haben, wird als Standarddienstkonto das Compute Engine-Standarddienstkonto (PROJECT_NUMBER-compute@developer.gserviceaccount.com) verwendet. Die Berechtigung wird in der Regel über die Rolle roles/iam.serviceAccountUser zugewiesen.

    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. Wenn Sie ein neues Hauptkonto hinzufügen möchten, geben Sie die E-Mail-Adresse Ihres Dienstkontos (SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com) ein.

    5. Wählen Sie in der Liste Rolle auswählen die Rolle Dienstkonten > Dienstkontonutzer aus.

    6. Klicken Sie auf Speichern.

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. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

  3. Aktivieren Sie die APIs Artifact Registry, Batch, Cloud Build, Compute Engine Workflow Executions und Workflows.

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

  4. Erstellen Sie ein Dienstkonto für Ihren Workflow, das zur Authentifizierung bei anderen Google Cloud-Diensten verwendet werden soll, 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 nutzerverwalteten Dienstkonto, das Sie im vorherigen Schritt erstellt haben, Rollen zu. Führen Sie den folgenden Befehl für jede der folgenden IAM-Rollen einmal aus:

      • roles/batch.jobsEditor: zum Bearbeiten von Batchjobs.
      • roles/logging.logWriter: zum Schreiben von Protokollen.
      • roles/storage.admin: Cloud Storage-Ressourcen verwalten.
      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 Projekt-ID, unter der Sie das Dienstkonto erstellt haben
      • ROLE: die zu gewährende Rolle

  5. Weisen Sie dem nutzerverwalteten Dienstkonto, das Sie im vorherigen Schritt erstellt haben, die IAM-Rolle „Service Account User“ (roles/iam.serviceAccountUser) für das Standarddienstkonto zu. Nachdem Sie die Compute Engine API aktiviert haben, wird als Standarddienstkonto das Compute Engine-Standarddienstkonto (PROJECT_NUMBER-compute@developer.gserviceaccount.com) verwendet. Die Berechtigung wird in der Regel über die Rolle roles/iam.serviceAccountUser zugewiesen.

    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 zum Speichern Ihres Docker-Container-Images.

Console

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

    Zu Repositories

  2. Klicken Sie auf Repository erstellen.

  3. Geben Sie containers als Repository-Namen ein.

  4. Wählen Sie als Format die Option Docker aus.

  5. Wählen Sie als Standorttyp die Option Region aus.

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

  7. 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 Quellcode der Anwendung für diese Anleitung in GitHub. Sie können dieses Repository klonen oder die Beispiele herunterladen.

  1. 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 Samples in der Datei main.zip herunterladen und extrahieren.

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

Die 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 die Google Cloud-Projekt-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 Dockerfiles ein Docker-Image mit dem Namen primegen-service erstellt und das Image in ein Artifact Registry-Repository mit dem Namen containers übertragen.

Workflow bereitstellen, der einen Batchjob plant und ausführt

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

Console

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

    Zur Seite "Workflows"

  2. Klicken Sie auf  Erstellen.

  3. Geben Sie einen Namen für den neuen Workflow ein, z. B. batch-workflow.

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

  5. Wählen Sie das zuvor erstellte Dienstkonto aus.

  6. Klicken Sie auf Weiter.

  7. Geben Sie im Workflow-Editor die 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}"
          }
        }
      }
    ]
  }
}

  8. Klicken Sie auf Bereitstellen.

gcloud

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

  2. Kopieren Sie den folgenden Workflow in einen Texteditor und fügen Sie ihn in Ihre Quellcodedatei 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}"
          }
        }
      }
    ]
  }
}

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

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

    Zur Seite "Workflows"

  2. Klicken Sie auf der Seite Workflows auf den Batch-Workflow, um die Detailseite aufzurufen.

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

  4. Klicken Sie noch einmal auf Ausführen.

    Die Workflowausführung sollte nur wenige Minuten dauern.

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

  1. Führen Sie den Workflow aus:

    gcloud workflows run batch-workflow \
  --location=us-central1

    Die Ausführung des Workflows sollte nur wenige Minuten dauern.

  2. Sie können den Status einer lang andauernden Ausführung prüfen.

  3. 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 prüfen, ob die Ergebnisse wie erwartet sind, indem Sie die Objekte in Ihrem Cloud Storage-Ausgabe-Bucket auflisten.

Console

  1. Wechseln Sie in der Cloud Console zur Seite Cloud Storage-Buckets.

    Buckets aufrufen

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

    Die Ergebnisse sollten in etwa so aussehen: Insgesamt sechs Dateien, in denen jeweils 10.000 Primzahlen aufgelistet 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

  1. Rufen Sie den Namen des Ausgabe-Buckets ab:

    gcloud storage ls

    Die entsprechende Ausgabe sieht etwa so aus: 

    gs://PROJECT_ID-job-primegen-TIMESTAMP/

  2. Objekte in Ihrem Bucket auflisten:

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

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

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

    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:

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

In dieser Anleitung erstellte Ressourcen löschen

  1. So löschen Sie den Batchjob:

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

    2. So löschen Sie den Job:

      gcloud batch jobs delete BATCH_JOB_NAME --location us-central1

  2. So löschen Sie den Workflow:

    gcloud workflows delete WORKFLOW_NAME

  3. Löschen Sie das Container-Repository:

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

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

Nächste Schritte