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. Externe Speicheroptionen umfassen neue oder vorhandene Speicheroptionen nichtflüchtige Speicher, neue lokale SSDs, vorhandene Cloud Storage-Buckets, und ein bestehendes Network File System (NFS) wie Filestore-Dateifreigabe.

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

Hinweise

Job erstellen, der Speicher-Volumes verwendet

Optional kann ein Job einen oder mehrere der folgenden Arten von externen Speicher-Volumes. Weitere Informationen zu allen Arten von Speicher-Volumes Unterschiede und Einschränkungen finden Sie in der Dokumentation zu Compute Engine-VM-Speicheroptionen

Sie können einem Job erlauben, jedes Speicher-Volume zu verwenden, indem Sie es einschließen in der Jobdefinition angeben und seine Bereitstellungspfad (mountPath) in Ihren Runnables. Informationen zum Erstellen eines Jobs, der Speicher-Volumes verwendet, finden Sie unter einem oder mehreren der folgenden Abschnitte:

Nichtflüchtigen Speicher verwenden

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

  • Alle nichtflüchtigen Speicher: Überprüfen Sie den Einschränkungen für alle nichtflüchtigen Speicher.

  • Neue und vorhandene nichtflüchtige Speicher im Vergleich: Jeder nichtflüchtige Speicher in einem Job kann entweder neu (in dem Job definiert und erstellt) oder vorhanden (bereits die in Ihrem Projekt erstellt und im Job angegeben wurden). Um einen nichtflüchtigen Speicher zu nutzen, muss es sein formatiert und im die VMs des Jobs, die sich am selben Standort wie der nichtflüchtige Speicher befinden müssen. stellt alle nichtflüchtigen Speicher bereit, die Sie in einen Job aufnehmen, und formatiert neue nichtflüchtige Speicher; Sie müssen jedoch alle vorhandene nichtflüchtige Speicher, die ein Job verwenden soll.

    Die unterstützten Standortoptionen, Formatierungsoptionen, und Halterungsoptionen zwischen neuen und vorhandenen nichtflüchtigen Speichern, wie im Folgenden beschrieben. Tabelle:

    Neue nichtflüchtige Speicher Vorhandene nichtflüchtige Speicher
    Formatoptionen

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

    Sie müssen den nichtflüchtigen Speicher formatieren. ein ext4-Dateisystem bevor Sie sie für einen Job nutzen.

    Bereitstellungsoptionen

    Alle Optionen werden unterstützt.

    Alle Optionen außer dem Schreiben werden unterstützt. Dies ist auf Einschränkungen von Multi-Writer-Modus.

    Sie müssen Nichtflüchtigen Speicher trennen von allen VMs, an die er angehängt ist, bevor er für einen Job verwendet wird.

    Speicherortoptionen

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

    Sie können für Ihren Job einen beliebigen Standort auswählen. Die persistente Laufwerke in der Zone erstellt werden, in der Ihr Projekt ausgeführt wird.

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


    Sie müssen den Standort des Auftrags (oder, falls angegeben, nur den zulässige Standorte) an Standorte, die alle nichtflüchtigen Speicher des Jobs enthalten. Laufwerke. Bei einem zonalen nichtflüchtigen Speicher beispielsweise Der Speicherort muss die Zone des Laufwerks sein. für einen regionalen nichtflüchtigen Speicher Der Speicherort des Jobs muss entweder die Region des Laufwerks sein oder, falls die Zonen angeben, eine oder beide Zonen, in denen regionalen nichtflüchtigen Speicher befindet.

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

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

Console

Im folgenden Beispiel wird mit der Google Cloud Console ein Job erstellt, führt ein Skript zum Lesen einer Datei aus einem vorhandenen zonalen nichtflüchtigen Speicher aus, der sich in der us-central1-a-Zone befindet. Im Beispielskript wird davon ausgegangen, über einen zonalen nichtflüchtigen Speicher verfügt, der eine Textdatei namens example.txt im Stammverzeichnis.

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

Wenn Sie einen zonalen nichtflüchtigen Speicher erstellen möchten, Führen Sie das Beispielskript aus. Führen Sie dabei die folgenden Schritte aus, bevor Sie den Job erstellen:

  1. Hängen Sie einen neuen, leeren nichtflüchtigen Speicher namens example-disk an eine Linux-VM im us-central1-a und führen Sie dann Befehle zum Formatieren und Bereitstellen auf der VM aus. auf dem Laufwerk. Anweisungen finden Sie unter Nichtflüchtigen Speicher zu Ihrer VM hinzufügen

    Trennen Sie die Verbindung zur VM noch nicht.

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

    1. Um das aktuelle Arbeitsverzeichnis in das Stammverzeichnis der nichtflüchtigen Speicher den folgenden Befehl ein:

      cd VM_MOUNT_PATH
      

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

    2. Drücken Sie Enter.

    3. Zum Erstellen und Definieren einer Datei mit dem Namen example.txt: geben Sie den folgenden Befehl ein:

      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, Löschen Sie die VM, die trennt den nichtflüchtigen Speicher automatisch.

    • Andernfalls trennen Sie den nichtflüchtigen Speicher. Anweisungen finden Sie unter Bootlaufwerke trennen und neu anhängen und trennen Sie den nichtflüchtigen Speicher example-disk das Bootlaufwerk der VM.

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

So erstellen Sie einen Job, der vorhandene zonale nichtflüchtige Speicher mit der Methode Führen Sie in der Google Cloud Console die folgenden Schritte aus:

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

    Zur Jobliste

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

  3. Konfigurieren Sie die Seite Jobdetails:

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

      Geben Sie beispielsweise example-disk-job ein.

    2. Konfigurieren Sie den Bereich Aufgabendetails:

      1. Fügen Sie im Fenster New Runnable (Neu ausführbar) mindestens ein Skript hinzu oder Container für die Ausführung dieses Jobs.

        Um beispielsweise ein Skript auszuführen, das den Inhalt einer Datei ausgibt, den Namen example.txt hat und sich im Stammverzeichnis befindet des nichtflüchtigen Speichers, den dieser Job verwendet, gehen Sie 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 "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 zu in dem Sie den nichtflüchtigen Speicher auf den VMs bereitstellen möchten, für diesen Job, z. B. /mnt/disks/example-disk.

        3. Klicken Sie auf Fertig.

      2. Geben Sie in das Feld Aufgabenanzahl die Anzahl der Aufgaben ein, für diesen Job.

        Geben Sie beispielsweise 1 ein (Standardeinstellung).

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

        Geben Sie beispielsweise 1 ein (Standardeinstellung).

  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. Zur Verwendung eines vorhandenen zonalen nichtflüchtigen Speichers müssen die VMs eines Jobs sich in derselben Zone befinden.

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

        Um beispielsweise den zonalen nichtflüchtigen Speicher zu verwenden, 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ür jeden vorhandenen zonalen nichtflüchtigen Speicher, auf dem Sie die Bereitstellung vornehmen möchten gehen Sie so vor:

      1. Klicken Sie im Abschnitt Speichervolumen 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 Bereich Volume-Typ die Option Nichtflüchtiger Speicher (Standard).

        2. Wählen Sie in der Liste Laufwerk ein Vorhandener zonaler nichtflüchtiger Speicher, auf dem Sie die Bereitstellung vornehmen möchten für diesen Job. Das Laufwerk muss sich im selben wie dieser Job.

          Wählen Sie beispielsweise den vorhandenen zonalen nichtflüchtigen Speicher aus. die Sie vorbereitet haben und die sich im us-central1-a und enthält die Datei example.txt.

        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 Ihre Festplatte.

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

          Geben Sie beispielsweise Folgendes ein:

          /mnt/disks/EXISTING_PERSISTENT_DISK_NAME
          

          EXISTING_PERSISTENT_DISK_NAME ersetzen durch den Namen des Laufwerks. Wenn Sie den Namen zonalen nichtflüchtigen Speichers den neuen Namen zu verwenden.

          Ersetzen Sie beispielsweise EXISTING_PERSISTENT_DISK_NAME mit example-disk.

        5. Klicken Sie auf Fertig.

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

  7. Optional: Um die Jobkonfiguration zu überprüfen, klicken Sie auf Vorschau.

  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 hinzufügt und bereitstellt. Der Job umfasst drei Aufgaben, die jeweils ein Skript ausführen, um eine Datei im neuen Nichtflüchtiger Speicher mit dem Namen output_task_TASK_INDEX.txt wobei TASK_INDEX der Index jeder Aufgabe ist: 0, 1 und 2.

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

  1. Erstellen Sie eine JSON-Datei.

    • Wenn Sie für diesen Job keine Instanzvorlage 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: der Name eines vorhandenen nichtflüchtigen Speichers.
      • EXISTING_PERSISTENT_DISK_LOCATION: die Speicherort eines vorhandenen nichtflüchtigen Speichers. Für jede vorhandene zonale Nichtflüchtiger Speicher muss der Speicherort des Jobs die Zone des Laufwerks sein. für muss der Speicherort des Jobs entweder die Region des Laufwerks oder, bei Angabe von Zonen, eine oder beiden spezifischen Zonen, in denen der regionale nichtflüchtige Speicher befindet. Wenn Sie keine vorhandene persistente können Sie einen beliebigen Speicherort auswählen. Weitere Informationen zum Feld allowedLocations.
      • NEW_PERSISTENT_DISK_SIZE: die Größe des den neuen nichtflüchtigen Speicher in GB. Die zulässige Größen hängt vom Typ des nichtflüchtigen Speichers ab, aber das Minimum ist oft 10 GB (10) und häufig 64 TB (64000).
      • NEW_PERSISTENT_DISK_TYPE: die Laufwerkstyp des neuen nichtflüchtigen Speichers, entweder pd-standard, pd-balanced, pd-ssd oder pd-extreme. Der Standardlaufwerkstyp für Nicht-Boot-Vorgänge Nichtflüchtiger Speicher ist pd-standard.
      • NEW_PERSISTENT_DISK_NAME: der Name des neuen nichtflüchtigen Speichers.
    • Wenn Sie mit einer VM-Instanzvorlage für diesen Job, wie oben gezeigt eine JSON-Datei erstellen, außer dass Feld „instances Dabei gilt:

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

      wobei INSTANCE_TEMPLATE_NAME der Name ist der Instanzvorlage für diesen Job. Für einen Job, bei dem nichtflüchtigen Speichers definieren und anhängen, nichtflüchtige Speicher, die der Job verwenden soll. In diesem Beispiel Die Vorlage muss einen neuen nichtflüchtigen Speicher namens NEW_PERSISTENT_DISK_NAME und und hängen Sie einen vorhandenen nichtflüchtigen Speicher mit dem Namen EXISTING_PERSISTENT_DISK_NAME.

  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: Pfad für ein JSON-Objekt mit den Konfigurationsdetails des Jobs.

API

Im folgenden Beispiel wird mit der Batch API ein Job erstellt die einen vorhandenen nichtflüchtigen Speicher und einen neuen nichtflüchtigen Speicher hinzufügt und bereitstellt Laufwerk. Der Job umfasst drei Aufgaben, die jeweils ein Skript ausführen, um eine Datei im neuen Nichtflüchtiger Speicher mit dem Namen output_task_TASK_INDEX.txt, wobei TASK_INDEX ist der Index jeder Aufgabe: 0, 1 und 2.

So erstellen Sie einen Job, der nichtflüchtige Speicher verwendet: Batch API verwenden, verwenden Sie jobs.create-Methode. Geben Sie in der Anfrage die nichtflüchtigen Speicher in der instances und stellen Sie den nichtflüchtigen Speicher im Feld volumes bereit.

  • Wenn Sie für diesen Job keine Instanzvorlage verwenden, gehen Sie so vor: 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: der Name eines vorhandenen nichtflüchtigen Speichers.
    • EXISTING_PERSISTENT_DISK_LOCATION: die Speicherort eines vorhandenen nichtflüchtigen Speichers. Für jede vorhandene zonale Nichtflüchtiger Speicher muss der Speicherort des Jobs die Zone des Laufwerks sein. für muss der Speicherort des Jobs entweder die Region des Laufwerks oder, bei Angabe von Zonen, eine oder beiden spezifischen Zonen, in denen der regionale nichtflüchtige Speicher befindet. Wenn Sie keine vorhandene persistente können Sie einen beliebigen Speicherort auswählen. Weitere Informationen zum Feld allowedLocations.
    • NEW_PERSISTENT_DISK_SIZE: die Größe des den neuen nichtflüchtigen Speicher in GB. Die zulässige Größen hängt vom Typ des nichtflüchtigen Speichers ab, aber das Minimum ist oft 10 GB (10) und häufig 64 TB (64000).
    • NEW_PERSISTENT_DISK_TYPE: die Laufwerkstyp des neuen nichtflüchtigen Speichers, entweder pd-standard, pd-balanced, pd-ssd oder pd-extreme. Der Standardlaufwerkstyp für Nicht-Boot-Vorgänge Nichtflüchtiger Speicher ist pd-standard.
    • NEW_PERSISTENT_DISK_NAME: der Name des neuen nichtflüchtigen Speichers.
  • Wenn Sie mit einer VM-Instanzvorlage für diesen Job, wie oben gezeigt eine JSON-Datei erstellen, außer dass Feld „instances Dabei gilt:

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

    Dabei ist INSTANCE_TEMPLATE_NAME der Name der Instanzvorlage für diesen Job. Für einen Job, bei dem nichtflüchtigen Speichers definieren und anhängen, nichtflüchtige Speicher, die der Job verwenden soll. In diesem Beispiel Die Vorlage muss einen neuen nichtflüchtigen Speicher namens NEW_PERSISTENT_DISK_NAME und und hängen Sie einen vorhandenen nichtflüchtigen Speicher mit dem Namen EXISTING_PERSISTENT_DISK_NAME.

Go

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

  • So hängen Sie nichtflüchtige Speicher für einen Job an die VMs an: eines der folgenden Elemente enthalten: <ph type="x-smartling-placeholder">
  • Stellen Sie die nichtflüchtigen Speicher für den Job mit der Methode Volume-Typ mit dem Typ Volume_DeviceName und MountPath ein. Verwenden Sie für neue nichtflüchtige Speicher auch die MountOptions, um den Schreibvorgang zu ermöglichen.

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

Java

Um einen Batchjob zu erstellen, der neue oder vorhandene verwendet nichtflüchtige Speicher mit die Cloud-Clientbibliotheken für Java, verwenden Sie CreateJobRequest Kurs und Folgendes enthalten:

  • So hängen Sie nichtflüchtige Speicher für einen Job an die VMs an: eines der folgenden Elemente enthalten: <ph type="x-smartling-placeholder">
      </ph>
    • Wenn Sie für diesen Job keine VM-Instanzvorlage verwenden, Schließen Sie die Methode setDisks ein.
    • Wenn Sie für diesen Job eine VM-Instanzvorlage verwenden, Schließen Sie die Methode setInstanceTemplate ein.
  • Stellen Sie die nichtflüchtigen Speicher für den Job mit der Methode Volume Kurs mit der Methode setDeviceName und setMountPath-Methode. Verwenden Sie für neue nichtflüchtige Speicher auch die setMountOptions-Methode um das Schreiben zu ermöglichen.

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 verwendet nichtflüchtige Speicher mit Die Cloud-Clientbibliotheken für Node.js verwenden die Methode createJob-Methode und Folgendes enthalten:

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

Python

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

  • So hängen Sie nichtflüchtige Speicher für einen Job an die VMs an: eines der folgenden Elemente enthalten: <ph type="x-smartling-placeholder">
  • Stellen Sie die nichtflüchtigen Speicher für den Job mit der Methode Volume Kurs mit dem Attribut device_name und mount_path. Verwenden Sie für neue nichtflüchtige Speicher auch die mount_options, um den Schreibvorgang zu ermöglichen.

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

C++

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

  • So hängen Sie nichtflüchtige Speicher für einen Job an die VMs an: eines der folgenden Elemente enthalten: <ph type="x-smartling-placeholder">
      </ph>
    • Wenn Sie für diesen Job keine VM-Instanzvorlage verwenden, Verwenden Sie die Methode set_remote_path.
    • Wenn Sie für diesen Job eine VM-Instanzvorlage verwenden, nutzen Sie die Methode set_instance_template-Methode.
  • Um die nichtflüchtigen Speicher für den Job bereitzustellen, verwenden Sie das Feld volumes mit die Felder deviceName und mountPath. Bei neuen nichtflüchtigen Speichern gilt: verwenden Sie das Feld mountOptions, um den Schreibvorgang zu ermöglichen.

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 erstellen, der eine lokale SSD verwendet, mit der Methode gcloud CLI oder Batch API verwenden. Im folgenden Beispiel wird beschrieben, wie Sie einen Job erstellen, mit dem Sie eine lokale SSD bereitstellt. Der Job umfasst außerdem 3 Aufgaben Jeder dieser Server führt ein Skript aus, um eine Datei mit dem Namen output_task_TASK_INDEX.txt, wobei TASK_INDEX ist der Index jeder Aufgabe: 0, 1 und 2.

gcloud

So erstellen Sie einen Job, der lokale SSDs verwendet: gcloud CLI verwenden, verwenden Sie die gcloud batch jobs submit-Befehl Erstellen Sie in der JSON-Konfigurationsdatei des Jobs die lokalen SSDs in der instances und stellen Sie die lokalen SSDs im Feld volumes bereit.

  1. Erstellen Sie eine JSON-Datei.

    • Wenn Sie für diesen Job keine Instanzvorlage 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: die Maschinentyp, bei dem es sich um vordefiniert oder benutzerdefiniert, der VMs des Jobs. 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 von alle lokalen SSDs in GB an. Jede lokale SSD hat 375 GB, muss dieser Wert ein Vielfaches von 375 GB sein. Für Legen Sie diesen Wert beispielsweise für zwei lokale SSDs auf 750 GB fest.
    • Wenn Sie mit einer VM-Instanzvorlage für diesen Job, wie oben gezeigt eine JSON-Datei erstellen, außer dass Feld „instances Dabei gilt:

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

      wobei INSTANCE_TEMPLATE_NAME der Name ist der Instanzvorlage für diesen Job. Für einen Job, bei dem lokale SSDs definiert und angehängt wird, lokale SSDs, die der Job verwenden soll. In diesem Beispiel In der Vorlage muss eine lokale SSD mit dem Namen LOCAL_SSD_NAME

  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: Pfad für ein JSON-Objekt mit den Konfigurationsdetails des Jobs.

API

So erstellen Sie einen Job, der lokale SSDs verwendet: Batch API verwenden, verwenden Sie jobs.create-Methode. Erstellen Sie in der Anfrage die lokalen SSDs in der instances und stellen Sie die lokalen SSDs im Feld volumes bereit.

  • Wenn Sie für diesen Job keine Instanzvorlage verwenden, gehen Sie so vor: 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: die Maschinentyp, bei dem es sich um vordefiniert oder benutzerdefiniert, der VMs des Jobs. 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 von alle lokalen SSDs in GB an. Jede lokale SSD hat 375 GB, muss dieser Wert ein Vielfaches von 375 GB sein. Für Legen Sie diesen Wert beispielsweise für zwei lokale SSDs auf 750 GB fest.
  • Wenn Sie mit einer VM-Instanzvorlage für diesen Job, wie oben gezeigt eine JSON-Datei erstellen, außer dass Feld „instances Dabei gilt:

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

    Dabei ist INSTANCE_TEMPLATE_NAME der Name der Instanzvorlage für diesen Job. Für einen Job, bei dem lokale SSDs definiert und angehängt wird, lokale SSDs, die der Job verwenden soll. In diesem Beispiel In der Vorlage muss eine lokale SSD mit dem Namen LOCAL_SSD_NAME

Cloud Storage-Bucket verwenden

So erstellen Sie einen Job, der einen vorhandenen Cloud Storage-Bucket verwendet: wählen Sie eine der folgenden Methoden aus:

  • Empfohlen: Stellen Sie einen Bucket direkt auf den VMs Ihres Jobs bereit. Geben Sie dazu den Parameter Bucket in der Definition des Jobs hinzugefügt, wie in diesem Abschnitt gezeigt. Wenn der Job ausgeführt wird, wird der Bucket automatisch mithilfe von Cloud Storage FUSE
  • Job mit Aufgaben erstellen, die direkt auf ein Cloud Storage-Bucket mit dem gsutil-Befehlszeilentool oder Clientbibliotheken für die Cloud Storage API. Um zu erfahren, wie Sie auf ein Cloud Storage-Bucket direkt von einer VM aus abrufen können, Compute Engine-Dokumentation für Daten in Cloud Storage-Buckets schreiben und daraus lesen

Bevor Sie einen Job erstellen, der einen Bucket verwendet, erstellen Sie einen Bucket oder identifizieren Sie einen vorhanden ist. Weitere Informationen finden Sie unter Buckets erstellen und Buckets auflisten

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

Im folgenden Beispiel wird beschrieben, wie Sie einen Job erstellen, bei dem ein Cloud Storage-Bucket. Der Job hat außerdem 3 Aufgaben, die jeweils ausgeführt werden ein Skript zum Erstellen einer Datei im Bucket namens output_task_TASK_INDEX.txt Dabei ist TASK_INDEX der Index jeder Aufgabe: 0, 1 und 2.

Console

So erstellen Sie einen Job, der einen Cloud Storage-Bucket verwendet, mithilfe der Methode Führen Sie in der Google Cloud Console die folgenden Schritte aus:

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

    Zur Jobliste

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

  3. Konfigurieren Sie die Seite Jobdetails:

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

      Geben Sie beispielsweise example-bucket-job ein.

    2. Konfigurieren Sie den Bereich Aufgabendetails:

      1. Fügen Sie im Fenster New Runnable (Neu ausführbar) mindestens ein Skript hinzu oder Container für die Ausführung dieses Jobs.

        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 die Runnables dieses Jobs für den Zugriff vorhandener Cloud Storage-Bucket. Der Pfad muss beginnen mit /mnt/disks/ gefolgt von einem Verzeichnis oder Pfad, der Ihrer Wahl. Wenn Sie beispielsweise mit dem Verzeichnis my-bucket, legen Sie den Bereitstellungspfad zu /mnt/disks/my-bucket.

        3. Klicken Sie auf Fertig.

      2. Geben Sie in das Feld Aufgabenanzahl die Anzahl der Aufgaben ein, für diesen Job.

        Geben Sie beispielsweise 3 ein.

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

        Geben Sie beispielsweise 1 ein (Standardeinstellung).

  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ür jeden Cloud Storage-Bucket, den Sie bereitstellen möchten gehen Sie so vor:

      1. Klicken Sie im Abschnitt Speichervolumen 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 einen vorhandenen Bucket.

          Geben Sie z. B. den Bucket ein, den Sie in diesem Job ausführbar ist.

        3. Geben Sie im Feld Bereitstellungspfad den Bereitstellungspfad des Bucket (MOUNT_PATH), den Sie das im Runnable angegeben ist.

        4. Klicken Sie auf Fertig.

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

  6. Optional: Um die Jobkonfiguration zu überprüfen, klicken Sie auf Vorschau.

  7. Klicken Sie auf Erstellen.

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

gcloud

So erstellen Sie einen Job, der einen Cloud Storage-Bucket verwendet, mithilfe der Methode gcloud CLI verwenden, verwenden Sie die gcloud batch jobs submit-Befehl Stellen Sie den Bucket in der JSON-Konfigurationsdatei des Jobs im volumes.

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: Pfad des Bucket-Verzeichnisses auf den dieser Job zugreifen soll. Er muss mit dem Namen aus dem Bucket. Für einen Bucket namens BUCKET_NAME, der Pfad BUCKET_NAME steht für das Stammverzeichnis des Buckets und dem Pfad BUCKET_NAME/subdirectory steht für das Unterverzeichnis subdirectory.
    • MOUNT_PATH: der Bereitstellungspfad des Jobs die Runnables verwenden, um auf diesen Bucket zuzugreifen. Der Pfad muss mit /mnt/disks/ gefolgt von einem Verzeichnis oder Pfad Ihrer Wahl. Für Wenn Sie diesen Bucket mit einem Verzeichnis namens my-bucket, 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: Pfad für ein JSON-Objekt mit den Konfigurationsdetails des Jobs.

API

So erstellen Sie einen Job, der einen Cloud Storage-Bucket verwendet, mithilfe der Methode Batch API verwenden, verwenden Sie jobs.create-Methode 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: Pfad des Bucket-Verzeichnisses auf den dieser Job zugreifen soll. Er muss mit dem Namen des Buckets. Für einen Bucket namens BUCKET_NAME, der Pfad BUCKET_NAME steht für die Wurzel. Verzeichnis des Buckets und Pfad BUCKET_NAME/subdirectory steht für das Unterverzeichnis subdirectory.
  • MOUNT_PATH: der Bereitstellungspfad des Jobs die Runnables verwenden, um auf diesen Bucket zuzugreifen. Der Pfad muss mit /mnt/disks/ gefolgt von einem Verzeichnis oder Pfad Ihrer Wahl. Wenn Sie diesen Bucket beispielsweise mit einem im Verzeichnis my-bucket, legen Sie den Bereitstellungspfad auf /mnt/disks/my-bucket.

Go

Go

Weitere Informationen finden Sie in der Batch Go API Referenzdokumentation.

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 finden Sie in der Batch Java API Referenzdokumentation.

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 finden Sie in der Batch Node.js API Referenzdokumentation.

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 finden Sie in der Batch Python API Referenzdokumentation.

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 finden Sie in der Batch C++ API Referenzdokumentation.

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, wie eine Filestore-Dateifreigabe über die Google Cloud Console, die gcloud CLI oder Batch API

Prüfen Sie vor dem Erstellen eines Jobs, der ein NFS verwendet, dass die Firewall des Netzwerks so konfiguriert ist, dass der Datenverkehr zwischen die VMs und das NFS Ihres Jobs. Weitere Informationen finden Sie unter Firewallregeln für Filestore konfigurieren

Im folgenden Beispiel wird beschrieben, wie Sie einen Job erstellen, der stellt ein NFS bereit. Der Job hat außerdem 3 Aufgaben, die jeweils ein Skript ausführen, um eine Datei im NFS mit dem Namen output_task_TASK_INDEX.txt Dabei ist TASK_INDEX der Index jeder Aufgabe: 0, 1 und 2.

Console

So erstellen Sie mit der Google Cloud Console einen Job, der ein NFS verwendet: Gehen Sie so vor:

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

    Zur Jobliste

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

  3. Konfigurieren Sie die Seite Jobdetails:

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

      Geben Sie beispielsweise example-nfs-job ein.

    2. Konfigurieren Sie den Bereich Aufgabendetails:

      1. Fügen Sie im Fenster New Runnable (Neu ausführbar) mindestens ein Skript hinzu oder Container für die Ausführung dieses Jobs.

        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 die ausführbare Datei des Jobs für den Zugriff auf dieses NFS verwendet. Der Pfad muss mit /mnt/disks/ beginnen, gefolgt von einem Verzeichnis oder Pfad Ihrer Wahl. Wenn Sie beispielsweise dieses NFS mit einem Verzeichnis namens my-nfs, legen Sie den Bereitstellungspfad auf /mnt/disks/my-nfs fest.

        3. Klicken Sie auf Fertig.

      2. Geben Sie in das Feld Aufgabenanzahl die Anzahl der Aufgaben ein, für diesen Job.

        Geben Sie beispielsweise 3 ein.

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

        Geben Sie beispielsweise 1 ein (Standardeinstellung).

  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ür jeden Cloud Storage-Bucket, den Sie bereitstellen möchten gehen Sie so vor:

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

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

        1. Gehen Sie im Bereich Volume-Typ so vor: Wählen Sie Netzwerkdateisystem aus.

        2. Geben Sie in das Feld Dateiserver die IP-Adresse des Server mit dem NFS, den Sie in der ausführbaren Datei dieses Jobs angegeben haben, befindet.

          Wenn Ihr NFS beispielsweise ein Filestore-Dateifreigabe, Geben Sie dann die IP-Adresse von Filestore an. die Sie erhalten, indem Sie beschreiben der Filestore-Instanz

        3. Geben Sie im Feld Remote-Pfad einen Pfad ein, der auf das NFS, das Sie im vorherigen Schritt angegeben haben.

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

        4. Geben Sie im Feld Bereitstellungspfad den Bereitstellungspfad zum NFS ein (MOUNT_PATH), die Sie in aus dem vorherigen Schritt.

    3. Klicken Sie auf Fertig.

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

  6. Optional: Um die Jobkonfiguration zu überprüfen, klicken Sie auf Vorschau.

  7. Klicken Sie auf Erstellen.

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

gcloud

So erstellen Sie einen Job, der ein NFS verwendet, mithilfe der Methode gcloud CLI verwenden, verwenden Sie die gcloud batch jobs submit-Befehl Stellen Sie das NFS in der JSON-Konfigurationsdatei des Jobs in der volumes.

  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 zum Beispiel NFS ist eine Filestore-Dateifreigabe, die IP-Adresse von Filestore angeben die Sie erhalten, indem Sie beschreiben der Filestore-Instanz
    • NFS_PATH: Pfad des NFS-Verzeichnisses auf den dieser Job zugreifen soll. Er muss mit einem / beginnen. gefolgt vom Stammverzeichnis des NFS. Beispiel: Für eine Filestore-Dateifreigabe mit dem Namen FILE_SHARE_NAME, der Pfad /FILE_SHARE_NAME steht für die Wurzel Verzeichnis der Dateifreigabe und den Pfad /FILE_SHARE_NAME/subdirectory steht für das Unterverzeichnis subdirectory.
    • MOUNT_PATH: der Bereitstellungspfad des Jobs Runnables verwenden, um auf dieses NFS zuzugreifen. Der Pfad muss mit /mnt/disks/ gefolgt von einem Verzeichnis oder Pfad Ihrer Wahl. Wenn Sie dieses NFS beispielsweise mit einem Verzeichnis namens my-nfs 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: Pfad für ein JSON-Objekt mit den Konfigurationsdetails des Jobs.

API

So erstellen Sie einen Job, der ein NFS verwendet, mithilfe der Methode Batch API verwenden, verwenden Sie jobs.create-Methode und stellen Sie das NFS 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": [
                    {
                        "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 Network File Systems. Wenn zum Beispiel NFS ist eine Filestore-Dateifreigabe, die IP-Adresse von Filestore angeben die Sie erhalten, indem Sie beschreiben der Filestore-Instanz
  • NFS_PATH: Pfad des NFS-Verzeichnisses auf den dieser Job zugreifen soll. Er muss mit einem / beginnen. gefolgt vom Stammverzeichnis des NFS. Beispiel: Für eine Filestore-Dateifreigabe mit dem Namen FILE_SHARE_NAME, der Pfad /FILE_SHARE_NAME steht für die Wurzel Verzeichnis der Dateifreigabe und den Pfad /FILE_SHARE_NAME/subdirectory für ein Unterverzeichnis.
  • MOUNT_PATH: der Bereitstellungspfad des Jobs Runnables verwenden, um auf dieses NFS zuzugreifen. Der Pfad muss mit /mnt/disks/ gefolgt von einem Verzeichnis oder Pfad Ihrer Wahl. Wenn Sie dieses NFS beispielsweise mit einem Verzeichnis namens my-nfs den Bereitstellungspfad auf /mnt/disks/my-nfs fest.

Nächste Schritte