Netzwerk für einen Job angeben

In diesem Dokument wird beschrieben, wie Sie das Netzwerk für die VMs angeben, auf denen ein Job ausgeführt wird.

Sie können Verbindungen für die VMs steuern, auf denen ein Job ausgeführt wird, indem Sie ein Netzwerk angeben mit dem gewünschten Zugriff. Sie können beispielsweise ein Netzwerk angeben, das einem Job den Zugriff auf die erforderlichen Ressourcen erlaubt, oder den Zugriff einschränken, um die Sicherheit zu verbessern. Wenn Sie keine Netzwerkanforderungen haben und das Netzwerk für einen Job nicht konfigurieren möchten, können Sie die Angabe des Netzwerks überspringen, um stattdessen die Standardnetzwerkkonfiguration zu verwenden.

Weitere Informationen zu Netzwerkkonzepten und zum Konfigurieren von Netzwerken finden Sie unter Batch-Netzwerk – Übersicht.

Hinweise

  1. Wenn Sie Batch zum ersten Mal verwenden, lesen Sie Erste Schritte mit Batch und aktivieren Sie Batch, indem Sie den Voraussetzungen für Projekte und Nutzer.

  2. Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen eines Jobs benötigen, der in einem bestimmten Netzwerk ausgeführt wird:

    Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

    Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

  3. Wählen Sie das gewünschte Netzwerk aus. für den Job nutzen. Das für einen Job angegebene Netzwerk muss die folgenden Anforderungen erfüllen: Weitere Informationen finden Sie unter VPC-Netzwerke erstellen und verwalten.
  4. Wenn Sie möchten, dass ein Job in einem Subnetz eines freigegebene VPC-Netzwerks die von einem anderen Projekt gehostet werden, Batch-Dienst-Agent muss die Berechtigung zur Verwendung dieses Subnetzes erhalten haben.

    Damit der Batch-Dienst-Agent Ihres Projekts die erforderlichen Berechtigungen zum Erstellen eines Jobs hat, der in einem Subnetz eines freigegebenen VPC-Netzwerks ausgeführt wird, bitten Sie Ihren Administrator, dem Batch-Dienst-Agent Ihres Projekts die IAM-Rolle Compute Network User (roles/compute.networkUser) für das Subnetz der freigegebenen VPC zuzuweisen.

    Weitere Informationen finden Sie in der Dokumentation zum Einrichten einer freigegebenen VPC für Dienstkonten.

Job erstellen, der in einem bestimmten Netzwerk ausgeführt wird

Geben Sie das Netzwerk für einen Job an, wenn Sie ihn erstellen. Insbesondere müssen Sie ein VPC-Netzwerk und einen Subnetz enthält, in dem Sie diesen Job ausführen möchten.

Wenn Sie beim Erstellen dieses Jobs eine VM-Instanzvorlage verwenden möchten, müssen Sie das Netzwerk in der VM-Instanzvorlage angeben. Andernfalls führen Sie die folgenden Schritte aus, um das Netzwerk für einen Job anzugeben, indem Sie über die gcloud CLI oder Batch API.

gcloud

Wenn Sie mit der gcloud CLI einen Job erstellen möchten, der in einem bestimmten Netzwerk ausgeführt wird, wählen Sie eine der folgenden Optionen aus:

Mit gcloud-Flags das Netzwerk für einen Job angeben

So erstellen Sie einen Job und geben mit gcloud-Flags das Netzwerk für den Job an: führen Sie die folgenden Schritte aus:

  1. Erstellen Sie eine JSON-Datei, die die Konfigurationsdetails Ihres Jobs enthält.

    Um beispielsweise einen einfachen Skriptjob zu erstellen, erstellen Sie eine JSON-Datei mit dem folgenden Inhalten.

    {
  "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. Erstellen Sie den Job mit dem Befehl gcloud batch jobs submit. Fügen Sie die Flags --network und --subnetwork ein, um das Netzwerk für den Job anzugeben.

    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

    Ersetzen Sie Folgendes:

    • JOB_NAME: der Name dieses Jobs.
    • LOCATION: die location für diesen Job an.
    • JSON_CONFIGURATION_FILE: der Pfad zur JSON-Datei mit den Konfigurationsdetails des Jobs.
    • HOST_PROJECT_ID: die Projekt-ID des Projekts für das angegebene Netzwerk:
      • Wenn Sie ein freigegebene VPC-Netzwerk verwenden, geben Sie den Host an Projekt arbeiten.
      • Geben Sie andernfalls das aktuelle Projekt an.
    • NETWORK: Der Name eines VPC-Netzwerks im aktuellen Projekt oder eines freigegebenen VPC-Netzwerks, das vom aktuellen Projekt gehostet oder für dieses freigegeben wird.
    • REGION: die Region, in der sich das Subnetz und die VMs für den Job befinden:
      • Wenn Sie das Feld allowedLocations angeben, um den zulässigen Speicherort für die VMs für den Job anzugeben, müssen Sie hier dieselbe Region angeben.
      • Andernfalls muss die Region mit dem Standort übereinstimmen, den Sie für den Job ausgewählt haben (LOCATION).
    • SUBNET: der Name eines Subnetz, das Teil des VPC-Netzwerk und befindet sich in derselben Region wie die VMs für den Job

Netzwerk für einen Job mit JSON-Feldern angeben

So erstellst du einen Job und verwendest Felder in der JSON-Konfigurationsdatei, um das Netzwerk für den Job anzugeben:

  1. Erstellen Sie eine JSON-Datei mit den Konfigurationsdetails des Jobs. Fügen Sie zum Angeben des Netzwerks für den Job den Parameter network- und subnetwork-Felder:

    Wenn Sie beispielsweise einen einfachen Script-Job erstellen möchten, der in einem bestimmten Netzwerk ausgeführt wird, erstellen Sie eine JSON-Datei mit dem folgenden Inhalt.

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

    Ersetzen Sie Folgendes:

    • HOST_PROJECT_ID: die Projekt-ID des Projekts für das angegebene Netzwerk:
      • Wenn Sie ein freigegebenes VPC-Netzwerk verwenden, geben Sie das Hostprojekt an.
      • Geben Sie andernfalls das aktuelle Projekt an.
    • NETWORK: der Name eines VPC-Netzwerk im aktuellen Projekt oder ein freigegebenes VPC-Netzwerk das vom aktuellen Projekt gehostet wird oder für das aktuelle Projekt freigegeben wird.
    • REGION: die Region, in der sich das Subnetz und die VMs für den Job befinden:
      • Wenn Sie den Parameter Feld „allowedLocations“ um den zulässigen Standort für die VMs für den Job anzugeben, muss hier dieselbe Region angeben.
      • Andernfalls muss die Region mit dem Standort übereinstimmen, den Sie für den Job ausgewählt haben (LOCATION).
    • SUBNET: der Name eines Subnetz, das Teil des VPC-Netzwerk und befindet sich in derselben Region wie der VMs für den Job

  2. Erstellen Sie den Job mit dem Befehl gcloud batch jobs submit.

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

    Ersetzen Sie Folgendes:

    • JOB_NAME: Der Name für diesen Job.
    • LOCATION: den Speicherort für diese Aufgabe.
    • JSON_CONFIGURATION_FILE: der Pfad für den JSON-Datei mit den Konfigurationsdetails des Jobs.

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

Verwenden Sie zum Erstellen eines Jobs mit der Batch API die Methode jobs.create-Methode und geben Sie die Konfigurationsdetails des Jobs an. Geben Sie das Netzwerk für den Job an, indem Sie die Felder network und subnetwork einfügen.

Um beispielsweise einen einfachen Skriptjob zu erstellen, Netzwerk suchen, stellen Sie die folgende POST-Anfrage:

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: die Projekt-ID Ihres Projekts.
  • LOCATION: den Speicherort für diese Aufgabe.
  • JOB_NAME: Der Name für diesen Job.
  • HOST_PROJECT_ID: die Projekt-ID des Projekts für das angegebene Netzwerk:
    • Wenn Sie ein freigegebene VPC-Netzwerk verwenden, geben Sie den Host an Projekt arbeiten.
    • Geben Sie andernfalls das aktuelle Projekt an (PROJECT_ID).
  • NETWORK: der Name eines VPC-Netzwerk im aktuellen Projekt oder ein freigegebenes VPC-Netzwerk das vom aktuellen Projekt gehostet wird oder für das aktuelle Projekt freigegeben wird.
  • REGION: die Region, in der das Subnetz und die VMs für den Job befinden:
    • Wenn Sie den Parameter Feld „allowedLocations“ um den zulässigen Standort für die VMs für den Job anzugeben, muss hier dieselbe Region angeben.
    • Andernfalls muss die Region mit der im Standort, den Sie für den Job auswählen (LOCATION).
  • SUBNET: der Name eines Subnetz, das Teil des VPC-Netzwerk und befindet sich in derselben Region wie der VMs für den Job

Nächste Schritte