Jobs erstellen und ausführen, die GPUs verwenden

In diesem Dokument wird beschrieben, wie Sie einen Job erstellen und ausführen, der eine Grafikprozessoreinheit (GPU) verwendet. Weitere Informationen zu den Funktionen und Einschränkungen von GPUs finden Sie in der Compute Engine-Dokumentation unter GPUs.

Wenn Sie einen Batchjob erstellen, können Sie optional GPUs verwenden, um bestimmte Arbeitslasten zu beschleunigen. Gängige Anwendungsfälle für Jobs mit GPUs sind intensive Datenverarbeitung und Arbeitslasten für künstliche Intelligenz (KI) wie maschinelles Lernen (ML).

Hinweise

  1. Wenn Sie Batch noch nicht verwendet haben, lesen Sie den Hilfeartikel Batch-Dateien erstellen und ausführen und aktivieren Sie Batch, indem Sie die Voraussetzungen für Projekte und Nutzer erfüllen.

  2. Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen eines Jobs benötigen:

    Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

    Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Job erstellen, der GPUs verwendet

So erstellen Sie einen Job, der GPUs verwendet:

  1. Anforderungen für einen Job planen, der GPUs verwendet
  2. Erstellen Sie einen Job mit den von Ihnen ermittelten Anforderungen und Methoden. Beispiele zum Erstellen eines Jobs mit den empfohlenen Optionen finden Sie in diesem Dokument unter Beispieljob mit GPUs erstellen.

Anforderungen für einen Job mit GPUs planen

Bevor Sie einen Job erstellen, der GPUs verwendet, planen Sie die Anforderungen des Jobs wie in den folgenden Abschnitten beschrieben:

  1. GPU-Maschinentyp und Bereitstellungsmethode auswählen
  2. GPU-Treiber installieren
  3. Kompatible VM-Ressourcen definieren

Schritt 1: GPU-Maschinentyp und Bereitstellungsmethode auswählen

Die Anforderungen eines Jobs variieren je nach bevorzugtem GPU-Maschinentyp und Bereitstellungsmethode. Die Optionen für beide sind möglicherweise voneinander abhängig. Je nach Ihren Anforderungen und Prioritäten können Sie zuerst den GPU-Maschinentyp oder zuerst die Bereitstellungsmethode auswählen. Im Allgemeinen wirkt sich der GPU-Maschinentyp hauptsächlich auf die Leistung und die Grundpreise aus. Die Bereitstellungsmethode wirkt sich hauptsächlich auf die Ressourcenverfügbarkeit und zusätzliche Kosten oder Rabatte aus.

GPU-Maschinentyp auswählen

Die verfügbaren GPU-Maschinentypen (gültige Kombinationen aus GPU-Typ, Anzahl der GPUs und Maschinentyp (vCPUs und Arbeitsspeicher)) und ihre Anwendungsfälle sind auf der Seite GPU-Maschinentypen in der Compute Engine-Dokumentation aufgeführt.

Die für einen Job erforderlichen Felder zur Angabe eines GPU-Maschinentyps variieren je nach Kategorie in der folgenden Tabelle:

GPU-Maschinentypen und ihre Jobanforderungen

GPUs für beschleunigungsoptimierte VMs: VMs mit einem Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie sind automatisch mit einem bestimmten Typ und einer bestimmten Anzahl dieser GPUs verbunden.

Wenn Sie GPUs für beschleunigungsoptimierte VMs verwenden möchten, empfehlen wir Ihnen, den Maschinentyp anzugeben. Jeder beschleunigungsoptimierte Maschinentyp unterstützt nur einen bestimmten Typ und eine bestimmte Anzahl von GPUs. Daher ist es funktional gleichgültig, ob Sie diese Werte zusätzlich zum beschleunigungsoptimierten Maschinentyp angeben oder nicht.

Insbesondere unterstützt Batch auch die Angabe von nur Typ und Anzahl der GPUs für beschleunigungsoptimierte VMs. Die daraus resultierenden vCPU- und Arbeitsspeicheroptionen sind jedoch oft sehr begrenzt. Wir empfehlen daher, zu prüfen, ob die verfügbaren vCPU- und Speicheroptionen mit den Anforderungen der Aufgabe kompatibel sind.

GPUs für N1-VMs: Bei diesen GPUs müssen Sie den Typ und die Anzahl angeben, die an jede VM angehängt werden soll. Sie müssen an VMs mit einem Maschinentyp aus der N1-Maschinenreihe angehängt werden.

Wenn Sie GPUs für N1-VMs verwenden möchten, sollten Sie mindestens den GPU-Typ und die Anzahl der GPUs angeben. Die Kombination der Werte muss mit einer der gültigen GPU-Optionen für die N1-Maschinentypen übereinstimmen. Die vCPU- und Arbeitsspeicheroptionen für N1-VMs mit einem bestimmten GPU-Typ und einer bestimmten GPU-Anzahl sind recht flexibel. Sofern Sie den Job nicht mit der Google Cloud Console erstellen, können Sie Batch automatisch einen Maschinentyp auswählen lassen, der die Aufgabenanforderungen des Jobs erfüllt.
Bereitstellungsmethode auswählen

Batch verwendet je nach Art der angeforderten Ressourcen unterschiedliche Methoden, um die VM-Ressourcen für Jobs bereitzustellen, die GPUs verwenden. Die verfügbaren Bereitstellungsmethoden und ihre Anforderungen werden in der folgenden Tabelle erläutert. Sie sind nach Anwendungsfall aufgelistet, von der höchsten bis zur niedrigsten Ressourcenverfügbarkeit.

Zusammenfassend empfehlen wir den meisten Nutzern Folgendes:

  • Wenn Sie A3-GPU-Maschinentypen ohne Reservierung verwenden möchten, verwenden Sie den Dynamic Workload Scheduler für Batch (Vorabversion).

  • Verwenden Sie für alle anderen GPU-Maschinentypen die Standardbereitstellungsmethode. Die Standardbereitstellungsmethode ist in der Regel „On-Demand“. Eine Ausnahme besteht, wenn Ihr Projekt nicht verwendete Reservierungen enthält, die der Job automatisch nutzen kann.

Bereitstellungsmethoden und ihre Jobanforderungen

Reservierungen

  • Anwendungsfall: Wir empfehlen Reservierungen für Jobs, wenn Sie eine sehr hohe Verfügbarkeit von Ressourcen benötigen oder bereits vorhandene Reservierungen haben, die möglicherweise nicht genutzt werden.

  • Details: Für eine Reservierung fallen die Kosten für die angegebene(n) VM(s) zum gleichen Preis wie für die Ausführung der VM(s) an, bis Sie die Reservierung löschen. Für VMs, die eine Reservierung nutzen, fallen keine separaten Kosten an. Für Reservierungen fallen jedoch unabhängig von der Nutzung Kosten an.

Batch verwendet Reservierungen für Jobs, die nicht verwendete Reservierungen verbrauchen können. Weitere Informationen zu Reservierungen und ihren Anforderungen finden Sie auf der Seite Ressourcenverfügbarkeit mit VM-Reservierungen gewährleisten.

Dynamischer Arbeitslastplaner für Batch-Jobs (Vorabversion)

  • Anwendungsfall: Wir empfehlen den Dynamic Workload Scheduler, wenn Sie GPUs für VMs mit einem Maschinentyp aus der A3-Maschinenreihe verwenden möchten, ohne eine Reservierung zu verbrauchen.

  • Details: Mit dem Dynamic Workload Scheduler können Sie einfacher gleichzeitig auf viele Ressourcen zugreifen, die KI- und ML-Arbeitslasten beschleunigen. Der Dynamic Workload Scheduler kann beispielsweise bei der Jobplanung hilfreich sein, da er Verzögerungen oder Probleme aufgrund von nicht verfügbaren Ressourcen minimiert.

Der Dynamic Workload Scheduler wird in Batch für Jobs verwendet, die folgende Eigenschaften haben:

  • Geben Sie einen A3-GPU-Maschinentyp an.
  • Reservierungen blockieren Insbesondere muss das Feld reservation im Job auf NO_RESERVATION gesetzt sein. Weitere Informationen finden Sie unter Job erstellen und ausführen, der keine reservierten VMs nutzen kann.
  • Verwenden Sie keine Spot-VMs. Konkret kann der Job entweder das Feld provisioningModel weglassen oder das Feld provisioningModel auf STANDARD setzen.

On demand

  • Anwendungsfall: Für alle anderen Jobs empfehlen wir die On-Demand-Ausführung.

  • Details: On-Demand ist in der Regel die Standardmethode für den Zugriff auf Compute Engine-VMs. Bei On-Demand können Sie Ressourcen auf VM-Ebene anfordern und (sofern verfügbar) sofort darauf zugreifen.

Batch verwendet On-Demand für alle anderen Jobs.

Spot-VMs

  • Nutzungsfall: Wir empfehlen, Spot-VMs zu verwenden, um die Kosten für fehlertolerante Arbeitslasten zu senken.

  • Details: Spot-VMs bieten erhebliche Rabatte, sind aber möglicherweise nicht immer verfügbar und können jederzeit vorzeitig beendet werden. Weitere Informationen finden Sie in der Compute Engine-Dokumentation unter Spot-VMs.

Batch verwendet Spot-VMs für Jobs, bei denen das Feld provisioningModel auf SPOT festgelegt ist.

Schritt 2: GPU-Treiber installieren

Wenn Sie GPUs für einen Job verwenden möchten, müssen Sie die GPU-Treiber installieren. Sie haben folgende Möglichkeiten, GPU-Treiber zu installieren:

  • GPU-Treiber automatisch installieren (nach Möglichkeit empfohlen): Wie in den Beispielen gezeigt, können Sie das Feld installGpuDrivers für den Job auf true festlegen, damit Batch die erforderlichen GPU-Treiber von einem Drittanbieter-Speicherort abholt und in Ihrem Namen installiert. Diese Methode wird empfohlen, wenn Sie bei Ihrer Arbeit keine Treiber manuell installieren müssen.

    Optional: Wenn Sie angeben möchten, welche Version des GPU-Treibers mit dem Batch installiert werden soll, legen Sie auch das Feld driverVersion fest.

  • GPU-Treiber manuell installieren:Diese Methode ist erforderlich, wenn eine der folgenden Bedingungen erfüllt ist:

    Für die manuelle Installation der erforderlichen GPU-Treiber wird die folgende Methode empfohlen:

    1. Erstellen Sie ein benutzerdefiniertes VM-Image, das die GPU-Treiber enthält.

      1. Führen Sie zum Installieren von GPU-Treibern ein Installationsskript für das gewünschte Betriebssystem aus:

      2. Wenn Ihr Job Container-Ausführprogramme enthält und nicht Container-Optimized OS verwendet, müssen Sie auch das NVIDIA Container Toolkit installieren.

    2. Wenn Sie einen Job erstellen und einreichen, der GPUs verwendet, geben Sie das benutzerdefinierte VM-Image an, das die GPU-Treiber enthält, und legen Sie das Feld installGpuDrivers für den Job auf false (Standard) fest.

Schritt 3: Kompatible VM-Ressourcen definieren

Informationen zu den Anforderungen und Optionen für die Definition der VM-Ressourcen für einen Job finden Sie unter Jobressourcen.

Zusammenfassend müssen Sie beim Definieren der VM-Ressourcen für einen Job, der GPUs verwendet, Folgendes tun:

  • Achten Sie darauf, dass der GPU-Maschinentyp am Speicherort der VMs Ihres Jobs verfügbar ist.

    Informationen dazu, wo GPU-Maschinentypen verfügbar sind, finden Sie in der Compute Engine-Dokumentation unter GPU-Verfügbarkeit nach Regionen und Zonen.

  • Wenn Sie den Maschinentyp des Jobs angeben, muss dieser genügend vCPUs und Arbeitsspeicher für die Aufgabenanforderungen des Jobs haben. Die Angabe des Maschinentyps des Jobs ist erforderlich, wenn Sie einen Job in der Google Cloud -Konsole erstellen. Sie wird empfohlen, wenn Sie einen Job erstellen, der GPUs für acceleratoroptimierte VMs verwendet.

  • Achten Sie darauf, die VM-Ressourcen für einen Job mit einer gültigen Methode zu definieren:

    • Definieren Sie VM-Ressourcen direkt mithilfe des Felds instances[].policy (nach Möglichkeit empfohlen). Diese Methode wird in den Beispielen veranschaulicht.
    • Definieren Sie VM-Ressourcen über eine Vorlage mithilfe des Felds instances[].instanceTemplate. Diese Methode ist erforderlich, um GPU-Treiber manuell über ein benutzerdefiniertes Image zu installieren. Weitere Informationen finden Sie unter Jobressourcen mit einer VM-Instanzvorlage definieren.

Beispieljob erstellen, der GPUs verwendet

In den folgenden Abschnitten wird beschrieben, wie Sie mit den empfohlenen Optionen einen Beispieljob für jeden GPU-Maschinentyp erstellen. Bei den Beispieljobs werden GPU-Treiber automatisch installiert, VM-Ressourcen direkt definiert und entweder die Bereitstellungsmethode angegeben oder die Standardbereitstellungsmethode verwendet.

GPUs für A3-VMs über Dynamic Workload Scheduler for Batch (Vorabversion) verwenden

Sie können einen Job erstellen, der GPUs für A3-VMs über Dynamic Workload Scheduler mit der gcloud CLI oder der Batch API verwendet.

gcloud

  1. Erstellen Sie eine JSON-Datei, die GPU-Treiber installiert, einen Maschinentyp aus der A3-Maschinenreihe angibt, Reservierungen blockiert und an einem Speicherort ausgeführt wird, der den GPU-Maschinentyp hat.

    Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der GPUs für A3-VMs über den Dynamic Workload Scheduler verwendet, erstellen Sie eine JSON-Datei mit dem folgenden Inhalt:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Ersetzen Sie Folgendes:

    • INSTALL_GPU_DRIVERS: Wenn diese Option auf true festgelegt ist, ruft Batch die für den GPU-Typ erforderlichen Treiber ab, den Sie im Feld policy angeben, von einem Drittanbieter ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standardeinstellung) festlegen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

    • MACHINE_TYPE: ein Maschinentyp aus der A3-Maschinenserie.

    • ALLOWED_LOCATIONS: Optional können Sie das Feld allowedLocations[] verwenden, um eine Region oder bestimmte Zonen in einer Region anzugeben, in der die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 sind beispielsweise alle Zonen in der Region us-central1 zulässig. Geben Sie Standorte an, an denen der für diesen Job erforderliche GPU-Maschinentyp verfügbar ist. Wenn Sie dieses Feld weglassen, muss der GPU-Maschinentyp am Standort des Jobs verfügbar sein.

  2. Verwenden Sie den Befehl gcloud batch jobs submit, um den Job zu erstellen und auszuführen:

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

    Ersetzen Sie Folgendes:

    • JOB_NAME: Der Name des Jobs.

    • LOCATION: den Standort der Stelle.

    • JSON_CONFIGURATION_FILE: der Pfad zu einer JSON-Datei mit den Konfigurationsdetails des Jobs.

API

Stellen Sie eine POST-Anfrage an die jobs.create-Methode, die GPU-Treiber installiert, einen Maschinentyp aus der A3-Maschinenreihe angibt, Reservierungen blockiert und an einem Ort ausgeführt wird, an dem sich der GPU-Maschinentyp befindet.

Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der GPUs für A3-VMs über Dynamic Workload Scheduler verwendet, senden Sie die folgende Anfrage:

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: die Projekt-ID Ihres Projekts.

  • LOCATION: den Standort der Stelle.

  • JOB_NAME: Der Name des Jobs.

  • INSTALL_GPU_DRIVERS: Wenn diese Option auf true festgelegt ist, ruft Batch die für den GPU-Typ erforderlichen Treiber ab, den Sie im Feld policy angeben, von einem Drittanbieter ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standardeinstellung) festlegen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

  • MACHINE_TYPE: ein Maschinentyp aus der A3-Maschinenserie.

  • ALLOWED_LOCATIONS: Optional können Sie das Feld allowedLocations[] verwenden, um eine Region oder bestimmte Zonen in einer Region anzugeben, in denen die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 sind beispielsweise alle Zonen in der Region us-central1 zulässig. Geben Sie Standorte an, an denen der für diesen Job erforderliche GPU-Maschinentyp verfügbar ist. Wenn Sie dieses Feld weglassen, achten Sie darauf, dass der GPU-Maschinentyp am Standort des Jobs verfügbar ist.

GPUs für beschleunigungsoptimierte VMs verwenden

Sie können einen Job erstellen, der GPUs für beschleunigeroptimierte VMs verwendet. Dazu können Sie dieGoogle Cloud -Console, die gcloud CLI, die Batch API, Java, Node.js oder Python verwenden.

Console

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

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

    Jobliste aufrufen

  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-gpu-job ein.

    2. Konfigurieren Sie den Abschnitt Aufgabendetails:

      1. Fügen Sie im Fenster Neues Runnable mindestens ein Script oder einen Container hinzu, das bzw. den dieser Job ausführen soll.

        So erstellen Sie beispielsweise einen einfachen Scriptjob:

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

        2. Geben Sie im Feld das folgende Script ein:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Klicken Sie auf Fertig.

      2. Geben Sie im Feld Task count (Aufgabenanzahl) die Anzahl der Aufgaben für diesen Job ein.

        Geben Sie beispielsweise 3 ein.

      3. Optional: Geben Sie im Feld Parallelität die Anzahl der Aufgaben ein, die gleichzeitig ausgeführt werden sollen.

        Geben Sie beispielsweise 1 (Standardeinstellung) ein.

  4. Konfigurieren Sie die Seite Ressourcenspezifikationen:

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

    2. Optional: Wählen Sie im Abschnitt VM-Bereitstellungsmodell eine der folgenden Optionen für das Bereitstellungsmodell für die VMs dieses Jobs aus:

      • Wenn Ihr Job eine vorzeitige Beendigung verkraften kann und Sie vergünstigte VMs benötigen, wählen Sie Spot aus.

      • Wählen Sie andernfalls Standard (Standardeinstellung) aus.

    3. Wählen Sie den Standort für diese Stelle aus.

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

      2. Führen Sie im Feld Zone einen der folgenden Schritte aus:

        • Wenn Sie diesen Job nur in einer bestimmten Zone ausführen lassen möchten, wählen Sie eine Zone aus.

        • Wählen Sie andernfalls beliebig (Standardeinstellung) aus.

    4. Wählen Sie den GPU-Maschinentyp für die VMs dieses Jobs aus:

      1. Klicken Sie in den Optionen für die Maschinenfamilie auf GPUs.

      2. Wählen Sie im Feld GPU-Typ den GPU-Typ aus. Wählen Sie dann im Feld Anzahl der GPUs die Anzahl der GPUs für jede VM aus.

        Wenn Sie einen der GPU-Typen für beschleunigungsoptimierte VMs ausgewählt haben, ist im Feld Maschinentyp nur eine Option für den Maschinentyp verfügbar, die auf dem Typ und der Anzahl der ausgewählten GPUs basiert.

      3. Wenn Sie GPU-Treiber automatisch installieren möchten, wählen Sie GPU-Treiberinstallation (Standardeinstellung) aus.

    5. Konfigurieren Sie die Menge der für jede Aufgabe erforderlichen VM-Ressourcen:

      1. Geben Sie im Feld Kerne die Anzahl der vCPUs pro Aufgabe ein.

        Geben Sie beispielsweise 1 (Standardeinstellung) ein.

      2. Geben Sie im Feld Speicher die Größe des RAM in GB pro Aufgabe ein.

        Geben Sie beispielsweise 0.5 (Standardeinstellung) ein.

    6. Klicken Sie auf Fertig.

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

  6. Optional: Wenn Sie die Jobkonfiguration überprüfen möchten, klicken Sie im linken Bereich auf Vorschau.

  7. Klicken Sie auf Erstellen.

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

gcloud

  1. Erstellen Sie eine JSON-Datei, die GPU-Treiber installiert, einen Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie angibt und an einem Speicherort ausgeführt wird, der den GPU-Maschinentyp hat.

    Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der GPUs für accelerator-optimierte VMs verwendet, erstellen Sie eine JSON-Datei mit dem folgenden Inhalt:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Ersetzen Sie Folgendes:

    • INSTALL_GPU_DRIVERS: Wenn diese Option auf true festgelegt ist, ruft Batch die für den GPU-Typ erforderlichen Treiber ab, den Sie im Feld policy angeben, von einem Drittanbieter-Speicherort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standardeinstellung) festlegen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

    • MACHINE_TYPE: ein Maschinentyp aus der Beschleunigungsoptimierten Maschinenfamilie.

    • ALLOWED_LOCATIONS: Optional können Sie das Feld allowedLocations[] verwenden, um eine Region oder bestimmte Zonen in einer Region anzugeben, in denen die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 sind beispielsweise alle Zonen in der Region us-central1 zulässig. Geben Sie Standorte an, an denen der für diesen Job erforderliche GPU-Maschinentyp verfügbar ist. Wenn Sie dieses Feld weglassen, achten Sie darauf, dass der GPU-Maschinentyp am Standort des Jobs verfügbar ist.

  2. Verwenden Sie den Befehl gcloud batch jobs submit, um den Job zu erstellen und auszuführen:

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

    Ersetzen Sie Folgendes:

    • JOB_NAME: Der Name des Jobs.

    • LOCATION: den Standort der Stelle.

    • JSON_CONFIGURATION_FILE: der Pfad zu einer JSON-Datei mit den Konfigurationsdetails des Jobs.

API

Stellen Sie eine POST-Anfrage an die Methode jobs.create, die GPU-Treiber installiert, einen Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie angibt und an einem Ort ausgeführt wird, an dem der GPU-Maschinentyp vorhanden ist.

Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der GPUs für accelerator-optimierte VMs verwendet, stellen Sie folgende Anfrage:

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: die Projekt-ID Ihres Projekts.

  • LOCATION: den Standort der Stelle.

  • JOB_NAME: Der Name des Jobs.

  • INSTALL_GPU_DRIVERS: Wenn diese Option auf true festgelegt ist, ruft Batch die für den GPU-Typ erforderlichen Treiber ab, den Sie im Feld policy angeben, von einem Drittanbieter-Speicherort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standardeinstellung) festlegen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

  • MACHINE_TYPE: ein Maschinentyp aus der Beschleunigungsoptimierten Maschinenfamilie.

  • ALLOWED_LOCATIONS: Optional können Sie das Feld allowedLocations[] verwenden, um eine Region oder bestimmte Zonen in einer Region anzugeben, in der die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 sind beispielsweise alle Zonen in der Region us-central1 zulässig. Geben Sie Standorte an, an denen der für diesen Job erforderliche GPU-Maschinentyp verfügbar ist. Wenn Sie dieses Feld weglassen, achten Sie darauf, dass der GPU-Maschinentyp am Standort des Jobs verfügbar ist.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
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.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
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.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJob {

  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 Google 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";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // Accelerator-optimized machine types are available to Batch jobs. See the list
    // of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
    String machineType = "g2-standard-4";

    createGpuJob(projectId, region, jobName, installGpuDrivers, machineType);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String machineType)
      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.
    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! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // 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();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .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(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType(machineType).build();  

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(instancePolicy)
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .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());

      return result;
    }
  }
}

Node.js 

// 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();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// 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
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-l4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'g2-standard-4';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  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 "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.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 callCreateBatchGPUJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchGPUJob();

Python 

from google.cloud import batch_v1


def create_gpu_job(project_id: str, region: str, job_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 on GPU machines.

    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.

    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! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # 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]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    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 "g2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "g2-standard-4"

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # 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)

GPUs für N1-VMs verwenden

Sie können einen Job erstellen, der GPUs für N1-VMs verwendet, mit der Google Cloud -Konsole, der gcloud CLI, der Batch API, Java, Node.js oder Python.

Console

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

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

    Jobliste aufrufen

  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-gpu-job ein.

    2. Konfigurieren Sie den Abschnitt Aufgabendetails:

      1. Fügen Sie im Fenster Neues Runnable mindestens ein Script oder einen Container hinzu, das bzw. den dieser Job ausführen soll.

        So erstellen Sie beispielsweise einen einfachen Scriptjob:

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

        2. Geben Sie im Feld das folgende Script ein:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Klicken Sie auf Fertig.

      2. Geben Sie im Feld Task count (Aufgabenanzahl) die Anzahl der Aufgaben für diesen Job ein.

        Geben Sie beispielsweise 3 ein.

      3. Optional: Geben Sie im Feld Parallelität die Anzahl der Aufgaben ein, die gleichzeitig ausgeführt werden sollen.

        Geben Sie beispielsweise 1 (Standardeinstellung) ein.

  4. Konfigurieren Sie die Seite Ressourcenspezifikationen:

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

    2. Optional: Wählen Sie im Abschnitt VM-Bereitstellungsmodell eine der folgenden Optionen für das Bereitstellungsmodell für die VMs dieses Jobs aus:

      • Wenn Ihr Job eine vorzeitige Beendigung verkraften kann und Sie vergünstigte VMs benötigen, wählen Sie Spot aus.

      • Wählen Sie andernfalls Standard (Standardeinstellung) aus.

    3. Wählen Sie den Standort für diese Stelle aus.

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

      2. Führen Sie im Feld Zone einen der folgenden Schritte aus:

        • Wenn Sie diesen Job nur in einer bestimmten Zone ausführen lassen möchten, wählen Sie eine Zone aus.

        • Wählen Sie andernfalls beliebig (Standardeinstellung) aus.

    4. Wählen Sie den GPU-Maschinentyp für die VMs dieses Jobs aus:

      1. Klicken Sie in den Optionen für die Maschinenfamilie auf GPUs.

      2. Wählen Sie im Feld GPU-Typ den GPU-Typ aus.

        Wenn Sie einen der GPU-Typen für N1-VMs ausgewählt haben, ist das Feld Reihe auf N1 festgelegt.

      3. Wählen Sie im Feld Anzahl der GPUs die Anzahl der GPUs für jede VM aus.

      4. Wählen Sie im Feld Maschinentyp den Maschinentyp aus.

      5. Wenn Sie GPU-Treiber automatisch installieren möchten, wählen Sie GPU-Treiberinstallation (Standardeinstellung) aus.

    5. Konfigurieren Sie die Menge der für jede Aufgabe erforderlichen VM-Ressourcen:

      1. Geben Sie im Feld Kerne die Anzahl der vCPUs pro Aufgabe ein.

        Geben Sie beispielsweise 1 (Standardeinstellung) ein.

      2. Geben Sie im Feld Speicher die Größe des RAM in GB pro Aufgabe ein.

        Geben Sie beispielsweise 0.5 (Standardeinstellung) ein.

    6. Klicken Sie auf Fertig.

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

  6. Optional: Wenn Sie die Jobkonfiguration überprüfen möchten, klicken Sie im linken Bereich auf Vorschau.

  7. Klicken Sie auf Erstellen.

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

gcloud

  1. Erstellen Sie eine JSON-Datei, die GPU-Treiber installiert, die Unterfelder type und count des Felds accelerators[] definiert und an einem Speicherort ausgeführt wird, der den GPU-Maschinentyp hat.

    Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der GPUs für N1-VMs verwendet und Batch den genauen N1-Maschinentyp auswählen lässt, erstellen Sie eine JSON-Datei mit folgendem Inhalt:

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Ersetzen Sie Folgendes:

    • INSTALL_GPU_DRIVERS: Wenn diese Option auf true festgelegt ist, ruft Batch die für den GPU-Typ erforderlichen Treiber ab, den Sie im Feld policy angeben, von einem Drittanbieter ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standardeinstellung) festlegen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

    • GPU_TYPE: GPU-Typ Mit dem Befehl gcloud compute accelerator-types list können Sie eine Liste der verfügbaren GPU-Typen aufrufen. Verwenden Sie dieses Feld nur für GPUs für N1-VMs.

    • GPU_COUNT: die Anzahl der GPUs des angegebenen Typs. Weitere Informationen zu den zulässigen Optionen finden Sie unter GPU-Maschinentypen für die N1-Maschinenserie. Verwenden Sie dieses Feld nur für GPUs für N1-VMs.

    • ALLOWED_LOCATIONS: Optional können Sie das Feld allowedLocations[] verwenden, um eine Region oder bestimmte Zonen in einer Region anzugeben, in der die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 sind beispielsweise alle Zonen in der Region us-central1 zulässig. Geben Sie Standorte an, an denen der für diesen Job erforderliche GPU-Maschinentyp verfügbar ist. Wenn Sie dieses Feld weglassen, achten Sie darauf, dass der GPU-Maschinentyp am Standort des Jobs verfügbar ist.

  2. Verwenden Sie den Befehl gcloud batch jobs submit, um den Job zu erstellen und auszuführen:

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

    Ersetzen Sie Folgendes:

    • JOB_NAME: Der Name des Jobs.

    • LOCATION: den Standort der Stelle.

    • JSON_CONFIGURATION_FILE: der Pfad zu einer JSON-Datei mit den Konfigurationsdetails des Jobs.

API

Stellen Sie eine POST-Anfrage an die jobs.create-Methode, die GPU-Treiber installiert, die Unterfelder type und count des Felds accelerators[] definiert und einen Speicherort mit dem GPU-Maschinentyp verwendet.

Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der GPUs für N1-VMs verwendet und Batch den genauen N1-Maschinentyp auswählen lässt, stellen Sie folgende Anfrage:

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: die Projekt-ID Ihres Projekts.

  • LOCATION: den Standort der Stelle.

  • JOB_NAME: Der Name des Jobs.

  • INSTALL_GPU_DRIVERS: Wenn diese Option auf true festgelegt ist, ruft Batch die für den GPU-Typ erforderlichen Treiber ab, den Sie im Feld policy angeben, von einem Drittanbieter ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standardeinstellung) festlegen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

  • GPU_TYPE: GPU-Typ Mit dem Befehl gcloud compute accelerator-types list können Sie eine Liste der verfügbaren GPU-Typen aufrufen. Verwenden Sie dieses Feld nur für GPUs für N1-VMs.

  • GPU_COUNT: die Anzahl der GPUs des angegebenen Typs. Weitere Informationen zu den zulässigen Optionen finden Sie unter GPU-Maschinentypen für die N1-Maschinenserie. Verwenden Sie dieses Feld nur für GPUs für N1-VMs.

  • ALLOWED_LOCATIONS: Optional können Sie das Feld allowedLocations[] verwenden, um eine Region oder bestimmte Zonen in einer Region anzugeben, in denen die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 sind beispielsweise alle Zonen in der Region us-central1 zulässig. Geben Sie Standorte an, an denen der für diesen Job erforderliche GPU-Maschinentyp verfügbar ist. Wenn Sie dieses Feld weglassen, muss der GPU-Maschinentyp am Standort des Jobs verfügbar sein.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
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.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
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.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJobN1 {

  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 Google 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";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // The GPU type. You can view a list of the available GPU types
    // by using the `gcloud compute accelerator-types list` command.
    String gpuType = "nvidia-tesla-t4";
    // The number of GPUs of the specified type.
    int gpuCount = 2;

    createGpuJob(projectId, region, jobName, installGpuDrivers, gpuType, gpuCount);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String gpuType, int gpuCount)
      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.
    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! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // 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();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .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(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Accelerator describes Compute Engine accelerators to be attached to the VM.
      Accelerator accelerator = Accelerator.newBuilder()
          .setType(gpuType)
          .setCount(gpuCount)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(InstancePolicy.newBuilder().addAccelerators(accelerator))
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .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());

      return result;
    }
  }
}

Node.js 

// 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();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// 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
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-gpu-job-n1';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-tesla-t4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'n1-standard-16';

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  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 "g2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.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 callCreateBatchGPUJobN1() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchGPUJobN1();

Python 

from google.cloud import batch_v1


def create_gpu_job(
    project_id: str, region: str, zone: str, job_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 on GPU machines.

    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
        zone: name of the zone you want to use to run the job. Important in regard to GPUs availability.
            GPUs availability can be found here: https://cloud.google.com/compute/docs/gpus/gpu-regions-zones
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    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! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # 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]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    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.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-16"

    accelerator = batch_v1.AllocationPolicy.Accelerator()
    # Note: not every accelerator is compatible with instance type
    # Read more here: https://cloud.google.com/compute/docs/gpus#t4-gpus
    accelerator.type_ = "nvidia-tesla-t4"
    accelerator.count = 1

    policy.accelerators = [accelerator]
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = ["zones/us-central1-b"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # 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)

Nächste Schritte