Einen Job erstellen und ausführen, der GPUs verwendet

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 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. Häufige Anwendungsfälle für Jobs, die GPUs verwenden, 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 Abschnitt 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, damit Sie die nötigen Berechtigungen zum Erstellen eines Jobs haben:

    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 Anforderungen und Methoden, die Sie ermittelt haben. Beispiele zum Erstellen eines Jobs mit den empfohlenen Optionen finden Sie in diesem Dokument unter Beispieljob mit GPUs erstellen.

Anforderungen für einen Job planen, der GPUs verwendet

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

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

Schritt 1: GPU-Maschinentyp und Verbrauchsoption auswählen

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

Führen Sie die folgenden Schritte aus, um den GPU-Maschinentyp und die Verbrauchsoption für Ihren Job auszuwählen:

  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 darauf, 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 unter Verbrauchsoption auswählen bzw. GPU-Maschinentyp auswählen.

GPU-Maschinentyp auswählen

Führen Sie die folgenden Schritte aus, um den GPU-Maschinentyp für einen Job auszuwählen und die Jobanforderungen zu verstehen:

  1. GPU-Maschinentyp auswählen:Informationen zu den verfügbaren GPU-Maschinentypen (den gültigen 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 Für Beschleuniger optimierte Maschinentypfamilie.

  2. Jobanforderungen 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 Maschinentypfamilie 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 daher funktional gleichwertig, ob Sie diese Werte zusätzlich zum beschleunigungsoptimierten Maschinentyp angeben oder nicht.

    Insbesondere unterstützt Batch auch die Angabe von Typ und Anzahl der GPUs für beschleunigungsoptimierte VMs, aber die resultierenden vCPU- und Arbeitsspeicheroptionen sind oft sehr begrenzt. Daher empfehlen wir, dass Sie prüfen, ob die verfügbaren vCPU- und Speicheroptionen mit den Aufgabenanforderungen des Jobs kompatibel sind.

    GPUs für N1-VMs: Für diese 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, dass Sie mindestens den Typ und die Anzahl der GPUs angeben. 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. Sofern Sie den Job nicht über die Google Cloud Konsole erstellen, kann Batch automatisch einen Maschinentyp auswählen, der die Anforderungen der Aufgaben 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.

Die verfügbaren Verbrauchsoptionen für Batch und ihre Anforderungen werden in der folgenden Tabelle erläutert. Sie sind nach Anwendungsfällen sortiert, von der höchsten bis zur niedrigsten Ressourcenverfügbarkeit.

Zusammenfassend empfehlen wir den meisten Nutzern, die Verbrauchsoption für einen Job so auszuwählen:

  • Sofern keine der anderen Bedingungen zutrifft, verwenden Sie Flex-Start-VMs (Vorabversion) (bevorzugt, wenn sie Ihren Anforderungen entsprechen) oder On-Demand-VMs.
  • Wenn für Ihren Job eine sehr hohe Zusicherung der Ressourcenverfügbarkeit erforderlich ist oder Sie ungenutzte Reservierungen haben, die Sie nicht löschen können, verwenden Sie Reservierungen im Kalendermodus (Vorabversion) (bevorzugt, wenn sie Ihren Anforderungen entsprechen) oder Reservierungen.
  • (Optional) Wenn Ihre Arbeitslast sehr fehlertolerant ist, können Sie möglicherweise Kosten senken, indem Sie Spot-VMs verwenden.
Nutzungsoptionen und ihre Jobanforderungen

Reservierungen

  • Anwendungsfall: Wir empfehlen Reservierungen für Jobs, wenn Sie eine sehr hohe Wahrscheinlichkeit für die 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: Nachdem eine Reservierung erstellt wurde, fallen die Kosten der angegebenen VMs zum gleichen Preis wie beim Ausführen der VMs 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.

    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 (Vorschau)

  • 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 Wahrscheinlichkeit 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 Anfrage für eine zukünftige Reservierung 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 für den gesamten Reservierungszeitraum zum Dynamic Workload Scheduler-Preis, der Rabatte von bis zu 53% auf On-Demand-Preise bietet. Nachdem Sie eine automatisch erstellte Reservierung im Kalendermodus gefunden haben, die Sie verwenden können, ähnelt das Erstellen eines Jobs, der eine Reservierung im Kalendermodus nutzt, dem 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 Bedingungen erfüllen:

Flex-Start-VMs (Vorschau)

  • Anwendungsfall: Wir empfehlen Flex-Start-VMs, wenn Ihr Job eine Verfügbarkeit nach dem Best-Effort-Prinzip tolerieren kann und Sie im Gegenzug von einem Rabatt und einer Ausführungsdauer von bis zu 7 Tagen profitieren möchten.

    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 bei der Jobplanung hilfreich sein, da sie Verzögerungen oder Probleme, die durch nicht verfügbare Ressourcen verursacht werden, verringern.

  • Details: Wenn eine Anfrage zum Erstellen eines Jobs, der Flex-Start-VMs verwendet, erfüllt wird, werden die VMs zum Dynamic Workload Scheduler-Preis abgerechnet. Dieser bietet Rabatte von bis zu 53% auf den On-Demand-Preis.

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

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

On demand

  • Anwendungsfall: Wir empfehlen standardmäßig On-Demand für die meisten anderen Jobs.1

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

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

  • Setzen Sie das Feld provisioningModel auf STANDARD.
  • Reservierungen blockieren. Wenn Sie verhindern möchten, dass für einen Job automatisch kompatible Reservierungen verwendet werden, setzen Sie das Feld reservation auf NO_RESERVATION. Weitere Informationen finden Sie unter Job erstellen und ausführen, der keine reservierten VMs nutzen kann.

1Ausnahme: Bei Jobs, die die A3-Maschinenserie verwenden, ist das Standardverhalten eindeutig. Wir empfehlen, keine On-Demand-VMs zu verwenden und das Feld provisioningModel nicht undefiniert zu lassen. Verwenden Sie stattdessen die Jobanforderungen für Flex-Start-VMs. Die On-Demand-Nutzung wird für die A3-Maschinenserie aufgrund der geringen Ressourcenverfügbarkeit nicht empfohlen. Wenn ein Job also die A3-Maschinenserie verwendet, Reservierungen blockiert und das Feld provisioningModel entweder nicht definiert oder auf STANDARD festgelegt ist, ist die Standardverbrauchsoption „unique“: Das Verhalten ähnelt dem von Flex-Start-VMs, bei denen die Laufzeit auf 7 Tage begrenzt ist. Es wird jedoch nicht empfohlen, da für diese Jobs keine Rabatte aus der Dynamic Workload Scheduler-Preisgestaltung gelten. Wenn für Ihren Job mit A3-VMs ein Zeitlimit von 7 Tagen akzeptabel ist, empfehlen wir, Flex-Start-VMs anstelle von On-Demand-VMs zu verwenden. Andernfalls können Sie nicht sicherstellen, dass für Jobs mit A3-VMs On-Demand-Instanzen verwendet werden, es sei denn, Sie legen provisioningModel auf STANDARD fest und prüfen manuell, ob für den Job keine Reservierungen genutzt werden können, ohne das Feld reservation auf NO_RESERVATION festzulegen.

Spot-VMs

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

  • Details: Wenn eine Anfrage zum Erstellen eines Jobs, der Spot-VMs verwendet, erfüllt wird, werden die VMs zu den Preisen für Spot-VMs abgerechnet. Diese Preise können sich häufig ändern und bieten möglicherweise den größten Rabatt von bis zu 91 % auf die 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 in der Compute Engine-Dokumentation

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

  • Setzen Sie das Feld provisioningModel auf SPOT.
  • Optional: Reservierungen blockieren Sie können keine Spot-VMs mit Reservierungen verwenden. Insbesondere kann im Job optional das Feld reservation auf NO_RESERVATION gesetzt werden. Weitere Informationen finden Sie unter Job erstellen und ausführen, der keine reservierten VMs nutzen kann.

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 (empfohlen, falls möglich): Wie in den Beispielen gezeigt, können Sie Batch die erforderlichen GPU-Treiber von einem Drittanbieterstandort abrufen und in Ihrem Namen installieren lassen. Dazu müssen Sie das Feld installGpuDrivers für den Job auf true festlegen. Diese Methode wird empfohlen, wenn für Ihren Job keine manuelle Installation von Treibern erforderlich ist.

    Wenn Sie angeben müssen, welche Version des GPU-Treibers von Batch installiert werden soll, legen Sie 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 basierend auf dem Betriebssystem aus, das Sie verwenden möchten:

      2. Wenn Ihr Job Container-Runnables 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 zum Definieren der VM-Ressourcen für einen Job finden Sie unter Job-Ressourcen.

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 Verfügbarkeit von Beschleunigern.

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

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

    • VM-Ressourcen direkt mit dem Feld instances[].policy definieren (nach Möglichkeit empfohlen). 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 Job-Ressourcen mit einer VM-Instanzvorlage definieren.

Beispieljob 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 (Vorschau)

Ressourcenverfügbarkeit mit VM-Reservierungen sicherstellen
Flex-Start-VMs (Vorschau)

GPUs und Flex-Start-VMs verwenden
On-Demand-VMs 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 verwendet, indem Sie die gcloud CLI oder die Batch API verwenden.

gcloud

  1. Erstellen Sie eine JSON-Datei, in der GPU-Treiber installiert werden, ein GPU-Maschinentyp angegeben wird, der Flex-Start-VMs unterstützt, Reservierungen blockiert werden und die in 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 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": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Ersetzen Sie Folgendes:

    • INSTALL_GPU_DRIVERS: Wenn auf true festgelegt, ruft Batch die für den GPU-Typ erforderlichen Treiber, die Sie im Feld policy angeben, von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) festlegen, 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: Optional können Sie mit dem allowedLocations[]-Feld eine Region oder bestimmte Zonen in einer Region angeben, in der die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 werden beispielsweise alle Zonen in der Region us-central1 zugelassen. Achten Sie darauf, dass Sie Standorte angeben, an denen der GPU-Maschinentyp verfügbar ist, den Sie für diesen Job benötigen. Wenn Sie dieses Feld weglassen, muss der GPU-Maschinentyp am Standort des Jobs verfügbar sein.

  2. Verwenden Sie den Befehl gcloud alpha 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 zu einer JSON-Datei mit den Konfigurationsdetails des Jobs.

API

Stellen Sie eine POST-Anfrage an die v1alpha-Methode jobs.create, die GPU-Treiber installiert, einen GPU-Maschinentyp angibt, der Flex-Start-VMs unterstützt, Reservierungen blockiert und an einem Ort 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 accelerator-optimierte VMs verwendet, stellen Sie die folgende Anfrage:

POST https://batch.googleapis.com/v1alpha/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: Wenn auf true festgelegt, ruft Batch die für den GPU-Typ, den Sie im Feld policy angeben, erforderlichen Treiber von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) festlegen, 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: Optional können Sie mit dem allowedLocations[]-Feld eine Region oder bestimmte Zonen in einer Region angeben, in der die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 werden beispielsweise alle Zonen in der Region us-central1 zugelassen. Achten Sie darauf, dass Sie Standorte angeben, an denen der GPU-Maschinentyp verfügbar ist, den Sie für diesen Job benötigen. Wenn Sie dieses Feld weglassen, muss der GPU-Maschinentyp am Standort des Jobs verfügbar sein.

GPUs für beschleunigungsoptimierte VMs verwenden

Sie können einen Job erstellen, der GPUs für beschleunigeroptimierte VMs verwendet, indem 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 Job-Liste 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 Abschnitt Aufgabendetails:

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

        So erstellen Sie beispielsweise einen einfachen Skriptjob:

        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 Anzahl der Aufgaben 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 vorzeitigen Beendigungen standhalten 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 (Standard) 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 die Ausführung dieses Jobs auf eine bestimmte Zone beschränken möchten, wählen Sie eine Zone aus.

        • Wählen Sie andernfalls Beliebig (Standard) 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 von Ihnen ausgewählten GPUs basiert.

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

    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 Menge an 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, in der GPU-Treiber installiert werden, ein Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie angegeben wird und die an einem Ort ausgeführt wird, an dem der GPU-Maschinentyp verfügbar ist.

    Wenn Sie beispielsweise einen einfachen Scriptjob erstellen möchten, der GPUs für accelerator-optimierte 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: Wenn auf true festgelegt, ruft Batch die für den GPU-Typ, den Sie im Feld policy angeben, erforderlichen Treiber von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) festlegen, 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: Optional können Sie mit dem allowedLocations[]-Feld eine Region oder bestimmte Zonen in einer Region angeben, in denen die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 werden beispielsweise alle Zonen in der Region us-central1 zugelassen. Achten Sie darauf, dass Sie Standorte angeben, an denen der GPU-Maschinentyp verfügbar ist, den Sie für diesen Job benötigen. 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: Der Standort des Jobs.

    • 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 Standort ausgeführt wird, der den GPU-Maschinentyp hat.

Wenn Sie beispielsweise einen einfachen Skriptjob erstellen möchten, der GPUs für accelerator-optimierte 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: Wenn auf true festgelegt, ruft Batch die für den GPU-Typ erforderlichen Treiber, die Sie im Feld policy angeben, von einem Drittanbieterstandort ab und installiert sie in Ihrem Namen. Wenn Sie dieses Feld auf false (Standard) festlegen, 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: Optional können Sie mit dem allowedLocations[]-Feld eine Region oder bestimmte Zonen in einer Region angeben, in der die VMs für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1 werden beispielsweise alle Zonen in der Region us-central1 zugelassen. Achten Sie darauf, dass Sie Standorte angeben, an denen der GPU-Maschinentyp verfügbar ist, den Sie für diesen Job benötigen. 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 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 Job-Liste 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 Abschnitt Aufgabendetails:

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

        So erstellen Sie beispielsweise einen einfachen Skriptjob:

        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 Anzahl der Aufgaben 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 vorzeitigen Beendigungen standhalten 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 (Standard) 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 die Ausführung dieses Jobs auf eine bestimmte Zone beschränken möchten, wählen Sie eine Zone aus.

        • Wählen Sie andernfalls Beliebig (Standard) 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 Serie 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 (Standard) aus.

    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 Menge an 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, in der GPU-Treiber installiert werden, die Unterfelder type und count des Felds accelerators[] definiert werden und die an einem Ort ausgeführt wird, an dem der GPU-Maschinentyp vorhanden ist.

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

    Ersetzen Sie Folgendes:

  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 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 type- und count-Unterfelder des Felds accelerators[] definiert und einen Standort verwendet, der den GPU-Maschinentyp hat.

Wenn Sie beispielsweise einen einfachen Scriptjob 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:

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