Specificare la rete per un job

Questo documento spiega come specificare la rete per le VM che eseguono un job.

Puoi controllare le connessioni per le VM che eseguono un job specificando una rete con l'accesso desiderato. Ad esempio, potresti specificare una rete che consente un job per accedere alle risorse richieste o ne limita l'accesso per migliorare la sicurezza. In alternativa, se non hai requisiti di rete e configurare il networking per un job, salta la specifica della rete utilizza la configurazione di rete predefinita.

Per ulteriori informazioni sui concetti di networking e su quando configurarla, consulta la panoramica del networking in batch.

Prima di iniziare

  1. Se non hai mai utilizzato Batch, rivedi Inizia a utilizzare Batch e abilita Batch, completando prerequisiti per progetti e utenti.

  2. Per ottenere le autorizzazioni necessarie per creare un job che viene eseguito su una rete specifica, chiedi all'amministratore di concederti i seguenti ruoli IAM:

    Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

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

  3. Identifica la rete che vuoi utilizzare per il job. La rete specificata per un job deve soddisfare i seguenti requisiti requisiti: Per scoprire di più, consulta Creare e gestire reti VPC.
  4. Se vuoi che un job venga eseguito su una subnet di una rete VPC condiviso ospitato da un altro progetto, Agente di servizio batch gli utenti devono avere l'autorizzazione per utilizzare questa subnet.

    Per assicurarti che l'agente di servizio Batch del tuo progetto disponga dei necessari autorizzazioni per creare un job che viene eseguito su una subnet di una rete VPC condiviso, chiedi all'amministratore di concedere all'agente di servizio Batch del tuo progetto Ruolo IAM Utente di rete Compute (roles/compute.networkUser) sulla subnet VPC condiviso.

    Per saperne di più, consulta la documentazione relativa alla configurazione del VPC condiviso per gli account di servizio.

Creare un job che viene eseguito su una rete specifica

Specifica la rete per un job al momento della creazione. In particolare, devi specificare una rete VPC e una subnet situate dove vuoi eseguire il job.

Se vuoi utilizzare un modello di istanza VM durante la creazione di questo job, devi specificare la rete nel modello di istanza VM. In caso contrario, segui i passaggi riportati di seguito per specificare la rete per un job utilizzando l'interfaccia a riga di comando gcloud o l'API Batch.

gcloud

Per creare un job che viene eseguito su una rete specifica utilizzando gcloud CLI, seleziona una delle opzioni seguenti:

Utilizza i flag gcloud per specificare la rete per un job

Per creare un job e utilizzare i flag gcloud per specificare la rete per il job, completa i seguenti passaggi:

  1. Crea un file JSON che specifichi i dettagli di configurazione del job.

    Ad esempio, per creare un job di script di base, crea un file JSON con i seguenti contenuti.

    {
  "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. Crea il job utilizzando il comando gcloud batch jobs submit. Per specificare la rete del job, includi Flag --network e --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

    Sostituisci quanto segue:

    • JOB_NAME: il nome di questo job.
    • LOCATION: il location per questo lavoro.
    • JSON_CONFIGURATION_FILE: il percorso file JSON con i dettagli di configurazione del job.
    • HOST_PROJECT_ID: il ID progetto del progetto per la rete specificata:
      • Se utilizzi una rete VPC condiviso, specifica l'host progetto.
      • In caso contrario, specifica il progetto corrente.
    • NETWORK: il nome di una rete VPC nel progetto corrente o di una rete VPC condivisa in hosting o condivisa con il progetto corrente.
    • REGION: il region in cui la subnet e le VM per il job si trovano:
      • Se includi il parametro Campo allowedLocations specificare la località consentita per le VM per il job, deve specificare la stessa regione qui.
      • In caso contrario, la regione deve corrispondere alla regione località selezionata per il lavoro (LOCATION).
    • SUBNET: il nome di una subnet che fa parte della rete VPC e si trova nella stessa regione delle VM per il job.

Utilizza i campi JSON per specificare la rete per un job

Per creare un job e utilizzare i campi del file di configurazione JSON per specificare rete per il job, completa questi passaggi:

  1. Crea un file JSON che specifichi i dettagli di configurazione del job. Per specificare la rete per il job, includi i campi network e subnetwork.

    Ad esempio, per creare un job di script di base che viene eseguito su una specifica rete, crea un file JSON con il contenuto seguente.

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

    Sostituisci quanto segue:

    • HOST_PROJECT_ID: il ID progetto del progetto per la rete specificata:
      • Se utilizzi una rete VPC condiviso, specifica l'host progetto.
      • In caso contrario, specifica il progetto corrente.
    • NETWORK: il nome di una rete VPC nel progetto corrente o di una rete VPC condivisa in hosting o condivisa con il progetto corrente.
    • REGION: il region in cui la subnet e le VM per il job si trovano:
      • Se includi il parametro Campo allowedLocations specificare la località consentita per le VM per il job, deve specificare la stessa regione qui.
      • In caso contrario, la regione deve corrispondere alla regione località selezionata per il lavoro (LOCATION).
    • SUBNET: il nome di una subnet che fa parte della rete VPC e si trova nella stessa regione delle VM per il job.

  2. Crea il job utilizzando il comando gcloud batch jobs submit.

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

    Sostituisci quanto segue:

    • JOB_NAME: il nome di questo job.
    • LOCATION: il località per questo lavoro.
    • JSON_CONFIGURATION_FILE: il percorso file JSON con i dettagli di configurazione del 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

Per creare un job utilizzando l'API Batch, utilizza il metodo jobs.create e specifica i dettagli di configurazione del job. Per specificare la rete per il job, includi il parametro Campi network e subnetwork:

Ad esempio, per creare un job di script di base che viene eseguito su una rete specifica, effettua la seguente richiesta POST:

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

Sostituisci quanto segue:

  • PROJECT_ID: il ID progetto del tuo progetto.
  • LOCATION: la località per questo lavoro.
  • JOB_NAME: il nome di questo job.
  • HOST_PROJECT_ID: il ID progetto del progetto per la rete specificata:
    • Se utilizzi una rete VPC condiviso, specifica l'host progetto.
    • In caso contrario, specifica il progetto attuale (PROJECT_ID).
  • NETWORK: il nome di una rete VPC nel progetto corrente o di una rete VPC condivisa in hosting o condivisa con il progetto corrente.
  • REGION: il region in cui la subnet e le VM per il job si trovano:
    • Se includi il campo allowedLocations per specificare la posizione consentita per le VM del job, devi specificare la stessa regione qui.
    • In caso contrario, la regione deve corrispondere alla località selezionata per il job (LOCATION).
  • SUBNET: il nome di una subnet che fa parte della rete VPC e si trova nella stessa regione delle VM per il job.

Passaggi successivi