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) Weitere Informationen zu den Funktionen und Einschränkungen für GPUs finden Sie unter Informationen zu GPUs in der Compute Engine-Dokumentation

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

Hinweise

  1. Wenn Sie Batch zum ersten Mal verwenden, lesen Sie Erste Schritte mit Batch und aktivieren Sie Batch, indem Sie den Voraussetzungen für Projekte und Nutzer.

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

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

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

Job erstellen, der GPUs verwendet

So erstellen Sie einen Job, der GPUs verwendet:

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

Anforderungen für einen Job mit GPUs planen

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

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

Schritt 1: GPU-Maschinentyp auswählen

Die verfügbaren GPU-Maschinentypen (die gültigen Kombinationen von GPU-Typ, Anzahl der GPUs, dem Maschinentyp (vCPUs und Arbeitsspeicher)) sowie deren Anwendungsfälle sind auf der Seite GPU-Maschinentypen in der Compute Engine Dokumentation.

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

GPU-Maschinentypen und Jobanforderungen

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

Zur Verwendung von GPUs für beschleunigeroptimierte VMs empfehlen wir, dass Sie geben Sie den Maschinentyp an. Jeder beschleunigeroptimierte Maschinentyp unterstützt nur einen bestimmten GPU-Typ und eine bestimmte Anzahl von GPUs, unabhängig davon, ob Sie diese Werte zusätzlich zum beschleunigeroptimierten Maschinentyp.

Insbesondere unterstützt Batch auch die Angabe des Attributs Typ und Anzahl der GPUs für beschleunigeroptimierte VMs, aber die daraus resultierenden vCPU- und Arbeitsspeicheroptionen sind oft sehr begrenzt. Daher empfehlen wir Ihnen, dass die verfügbaren vCPU- und Arbeitsspeicheroptionen kompatibel sind, mit den Aufgabenanforderungen des Jobs.

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

Zur Verwendung von GPUs für N1-VMs empfehlen wir, mindestens die und die Anzahl der GPUs. Stellen Sie sicher, dass die Kombination stimmt mit einem der gültigen GPU-Optionen für N1-Maschinentypen Die vCPU- und Arbeitsspeicheroptionen für N1-VMs, die einen bestimmten Typ und ist sehr flexibel. Wenn es bevorzugt wird, kann Batch also eine Maschinentyp, der die Aufgabenanforderungen des Jobs erfüllt.

Schritt 2: GPU-Treiber installieren

Wählen Sie eine der folgenden Methoden aus, um die erforderlichen GPU-Treiber zu installieren:

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

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

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

    • Ein Job verwendet sowohl Script- als auch Container-Ausführbare und hat keinen Internetzugang. Weitere Informationen zu den Zugriffsberechtigungen eines Jobs finden Sie unter Batch-Netzwerkübersicht.
    • Ein Job verwendet ein benutzerdefiniertes VM-Image. Weitere Informationen zu VM-Betriebssystem-Images und zu den verfügbaren VM-Betriebssystem-Images finden Sie unter VM-Betriebssystemumgebung – Übersicht.

    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. Um GPU-Treiber zu installieren, führen Sie ein Installationsskript basierend auf dem Betriebssystem aus die Sie verwenden möchten:

      2. Wenn Ihr Job Container Runnables hat und keine Container-Optimized OS müssen Sie auch den NVIDIA Container Toolkit

    2. Erstellen und senden Sie einen Job mit dem benutzerdefinierten VM-Image, indem Sie Mit einer Compute Engine-Instanzvorlage Legen Sie für den Job das Feld installGpuDrivers auf false (Standard) fest.

Schritt 3: Kompatible VM-Ressourcen definieren

Weitere Informationen zu den Anforderungen und Optionen zum Definieren der VM-Ressourcen für eine 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 Ihres die VMs des Jobs.

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

  • Wenn Sie den Maschinentyp des Jobs angeben, achten Sie darauf, dass dieser über genügend vCPUs und Arbeitsspeicher für die Aufgabenanforderungen des Jobs. Computer des Jobs angeben -Typ ist erforderlich, wenn GPUs für beschleunigeroptimierte VMs verwendet werden, und optional wenn Sie GPUs für N1-VMs verwenden.

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

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

Beispieljob erstellen, der GPUs verwendet

In den folgenden Abschnitten wird erläutert, wie Sie einen Beispieljob für verschiedene GPU-Maschinentypen erstellen. In den Beispieljobs werden GPU-Treiber automatisch installiert und VM-Ressourcen direkt definieren.

GPUs für beschleunigeroptimierte VMs verwenden

Sie können einen Job erstellen, der GPUs für beschleunigeroptimierte VMs verwendet, indem Sie die gcloud CLI, Batch API, Java oder Python verwenden.

gcloud

  1. Erstellen Sie eine JSON-Datei, die GPU-Treiber installiert, das Feld machineType mit dem Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie definiert und einen Speicherort mit den angegebenen GPUs verwendet.

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

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

    Ersetzen Sie Folgendes:

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

    • MACHINE_TYPE: ein Maschinentyp aus der beschleunigeroptimierte Maschinenfamilie.

    • ALLOWED_LOCATIONS: Das Feld allowedLocations[] definiert eine Region und optional eine oder mehrere Zonen, in denen die VM-Instanzen für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1, zones/us-central1-a ist beispielsweise die Zone us-central1-a zulässig. Achten Sie darauf, Standorte, an denen der GPU-Maschinentyp angeboten wird die Sie für diesen Job benötigen. Andernfalls stellen Sie beim Auslassen dieses Feldes sicher, Prüfen Sie, ob am Standort des Jobs der GPU-Maschinentyp angeboten wird.

  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, das Feld machineType mit dem Maschinentyp aus der beschleunigungsoptimierten Maschinenfamilie definiert und einen Speicherort mit den angegebenen GPUs verwendet.

Um beispielsweise einen einfachen Skriptjob zu erstellen, 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": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    }
}

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 festgelegt auf true, ruft Batch die Treiber ab, die für die GPU-Typ, den Sie im Feld policy angeben von einem Drittanbieter aus und installiert sie per Batch . Wenn Sie dieses Feld auf false (Standardeinstellung) festlegen, müssen Sie um GPU-Treiber manuell zu installieren, um GPUs für diesen Job zu verwenden.

  • MACHINE_TYPE: ein Maschinentyp aus der beschleunigeroptimierte Maschinenfamilie.

  • ALLOWED_LOCATIONS: Im Feld allowedLocations[] wird eine Region und optional eine oder mehrere Zonen definiert, in denen die VM-Instanzen für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1, zones/us-central1-a ist beispielsweise die Zone us-central1-a zulässig. Geben Sie Standorte an, an denen der für diesen Job erforderliche GPU-Maschinentyp verfügbar ist. Andernfalls stellen Sie beim Auslassen dieses Feldes sicher, Prüfen Sie, ob am Standort des Jobs der GPU-Maschinentyp angeboten wird.

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;
    }
  }
}

Python 

from google.cloud import batch_v1


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

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

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

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

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

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

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

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

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

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

    return client.create_job(create_request)

GPUs für N1-VMs verwenden

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

gcloud

  1. Erstellen Sie eine JSON-Datei, die GPU-Treiber installiert, die Unterfelder type und count des Felds accelerators[] definiert und einen Speicherort mit den angegebenen GPUs verwendet.

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

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

    Ersetzen Sie Folgendes:

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

    • GPU_TYPE: die GPU Typ. Sie können eine Liste der verfügbaren GPU-Typen aufrufen, indem Sie die Methode gcloud compute accelerator-types list-Befehl 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 in der GPU-Maschinentypen für die N1-Maschinenserie Verwenden Sie dieses Feld nur für GPUs für N1-VMs.

    • ALLOWED_LOCATIONS: Das Feld allowedLocations[] definiert eine Region und optional eine oder mehrere Zonen, in denen die VM-Instanzen für Ihren Job ausgeführt werden dürfen. Mit regions/us-central1, zones/us-central1-a ist beispielsweise die Zone us-central1-a zulässig. Achten Sie darauf, Standorte, an denen der GPU-Maschinentyp angeboten wird die Sie für diesen Job benötigen. Andernfalls stellen Sie beim Auslassen dieses Feldes sicher, Prüfen Sie, ob am Standort des Jobs der GPU-Maschinentyp angeboten wird.

  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 den Methode jobs.create das GPU-Treiber installiert, die Unterfelder type und count des Felds accelerators[] und verwendet einen Standort, der die angegebenen GPU-Typ.

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, führen Sie folgende Anfrage aus:

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

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

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 festgelegt auf true, ruft Batch die Treiber ab, die für die GPU-Typ, den Sie im Feld policy angeben von einem Drittanbieter aus und installiert sie per Batch . Wenn Sie dieses Feld auf false (Standardeinstellung) festlegen, müssen Sie GPU-Treiber manuell installieren, um GPUs für diesen Job zu verwenden.

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

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

  • ALLOWED_LOCATIONS: Die Feld allowedLocations[] definiert eine Region und optional eine oder mehrere Zonen, in denen die VM für Ihren Job ausgeführt werden dürfen – Beispiel: regions/us-central1, zones/us-central1-a lässt die Zone zu, us-central1-a Geben Sie Standorte an, an denen der für diesen Job erforderliche GPU-Maschinentyp verfügbar ist. Wenn Sie dieses Feld weglassen, achten Sie darauf, dass der GPU-Maschinentyp am Standort des Jobs verfügbar ist.

Java 


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

public class 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

Wählen Sie eine der folgenden Optionen aus, um einen Job mit GPUs unter Verwendung von Node.js zu erstellen. auf Basis des Maschinentyps für Ihr GPU-Modell:

Job erstellen, der GPUs mit beschleunigeroptimierten VMs verwendet

Wenn Sie GPUs mit beschleunigeroptimierten VMs verwenden möchten, geben Sie einfach den Maschinentyp an den Sie für die VMs des Jobs benötigen:

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

Job erstellen, der GPUs mit N1-VMs verwendet

Wenn Sie GPUs mit N1-VMs verwenden möchten, müssen Sie die Anzahl und den Typ der GPUs für jede VM des Jobs angeben:

// 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