Crea ed esegui un job che utilizza le GPU

Questo documento spiega come creare ed eseguire un job che utilizza un'unità di elaborazione grafica (GPU). Per saperne 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 workload specifici. I casi d'uso comuni per i job che utilizzano le GPU includono il trattamento intensivo dei dati e i workload di intelligenza artificiale (AI), come il machine learning (ML). In alternativa, puoi accelerare i workload di AI e ML utilizzando le TPU.

Prima di iniziare

  1. Se non hai mai utilizzato Batch, consulta Inizia a utilizzare Batch e abilita Batch 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 Gestisci l'accesso a progetti, cartelle e organizzazioni.

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

Crea un job che utilizza le GPU

Per creare un job che utilizza le GPU, segui questi passaggi:

  1. Pianifica la configurazione di 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 Crea un job che utilizza le GPU in questo documento.

Pianifica la configurazione di un job che utilizza le GPU

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

  1. Seleziona il tipo di macchina GPU e l'opzione di consumo
  2. Installa i driver della GPU
  3. Definisci risorse VM compatibili

Passaggio 1: seleziona il tipo di macchina GPU e l'opzione di consumo

I requisiti di un job variano in base al tipo di macchina GPU e all'opzione di consumo che preferisci. Le opzioni per ciascuno potrebbero essere interdipendenti.

Per selezionare il tipo di macchina GPU e l'opzione di consumo per il job, completa i seguenti passaggi:

  1. Identifica e seleziona la tua priorità:

  2. Effettua la selezione rimanente in base a ciò che è compatibile con la prima selezione.

    1. Per identificare le opzioni compatibili con la tua prima selezione, consulta Disponibilità delle opzioni di consumo per tipo di macchina nella documentazione di Compute Engine.

    2. Consulta la sezione rimanente per Seleziona l'opzione di consumo o Seleziona il tipo di macchina GPU, rispettivamente.

Seleziona il tipo di macchina GPU

Per selezionare il tipo di macchina GPU per un job e comprenderne i requisiti, completa i seguenti passaggi:

  1. Seleziona un tipo di macchina GPU: per esaminare i tipi di macchina 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 consigliati, consulta Tipi di macchine GPU e Famiglia di macchine ottimizzate per l'acceleratore nella documentazione di Compute Engine.

  2. Comprendi i requisiti del job per il tipo di macchina GPU: i campi obbligatori per un job per specificare un tipo di macchina GPU variano in base alle categorie nella tabella seguente:

    Tipi di macchine GPU e requisiti dei job

    GPU per VM ottimizzate per l'acceleratore: alle VM con un tipo di macchina della famiglia di macchine ottimizzate per l'acceleratore vengono collegati automaticamente un tipo e un numero specifici di queste GPU.

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

    In particolare, 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 VM N1: queste GPU richiedono di specificare il tipo e la quantità da collegare a ogni VM e devono essere collegate alle 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 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 un tipo e un numero di GPU specifici sono piuttosto flessibili. A meno che non crei il job utilizzando la console Google Cloud , puoi consentire a Batch di selezionare automaticamente un tipo di macchina che soddisfi i requisiti delle attività del job.
Seleziona l'opzione di consumo

Questa sezione riassume come selezionare l'opzione di consumo per un job e i requisiti del job per ogni opzione.

Le opzioni di consumo disponibili per Batch e i relativi requisiti dei job sono spiegati nella tabella seguente. Questa tabella elenca le opzioni di consumo in base ai relativi casi d'uso, dalla disponibilità più alta a quella più bassa. Assicurati che l'opzione di consumo selezionata soddisfi anche i tuoi requisiti in termini di prezzi, runtime e supporto del tipo di macchina. Per maggiori informazioni sulla scelta di un'opzione di consumo, consulta anche Migliora l'ottenibilità delle risorse, la documentazione di Compute Engine per i modelli di provisioning e la documentazione di AI Hypercomputer per le opzioni di consumo.

Opzioni di consumo e 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 e non puoi utilizzare le prenotazioni in modalità calendario o se hai già prenotazioni esistenti che potrebbero non essere utilizzate.

  • Dettagli: dopo la creazione, una prenotazione comporta i costi delle VM specificate allo stesso prezzo dell'esecuzione delle VM fino a quando non elimini la prenotazione. Le VM che utilizzano una prenotazione non comportano costi separati, ma le prenotazioni comportano costi indipendentemente dall'utilizzo.

    Scopri di più sulle prenotazioni nella documentazione di Compute Engine.

Batch utilizza le prenotazioni per i job che possono utilizzare VM prenotate inutilizzate. Per saperne di più sui requisiti dei job per l'utilizzo delle prenotazioni, consulta la pagina Garantisci la disponibilità delle risorse utilizzando le prenotazioni VM.

Prenotazioni in modalità Calendario

  • Caso d'uso: consigliamo le prenotazioni in modalità calendario per i job se vuoi utilizzare un tipo di macchina GPU che supporta le prenotazioni in modalità calendario e hai bisogno di un livello molto elevato di garanzia della disponibilità delle risorse per un periodo compreso tra 1 e 90 giorni.

  • Dettagli: prima di creare un job, devi richiedere o identificare una prenotazione in modalità calendario che puoi utilizzare. Se Compute Engine soddisfa una richiesta di prenotazione futura in modalità calendario, la prenotazione in modalità calendario creata automaticamente comporta lo stesso costo dell'esecuzione delle VM specificate per l'intero periodo di prenotazione in base ai prezzi di Dynamic Workload Scheduler, che offre sconti fino al 53% sui prezzi on demand. Dopo aver identificato una prenotazione in modalità calendario creata automaticamente che puoi utilizzare, la creazione di un job che utilizza una prenotazione in modalità calendario è molto simile alla creazione di un job che utilizza una prenotazione.

    Scopri di più sulle prenotazioni in modalità calendario nella documentazione di Compute Engine.

Batch utilizza prenotazioni in modalità calendario per i lavori che eseguono tutte le seguenti operazioni:

VM con avvio flessibile

  • Caso d'uso: consigliamo le Flex-start VM se il tuo job può tollerare l'ottenibilità secondo il principio del "best effort" in cambio di prezzi scontati e fino a 7 giorni per completare l'esecuzione.

    Rispetto alle VM on demand e spot, le VM con avvio flessibile possono semplificare l'accesso simultaneo a molte risorse GPU. Ad esempio, le VM con avvio flessibile possono essere utili per la pianificazione dei job, in quanto riducono i ritardi o i problemi causati dalla mancata disponibilità delle risorse.

  • Dettagli: se una richiesta di creazione di un job che utilizza Flex-start VM viene soddisfatta, alle VM vengono addebitati i prezzi di Dynamic Workload Scheduler, che offrono sconti fino al 53% sui prezzi on demand.

    Scopri di più sulle VM Flex-start nella documentazione di Compute Engine.

On demand

  • Caso d'uso: on demand è veloce e semplice da provare, quindi è l'opzione di consumo predefinita per la maggior parte dei job.1 Tuttavia, non consigliamo on demand se un'altra opzione di consumo si adatta meglio alle tue priorità o se riscontri ripetutamente problemi con l'ottenibilità delle risorse.

  • Dettagli: on demand è in genere il modo predefinito per accedere alle VM di Compute Engine. On demand ti consente di accedere alle risorse (se disponibili) quando richiesto. Le risorse non vengono eliminate finché il job non termina o non viene raggiunto il limite di tempo di esecuzione.

Per impostazione predefinita, Batch utilizza on demand per la maggior parte dei job. Se vuoi assicurarti che un job utilizzi on demand, esegui tutte le seguenti operazioni:1

  • Imposta il campo provisioningModel su STANDARD.
  • Previeni il consumo delle prenotazioni. Per impedire a un job di utilizzare automaticamente le prenotazioni compatibili, imposta il campo reservation su NO_RESERVATION. Per saperne di più, consulta Crea ed esegui un job che non può utilizzare le VM prenotate.

1Eccezione: per i job che utilizzano la serie di macchine A3, il comportamento predefinito è univoco e ti consigliamo di non utilizzare on demand e di non lasciare il campo provisioningModel non definito; utilizza invece i requisiti dei job per le VM con avvio flessibile. L'utilizzo on demand non è consigliato per la serie di macchine A3 a causa della scarsa disponibilità di risorse. Di conseguenza, se un job utilizza la serie di macchine A3, blocca le prenotazioni e ha il campo provisioningModel non definito o impostato su STANDARD, l'opzione di consumo predefinita è unica: il comportamento è simile alle Flex-start VM, che limitano il tempo di esecuzione a 7 giorni; tuttavia, non è consigliato perché questi job non ricevono sconti dai prezzi di Dynamic Workload Scheduler. Se il tuo job con VM A3 può tollerare un limite di tempo di esecuzione di 7 giorni, ti consigliamo di utilizzare le Flex-start VM anziché on demand. In caso contrario, non puoi assicurarti che i job con VM A3 utilizzino on-demand, a meno che non imposti provisioningModel su STANDARD e verifichi manualmente che il job non possa utilizzare prenotazioni, senza impostare il campo reservation su NO_RESERVATION.

VM spot

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

  • Dettagli: se una richiesta di creazione di un job che utilizza VM spot viene soddisfatta, alle VM vengono addebitati i prezzi delle VM spot, che possono cambiare spesso e potrebbero fornire lo sconto maggiore, fino al 91% di sconto sui prezzi on demand. Tuttavia, le VM spot potrebbero non essere sempre disponibili e possono essere prerilasciate in qualsiasi momento.

    Scopri di più sulle VM spot e sui suggerimenti per i job con VM spot.

Batch utilizza VM spot per i job che svolgono tutte le seguenti attività:

  • Imposta il campo provisioningModel su SPOT.
  • (Facoltativo) Previeni il consumo delle prenotazioni. Non puoi utilizzare le VM spot con le prenotazioni. In particolare, il job può facoltativamente impostare il campo reservation su NO_RESERVATION. Per saperne di più, consulta Crea ed esegui un job che non può utilizzare le VM prenotate.

Passaggio 2: installa i driver della GPU

Per utilizzare le GPU per un job, devi installare i driver GPU. Per installare i driver della GPU, seleziona uno dei seguenti metodi:

Passaggio 3: definisci le risorse VM compatibili

Per scoprire i requisiti e le opzioni per la definizione delle risorse VM per un job, consulta Risorse del job.

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

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

    Per scoprire dove sono disponibili i tipi di macchine GPU, consulta Località delle GPU nella documentazione di Compute Engine.

  • Se specifichi il tipo di macchina del job, assicurati che abbia vCPU e memoria sufficienti per i requisiti delle attività del job. La specifica del tipo di macchina del job è obbligatoria ogni volta che crei un job utilizzando la console Google Cloud ed è consigliata ogni volta che crei un job che utilizza GPU per VM ottimizzate per l'acceleratore.

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

    • Definisci le risorse della VM direttamente utilizzando il campo instances[].policy (consigliato, se possibile). Questo metodo è mostrato negli esempi.
    • Definisci le risorse VM tramite un template utilizzando il campo instances[].instanceTemplate. Questo metodo è obbligatorio per installare manualmente i driver GPU tramite un'immagine personalizzata. Per saperne di più, consulta Definisci le risorse del job utilizzando un template di istanza VM.

Crea un job che utilizza le GPU

Le sezioni seguenti spiegano come creare un job di esempio per ogni opzione di consumo. In particolare, i job di esempio utilizzano le opzioni consigliate: tutti installano automaticamente i driver GPU e tutti definiscono direttamente le risorse VM.

Opzione di consumo Esempi di istruzioni per i job
Prenotazioni o prenotazioni in modalità calendario

Garantisci la disponibilità delle risorse utilizzando le prenotazioni delle VM
VM con avvio flessibile

Utilizza GPU e VM Flex-start
VM on demand o VM spot

Seleziona una delle seguenti opzioni in base al tipo di macchina GPU:

Utilizza GPU e VM Flex-start

Puoi creare un job che utilizza GPU per le VM A3 tramite Dynamic Workload Scheduler utilizzando gcloud CLI o l'API Batch.

gcloud

  1. Crea un file JSON che installi i driver GPU, specifichi un tipo di macchina GPU che supporti le VM Flex-start, blocchi le prenotazioni e venga eseguito in una località che supporti il tipo di macchina GPU.

    Ad esempio, per creare un job di script di base che utilizza VM Flex-start e GPU per VM ottimizzate per l'acceleratore, 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": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Sostituisci quanto segue:

    • INSTALL_GPU_DRIVERS: se installare o meno automaticamente i driver della GPU. 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 GPU che supporta le VM con avvio flessibile. Per saperne di più, consulta Disponibilità delle opzioni di consumo per tipo di macchina nella documentazione di Compute Engine.

    • ALLOWED_LOCATIONS: le località consentite per il job. Assicurati che la località delle risorse di Compute Engine del job offra il tipo di macchina GPU che vuoi per questo job utilizzando una delle seguenti opzioni:

      • Per impostazione predefinita, se ometti il campo allowedLocations[], un job viene eseguito sulle risorse Compute Engine create nella regione della località del job (LOCATION).
      • Facoltativamente, se includi il campo allowedLocations[], il job può essere eseguito solo sulle risorse Compute Engine create nelle località specificate.

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

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

API

Effettua una richiesta POST al metodo jobs.create che installa i driver GPU, specifica un tipo di macchina GPU che supporta le Flex-start VM, blocca le prenotazioni e viene eseguito in una località che supporta il tipo di macchina GPU.

Ad esempio, per creare un job di script di base che utilizza VM Flex-start e GPU per VM ottimizzate per l'acceleratore, invia 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": {
                    "provisioningModel":"FLEX_START",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del tuo progetto.

  • LOCATION: la località del job.

  • JOB_NAME: il nome del job.

  • INSTALL_GPU_DRIVERS: se installare o meno automaticamente i driver della GPU. 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 GPU che supporta le VM con avvio flessibile. Per ulteriori informazioni, consulta Disponibilità delle opzioni di consumo per tipo di macchina nella documentazione di Compute Engine.

  • ALLOWED_LOCATIONS: le località consentite per il job. Assicurati che la località delle risorse di Compute Engine del job offra il tipo di macchina GPU che vuoi per questo job utilizzando una delle seguenti opzioni:

    • Per impostazione predefinita, se ometti il campo allowedLocations[], un job viene eseguito sulle risorse Compute Engine create nella regione della località del job (LOCATION).
    • Facoltativamente, se includi il campo allowedLocations[], il job può essere eseguito solo sulle risorse Compute Engine create nelle località specificate.

Utilizza le GPU per le VM ottimizzate per l'acceleratore

Puoi creare un job che utilizza le GPU per le VM ottimizzate per l'acceleratore utilizzando la consoleGoogle Cloud , gcloud CLI, l'API Batch, Java, Node.js o Python.

Console

Per creare un job che utilizza le GPU tramite la console Google Cloud , segui questi passaggi:

  1. Nella console Google Cloud , vai alla pagina Elenco job.

    Vai all'elenco dei job

  2. Fai clic su Crea. Viene visualizzata la pagina Crea job batch. Nel riquadro a sinistra, è selezionata la pagina Dettagli job.

  3. Configura la pagina Dettagli job:

    1. (Facoltativo) Nel campo Nome job, personalizza il nome del job.

      Ad esempio, inserisci example-gpu-job.

    2. Configura la sezione Dettagli attività:

      1. Nella finestra Nuovo eseguibile, aggiungi almeno uno script o un container per l'esecuzione di questo job.

        Ad esempio, per creare un job di script di base, segui questi passaggi:

        1. Seleziona la casella di controllo Script. Viene visualizzato un campo.

        2. Nel campo, inserisci il seguente script:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Fai clic su Fine.

      2. Nel campo Conteggio attività, inserisci il numero di attività per questo job.

        Ad esempio, inserisci 3.

      3. (Facoltativo) Nel campo Parallelismo, inserisci il numero di attività da eseguire contemporaneamente.

        Ad esempio, inserisci 1 (impostazione predefinita).

  4. Configura la pagina Specifiche delle risorse:

    1. Nel riquadro a sinistra, fai clic su Specifiche delle risorse. Viene visualizzata la pagina Specifiche delle risorse.

    2. Nella sezione Modello di provisioning delle VM, seleziona una delle seguenti opzioni per l'opzione di consumo per le VM di questo job:

      • Se il tuo job può tollerare il prerilascio e vuoi VM spot scontate, seleziona Spot.

      • In caso contrario, per utilizzare le VM on demand, seleziona Standard (impostazione predefinita).

    3. Seleziona la località per questo job.

      1. Nel campo Regione, seleziona una regione.

      2. Nel campo Zona, esegui una delle seguenti operazioni:

        • Se vuoi limitare l'esecuzione di questo job solo a una zona specifica, seleziona una zona.

        • In caso contrario, seleziona Qualsiasi (impostazione predefinita).

    4. Seleziona il tipo di macchina GPU per le VM di questo job:

      1. Nelle opzioni della famiglia di macchine, fai clic su GPU.

      2. Nel campo Tipo di GPU, seleziona il tipo di GPU. Quindi, nel campo Numero di GPU, seleziona il numero di GPU per ogni VM.

        Se hai selezionato uno dei tipi di GPU per le VM ottimizzate per l'acceleratore, il campo Tipo di macchina consente una sola opzione per il tipo di macchina in base al tipo e al numero di GPU selezionati.

      3. Per installare automaticamente i driver GPU, seleziona Installazione dei driver GPU (impostazione predefinita).

    5. Configura la quantità di risorse VM richieste per ogni attività:

      1. Nel campo Core, inserisci il numero di vCPUs per attività.

        Ad esempio, inserisci 1 (impostazione predefinita).

      2. Nel campo Memoria, inserisci la quantità di RAM in GB per attività.

        Ad esempio, inserisci 0.5 (impostazione predefinita).

    6. Fai clic su Fine.

  5. (Facoltativo) Configura gli altri campi per questo job.

  6. (Facoltativo) Per esaminare la configurazione del job, fai clic su Anteprima nel riquadro a sinistra.

  7. Fai clic su Crea.

    Nella pagina Dettagli job viene visualizzato il job che hai creato.

gcloud

  1. Crea un file JSON che installi i driver GPU, specifichi un tipo di macchina della famiglia di macchine ottimizzate per l'acceleratore e venga eseguito 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 ottimizzate per l'acceleratore, 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Sostituisci quanto segue:

    • INSTALL_GPU_DRIVERS: se installare o meno automaticamente i driver della GPU. 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.

    • PROVISIONING_MODEL: il modello di provisioning per la tua opzione di consumo, ovvero STANDARD per on demand o SPOT per le VM spot.

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

    • ALLOWED_LOCATIONS: le località consentite per il job. Assicurati che la località delle risorse di Compute Engine del job offra il tipo di macchina GPU che vuoi per questo job utilizzando una delle seguenti opzioni:

      • Per impostazione predefinita, se ometti il campo allowedLocations[], un job viene eseguito sulle risorse Compute Engine create nella regione della località del job (LOCATION).
      • Facoltativamente, se includi il campo allowedLocations[], il job può essere eseguito solo sulle risorse Compute Engine create nelle località specificate.

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

    • 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 e viene eseguito in una località con il tipo di macchina GPU.

Ad esempio, per creare un job di script di base che utilizza GPU per VM ottimizzate per l'acceleratore, invia 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del tuo progetto.

  • LOCATION: la località del job.

  • JOB_NAME: il nome del job.

  • INSTALL_GPU_DRIVERS: se installare o meno automaticamente i driver della GPU. 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.

  • PROVISIONING_MODEL: il modello di provisioning per la tua opzione di consumo, ovvero STANDARD per on demand o SPOT per le VM spot.

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

  • ALLOWED_LOCATIONS: le località consentite per il job. Assicurati che la località delle risorse di Compute Engine del job offra il tipo di macchina GPU che vuoi per questo job utilizzando una delle seguenti opzioni:

    • Per impostazione predefinita, se ometti il campo allowedLocations[], un job viene eseguito sulle risorse Compute Engine create nella regione della località del job (LOCATION).
    • Facoltativamente, se includi il campo allowedLocations[], il job può essere eseguito solo sulle risorse Compute Engine create nelle località specificate.

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)

Utilizza le GPU per le VM N1

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

Console

Per creare un job che utilizza le GPU tramite la console Google Cloud , segui questi passaggi:

  1. Nella console Google Cloud , vai alla pagina Elenco job.

    Vai all'elenco dei job

  2. Fai clic su Crea. Viene visualizzata la pagina Crea job batch. Nel riquadro a sinistra, è selezionata la pagina Dettagli job.

  3. Configura la pagina Dettagli job:

    1. (Facoltativo) Nel campo Nome job, personalizza il nome del job.

      Ad esempio, inserisci example-gpu-job.

    2. Configura la sezione Dettagli attività:

      1. Nella finestra Nuovo eseguibile, aggiungi almeno uno script o un container per l'esecuzione di questo job.

        Ad esempio, per creare un job di script di base, segui questi passaggi:

        1. Seleziona la casella di controllo Script. Viene visualizzato un campo.

        2. Nel campo, inserisci il seguente script:

          echo Hello world from task ${BATCH_TASK_INDEX}.

        3. Fai clic su Fine.

      2. Nel campo Conteggio attività, inserisci il numero di attività per questo job.

        Ad esempio, inserisci 3.

      3. (Facoltativo) Nel campo Parallelismo, inserisci il numero di attività da eseguire contemporaneamente.

        Ad esempio, inserisci 1 (impostazione predefinita).

  4. Configura la pagina Specifiche delle risorse:

    1. Nel riquadro a sinistra, fai clic su Specifiche delle risorse. Viene visualizzata la pagina Specifiche delle risorse.

    2. Nella sezione Modello di provisioning delle VM, seleziona una delle seguenti opzioni per l'opzione di consumo per le VM di questo job:

      • Se il tuo job può tollerare il prerilascio e vuoi VM spot scontate, seleziona Spot.

      • In caso contrario, per utilizzare le VM on demand, seleziona Standard (impostazione predefinita).

    3. Seleziona la località per questo job.

      1. Nel campo Regione, seleziona una regione.

      2. Nel campo Zona, esegui una delle seguenti operazioni:

        • Se vuoi limitare l'esecuzione di questo job solo a una zona specifica, seleziona una zona.

        • In caso contrario, seleziona Qualsiasi (impostazione predefinita).

    4. Seleziona il tipo di macchina GPU per le VM di questo job:

      1. Nelle opzioni della famiglia di macchine, fai clic su GPU.

      2. Nel campo Tipo di GPU, seleziona il tipo di GPU.

        Se hai selezionato uno dei tipi di GPU per le VM N1, il campo Serie è impostato su N1.

      3. Nel campo Numero di GPU, seleziona il numero di GPU per ogni VM.

      4. Nel campo Tipo di macchina, seleziona il tipo di macchina.

      5. Per installare automaticamente i driver GPU, seleziona Installazione dei driver GPU (impostazione predefinita).

    5. Configura la quantità di risorse VM richieste per ogni attività:

      1. Nel campo Core, inserisci il numero di vCPUs per attività.

        Ad esempio, inserisci 1 (impostazione predefinita).

      2. Nel campo Memoria, inserisci la quantità di RAM in GB per attività.

        Ad esempio, inserisci 0.5 (impostazione predefinita).

    6. Fai clic su Fine.

  5. (Facoltativo) Configura gli altri campi per questo job.

  6. (Facoltativo) Per esaminare la configurazione del job, fai clic su Anteprima nel riquadro a sinistra.

  7. Fai clic su Crea.

    Nella pagina Dettagli job viene visualizzato il job che hai creato.

gcloud

  1. Crea un file JSON che installi i driver GPU, definisca i campi secondari type e count del campo accelerators[] ed esegua l'operazione in una località con il tipo di macchina GPU.

    Ad esempio, per creare un job di script di base che utilizza GPU per le VM N1 e consente 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    Sostituisci quanto segue:

    • INSTALL_GPU_DRIVERS: se installare o meno automaticamente i driver della GPU. 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.

    • PROVISIONING_MODEL: il modello di provisioning per la tua opzione di consumo, ovvero STANDARD per on demand o SPOT per le VM spot.

    • 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: le località consentite per il job. Assicurati che la località delle risorse di Compute Engine del job offra il tipo di macchina GPU che vuoi per questo job utilizzando una delle seguenti opzioni:

      • Per impostazione predefinita, se ometti il campo allowedLocations[], un job viene eseguito sulle risorse Compute Engine create nella regione della località del job (LOCATION).
      • Facoltativamente, se includi il campo allowedLocations[], il job può essere eseguito solo sulle risorse Compute Engine create nelle località specificate.

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

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

API

Effettua una richiesta POST al metodo jobs.create che installa i driver GPU, definisce i sottocampi type e count del campo accelerators[] e utilizza una località 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto del tuo progetto.

  • LOCATION: la località del job.

  • JOB_NAME: il nome del job.

  • INSTALL_GPU_DRIVERS: se installare o meno automaticamente i driver della GPU. 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.

  • PROVISIONING_MODEL: il modello di provisioning per la tua opzione di consumo, ovvero STANDARD per on demand o SPOT per le VM spot.

  • 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 ulteriori informazioni sulle opzioni valide, consulta Tipi di macchine GPU per la serie di macchine N1. Utilizza questo campo solo per le GPU per le VM N1.

  • ALLOWED_LOCATIONS: le località consentite per il job. Assicurati che la località delle risorse di Compute Engine del job offra il tipo di macchina GPU che vuoi per questo job utilizzando una delle seguenti opzioni:

    • Per impostazione predefinita, se ometti il campo allowedLocations[], un job viene eseguito sulle risorse Compute Engine create nella regione della località del job (LOCATION).
    • Facoltativamente, se includi il campo allowedLocations[], il job può essere eseguito solo sulle risorse Compute Engine create nelle località specificate.

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