Crea ed esegui un job di base

Questo documento illustra le nozioni di base per la creazione di job batch: come creare ed eseguire un job basato su uno script o un'immagine container e utilizzare variabili predefinite e personalizzate. Per scoprire di più sulla creazione e l'esecuzione dei job, consulta Panoramica della creazione e dell'esecuzione dei job.

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:

   • Batch Job Editor (roles/batch.jobsEditor) nel progetto
   • Utente account di servizio (roles/iam.serviceAccountUser) nell'account di servizio del job, che per impostazione predefinita è l'account di servizio Compute Engine predefinito

   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.

3. Ogni volta che crei un job, assicurati che abbia una configurazione di rete valida.
   • Se non hai requisiti di rete specifici per il tuo progetto o carico di lavoro e non hai modificato la rete predefinita per il progetto, non è richiesta alcuna azione.
   • In caso contrario, devi configurare la rete quando crei un job. Scopri come configurare il networking per un job prima di crearne uno di base, in modo da poter modificare gli esempi riportati di seguito per soddisfare i tuoi requisiti di networking.
   Per ulteriori informazioni sulla configurazione di rete per un job, consulta Panoramica della rete batch.
4. Ogni volta che crei un job, assicurati che abbia un ambiente VM sistema operativo (OS) valido.
   • Se non hai requisiti specifici per l'immagine del sistema operativo o il disco di avvio della VM per il tuo workload o progetto, non devi fare nulla.
   • In caso contrario, devi preparare un'opzione di ambiente OS VM valida. Prima di creare un job di base, consenti la configurazione predefinita per l'ambiente del sistema operativo della VM o scopri come personalizzare l'ambiente del sistema operativo della VM in modo da poter modificare gli esempi riportati di seguito in base alle tue esigenze.
   Per saperne di più sull'ambiente del sistema operativo della VM per un job, consulta la panoramica dell'ambiente del sistema operativo della VM.

Creare un job di base

Per informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa REST projects.locations.jobs. In sintesi, un job è costituito da un array di una o più attività che eseguono tutte uno o più elementi eseguibili, ovvero gli script e/o i container eseguibili per il job. Per illustrare le nozioni di base, questa sezione spiega come creare un job di esempio con un solo elemento eseguibile, uno script o un'immagine container:

• Se vuoi utilizzare Batch per scrivere job che eseguono un'immagine container, consulta la sezione Creare un job container.
• In caso contrario, se non sai se vuoi utilizzare le immagini dei contenitori o se non hai dimestichezza con i contenitori, ti consigliamo di creare un job di script.

Il job di esempio per entrambi i tipi di job contiene un gruppo di attività con un array di 4 attività. Ogni attività stampa un messaggio e il relativo indice nell'output standard e in Cloud Logging. La definizione di questo job specifica un parallelismo di 2, il che indica che il job deve essere eseguito su 2 VM per consentire l'esecuzione di 2 attività alla volta.

Crea un job di container di base

Puoi selezionare o creare un'immagine contenitore per fornire il codice e le dipendenze necessarie per l'esecuzione del tuo job da qualsiasi ambiente di calcolo. Per ulteriori informazioni, consulta Utilizzare le immagini container e Eseguire i container sulle istanze VM.

Puoi creare un job di container di base utilizzando la console Google Cloud, gcloud CLI, l'API Batch, Go, Java, Node.js, Python o C++.

Console

Per creare un job di contenitore di base utilizzando la console Google Cloud, segui questi passaggi:

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

   Vai all'elenco di 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-basic-job.

   2. Configura la sezione Dettagli attività:

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

         Ad esempio, per aggiungere un contenitore:

         1. Seleziona URL immagine container (valore predefinito).

         2. Nel campo URL immagine container, inserisci l'URL di un'immagine container che vuoi eseguire per ogni attività in questo job.

            Ad esempio, per utilizzare l'immagine del contenitore Docker busybox, inserisci il seguente URL:

            gcr.io/google-containers/busybox
            

         3. (Facoltativo) Per eseguire l'override del comando ENTRYPOINT dell'immagine container, inserisci un comando nel campo Entry point.

            Ad esempio, inserisci quanto segue:

            /bin/sh
            

         4. (Facoltativo) Per eseguire l'override del comando CMD dell'immagine container, procedi nel seguente modo:

            1. Seleziona la casella di controllo Esegui l'override del comando CMD dell'immagine container. Viene visualizzato un campo.

            2. Nel campo, inserisci uno o più comandi, separando ciascun comando con un nuovo rigo.

               Ad esempio, inserisci i seguenti comandi:

               -c
               echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
               

            3. Fai clic su Fine.

      2. Nel campo Numero di attività, inserisci il numero di attività per questo job. Il valore deve essere un numero intero compreso tra 1 e il limite di attività per gruppo di attività.

         Ad esempio, inserisci 4.

      3. Nel campo Parallelismo, inserisci il numero di attività da eseguire contemporaneamente. Il numero non può essere maggiore del numero totale di attività e deve essere un numero intero compreso tra 1 e il limite di attività parallele per job.

         Ad esempio, inserisci 2.

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 il modello di provisioning delle VM di questo job:

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

      • In caso contrario, seleziona Standard.

      Ad esempio, seleziona Standard (impostazione predefinita).

   3. Seleziona la località per questo job:

      1. Nel campo Regione, seleziona una regione.

         Ad esempio, seleziona us-central1 (Iowa) (impostazione predefinita).

      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.

         Ad esempio, seleziona Qualsiasi (impostazione predefinita).

   4. Seleziona una delle seguenti famiglie di macchine:

      • Per i carichi di lavoro comuni, fai clic su Per uso generico.

      • Per i carichi di lavoro ad alte prestazioni, fai clic su Ottimizzato per il calcolo.

      • Per i workload che richiedono molta memoria, fai clic su Ottimizzato per la memoria.

      • Per i carichi di lavoro ottimizzati per l'acceleratore, fai clic su GPU. Per ulteriori informazioni, consulta la sezione Creare ed eseguire un job che utilizza le GPU.

      Ad esempio, fai clic su Uso generico (valore predefinito).

   5. Nel campo Serie, seleziona una serie di macchine per le VM di questo job.

      Ad esempio, se hai selezionato Uso generico per la famiglia di macchine, seleziona E2 (valore predefinito).

   6. Nel campo Tipo di macchina, seleziona un tipo di macchina per le VM di questo job.

      Ad esempio, se hai selezionato E2 per la serie di macchine, seleziona e2-medium (2 vCPU, 4 GB di memoria) (valore predefinito).

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

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

         Ad esempio, inserisci 1 (valore predefinito).

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

         Ad esempio, inserisci 0.5 (valore predefinito).

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

6. Fai clic su Crea.

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

gcloud

Per creare un job di contenitore di base utilizzando gcloud CLI, procedi nel seguente modo:

1. Crea un file JSON che specifichi i dettagli di configurazione del job. Ad esempio, per creare un job contenitore di base, crea un file JSON con i seguenti contenuti. Per ulteriori informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa REST projects.locations.jobs.

   Nota: se preferisci, puoi specificare i dettagli di configurazione del job in un file YAML anziché in un file JSON convertendo autonomamente la sintassi JSON in sintassi YAML. Tuttavia, la documentazione di Batch fornisce solo esempi per la sintassi JSON. Per ulteriori informazioni, consulta il comando gcloud batch jobs submit.

   {
       "taskGroups": [
           {
               "taskSpec": {
                   "runnables": [
                       {
                           "container": {
                               CONTAINER
                           }
                       }
                   ],
                   "computeResource": {
                       "cpuMilli": CORES,
                       "memoryMib": MEMORY
                   },
                   "maxRetryCount": MAX_RETRY_COUNT,
                   "maxRunDuration": "MAX_RUN_DURATION"
               },
               "taskCount": TASK_COUNT,
               "parallelism": PARALLELISM
           }
       ]
   }
   

   Sostituisci quanto segue:

   • CONTAINER: il contenitore in cui viene eseguita ogni attività. Come minimo, un contenitore deve specificare un'immagine nel sottocampo imageUri, ma potrebbero essere necessari anche sottocampi aggiuntivi. Per ulteriori informazioni, consulta i sottocampi container e il job contenitore di esempio in questa sezione.
   • CORES: facoltativo. La quantità di core, in particolare vCPU, che solitamente rappresentano metà di un core fisico, da allocare per ogni attività in unità milliCPU. Se il campo cpuMilli non è specificato, il valore viene impostato su 2000 (2 vCPU).
   • MEMORY: facoltativo. La quantità di memoria da allocare per ogni attività in MB. Se il campo memoryMib non è specificato, il valore viene impostato su 2000 (2 GB).
   • MAX_RETRY_COUNT: facoltativo. Il numero massimo di tentativi per un'attività. Il valore deve essere un numero intero compreso tra 0 e 10. Se il campo maxRetryCount non è specificato, il valore viene impostato su 0, il che significa di non riprovare a eseguire l'attività. Per ulteriori informazioni sul campo maxRetryCount, consulta Automatizzare i tentativi di esecuzione delle attività.
   • MAX_RUN_DURATION: facoltativo. Il tempo massimo per cui è consentita l'esecuzione di un'attività prima di riprovare o di non riuscire, formattato come un valore in secondi seguito da s, ad esempio 3600s per 1 ora. Se il campo maxRunDuration non è specificato, il valore viene impostato sul tempo di esecuzione massimo per un job. Per ulteriori informazioni sul campo maxRunDuration, consulta Limitare i tempi di esecuzione di attività e eseguibili utilizzando i timeout.
   • TASK_COUNT: facoltativo. Il numero di attività per il job. Il valore deve essere un numero intero compreso tra 1 e il limite di attività per gruppo di attività. Se il campo taskCount non è specificato, il valore viene impostato su 1.
   • PARALLELISM: facoltativo. Il numero di attività che il job esegue contemporaneamente. Il numero non può essere maggiore del numero di attività e deve essere un numero intero compreso tra 1 e il limite di attività parallele per job. Se il campo parallelism non è specificato, il valore viene impostato su 1.

2. Crea un job utilizzando 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.

Ad esempio, per creare un job che esegue attività utilizzando l'busyboximmagine del container Docker:

1. Crea un file JSON nella directory attuale denominato hello-world-container.json con i seguenti contenuti:

   {
       "taskGroups": [
           {
               "taskSpec": {
                   "runnables": [
                       {
                           "container": {
                               "imageUri": "gcr.io/google-containers/busybox",
                               "entrypoint": "/bin/sh",
                               "commands": [
                                   "-c",
                                   "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                               ]
                           }
                       }
                   ],
                   "computeResource": {
                       "cpuMilli": 2000,
                       "memoryMib": 16
                   },
                   "maxRetryCount": 2,
                   "maxRunDuration": "3600s"
               },
               "taskCount": 4,
               "parallelism": 2
           }
       ],
       "allocationPolicy": {
           "instances": [
               {
                   "policy": { "machineType": "e2-standard-4" }
               }
           ]
       },
       "labels": {
           "department": "finance",
           "env": "testing"
       },
       "logsPolicy": {
           "destination": "CLOUD_LOGGING"
       }
   }
   

2. Esegui questo comando:

   gcloud batch jobs submit example-container-job \
     --location us-central1 \
     --config hello-world-container.json
   

API

Per creare un job di contenitore di base utilizzando l'API Batch, utilizza il metodo jobs.create. Per ulteriori informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa REST projects.locations.jobs.

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            CONTAINER
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}

Sostituisci quanto segue:

• PROJECT_ID: il ID progetto del tuo progetto.
• LOCATION: la località del lavoro.
• JOB_NAME: il nome del job.
• CONTAINER: il contenitore in cui viene eseguita ogni attività. Come minimo, un contenitore deve specificare un'immagine nel sottocampo imageUri, ma potrebbero essere necessari anche sottocampi aggiuntivi. Per ulteriori informazioni, consulta i sottocampi container e il job contenitore di esempio in questa sezione.
• CORES: facoltativo. La quantità di core, in particolare vCPU, che solitamente rappresentano metà di un core fisico, da allocare per ogni attività in unità di milliCPU. Se il campo cpuMilli non è specificato, il valore viene impostato su 2000 (2 vCPU).
• MEMORY: facoltativo. La quantità di memoria da allocare per ogni attività in MB. Se il campo memoryMib non è specificato, il valore viene impostato su 2000 (2 GB).
• MAX_RETRY_COUNT: facoltativo. Il numero massimo di tentativi per un'attività. Il valore deve essere un numero intero compreso tra 0 e 10. Se il campo maxRetryCount non è specificato, il valore viene impostato su 0, il che significa di non riprovare a eseguire l'attività. Per ulteriori informazioni sul campo maxRetryCount, consulta Automatizzare i tentativi di esecuzione delle attività.
• MAX_RUN_DURATION: facoltativo. Il tempo massimo per cui è consentita l'esecuzione di un'attività prima di riprovare o di non riuscire, formattato come un valore in secondi seguito da s, ad esempio 3600s per 1 ora. Se il campo maxRunDuration non è specificato, il valore viene impostato sul tempo di esecuzione massimo per un job. Per ulteriori informazioni sul campo maxRunDuration, consulta Limitare i tempi di esecuzione di attività e eseguibili utilizzando i timeout.
• TASK_COUNT: facoltativo. Il numero di attività per il job, che deve essere un numero intero compreso tra 1 e il limite di attività per gruppo di attività. Se il campo taskCount non è specificato, il valore viene impostato su 1.
• PARALLELISM: facoltativo. Il numero di attività eseguite contemporaneamente dal job. Il numero non può essere superiore al numero di attività e deve essere un numero intero compreso tra 1 e il limite di attività parallele per job. Se il campo parallelism non è specificato, il valore viene impostato su 1.

Ad esempio, per creare un job che esegue attività utilizzando l'immagine del container Docker busybox, utilizza la seguente richiesta:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/jobs?job_id=example-container-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            "imageUri": "gcr.io/google-containers/busybox",
                            "entrypoint": "/bin/sh",
                            "commands": [
                                "-c",
                                "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                            ]
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

dove PROJECT_ID è l'ID progetto del tuo progetto.

Vai

Go

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch Go.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that runs the specified container
func createContainerJob(w io.Writer, projectID, region, jobName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	container := &batchpb.Runnable_Container{
		ImageUri:   "gcr.io/google-containers/busybox",
		Commands:   []string{"-c", "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."},
		Entrypoint: "/bin/sh",
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 2 whole CPUs.
		CpuMilli:  2000,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Container_{Container: container},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// 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 "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "container"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Java

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch Java.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.batch.v1.AllocationPolicy;
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.ComputeResource;
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.LogsPolicy.Destination;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.Runnable.Container;
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 CreateWithContainerNoMounting {

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

    createContainerJob(projectId, region, jobName);
  }

  // This method shows how to create a sample Batch Job that will run a simple command inside a
  // container on Cloud Compute instances.
  public static void createContainerJob(String projectId, String region, String jobName)
      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. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setContainer(
                  Container.newBuilder()
                      .setImageUri("gcr.io/google-containers/busybox")
                      .setEntrypoint("/bin/sh")
                      .addCommands("-c")
                      .addCommands(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                              + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      .build())
              .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 2 whole CPUs.
              .setCpuMilli(2000)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .setComputeResource(computeResource)
              .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(4).setTaskSpec(task).build();

      // 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 "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(InstancePolicyOrTemplate.newBuilder().setPolicy(instancePolicy).build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "container")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING).build())
              .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());
    }
  }
}

Node.js

Node.js

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch Node.js.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';

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

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.container = new batch.Runnable.Container();
runnable.container.imageUri = 'gcr.io/google-containers/busybox';
runnable.container.entrypoint = '/bin/sh';
runnable.container.commands = [
  '-c',
  'echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.',
];
task.runnables = [runnable];

// We can specify what resources are requested by each task.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.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 "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'container'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.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 callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const response = await batchClient.createJob(request);
  console.log(response);
}

await callCreateJob();

Python

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch Python.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import batch_v1


def create_container_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 inside a container on Cloud Compute instances.

    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.
    runnable = batch_v1.Runnable()
    runnable.container = batch_v1.Runnable.Container()
    runnable.container.image_uri = "gcr.io/google-containers/busybox"
    runnable.container.entrypoint = "/bin/sh"
    runnable.container.commands = [
        "-c",
        "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.",
    ]

    # Jobs can be divided into tasks. In this case, we have only one task.
    task = batch_v1.TaskSpec()
    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 "e2-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 = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    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)

C++

C++

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch C++.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            container {
              image_uri: "gcr.io/google-containers/busybox"
              entrypoint: "/bin/sh"
              commands: "-c"
              commands: "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "container" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

Creare un job di script di base

Puoi creare un job di script di base utilizzando la console Google Cloud, gcloud CLI, l'API Batch, Go, Java, Node.js, Python o C++.

Console

Per creare un job di script di base utilizzando la console Google Cloud, segui questi passaggi:

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

   Vai all'elenco di 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-basic-job.

   2. Configura la sezione Dettagli attività:

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

         Ad esempio, per aggiungere uno script:

         1. Seleziona Script. Viene visualizzato un campo.

         2. Nel campo, inserisci uno script da eseguire per ogni attività di questo job.

            Ad esempio, inserisci il seguente script:

            echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
            

         3. Fai clic su Fine.

      2. Nel campo Numero di attività, inserisci il numero di attività per questo job. Il valore deve essere un numero intero compreso tra 1 e il limite di attività per gruppo di attività.

         Ad esempio, inserisci 4.

      3. Nel campo Parallelismo, inserisci il numero di attività da eseguire contemporaneamente. Il numero non può essere maggiore del numero totale di attività e deve essere un numero intero compreso tra 1 e il limite di attività parallele per job.

         Ad esempio, inserisci 2.

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 il modello di provisioning delle VM di questo job:

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

      • In caso contrario, seleziona Standard.

      Ad esempio, seleziona Standard (impostazione predefinita).

   3. Seleziona la località per questo job:

      1. Nel campo Regione, seleziona una regione.

         Ad esempio, seleziona us-central1 (Iowa) (impostazione predefinita).

      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.

         Ad esempio, seleziona Qualsiasi (impostazione predefinita).

   4. Seleziona una delle seguenti famiglie di macchine:

      • Per i carichi di lavoro comuni, fai clic su Per uso generico.

      • Per i carichi di lavoro ad alte prestazioni, fai clic su Ottimizzato per il calcolo.

      • Per i workload che richiedono molta memoria, fai clic su Ottimizzato per la memoria.

      • Per i carichi di lavoro ottimizzati per l'acceleratore, fai clic su GPU. Per ulteriori informazioni, consulta la sezione Creare ed eseguire un job che utilizza le GPU.

      Ad esempio, fai clic su Uso generico (valore predefinito).

   5. Nel campo Serie, seleziona una serie di macchine per le VM di questo job.

      Ad esempio, se hai selezionato Uso generico per la famiglia di macchine, seleziona E2 (valore predefinito).

   6. Nel campo Tipo di macchina, seleziona un tipo di macchina per le VM di questo job.

      Ad esempio, se hai selezionato E2 per la serie di macchine, seleziona e2-medium (2 vCPU, 4 GB di memoria) (valore predefinito).

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

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

         Ad esempio, inserisci 1 (valore predefinito).

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

         Ad esempio, inserisci 0.5 (valore predefinito).

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

6. Fai clic su Crea.

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

gcloud

Per creare un job di script di base utilizzando gcloud CLI, procedi nel seguente modo:

1. Crea un file JSON che specifichi i dettagli di configurazione del job. Ad esempio, per creare un job di script di base, crea un file JSON con i seguenti contenuti. Per ulteriori informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa REST projects.locations.jobs.

   Nota: se preferisci, puoi specificare i dettagli di configurazione del job in un file YAML anziché in un file JSON convertendo autonomamente la sintassi JSON in sintassi YAML. Tuttavia, la documentazione di Batch fornisce solo esempi per la sintassi JSON. Per ulteriori informazioni, consulta il comando gcloud batch jobs submit.

   {
       "taskGroups": [
           {
               "taskSpec": {
                   "runnables": [
                       {
                           "script": {
                               SCRIPT
                           }
                       }
                   ],
                   "computeResource": {
                       "cpuMilli": CORES,
                       "memoryMib": MEMORY
                   },
                   "maxRetryCount": MAX_RETRY_COUNT,
                   "maxRunDuration": "MAX_RUN_DURATION"
               },
               "taskCount": TASK_COUNT,
               "parallelism": PARALLELISM
           }
       ]
   }
   

   Sostituisci quanto segue:

   • SCRIPT: lo script eseguito da ogni attività. Uno script deve essere definito come testo utilizzando il sottocampo text o come percorso di un file accessibile utilizzando il sottocampo path. Per ulteriori informazioni, consulta i subcampi script e il job di script di esempio in questa sezione.
   • CORES: facoltativo. La quantità di core, in particolare vCPU, che solitamente rappresentano metà di un core fisico, da allocare per ogni attività in unità milliCPU. Se il campo cpuMilli non è specificato, il valore viene impostato su 2000 (2 vCPU).
   • MEMORY: facoltativo. La quantità di memoria da allocare per ogni attività in MB. Se il campo memoryMib non è specificato, il valore viene impostato su 2000 (2 GB).
   • MAX_RETRY_COUNT: facoltativo. Il numero massimo di tentativi per un'attività. Il valore deve essere un numero intero compreso tra 0 e 10. Se il campo maxRetryCount non è specificato, il valore viene impostato su 0, il che significa di non riprovare a eseguire l'attività. Per ulteriori informazioni sul campo maxRetryCount, consulta Automatizzare i tentativi di esecuzione delle attività.
   • MAX_RUN_DURATION: facoltativo. Il tempo massimo per cui è consentita l'esecuzione di un'attività prima di riprovare o di non riuscire, formattato come un valore in secondi seguito da s, ad esempio 3600s per 1 ora. Se il campo maxRunDuration non è specificato, il valore viene impostato sul tempo di esecuzione massimo per un job. Per ulteriori informazioni sul campo maxRunDuration, consulta Limitare i tempi di esecuzione di attività e eseguibili utilizzando i timeout.
   • TASK_COUNT: facoltativo. Il numero di attività per il job. Il valore deve essere un numero intero compreso tra 1 e il limite di attività per gruppo di attività. Se il campo taskCount non è specificato, il valore viene impostato su 1.
   • PARALLELISM: facoltativo. Il numero di attività che il job esegue contemporaneamente. Il numero non può essere maggiore del numero di attività e deve essere un numero intero compreso tra 1 e il limite di attività parallele per job. Se il campo parallelism non è specificato, il valore viene impostato su 1.

2. Crea un job utilizzando 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.

Ad esempio, per creare un job che esegue attività utilizzando uno script:

1. Crea un file JSON nella directory attuale denominato hello-world-script.json con i seguenti contenuti:

   {
       "taskGroups": [
           {
               "taskSpec": {
                   "runnables": [
                       {
                           "script": {
                               "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                           }
                       }
                   ],
                   "computeResource": {
                       "cpuMilli": 2000,
                       "memoryMib": 16
                   },
                   "maxRetryCount": 2,
                   "maxRunDuration": "3600s"
               },
               "taskCount": 4,
               "parallelism": 2
           }
       ],
       "allocationPolicy": {
           "instances": [
               {
                   "policy": { "machineType": "e2-standard-4" }
               }
           ]
       },
       "labels": {
           "department": "finance",
           "env": "testing"
       },
       "logsPolicy": {
           "destination": "CLOUD_LOGGING"
       }
   }
   

2. Esegui questo comando:

   gcloud batch jobs submit example-script-job \
     --location us-central1 \
     --config hello-world-script.json
   

API

Per creare un job di script di base utilizzando l'API Batch, utilizza il metodo jobs.create. Per ulteriori informazioni su tutti i campi che puoi specificare per un job, consulta la documentazione di riferimento per la risorsa REST projects.locations.jobs.

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}

Sostituisci quanto segue:

• PROJECT_ID: il ID progetto del tuo progetto.
• LOCATION: la località del lavoro.
• JOB_NAME: il nome del job.
• SCRIPT: lo script eseguito da ogni attività. Uno script deve essere definito come testo utilizzando il sottocampo text o come percorso di un file accessibile utilizzando il sottocampo path. Per ulteriori informazioni, consulta i subcampi script e il job di script di esempio in questa sezione.
• CORES: facoltativo. La quantità di core, in particolare vCPU, che solitamente rappresentano metà di un core fisico, da allocare per ogni attività in unità di milliCPU. Se il campo cpuMilli non è specificato, il valore viene impostato su 2000 (2 vCPU).
• MEMORY: facoltativo. La quantità di memoria da allocare per ogni attività in MB. Se il campo memoryMib non è specificato, il valore viene impostato su 2000 (2 GB).
• MAX_RETRY_COUNT: facoltativo. Il numero massimo di tentativi per un'attività. Il valore deve essere un numero intero compreso tra 0 e 10. Se il campo maxRetryCount non è specificato, il valore viene impostato su 0, il che significa di non riprovare a eseguire l'attività. Per ulteriori informazioni sul campo maxRetryCount, consulta Automatizzare i tentativi di esecuzione delle attività.
• MAX_RUN_DURATION: facoltativo. Il tempo massimo per cui è consentita l'esecuzione di un'attività prima di riprovare o di non riuscire, formattato come un valore in secondi seguito da s, ad esempio 3600s per 1 ora. Se il campo maxRunDuration non è specificato, il valore viene impostato sul tempo di esecuzione massimo per un job. Per ulteriori informazioni sul campo maxRunDuration, consulta Limitare i tempi di esecuzione di attività e eseguibili utilizzando i timeout.
• TASK_COUNT: facoltativo. Il numero di attività per il job. Il valore deve essere un numero intero compreso tra 1 e il limite di attività per gruppo di attività. Se il campo taskCount non è specificato, il valore viene impostato su 1.
• PARALLELISM: facoltativo. Il numero di attività eseguite contemporaneamente dal job. Il numero non può essere superiore al numero di attività e deve essere un numero intero compreso tra 1 e il limite di attività parallele per job. Se il campo parallelism non è specificato, il valore viene impostato su 1.

Ad esempio, per creare un job che esegue attività utilizzando uno script, utilizza la seguente richiesta:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/jobs?job_id=example-script-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

dove PROJECT_ID è l'ID progetto del tuo progetto.

Vai

Go

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch Go.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that executes the specified script
func createScriptJob(w io.Writer, projectID, region, jobName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		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.
	// command := &batchpb.Runnable_Script_Path{
	// 	Path: "/tmp/test.sh",
	// }

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 2 whole CPUs.
		CpuMilli:  2000,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Script_{
				Script: &batchpb.Runnable_Script{Command: command},
			},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// 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 "e2-standard-4" machine type.
	// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "script"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Java

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch Java.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.cloud.batch.v1.AllocationPolicy;
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.ComputeResource;
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.LogsPolicy.Destination;
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 CreateWithScriptNoMounting {

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

    createScriptJob(projectId, region, jobName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJob(String projectId, String region, String jobName)
      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. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    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();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 2 whole CPUs.
              .setCpuMilli(2000)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .setComputeResource(computeResource)
              .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(4).setTaskSpec(task).build();

      // 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 "e2-standard-4" machine type.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(InstancePolicyOrTemplate.newBuilder().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(Destination.CLOUD_LOGGING).build())
              .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());
    }
  }
}

Node.js

Node.js

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch Node.js.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';

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

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.script = new batch.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.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.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 "e2-standard-4" machine type.
// Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'script'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.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 callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

  // Run request
  const response = await batchClient.createJob(request);
  console.log(response);
}

await callCreateJob();

Python

Python

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch Python.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from google.cloud import batch_v1


def create_script_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.

    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
    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 "e2-standard-4" machine type.
    # Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
    allocation_policy = batch_v1.AllocationPolicy()
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}
    # 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)

C++

C++

Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Batch C++.

Per autenticarti a Batch, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            script {
              text: "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "script" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

Utilizzare le variabili di ambiente

Utilizza le variabili di ambiente quando scrivi uno script o un'immagine container per cui vuoi che venga eseguito un job. Puoi utilizzare una delle variabili di ambiente predefinite per tutti i job batch e le eventuali variabili di ambiente personalizzate che definisci durante la creazione del job.

Utilizzare le variabili di ambiente predefinite

Per impostazione predefinita, i file eseguibili nel job possono utilizzare le seguenti variabili di ambiente predefinite:

• BATCH_TASK_COUNT: il numero totale di attività in questo gruppo di attività.
• BATCH_TASK_INDEX: il numero di indice di questa attività nel gruppo di attività. L'indice della prima attività è 0 e viene incrementato per ogni attività aggiuntiva.
• BATCH_HOSTS_FILE: il percorso di un file che elenca tutte le istanze VM in esecuzione in questo gruppo di attività. Per utilizzare questa variabile di ambiente, il campo requireHostsFile deve essere impostato su true.
• BATCH_TASK_RETRY_ATTEMPT: il numero di volte in cui questa attività è stata già tentata. Il valore è 0 durante il primo tentativo di un'attività e viene incrementato per ogni nuovo tentativo. Il numero totale di nuovi tentativi consentiti per un'attività è determinato dal valore del campo maxRetryCount, che è 0 se non definito. Per ulteriori informazioni sui tentativi ripetuti, consulta Automatizzare i tentativi ripetuti delle attività.

Per un esempio di come utilizzare le variabili di ambiente predefinite, consulta gli esempi di eseguibili precedenti in Creare un job di base in questo documento.

Definire e utilizzare variabili di ambiente personalizzate

Se vuoi, puoi definire una o più variabili di ambiente personalizzate in un job.

Definisci ogni variabile in un ambiente specifico in base all'ambito preferito per i relativi dati:

• Per una variabile che ha lo stesso valore per tutte le attività, utilizza una delle seguenti opzioni:

  • Se la variabile ha lo stesso valore per tutti i runnable, utilizza l'ambiente di tutti i runnable (campo secondario environment di taskSpec).

  • In caso contrario, se la variabile ha un valore distinto per tutti i runnable, utilizza uno o più ambienti di runnable specifici (campo secondario environment di runnables[]).

• In caso contrario, per una variabile array che ha un valore separato per ogni attività, utilizza l'ambiente di tutte le attività (taskEnvironment).

Nell'ambiente selezionato, definisci il nome e i valori di ogni variabile utilizzando uno dei seguenti sottocampi dell'ambiente:

• Per definire la variabile direttamente nel file JSON di configurazione del job, utilizza il sottocampo delle variabili standard (variables), come mostrato in questa sezione. Questa opzione è consigliata per i dati che non vuoi criptare.

• Per definire la variabile utilizzando dati criptati, puoi utilizzare Secret Manager o Cloud Key Management Service:

  • Per utilizzare i contenuti criptati di un secret di Secret Manager esistente, utilizza il sottocampo delle variabili di secret (secretVariables). Per saperne di più sull'utilizzo dei secret in un job, consulta Proteggere i dati sensibili utilizzando Secret Manager.

  • Per utilizzare i contenuti criptati di una chiave Cloud Key Management Service esistente, utilizza il sottocampo delle variabili criptate (encryptedVariables). Per ulteriori informazioni sulle chiavi Cloud KMS, consulta la documentazione di Cloud Key Management Service.

Puoi definire e utilizzare variabili di ambiente personalizzate per il tuo job utilizzando l'interfaccia a riga di comando gcloud o l'API Batch. Gli esempi riportati di seguito spiegano come creare due job che definiscono e utilizzano variabili standard. Il primo job di esempio ha una variabile per un eseguibile specifico. Il secondo job di esempio ha una variabile array, che ha un valore diverso per ogni attività.

gcloud

Se vuoi definire un job che trasmette una variabile di ambiente a un programma eseguibile eseguito da ogni attività, consulta l'esempio su come definire e utilizzare una variabile di ambiente per un programma eseguibile. In caso contrario, se vuoi definire un job che trasmette un elenco di variabili di ambiente a diverse attività in base all'indice dell'attività, consulta l'esempio su come definire e utilizzare una variabile di ambiente per ogni attività.

Definire e utilizzare una variabile di ambiente per un file eseguibile

Per creare un job che trasmette le variabili di ambiente a un file eseguibile utilizzando la CLI gcloud, utilizza il comando gcloud batch jobs submit e specifica le variabili di ambiente nel file di configurazione del job.

Ad esempio, per creare un job di script che definisce una variabile di ambiente e la passa agli script di tre attività, effettua la seguente richiesta:

1. Crea un file JSON nella directory attuale denominato hello-world-environment-variables.json con i seguenti contenuti:

   {
       "taskGroups": [
           {
               "taskSpec": {
                   "runnables": [
                       {
                           "script": {
                               "text": "echo Hello ${VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                           },
                           "environment": {
                               "variables": {
                                   "VARIABLE_NAME": "VARIABLE_VALUE"
                               }
                           }
                       }
                   ],
                   "computeResource": {
                       "cpuMilli": 2000,
                       "memoryMib": 16
                   }
               },
               "taskCount": 3,
               "parallelism": 1
           }
       ],
       "allocationPolicy": {
           "instances": [
               {
                   "policy": {
                       "machineType": "e2-standard-4"
                   }
               }
           ]
       }
   }
   

   Sostituisci quanto segue:

   • VARIABLE_NAME: il nome della variabile di ambiente trasmessa a ogni attività. Per convenzione, i nomi delle variabili di ambiente sono scritti in maiuscolo.
   • VARIABLE_VALUE: facoltativo. Il valore della variabile di ambiente passata a ogni attività.

2. Esegui questo comando:

   gcloud batch jobs submit example-environment-variables-job \
     --location us-central1 \
     --config hello-world-environment-variables.json
   

Definire e utilizzare una variabile di ambiente per ogni attività

Per creare un job che trasmette le variabili di ambiente a un'attività in base all'indice dell'attività utilizzando gcloud CLI, utilizza il comando gcloud batch jobs submit e specifica il campo dell'array taskEnvironments nel file di configurazione del job.

Ad esempio, per creare un job che includa un array di 3 variabili di ambiente con nomi corrispondenti e valori diversi e che trasmetta le variabili di ambiente agli script delle attività i cui indici corrispondono agli indici delle variabili di ambiente nell'array:

1. Crea un file JSON nella directory attuale denominato hello-world-task-environment-variables.json con i seguenti contenuti:

   {
       "taskGroups": [
           {
               "taskSpec": {
                   "runnables": [
                       {
                           "script": {
                               "text": "echo Hello ${TASK_VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                           },
                       }
                   ],
                   "computeResource": {
                       "cpuMilli": 2000,
                       "memoryMib": 16
                   }
               },
               "taskCount": 3,
               "taskEnvironments": [
                   {
                       "variables": {
                           "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_0"
                       }
                   },
                   {
                       "variables": {
                           "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_1"
                       }
                   },
                   {
                       "variables": {
                           "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_2"
                       }
                   }
               ]
           }
       ],
       "allocationPolicy": {
           "instances": [
               {
                   "policy": {
                       "machineType": "e2-standard-4"
                   }
               }
           ]
       }
   }
   

   Sostituisci quanto segue:

   • TASK_VARIABLE_NAME: il nome delle variabili di ambiente dell'attività trasmesse alle attività con indici corrispondenti. Per convenzione, i nomi delle variabili di ambiente sono scritti in maiuscolo.
   • TASK_VARIABLE_VALUE_0: il valore della variabile di ambiente passata alla prima attività, per la quale BATCH_TASK_INDEX è uguale a 0.
   • TASK_VARIABLE_VALUE_1: il valore della variabile di ambiente passata alla seconda attività, per la quale BATCH_TASK_INDEX è uguale a 1.
   • TASK_VARIABLE_VALUE_2: il valore della variabile di ambiente passata alla terza attività, per la quale BATCH_TASK_INDEX è uguale a 2.
   Nota: se nel campo dell'array taskEnvironments viene specificata una variabile di ambiente, il valore del campo taskCount deve essere uguale alla lunghezza dell'array taskEnvironments. La lunghezza massima dell'array taskEnvironments è 200.

2. Esegui questo comando:

   gcloud batch jobs submit example-task-environment-variables-job \
     --location us-central1 \
     --config hello-world-task-environment-variables.json
   

API

Se vuoi definire un job che trasmette una variabile di ambiente a un programma eseguibile eseguito da ogni attività, consulta l'esempio su come definire e utilizzare una variabile di ambiente per un programma eseguibile. In caso contrario, se vuoi definire un job che trasmette un elenco di variabili di ambiente a diverse attività in base all'indice dell'attività, consulta l'esempio su come definire e utilizzare una variabile di ambiente per ogni attività.

Definire e utilizzare una variabile di ambiente per un file eseguibile

Per creare un job che trasmette le variabili di ambiente a un file eseguibile utilizzando l'API Batch, utilizza il comando gcloud batch jobs submit e specifica le variabili di ambiente nel campo environment.

Ad esempio, per creare un job che includa una variabile di ambiente e la trasmetta agli script di tre attività, effettua la seguente richiesta:

POST https://batch.googleapis.com/v1/projects/<var>PROJECT_ID</var>/locations/us-central1/jobs?job_id=example-environment-variables-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                        "environment": {
                            "variables": {
                                "VARIABLE_NAME": "VARIABLE_VALUE"
                            }
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "parallelism": 1
        }

    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": "e2-standard-4"
                }
            }
        ]
    }
}

Sostituisci quanto segue:

• PROJECT_ID: il ID progetto del tuo progetto.
• VARIABLE_NAME: il nome della variabile di ambiente passata a ogni attività. Per convenzione, i nomi delle variabili di ambiente sono scritti in maiuscolo.
• VARIABLE_VALUE: il valore della variabile di ambiente passata a ogni attività.

Definire e utilizzare una variabile di ambiente per ogni attività

Per creare un job che trasmette le variabili di ambiente a un'attività in base all'indice dell'attività utilizzando l'API Batch, utilizza il metodo jobs.create e specifica le variabili di ambiente nel campo dell'array taskEnvironments.

Ad esempio, per creare un job che includa un array di tre variabili di ambiente con nomi corrispondenti e valori diversi e che le passi agli script di tre attività in base ai relativi indici, effettua la seguente richiesta:

POST https://batch.googleapis.com/v1/projects/<var>PROJECT_ID</var>/locations/us-central1/jobs?job_id=example-task-environment-variables-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${TASK_VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "taskEnvironments": [
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_0"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_1"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_2"
                    }
                }
            ]
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    }
}

Sostituisci quanto segue:

• PROJECT_ID: il ID progetto del tuo progetto.
• TASK_VARIABLE_NAME: il nome delle variabili di ambiente passate alle attività con indici corrispondenti. Per convenzione, i nomi delle variabili di ambiente sono scritti in maiuscolo.
• TASK_VARIABLE_VALUE_0: il valore della variabile di ambiente passata alla prima attività, per la quale BATCH_TASK_INDEX è uguale a 0.
• TASK_VARIABLE_VALUE_1: il valore della variabile di ambiente passata alla seconda attività, per la quale BATCH_TASK_INDEX è uguale a 1.
• TASK_VARIABLE_VALUE_2: il valore della variabile di ambiente passata alla terza attività, per la quale BATCH_TASK_INDEX è uguale a 2.

Nota: se nel campo dell'array taskEnvironments viene specificata una variabile di ambiente, il valore del campo taskCount deve essere uguale alla lunghezza dell'array taskEnvironments. La lunghezza massima dell'array taskEnvironments è 200.

Passaggi successivi

• Se hai problemi a creare o eseguire un job, consulta la sezione Risoluzione dei problemi.
• Visualizza job e attività.
• Scopri di più sulle opzioni di creazione dei job.