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

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

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

Pour en savoir plus sur les concepts de mise en réseau et sur le moment où configurer la mise en réseau, consultez 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 Gérer l'accès aux projets, aux dossiers et aux organisations.

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

  3. Identifiez le réseau que vous souhaitez utiliser pour le job. Le réseau que vous spécifiez pour un job 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'un job s'exécute sur un sous-réseau d'un réseau VPC partagé hébergé par un autre projet, l'agent du service Batch de votre projet 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 un job qui s'exécute 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 un job 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 où vous souhaitez exécuter ce job.

Si vous souhaitez utiliser un modèle d'instance de VM lors de la création de ce job, vous devez spécifier le réseau dans le modèle d'instance de VM. Sinon, suivez les étapes ci-dessous pour spécifier le réseau d'un job à l'aide de gcloud CLI ou de l'API Batch.

gcloud

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

Utiliser des options gcloud pour spécifier le réseau d'un job

Pour créer un job et utiliser des indicateurs gcloud afin de spécifier le réseau pour le job, procédez comme suit :

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

    Par exemple, pour créer un job de script de base, créez un fichier 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."
            }
          }
        ]
      },
      "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 les indicateurs --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 ce job.
    • LOCATION : emplacement de ce job.
    • JSON_CONFIGURATION_FILE : chemin d'accès au fichier JSON contenant les informations de configuration du job.
    • HOST_PROJECT_ID : ID du 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 actuel.
    • NETWORK : nom d'un réseau VPC dans le projet actuel ou d'un réseau VPC partagé hébergé par le projet actuel ou partagé avec lui.
    • REGION : région où se trouvent le sous-réseau et les VM pour le job :
      • Si vous incluez le champ allowedLocations pour spécifier l'emplacement autorisé des VM pour le job, vous devez spécifier la même région ici.
      • Sinon, la région doit être identique à l'emplacement que vous sélectionnez pour le job (LOCATION).
    • SUBNET : nom d'un sous-réseau qui fait partie du réseau VPC et qui se trouve dans la même région que les VM du job.

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

Pour créer un job et utiliser les champs du fichier de configuration JSON afin de spécifier le réseau pour le job, 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 de la tâche, incluez les champs network et subnetwork.

    Par exemple, pour créer un job de script de base qui s'exécute sur un réseau spécifique, créez un fichier 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."
            }
          }
        ]
      },
      "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 : ID du 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 actuel.
    • NETWORK : nom d'un réseau VPC dans le projet actuel ou d'un réseau VPC partagé hébergé par le projet actuel ou partagé avec lui.
    • REGION : région où se trouvent le sous-réseau et les VM pour le job :
      • Si vous incluez le champ allowedLocations pour spécifier l'emplacement autorisé des VM pour le job, vous devez spécifier la même région ici.
      • Sinon, la région doit être identique à l'emplacement que vous sélectionnez pour le job (LOCATION).
    • SUBNET : nom d'un sous-réseau qui fait partie du réseau VPC et qui se trouve dans la même région que les VM du job.

  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 ce job.
    • LOCATION : emplacement de ce job.
    • JSON_CONFIGURATION_FILE : chemin d'accès au fichier JSON contenant les informations de configuration du job.

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 jobs.create et spécifiez les détails de configuration de votre job. Pour spécifier le réseau de la tâche, incluez les champs network et subnetwork.

Par exemple, pour créer un job de script de base qui s'exécute sur un réseau spécifique, envoyez 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 de ce job.
  • JOB_NAME : nom de ce job.
  • HOST_PROJECT_ID : ID du 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 actuel (PROJECT_ID).
  • NETWORK : nom d'un réseau VPC dans le projet actuel ou d'un réseau VPC partagé hébergé par le projet actuel ou partagé avec lui.
  • REGION : région où se trouvent le sous-réseau et les VM pour le job :
    • Si vous incluez le champ allowedLocations pour spécifier l'emplacement autorisé des VM pour le job, vous devez spécifier la même région ici.
    • Sinon, la région doit être identique à l'emplacement que vous sélectionnez pour le job (LOCATION).
  • SUBNET : nom d'un sous-réseau qui fait partie du réseau VPC et qui se trouve dans la même région que les VM du job.

Étapes suivantes