Especifica la red para un trabajo

En este documento, se explica cómo especificar la red para las VMs que ejecutan una tarea.

Para controlar las conexiones de las VMs que ejecutan una tarea, especifica una red con el acceso deseado. Por ejemplo, puedes especificar una red que permita que un trabajo acceda a los recursos necesarios o limite el acceso para mejorar la seguridad. Como alternativa, si no tienes ningún requisito de red y no quieres configurar una red para un trabajo, omite especificar la red para usar la configuración de red predeterminada.

Para obtener más información sobre los conceptos de redes y cuándo configurarlas, consulta la descripción general de las redes por lotes.

Antes de comenzar

  1. Si nunca antes usaste Batch, consulta Cómo comenzar a usar Batch y habilita Batch completando los requisitos previos para proyectos y usuarios.

  2. Para obtener los permisos que necesitas para crear un trabajo que se ejecute en una red específica, pídele a tu administrador que te otorgue los siguientes roles de IAM:

    Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

    También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

  3. Identifica la red que deseas usar para el trabajo. La red que especifiques para un trabajo debe cumplir con los siguientes requisitos:
    • La red es una red de nube privada virtual (VPC) que se encuentra en el mismo proyecto que la tarea o es una red de VPC compartida que aloja o comparte el proyecto para la tarea.
    • La red incluye una subred en la ubicación en la que deseas ejecutar la tarea.
    • La red permite el acceso necesario para tu trabajo. Por ejemplo, si tu trabajo requiere comunicación entre VMs, como un trabajo que usa bibliotecas MPI para comunicarse entre tareas estrechamente vinculadas, asegúrate de que la red tenga una regla de firewall que permita conexiones entre las VMs del trabajo.

      Obtén más información para configurar reglas de firewall de VPC para casos de uso comunes.

    Para obtener más información, consulta Crea y administra redes de VPC.
  4. Si deseas que una tarea se ejecute en una subred de una red de VPC compartida que aloja otro proyecto, se debe otorgar permiso al agente de servicio por lotes de tu proyecto para usar esa subred.

    Para garantizar que el agente de servicio de Batch de tu proyecto tenga los permisos necesarios para crear un trabajo que se ejecute en una subred de una red de VPC compartida, pídele a tu administrador que le otorgue al agente de servicio de Batch de tu proyecto el rol de IAM de Usuario de la red de Compute (roles/compute.networkUser) en la subred de VPC compartida.

    Para obtener más información, consulta la documentación para configurar la VPC compartida para cuentas de servicio.

Crea un trabajo que se ejecute en una red específica

Especifica la red de un trabajo cuando lo creas. Específicamente, debes especificar una red de VPC y una subred que se encuentre donde deseas ejecutar esta tarea.

Si quieres usar una plantilla de instancias de VM cuando crees este trabajo, debes especificar la red en la plantilla de instancias de VM. De lo contrario, usa los siguientes pasos para especificar la red de un trabajo con gcloud CLI o la API de Batch.

gcloud

Para crear un trabajo que se ejecute en una red específica con gcloud CLI, selecciona una de las siguientes opciones:

Usa marcas de gcloud para especificar la red de un trabajo

Para crear un trabajo y usar marcas de gcloud para especificar la red del trabajo, completa los siguientes pasos:

  1. Crea un archivo JSON que especifique los detalles de configuración de tu trabajo.

    Por ejemplo, para crear una tarea de secuencia de comandos básica, crea un archivo JSON con el siguiente contenido.

    {
  "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 el trabajo con el comando gcloud batch jobs submit. Para especificar la red del trabajo, incluye las marcas --network y --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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre de este trabajo.
    • LOCATION: La ubicación de este trabajo.
    • JSON_CONFIGURATION_FILE: Es la ruta de acceso al archivo JSON con los detalles de configuración de la tarea.
    • HOST_PROJECT_ID: Es el ID del proyecto del proyecto de la red que especificas:
      • Si usas una red de VPC compartida, especifica el proyecto host.
      • De lo contrario, especifica el proyecto actual.
    • NETWORK: Es el nombre de una red de VPC en el proyecto actual o una red de VPC compartida que aloja o comparte el proyecto actual.
    • REGION: Es la región en la que se encuentran la subred y las VMs del trabajo:
      • Si incluyes el campo allowedLocations para especificar la ubicación permitida para las VMs del trabajo, debes especificar la misma región aquí.
      • De lo contrario, la región debe ser la misma que la ubicación que selecciones para el trabajo (LOCATION).
    • SUBNET: Es el nombre de una subred que forma parte de la red de VPC y se encuentra en la misma región que las VMs para la tarea.

Usa campos JSON para especificar la red de un trabajo

Para crear una tarea y usar campos en el archivo de configuración JSON para especificar la red de la tarea, completa los siguientes pasos:

  1. Crea un archivo JSON que especifique los detalles de configuración de tu trabajo. Para especificar la red del trabajo, incluye los campos network y subnetwork.

    Por ejemplo, para crear una tarea de secuencia de comandos básica que se ejecute en una red específica, crea un archivo JSON con el siguiente contenido.

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

    Reemplaza lo siguiente:

    • HOST_PROJECT_ID: Es el ID del proyecto del proyecto de la red que especificas:
      • Si usas una red de VPC compartida, especifica el proyecto host.
      • De lo contrario, especifica el proyecto actual.
    • NETWORK: Es el nombre de una red de VPC en el proyecto actual o una red de VPC compartida que aloja o comparte el proyecto actual.
    • REGION: Es la región en la que se encuentran la subred y las VMs del trabajo:
      • Si incluyes el campo allowedLocations para especificar la ubicación permitida para las VMs del trabajo, debes especificar la misma región aquí.
      • De lo contrario, la región debe ser la misma que la ubicación que selecciones para la tarea (LOCATION).
    • SUBNET: Es el nombre de una subred que forma parte de la red de VPC y se encuentra en la misma región que las VMs para la tarea.

  2. Crea el trabajo con el comando gcloud batch jobs submit.

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

    Reemplaza lo siguiente:

    • JOB_NAME: Es el nombre de este trabajo.
    • LOCATION: La ubicación de este trabajo.
    • JSON_CONFIGURATION_FILE: Es la ruta de acceso al archivo JSON con los detalles de configuración de la tarea.

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

Para crear un trabajo con la API de Batch, usa el método jobs.create y especifica los detalles de configuración de tu trabajo. Para especificar la red del trabajo, incluye los campos network y subnetwork.

Por ejemplo, para crear un trabajo de secuencia de comandos básico que se ejecute en una red específica, realiza la siguiente solicitud 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"
  }
}

Reemplaza lo siguiente:

  • PROJECT_ID: Es el ID del proyecto de tu proyecto.
  • LOCATION: La ubicación de este trabajo.
  • JOB_NAME: Es el nombre de este trabajo.
  • HOST_PROJECT_ID: Es el ID del proyecto del proyecto de la red que especificas:
    • Si usas una red de VPC compartida, especifica el proyecto host.
    • De lo contrario, especifica el proyecto actual (PROJECT_ID).
  • NETWORK: Es el nombre de una red de VPC en el proyecto actual o una red de VPC compartida que aloja o comparte el proyecto actual.
  • REGION: Es la región en la que se encuentran la subred y las VMs del trabajo:
    • Si incluyes el campo allowedLocations para especificar la ubicación permitida para las VMs del trabajo, debes especificar la misma región aquí.
    • De lo contrario, la región debe ser la misma que la ubicación que selecciones para el trabajo (LOCATION).
  • SUBNET: Es el nombre de una subred que forma parte de la red de VPC y se encuentra en la misma región que las VMs para la tarea.

¿Qué sigue?