Crea ed esegui un job che utilizza le GPU

Questo documento spiega come creare ed eseguire un job che utilizza una GPU (Graphics Processing Unit). Per scoprire di più sulle funzionalità e sulle limitazioni delle GPU, consulta Informazioni sulle GPU nella documentazione di Compute Engine.

Quando crei un job batch, puoi facoltativamente utilizzare le GPU per accelerare carichi di lavoro specifici. I casi d'uso comuni per i job che utilizzano le GPU includono elaborazione di dati intensivi e carichi di lavoro di intelligenza artificiale (AI) come il machine learning (ML).

Prima di iniziare

  1. Se non hai mai utilizzato Batch, consulta la guida introduttiva all'utilizzo di Batch e attivalo completando i prerequisiti per progetti e utenti.

  2. Per ottenere le autorizzazioni necessarie per creare un job, chiedi all'amministratore di concederti i seguenti ruoli IAM:

    Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

    Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Creare un job che utilizza le GPU

Per creare un job che utilizza le GPU:

  1. Pianifica i requisiti per un job che utilizza le GPU.
  2. Crea un job con i requisiti e i metodi che hai identificato. Per esempi su come creare un job utilizzando le opzioni consigliate, consulta Creare un job di esempio che utilizza le GPU in questo documento.

Pianificare i requisiti per un job che utilizza le GPU

Prima di creare un job che utilizza le GPU, pianifica i relativi requisiti come spiegato nelle sezioni seguenti:

  1. Seleziona il tipo di macchina GPU e il metodo di provisioning
  2. Installa i driver della GPU
  3. Definire le risorse VM compatibili

Passaggio 1: seleziona il tipo di macchina GPU e il metodo di provisioning

I requisiti di un job variano in base al tipo di macchina GPU e al metodo di provisioning preferiti e le opzioni per ciascuno potrebbero essere interdipendenti. In base ai tuoi requisiti e alle tue priorità, puoi selezionare prima il tipo di macchina GPU o prima il metodo di provisioning. In genere, il tipo di macchina GPU influisce principalmente sulle prestazioni e sui prezzi base, mentre il metodo di provisioning influisce principalmente sulla disponibilità delle risorse e su costi o sconti aggiuntivi.

Seleziona il tipo di macchina GPU

I tipi di macchine GPU disponibili (le combinazioni valide di tipo di GPU, numero di GPU e tipo di macchina (vCPU e memoria)) e i relativi casi d'uso sono elencati nella pagina Tipi di macchine GPU della documentazione di Compute Engine.

I campi richiesti per un job per specificare un tipo di macchina GPU variano in base alle categorie riportate nella tabella seguente:

Tipi di macchine GPU e relativi requisiti dei job

GPU per VM ottimizzate per l'acceleratore: le VM con un tipo di macchina della famiglia di macchine ottimizzate per l'acceleratore hanno un tipo e un numero specifici di queste GPU collegate automaticamente.

Per utilizzare le GPU per le VM ottimizzate per l'acceleratore, ti consigliamo di specificare il tipo di macchina. Ogni tipo di macchina ottimizzato per l'acceleratore supporta solo un tipo e un numero specifico di GPU, pertanto è funzionalmente equivalente se specifichi o meno questi valori oltre al tipo di macchina ottimizzato per l'acceleratore.

Nello specifico, Batch supporta anche la specifica solo del tipo e del numero di GPU per le VM ottimizzate per l'acceleratore, ma le opzioni di vCPU e memoria risultanti sono spesso molto limitate. Di conseguenza, ti consigliamo di verificare che le opzioni di vCPU e memoria disponibili siano compatibili con i requisiti delle attività del job.

GPU per le VM N1: per queste GPU devi specificare il tipo e la quantità da collegare a ogni VM e devono essere collegate a VM con un tipo di macchina della serie di macchine N1.

Per utilizzare le GPU per le VM N1, ti consigliamo di specificare almeno il tipo di GPU e il numero di GPU. Assicurati che la combinazione di valori corrisponda a una delle opzioni GPU valide per i tipi di macchine N1. Le opzioni di vCPU e memoria per le VM N1 che utilizzano GPU di tipo e numero specifici sono abbastanza flessibili, quindi, se preferisci, puoi lasciare che Batch selezioni un tipo di macchina che soddisfi i requisiti delle attività del job.
Seleziona il metodo di provisioning

Batch utilizza diversi metodi per eseguire il provisioning delle risorse VM per i job che utilizzano le GPU in base al tipo di risorse richieste dal job. I metodi di provisioning disponibili e i relativi requisiti sono descritti nella tabella seguente, che li elenca in base ai casi d'uso: dalla disponibilità delle risorse più elevata a quella più bassa.

In sintesi, consigliamo alla maggior parte degli utenti di procedere nel seguente modo:

  • Se intendi utilizzare tipi di macchine GPU A3 senza una prenotazione, utilizza Dinamic Workload Scheduler per Batch (anteprima).

  • Per tutti gli altri tipi di macchine GPU, utilizza il metodo di provisioning predefinito. Il metodo di provisioning predefinito è solitamente on demand. Un'eccezione è rappresentata dal caso in cui il progetto abbia prenotazioni inutilizzate che il job può consumare automaticamente.

Metodi di provisioning e relativi requisiti dei job

Prenotazioni

  • Caso d'uso: consigliamo le prenotazioni per i job se vuoi un livello molto elevato di garanzia della disponibilità delle risorse o se hai già prenotazioni esistenti che potrebbero non essere utilizzate.

  • Dettagli: una prenotazione comporta i costi delle VM specificate allo stesso prezzo dell'esecuzione delle VM fino all'eliminazione della prenotazione. Le VM che utilizzano una prenotazione non comportano costi distinti, ma le prenotazioni comportano costi indipendentemente dal consumo.

Batch utilizza le prenotazioni per i job che possono consumare le prenotazioni inutilizzate. Per ulteriori informazioni sulle prenotazioni e sui relativi requisiti, consulta la pagina Garantire la disponibilità delle risorse utilizzando le prenotazioni delle VM.

Dynamic Workload Scheduler per Batch (anteprima)

  • Caso d'uso: consigliamo di utilizzare Dynamic Workload Scheduler se vuoi utilizzare le GPU per le VM con un tipo di macchina della serie di macchine A3 senza utilizzare una prenotazione.

  • Dettagli: Dynamic Workload Scheduler può semplificare l'accesso contemporaneamente a molte risorse che accelerano i carichi di lavoro di AI e ML. Ad esempio, Dynamic Workload Scheduler può essere utile per la programmazione dei job attenuando i ritardi o i problemi causati dalla mancanza di disponibilità delle risorse.

Batch utilizza Dynamic Workload Scheduler per i job che svolgono tutte le seguenti operazioni:

  • Specifica un tipo di macchina GPU A3.
  • Blocca le prenotazioni. Nello specifico, il job deve impostare il campo reservation su NO_RESERVATION. Per ulteriori informazioni, consulta Creare ed eseguire un job che non può utilizzare VM riservate.
  • Non utilizzare VM spot. In particolare, il job può omettere il campo provisioningModel o impostare il campo provisioningModel su STANDARD.

On demand

  • Caso d'uso: consigliamo di utilizzare la modalità on demand per tutti gli altri job.

  • Dettagli: in genere, la modalità On demand è il metodo predefinito per accedere alle VM Compute Engine. La modalità On Demand ti consente di richiedere e (se disponibile) accedere immediatamente alle risorse una VM alla volta.

Batch utilizza on demand per tutti gli altri job.

VM spot

  • Caso d'uso: ti consigliamo di provare a utilizzare le VM spot per ridurre i costi per i carichi di lavoro a tolleranza di errore.

  • Dettagli: le VM spot offrono sconti significativi, ma potrebbero non essere sempre disponibili e possono essere prelevate in qualsiasi momento. Per maggiori informazioni, consulta la sezione VM spot nella documentazione di Compute Engine.

Batch utilizza le VM spot per i job che impostano il campo provisioningModel su SPOT.

Passaggio 2: installa i driver della GPU

Per installare i driver GPU richiesti, seleziona uno dei seguenti metodi:

Passaggio 3: definisci le risorse VM compatibili

Per informazioni sui requisiti e sulle opzioni per definire le risorse VM per un job, consulta Risorse dei job.

In sintesi, devi eseguire tutte le operazioni riportate di seguito quando definisci le risorse VM per un job che utilizza le GPU:

  • Assicurati che il tipo di macchina GPU sia disponibile nella posizione delle VM del tuo job.

    Per scoprire dove sono disponibili i tipi di macchine GPU, consulta la sezione Disponibilità delle GPU per regioni e zone nella documentazione di Compute Engine.

  • Se specifichi il tipo di macchina del job, assicurati che disponga di vCPU e memoria sufficienti per i requisiti delle attività del job. È consigliabile specificare il tipo di macchina del job quando si utilizzano GPU per le VM ottimizzate per l'acceleratore ed è facoltativo quando si utilizzano GPU per le VM N1.

  • Assicurati di definire le risorse VM per un job utilizzando un metodo valido:

    • Definisci le risorse VM direttamente utilizzando il campo instances[].policy (consigliato se possibile). Questo metodo è mostrato negli esempi.
    • Definisci le risorse VM tramite un modello utilizzando il campo instances[].instanceTemplate. Questo metodo è necessario per installare manualmente i driver GPU tramite un'immagine personalizzata. Per ulteriori informazioni, consulta Definire le risorse dei job utilizzando un modello di istanza VM.

Crea un job di esempio che utilizza le GPU

Le sezioni seguenti spiegano come creare un job di esempio per ogni tipo di macchina GPU utilizzando le opzioni consigliate. Nello specifico, i job di esempio installano tutti automaticamente i driver GPU, definiscono tutti direttamente le risorse VM e specificano il metodo di provisioning o utilizzano il metodo di provisioning predefinito.

Utilizzare le GPU per le VM A3 tramite lo scheduler dei workload dinamici per Batch (anteprima)

Puoi creare un job che utilizza le GPU per le VM A3 tramite lo scheduler dei carichi di lavoro dinamico utilizzando gcloud CLI o l'API Batch.

gcloud

  1. Crea un file JSON che installa i driver GPU, specifica un tipo di macchina della serie A3, blocca le prenotazioni ed esegue in una località con il tipo di macchina GPU.

    Ad esempio, per creare un job di script di base che utilizza le GPU per le VM A3 tramite Dynamic Workload Scheduler, crea un file JSON con i seguenti contenuti:

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

    Sostituisci quanto segue:

    • INSTALL_GPU_DRIVERS: se impostato su true, Batch recupera i driver richiesti per il tipo di GPU specificato nel campo policy da una posizione di terze parti e li installa per tuo conto. Se imposti questo campo su false (valore predefinito), devi installare manualmente i driver GPU per utilizzare le GPU per questo job.

    • MACHINE_TYPE: un tipo di macchina della serie di macchine A3.

    • ALLOWED_LOCATIONS: se vuoi, puoi utilizzare il campo allowedLocations[] per specificare una regione o zone specifiche in una regione in cui è consentito eseguire le VM per il tuo job. Ad esempio, regions/us-central1 consente tutte le zone della regione us-central1. Assicurati di specificare le località che offrono il tipo di macchina GPU che vuoi per questo job. In caso contrario, se ometti questo campo, assicurati che la località del job offra il tipo di macchina GPU.

  2. Per creare ed eseguire il job, utilizza il comando gcloud batch jobs submit:

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

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.

    • LOCATION: la località del lavoro.

    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Invia una richiesta POST al metodo jobs.create che installa i driver GPU, specifica un tipo di macchina della serie A3, blocca le prenotazioni ed esegue in una posizione con il tipo di macchina GPU.

Ad esempio, per creare un job di script di base che utilizza le GPU per le VM A3 tramite la pianificazione dei workload dinamici, effettua la seguente richiesta:

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

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

Sostituisci quanto segue:

  • PROJECT_ID: il ID progetto del tuo progetto.

  • LOCATION: la località del lavoro.

  • JOB_NAME: il nome del job.

  • INSTALL_GPU_DRIVERS: se impostato su true, Batch recupera i driver richiesti per il tipo di GPU specificato nel campo policy da una posizione di terze parti e li installa per tuo conto. Se imposti questo campo su false (valore predefinito), devi installare manualmente i driver GPU per utilizzare le GPU per questo job.

  • MACHINE_TYPE: un tipo di macchina della serie di macchine A3.

  • ALLOWED_LOCATIONS: facoltativamente, puoi utilizzare il campo allowedLocations[] per specificare una regione o zone specifiche in una regione in cui è consentito eseguire le VM per il tuo job. Ad esempio, regions/us-central1 consente tutte le zone della regione us-central1. Assicurati di specificare le località che offrono il tipo di macchina GPU che vuoi per questo job. In caso contrario, se ometti questo campo, assicurati che la località del job offra il tipo di macchina GPU.

Utilizzare le GPU per le VM ottimizzate per l'acceleratore

Puoi creare un job che utilizza le GPU per le VM ottimizzate per gli acceleratori utilizzando gcloud CLI'API Batch, Java, Node.js o Python.

gcloud

  1. Crea un file JSON che installa i driver GPU, specifica un tipo di macchina della famiglia di macchine ottimizzate per l'acceleratore ed esegui in una posizione che ha il tipo di macchina GPU.

    Ad esempio, per creare un job di script di base che utilizzi le GPU per le VM ottimizzate per gli acceleratori, crea un file JSON con i seguenti contenuti:

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

    Sostituisci quanto segue:

    • INSTALL_GPU_DRIVERS: se impostato su true, Batch recupera i driver richiesti per il tipo di GPU specificato nel campo policy da una posizione di terze parti e li installa per tuo conto. Se imposti questo campo su false (valore predefinito), devi installare manualmente i driver GPU per utilizzare le GPU per questo job.

    • MACHINE_TYPE: un tipo di macchina della famiglia di macchine ottimizzate per l'acceleratore.

    • ALLOWED_LOCATIONS: se vuoi, puoi utilizzare il campo allowedLocations[] per specificare una regione o zone specifiche in una regione in cui è consentito eseguire le VM per il tuo job. Ad esempio, regions/us-central1 consente tutte le zone della regione us-central1. Assicurati di specificare le località che offrono il tipo di macchina GPU che vuoi per questo job. In caso contrario, se ometti questo campo, assicurati che la località del job offra il tipo di macchina GPU.

  2. Per creare ed eseguire il job, utilizza il comando gcloud batch jobs submit:

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

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.

    • LOCATION: la località del lavoro.

    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Invia una richiesta POST al metodo jobs.create che installa i driver GPU, specifica un tipo di macchina della famiglia di macchine ottimizzate per l'acceleratore ed esegue in una posizione che ha il tipo di macchina GPU.

Ad esempio, per creare un job di script di base che utilizza le GPU per le VM ottimizzate per gli acceleratori, effettua la seguente richiesta:

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

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

Sostituisci quanto segue:

  • PROJECT_ID: il ID progetto del tuo progetto.

  • LOCATION: la località del lavoro.

  • JOB_NAME: il nome del job.

  • INSTALL_GPU_DRIVERS: se impostato su true, Batch recupera i driver richiesti per il tipo di GPU specificato nel campo policy da una posizione di terze parti e li installa per tuo conto. Se imposti questo campo su false (valore predefinito), devi installare manualmente i driver GPU per utilizzare le GPU per questo job.

  • MACHINE_TYPE: un tipo di macchina della famiglia di macchine ottimizzate per l'acceleratore.

  • ALLOWED_LOCATIONS: se vuoi, puoi utilizzare il campo allowedLocations[] per specificare una regione o zone specifiche in una regione in cui è consentito eseguire le VM per il tuo job. Ad esempio, regions/us-central1 consente tutte le zone della regione us-central1. Assicurati di specificare le località che offrono il tipo di macchina GPU che vuoi per questo job. In caso contrario, se ometti questo campo, assicurati che la località del job offra il tipo di macchina GPU.

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)

Utilizzare le GPU per le VM N1

Puoi creare un job che utilizza le GPU per le VM N1 utilizzando l'interfaccia alla gcloud CLI'API Batch, Java, Node.js o Python.

gcloud

  1. Crea un file JSON che installa i driver della GPU, definisce i sottocampi type e count del campo accelerators[] ed esegue in una posizione con il tipo di macchina GPU.

    Ad esempio, per creare un job di script di base che utilizzi le GPU per le VM N1 e consenta a Batch di selezionare il tipo di macchina N1 esatto, crea un file JSON con i seguenti contenuti:

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

    Sostituisci quanto segue:

    • INSTALL_GPU_DRIVERS: se impostato su true, Batch recupera i driver richiesti per il tipo di GPU specificato nel campo policy da una posizione di terze parti e li installa per tuo conto. Se imposti questo campo su false (valore predefinito), devi installare manualmente i driver GPU per utilizzare le GPU per questo job.

    • GPU_TYPE: il tipo di GPU. Puoi visualizzare un elenco dei tipi di GPU disponibili utilizzando il comando gcloud compute accelerator-types list. Utilizza questo campo solo per le GPU per le VM N1.

    • GPU_COUNT: il numero di GPU del tipo specificato. Per saperne di più sulle opzioni valide, consulta i tipi di macchine GPU per la serie di macchine N1. Utilizza questo campo solo per le GPU per le VM N1.

    • ALLOWED_LOCATIONS: se vuoi, puoi utilizzare il campo allowedLocations[] per specificare una regione o zone specifiche in una regione in cui è consentito eseguire le VM per il tuo job. Ad esempio, regions/us-central1 consente tutte le zone della regione us-central1. Assicurati di specificare le località che offrono il tipo di macchina GPU che vuoi per questo job. In caso contrario, se ometti questo campo, assicurati che la località del job offra il tipo di macchina GPU.

  2. Per creare ed eseguire il job, utilizza il comando gcloud batch jobs submit:

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

    Sostituisci quanto segue:

    • JOB_NAME: il nome del job.

    • LOCATION: la località del lavoro.

    • JSON_CONFIGURATION_FILE: il percorso di un file JSON con i dettagli di configurazione del job.

API

Invia una richiesta POST al metodo jobs.create che installa i driver GPU, definisce i subcampi type e count del campo accelerators[] e utilizza una posizione con il tipo di macchina GPU.

Ad esempio, per creare un job di script di base che utilizzi GPU per le VM N1 e consenta a Batch di selezionare il tipo di macchina N1 esatto, effettua la seguente richiesta:

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

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

Sostituisci quanto segue:

  • PROJECT_ID: il ID progetto del tuo progetto.

  • LOCATION: la località del lavoro.

  • JOB_NAME: il nome del job.

  • INSTALL_GPU_DRIVERS: se impostato su true, Batch recupera i driver richiesti per il tipo di GPU specificato nel campo policy da una posizione di terze parti e li installa per tuo conto. Se imposti questo campo su false (valore predefinito), devi installare manualmente i driver GPU per utilizzare le GPU per questo job.

  • GPU_TYPE: il tipo di GPU. Puoi visualizzare un elenco dei tipi di GPU disponibili utilizzando il comando gcloud compute accelerator-types list. Utilizza questo campo solo per le GPU per le VM N1.

  • GPU_COUNT: il numero di GPU del tipo specificato. Per saperne di più sulle opzioni valide, consulta Tipi di macchine GPU per le serie di macchine N1. Utilizza questo campo solo per le GPU per le VM N1.

  • ALLOWED_LOCATIONS: se vuoi, puoi utilizzare il campo allowedLocations[] per specificare una regione o zone specifiche in una regione in cui è consentito eseguire le VM per il tuo job. Ad esempio, regions/us-central1 consente tutte le zone della regione us-central1. Assicurati di specificare le località che offrono il tipo di macchina GPU che vuoi per questo job. In caso contrario, se ometti questo campo, assicurati che la località del job offra il tipo di macchina GPU.

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)

Passaggi successivi