Job erstellen und ausführen, der Speicher-Volumes verwendet

In diesem Dokument wird erläutert, wie Sie einen Batchjob erstellen und ausführen, der ein oder mehrere externe Speicher-Volumes verwendet. Zu den externen Speicheroptionen gehören neue oder vorhandene nichtflüchtige Speicher, neue lokale SSDs, vorhandene Cloud Storage-Buckets und ein bestehendes Netzwerkdateisystem (Network File System, NFS) wie eine Filestore-Dateifreigabe.

Unabhängig davon, ob Sie externe Speicher-Volumes hinzufügen, hat jede Compute Engine-VM für einen Job ein Bootlaufwerk, das Speicher für das Betriebssystem-Image des Jobs und Anweisungen zur Verfügung stellt. Informationen zum Konfigurieren des Bootlaufwerks für einen Job finden Sie stattdessen unter VM-Betriebssystemumgebung – Übersicht.

Hinweise

Job erstellen, der Speicher-Volumes verwendet

Optional kann ein Job eines oder mehrere der folgenden Typen externer Speicher-Volumes verwenden. Weitere Informationen zu allen Arten von Speicher-Volumes und den jeweiligen Unterschieden und Einschränkungen finden Sie in der Dokumentation zu Compute Engine-VM-Speicheroptionen.

Sie können zulassen, dass ein Job jedes Speicher-Volume verwendet, indem Sie es in die Definition des Jobs aufnehmen und den Bereitstellungspfad (mountPath) in Ihren Runnables angeben. Informationen zum Erstellen eines Jobs, der Speicher-Volumes verwendet, finden Sie in den folgenden Abschnitten:

Nichtflüchtigen Speicher verwenden

Für einen Job, der nichtflüchtige Speicher verwendet, gelten die folgenden Einschränkungen:

  • Alle nichtflüchtigen Speicher: Lesen Sie die Einschränkungen für alle nichtflüchtigen Speicher.

  • Neue und vorhandene nichtflüchtige Speicher: Jeder nichtflüchtige Speicher in einem Job kann entweder neu (im Job definiert und mit dem Job erstellt) oder bereits vorhanden sein (bereits im Projekt erstellt und im Job angegeben). Nichtflüchtige Speicher müssen formatiert und auf den VMs des Jobs bereitgestellt werden, die sich am selben Speicherort wie der nichtflüchtige Speicher befinden. Alle nichtflüchtigen Speicher, die Sie in einen Job aufnehmen, werden im Batch bereitgestellt und alle neuen nichtflüchtigen Speicher formatiert. Sie müssen jedoch alle vorhandenen nichtflüchtigen Speicher, die ein Job verwenden soll, formatieren und trennen.

    Die unterstützten Standort-, Formatierungsoptionen und Bereitstellungsoptionen variieren für neue und vorhandene nichtflüchtige Speicher, wie in der folgenden Tabelle beschrieben:

    Neue nichtflüchtige Speicher Vorhandene nichtflüchtige Speicher
    Formatoptionen

    Der nichtflüchtige Speicher wird automatisch mit einem ext4-Dateisystem formatiert.

    Sie müssen den nichtflüchtigen Speicher formatieren, um ein ext4-Dateisystem zu verwenden, bevor Sie es für einen Job nutzen.

    Bereitstellungsoptionen

    Es werden alle Optionen unterstützt.

    Alle Optionen außer Schreibvorgang werden unterstützt. Das liegt an den Einschränkungen des Modus für mehrere Autoren.

    Sie müssen den nichtflüchtigen Speicher von allen VMs trennen, an die er angehängt ist, bevor Sie ihn für einen Job verwenden können.

    Speicherortoptionen

    Sie können nur zonale nichtflüchtige Speicher erstellen.

    Sie können für den Job einen beliebigen Standort auswählen. Der nichtflüchtige Speicher wird in der Zone erstellt, in der Ihr Projekt ausgeführt wird.

    Sie können zonale und regionale nichtflüchtige Speicher auswählen.


    Sie müssen als Speicherort des Jobs (oder, falls angegeben, nur die zulässigen Speicherorte) des Jobs nur Speicherorte angeben, die den gesamten nichtflüchtigen Speicher des Jobs enthalten. Bei einem zonalen nichtflüchtigen Speicher muss der Standort des Jobs beispielsweise die Zone des Laufwerks sein. Bei einem regionalen nichtflüchtigen Speicher muss der Standort des Jobs entweder die Region des Laufwerks oder – bei Angabe von Zonen – eine oder beide Zonen sein, in denen sich der regionale nichtflüchtige Speicher befindet.

  • Instanzvorlagen: Wenn Sie beim Erstellen dieses Jobs eine VM-Instanzvorlage verwenden möchten, müssen Sie in der Instanzvorlage alle nichtflüchtigen Speicher für diesen Job anhängen. Wenn Sie keine Instanzvorlage verwenden möchten, müssen Sie jeden nichtflüchtigen Speicher direkt in der Jobdefinition anhängen.

Sie können einen Job erstellen, der einen nichtflüchtigen Speicher verwendet, mit der Google Cloud Console, der gcloud CLI, der Batch API, Go, Java, Node.js, Python oder C++.

Console

Im folgenden Beispiel wird mit der Google Cloud Console ein Job erstellt, der ein Skript zum Lesen einer Datei aus einem vorhandenen zonalen nichtflüchtigen Speicher in der Zone us-central1-a ausführt. Im Beispielskript wird davon ausgegangen, dass der Job einen vorhandenen zonalen nichtflüchtigen Speicher hat, der im Stammverzeichnis eine Textdatei mit dem Namen example.txt enthält.

Optional: Beispiel für einen zonalen nichtflüchtigen Speicher erstellen

Wenn Sie einen zonalen nichtflüchtigen Speicher erstellen möchten, in dem Sie das Beispielskript ausführen können, gehen Sie vor dem Job folgendermaßen vor:

  1. Hängen Sie einen neuen, leeren nichtflüchtigen Speicher mit dem Namen example-disk an eine Linux-VM in der Zone us-central1-a an und führen Sie dann Befehle auf der VM aus, um das Laufwerk zu formatieren und bereitzustellen. Eine Anleitung dazu finden Sie unter Nichtflüchtigen Speicher zu Ihrer VM hinzufügen.

    Trennen Sie die Verbindung zur VM noch nicht.

  2. Führen Sie die folgenden Befehle auf der VM aus, um example.txt auf dem nichtflüchtigen Speicher zu erstellen:

    1. Geben Sie den folgenden Befehl ein, um vom aktuellen Arbeitsverzeichnis in das Stammverzeichnis des nichtflüchtigen Speichers zu wechseln:

      cd VM_MOUNT_PATH
      

      Ersetzen Sie VM_MOUNT_PATH durch den Pfad zu dem Verzeichnis, in dem der nichtflüchtige Speicher im vorherigen Schritt auf dieser VM bereitgestellt wurde, z. B. /mnt/disks/example-disk.

    2. Drücken Sie Enter.

    3. Geben Sie den folgenden Befehl ein, um eine Datei mit dem Namen example.txt zu erstellen und zu definieren:

      cat > example.txt
      
    4. Drücken Sie Enter.

    5. Geben Sie den Inhalt der Datei ein. Geben Sie beispielsweise Hello world! ein.

    6. Drücken Sie zum Speichern der Datei Ctrl+D (oder Command+D unter macOS).

    Wenn Sie fertig sind, können Sie die Verbindung zur VM trennen.

  3. Trennen Sie den nichtflüchtigen Speicher von der VM.

    • Wenn Sie die VM nicht mehr benötigen, können Sie die VM löschen. Dadurch wird der nichtflüchtige Speicher automatisch getrennt.

    • Andernfalls trennen Sie den nichtflüchtigen Speicher. Eine Anleitung finden Sie unter Bootlaufwerke trennen und neu anhängen. Außerdem sollten Sie den nichtflüchtigen Speicher example-disk anstelle des Bootlaufwerks der VM trennen.

Job erstellen, der den vorhandenen zonalen nichtflüchtigen Speicher verwendet

So erstellen Sie mit der Google Cloud Console einen Job, der vorhandene zonale nichtflüchtige Speicher verwendet:

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

    Zur Jobliste

  2. Klicken Sie auf Erstellen. Die Seite Batchjob erstellen wird geöffnet. Im linken Bereich ist die Seite Jobdetails ausgewählt.

  3. Konfigurieren Sie die Seite Jobdetails:

    1. Optional: Passen Sie im Feld Jobname den Jobnamen an.

      Geben Sie beispielsweise example-disk-job ein.

    2. Konfigurieren Sie den Bereich Aufgabendetails:

      1. Fügen Sie im Fenster New runnable mindestens ein Script oder einen Container für die Ausführung dieses Jobs hinzu.

        So führen Sie beispielsweise ein Skript aus, das den Inhalt einer Datei mit dem Namen example.txt ausgibt, die sich im Stammverzeichnis des von diesem Job verwendeten nichtflüchtigen Speichers befindet:

        1. Klicken Sie das Kästchen Script an. Ein Textfeld wird angezeigt.

        2. Geben Sie das folgende Skript in das Textfeld ein:

          echo "Here is the content of the example.txt file in the persistent disk."
          cat MOUNT_PATH/example.txt
          

          Ersetzen Sie MOUNT_PATH durch den Pfad, unter dem Sie den nichtflüchtigen Speicher auf den VMs für diesen Job bereitstellen möchten, z. B. /mnt/disks/example-disk.

        3. Klicken Sie auf Fertig.

      2. Geben Sie im Feld Aufgabenanzahl die Anzahl der Tasks für diesen Job ein.

        Geben Sie beispielsweise 1 (Standard) ein.

      3. Geben Sie in das Feld Parallelism die Anzahl der Tasks ein, die gleichzeitig ausgeführt werden sollen.

        Geben Sie beispielsweise 1 (Standard) ein.

  4. Konfigurieren Sie die Seite Ressourcenspezifikationen:

    1. Klicken Sie im linken Bereich auf Ressourcenspezifikationen. Die Seite Ressourcenspezifikationen wird geöffnet.

    2. Wählen Sie den Standort für diesen Job aus. Wenn Sie einen vorhandenen zonalen nichtflüchtigen Speicher verwenden möchten, müssen sich die VMs eines Jobs in derselben Zone befinden.

      1. Wählen Sie im Feld Region eine Region aus.

        Wenn Sie beispielsweise den zonalen nichtflüchtigen Beispielspeicher verwenden möchten, wählen Sie us-central1 (Iowa) (Standardeinstellung) aus.

      2. Wählen Sie im Feld Zone eine Zone aus.

        Wählen Sie beispielsweise us-central1-a (Iowa) aus.

  5. Konfigurieren Sie die Seite Zusätzliche Konfigurationen:

    1. Klicken Sie im linken Bereich auf Zusätzliche Konfigurationen. Die Seite Zusätzliche Konfigurationen wird geöffnet.

    2. Führen Sie für jeden vorhandenen zonalen nichtflüchtigen Speicher, den Sie für diesen Job bereitstellen möchten, die folgenden Schritte aus:

      1. Klicken Sie im Abschnitt Speicher-Volume auf Neues Volume hinzufügen. Das Fenster Neues Volume wird angezeigt.

      2. Führen Sie im Fenster Neues Volume die folgenden Schritte aus:

        1. Wählen Sie im Abschnitt Volume-Typ die Option Nichtflüchtiger Speicher (Standardeinstellung) aus.

        2. Wählen Sie in der Liste Laufwerk einen vorhandenen zonalen nichtflüchtigen Speicher aus, den Sie für diesen Job bereitstellen möchten. Das Laufwerk muss sich in derselben Zone wie dieser Job befinden.

          Wählen Sie beispielsweise den vorbereiteten zonalen nichtflüchtigen Speicher aus, der sich in der Zone us-central1-a befindet und die Datei example.txt enthält.

        3. Optional: Wenn Sie diesen zonalen nichtflüchtigen Speicher umbenennen möchten, gehen Sie so vor:

          1. Wählen Sie Gerätenamen anpassen aus.

          2. Geben Sie im Feld Gerätename den neuen Namen für das Laufwerk ein.

        4. Geben Sie im Feld Bereitstellungspfad den Bereitstellungspfad (MOUNT_PATH) für den nichtflüchtigen Speicher ein:

          Geben Sie beispielsweise Folgendes ein:

          /mnt/disks/EXISTING_PERSISTENT_DISK_NAME
          

          Ersetzen Sie EXISTING_PERSISTENT_DISK_NAME durch den Namen des Laufwerks. Wenn Sie den zonalen nichtflüchtigen Speicher umbenannt haben, verwenden Sie den neuen Namen.

          Ersetzen Sie beispielsweise EXISTING_PERSISTENT_DISK_NAME durch example-disk.

        5. Klicken Sie auf Fertig.

  6. Optional: Konfigurieren Sie die anderen Felder für diesen Job.

  7. Optional: Klicken Sie im linken Bereich auf Vorschau, um die Jobkonfiguration zu prüfen.

  8. Klicken Sie auf Erstellen.

Auf der Seite Jobdetails wird der von Ihnen erstellte Job angezeigt.

gcloud

Im folgenden Beispiel wird mit der gcloud CLI ein Job erstellt, der einen vorhandenen nichtflüchtigen Speicher und einen neuen nichtflüchtigen Speicher anhängt und bereitstellt. Der Job hat drei Aufgaben, die jeweils ein Skript zum Erstellen einer Datei im neuen nichtflüchtigen Speicher output_task_TASK_INDEX.txt ausführen, wobei TASK_INDEX der Index der einzelnen Aufgaben ist: 0, 1 und 2.

Verwenden Sie den Befehl gcloud batch jobs submit, um über die gcloud CLI einen Job zu erstellen, der nichtflüchtige Speicher verwendet. Geben Sie in der JSON-Konfigurationsdatei des Jobs die nichtflüchtigen Speicher im Feld instances an und stellen Sie den nichtflüchtigen Speicher im Feld volumes bereit.

  1. Erstellen Sie eine JSON-Datei.

    • Wenn Sie keine Instanzvorlage für diesen Job verwenden, erstellen Sie eine JSON-Datei mit folgendem Inhalt:

      {
          "allocationPolicy": {
              "instances": [
                  {
                      "policy": {
                          "disks": [
                              {
                                  "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                                  "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                              },
                              {
                                  "newDisk": {
                                      "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                      "type": "NEW_PERSISTENT_DISK_TYPE"
                                  },
                                  "deviceName": "NEW_PERSISTENT_DISK_NAME"
                              }
                          ]
                      }
                  }
              ],
              "location": {
                  "allowedLocations": [
                      "EXISTING_PERSISTENT_DISK_LOCATION"
                  ]
              }
          },
          "taskGroups": [
              {
                  "taskSpec": {
                      "runnables": [
                          {
                              "script": {
                                  "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                              }
                          }
                      ],
                      "volumes": [
                          {
                              "deviceName": "NEW_PERSISTENT_DISK_NAME",
                              "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                              "mountOptions": "rw,async"
                          },
                          {
      
                              "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                              "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                          }
                      ]
                  },
                  "taskCount":3
              }
          ],
          "logsPolicy": {
              "destination": "CLOUD_LOGGING"
          }
      }
      

      Ersetzen Sie Folgendes:

      • PROJECT_ID: die Projekt-ID Ihres Projekts.
      • EXISTING_PERSISTENT_DISK_NAME: durch den Namen eines vorhandenen nichtflüchtigen Speichers
      • EXISTING_PERSISTENT_DISK_LOCATION: der Speicherort eines vorhandenen nichtflüchtigen Speichers. Bei jedem vorhandenen zonalen nichtflüchtigen Speicher muss der Jobstandort die Zone des Laufwerks sein. Für jeden vorhandenen regionalen nichtflüchtigen Speicher muss der Speicherort des Jobs entweder die Region des Laufwerks oder, bei Angabe von Zonen, eine oder beide Zonen sein, in denen sich der regionale nichtflüchtige Speicher befindet. Wenn Sie keine vorhandenen nichtflüchtigen Speicher angeben, können Sie einen beliebigen Speicherort auswählen. Weitere Informationen zum Feld allowedLocations
      • NEW_PERSISTENT_DISK_SIZE: durch die Größe des neuen nichtflüchtigen Speichers in GB. Die zulässigen Größen hängen vom Typ des nichtflüchtigen Speichers ab. Die Mindestgröße beträgt jedoch häufig 10 GB (10) und die maximale Größe oft 64 TB (64000).
      • NEW_PERSISTENT_DISK_TYPE: durch den Laufwerkstyp des neuen nichtflüchtigen Speichers, entweder pd-standard, pd-balanced, pd-ssd oder pd-extreme. Für Batchjobs ist der Standardwert pd-balanced.
      • NEW_PERSISTENT_DISK_NAME: durch den Namen des neuen nichtflüchtigen Speichers.
    • Wenn Sie eine VM-Instanzvorlage für diesen Job verwenden, erstellen Sie wie oben gezeigt eine JSON-Datei. Ersetzen Sie dabei das Feld instances jedoch durch Folgendes:

      "instances": [
          {
              "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
          }
      ],
      

      Dabei ist INSTANCE_TEMPLATE_NAME der Name der Instanzvorlage für diesen Job. Bei einem Job, der nichtflüchtige Speicher verwendet, muss diese Instanzvorlage die nichtflüchtigen Speicher definieren und anhängen, die der Job verwenden soll. Für dieses Beispiel muss die Vorlage einen neuen nichtflüchtigen Speicher mit dem Namen NEW_PERSISTENT_DISK_NAME definieren und anhängen sowie einen vorhandenen nichtflüchtigen Speicher mit dem Namen EXISTING_PERSISTENT_DISK_NAME anhängen.

  2. Führen Sie dazu diesen Befehl aus:

    gcloud batch jobs submit JOB_NAME \
      --location LOCATION \
      --config JSON_CONFIGURATION_FILE
    

    Ersetzen Sie Folgendes:

    • JOB_NAME: der Name des Jobs.

    • LOCATION: der Standort des Jobs.

    • JSON_CONFIGURATION_FILE: der Pfad für eine JSON-Datei mit den Konfigurationsdetails des Jobs.

API

Im folgenden Beispiel wird mit der Batch API ein Job erstellt, bei dem ein vorhandener nichtflüchtiger Speicher und ein neuer nichtflüchtiger Speicher hinzugefügt und bereitgestellt werden. Der Job hat drei Aufgaben, die jeweils ein Skript zum Erstellen einer Datei im neuen nichtflüchtigen Speicher output_task_TASK_INDEX.txt ausführen, wobei TASK_INDEX der Index der einzelnen Aufgaben ist: 0, 1 und 2.

Verwenden Sie die Methode jobs.create, um mit der Batch API einen Job zu erstellen, der nichtflüchtige Speicher verwendet. Geben Sie in der Anfrage die nichtflüchtigen Speicher im Feld instances an und stellen Sie den nichtflüchtigen Speicher im Feld volumes bereit.

  • Wenn Sie keine Instanzvorlage für diesen Job verwenden, stellen Sie die folgende Anfrage:

    POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME
    
    {
        "allocationPolicy": {
            "instances": [
                {
                    "policy": {
                        "disks": [
                            {
                                "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                                "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                            },
                            {
                                "newDisk": {
                                    "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                    "type": "NEW_PERSISTENT_DISK_TYPE"
                                },
                                "deviceName": "NEW_PERSISTENT_DISK_NAME"
                            }
                        ]
                    }
                }
            ],
            "location": {
                "allowedLocations": [
                    "EXISTING_PERSISTENT_DISK_LOCATION"
                ]
            }
        },
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                            }
                        }
                    ],
                    "volumes": [
                        {
                            "deviceName": "NEW_PERSISTENT_DISK_NAME",
                            "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                            "mountOptions": "rw,async"
                        },
                        {
    
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                        }
                    ]
                },
                "taskCount":3
            }
        ],
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Ersetzen Sie Folgendes:

    • PROJECT_ID: die Projekt-ID Ihres Projekts.
    • LOCATION: der Standort des Jobs.
    • JOB_NAME: der Name des Jobs.
    • EXISTING_PERSISTENT_DISK_NAME: durch den Namen eines vorhandenen nichtflüchtigen Speichers
    • EXISTING_PERSISTENT_DISK_LOCATION: durch den Speicherort eines vorhandenen nichtflüchtigen Speichers. Bei jedem vorhandenen zonalen nichtflüchtigen Speicher muss der Standort des Jobs die Zone des Laufwerks sein. Für jeden vorhandenen regionalen nichtflüchtigen Speicher muss der Standort des Jobs entweder die Region des Laufwerks oder, bei Angabe von Zonen, eine oder beide Zonen sein, in denen sich der regionale nichtflüchtige Speicher befindet. Wenn Sie keinen vorhandenen nichtflüchtigen Speicher angeben, können Sie einen beliebigen Speicherort auswählen. Weitere Informationen zum Feld allowedLocations.
    • NEW_PERSISTENT_DISK_SIZE: durch die Größe des neuen nichtflüchtigen Speichers in GB. Die zulässigen Größen hängen vom Typ des nichtflüchtigen Speichers ab. Die Mindestgröße beträgt jedoch häufig 10 GB (10) und die maximale Größe oft 64 TB (64000).
    • NEW_PERSISTENT_DISK_TYPE: durch den Laufwerkstyp des neuen nichtflüchtigen Speichers, entweder pd-standard, pd-balanced, pd-ssd oder pd-extreme. Für Batchjobs ist der Standardwert pd-balanced.
    • NEW_PERSISTENT_DISK_NAME: durch den Namen des neuen nichtflüchtigen Speichers.
  • Wenn Sie eine VM-Instanzvorlage für diesen Job verwenden, erstellen Sie wie oben gezeigt eine JSON-Datei. Ersetzen Sie dabei das Feld instances jedoch durch Folgendes:

    "instances": [
        {
            "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
        }
    ],
    ...
    

    Dabei ist INSTANCE_TEMPLATE_NAME der Name der Instanzvorlage für diesen Job. Bei einem Job, der nichtflüchtige Speicher verwendet, muss diese Instanzvorlage die nichtflüchtigen Speicher definieren und anhängen, die der Job verwenden soll. Für dieses Beispiel muss die Vorlage einen neuen nichtflüchtigen Speicher mit dem Namen NEW_PERSISTENT_DISK_NAME definieren und anhängen sowie einen vorhandenen nichtflüchtigen Speicher mit dem Namen EXISTING_PERSISTENT_DISK_NAME anhängen.

Einfach loslegen (Go)

Um einen Batchjob zu erstellen, der neue oder vorhandene nichtflüchtige Speicher mithilfe der Cloud-Clientbibliotheken für Go verwendet, verwenden Sie die Funktion CreateJob und fügen Sie Folgendes ein:

  • Fügen Sie zum Anhängen von nichtflüchtigem Speicher an die VMs für einen Job eine der folgenden Optionen ein:
  • Verwenden Sie zum Bereitstellen des nichtflüchtigen Speichers für den Job den Typ Volume mit dem Typ Volume_DeviceName und dem Feld MountPath. Verwenden Sie für neue nichtflüchtige Speicher auch das Feld MountOptions, um das Schreiben zu aktivieren.

Ein Codebeispiel für einen ähnlichen Anwendungsfall finden Sie unter Cloud Storage-Bucket verwenden.

Java

Zum Erstellen eines Batchjobs, der neue oder vorhandene nichtflüchtige Speicher mit den Cloud-Clientbibliotheken für Java verwendet, verwenden Sie die Klasse CreateJobRequest und fügen Sie Folgendes ein:

  • Fügen Sie zum Anhängen von nichtflüchtigem Speicher an die VMs für einen Job eine der folgenden Optionen ein:
  • Verwenden Sie zum Bereitstellen des nichtflüchtigen Speichers für den Job die Klasse Volume mit der Methode setDeviceName und der Methode setMountPath. Verwenden Sie für neue nichtflüchtige Speicher auch die Methode setMountOptions, um das Schreiben zu aktivieren.

Ein Codebeispiel für einen ähnlichen Anwendungsfall finden Sie unter Cloud Storage-Bucket verwenden.

Node.js

Um einen Batchjob zu erstellen, der neue oder vorhandene nichtflüchtige Speicher mithilfe der Cloud-Clientbibliotheken für Node.js verwendet, verwenden Sie die Methode createJob und fügen Sie Folgendes ein:

Ein Codebeispiel für einen ähnlichen Anwendungsfall finden Sie unter Cloud Storage-Bucket verwenden.

Python

Zum Erstellen eines Batch-Jobs, der neue oder vorhandene nichtflüchtige Speicher mit den Cloud-Clientbibliotheken für Python verwendet, verwenden Sie die CreateJob-Funktion und fügen Sie Folgendes ein:

  • Fügen Sie zum Anhängen von nichtflüchtigem Speicher an die VMs für einen Job eine der folgenden Optionen ein:
  • Wenn Sie nichtflüchtige Speicher für den Job bereitstellen möchten, verwenden Sie die Klasse Volume mit den Attributen device_name und mount_path. Verwenden Sie für neue nichtflüchtige Speicher auch das Attribut mount_options, um das Schreiben zu aktivieren.

Ein Codebeispiel für einen ähnlichen Anwendungsfall finden Sie unter Cloud Storage-Bucket verwenden.

C++

Um einen Batchjob zu erstellen, der neue oder vorhandene nichtflüchtige Speicher mithilfe der Cloud-Clientbibliotheken für C++ verwendet, verwenden Sie die Funktion CreateJob und fügen Sie Folgendes ein:

  • Fügen Sie zum Anhängen von nichtflüchtigem Speicher an die VMs für einen Job eine der folgenden Optionen ein:
    • Wenn Sie für diesen Job keine VM-Instanzvorlage verwenden, verwenden Sie die Methode set_remote_path.
    • Wenn Sie eine VM-Instanzvorlage für diesen Job verwenden, nutzen Sie die Methode set_instance_template.
  • Verwenden Sie das Feld volumes mit den Feldern deviceName und mountPath, um den nichtflüchtigen Speicher für den Job bereitzustellen. Verwenden Sie für neue nichtflüchtige Speicher auch das Feld mountOptions, um das Schreiben zu aktivieren.

Ein Codebeispiel für einen ähnlichen Anwendungsfall finden Sie unter Cloud Storage-Bucket verwenden.

Lokale SSD verwenden

Für einen Job, der lokale SSDs verwendet, gelten die folgenden Einschränkungen:

Sie können einen Job mit einer lokalen SSD über die gcloud CLI oder Batch API erstellen. Im folgenden Beispiel wird beschrieben, wie Sie einen Job erstellen, bei dem eine lokale SSD erstellt, angehängt und bereitgestellt wird. Der Job hat außerdem drei Aufgaben, die jeweils ein Skript zum Erstellen einer Datei auf der lokalen SSD mit dem Namen output_task_TASK_INDEX.txt ausführen, wobei TASK_INDEX der Index der einzelnen Aufgaben ist: 0, 1 und 2.

gcloud

Verwenden Sie den Befehl gcloud batch jobs submit, um über die gcloud CLI einen Job zu erstellen, der lokale SSDs verwendet. Erstellen Sie in der JSON-Konfigurationsdatei des Jobs die lokalen SSDs im Feld instances und hängen Sie sie an. Stellen Sie die lokalen SSDs im Feld volumes bereit.

  1. Erstellen Sie eine JSON-Datei.

    • Wenn Sie keine Instanzvorlage für diesen Job verwenden, erstellen Sie eine JSON-Datei mit folgendem Inhalt:

      {
          "allocationPolicy": {
              "instances": [
                  {
                      "policy": {
                          "machineType": MACHINE_TYPE,
                          "disks": [
                              {
                                  "newDisk": {
                                      "sizeGb": LOCAL_SSD_SIZE,
                                      "type": "local-ssd"
                                  },
                                  "deviceName": "LOCAL_SSD_NAME"
                              }
                          ]
                      }
                  }
              ]
          },
          "taskGroups": [
              {
                  "taskSpec": {
                      "runnables": [
                          {
                              "script": {
                                  "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                              }
                          }
                      ],
                      "volumes": [
                          {
                              "deviceName": "LOCAL_SSD_NAME",
                              "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                              "mountOptions": "rw,async"
                          }
                      ]
                  },
                  "taskCount":3
              }
          ],
          "logsPolicy": {
              "destination": "CLOUD_LOGGING"
          }
      }
      

      Ersetzen Sie Folgendes:

      • MACHINE_TYPE: der Maschinentyp der VMs des Jobs, der vordefiniert oder benutzerdefiniert sein kann. Die zulässige Anzahl lokaler SSDs hängt vom Maschinentyp für die VMs des Jobs ab.
      • LOCAL_SSD_NAME: der Name einer lokalen SSD, die für diesen Job erstellt wurde.
      • LOCAL_SSD_SIZE: die Größe aller lokalen SSDs in GB. Jede lokale SSD ist 375 GB groß, sodass dieser Wert ein Vielfaches von 375 GB sein muss. Legen Sie beispielsweise bei 2 lokalen SSDs diesen Wert auf 750 GB fest.
    • Wenn Sie eine VM-Instanzvorlage für diesen Job verwenden, erstellen Sie wie oben gezeigt eine JSON-Datei. Ersetzen Sie dabei das Feld instances jedoch durch Folgendes:

      "instances": [
          {
              "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
          }
      ],
      

      Dabei ist INSTANCE_TEMPLATE_NAME der Name der Instanzvorlage für diesen Job. Bei einem Job, der lokale SSDs verwendet, müssen in dieser Instanzvorlage die lokalen SSDs definiert und angehängt werden, die der Job verwenden soll. Für dieses Beispiel muss in der Vorlage eine lokale SSD mit dem Namen LOCAL_SSD_NAME definiert und angehängt werden.

  2. Führen Sie dazu diesen Befehl aus:

    gcloud batch jobs submit JOB_NAME \
      --location LOCATION \
      --config JSON_CONFIGURATION_FILE
    

    Ersetzen Sie Folgendes:

    • JOB_NAME: der Name des Jobs.
    • LOCATION: der Standort des Jobs.
    • JSON_CONFIGURATION_FILE: der Pfad für eine JSON-Datei mit den Konfigurationsdetails des Jobs.

API

Verwenden Sie die Methode jobs.create, um mit der Batch API einen Job zu erstellen, der lokale SSDs verwendet. Erstellen Sie in der Anfrage die lokalen SSDs im Feld instances und hängen Sie sie an. Stellen Sie die lokalen SSDs im Feld volumes bereit.

  • Wenn Sie keine Instanzvorlage für diesen Job verwenden, stellen Sie die folgende Anfrage:

    POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME
    
    {
        "allocationPolicy": {
            "instances": [
                {
                    "policy": {
                        "machineType": MACHINE_TYPE,
                        "disks": [
                            {
                                "newDisk": {
                                    "sizeGb": LOCAL_SSD_SIZE,
                                    "type": "local-ssd"
                                },
                                "deviceName": "LOCAL_SSD_NAME"
                            }
                        ]
                    }
                }
            ]
        },
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                            }
                        }
                    ],
                    "volumes": [
                        {
                            "deviceName": "LOCAL_SSD_NAME",
                            "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                            "mountOptions": "rw,async"
                        }
                    ]
                },
                "taskCount":3
            }
        ],
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Ersetzen Sie Folgendes:

    • PROJECT_ID: die Projekt-ID Ihres Projekts.
    • LOCATION: der Standort des Jobs.
    • JOB_NAME: der Name des Jobs.
    • MACHINE_TYPE: der Maschinentyp der VMs des Jobs, der vordefiniert oder benutzerdefiniert sein kann. Die zulässige Anzahl lokaler SSDs hängt vom Maschinentyp für die VMs des Jobs ab.
    • LOCAL_SSD_NAME: der Name einer lokalen SSD, die für diesen Job erstellt wurde.
    • LOCAL_SSD_SIZE: die Größe aller lokalen SSDs in GB. Jede lokale SSD ist 375 GB groß, sodass dieser Wert ein Vielfaches von 375 GB sein muss. Legen Sie beispielsweise bei 2 lokalen SSDs diesen Wert auf 750 GB fest.
  • Wenn Sie eine VM-Instanzvorlage für diesen Job verwenden, erstellen Sie wie oben gezeigt eine JSON-Datei. Ersetzen Sie dabei das Feld instances jedoch durch Folgendes:

    "instances": [
        {
            "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
        }
    ],
    ...
    

    Dabei ist INSTANCE_TEMPLATE_NAME der Name der Instanzvorlage für diesen Job. Bei einem Job, der lokale SSDs verwendet, müssen in dieser Instanzvorlage die lokalen SSDs definiert und angehängt werden, die der Job verwenden soll. Für dieses Beispiel muss in der Vorlage eine lokale SSD mit dem Namen LOCAL_SSD_NAME definiert und angehängt werden.

Cloud Storage-Bucket verwenden

Wählen Sie eine der folgenden Methoden aus, um einen Job zu erstellen, der einen vorhandenen Cloud Storage-Bucket verwendet:

  • Empfohlen: Stellen Sie einen Bucket direkt auf den VMs des Jobs bereit. Geben Sie dazu den Bucket in der Definition des Jobs an, wie in diesem Abschnitt gezeigt. Bei der Ausführung des Jobs wird der Bucket mit Cloud Storage FUSE automatisch auf den VMs für den Job bereitgestellt.
  • Erstellen Sie einen Job mit Aufgaben, die direkt auf einen Cloud Storage-Bucket zugreifen. Verwenden Sie dazu das gsutil-Befehlszeilentool oder die Clientbibliotheken für die Cloud Storage API. Informationen zum direkten Zugriff auf einen Cloud Storage-Bucket von einer VM aus finden Sie in der Compute Engine-Dokumentation unter Daten in Cloud Storage-Buckets schreiben und lesen.

Erstellen Sie vor dem Erstellen eines Jobs, der einen Bucket verwendet, einen Bucket oder identifizieren Sie einen vorhandenen Bucket. Weitere Informationen finden Sie unter Buckets erstellen und Buckets auflisten.

Sie können einen Job erstellen, der einen Cloud Storage-Bucket verwendet, und zwar mit der Google Cloud Console, der gcloud CLI, der Batch API, Go, Java, Node.js, Python oder C++.

Im folgenden Beispiel wird beschrieben, wie Sie einen Job erstellen, der einen Cloud Storage-Bucket bereitstellt. Der Job enthält außerdem drei Aufgaben, die jeweils ein Skript zum Erstellen einer Datei im Bucket output_task_TASK_INDEX.txt ausführen, wobei TASK_INDEX der Index der einzelnen Aufgaben ist: 0, 1 und 2.

Console

So erstellen Sie mit der Google Cloud Console einen Job, der einen Cloud Storage-Bucket verwendet:

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

    Zur Jobliste

  2. Klicken Sie auf Erstellen. Die Seite Batchjob erstellen wird geöffnet. Im linken Bereich ist die Seite Jobdetails ausgewählt.

  3. Konfigurieren Sie die Seite Jobdetails:

    1. Optional: Passen Sie im Feld Jobname den Jobnamen an.

      Geben Sie beispielsweise example-bucket-job ein.

    2. Konfigurieren Sie den Bereich Aufgabendetails:

      1. Fügen Sie im Fenster New runnable mindestens ein Script oder einen Container für die Ausführung dieses Jobs hinzu.

        Gehen Sie beispielsweise so vor:

        1. Klicken Sie das Kästchen Script an. Ein Textfeld wird angezeigt.

        2. Geben Sie das folgende Skript in das Textfeld ein:

          echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt
          

          Ersetzen Sie MOUNT_PATH durch den Bereitstellungspfad, mit dem die Runnables dieses Jobs auf einen vorhandenen Cloud Storage-Bucket zugreifen. Der Pfad muss mit /mnt/disks/ beginnen, gefolgt von einem ausgewählten Verzeichnis oder Pfad. Wenn Sie diesen Bucket beispielsweise mit einem Verzeichnis namens my-bucket darstellen möchten, legen Sie den Bereitstellungspfad auf /mnt/disks/my-bucket fest.

        3. Klicken Sie auf Fertig.

      2. Geben Sie im Feld Aufgabenanzahl die Anzahl der Tasks für diesen Job ein.

        Geben Sie beispielsweise 3 ein.

      3. Geben Sie in das Feld Parallelism die Anzahl der Tasks ein, die gleichzeitig ausgeführt werden sollen.

        Geben Sie beispielsweise 1 (Standard) ein.

  4. Konfigurieren Sie die Seite Zusätzliche Konfigurationen:

    1. Klicken Sie im linken Bereich auf Zusätzliche Konfigurationen. Die Seite Zusätzliche Konfigurationen wird geöffnet.

    2. Führen Sie für jeden Cloud Storage-Bucket, den Sie für diesen Job bereitstellen möchten, die folgenden Schritte aus:

      1. Klicken Sie im Abschnitt Speicher-Volume auf Neues Volume hinzufügen. Das Fenster Neues Volume wird angezeigt.

      2. Führen Sie im Fenster Neues Volume die folgenden Schritte aus:

        1. Wählen Sie im Abschnitt Volume-Typ die Option Cloud Storage-Bucket aus.

        2. Geben Sie im Feld Name des Storage-Buckets den Namen eines vorhandenen Buckets ein.

          Geben Sie beispielsweise den Bucket ein, den Sie im Runnable dieses Jobs angegeben haben.

        3. Geben Sie im Feld Bereitstellungspfad den Bereitstellungspfad des Buckets (MOUNT_PATH) ein, den Sie im Runnable angegeben haben.

        4. Klicken Sie auf Fertig.

  5. Optional: Konfigurieren Sie die anderen Felder für diesen Job.

  6. Optional: Klicken Sie im linken Bereich auf Vorschau, um die Jobkonfiguration zu prüfen.

  7. Klicken Sie auf Erstellen.

Auf der Seite Jobdetails wird der von Ihnen erstellte Job angezeigt.

gcloud

Verwenden Sie den Befehl gcloud batch jobs submit, um über die gcloud CLI einen Job zu erstellen, der einen Cloud Storage-Bucket verwendet. Stellen Sie den Bucket in der JSON-Konfigurationsdatei des Jobs im Feld volumes bereit.

So erstellen Sie beispielsweise einen Job, der Dateien an einen Cloud Storage ausgibt:

  1. Erstellen Sie eine package.json-Datei mit folgendem Inhalt:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                            }
                        }
                    ],
                    "volumes": [
                        {
                            "gcs": {
                                "remotePath": "BUCKET_PATH"
                            },
                            "mountPath": "MOUNT_PATH"
                        }
                    ]
                },
                "taskCount": 3
            }
        ],
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Ersetzen Sie Folgendes:

    • BUCKET_PATH: Der Pfad des Bucket-Verzeichnisses, auf das dieser Job zugreifen soll. Der Pfad muss mit dem Namen des Buckets beginnen. Bei einem Bucket mit dem Namen BUCKET_NAME steht beispielsweise der Pfad BUCKET_NAME für das Stammverzeichnis des Buckets und der Pfad BUCKET_NAME/subdirectory für das Unterverzeichnis subdirectory.
    • MOUNT_PATH: der Bereitstellungspfad, mit dem die Runnables des Jobs auf diesen Bucket zugreifen. Der Pfad muss mit /mnt/disks/ beginnen, gefolgt von einem ausgewählten Verzeichnis oder Pfad. Wenn Sie diesen Bucket beispielsweise mit einem Verzeichnis namens my-bucket darstellen möchten, legen Sie den Bereitstellungspfad auf /mnt/disks/my-bucket fest.
  2. Führen Sie dazu diesen Befehl aus:

    gcloud batch jobs submit JOB_NAME \
      --location LOCATION \
      --config JSON_CONFIGURATION_FILE
    

    Ersetzen Sie Folgendes:

    • JOB_NAME: der Name des Jobs.
    • LOCATION: der Standort des Jobs.
    • JSON_CONFIGURATION_FILE: der Pfad für eine JSON-Datei mit den Konfigurationsdetails des Jobs.

API

Verwenden Sie zum Erstellen eines Jobs, der einen Cloud Storage-Bucket mit der Batch API verwendet, die Methode jobs.create und stellen Sie den Bucket im Feld volumes bereit.

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
            "destination": "CLOUD_LOGGING"
    }
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: die Projekt-ID Ihres Projekts.
  • LOCATION: der Standort des Jobs.
  • JOB_NAME: der Name des Jobs.
  • BUCKET_PATH: der Pfad des Bucket-Verzeichnisses, auf das dieser Job zugreifen soll. Der Pfad muss mit dem Namen des Buckets beginnen. Bei einem Bucket mit dem Namen BUCKET_NAME steht beispielsweise der Pfad BUCKET_NAME für das Stammverzeichnis des Buckets und der Pfad BUCKET_NAME/subdirectory für das Unterverzeichnis subdirectory.
  • MOUNT_PATH: der Bereitstellungspfad, mit dem die Runnables des Jobs auf diesen Bucket zugreifen. Der Pfad muss mit /mnt/disks/ beginnen, gefolgt von einem ausgewählten Verzeichnis oder Pfad. Wenn Sie diesen Bucket beispielsweise mit einem Verzeichnis namens my-bucket darstellen möchten, legen Sie den Bereitstellungspfad auf /mnt/disks/my-bucket fest.

Einfach loslegen (Go)

Go

Weitere Informationen findest du in der Referenzdokumentation zur Batch Go API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Batch zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	batchpb "google.golang.org/genproto/googleapis/cloud/batch/v1"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that executes the specified script
func createScriptJobWithBucket(w io.Writer, projectID, region, jobName, bucketName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"
	// jobName := "some-bucket"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		Text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt",
	}

	// Specify the Google Cloud Storage bucket to mount
	volume := &batchpb.Volume{
		Source: &batchpb.Volume_Gcs{
			Gcs: &batchpb.GCS{
				RemotePath: bucketName,
			},
		},
		MountPath:    "/mnt/share",
		MountOptions: []string{},
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
		CpuMilli:  500,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Script_{
				Script: &batchpb.Runnable_Script{Command: command},
			},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Volumes:       []*batchpb.Volume{volume},
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// Policies are used to define on what kind of virtual machines the tasks will run on.
	// In this case, we tell the system to use "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "script"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Java

Weitere Informationen findest du in der Referenzdokumentation zur Batch Java API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Batch zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.ComputeResource;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.GCS;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.LogsPolicy.Destination;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Script;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.cloud.batch.v1.Volume;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateWithMountedBucket {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";

    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";

    // Name of the bucket to be mounted for your Job.
    String bucketName = "BUCKET_NAME";

    createScriptJobWithBucket(projectId, region, jobName, bucketName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJobWithBucket(String projectId, String region, String jobName,
      String bucketName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      Volume volume = Volume.newBuilder()
          .setGcs(GCS.newBuilder()
              .setRemotePath(bucketName)
              .build())
          .setMountPath("/mnt/share")
          .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
              .setCpuMilli(500)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .addVolumes(volume)
              .setComputeResource(computeResource)
              .setMaxRetryCount(2)
              .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
              .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder().setTaskCount(4).setTaskSpec(task).build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      // In this case, we tell the system to use "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(InstancePolicyOrTemplate.newBuilder().setPolicy(instancePolicy).build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              .putLabels("mount", "bucket")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING).build())
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());
    }
  }
}

Node.js

Node.js

Weitere Informationen findest du in der Referenzdokumentation zur Batch Node.js API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Batch zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';
/**
 * The name of the bucket to be mounted.
 */
// const bucketName = 'YOUR_BUCKET_NAME';

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.script = new batch.Runnable.Script();
runnable.script.text =
  'echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt';
// You can also run a script from a file. Just remember, that needs to be a script that's
// already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
// exclusive.
// runnable.script.path = '/tmp/test.sh'
task.runnables = [runnable];

const gcsBucket = new batch.GCS();
gcsBucket.remotePath = bucketName;
const gcsVolume = new batch.Volume();
gcsVolume.gcs = gcsBucket;
gcsVolume.mountPath = '/mnt/share';
task.volumes = [gcsVolume];

// We can specify what resources are requested by each task.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.taskSpec = task;

// Policies are used to define on what kind of virtual machines the tasks will run on.
// In this case, we tell the system to use "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'script'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.logsPolicy.destination = batch.LogsPolicy.Destination.CLOUD_LOGGING;

// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const response = await batchClient.createJob(request);
  console.log(response);
}

callCreateJob();

Python

Python

Weitere Informationen findest du in der Referenzdokumentation zur Batch Python API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Batch zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

from google.cloud import batch_v1

def create_script_job_with_bucket(
    project_id: str, region: str, job_name: str, bucket_name: str
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.
        bucket_name: name of the bucket to be mounted for your Job.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
    task.runnables = [runnable]

    gcs_bucket = batch_v1.GCS()
    gcs_bucket.remote_path = bucket_name
    gcs_volume = batch_v1.Volume()
    gcs_volume.gcs = gcs_bucket
    gcs_volume.mount_path = "/mnt/share"
    task.volumes = [gcs_volume]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 500  # in milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
    resources.memory_mib = 16
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    allocation_policy = batch_v1.AllocationPolicy()
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script", "mount": "bucket"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

C++

C++

Weitere Informationen findest du in der Referenzdokumentation zur Batch C++ API.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich bei Batch zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id, std::string const& bucket_name) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it, and then override the GCS remote path.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            script {
              text: "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
            }
          }
          volumes { mount_path: "/mnt/share" }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "script" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    job->mutable_task_groups(0)
        ->mutable_task_spec()
        ->mutable_volumes(0)
        ->mutable_gcs()
        ->set_remote_path(bucket_name);
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

Netzwerkdateisystem verwenden

Sie können einen Job erstellen, der ein vorhandenes Network File System (NFS) verwendet, z. B. eine Filestore-Dateifreigabe, mit der Google Cloud Console, der gcloud CLI oder der Batch API.

Achten Sie vor dem Erstellen eines Jobs, der ein NFS verwendet, dafür, dass die Firewall Ihres Netzwerks so konfiguriert ist, dass Traffic zwischen den VMs des Jobs und dem NFS zugelassen wird. Weitere Informationen finden Sie unter Firewallregeln für Filestore konfigurieren.

In diesem Beispiel wird beschrieben, wie Sie einen Job erstellen, der ein NFS angibt und bereitstellt. Der Job hat außerdem drei Aufgaben, die jeweils ein Skript zum Erstellen einer Datei im NFS mit dem Namen output_task_TASK_INDEX.txt ausführen, wobei TASK_INDEX der Index der einzelnen Aufgaben ist: 0, 1 und 2.

Console

So erstellen Sie in der Google Cloud Console einen Job, der NFS verwendet:

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

    Zur Jobliste

  2. Klicken Sie auf Erstellen. Die Seite Batchjob erstellen wird geöffnet. Im linken Bereich ist die Seite Jobdetails ausgewählt.

  3. Konfigurieren Sie die Seite Jobdetails:

    1. Optional: Passen Sie im Feld Jobname den Jobnamen an.

      Geben Sie beispielsweise example-nfs-job ein.

    2. Konfigurieren Sie den Bereich Aufgabendetails:

      1. Fügen Sie im Fenster New runnable mindestens ein Script oder einen Container für die Ausführung dieses Jobs hinzu.

        Gehen Sie beispielsweise so vor:

        1. Klicken Sie das Kästchen Script an. Ein Textfeld wird angezeigt.

        2. Geben Sie das folgende Skript in das Textfeld ein:

          echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt
          

          Ersetzen Sie MOUNT_PATH durch den Bereitstellungspfad, den das ausführbare Netzwerk des Jobs für den Zugriff auf dieses NFS verwendet. Der Pfad muss mit /mnt/disks/ beginnen, gefolgt von einem ausgewählten Verzeichnis oder Pfad. Wenn Sie beispielsweise dieses NFS mit einem Verzeichnis namens my-nfs darstellen möchten, legen Sie den Bereitstellungspfad auf /mnt/disks/my-nfs fest.

        3. Klicken Sie auf Fertig.

      2. Geben Sie im Feld Aufgabenanzahl die Anzahl der Tasks für diesen Job ein.

        Geben Sie beispielsweise 3 ein.

      3. Geben Sie in das Feld Parallelism die Anzahl der Tasks ein, die gleichzeitig ausgeführt werden sollen.

        Geben Sie beispielsweise 1 (Standard) ein.

  4. Konfigurieren Sie die Seite Zusätzliche Konfigurationen:

    1. Klicken Sie im linken Bereich auf Zusätzliche Konfigurationen. Die Seite Zusätzliche Konfigurationen wird geöffnet.

    2. Führen Sie für jeden Cloud Storage-Bucket, den Sie für diesen Job bereitstellen möchten, die folgenden Schritte aus:

      1. Klicken Sie im Abschnitt Speicher-Volume auf Neues Volume hinzufügen. Das Fenster Neues Volume wird angezeigt.

      2. Führen Sie im Fenster Neues Volume die folgenden Schritte aus:

        1. Wählen Sie im Abschnitt Volume-Typ die Option Netzwerkdateisystem aus.

        2. Geben Sie im Feld Dateiserver die IP-Adresse des Servers ein, auf dem sich das NFS-Feld befindet, das Sie im Runnable dieses Jobs angegeben haben.

          Wenn Ihr NFS beispielsweise eine Filestore-Dateifreigabe ist, geben Sie die IP-Adresse der Filestore-Instanz an, die Sie durch Beschreiben der Filestore-Instanz abrufen können.

        3. Geben Sie im Feld Remote-Pfad einen Pfad ein, der auf das im vorherigen Schritt angegebene NFS zugreifen kann.

          Der Pfad des NFS-Verzeichnisses muss mit einem / beginnen, gefolgt vom Stammverzeichnis des NFS.

        4. Geben Sie im Feld Bereitstellungspfad den Bereitstellungspfad für NFS (MOUNT_PATH) ein, den Sie im vorherigen Schritt angegeben haben.

    3. Klicken Sie auf Fertig.

  5. Optional: Konfigurieren Sie die anderen Felder für diesen Job.

  6. Optional: Klicken Sie im linken Bereich auf Vorschau, um die Jobkonfiguration zu prüfen.

  7. Klicken Sie auf Erstellen.

Auf der Seite Jobdetails wird der von Ihnen erstellte Job angezeigt.

gcloud

Verwenden Sie den Befehl gcloud batch jobs submit, um über die gcloud CLI einen Job zu erstellen, der NFS verwendet. Stellen Sie in der JSON-Konfigurationsdatei des Jobs das NFS im Feld volumes bereit.

  1. Erstellen Sie eine package.json-Datei mit folgendem Inhalt:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                            }
                        }
                    ],
                    "volumes": [
                        {
                            "nfs": {
                                "server": "NFS_IP_ADDRESS",
                                "remotePath": "NFS_PATH"
                            },
                            "mountPath": "MOUNT_PATH"
                        }
                    ]
                },
                "taskCount": 3
            }
        ],
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Ersetzen Sie Folgendes:

    • NFS_IP_ADDRESS: die IP-Adresse des NFS. Wenn Ihre NFS-Datei beispielsweise eine Filestore-Dateifreigabe ist, geben Sie die IP-Adresse der Filestore-Instanz an, die Sie durch Beschreiben der Filestore-Instanz abrufen können.
    • NFS_PATH: Der Pfad des NFS-Verzeichnisses, auf das dieser Job zugreifen soll. Er muss mit einem / beginnen, gefolgt vom Stammverzeichnis des NFS. Bei einer Filestore-Dateifreigabe mit dem Namen FILE_SHARE_NAME steht beispielsweise der Pfad /FILE_SHARE_NAME für das Stammverzeichnis der Dateifreigabe und der Pfad /FILE_SHARE_NAME/subdirectory für das Unterverzeichnis subdirectory.
    • MOUNT_PATH: Der Bereitstellungspfad, den die Runnables des Jobs für den Zugriff auf dieses NFS verwenden. Der Pfad muss mit /mnt/disks/ beginnen, gefolgt von einem ausgewählten Verzeichnis oder Pfad. Wenn Sie beispielsweise dieses NFS mit einem Verzeichnis namens my-nfs darstellen möchten, legen Sie den Bereitstellungspfad auf /mnt/disks/my-nfs fest.
  2. Führen Sie dazu diesen Befehl aus:

    gcloud batch jobs submit JOB_NAME \
      --location LOCATION \
      --config JSON_CONFIGURATION_FILE
    

    Ersetzen Sie Folgendes:

    • JOB_NAME: der Name des Jobs.
    • LOCATION: der Standort des Jobs.
    • JSON_CONFIGURATION_FILE: der Pfad für eine JSON-Datei mit den Konfigurationsdetails des Jobs.

API

Verwenden Sie die Methode jobs.create und stellen Sie das NFS im Feld volumes bereit, um mit der Batch API einen Job zu erstellen, der NFS verwendet.

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME

   {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: die Projekt-ID Ihres Projekts.
  • LOCATION: der Standort des Jobs.
  • JOB_NAME: der Name des Jobs.
  • NFS_IP_ADDRESS: die IP-Adresse des Netzwerkdateisystems. Wenn Ihre NFS-Datei beispielsweise eine Filestore-Dateifreigabe ist, geben Sie die IP-Adresse der Filestore-Instanz an, die Sie durch Beschreiben der Filestore-Instanz abrufen können.
  • NFS_PATH: Der Pfad des NFS-Verzeichnisses, auf das dieser Job zugreifen soll. Er muss mit einem / beginnen, gefolgt vom Stammverzeichnis des NFS. Bei einer Filestore-Dateifreigabe mit dem Namen FILE_SHARE_NAME steht beispielsweise der Pfad /FILE_SHARE_NAME für das Stammverzeichnis der Dateifreigabe und der Pfad /FILE_SHARE_NAME/subdirectory für ein Unterverzeichnis.
  • MOUNT_PATH: Der Bereitstellungspfad, den die Runnables des Jobs für den Zugriff auf dieses NFS verwenden. Der Pfad muss mit /mnt/disks/ beginnen, gefolgt von einem ausgewählten Verzeichnis oder Pfad. Wenn Sie beispielsweise dieses NFS mit einem Verzeichnis namens my-nfs darstellen möchten, legen Sie den Bereitstellungspfad auf /mnt/disks/my-nfs fest.

Nächste Schritte