Créer et exécuter une tâche

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Cette page explique comment exécuter une charge de travail de traitement par lot sur Google Cloud en créant une tâche par lot.

Créez une tâche pour spécifier votre charge de travail et ses exigences. Une fois la tâche créée, Google Cloud met automatiquement en file d'attente, programme et exécute la tâche. Le temps nécessaire pour terminer l'exécution d'une tâche varie selon les tâches et à différents moments, en fonction des facteurs liés à la disponibilité des ressources. En règle générale, les tâches sont plus susceptibles de s'exécuter et de se terminer plus tôt si elles sont plus petites et ne nécessitent que quelques ressources courantes. Pour les exemples de tâches décrits sur cette page, qui utilisent peu de ressources, il est possible qu'ils s'exécutent en quelques minutes seulement.

Vous pouvez créer une tâche de différentes manières:

  • Créer une tâche de base décrit les principes de base, y compris la définition des tâches d'une tâche à l'aide d'un script ou d'une image de conteneur.
  • Créer une tâche qui utilise des variables d'environnement décrit comment accéder aux variables d'environnement prédéfinies par lot, ou comment les utiliser, et celles que vous définissez dans les ressources de votre tâche.
  • Facultatif: Créer une tâche à partir d'un modèle d'instance Compute Engine décrit comment spécifier un modèle d'instance pour définir les ressources d'une tâche. Si votre tâche doit utiliser une image de VM spécifique ou un type de machine personnalisé, un modèle d'instance est obligatoire.
  • Facultatif : Créer une tâche qui utilise un compte de service personnalisé décrit comment spécifier le compte de service d'une tâche, ce qui influence les ressources et les applications auxquelles les VM d'une tâche peuvent accéder.
  • Facultatif: Créer une tâche utilisant un MPI pour des tâches étroitement couplées décrit comment configurer une tâche avec des tâches interdépendantes qui communiquent entre elles à travers différentes VM à l'aide d'une bibliothèque MPI (Message Passing Interface). Un cas d'utilisation courant de l'indicateur de charge (MPI) concerne les charges de travail de calcul hautes performances à couplage fort.
  • Facultatif: Créer une tâche utilisant un GPU décrit comment définir une tâche utilisant un processeur graphique. Les cas d'utilisation courants des tâches utilisant des GPU incluent les charges de travail intensives de traitement de données ou de machine learning (ML).
  • Facultatif: Créer une tâche qui utilise des volumes de stockage décrit comment définir une tâche pouvant accéder à un ou plusieurs volumes de stockage externes. Les options de stockage incluent un disque persistant nouveau ou existant, de nouveaux SSD locaux, des buckets Cloud Storage existants et un système de fichiers réseau (NFS, Network File System) existant tel qu'un partage de fichiers Filestore.

Avant de commencer

  • Si vous n'avez jamais utilisé Batch auparavant, consultez la page Premiers pas avec Batch et activez-le en remplissant les conditions préalables pour les projets et les utilisateurs.
  • Pour obtenir les autorisations nécessaires pour créer une tâche, demandez à votre administrateur de vous attribuer les rôles IAM suivants:

    • Éditeur de tâches par lot (roles/batch.jobsEditor)
    • Utilisateur du compte de service (roles/iam.serviceAccountUser) sur le compte de service de la tâche, qui correspond par défaut au compte de service Compute Engine par défaut
    • Créer une tâche à partir d'un modèle d'instance Compute Engine : Compute Viewer (roles/compute.viewer) sur le modèle d'instance
    • Créer une tâche qui utilise un bucket Cloud Storage : lecteur des objets Storage (roles/storage.objectViewer)

    Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Créer une tâche de base

Cette section explique comment créer un exemple de tâche qui exécute un script ou une image de conteneur:

  • Si vous souhaitez utiliser Batch pour écrire des tâches qui utilisent une image de conteneur, consultez la section Créer une tâche de conteneur.
  • Sinon, si vous ne savez pas si vous souhaitez utiliser des images de conteneurs ou si vous ne connaissez pas les conteneurs, il est recommandé de créer une tâche de script.

L'exemple de tâche pour les deux types de tâches contient un groupe de tâches comportant un tableau comportant quatre tâches. Chaque tâche imprime un message et son index dans la sortie standard et dans Cloud Logging. La définition de cette tâche spécifie un parallélisme de 2, ce qui signifie qu'elle doit s'exécuter sur deux VM pour permettre l'exécution simultanée de deux tâches.

Créer une tâche de conteneur de base

Vous pouvez sélectionner ou créer une image de conteneur pour fournir le code et les dépendances nécessaires à l'exécution de votre tâche à partir de n'importe quel environnement de calcul. Pour en savoir plus, consultez les pages Utiliser des images de conteneurs et Exécuter des conteneurs sur des instances de VM.

Vous pouvez créer une tâche de conteneur de base à l'aide de Google Cloud Console, de gcloud CLI, de Batch API, de Go, de Java, de Node.js ou de Python.

Console

Pour créer une tâche de conteneur de base à l'aide de Google Cloud Console, procédez comme suit:

  1. Dans Google Cloud Console, accédez à la page Liste de tâches.

    Accéder à la liste des tâches

  2. Cliquez sur Créer. La page Créer une tâche par lot s'ouvre.

  3. Dans le champ Job name (Nom de la tâche), saisissez un nom de tâche.

    Par exemple, saisissez example-basic-job.

  4. Dans le champ Région, sélectionnez l'emplacement de cette tâche.

    Par exemple, sélectionnez us-central1 (valeur par défaut).

  5. Pour Modèle de provisionnement de VM, sélectionnez une option pour le modèle de provisionnement pour les VM de cette tâche:

    • Si votre tâche peut résister à la préemption et que vous souhaitez obtenir des VM à prix réduit, sélectionnez Spot.
    • Sinon, sélectionnez Standard.

    Par exemple, sélectionnez Standard (par défaut).

  6. Dans le champ Nombre de tâches, saisissez le nombre de tâches pour cette tâche. La valeur doit être un nombre entier compris entre 1 et 10000.

    Par exemple, saisissez 4.

  7. Dans le champ Parallélisme, saisissez le nombre de tâches à exécuter simultanément. Le nombre ne peut pas être supérieur au nombre total de tâches et doit être un nombre entier compris entre 1 et 1000.

    Par exemple, saisissez 2.

  8. Dans le champ Détails de la tâche, sélectionnez URL de l'image du conteneur (valeur par défaut).

  9. Dans le champ URL de l'image du conteneur, saisissez une image de conteneur.

    Par exemple, saisissez la commande suivante pour utiliser l'image de conteneur Docker busybox.

    gcr.io/google-containers/busybox
    
  10. Facultatif: Pour remplacer la commande ENTRYPOINT de l'image de conteneur, saisissez une nouvelle commande dans le champ Entry point (Point d'entrée).

    Par exemple, saisissez la commande suivante:

    /bin/sh
    
  11. Facultatif: Pour remplacer la commande CMD de l'image de conteneur, cochez la case Remplacer la commande CMD de l'image de conteneur, puis saisissez une ou plusieurs commandes dans le champ qui s'affiche en les séparant par une nouvelle ligne.

    Par exemple, cochez la case Ignorer la commande CMD de l'image de conteneur, puis saisissez les commandes suivantes:

    -c
    echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
    
  12. Pour Ressources de la tâche, spécifiez la quantité de ressources de VM nécessaire pour chaque tâche: dans le champ Cœurs, saisissez la quantité de processeurs virtuels et, dans le champ Mémoire, saisissez la quantité de RAM en Go.

    Par exemple, saisissez 1 vCPU (par défaut) et 0,5 Go (par défaut).

  13. Cliquez sur Créer.

La page Liste de tâches affiche la tâche que vous avez créée.

gcloud

Pour créer une tâche de conteneur de base à l'aide de gcloud CLI, procédez comme suit:

  1. Créez un fichier JSON spécifiant les détails de configuration de votre tâche. Par exemple, pour créer une tâche de conteneur de base, créez un fichier JSON avec le contenu suivant. Pour en savoir plus sur tous les champs que vous pouvez spécifier pour une tâche, consultez la documentation de référence de la ressource REST projects.locations.jobs.

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

    Remplacez les éléments suivants :

    • CONTAINER: conteneur que chaque tâche exécute.
    • CORES : facultatif. Quantité de cœurs, en particulier de processeurs virtuels, qui représentent généralement la moitié d'un cœur physique, à allouer pour chaque tâche en milliprocesseurs. Si le champ cpuMilli n'est pas spécifié, la valeur est définie sur 2000 (2 processeurs virtuels).
    • MEMORY : facultatif. Quantité de mémoire à allouer pour chaque tâche, en Mo. Si le champ memoryMib n'est pas spécifié, la valeur est définie sur 2000 (2 Go).
    • MAX_RETRY_COUNT : facultatif. Nombre maximal de tentatives pour une tâche. La valeur doit être un nombre entier compris entre 0 et 10. Si le champ maxRetryCount n'est pas spécifié, la valeur est définie sur 0, ce qui signifie que la tâche n'est pas relancée.
    • MAX_RUN_DURATION : facultatif. Durée maximale d'exécution d'une tâche avant la tentative d'exécution d'une tâche ou l'échec de celle-ci. Cette valeur doit correspondre à une valeur en secondes suivie de s. Si le champ maxRunDuration n'est pas spécifié, la valeur est définie sur 604800s (7 jours), ce qui correspond à la valeur maximale.
    • TASK_COUNT : facultatif. Nombre de tâches pour la tâche. La valeur doit être un nombre entier compris entre 1 et 10000. Si le champ taskCount n'est pas spécifié, la valeur est définie sur 1.
    • PARALLELISM : facultatif. Nombre de tâches que la tâche exécute simultanément. Le nombre ne peut pas être supérieur au nombre de tâches et doit être un nombre entier compris entre 1 et 1000. Si le champ parallelism n'est pas spécifié, la valeur est définie sur 1.
  2. Créez une tâche à l'aide de la commande gcloud batch jobs submit.

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

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.
    • LOCATION: emplacement de la tâche.
    • JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

Par exemple, pour créer une tâche qui exécute des tâches à l'aide de l'image de conteneur Docker busybox :

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-world-container.json avec le contenu suivant:

    {
        "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. Exécutez la commande suivante :

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

API

Pour créer une tâche de conteneur de base à l'aide de l'API Batch, utilisez la méthode jobs.create. Pour en savoir plus sur tous les champs que vous pouvez spécifier pour une tâche, consultez la documentation de référence de la ressource 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
        }
    ]
}

Remplacez les éléments suivants :

  • PROJECT_ID: ID de votre projet
  • LOCATION : emplacement de la tâche.
  • JOB_NAME: nom de la tâche.
  • CONTAINER : conteneur que chaque tâche exécute.
  • CORES : facultatif. Quantité de cœurs, en particulier de processeurs virtuels, qui représentent généralement la moitié d'un cœur physique, à allouer pour chaque tâche en milliprocesseurs. Si le champ cpuMilli n'est pas spécifié, la valeur est définie sur 2000 (2 processeurs virtuels).
  • MEMORY : facultatif. Quantité de mémoire à allouer pour chaque tâche, en Mo. Si le champ memoryMib n'est pas spécifié, la valeur est définie sur 2000 (2 Go).
  • MAX_RETRY_COUNT : facultatif. Nombre maximal de nouvelles tentatives pour une tâche. La valeur doit être un nombre entier compris entre 0 et 10. Si le champ maxRetryCount n'est pas spécifié, la valeur est définie sur 0, ce qui signifie que la tâche n'est pas relancée.
  • MAX_RUN_DURATION : facultatif. Durée maximale autorisée pour l'exécution d'une tâche avant la tentative d'exécution d'une nouvelle tentative ou l'échec d'une nouvelle tentative, sous la forme d'une valeur en secondes suivie de s. Si le champ maxRunDuration n'est pas spécifié, la valeur est définie sur 604800s (7 jours), ce qui correspond à la valeur maximale.
  • TASK_COUNT : facultatif. Nombre de tâches pour la tâche. Doit être un nombre entier compris entre 1 et 10000. Si le champ taskCount n'est pas spécifié, la valeur est définie sur 1.
  • PARALLELISM : facultatif. Nombre de tâches que la tâche exécute simultanément. Le nombre ne peut pas être supérieur au nombre de tâches et doit être un nombre entier compris entre 1 et 1000. Si le champ parallelism n'est pas spécifié, la valeur est définie sur 1.

Par exemple, pour créer une tâche qui exécute des tâches à l'aide de l'image de conteneur Docker busybox, exécutez la requête suivante:

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

PROJECT_ID est l'ID de votre projet.

Go

Go

Pour en savoir plus, consultez la documentation de référence de l'API par lot Go.

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: %v", 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: %v", err)
	}

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

	return nil
}

Java

Java

Pour en savoir plus, consultez la documentation de référence de l'API par lot Java.


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

Pour en savoir plus, consultez la documentation de référence de l'API par lot Node.js.

/**
 * 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 = [
  '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 out 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);
}

callCreateJob();

Python

Python

Pour en savoir plus, consultez la documentation de référence de l'API par lot Python.

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)

Créer une tâche de script de base

Vous pouvez créer une tâche de script de base à l'aide de Google Cloud Console, de gcloud CLI, de Batch API, de Go, de Java, de Node.js ou de Python.

Console

Pour créer une tâche de script de base à l'aide de Google Cloud Console, procédez comme suit:

  1. Dans Google Cloud Console, accédez à la page Liste de tâches.

    Accéder à la liste des tâches

  2. Cliquez sur Créer. La page Créer une tâche par lot s'ouvre.

  3. Dans le champ Job name (Nom de la tâche), saisissez un nom de tâche.

    Par exemple, saisissez example-basic-job.

  4. Dans le champ Région, sélectionnez l'emplacement de cette tâche.

    Par exemple, sélectionnez us-central1 (valeur par défaut).

  5. Pour Modèle de provisionnement de VM, sélectionnez une option pour le modèle de provisionnement pour les VM de cette tâche:

    • Si votre tâche peut résister à la préemption et que vous souhaitez obtenir des VM à prix réduit, sélectionnez Spot.
    • Sinon, sélectionnez Standard.

    Par exemple, sélectionnez Standard (par défaut).

  6. Dans le champ Nombre de tâches, saisissez le nombre de tâches pour cette tâche. La valeur doit être un nombre entier compris entre 1 et 10000.

    Par exemple, saisissez 4.

  7. Dans le champ Parallélisme, saisissez le nombre de tâches à exécuter simultanément. Le nombre ne peut pas être supérieur au nombre total de tâches et doit être un nombre entier compris entre 1 et 1000.

    Par exemple, saisissez 2.

  8. Pour Détails de la tâche, sélectionnez Script.

    Dans le champ qui s'affiche, saisissez un script à exécuter pour chaque tâche.

    Par exemple, utilisez le script suivant:

    echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.
    
  9. Pour Ressources de la tâche, spécifiez la quantité de ressources de VM nécessaire pour chaque tâche: dans le champ Cœurs, saisissez la quantité de processeurs virtuels et, dans le champ Mémoire, saisissez la quantité de RAM en Go.

    Par exemple, saisissez 1 vCPU (par défaut) et 0,5 Go (par défaut).

  10. Cliquez sur Créer.

La page Liste de tâches affiche la tâche que vous avez créée.

gcloud

Pour créer une tâche de script de base à l'aide de gcloud CLI, procédez comme suit:

  1. Créez un fichier JSON spécifiant les détails de configuration de votre tâche. Par exemple, pour créer une tâche de script de base, créez un fichier JSON avec le contenu suivant. Pour en savoir plus sur tous les champs que vous pouvez spécifier pour une tâche, consultez la documentation de référence de la ressource REST projects.locations.jobs.

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

    Remplacez les éléments suivants :

    • SCRIPT : script exécuté pour chaque tâche.
    • CORES : facultatif. Quantité de cœurs, en particulier de processeurs virtuels, qui représentent généralement la moitié d'un cœur physique, à allouer pour chaque tâche en milliprocesseurs. Si le champ cpuMilli n'est pas spécifié, la valeur est définie sur 2000 (2 processeurs virtuels).
    • MEMORY : facultatif. Quantité de mémoire à allouer pour chaque tâche, en Mo. Si le champ memoryMib n'est pas spécifié, la valeur est définie sur 2000 (2 Go).
    • MAX_RETRY_COUNT : facultatif. Nombre maximal de tentatives pour une tâche. La valeur doit être un nombre entier compris entre 0 et 10. Si le champ maxRetryCount n'est pas spécifié, la valeur est définie sur 0, ce qui signifie que la tâche n'est pas relancée.
    • MAX_RUN_DURATION : facultatif. Durée maximale d'exécution d'une tâche avant la tentative d'exécution d'une tâche ou l'échec de celle-ci. Cette valeur doit correspondre à une valeur en secondes suivie de s. Si le champ maxRunDuration n'est pas spécifié, la valeur est définie sur 604800s (7 jours), ce qui correspond à la valeur maximale.
    • TASK_COUNT : facultatif. Nombre de tâches pour la tâche. La valeur doit être un nombre entier compris entre 1 et 10000. Si le champ taskCount n'est pas spécifié, la valeur est définie sur 1.
    • PARALLELISM : facultatif. Nombre de tâches que la tâche exécute simultanément. Le nombre ne peut pas être supérieur au nombre de tâches et doit être un nombre entier compris entre 1 et 1000. Si le champ parallelism n'est pas spécifié, la valeur est définie sur 1.
  2. Créez une tâche à l'aide de la commande gcloud batch jobs submit.

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

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.
    • LOCATION: emplacement de la tâche.
    • JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

Par exemple, pour créer une tâche qui exécute des tâches à l'aide d'un script:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-world-script.json avec le contenu suivant:

    {
        "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. Exécutez la commande suivante :

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

API

Pour créer une tâche de script de base à l'aide de l'API Batch, utilisez la méthode jobs.create. Pour en savoir plus sur tous les champs que vous pouvez spécifier pour une tâche, consultez la documentation de référence de la ressource 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
        }
    ]
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet
  • LOCATION : emplacement de la tâche.
  • JOB_NAME: nom de la tâche.
  • SCRIPT: script exécuté pour chaque tâche.
  • CORES : facultatif. Quantité de cœurs, en particulier de processeurs virtuels, qui représentent généralement la moitié d'un cœur physique, à allouer pour chaque tâche en milliprocesseurs. Si le champ cpuMilli n'est pas spécifié, la valeur est définie sur 2000 (2 processeurs virtuels).
  • MEMORY : facultatif. Quantité de mémoire à allouer pour chaque tâche, en Mo. Si le champ memoryMib n'est pas spécifié, la valeur est définie sur 2000 (2 Go).
  • MAX_RETRY_COUNT : facultatif. Nombre maximal de nouvelles tentatives pour une tâche. La valeur doit être un nombre entier compris entre 0 et 10. Si le champ maxRetryCount n'est pas spécifié, la valeur est définie sur 0, ce qui signifie que la tâche n'est pas relancée.
  • MAX_RUN_DURATION : facultatif. Durée maximale autorisée pour l'exécution d'une tâche avant la tentative d'exécution d'une nouvelle tentative ou l'échec d'une nouvelle tentative, sous la forme d'une valeur en secondes suivie de s. Si le champ maxRunDuration n'est pas spécifié, la valeur est définie sur 604800s (7 jours), ce qui correspond à la valeur maximale.
  • TASK_COUNT : facultatif. Nombre de tâches pour la tâche. La valeur doit être un nombre entier compris entre 1 et 10000. Si le champ taskCount n'est pas spécifié, la valeur est définie sur 1.
  • PARALLELISM : facultatif. Nombre de tâches que la tâche exécute simultanément. Le nombre ne peut pas être supérieur au nombre de tâches et doit être un nombre entier compris entre 1 et 1000. Si le champ parallelism n'est pas spécifié, la valeur est définie sur 1.

Par exemple, pour créer une tâche qui exécute des tâches à l'aide d'un script, utilisez la requête suivante:

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

PROJECT_ID est l'ID de votre projet.

Go

Go

Pour en savoir plus, consultez la documentation de référence de l'API par lot Go.

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: %v", 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: %v", err)
	}

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

	return nil
}

Java

Java

Pour en savoir plus, consultez la documentation de référence de l'API par lot Java.


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

Pour en savoir plus, consultez la documentation de référence de l'API par lot Node.js.

/**
 * 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 out 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);
}

callCreateJob();

Python

Python

Pour en savoir plus, consultez la documentation de référence de l'API par lot Python.

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)

Créer une tâche utilisant des variables d'environnement

Vous pouvez définir des variables d'environnement dans les ressources de votre tâche et les utiliser dans les exécutables de votre tâche.

Par défaut, les exécutables de votre tâche peuvent utiliser les variables d'environnement suivantes:

  • BATCH_TASK_COUNT: nombre de tâches dans un groupe de tâches.
  • BATCH_TASK_INDEX : numéro d'index d'une tâche dans un groupe de tâches. La numérotation de l'index commence à 0.
  • BATCH_HOSTS_FILE : facultatif. Chemin d'accès au fichier répertoriant toutes les instances de VM en cours d'exécution dans un groupe de tâches. Pour utiliser cette variable d'environnement, le champ requireHostsFile est obligatoire et doit être défini sur "true".

Vous pouvez également définir des variables d'environnement personnalisées dans les ressources de votre tâche et les utiliser comme suit:

  • Un exécutable qui exécute chaque tâche.
  • Dans tous les exécutables de cette tâche.

Cette section fournit des exemples montrant comment créer deux tâches définissant des variables d'environnement personnalisées dans leurs ressources. Le premier exemple de tâche transmet une variable d'environnement à un exécutable que chaque tâche exécute. Le deuxième exemple de tâche transmet un tableau de variables d'environnement, avec des noms correspondants, mais des valeurs différentes, aux tâches correspondant aux index de la variable d'environnement du tableau.

Vous pouvez définir des variables d'environnement pour votre tâche à l'aide de la CLI gcloud ou de l'API Batch.

Glocud

Si vous souhaitez définir une tâche qui transmet une variable d'environnement à un exécutable exécuté par chaque tâche, consultez l'exemple de définition et utilisation d'une variable d'environnement pour un environnement exécutable. Sinon, si vous souhaitez définir une tâche qui transmet une liste de variables d'environnement à différentes tâches en fonction de l'index des tâches, consultez l'exemple de définition et utilisation d'une variable d'environnement pour chaque tâche.

Définir et utiliser une variable d'environnement pour un environnement exécutable

Pour créer une tâche qui transmet des variables d'environnement à une exécution à l'aide de gcloud CLI, utilisez la commande gcloud batch jobs submit et spécifiez les variables d'environnement dans le fichier de configuration de la tâche.

Par exemple, pour créer une tâche de script qui définit une variable d'environnement et la transmettre aux scripts de trois tâches, exécutez la requête suivante:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-word-environment-variables.json avec le contenu suivant:

    {
        "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"
                    }
                }
            ]
        }
    }
    

    Remplacez les éléments suivants :

    • VARIABLE_NAME: nom de la variable d'environnement transmise à chaque tâche. Par convention, les noms de variables d'environnement sont en majuscules.
    • VARIABLE_VALUE : facultatif. Valeur de la variable d'environnement transmise à chaque tâche.
  2. Exécutez la commande suivante :

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

Définir et utiliser une variable d'environnement pour chaque tâche

Pour créer une tâche qui transmet des variables d'environnement à une tâche en fonction de l'index de la tâche à l'aide de gcloud CLI, utilisez la commande gcloud batch jobs submit et spécifiez le champ de tableau taskEnvironments dans le fichier de configuration de la tâche.

Par exemple, pour créer une tâche comprenant un tableau de trois variables d'environnement avec des noms correspondants et des valeurs différentes, et qui transmet les variables d'environnement aux scripts des tâches dont les index correspondent aux index des variables d'environnement du tableau:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-word-task-environment-variables.json avec le contenu suivant:

    {
        "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"
                    }
                }
            ]
        }
    }
    

    Remplacez les éléments suivants :

    • TASK_VARIABLE_NAME : nom des variables d'environnement transmises aux tâches avec des index correspondants. Par convention, les noms de variables d'environnement sont en majuscules.
    • TASK_VARIABLE_VALUE_0: valeur de la variable d'environnement transmise à la tâche et BATCH_TASK_INDEX égale à 0.
    • TASK_VARIABLE_VALUE_1: valeur de la variable d'environnement transmise à la tâche et BATCH_TASK_INDEX égale à 1.
    • TASK_VARIABLE_VALUE_2 : valeur de la variable d'environnement transmise à la tâche et BATCH_TASK_INDEX égale à 2.
  2. Exécutez la commande suivante :

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

API

Si vous souhaitez définir une tâche qui transmet une variable d'environnement à un exécutable exécuté par chaque tâche, consultez l'exemple de définition et utilisation d'une variable d'environnement pour un environnement exécutable. Sinon, si vous souhaitez définir une tâche qui transmet une liste de variables d'environnement à différentes tâches en fonction de l'index des tâches, consultez l'exemple de définition et utilisation d'une variable d'environnement pour chaque tâche.

Définir et utiliser une variable d'environnement pour un environnement exécutable

Pour créer une tâche qui transmet des variables d'environnement à une exécution exécutable à l'aide de l'API Batch, exécutez la commande gcloud batch jobs submit et spécifiez les variables d'environnement dans le champ environment.

Par exemple, pour créer une tâche qui inclut une variable d'environnement et la transmet aux scripts de trois tâches, exécutez la requête suivante:

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"
                }
            }
        ]
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet
  • VARIABLE_NAME : nom de la variable d'environnement transmise à chaque tâche. Par convention, les noms des variables d'environnement sont en majuscules.
  • VARIABLE_VALUE: valeur de la variable d'environnement transmise à chaque tâche.

Définir et utiliser une variable d'environnement pour chaque tâche

Pour créer une tâche qui transmet des variables d'environnement à une tâche en fonction d'un index de tâches à l'aide de l'API Batch, utilisez la méthode jobs.create et spécifiez les variables d'environnement dans le champ du tableau taskEnvironments.

Par exemple, pour créer une tâche comprenant un tableau de trois variables d'environnement avec des noms correspondants et des valeurs différentes, et qui transmet les variables d'environnement aux scripts de trois tâches en fonction de leurs index, exécutez la requête suivante:

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" }
            }
        ]
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: ID de votre projet
  • TASK_VARIABLE_NAME : nom des variables d'environnement transmises aux tâches avec des index correspondants. Par convention, les noms de variables d'environnement sont en majuscules.
  • TASK_VARIABLE_VALUE_0 : valeur de la variable d'environnement transmise à la tâche, où BATCH_TASK_INDEX est égal à 0.
  • TASK_VARIABLE_VALUE_1: valeur de la variable d'environnement transmise à la tâche, où BATCH_TASK_INDEX est égal à 1.
  • TASK_VARIABLE_VALUE_2 : valeur de la variable d'environnement transmise à la tâche, où BATCH_TASK_INDEX est égal à 2.

Créer une tâche à partir d'un modèle d'instance Compute Engine

Vous pouvez éventuellement utiliser un modèle d'instance Compute Engine pour définir les ressources de votre tâche. Cela est nécessaire pour créer une tâche qui utilise des images de VM par défaut ou pour créer une tâche avec un type de machine personnalisé.

Cette section fournit des exemples illustrant comment créer une tâche de script de base à partir d'un modèle d'instance existant. Vous pouvez créer une tâche à partir d'un modèle d'instance à l'aide de gcloud CLI ou de Batch API.

gcloud

Pour créer une tâche à partir d'un modèle d'instance à l'aide de gcloud CLI, exécutez la commande gcloud batch jobs submit et spécifiez le modèle d'instance dans le fichier de configuration JSON de la tâche.

Par exemple, pour créer une tâche de script de base à partir d'un modèle d'instance:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-world-instance-template.json avec le contenu suivant:

    {
        "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": [
                {
                    "installGpuDrivers" INSTALL_GPU_DRIVERS,
                    "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
                }
            ]
        },
        "labels": {
            "department": "finance",
            "env": "testing"
        },
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS : facultatif. Lorsque ce paramètre est défini sur true, Batch récupère et installe les pilotes de GPU requis pour cette tâche.
    • INSTALL_GPU_DRIVERS : facultatif. Lorsque ce paramètre est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans votre modèle d'instance Compute Engine, et il les installe en votre nom. Pour en savoir plus, découvrez comment créer une tâche utilisant un GPU.
    • INSTANCE_TEMPLATE_NAME: nom d'un modèle d'instance Compute Engine existant. Découvrez comment créer et répertorier les modèles d'instances.
  2. Exécutez la commande suivante :

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

API

Pour créer une tâche de base à l'aide de l'API Batch, utilisez la méthode jobs.create et spécifiez un modèle d'instance dans le champ allocationPolicy.

Par exemple, pour créer des tâches de script de base à partir d'un modèle d'instance, utilisez la requête suivante:

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": [
            {
                "installGpuDrivers" INSTALL_GPU_DRIVERS,
                "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: ID de votre projet
  • INSTALL_GPU_DRIVERS : facultatif. Lorsque ce paramètre est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans votre modèle d'instance Compute Engine, et il les installe en votre nom. Pour en savoir plus, découvrez comment créer une tâche utilisant un GPU.
  • INSTANCE_TEMPLATE_NAME : nom d'un modèle d'instance Compute Engine existant. Découvrez comment créer et répertorier les modèles d'instances.

Créer une tâche utilisant un compte de service personnalisé

Vous pouvez éventuellement créer une tâche qui utilise un compte de service personnalisé au lieu du compte de service Compute Engine par défaut. Le compte de service d'une tâche influence les ressources et les applications auxquelles les VM peuvent accéder. Le compte de service Compute Engine par défaut est automatiquement associé à toutes les VM. Par conséquent, l'utilisation d'un compte de service personnalisé offre un plus grand contrôle sur la gestion des autorisations d'une tâche et constitue une bonne pratique recommandée pour limiter les droits.

Avant de créer une tâche utilisant un compte de service personnalisé, assurez-vous que le compte de service que vous prévoyez d'utiliser dispose des autorisations nécessaires pour créer des tâches par lot pour votre projet. Pour en savoir plus, consultez Activer Batch pour un projet.

Pour créer une tâche utilisant un compte de service personnalisé, sélectionnez l'une des méthodes suivantes:

  • Spécifiez le compte de service personnalisé dans la définition de votre tâche, comme indiqué dans cette section.
  • Utilisez un modèle d'instance Compute Engine et spécifiez le compte de service personnalisé à la fois dans le modèle d'instance et dans la définition de votre tâche.

Cette section fournit un exemple de création d'une tâche utilisant un compte de service personnalisé. Vous pouvez créer une tâche utilisant un compte de service personnalisé à l'aide de gcloud CLI ou de Batch API.

gcloud

Pour créer une tâche utilisant un compte de service personnalisé à l'aide de gcloud CLI, exécutez la commande gcloud batch jobs submit et spécifiez le compte de service personnalisé dans le fichier de configuration de la tâche.

Par exemple, pour créer une tâche de script qui utilise un compte de service personnalisé:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-world-service-account.json avec le contenu suivant:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello World! This is task $BATCH_TASK_INDEX."
                            }
                        }
                    ]
                }
            }
        ],
        "allocationPolicy": {
            "serviceAccount": {
                "email": "SERVICE_ACCOUNT_EMAIL"
            }
        }
    }
    

    SERVICE_ACCOUNT_EMAIL est l'adresse e-mail de votre compte de service. Si le champ serviceAccount n'est pas spécifié, la valeur est définie sur le compte de service Compute Engine par défaut.

  2. Exécutez la commande suivante :

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

API

Pour créer une tâche utilisant un compte de service personnalisé à l'aide de l'API Batch, utilisez la méthode jobs.create et spécifiez votre compte de service personnalisé dans le champ allocationPolicy.

Par exemple, pour créer une tâche de script utilisant un compte de service personnalisé, exécutez la requête suivante:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello World! This is task $BATCH_TASK_INDEX."
                        }
                    }
                ]
            }
        }
    ],
    "allocationPolicy": {
        "serviceAccount": {
            "email": "SERVICE_ACCOUNT_EMAIL"
        }
    }
}

Remplacez les éléments suivants :

Créer une tâche utilisant un MPI pour des tâches étroitement couplées

Vous pouvez également créer une tâche utilisant une bibliothèque MPI (Message Passing Interface) pour permettre aux tâches interdépendantes de communiquer entre elles via différentes instances de VM.

Cette section fournit des exemples de création d'une tâche pouvant utiliser une MPI. Par exemple, les tâches d'exemple comportent trois exécutables:

  • La première solution exécutable est un script qui prépare la tâche pour la MPI en désactivant le multithreading simultané et en installant la MPI Intel.
  • Le second exécutable est un barrière exécutable vide (au format { "barrier": {} }), qui garantit que toutes les tâches terminent de configurer une MPI avant de continuer à exécutable par la suite.
  • Le troisième exécutable (et tous les exécutables suivants) est disponible pour la charge de travail de la tâche.

Vous pouvez créer une tâche utilisant la MPI pour les tâches étroitement couplées à l'aide de la CLI gcloud ou de l'API Batch.

gcloud

Pour créer une tâche de script utilisant une MPI pour des tâches étroitement couplées à l'aide de gcloud CLI, procédez comme suit:

  1. Créez un fichier de configuration JSON avec le contenu suivant:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                            }
                        },
                        { "barrier": {} },
                        {
                            "script": {
                                SCRIPT
                            }
                        }
                    ]
                },
                "taskCount": TASK_COUNT,
                "taskCountPerNode": TASK_COUNT_PER_NODE,
                "requireHostsFile": REQUIRE_HOSTS_FILE,
                "permissiveSsh": PERMISSIVE_SSH
            }
        ]
    }
    

    Remplacez les éléments suivants :

    • SCRIPT : script exécutable pour une charge de travail qui utilise un MPI.
    • TASK_COUNT : nombre de tâches pour la tâche. La valeur doit être un nombre entier compris entre 1 et 10000. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ est obligatoire et doit être défini sur 2 ou plus.
    • TASK_COUNT_PER_NODE : nombre de tâches qu'une tâche peut exécuter simultanément sur une instance de VM. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ est obligatoire et doit être défini sur 1, ce qui équivaut à exécuter une instance de VM par tâche.
    • REQUIRE_HOSTS_FILE : si ce champ est défini sur true, la tâche crée un fichier répertoriant les instances de VM s'exécutant dans un groupe de tâches. Le chemin d'accès au fichier est stocké dans la variable d'environnement BATCH_HOSTS_FILE. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ doit être défini sur "true".
    • PERMISSIVE_SSH: lorsqu'il est défini sur true, Batch configure SSH pour autoriser la communication sans mot de passe entre les instances de VM s'exécutant dans un groupe de tâches. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ doit être défini sur "true".
  2. Pour créer la tâche, utilisez la commande gcloud batch jobs submit.

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

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.
    • LOCATION : emplacement de la tâche.
    • JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

Vous pouvez éventuellement augmenter les performances des bibliothèques MPI fournies par Batch en procédant comme suit:

Par exemple, pour créer une tâche de script à partir d'un modèle d'instance qui utilise un MPI et dont une sortie génère le nom d'hôte des trois tâches du groupe de tâches:

  1. Dans le répertoire actuel, créez un fichier JSON nommé example-job-uses-mpi.json avec le contenu suivant:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                            }
                        },
                        { "barrier": {} },
                        {
                            "script": {
                                "text":
                                    "if [ $BATCH_TASK_INDEX = 0 ]; then
                                    mpirun -hostfile $BATCH_HOSTS_FILE -np 3 hostname;
                                    fi"
                            }
                        },
                        { "barrier": {} }
                    ]
                },
                "taskCount": 3,
                "taskCountPerNode": 1,
                "requireHostsFile": true,
                "permissiveSsh": true
            }
        ],
        "allocationPolicy": {
            "instances": [
                {
                    "instanceTemplate": "example-template-job-uses-mpi"
                }
            ]
        },
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    
  2. Exécutez la commande suivante :

    gcloud batch jobs submit example-template-job-uses-mpi \
      --location us-central1 \
      --config example-job-uses-mpi.json
    

API

Pour créer une tâche de script qui utilise un MPI pour des tâches étroitement couplées à l'aide de l'API Batch, exécutez la commande gcloud batch jobs submit et spécifiez les champs permissiveSsh, requireHostsFile, taskCount et taskCountPerNode.

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                        }
                    },
                    { "barrier": {} },
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ]
            },
            "taskCount": TASK_COUNT,
            "taskCountPerNode": TASK_COUNT_PER_NODE,
            "requireHostsFile": REQUIRE_HOSTS_FILE,
            "permissiveSsh": PERMISSIVE_SSH
        }
    ]
}

Remplacez les éléments suivants :

  • PROJECT_ID: ID de votre projet
  • LOCATION : emplacement de la tâche.
  • JOB_NAME: nom de la tâche.
  • SCRIPT : le script exécutable pour une charge de travail qui utilise un MPI.
  • TASK_COUNT: nombre de tâches pour la tâche. La valeur doit être un nombre entier compris entre 1 et 10000. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ est obligatoire et doit être défini sur 2 ou plus.
  • TASK_COUNT_PER_NODE : nombre de tâches qu'une tâche peut exécuter simultanément sur une instance de VM. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ est obligatoire et doit être défini sur 1, ce qui équivaut à exécuter une instance de VM par tâche.
  • REQUIRE_HOSTS_FILE: lorsque ce paramètre est défini sur true, la tâche crée un fichier répertoriant les instances de VM s'exécutant dans un groupe de tâches. Le chemin d'accès au fichier est stocké dans la variable d'environnement BATCH_HOSTS_FILE. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ doit être défini sur "true".
  • PERMISSIVE_SSH : lorsqu'il est défini sur true, Batch configure SSH pour les communications sans mot de passe entre les instances de VM s'exécutant dans un groupe de tâches. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ doit être défini sur "true".

Vous pouvez éventuellement augmenter les performances des bibliothèques MPI fournies par Batch en procédant comme suit:

Par exemple, pour créer une tâche de script à partir d'un modèle d'instance utilisant un fichier MPI et faisant en sorte qu'une tâche génère le nom d'hôte des trois tâches du groupe de tâches, utilisez la requête suivante:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                        }
                    },
                    { "barrier": {} },
                    {
                        "script": {
                            "text":
                                "if [ $BATCH_TASK_INDEX = 0 ]; then
                                mpirun -hostfile $BATCH_HOSTS_FILE -np 3 hostname;
                                fi"
                        }
                    },
                    { "barrier": {} }
                ]
            },
            "taskCount": 3,
            "taskCountPerNode": 1,
            "requireHostsFile": true,
            "permissiveSsh": true
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "instanceTemplate": "example-template-job-uses-mpi"
            }
        ]
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

PROJECT_ID est l'ID de votre projet.

Pour obtenir un exemple plus détaillé d'une tâche utilisant un MPI pour des tâches étroitement couplées, consultez la page Exécuter le modèle de recherche et de prévision météorologiques avec Batch.

Créer une tâche utilisant un GPU

Vous pouvez également créer une tâche qui ajoute une unité de traitement graphique (GPU) aux instances de VM exécutées dans le groupe de tâches de votre tâche.

Pour installer les pilotes de GPU requis pour votre tâche, sélectionnez l'une des méthodes suivantes:

Pour ajouter un GPU aux ressources de votre tâche, sélectionnez l'une des méthodes suivantes:

  • Définissez le type de machine et la plate-forme GPU dans la définition de votre tâche, comme indiqué dans cette section.
  • Définissez le GPU dans votre modèle d'instance Compute Engine. Si vous incluez un modèle d'instance dans la définition de votre tâche, vous devez utiliser cette méthode.

Cette section fournit des exemples montrant comment créer une tâche qui définit un GPU dans les ressources de la tâche et installer les pilotes requis pour le GPU. Plus précisément, le premier exemple montre comment ajouter un GPU à une tâche de conteneur qui utilise l'image par défaut. Le deuxième exemple montre comment ajouter un GPU à une tâche de script qui utilise l'image par défaut. Le troisième exemple montre comment ajouter un GPU à une tâche de conteneur et de script qui utilise l'image par défaut.

Vous pouvez créer une tâche utilisant un GPU à l'aide de gcloud CLI ou de l'API Batch.

gcloud

Si vous souhaitez ajouter un GPU à une tâche, consultez les exemples suivants:

Ajouter un GPU à une tâche de conteneur

Pour créer une tâche de conteneur avec un GPU utilisant l'image par défaut à l'aide de gcloud CLI, exécutez la commande gcloud batch jobs submit en spécifiant les éléments suivants dans le fichier de configuration de la tâche:

  • Le type de machine et la plate-forme GPU
  • Les champs volumes et options pour installer le GPU sur une tâche de conteneur avec l'image par défaut, comme illustré dans cet exemple.

Par exemple, pour créer une tâche de conteneur avec un GPU:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-world-container-job-gpu.json avec le contenu suivant:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "container": {
                                "volumes": [
                                    "/var/lib/nvidia/lib64:/usr/local/nvidia/lib64",
                                    "/var/lib/nvidia/bin:/usr/local/nvidia/bin"
                                ],
                                "options": "--privileged",
                                "commands": [
                                    "-c",
                                    "echo Hello world from task ${BATCH_TASK_INDEX}."
                                ]
                            }
                        }
                    ],
                },
                "taskCount": 3,
                "parallelism": 1
            }
        ],
        "allocationPolicy": {
            "instances": [
                {
                    "installGpuDrivers": INSTALL_GPU_DRIVERS,
                    "policy": {
                        "machineType": "MACHINE_TYPE",
                        "accelerators": [
                            {
                                "type": "GPU_TYPE",
                                "count": GPU_COUNT
                            }
                        ]
                    }
                }
            ],
            "location": {
                "allowedLocations": [
                    "ALLOWED_LOCATIONS"
                ]
            }
        }
    }
    

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS : facultatif. Lorsqu'elle est définie sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom.
    • MACHINE_TYPE: type de machine pour les VM de votre tâche, ce qui limite le type de GPU que vous pouvez utiliser. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • GPU_TYPE : le type GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • GPU_COUNT: nombre de GPU du type spécifié dans le champ type. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • ALLOWED_LOCATIONS : facultatif. Les emplacements où les instances de VM pour votre tâche sont autorisées à s'exécuter (par exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a). Si vous spécifiez un emplacement autorisé, vous devez sélectionner la région et, éventuellement, une ou plusieurs zones. Les emplacements que vous choisissez doivent disposer du type de GPU que vous souhaitez pour cette tâche. Pour en savoir plus, consultez le champ de tableau allowedLocations.
  2. Exécutez la commande suivante :

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

Ajouter un GPU à une tâche de script

Pour créer une tâche de script avec un GPU qui utilise l'image par défaut à l'aide de gcloud CLI, utilisez la commande gcloud batch jobs submit, et spécifiez le type de machine et la plate-forme GPU dans le fichier de configuration de la tâche.

Par exemple, pour créer une tâche de script avec un GPU:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-world-script-job-gpu.json avec le contenu suivant:

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

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS : facultatif. Lorsqu'elle est définie sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom.
    • MACHINE_TYPE : type de machine pour les VM de votre tâche, ce qui limite le type de GPU que vous pouvez utiliser. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • GPU_TYPE : le type GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • GPU_COUNT : nombre de GPU du type spécifié dans le champ type. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • ALLOWED_LOCATIONS : facultatif. Les emplacements où les instances de VM pour votre tâche sont autorisées à s'exécuter (par exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a). Si vous spécifiez un emplacement autorisé, vous devez sélectionner la région et, éventuellement, une ou plusieurs zones. Les emplacements que vous choisissez doivent disposer du type de GPU que vous souhaitez pour cette tâche. Pour en savoir plus, consultez le champ de tableau allowedLocations.
  2. Exécutez la commande suivante :

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

Ajouter un GPU à une tâche de conteneur et de script

Pour créer une tâche de conteneur et de script avec un GPU qui utilise l'image par défaut à l'aide de la CLI gcloud, exécutez la commande gcloud batch jobs submit et spécifiez les éléments suivants dans le fichier de configuration de la tâche:

  • Le type de machine et la plate-forme GPU
  • Le champ text de chaque script exécutable, ainsi que les champs imageUri et options de chaque conteneur exécutable, afin d'installer le GPU sur une tâche de conteneur et de script avec l'image par défaut, comme illustré dans cet exemple.

Par exemple, pour créer une tâche de conteneur et de script avec un GPU:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-world-container-script-job-gpu.json avec le contenu suivant:

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text":
                                    "distribution=$(. /etc/os-release;echo $ID$VERSION_ID);
                                    curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -;
                                    curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list;
                                    sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit;
                                    sudo systemctl restart docker"
                            }
                        },
                        {
                            "container": {
                                "imageUri": "gcr.io/google_containers/cuda-vector-add:v0.1",
                                "options": "--gpus all"
                            }
                        },
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                            }
                        }
                    ]
                },
                "taskCount": 3,
                "parallelism": 1
            }
        ],
        "allocationPolicy": {
            "instances": [
                {
                    "installGpuDrivers": INSTALL_GPU_DRIVERS,
                    "policy": {
                        "machineType": "MACHINE_TYPE",
                        "accelerators": [
                            {
                                "type": "GPU_TYPE",
                                "count": GPU_COUNT
                            }
                        ]
                    }
                }
            ],
            "location": {
                "allowedLocations": [
                    "ALLOWED_LOCATIONS"
                ]
            }
        }
    }
    

    Remplacez les éléments suivants :

    • INSTALL_GPU_DRIVERS : facultatif. Lorsqu'elle est définie sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom.
    • MACHINE_TYPE : type de machine pour les VM de votre tâche, ce qui limite le type de GPU que vous pouvez utiliser. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • GPU_TYPE: le type GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • GPU_COUNT: nombre de GPU du type spécifié dans le champ type. Ce champ est obligatoire pour créer une tâche avec un GPU.
    • ALLOWED_LOCATIONS : facultatif. Les emplacements où les instances de VM pour votre tâche sont autorisées à s'exécuter (par exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a). Si vous spécifiez un emplacement autorisé, vous devez sélectionner la région et, éventuellement, une ou plusieurs zones. Les emplacements que vous choisissez doivent disposer du type de GPU que vous souhaitez pour cette tâche. Pour en savoir plus, consultez le champ de tableau allowedLocations.
  2. Exécutez la commande suivante :

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

API

Si vous souhaitez ajouter un GPU à une tâche, consultez les exemples suivants:

Ajouter un GPU à une tâche de conteneur

Pour créer une tâche de conteneur avec un GPU qui utilise l'image par défaut à l'aide de l'API Batch, utilisez la méthode jobs.create et spécifiez les éléments suivants:

  • Le type de machine et la plate-forme GPU
  • Les champs volumes et options pour installer le GPU sur une tâche de conteneur avec l'image par défaut, comme illustré dans cet exemple.

Par exemple, pour créer une tâche de conteneur avec un GPU, exécutez la requête suivante:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            "volumes": [
                                "/var/lib/nvidia/lib64:/usr/local/nvidia/lib64",
                                "/var/lib/nvidia/bin:/usr/local/nvidia/bin"
                            ],
                            "options": "--privileged",
                            "commands": [
                                "-c",
                                "echo Hello world from task ${BATCH_TASK_INDEX}."
                            ]
                        }
                    }
                ],
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet
  • INSTALL_GPU_DRIVERS : facultatif. Lorsque ce paramètre est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom.
  • MACHINE_TYPE: type de machine pour les VM de votre tâche, ce qui limite le type de GPU que vous pouvez utiliser. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • GPU_TYPE : le type GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • GPU_COUNT : nombre de GPU du type que vous avez spécifié dans le champ type. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • ALLOWED_LOCATIONS : facultatif. Emplacements où les instances de VM de votre tâche sont autorisées à s'exécuter (par exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a). Si vous spécifiez un emplacement autorisé, vous devez sélectionner la région et, éventuellement, une ou plusieurs zones. Les emplacements que vous choisissez doivent disposer du type de GPU que vous souhaitez pour cette tâche. Pour en savoir plus, consultez le champ de tableau allowedLocations.

Ajouter un GPU à une tâche de script

Pour créer une tâche de script avec un GPU qui utilise l'image par défaut à l'aide de l'API Batch, utilisez la méthode jobs.create, et spécifiez les types de machine et d'accélérateur dans le champ instances.

Par exemple, pour créer une tâche de script avec un GPU, exécutez la requête suivante:

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

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

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet
  • INSTALL_GPU_DRIVERS : facultatif. Lorsque ce paramètre est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom.
  • MACHINE_TYPE: type de machine pour les VM de votre tâche, ce qui limite le type de GPU que vous pouvez utiliser. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • GPU_TYPE : le type GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • GPU_COUNT : nombre de GPU du type que vous avez spécifié dans le champ type. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • ALLOWED_LOCATIONS : facultatif. Emplacements où les instances de VM de votre tâche sont autorisées à s'exécuter (par exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a). Si vous spécifiez un emplacement autorisé, vous devez sélectionner la région et, éventuellement, une ou plusieurs zones. Les emplacements que vous choisissez doivent disposer du type de GPU que vous souhaitez pour cette tâche. Pour en savoir plus, consultez le champ de tableau allowedLocations.

Ajouter un GPU à une tâche de conteneur et de script

Pour créer une tâche de conteneur et de script avec un GPU qui utilise l'image par défaut à l'aide de l'API Batch, utilisez la méthode jobs.create et spécifiez les éléments suivants:

  • Le type de machine et la plate-forme GPU
  • Le champ text de chaque script exécutable, ainsi que les champs imageUri et options de chaque conteneur exécutable, afin d'installer le GPU sur une tâche de conteneur et de script avec l'image par défaut, comme illustré dans cet exemple.

Par exemple, pour créer une tâche de conteneur et de script avec un GPU, exécutez la requête suivante:

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text":
                                "distribution=$(. /etc/os-release;echo $ID$VERSION_ID);
                                curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -;
                                curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list;
                                sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit;
                                sudo systemctl restart docker"
                        }
                    },
                    {
                        "container": {
                            "imageUri": "gcr.io/google_containers/cuda-vector-add:v0.1",
                            "options": "--gpus all"
                        }
                    },
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet
  • INSTALL_GPU_DRIVERS : facultatif. Lorsque ce paramètre est défini sur true, Batch récupère les pilotes requis pour le type de GPU que vous spécifiez dans le champ policy à partir d'un emplacement tiers, et Batch les installe en votre nom.
  • MACHINE_TYPE: type de machine pour les VM de votre tâche, ce qui limite le type de GPU que vous pouvez utiliser. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • GPU_TYPE: le type GPU. Vous pouvez afficher la liste des types de GPU disponibles à l'aide de la commande gcloud compute accelerator-types list. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • GPU_COUNT: nombre de GPU du type que vous avez spécifié dans le champ type. Ce champ est obligatoire pour créer une tâche avec un GPU.
  • ALLOWED_LOCATIONS : facultatif. Emplacements où les instances de VM de votre tâche sont autorisées à s'exécuter (par exemple, regions/us-central1, zones/us-central1-a autorise la zone us-central1-a). Si vous spécifiez un emplacement autorisé, vous devez sélectionner la région et, éventuellement, une ou plusieurs zones. Les emplacements que vous choisissez doivent disposer du type de GPU que vous souhaitez pour cette tâche. Pour en savoir plus, consultez le champ de tableau allowedLocations.

Créer une tâche utilisant des volumes de stockage

Par défaut, chaque VM Compute Engine pour une tâche dispose d'un seul disque persistant de démarrage contenant le système d'exploitation. Vous pouvez éventuellement créer une tâche qui utilise des volumes de stockage supplémentaires. Plus précisément, les VM d'une tâche peuvent utiliser un ou plusieurs des types de volumes de stockage suivants. Pour en savoir plus sur tous les types de volumes de stockage, ainsi que sur les différences et les restrictions applicables à chacun, consultez la documentation sur les options de stockage des VM Compute Engine.

Vous pouvez autoriser une tâche à utiliser chaque volume de stockage en l'incluant dans la définition de votre tâche et en spécifiant son chemin d'installation (mountPath) dans vos exécutables. Pour savoir comment créer une tâche utilisant des volumes de stockage, consultez une ou plusieurs des sections suivantes:

Utiliser un disque persistant

Une tâche qui utilise des disques persistants présente les restrictions suivantes:

  • Tous les disques persistants : consultez les restrictions applicables à tous les disques persistants.
  • Modèles d'instance : si vous souhaitez spécifier un modèle d'instance lors de la création de cette tâche, vous devez y associer tous les disques persistants de cette tâche. Sinon, si vous ne souhaitez pas utiliser de modèle d'instance, vous devez associer un ou plusieurs disques persistants directement dans la définition de la tâche.
  • Disques persistants nouveaux ou existants : chaque disque persistant d'une tâche peut être soit nouveau (défini dans et créé avec la tâche), soit existant (déjà créé dans votre projet et spécifié dans la tâche). Les options d'installation compatibles avec la manière dont Batch installe les disques persistants sur les VM de la tâche, ainsi que les options d'emplacement compatibles avec votre tâche et ses disques persistants, varient entre les disques persistants nouveaux et existants, comme décrit dans le tableau suivant:

    Nouveaux disques persistants Disques persistants existants
    Options d'installation Toutes les options sont acceptées. Toutes les options, à l'exception de l'écriture, sont compatibles. Cela est dû aux restrictions du mode multi-rédacteur.
    Options d'emplacement

    Vous ne pouvez créer que des disques persistants zonaux.

    Vous pouvez sélectionner n'importe quel lieu pour votre tâche. Les disques persistants sont créés dans la zone dans laquelle votre projet s'exécute.

    Vous pouvez sélectionner des disques persistants zonaux et régionaux.

    Vous devez définir le lieu de la tâche (ou, si spécifié, uniquement les emplacements autorisés de la tâche) sur uniquement les emplacements contenant tous les disques persistants de la tâche. Par exemple, pour un disque persistant zonal, l'emplacement de la tâche doit correspondre à la zone du disque. Dans le cas d'un disque persistant régional, l'emplacement de la tâche doit correspondre à la région du disque ou, si vous spécifiez des zones, à l'une des zones spécifiques où se trouve le disque persistant régional, ou aux deux.

Vous pouvez créer une tâche qui utilise un disque persistant à l'aide de la CLI gcloud ou de l'API Batch. L'exemple suivant explique comment créer une tâche qui associe et installe un disque persistant existant, ainsi qu'un nouveau disque persistant. La tâche comporte également trois tâches qui exécutent chacune un script permettant de créer un fichier sur le nouveau disque persistant nommé output_task_TASK_INDEX.txt, où TASK_INDEX est l'index de chaque tâche : 0, 1 et 2.

gcloud

Pour créer une tâche qui utilise des disques persistants à l'aide de la CLI gcloud, utilisez la commande gcloud batch jobs submit. Dans le fichier de configuration JSON de la tâche, spécifiez les disques persistants dans le champ instances, puis installez le disque persistant dans le champ volumes.

  1. Créez un fichier JSON.

    • Si vous n'utilisez pas de modèle d'instance pour cette tâche, créez un fichier JSON avec le contenu suivant:

      {
          "allocationPolicy": {
              "instances": [
                  {
                      "policy": {
                          "disks": [
                              {
                                  "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                                  "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                              },
                              {
                                  "newDisk": {
                                      "sizeGb":NEW_PERSISTENT_DISK_SIZE,
                                      "type": "NEW_PERSISTENT_DISK_TYPE"
                                  },
                                  "deviceName": "NEW_PERSISTENT_DISK_NAME"
                              }
                          ]
                      }
                  }
              ],
              "location": {
                  "allowedLocations": [
                      "EXISTING_PERSISTENT_DISK_LOCATION"
                  ]
              }
          },
          "taskGroups":[
              {
                  "taskSpec":{
                      "runnables": [
                          {
                              "script": {
                                  "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                              }
                          }
                      ],
                      "volumes": [
                          {
                              "deviceName": "NEW_PERSISTENT_DISK_NAME",
                              "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                              "mountOptions": "rw,async"
                          },
                          {
      
                              "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                              "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                          }
                      ]
                  },
                  "taskCount":3
              }
          ],
          "logsPolicy": {
              "destination": "CLOUD_LOGGING"
          }
      }
      

      Remplacez les éléments suivants :

      • PROJECT_ID: ID de votre projet
      • EXISTING_PERSISTENT_DISK_NAME: nom d'un disque persistant existant.
      • EXISTING_PERSISTENT_DISK_LOCATION: emplacement d'un disque persistant existant. Pour chaque disque persistant zonal existant, l'emplacement de la tâche doit correspondre à la zone du disque. Pour chaque disque persistant régional existant, l'emplacement de la tâche doit correspondre à la région du disque ou, si vous spécifiez des zones, à l'une des zones spécifiques où se trouve le disque persistant régional, ou aux deux. Si vous ne spécifiez aucun disque persistant existant, vous pouvez sélectionner n'importe quel emplacement. En savoir plus sur le champ allowedLocations
      • NEW_PERSISTENT_DISK_SIZE: taille du nouveau disque persistant en Go. Les tailles autorisées dépendent du type de disque persistant, mais le minimum est souvent de 10 Go (10) et le maximum de 64 To (64000).
      • NEW_PERSISTENT_DISK_TYPE: le type de disque du nouveau disque persistant (pd-standard, pd-balanced, pd-ssd ou pd-extreme).
      • NEW_PERSISTENT_DISK_NAME: nom du nouveau disque persistant.
    • Si vous utilisez un modèle d'instance pour cette tâche, créez un fichier JSON comme indiqué précédemment, mais remplacez le champ instances par le code suivant:

      "instances": [
          {
              "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
          }
      ],
      

      INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour cette tâche. Pour une tâche qui utilise des disques persistants, ce modèle d'instance doit définir et associer les disques persistants que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un nouveau disque persistant nommé NEW_PERSISTENT_DISK_NAME, et associer un disque persistant existant nommé EXISTING_PERSISTENT_DISK_NAME.

  2. Exécutez la commande suivante :

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

    Remplacez les éléments suivants :

    • JOB_NAME: nom de la tâche.
    • LOCATION: emplacement de la tâche.
    • JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

Pour créer une tâche qui utilise des disques persistants à l'aide de l'API Batch, utilisez la méthode jobs.create. Dans la requête, spécifiez les disques persistants dans le champ instances, puis installez le disque persistant dans le champ volumes.

  • Si vous n'utilisez pas de modèle d'instance pour cette tâche, exécutez la requête suivante:

    POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME
    
    {
        "allocationPolicy": {
            "instances": [
                {
                    "policy": {
                        "disks": [
                            {
                                "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                                "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                            },
                            {
                                "newDisk": {
                                    "sizeGb":NEW_PERSISTENT_DISK_SIZE,
                                    "type": "NEW_PERSISTENT_DISK_TYPE"
                                },
                                "deviceName": "NEW_PERSISTENT_DISK_NAME"
                            }
                        ]
                    }
                }
            ],
            "location": {
                "allowedLocations": [
                    "EXISTING_PERSISTENT_DISK_LOCATION"
                ]
            }
        },
        "taskGroups":[
            {
                "taskSpec":{
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                            }
                        }
                    ],
                    "volumes": [
                        {
                            "deviceName": "NEW_PERSISTENT_DISK_NAME",
                            "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                            "mountOptions": "rw,async"
                        },
                        {
    
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                        }
                    ]
                },
                "taskCount":3
            }
        ],
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Remplacez les éléments suivants :

    • PROJECT_ID: ID de votre projet
    • LOCATION: emplacement de la tâche.
    • JOB_NAME: nom de la tâche.
    • EXISTING_PERSISTENT_DISK_NAME : nom d'un disque persistant existant.
    • EXISTING_PERSISTENT_DISK_LOCATION: emplacement d'un disque persistant existant. Pour chaque disque persistant zonal existant, l'emplacement de la tâche doit correspondre à la zone du disque. Pour chaque disque persistant régional existant, l'emplacement de la tâche doit correspondre à la région du disque ou, si vous spécifiez des zones, à l'une des zones spécifiques où se trouve le disque persistant régional, ou aux deux. Si vous ne spécifiez aucun disque persistant existant, vous pouvez sélectionner n'importe quel emplacement. En savoir plus sur le champ allowedLocations
    • NEW_PERSISTENT_DISK_SIZE : taille du nouveau disque persistant en Go. Les tailles autorisées dépendent du type de disque persistant, mais le minimum est souvent de 10 Go (10) et le maximum de 64 To (64000).
    • NEW_PERSISTENT_DISK_TYPE : le type de disque du nouveau disque persistant (pd-standard, pd-balanced, pd-ssd ou pd-extreme).
    • NEW_PERSISTENT_DISK_NAME: nom du nouveau disque persistant.
  • Si vous utilisez un modèle d'instance pour cette tâche, créez un fichier JSON comme indiqué précédemment, mais remplacez le champ instances par le code suivant:

    "instances": [
        {
            "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
        }
    ],
    

    INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour cette tâche. Pour une tâche qui utilise des disques persistants, ce modèle d'instance doit définir et associer les disques persistants que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un nouveau disque persistant nommé NEW_PERSISTENT_DISK_NAME, et associer un disque persistant existant nommé EXISTING_PERSISTENT_DISK_NAME.

Utiliser un SSD local

Une tâche qui utilise des disques SSD locaux est soumise aux restrictions suivantes:

Vous pouvez créer une tâche qui utilise un SSD local à l'aide de gcloud CLI ou de l'API Batch. L'exemple suivant montre comment créer une tâche qui crée, associe et installe un disque SSD local. La tâche comporte également trois tâches qui exécutent chacune un script permettant de créer un fichier dans le SSD local nommé output_task_TASK_INDEX.txt, où TASK_INDEX est l'index de chaque tâche : 0, 1 et 2.

gcloud

Pour créer une tâche qui utilise des disques SSD locaux à l'aide de la CLI gcloud, utilisez la commande gcloud batch jobs submit. Dans le fichier de configuration JSON de la tâche, créez et associez des disques SSD locaux dans le champ instances, puis installez-les dans le champ volumes.

  1. Créez un fichier JSON.

    • Si vous n'utilisez pas de modèle d'instance pour cette tâche, créez un fichier JSON avec le contenu suivant:

      {
          "allocationPolicy": {
              "instances": [
                  {
                      "policy": {
                          "machineType": MACHINE_TYPE,
                          "disks": [
                              {
                                  "newDisk": {
                                      "sizeGb":LOCAL_SSD_SIZE,
                                      "type": "local_ssd"
                                  },
                                  "deviceName": "LOCAL_SSD_NAME"
                              }
                          ]
                      }
                  }
              ]
          },
          "taskGroups":[
              {
                  "taskSpec":{
                      "runnables": [
                          {
                              "script": {
                                  "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                              }
                          }
                      ],
                      "volumes": [
                          {
                              "deviceName": "LOCAL_SSD_NAME",
                              "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                              "mountOptions": "rw,async"
                          }
                      ]
                  },
                  "taskCount":3
              }
          ],
          "logsPolicy": {
              "destination": "CLOUD_LOGGING"
          }
      }
      

      Remplacez les éléments suivants :

      • MACHINE_TYPE: type de machine des VM de la tâche. Le nombre de disques SSD locaux autorisés dépend du type de machine des VM de votre tâche.
      • LOCAL_SSD_NAME: nom d'un disque SSD local créé pour cette tâche.
      • LOCAL_SSD_SIZE : taille de tous les disques SSD locaux en Go. La valeur de chaque SSD local est de 375 Go. Cette valeur doit donc être un multiple de 375 Go. Par exemple, pour deux disques SSD locaux, définissez cette valeur sur 750 Go.
    • Si vous utilisez un modèle d'instance pour cette tâche, créez un fichier JSON comme indiqué précédemment, mais remplacez le champ instances par le code suivant:

      "instances": [
          {
              "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
          }
      ],
      

      INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour cette tâche. Pour une tâche qui utilise des disques SSD locaux, ce modèle d'instance doit définir et associer les disques SSD locaux que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un disque SSD local nommé LOCAL_SSD_NAME.

  2. Exécutez la commande suivante :

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

    Remplacez les éléments suivants :

    • JOB_NAME : nom de la tâche.
    • LOCATION : emplacement de la tâche.
    • JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

Pour créer une tâche qui utilise des disques SSD locaux à l'aide de l'API Batch, utilisez la méthode jobs.create. Dans la requête, créez et associez des disques SSD locaux dans le champ instances, puis installez-les dans le champ volumes.

  • Si vous n'utilisez pas de modèle d'instance pour cette tâche, exécutez la requête suivante:

    POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_NAME
    
    {
        "allocationPolicy": {
            "instances": [
                {
                    "policy": {
                        "machineType": MACHINE_TYPE,
                        "disks": [
                            {
                                "newDisk": {
                                    "sizeGb":LOCAL_SSD_SIZE,
                                    "type": "local_ssd"
                                },
                                "deviceName": "LOCAL_SSD_NAME"
                            }
                        ]
                    }
                }
            ]
        },
        "taskGroups":[
            {
                "taskSpec":{
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                            }
                        }
                    ],
                    "volumes": [
                        {
                            "deviceName": "LOCAL_SSD_NAME",
                            "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                            "mountOptions": "rw,async"
                        }
                    ]
                },
                "taskCount":3
            }
        ],
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Remplacez les éléments suivants :

    • PROJECT_ID : ID de votre projet
    • LOCATION : emplacement de la tâche.
    • JOB_NAME : nom de la tâche.
    • MACHINE_TYPE : type de machine des VM de la tâche. Le nombre de disques SSD locaux autorisés dépend du type de machine des VM de votre tâche.
    • LOCAL_SSD_NAME : nom d'un disque SSD local créé pour cette tâche.
    • LOCAL_SSD_SIZE : taille de tous les disques SSD locaux en Go. La valeur de chaque SSD local est de 375 Go. Cette valeur doit donc être un multiple de 375 Go. Par exemple, pour deux disques SSD locaux, définissez cette valeur sur 750 Go.
  • Si vous utilisez un modèle d'instance pour cette tâche, créez un fichier JSON comme indiqué précédemment, mais remplacez le champ instances par le code suivant:

    "instances": [
        {
            "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
        }
    ],
    

    INSTANCE_TEMPLATE_NAME est le nom du modèle d'instance pour cette tâche. Pour une tâche qui utilise des disques SSD locaux, ce modèle d'instance doit définir et associer les disques SSD locaux que la tâche doit utiliser. Pour cet exemple, le modèle doit définir et associer un disque SSD local nommé LOCAL_SSD_NAME.

Utiliser un bucket Cloud Storage

Pour créer une tâche qui utilise un bucket Cloud Storage existant, sélectionnez l'une des méthodes suivantes:

  • Installez un bucket directement dans l'environnement de calcul de votre tâche, comme indiqué dans cette section.
  • Créez une tâche de base avec des tâches qui accèdent directement à Cloud Storage, par exemple via des bibliothèques clientes.

Avant de créer une tâche qui utilise un bucket, créez un bucket ou identifiez un bucket existant. Pour en savoir plus, consultez les pages Créer des buckets de stockage et Répertorier des buckets.

Vous pouvez créer une tâche utilisant un bucket Cloud Storage à l'aide de gcloud CLI ou de l'API Batch.

L'exemple suivant explique comment créer une tâche installe un bucket Cloud Storage. La tâche comporte également trois tâches qui exécutent chacune un script permettant de créer un fichier dans le bucket output_task_TASK_INDEX.txt, où TASK_INDEX est l'index de chaque tâche : 0, 1 et 2.

gcloud

Pour créer une tâche utilisant un bucket Cloud Storage à l'aide de la CLI gcloud, utilisez la commande gcloud batch jobs submit. Dans le fichier de configuration JSON de la tâche, installez le bucket dans le champ volumes.

Par exemple, pour créer une tâche qui génère des fichiers dans Cloud Storage:

  1. Dans le répertoire actuel, créez un fichier JSON nommé hello-world-bucket.json avec le contenu suivant : json { "taskGroups": [ { "taskSpec": { "runnables": [ { "script": { "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt" } } ], "volumes": [ { "gcs": { "remotePath": "BUCKET_PATH" }, "mountPath": "MOUNT_PATH" } ] }, "taskCount": 3 } ], "logsPolicy": { "destination": "CLOUD_LOGGING" } } Remplacez le code suivant:
  • BUCKET_PATH: chemin d'accès au répertoire du bucket auquel cette tâche doit accéder, qui doit commencer par le nom du bucket Par exemple, pour un bucket nommé BUCKET_NAME, le chemin BUCKET_NAME représente le répertoire racine du bucket et le chemin BUCKET_NAME/subdirectory représente le sous-répertoire subdirectory.
  • MOUNT_PATH : chemin d'installation que les exécutables de la tâche utilisent pour accéder à ce bucket. Le chemin doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. Par exemple, si vous souhaitez représenter ce bucket avec un répertoire nommé my-bucket, définissez le chemin d'accès au montage sur /mnt/disks/my-bucket.
  1. Exécutez la commande suivante :

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

API

Pour créer une tâche qui utilise un bucket Cloud Storage à l'aide de l'API Batch, utilisez la méthode jobs.create et installez le bucket dans le champ volumes.

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
            "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet
  • BUCKET_PATH : chemin d'accès au répertoire du bucket auquel cette tâche doit accéder, qui doit commencer par le nom du bucket Par exemple, pour un bucket nommé BUCKET_NAME, le chemin BUCKET_NAME représente le répertoire racine du bucket et le chemin BUCKET_NAME/subdirectory représente le sous-répertoire subdirectory.
  • MOUNT_PATH : chemin d'installation que les exécutables de la tâche utilisent pour accéder à ce bucket. Le chemin doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. Par exemple, si vous souhaitez représenter ce bucket avec un répertoire nommé my-bucket, définissez le chemin d'accès au montage sur /mnt/disks/my-bucket.

Utiliser un système de fichiers en réseau

Vous pouvez créer une tâche utilisant un système de fichiers réseau (NFS, Network File System) existant, tel qu'un partage de fichiers Filestore, à l'aide de gcloud CLI ou de Batch API.

Avant de créer une tâche qui utilise un NFS, assurez-vous que le pare-feu de votre réseau est correctement configuré pour autoriser le trafic entre les VM de votre tâche et le NFS. Pour en savoir plus, consultez la page Configurer des règles de pare-feu pour Filestore.

L'exemple suivant explique comment créer une tâche qui spécifie et installe un NFS. La tâche comporte également trois tâches qui exécutent chacune un script permettant de créer un fichier dans le NFS nommé output_task_TASK_INDEX.txt, où TASK_INDEX est l'index de chaque tâche : 0, 1 et 2.

gcloud

Pour créer une tâche qui utilise un NFS à l'aide de gcloud CLI, utilisez la commande gcloud batch jobs submit. Dans le fichier de configuration JSON de la tâche, installez le NFS dans le champ volumes.

  1. Créez un fichier json contenant les éléments suivants :

    {
        "taskGroups": [
            {
                "taskSpec": {
                    "runnables": [
                        {
                            "script": {
                                "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                            }
                        }
                    ],
                    "volumes": [
                        {
                            "nfs": {
                                "server": "NFS_IP_ADDRESS",
                                "remotePath": "NFS_PATH"
                            },
                            "mountPath": "MOUNT_PATH"
                        }
                    ]
                },
                "taskCount": 3
            }
        ],
        "logsPolicy": {
            "destination": "CLOUD_LOGGING"
        }
    }
    

    Remplacez les éléments suivants :

    • NFS_IP_ADDRESS : adresse IP du NFS. Par exemple, si votre NFS est un partage de fichiers Filestore, spécifiez l'adresse IP de la VM hébergeant le partage de fichiers Filestore, que vous pouvez obtenir en décrit la VM Filestore.
    • NFS_PATH: chemin d'accès au répertoire NFS auquel cette tâche doit accéder, qui doit commencer par / suivi du répertoire racine du NFS. Par exemple, pour un partage de fichiers Filestore nommé FILE_SHARE_NAME, le chemin /FILE_SHARE_NAME représente le répertoire racine du partage de fichiers et le chemin /FILE_SHARE_NAME/subdirectory représente le sous-répertoire subdirectory.
    • MOUNT_PATH: chemin d'installation que les exécutables de la tâche utilisent pour accéder à ce NFS. Le chemin doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. Par exemple, si vous souhaitez représenter ce NFS avec un répertoire nommé my-nfs, définissez le chemin d'installation sur /mnt/disks/my-nfs.
  2. Exécutez la commande suivante :

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

    Remplacez les éléments suivants :

    • JOB_NAME : nom de la tâche.
    • LOCATION: emplacement de la tâche.
    • JSON_CONFIGURATION_FILE : chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

API

Pour créer une tâche qui utilise un NFS à l'aide de l'API Batch, utilisez la méthode jobs.create et installez-le dans le champ volumes.

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}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Remplacez les éléments suivants :

  • PROJECT_ID: ID de votre projet
  • LOCATION : emplacement de la tâche.
  • JOB_NAME : nom de la tâche.
  • NFS_IP_ADDRESS : adresse IP du système de fichiers en réseau Par exemple, si votre NFS est un partage de fichiers Filestore, spécifiez l'adresse IP de la VM hébergeant le partage de fichiers Filestore, que vous pouvez obtenir en décrit la VM Filestore.
  • NFS_PATH: chemin d'accès au répertoire NFS auquel cette tâche doit accéder, qui doit commencer par / suivi du répertoire racine du NFS. Par exemple, pour un partage de fichiers Filestore nommé FILE_SHARE_NAME, le chemin /FILE_SHARE_NAME représente le répertoire racine du partage de fichiers et le chemin /FILE_SHARE_NAME/subdirectory représente un sous-répertoire.
  • MOUNT_PATH : chemin d'installation que les exécutables de la tâche utilisent pour accéder à ce NFS. Le chemin doit commencer par /mnt/disks/, suivi du répertoire ou du chemin d'accès que vous choisissez. Par exemple, si vous souhaitez représenter ce NFS avec un répertoire nommé my-nfs, définissez le chemin d'installation sur /mnt/disks/my-nfs.

Étapes suivantes