Spécifier le réseau d'une tâche

Ce document explique comment spécifier le réseau des VM qui exécutent un job.

Vous pouvez contrôler les connexions des VM qui exécutent une tâche en spécifiant un réseau avec l'accès souhaité. Par exemple, vous pouvez spécifier un réseau qui permet à une tâche d'accéder aux ressources requises ou qui limite l'accès pour améliorer la sécurité. Si vous n'avez aucune exigence de mise en réseau et que vous ne souhaitez pas configurer la mise en réseau pour une tâche, vous pouvez ignorer la spécification du réseau et utiliser la configuration de mise en réseau par défaut.

Pour en savoir plus sur les concepts de mise en réseau et quand configurer la mise en réseau, consultez la section Présentation de la mise en réseau par lot.

Avant de commencer

  1. Si vous n'avez jamais utilisé Batch, consultez Premiers pas avec Batch et activez Batch en remplissant les conditions préalables pour les projets et les utilisateurs.

  2. Pour obtenir les autorisations nécessaires pour créer un job qui s'exécute sur un réseau spécifique, demandez à votre administrateur de vous accorder les rôles IAM suivants :

    Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

    Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

  3. Identifiez le réseau que vous souhaitez utiliser pour la tâche. Le réseau que vous spécifiez pour une tâche doit répondre aux exigences suivantes : Pour en savoir plus, consultez Créer et gérer des réseaux VPC.
  4. Si vous souhaitez qu'une tâche s'exécute sur un sous-réseau d'un réseau VPC partagé hébergé par un autre projet, Agent de service Batch doit être autorisé à utiliser ce sous-réseau.

    Pour vous assurer que l'agent de service Batch de votre projet dispose des autorisations nécessaires pour créer une tâche exécutée sur un sous-réseau d'un réseau VPC partagé, demandez à votre administrateur d'accorder à l'agent de service Batch de votre projet le rôle IAM Utilisateur de réseau Compute (roles/compute.networkUser) sur le sous-réseau VPC partagé.

    Pour en savoir plus, consultez la documentation sur la configuration d'un VPC partagé pour les comptes de service.

Créer une tâche qui s'exécute sur un réseau spécifique

Spécifiez le réseau d'une tâche lorsque vous la créez. Plus précisément, vous devez spécifier un réseau VPC et un sous-réseau situés à l'emplacement où vous souhaitez exécuter cette tâche.

Si vous souhaitez utiliser un modèle d'instance de VM lors de la création de cette tâche, vous devez spécifier le réseau dans le modèle d'instance de VM. Sinon, procédez comme suit pour spécifier le réseau d'une tâche à l'aide de la CLI gcloud ou de l'API Batch.

gcloud

Pour créer une tâche qui s'exécute sur un réseau spécifique à l'aide de la CLI gcloud, sélectionnez l'une des options suivantes :

Utiliser des options gcloud pour spécifier le réseau d'une tâche

Pour créer une tâche et utiliser des options gcloud pour spécifier le réseau de la tâche, procédez comme suit :

  1. Créez un fichier JSON qui spécifie les détails de configuration de votre tâche.

    Par exemple, pour créer un job de script de base, créez un fichier JSON avec la propriété les contenus suivants.

    {
  "taskGroups": [
    {
      "taskSpec": {
        "runnables": [
          {
            "script": {
              "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        ]
      },
      "taskCount": 3
    }
  ],
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

  2. Créez le job à l'aide de la commande gcloud batch jobs submit. Pour spécifier le réseau du job, incluez le paramètre Options --network et --subnetwork.

    gcloud batch jobs submit JOB_NAME \
    --location LOCATION \
    --config JSON_CONFIGURATION_FILE \
    --network projects/HOST_PROJECT_ID/global/networks/NETWORK \
    --subnetwork projects/HOST_PROJECT_ID/regions/REGION/subnetworks/SUBNET

    Remplacez les éléments suivants :

    • JOB_NAME : nom de cette tâche.
    • LOCATION : emplacement de cette tâche.
    • JSON_CONFIGURATION_FILE: chemin d'accès de JSON contenant les détails de la configuration du job.
    • HOST_PROJECT_ID : ID de projet du projet pour le réseau que vous spécifiez :
      • Si vous utilisez un réseau VPC partagé, spécifiez le projet hôte.
      • Sinon, spécifiez le projet en cours.
    • NETWORK : nom d'un réseau VPC dans le projet en cours ou d'un réseau VPC partagé hébergé par le projet en cours ou partagé avec celui-ci.
    • REGION : région où se trouvent le sous-réseau et les VM de la tâche :
      • Si vous incluez le champ allowedLocations pour spécifier l'emplacement autorisé des VM pour la tâche, vous devez spécifier la même région ici.
      • Sinon, la région doit être identique à celle Le lieu que vous avez sélectionné pour le projet (LOCATION).
    • SUBNET : nom d'un sous-réseau faisant partie du réseau VPC et situé dans la même région que les VM de la tâche.

Utiliser des champs JSON pour spécifier le réseau d'un job

Pour créer une tâche et utiliser les champs du fichier de configuration JSON pour spécifier le réseau de la tâche, procédez comme suit :

  1. Créez un fichier JSON qui spécifie les détails de configuration de votre job. Pour spécifier le réseau du job, incluez le paramètre Champs network et subnetwork.

    Par exemple, pour créer une tâche de script de base exécutée sur un réseau spécifique, créez un fichier JSON contenant 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."
            }
          }
        ]
      },
      "taskCount": 3
    }
  ],
  "allocationPolicy": {
    "network": {
      "networkInterfaces": [
        {
          "network": "projects/HOST_PROJECT_ID/global/networks/NETWORK",
          "subnetwork": "projects/HOST_PROJECT_ID/regions/REGION/subnetworks/SUBNET"
        }
      ]
    }
  },
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

    Remplacez les éléments suivants :

    • HOST_PROJECT_ID: le ID du projet du projet pour le réseau que vous spécifiez:
      • Si vous utilisez un réseau VPC partagé, spécifiez l'hôte projet.
      • Sinon, spécifiez le projet en cours.
    • NETWORK : nom d'un réseau VPC dans le projet en cours ou d'un réseau VPC partagé hébergé par le projet en cours ou partagé avec celui-ci.
    • REGION : région où se trouvent le sous-réseau et les VM de la tâche :
      • Si vous incluez le paramètre Champ allowedLocations pour spécifier l'emplacement autorisé pour les VM associées au job, vous doit spécifier la même région ici.
      • Sinon, la région doit être identique à l'emplacement que vous sélectionnez pour la tâche (LOCATION).
    • SUBNET : nom d'un sous-réseau faisant partie du réseau VPC et situé dans la même région que les VM de la tâche.

  2. Créez le job à 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 cette tâche.
    • JSON_CONFIGURATION_FILE : chemin d'accès au fichier JSON avec les détails de configuration de la tâche.

Java 


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
import com.google.cloud.batch.v1.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 CreateBatchCustomNetwork {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the region you want to use to run the job. Regions that are
    // available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
    String region = "europe-central2";
    // The name of the job that will be created.
    // It needs to be unique for each project and region pair.
    String jobName = "JOB_NAME";
    // The name of a VPC network in the current project or a Shared VPC network that is hosted by
    // or shared with the current project.

    String network = String.format("global/networks/%s", "test-network");
    // The name of a subnet that is part of the VPC network and is located
    // in the same region as the VMs for the job.
    String subnet = String.format("regions/%s/subnetworks/%s", region, "subnet");

    createBatchCustomNetwork(projectId, region, jobName, network, subnet);
  }

  // Create a job that runs on a specific network.
  public static Job createBatchCustomNetwork(String projectId, String region, String jobName,
                                             String network,  String subnet)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                              + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
          // Jobs can be divided into tasks. In this case, we have only one task.
          .addRunnables(runnable)
          .setMaxRetryCount(2)
          .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
          .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Specifies a VPC network and a subnet for Allocation Policy
      AllocationPolicy.NetworkPolicy networkPolicy =
          AllocationPolicy.NetworkPolicy.newBuilder()
              .addNetworkInterfaces(AllocationPolicy.NetworkInterface.newBuilder()
                  .setNetwork(network) // Set the network name
                  .setSubnetwork(subnet) // Set the subnet name
                  .setNoExternalIpAddress(true) // Blocks external access for all VMs
                  .build())
              .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
      AllocationPolicy.InstancePolicy instancePolicy =
          AllocationPolicy.InstancePolicy.newBuilder().setMachineType("e2-standard-4")
              .build();

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

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(Destination.CLOUD_LOGGING))
              .build();

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run for the specific project.
              .setParent(String.format("projects/%s/locations/%s", projectId, region))
              .setJob(job)
              .setJobId(jobName)
              .build();

      Job result =
          batchServiceClient
              .createJobCallable()
              .futureCall(createJobRequest)
              .get(5, TimeUnit.MINUTES);

      System.out.printf("Successfully created the job: %s", result.getName());

      return result;
    }
  }
}

Node.js 

// Imports the Batch library
const batchLib = require('@google-cloud/batch');
const batch = batchLib.protos.google.cloud.batch.v1;

// Instantiates a client
const batchClient = new batchLib.v1.BatchServiceClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// Project ID or project number of the Google Cloud project you want to use.
const projectId = await batchClient.getProjectId();
// Name of the region you want to use to run the job. Regions that are
// available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
const region = 'europe-central2';
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'example-job';
// The name of a VPC network in the current project or a Shared VPC network that is hosted by
// or shared with the current project.
const network = 'global/networks/test-network';
// The name of a subnetwork that is part of the VPC network and is located
// in the same region as the VMs for the job.
const subnetwork = `regions/${region}/subnetworks/subnet`;

// Define what will be done as part of the job.
const runnable = new batch.Runnable({
  script: new batch.Runnable.Script({
    commands: ['-c', 'echo Hello world! This is task ${BATCH_TASK_INDEX}.'],
  }),
});

// Specify what resources are requested by each task.
const computeResource = new batch.ComputeResource({
  // In milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
  cpuMilli: 500,
  // In MiB.
  memoryMib: 16,
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  computeResource,
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Specify VPC network and a subnet for Allocation Policy
const networkPolicy = new batch.AllocationPolicy.NetworkPolicy({
  networkInterfaces: [
    new batch.AllocationPolicy.NetworkInterface({
      // Set the network name
      network,
      // Set the subnetwork name
      subnetwork,
      // Blocks external access for all VMs
      noExternalIpAddress: true,
    }),
  ],
});

// 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 instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType: 'e2-standard-4',
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  policy: instancePolicy,
  network: networkPolicy,
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  labels: {env: 'testing', type: 'script'},
  allocationPolicy,
  // We use Cloud Logging as it's an option available out of the box
  logsPolicy: new batch.LogsPolicy({
    destination: batch.LogsPolicy.Destination.CLOUD_LOGGING,
  }),
});

// The job's parent is the project and region in which the job will run
const parent = `projects/${projectId}/locations/${region}`;

async function callCreateBatchCustomNetwork() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchCustomNetwork();

Python 

from google.cloud import batch_v1


def create_with_custom_network(
    project_id: str,
    region: str,
    network_name: str,
    subnet_name: str,
    job_name: str,
) -> batch_v1.Job:
    """Create a Batch job that runs on a specific network and subnet.

    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/locations
        network_name: The name of a VPC network in the current project or a Shared VPC network.
        subnet_name: Name of the subnetwork to be used within the specified region.
        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.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."

    # 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 = 3
    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]

    # Create a NetworkInterface object to specify network settings for the job
    network_interface = batch_v1.AllocationPolicy.NetworkInterface()
    # Set the network to the specified network name within the project
    network_interface.network = f"projects/{project_id}/global/networks/{network_name}"
    # Set the subnetwork to the specified subnetwork within the region
    network_interface.subnetwork = (
        f"projects/{project_id}/regions/{region}/subnetworks/{subnet_name}"
    )
    allocation_policy.network.network_interfaces = [network_interface]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    # 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)

API

Pour créer un job à l'aide de l'API Batch, utilisez la méthode Méthode jobs.create et spécifiez les détails de configuration de votre job. Pour spécifier le réseau du job, incluez le paramètre Champs network et subnetwork.

Par exemple, pour créer un job de script de base qui s'exécute sur un un réseau spécifique, exécutez la requête POST suivante:

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

{
  "taskGroups": [
    {
      "taskSpec": {
        "runnables": [
          {
            "script": {
              "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        ]
      },
      "taskCount": 3
    }
  ],
  "allocationPolicy": {
    "network": {
      "networkInterfaces": [
        {
          "network": "projects/HOST_PROJECT_ID/global/networks/NETWORK",
          "subnetwork": "projects/HOST_PROJECT_ID/regions/REGION/subnetworks/SUBNET"
        }
      ]
    }
  },
  "logsPolicy": {
    "destination": "CLOUD_LOGGING"
  }
}

Remplacez les éléments suivants :

  • PROJECT_ID : ID de projet de votre projet.
  • LOCATION: emplacement pour ce poste.
  • JOB_NAME: nom de la tâche.
  • HOST_PROJECT_ID : ID de projet du projet pour le réseau que vous spécifiez :
    • Si vous utilisez un réseau VPC partagé, spécifiez l'hôte projet.
    • Sinon, spécifiez le projet en cours (PROJECT_ID).
  • NETWORK: nom d'un Réseau VPC dans le projet actuel ou un réseau VPC partagé qui est hébergé par ou partagé avec le projet en cours.
  • REGION : région où se trouvent le sous-réseau et les VM de la tâche :
    • Si vous incluez le champ allowedLocations pour spécifier l'emplacement autorisé des VM pour la tâche, vous devez spécifier la même région ici.
    • Sinon, la région doit être identique à celle Le lieu que vous avez sélectionné pour le projet (LOCATION).
  • SUBNET : nom d'un sous-réseau faisant partie du réseau VPC et situé dans la même région que les VM de la tâche.

Étape suivante