Einen Job erstellen und ausführen, der GPUs verwendet

In diesem Dokument wird erläutert, wie Sie einen Job erstellen und ausführen, der einen Grafikprozessor (GPU) verwendet. Weitere Informationen zu den Features und Einschränkungen für 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. Zu den gängigen Anwendungsfällen für Jobs, die GPUs verwenden, gehören intensive Datenverarbeitung und Arbeitslasten für künstliche Intelligenz (KI) wie maschinelles Lernen (ML). Alternativ können Sie KI- und ML-Arbeitslasten beschleunigen, indem Sie stattdessen TPUs verwenden.

Hinweis

  1. Wenn Sie Batch noch nicht verwendet haben, lesen Sie die Informationen unter Erste Schritte mit Batch 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. Konfiguration für einen Job planen, der GPUs verwendet
  2. Erstellen Sie einen Job mit den von Ihnen ermittelten Anforderungen und Methoden. Beispiele für das Erstellen eines Jobs mit den empfohlenen Optionen finden Sie in diesem Dokument unter Job erstellen, der GPUs verwendet.

Konfiguration für einen Job planen, der GPUs verwendet

Bevor Sie einen Job erstellen, der GPUs verwendet, sollten Sie die Konfigurationsanforderungen des Jobs planen, wie in den folgenden Abschnitten erläutert:

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

Schritt 1: GPU-Maschinentyp und Nutzungsoption auswählen

Die Anforderungen eines Jobs variieren je nach bevorzugtem GPU-Maschinentyp und der Nutzungsvariante. Die Optionen für die einzelnen Typen können voneinander abhängig sein.

So wählen Sie den GPU-Maschinentyp und die Nutzungsoption für Ihren Job aus:

  1. Wählen Sie Ihre Priorität aus:

    • Wenn Sie Leistung und Basispreise priorisieren möchten, lesen Sie den Abschnitt GPU-Maschinentyp auswählen in diesem Dokument.
    • Wenn Sie die Ressourcenverfügbarkeit oder Rabatte priorisieren möchten, lesen Sie den Abschnitt Verbrauchsoption auswählen in diesem Dokument.

  2. Treffen Sie die restliche Auswahl basierend auf dem, was mit Ihrer ersten Auswahl kompatibel ist.

    1. Informationen zu den Optionen, die mit Ihrer ersten Auswahl kompatibel sind, finden Sie in der Compute Engine-Dokumentation unter Verfügbarkeit von Verbrauchsoptionen nach Maschinentyp.

    2. Weitere Informationen finden Sie im verbleibenden Abschnitt für Nutzungsvariante auswählen bzw. GPU-Maschinentyp auswählen.

GPU-Maschinentyp auswählen

So wählen Sie den GPU-Maschinentyp für einen Job aus und ermitteln die Jobanforderungen:

  1. GPU-Maschinentyp auswählen: Informationen zu den verfügbaren GPU-Maschinentypen (gültige Kombinationen aus GPU-Typ, Anzahl der GPUs und Maschinentyp (vCPUs und Arbeitsspeicher)) und den empfohlenen Anwendungsfällen finden Sie in der Compute Engine-Dokumentation unter GPU-Maschinentypen und Beschleunigeroptimierte Maschinenfamilie.

  2. Anforderungen an den Job für Ihren GPU-Maschinentyp: Die Felder, die für einen Job erforderlich sind, um einen GPU-Maschinentyp anzugeben, variieren je nach den Kategorien in der folgenden Tabelle:

    GPU-Maschinentypen und ihre Jobanforderungen

    GPUs für beschleunigungsoptimierte VMs: VMs mit einem Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie haben automatisch einen bestimmten Typ und eine bestimmte Anzahl dieser GPUs angehängt.

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

    Batch unterstützt auch die Angabe nur des Typs und der Anzahl der GPUs für beschleunigungsoptimierte VMs, aber die resultierenden vCPU- und Arbeitsspeicheroptionen sind oft sehr begrenzt. Wir empfehlen daher, zu prüfen, ob die verfügbaren vCPU- und Arbeitsspeicheroptionen mit den Aufgabenanforderungen des Jobs 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 sollen. Sie müssen an VMs mit einem Maschinentyp aus der N1-Maschinenserie angehängt werden.

    Wenn Sie GPUs für N1-VMs verwenden möchten, empfehlen wir, mindestens den GPU-Typ und die Anzahl der GPUs anzugeben. Achten Sie darauf, dass die Kombination der Werte mit einer der gültigen GPU-Optionen für die N1-Maschinentypen übereinstimmt. Die vCPU- und Arbeitsspeicheroptionen für N1-VMs, die einen bestimmten Typ und eine bestimmte Anzahl von GPUs verwenden, sind sehr flexibel. Wenn Sie den Job nicht mit der Google Cloud Console erstellen, können Sie Batch automatisch einen Maschinentyp auswählen lassen, der die Anforderungen des Jobs erfüllt.
Nutzungsoption auswählen

In diesem Abschnitt wird zusammengefasst, wie Sie die Verbrauchsoption für einen Job auswählen und welche Jobanforderungen für die einzelnen Optionen gelten.

In der folgenden Tabelle werden die verfügbaren Verbrauchsoptionen für Batch und die zugehörigen Jobanforderungen erläutert. In dieser Tabelle sind die Verbrauchsoptionen nach ihren Anwendungsfällen aufgeführt, von der höchsten bis zur niedrigsten Verfügbarkeit. Achten Sie darauf, dass die von Ihnen ausgewählte Nutzungsvariante auch Ihren Anforderungen an Preise, Laufzeit und Maschinentypunterstützung entspricht. Weitere Informationen zur Auswahl einer Verbrauchsoption finden Sie unter Ressourcenverfügbarkeit verbessern, in der Compute Engine-Dokumentation zu Bereitstellungsmodellen und in der AI Hypercomputer-Dokumentation zu Verbrauchsoptionen.

Nutzungsoptionen und ihre Jobanforderungen

Reservierungen

  • Anwendungsfall: Wir empfehlen Reservierungen für Jobs, wenn Sie eine sehr hohe Sicherheit der Ressourcenverfügbarkeit benötigen und keine Reservierungen im Kalendermodus verwenden können oder wenn Sie bereits vorhandene Reservierungen haben, die möglicherweise nicht verwendet werden.

  • Details: Nach dem Erstellen einer Reservierung fallen die Kosten für die angegebenen VMs an, die dem Preis für die Ausführung der VMs entsprechen, 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.

    Weitere Informationen zu Reservierungen finden Sie in der Compute Engine-Dokumentation.

Batch verwendet Reservierungen für Jobs, die nicht verwendete reservierte VMs nutzen können. Weitere Informationen zu den Jobanforderungen für die Nutzung von Reservierungen finden Sie auf der Seite Ressourcenverfügbarkeit mit VM-Reservierungen sicherstellen.

Reservierungen im Kalendermodus

  • Anwendungsfall: Wir empfehlen Reservierungen im Kalendermodus für Jobs, wenn Sie einen GPU-Maschinentyp verwenden möchten, der Reservierungen im Kalendermodus unterstützt, und eine sehr hohe Sicherheit der Ressourcenverfügbarkeit für mindestens 1 Tag und bis zu 90 Tage benötigen.

  • Details: Bevor Sie einen Job erstellen, müssen Sie eine Reservierung im Kalendermodus anfordern oder identifizieren, die Sie nutzen können. Wenn Compute Engine eine vorausschauende Reservierungsanfrage im Kalendermodus erfüllt, fallen für die automatisch erstellte Reservierung im Kalendermodus dieselben Kosten an wie für die Ausführung der angegebenen VMs während des gesamten Reservierungszeitraums zu den Preisen für Dynamic Workload Scheduler, die Rabatte von bis zu 53 % auf die On-Demand-Preise bieten. Nachdem Sie eine automatisch erstellte Reservierung im Kalendermodus identifiziert haben, die Sie verwenden können, ist das Erstellen eines Jobs, der eine Reservierung im Kalendermodus nutzt, sehr ähnlich wie das Erstellen eines Jobs, der eine Reservierung nutzt.

    Weitere Informationen zu Reservierungen im Kalendermodus finden Sie in der Compute Engine-Dokumentation.

Batch verwendet Reservierungen im Kalendermodus für Jobs, die alle folgenden Kriterien erfüllen:

Flex-Start-VMs

  • Anwendungsfall: Wir empfehlen Flex-Start-VMs, wenn Ihr Job mit einer Best-Effort-Verfügbarkeit auskommt und Sie dafür einen Rabatt und bis zu 7 Tage Zeit für die Ausführung erhalten.

    Im Vergleich zu On-Demand- und Spot-VMs können Sie mit Flex-Start-VMs einfacher gleichzeitig auf viele GPU-Ressourcen zugreifen. Flex-Start-VMs können beispielsweise für die Jobplanung hilfreich sein, da sie Verzögerungen oder Probleme durch nicht verfügbare Ressourcen minimieren.

  • Details: Wenn eine Anfrage zum Erstellen eines Jobs mit Flex-Start-VMs erfüllt wird, werden die VMs zu den Preisen für Dynamic Workload Scheduler abgerechnet. Diese bieten Rabatte von bis zu 53 % gegenüber den On-Demand-Preisen.

    Weitere Informationen zu Flex-Start-VMs finden Sie in der Compute Engine-Dokumentation.

Batch verwendet Flex-Start-VMs für Jobs, die alle folgenden Kriterien erfüllen:

On demand

  • Anwendungsfall: On-Demand ist schnell und einfach zu verwenden und daher die Standardoption für die meisten Jobs.1 Wir empfehlen On-Demand jedoch nicht, wenn eine andere Verbrauchsoption besser zu Ihren Prioritäten passt oder wenn Sie wiederholt Probleme mit der Ressourcenverfügbarkeit haben.

  • Details: On-Demand ist in der Regel die Standardmethode für den Zugriff auf Compute Engine-VMs. Mit On-Demand können Sie bei Bedarf auf Ressourcen zugreifen (sofern verfügbar). Die Ressourcen werden erst gelöscht, wenn entweder der Job abgeschlossen ist oder das Laufzeitlimit erreicht ist.

Batch verwendet für die meisten Jobs standardmäßig On-Demand-Ressourcen. Wenn Sie sicherstellen möchten, dass ein Job On-Demand-Ressourcen verwendet, gehen Sie so vor:1

1Ausnahme: Bei Jobs, die die A3-Maschinenserie verwenden, ist das Standardverhalten einzigartig. Wir empfehlen, On-Demand-VMs nicht zu verwenden und das Feld provisioningModel nicht undefiniert zu lassen. Verwenden Sie stattdessen die Jobanforderungen für Flex-Start-VMs. Die Verwendung von On-Demand-Preisen wird für die A3-Maschinenserie aufgrund der geringen Ressourcenverfügbarkeit nicht empfohlen. Wenn ein Job die A3-Maschinenserie verwendet, Reservierungen blockiert und das Feld provisioningModel entweder nicht definiert oder auf STANDARD gesetzt ist, ist die Standardverbrauchsoption eindeutig: Das Verhalten ähnelt Flex-Start-VMs, wodurch die Laufzeit auf 7 Tage begrenzt wird. Dies wird jedoch nicht empfohlen, da diese Jobs keine Rabatte aus den Preisen für Dynamic Workload Scheduler erhalten. Wenn Ihr Job mit A3-VMs ein Laufzeitlimit von 7 Tagen tolerieren kann, empfehlen wir, Flex-Start-VMs anstelle von On-Demand-VMs zu verwenden. Andernfalls können Sie nicht sicherstellen, dass Jobs mit A3-VMs On-Demand-Ressourcen verwenden, es sei denn, Sie setzen provisioningModel auf STANDARD und prüfen manuell, ob der Job Reservierungen nutzen kann, ohne das Feld reservation auf NO_RESERVATION zu setzen.

Spot-VMs

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

  • Details: Wenn eine Anfrage zum Erstellen eines Jobs, der Spot-VMs verwendet, erfüllt wird, werden die VMs zu Spot-VM-Preisen abgerechnet. Diese können sich häufig ändern und bieten möglicherweise den größten Rabatt, bis zu 91 % Rabatt auf On-Demand-Preise. Spot-VMs sind jedoch möglicherweise nicht immer verfügbar und können jederzeit vorzeitig beendet werden.

    Weitere Informationen zu Spot-VMs und Empfehlungen für Jobs mit Spot-VMs.

Batch verwendet Spot-VMs für Jobs, die alle folgenden Kriterien erfüllen:

Schritt 2: GPU-Treiber installieren

Wenn Sie GPUs für einen Job verwenden möchten, müssen Sie die GPU-Treiber installieren. Wählen Sie eine der folgenden Methoden aus, um GPU-Treiber zu installieren:

  • GPU-Treiber automatisch installieren (wenn möglich empfohlen): Wie in den Beispielen gezeigt, legen Sie das Feld installGpuDrivers für den Job auf true fest, damit Batch die erforderlichen GPU-Treiber von einem Drittanbieter abrufen und in Ihrem Namen installieren kann. Diese Methode wird empfohlen, wenn Sie für Ihren Job keine Treiber manuell installieren müssen.

    Wenn Sie angeben müssen, welche Version des GPU-Treibers von Batch installiert werden soll, legen Sie optional auch das Feld driverVersion fest.

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

    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ührbare Dateien enthält und kein 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 setzen Sie das Feld installGpuDrivers für den Job auf false (Standard).

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 Standort der VMs Ihres Jobs verfügbar ist.

    Informationen dazu, wo GPU-Maschinentypen verfügbar sind, finden Sie in der Compute Engine-Dokumentation unter GPU-Standorte.

  • Wenn Sie den Maschinentyp des Jobs angeben, achten Sie darauf, dass dieser Maschinentyp genügend vCPUs und Arbeitsspeicher für die Aufgabenanforderungen des Jobs hat. Der Maschinentyp des Jobs muss immer angegeben werden, wenn Sie einen Job mit der Google Cloud Console erstellen. Außerdem wird dies empfohlen, wenn Sie einen Job erstellen, der GPUs für beschleunigungsoptimierte VMs verwendet.

  • Definieren Sie die VM-Ressourcen für einen Job mit einer gültigen Methode:

    • VM-Ressourcen direkt mit dem Feld instances[].policy definieren (empfohlen, wenn möglich). Diese Methode wird in den Beispielen gezeigt.
    • VM-Ressourcen über eine Vorlage mit dem Feld instances[].instanceTemplate definieren 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.

Job erstellen, der GPUs verwendet

In den folgenden Abschnitten wird beschrieben, wie Sie für jede Verbrauchsoption einen Beispieljob erstellen. In den Beispieljobs werden die empfohlenen Optionen verwendet: Alle installieren GPU-Treiber automatisch und alle definieren VM-Ressourcen direkt.

Nutzungsoption Beispiel für Jobanweisungen
Reservierungen oder Reservierungen im Kalendermodus

Ressourcenverfügbarkeit mit VM-Reservierungen sicherstellen
Flex-Start-VMs

GPUs und Flex-Start-VMs verwenden
On-Demand- oder Spot-VMs

Wählen Sie je nach GPU-Maschinentyp eine der folgenden Optionen aus:

GPUs und Flex-Start-VMs 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 GPU-Maschinentyp angibt, der Flex-Start-VMs unterstützt, Reservierungen blockiert und an einem Standort ausgeführt wird, der den GPU-Maschinentyp unterstützt.

    Wenn Sie beispielsweise einen einfachen Skriptjob erstellen möchten, der Flex-Start-VMs und GPUs für beschleunigungsoptimierte VMs verwendet, 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": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Ersetzen Sie Folgendes:

    • INSTALL_GPU_DRIVERS: ob GPU-Treiber automatisch installiert werden sollen. Wenn der Wert auf true gesetzt ist, ruft Batch die Treiber, die für den im Feld policy angegebenen GPU-Typ erforderlich sind, von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) setzen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

    • MACHINE_TYPE: ein GPU-Maschinentyp, der Flex-Start-VMs unterstützt. Weitere Informationen finden Sie in der Compute Engine-Dokumentation unter Verfügbarkeit von Verbrauchsoptionen nach Maschinentyp.

    • ALLOWED_LOCATIONS: die zulässigen Standorte für den Job. Achten Sie darauf, dass der Standort für die Compute Engine-Ressourcen des Jobs den GPU-Maschinentyp bietet, den Sie für diesen Job verwenden möchten. Verwenden Sie dazu eine der folgenden Optionen:

      • Wenn Sie das Feld allowedLocations[] weglassen, wird ein Job standardmäßig auf Compute Engine-Ressourcen ausgeführt, die in der Region des Jobstandorts (LOCATION) erstellt werden.
      • Wenn Sie das Feld allowedLocations[] angeben, darf der Job nur auf Compute Engine-Ressourcen ausgeführt werden, die an den angegebenen Standorten erstellt wurden.

  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: der Standort des Jobs.

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

API

Senden Sie eine POST-Anfrage an die Methode jobs.create, die GPU-Treiber installiert, einen GPU-Maschinentyp angibt, der Flex-Start-VMs unterstützt, Reservierungen blockiert und an einem Standort ausgeführt wird, der den GPU-Maschinentyp unterstützt.

Wenn Sie beispielsweise einen einfachen Skriptjob erstellen möchten, der Flex-Start-VMs und GPUs für beschleunigungsoptimierte VMs verwendet, stellen 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": {
                    "provisioningModel":"FLEX_START",
                    "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: der Standort des Jobs.

  • JOB_NAME: Der Name des Jobs.

  • INSTALL_GPU_DRIVERS: ob GPU-Treiber automatisch installiert werden sollen. Wenn der Wert auf true gesetzt ist, ruft Batch die Treiber, die für den im Feld policy angegebenen GPU-Typ erforderlich sind, von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) setzen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

  • MACHINE_TYPE: ein GPU-Maschinentyp, der Flex-Start-VMs unterstützt. Weitere Informationen finden Sie in der Compute Engine-Dokumentation unter Verfügbarkeit von Verbrauchsoptionen nach Maschinentyp.

  • ALLOWED_LOCATIONS: die zulässigen Standorte für den Job. Achten Sie darauf, dass der Standort für die Compute Engine-Ressourcen des Jobs den GPU-Maschinentyp bietet, den Sie für diesen Job verwenden möchten. Verwenden Sie dazu eine der folgenden Optionen:

    • Wenn Sie das Feld allowedLocations[] weglassen, wird ein Job standardmäßig auf Compute Engine-Ressourcen ausgeführt, die in der Region des Jobstandorts (LOCATION) erstellt werden.
    • Wenn Sie das Feld allowedLocations[] angeben, darf der Job nur auf Compute Engine-Ressourcen ausgeführt werden, die an den angegebenen Standorten erstellt wurden.

GPUs für beschleunigungsoptimierte VMs verwenden

Sie können einen Job erstellen, der GPUs für beschleunigungsoptimierte 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 einen Job, der GPUs verwendet, mit der Google Cloud Console:

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

    Zur Jobliste

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

  3. Konfigurieren Sie die Seite Jobdetails:

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

      Geben Sie beispielsweise example-gpu-job ein.

    2. Konfigurieren Sie den Bereich Aufgabendetails:

      1. Fügen Sie im Fenster Neues ausführbares Element mindestens ein Script oder einen Container hinzu, damit dieser Job ausgeführt werden kann.

        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 Skript ein:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Klicken Sie auf Fertig.

      2. Geben Sie im Feld 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 Ressourcenspezifikationen. Die Seite Ressourcenspezifikationen wird geöffnet.

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

      • Wenn Ihr Job eine vorzeitige Beendigung verkraften kann und Sie Spot-VMs mit Rabatt nutzen möchten, wählen Sie Spot aus.

      • Wenn Sie On-Demand-VMs verwenden möchten, wählen Sie Standard (Standardeinstellung) aus.

    3. Wählen Sie den Standort für diesen Job 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 auf eine bestimmte Zone beschränken 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 zulässig, die auf dem Typ und der Anzahl der ausgewählten GPUs basiert.

      3. Wählen Sie GPU-Treiberinstallation (Standard) aus, um GPU-Treiber automatisch zu installieren.

    5. Konfigurieren Sie die Menge an VM-Ressourcen, die für jede Aufgabe erforderlich sind:

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

        Geben Sie beispielsweise 1 (Standardeinstellung) ein.

      2. Geben Sie im Feld Arbeitsspeicher die Größe des Arbeitsspeichers 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: Klicken Sie im linken Bereich auf Vorschau, um die Jobkonfiguration zu prüfen.

  7. Klicken Sie auf Erstellen.

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

gcloud

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

    Wenn Sie beispielsweise einen einfachen Skriptjob erstellen möchten, der GPUs für beschleunigungsoptimierte VMs verwendet, 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Ersetzen Sie Folgendes:

    • INSTALL_GPU_DRIVERS: ob GPU-Treiber automatisch installiert werden sollen. Wenn der Wert auf true gesetzt ist, ruft Batch die Treiber, die für den im Feld policy angegebenen GPU-Typ erforderlich sind, von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) setzen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

    • PROVISIONING_MODEL: das Bereitstellungsmodell für Ihre Verbrauchsoption: entweder STANDARD für On-Demand oder SPOT für Spot-VMs.

    • MACHINE_TYPE: ein Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie.

    • ALLOWED_LOCATIONS: die zulässigen Standorte für den Job. Achten Sie darauf, dass der Standort für die Compute Engine-Ressourcen des Jobs den GPU-Maschinentyp bietet, den Sie für diesen Job verwenden möchten. Verwenden Sie dazu eine der folgenden Optionen:

      • Wenn Sie das Feld allowedLocations[] weglassen, wird ein Job standardmäßig auf Compute Engine-Ressourcen ausgeführt, die in der Region des Jobstandorts (LOCATION) erstellt werden.
      • Wenn Sie das Feld allowedLocations[] angeben, darf der Job nur auf Compute Engine-Ressourcen ausgeführt werden, die an den angegebenen Standorten erstellt wurden.

  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: der Standort des Jobs.

    • JSON_CONFIGURATION_FILE: der Pfad für eine 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 Standort ausgeführt wird, der den GPU-Maschinentyp hat.

Wenn Sie beispielsweise einen einfachen Skriptjob erstellen möchten, der GPUs für beschleunigungsoptimierte VMs verwendet, stellen 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "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: der Standort des Jobs.

  • JOB_NAME: Der Name des Jobs.

  • INSTALL_GPU_DRIVERS: ob GPU-Treiber automatisch installiert werden sollen. Wenn der Wert auf true gesetzt ist, ruft Batch die Treiber, die für den im Feld policy angegebenen GPU-Typ erforderlich sind, von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) setzen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

  • PROVISIONING_MODEL: das Bereitstellungsmodell für Ihre Verbrauchsoption: entweder STANDARD für On-Demand oder SPOT für Spot-VMs.

  • MACHINE_TYPE: ein Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie.

  • ALLOWED_LOCATIONS: die zulässigen Standorte für den Job. Achten Sie darauf, dass der Standort für die Compute Engine-Ressourcen des Jobs den GPU-Maschinentyp bietet, den Sie für diesen Job verwenden möchten. Verwenden Sie dazu eine der folgenden Optionen:

    • Wenn Sie das Feld allowedLocations[] weglassen, wird ein Job standardmäßig auf Compute Engine-Ressourcen ausgeführt, die in der Region des Jobstandorts (LOCATION) erstellt werden.
    • Wenn Sie das Feld allowedLocations[] angeben, darf der Job nur auf Compute Engine-Ressourcen ausgeführt werden, die an den angegebenen Standorten erstellt wurden.

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, indem Sie die Google Cloud Console, die gcloud CLI, die Batch API, Java, Node.js oder Python verwenden.

Console

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

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

    Zur Jobliste

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

  3. Konfigurieren Sie die Seite Jobdetails:

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

      Geben Sie beispielsweise example-gpu-job ein.

    2. Konfigurieren Sie den Bereich Aufgabendetails:

      1. Fügen Sie im Fenster Neues ausführbares Element mindestens ein Script oder einen Container hinzu, damit dieser Job ausgeführt werden kann.

        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 Skript ein:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Klicken Sie auf Fertig.

      2. Geben Sie im Feld 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 Ressourcenspezifikationen. Die Seite Ressourcenspezifikationen wird geöffnet.

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

      • Wenn Ihr Job eine vorzeitige Beendigung verkraften kann und Sie Spot-VMs mit Rabatt nutzen möchten, wählen Sie Spot aus.

      • Wenn Sie On-Demand-VMs verwenden möchten, wählen Sie Standard (Standardeinstellung) aus.

    3. Wählen Sie den Standort für diesen Job 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 auf eine bestimmte Zone beschränken 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, wird das Feld Reihe auf N1 gesetzt.

      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. Wählen Sie GPU-Treiberinstallation (Standard) aus, um GPU-Treiber automatisch zu installieren.

    5. Konfigurieren Sie die Menge an VM-Ressourcen, die für jede Aufgabe erforderlich sind:

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

        Geben Sie beispielsweise 1 (Standardeinstellung) ein.

      2. Geben Sie im Feld Arbeitsspeicher die Größe des Arbeitsspeichers 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: Klicken Sie im linken Bereich auf Vorschau, um die Jobkonfiguration zu prüfen.

  7. Klicken Sie auf Erstellen.

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

gcloud

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

    Wenn Sie beispielsweise einen einfachen Skriptjob 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Ersetzen Sie Folgendes:

    • INSTALL_GPU_DRIVERS: ob GPU-Treiber automatisch installiert werden sollen. Wenn der Wert auf true gesetzt ist, ruft Batch die Treiber, die für den im Feld policy angegebenen GPU-Typ erforderlich sind, von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) setzen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

    • PROVISIONING_MODEL: das Bereitstellungsmodell für Ihre Verbrauchsoption: entweder STANDARD für On-Demand oder SPOT für Spot-VMs.

    • GPU_TYPE: der 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 gültigen 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: die zulässigen Standorte für den Job. Achten Sie darauf, dass der Standort für die Compute Engine-Ressourcen des Jobs den GPU-Maschinentyp bietet, den Sie für diesen Job verwenden möchten. Verwenden Sie dazu eine der folgenden Optionen:

      • Wenn Sie das Feld allowedLocations[] weglassen, wird ein Job standardmäßig auf Compute Engine-Ressourcen ausgeführt, die in der Region des Jobstandorts (LOCATION) erstellt werden.
      • Wenn Sie das Feld allowedLocations[] angeben, darf der Job nur auf Compute Engine-Ressourcen ausgeführt werden, die an den angegebenen Standorten erstellt wurden.

  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: der Standort des Jobs.

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

API

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

Wenn Sie beispielsweise einen einfachen Skriptjob erstellen möchten, der GPUs für N1-VMs verwendet und Batch den genauen N1-Maschinentyp auswählen lässt, stellen 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "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: der Standort des Jobs.

  • JOB_NAME: Der Name des Jobs.

  • INSTALL_GPU_DRIVERS: ob GPU-Treiber automatisch installiert werden sollen. Wenn der Wert auf true gesetzt ist, ruft Batch die Treiber, die für den im Feld policy angegebenen GPU-Typ erforderlich sind, von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) setzen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

  • PROVISIONING_MODEL: das Bereitstellungsmodell für Ihre Verbrauchsoption: entweder STANDARD für On-Demand oder SPOT für Spot-VMs.

  • GPU_TYPE: der 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 gültigen 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: die zulässigen Standorte für den Job. Achten Sie darauf, dass der Standort für die Compute Engine-Ressourcen des Jobs den GPU-Maschinentyp bietet, den Sie für diesen Job verwenden möchten. Verwenden Sie dazu eine der folgenden Optionen:

    • Wenn Sie das Feld allowedLocations[] weglassen, wird ein Job standardmäßig auf Compute Engine-Ressourcen ausgeführt, die in der Region des Jobstandorts (LOCATION) erstellt werden.
    • Wenn Sie das Feld allowedLocations[] angeben, darf der Job nur auf Compute Engine-Ressourcen ausgeführt werden, die an den angegebenen Standorten erstellt wurden.

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