基本ジョブを作成して実行する

このドキュメントでは、バッチジョブの作成の基本について説明します。スクリプトまたはコンテナ イメージに基づくジョブを作成、実行し、事前定義された変数とカスタム変数を使用する方法です。ジョブの作成と実行の詳細については、ジョブの作成と実行の概要をご覧ください。

始める前に

  • Batch を以前に使用したことがなかった場合は、Batch を使ってみるを確認し、プロジェクトとユーザーの前提条件を完了して Batch を有効にします。

  • ジョブの作成に必要な権限を取得するには、次の IAM ロールを付与するよう管理者に依頼してください。

    ロールの付与の詳細については、アクセスの管理をご覧ください。

    必要な権限は、カスタムロールや他の事前定義ロールから取得することもできます。

  • ジョブを作成するたびに、ジョブに有効なネットワーク構成があることを確認してください。
    • ワークロードまたはプロジェクトに特定のネットワーク要件がなく、プロジェクトのデフォルト ネットワークを変更していない場合は、何もする必要はありません。
    • それ以外の場合は、ジョブの作成時にネットワークを構成する必要があります。基本的なジョブを作成する前に、ジョブにネットワークを構成する方法を確認します。これにより、ネットワーク要件を満たすように以下の例を変更できます。
    ジョブのネットワーク構成の詳細については、バッチ ネットワーキングの概要をご覧ください。
  • ジョブを作成するたびに、ジョブに有効な VM オペレーティング システム（OS）環境があることを確認してください。
    • ワークロードまたはプロジェクトに特定の VM OS イメージまたはブートディスクの要件がない場合は、何もする必要はありません。
    • それ以外の場合は、有効な VM OS 環境オプションを準備する必要があります。基本ジョブを作成する前に、VM OS 環境のデフォルト構成を許可するか、VM OS 環境をカスタマイズする方法を学ぶことで、要件を満たすように以下の例を変更できます。
    ジョブの VM OS 環境の詳細については、VM OS 環境の概要をご覧ください。

基本的なジョブを作成する

ジョブに指定できるすべてのフィールドの詳細については、projects.locations.jobs REST リソースのリファレンス ドキュメントをご覧ください。要するに、すべてがジョブの実行可能なスクリプトやコンテナである実行可能物を 1 つ以上実行する 1 つ以上のタスクの配列で、ジョブは構成されます。基本を網羅するため、このセクションでは、スクリプトまたはコンテナ イメージのいずれかである実行可能物を 1 つだけ使用して、サンプルジョブを作成する方法について説明します。

  • バッチを使用してコンテナ イメージを実行するジョブを作成する場合は、コンテナ ジョブを作成するをご覧ください。
  • それ以外で、コンテナ イメージを使用するかどうか不明な場合、またはコンテナに精通していない場合は、スクリプト ジョブの作成をおすすめします。

両方の種類のサンプルジョブには、4 つのタスクの配列を含むタスクグループがあります。各タスクでは、メッセージとそのインデックスが標準出力と Cloud Logging に出力されます。このジョブの定義では、並列処理を 2 に指定しています。これは、ジョブを 2 つの VM で実行して、一度に 2 つのタスクを実行できるようにする必要があることを示しています。

基本コンテナジョブを作成する

コンテナ イメージを選択または作成して、あらゆるコンピューティング環境から実行するジョブのコードと依存関係を指定できます。詳細については、コンテナ イメージの操作と VM インスタンスでのコンテナの実行をご覧ください。

基本コンテナジョブは、Google Cloud コンソール、gcloud CLI、Batch API、Go、Java、Node.js、Python、C++ を使用して作成できます。

コンソール

Google Cloud コンソールを使用して基本コンテナジョブを作成するには、次のようにします。

  1. Google Cloud コンソールで、[ジョブリスト] ページに移動します。

    ジョブリストに移動する

  2. [ 作成] をクリックします。[バッチジョブを作成する] ページが開きます。左側のペインで [ジョブの詳細] ページが選択されています。

  3. [ジョブの詳細] ページを構成します。

    1. 省略可: [ジョブ名] フィールドでジョブ名をカスタマイズします。

      たとえば、「example-basic-job」と入力します。

    2. [タスクの詳細] セクションを構成します。

      1. [新しい実行可能物] ウィンドウで、このジョブを実行するためのスクリプトまたはコンテナを少なくとも 1 つ追加します。

        たとえば、コンテナを 1 つ追加するには、次のようにします。

        1. [コンテナ イメージの URL]（デフォルト）を選択します。

        2. [コンテナ イメージの URL] フィールドに、このジョブの各タスクで実行するコンテナ イメージの URL を入力します。

          たとえば、busybox Docker コンテナ イメージを使用するには、次の URL を入力します。

          gcr.io/google-containers/busybox

        3. （省略可）コンテナ イメージの ENTRYPOINT コマンドをオーバーライドするには、[エントリ ポイント] フィールドにコマンドを入力します。

          たとえば、次のように入力します。

          /bin/sh

        4. （省略可）コンテナ イメージの CMD コマンドをオーバーライドするには、次の手順を行います。

          1. [コンテナ イメージの CMD コマンドをオーバーライドする] チェックボックスをオンにします。テキスト ボックスが表示されます。

          2. テキスト ボックスに 1 つ以上のコマンドを入力し、各コマンドを改行で区切ります。

            たとえば、次のコマンドを入力します。

            -c
echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.

          3. [完了] をクリックします。

      2. [タスク数] フィールドに、このジョブのタスクの数を入力します。値は 1 とタスクグループあたりのタスク数の上限の間の整数である必要があります。

        たとえば、「4」と入力します。

      3. [並列処理] フィールドに、同時に実行するタスクの数を入力します。この数は、タスクの合計数よりも大きくすることはできません。また、1 と ジョブあたりの並列タスクの上限の間の整数である必要があります。

        たとえば、「2」と入力します。

  4. [リソースの仕様] ページを構成します。

    1. 左側のペインで [リソースの仕様] をクリックします。[リソースの仕様] ページが開きます。

    2. [VM プロビジョニング モデル] セクションで、このジョブの VM のプロビジョニング モデルに対して、次のいずれかのオプションを選択します。

      • ジョブがプリエンプションに耐えることができて、削減した VM が必要な場合は、[スポット] を選択します。

      • それ以外の場合は、[標準] を選択します。

      たとえば、[標準]（デフォルト）を選択します。

    3. このジョブのロケーションを選択します。

      1. [リージョン] フィールドでリージョンを選択します。

        たとえば、us-central1 (Iowa)（デフォルト）を選択します。

      2. [ゾーン] フィールドで、次のいずれかを行います。

        • このジョブを特定のゾーンでのみ実行するように制限する場合は、ゾーンを選択します。

        • それ以外の場合は、[任意] を選択します。

        たとえば、[任意] を選択します（デフォルト）。

    4. 次のいずれかのマシン ファミリーを選択します。

      • 一般的なワークロードの場合は、[汎用] をクリックします。

      • 高いパフォーマンスが要求されるワークロードの場合は、[コンピューティング最適化] をクリックします。

      • メモリ使用量の多いワークロードの場合は、[メモリ最適化] をクリックします。

      たとえば、[汎用]（デフォルト）をクリックします。

    5. [シリーズ] フィールドで、このジョブの VM のマシンシリーズを選択します。

      たとえば、マシン ファミリーに [汎用] を選択した場合は、E2（デフォルト）を選択します。

    6. [マシンタイプ] フィールドで、このジョブの VM のマシンタイプを選択します。

      たとえば、マシンシリーズに E2 を選択した場合は、e2-medium（2 vCPU、4 GB メモリ）を選択します（デフォルト）。

    7. 各タスクに必要な VM リソースの量を構成します。

      1. [Cores] フィールドに、タスクあたりの vCPU の量を入力します。

        たとえば、「1」（デフォルト）と入力します。

      2. [メモリ] フィールドに、タスクあたりの RAM の容量を GB 単位で入力します。

        たとえば、「0.5」（デフォルト）と入力します。

  5. 省略可: ジョブの構成を確認するには、左側のペインで [プレビュー] をクリックします。

  6. [作成] をクリックします。

[ジョブの詳細] ページに、作成したジョブが表示されます。

gcloud

gcloud CLI を使用して基本コンテナ ジョブを作成するには、次のようにします。

  1. ジョブの構成の詳細を指定する JSON ファイルを作成します。たとえば、基本コンテナジョブを作成するには、次の内容の JSON ファイルを作成します。ジョブに指定できるすべてのフィールドの詳細については、projects.locations.jobs REST リソースのリファレンス ドキュメントをご覧ください。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            CONTAINER
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}

    以下を置き換えます。

    • CONTAINER: 各タスクで実行するコンテナ。
    • CORES: 省略可。ミリ CPU 単位で各タスクに割り当てるコア数（特に物理コアの半分を表す vCPUs）。cpuMilli フィールドが指定されていない場合、値は 2000（2 vCPU）に設定されます。
    • MEMORY: 省略可。各タスクに割り当てるメモリ容量（MB 単位）。memoryMib フィールドが指定されていない場合、値は 2000（2 GB）に設定されます。
    • MAX_RETRY_COUNT: 省略可。タスクの再試行の最大回数。値は 0 と 10 の間の整数にする必要があります。maxRetryCount フィールドが指定されていない場合、値は 0 に設定されます。これは、タスクを再試行しないということです。 maxRetryCount フィールドの詳細については、タスクの再試行を自動化するをご覧ください。
    • MAX_RUN_DURATION: 省略可。タスクが再試行または失敗するまでに実行できる最長時間。値は秒単位で、その後に s が続きます（例: 1 時間の場合は 3600s）。maxRunDuration フィールドが指定されていない場合、値はジョブの最大実行時間に設定されます。 maxRunDuration フィールドの詳細については、タイムアウトを使用してタスクと実行可能物の実行時間を制限するをご覧ください。
    • TASK_COUNT: 省略可。ジョブのタスクの数。値は 1 とタスクグループあたりのタスク数の上限の間の整数である必要があります。taskCount フィールドが指定されていない場合、値は 1 に設定されます。
    • PARALLELISM: 省略可。ジョブが同時に実行するタスクの数。この値は、タスクの数より大きくすることはできません。また、1 と ジョブあたりの並列タスクの上限の間の整数である必要があります。parallelism フィールドが指定されていない場合、値は 1 に設定されます。

  2. gcloud batch jobs submit コマンドを使用してジョブを作成します。

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

    以下を置き換えます。

    • JOB_NAME: ジョブの名前。
    • LOCATION: ジョブのロケーション。
    • JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

たとえば、busybox Docker コンテナ イメージを使用してタスクを実行するジョブを作成するには、次のようにします。

  1. hello-world-container.json という名前の現在のディレクトリに、次の内容の JSON ファイルを作成します。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            "imageUri": "gcr.io/google-containers/busybox",
                            "entrypoint": "/bin/sh",
                            "commands": [
                                "-c",
                                "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                            ]
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

  2. 次のコマンドを実行します。

    gcloud batch jobs submit example-container-job \
  --location us-central1 \
  --config hello-world-container.json

API

Batch API を使用して基本コンテナ ジョブを作成するには、jobs.create メソッドを使用します。ジョブに指定できるすべてのフィールドの詳細については、projects.locations.jobs REST リソースのリファレンス ドキュメントをご覧ください。

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            CONTAINER
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}

以下を置き換えます。

  • PROJECT_ID: プロジェクトのプロジェクト ID
  • LOCATION: ジョブのロケーション。
  • JOB_NAME: ジョブの名前。
  • CONTAINER: 各タスクで実行するコンテナ。
  • CORES: 省略可。単位はミリ CPU 単位で各タスクに割り当てるコア数（特に物理コアの半分を表す vCPUs）。cpuMilli フィールドが指定されていない場合、値は 2000（2 vCPU）に設定されます。
  • MEMORY: 省略可。各タスクに割り当てるメモリ容量（MB 単位）。memoryMib フィールドが指定されていない場合、値は 2000（2 GB）に設定されます。
  • MAX_RETRY_COUNT: 省略可。タスクの再試行の最大回数。値は 0 と 10 の間の整数にする必要があります。maxRetryCount フィールドが指定されていない場合、値は 0 に設定されます。これは、タスクを再試行しないということです。 maxRetryCount フィールドの詳細については、タスクの再試行を自動化するをご覧ください。
  • MAX_RUN_DURATION: 省略可。タスクが再試行または失敗するまでに実行できる最長時間。値は秒単位で、その後に s が続きます（例: 1 時間の場合は 3600s）。maxRunDuration フィールドが指定されていない場合、値はジョブの最大実行時間に設定されます。 maxRunDuration フィールドの詳細については、タイムアウトを使用してタスクと実行可能物の実行時間を制限するをご覧ください。
  • TASK_COUNT: 省略可。ジョブのタスク数で、1 と タスクグループあたりのタスク数の上限の間の整数である必要があります。taskCount フィールドが指定されていない場合、値は 1 に設定されます。
  • PARALLELISM: 省略可。ジョブが同時に実行するタスクの数。この値は、タスクの数より大きくすることはできません。また、1 と ジョブあたりの並列タスクの上限の間の整数である必要があります。parallelism フィールドが指定されていない場合、値は 1 に設定されます。

たとえば、busybox Docker コンテナ イメージを使用してタスクを実行するジョブを作成するには、次のリクエストを使用します。

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/jobs?job_id=example-container-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "container": {
                            "imageUri": "gcr.io/google-containers/busybox",
                            "entrypoint": "/bin/sh",
                            "commands": [
                                "-c",
                                "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                            ]
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

PROJECT_ID はプロジェクトのプロジェクト ID です。

Go

Go

詳細については、Batch Go API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that runs the specified container
func createContainerJob(w io.Writer, projectID, region, jobName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	container := &batchpb.Runnable_Container{
		ImageUri:   "gcr.io/google-containers/busybox",
		Commands:   []string{"-c", "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."},
		Entrypoint: "/bin/sh",
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 2 whole CPUs.
		CpuMilli:  2000,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Container_{Container: container},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// 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 := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "container"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Java

詳細については、Batch Java API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.ComputeResource;
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.Container;
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 CreateWithContainerNoMounting {

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

    createContainerJob(projectId, region, jobName);
  }

  // This method shows how to create a sample Batch Job that will run a simple command inside a
  // container on Cloud Compute instances.
  public static void createContainerJob(String projectId, String region, String jobName)
      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. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {

      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setContainer(
                  Container.newBuilder()
                      .setImageUri("gcr.io/google-containers/busybox")
                      .setEntrypoint("/bin/sh")
                      .addCommands("-c")
                      .addCommands(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                              + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      .build())
              .build();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 2 whole CPUs.
              .setCpuMilli(2000)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .setComputeResource(computeResource)
              .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(4).setTaskSpec(task).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
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

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

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

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .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());
    }
  }
}

Node.js

Node.js

詳細については、Batch Node.js API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';

// 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();

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.container = new batch.Runnable.Container();
runnable.container.imageUri = 'gcr.io/google-containers/busybox';
runnable.container.entrypoint = '/bin/sh';
runnable.container.commands = [
  '-c',
  'echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.',
];
task.runnables = [runnable];

// We can specify what resources are requested by each task.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.taskSpec = 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
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'container'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.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 callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

callCreateJob();

Python

Python

詳細については、Batch Python API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

from google.cloud import batch_v1

def create_container_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command inside a container on Cloud Compute instances.

    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/get-started#locations
        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.container = batch_v1.Runnable.Container()
    runnable.container.image_uri = "gcr.io/google-containers/busybox"
    runnable.container.entrypoint = "/bin/sh"
    runnable.container.commands = [
        "-c",
        "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 = 4
    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]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # 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)

C++

C++

詳細については、Batch C++ API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            container {
              image_uri: "gcr.io/google-containers/busybox"
              entrypoint: "/bin/sh"
              commands: "-c"
              commands: "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "container" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

基本スクリプト ジョブを作成する

基本スクリプト ジョブは、Google Cloud コンソール、gcloud CLI、Batch API、Go、Java、Node.js、Python、C++ を使用して作成できます。

コンソール

Google Cloud コンソールを使用して基本スクリプト ジョブを作成するには、次のようにします。

  1. Google Cloud コンソールで、[ジョブリスト] ページに移動します。

    ジョブリストに移動する

  2. [ 作成] をクリックします。[バッチジョブを作成する] ページが開きます。左側のペインで [ジョブの詳細] ページが選択されています。

  3. [ジョブの詳細] ページを構成します。

    1. 省略可: [ジョブ名] フィールドでジョブ名をカスタマイズします。

      たとえば、「example-basic-job」と入力します。

    2. [タスクの詳細] セクションを構成します。

      1. [新しい実行可能物] ウィンドウで、このジョブを実行するためのスクリプトまたはコンテナを少なくとも 1 つ追加します。

        たとえば、1 つのスクリプトを追加するには、次のようにします。

        1. [スクリプト] を選択します。テキスト ボックスが表示されます。

        2. テキスト ボックスに、このジョブの各タスクで実行するスクリプトを入力します。

          たとえば、次のスクリプトを入力します。

          echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks.

        3. [完了] をクリックします。

      2. [タスク数] フィールドに、このジョブのタスクの数を入力します。値は 1 とタスクグループあたりのタスク数の上限の間の整数である必要があります。

        たとえば、「4」と入力します。

      3. [並列処理] フィールドに、同時に実行するタスクの数を入力します。この数は、タスクの合計数よりも大きくすることはできません。また、1 と ジョブあたりの並列タスクの上限の間の整数である必要があります。

        たとえば、「2」と入力します。

  4. [リソースの仕様] ページを構成します。

    1. 左側のペインで [リソースの仕様] をクリックします。[リソースの仕様] ページが開きます。

    2. [VM プロビジョニング モデル] セクションで、このジョブの VM のプロビジョニング モデルに対して、次のいずれかのオプションを選択します。

      • ジョブがプリエンプションに耐えることができて、削減した VM が必要な場合は、[スポット] を選択します。

      • それ以外の場合は、[標準] を選択します。

      たとえば、[標準]（デフォルト）を選択します。

    3. このジョブのロケーションを選択します。

      1. [リージョン] フィールドでリージョンを選択します。

        たとえば、us-central1 (Iowa)（デフォルト）を選択します。

      2. [ゾーン] フィールドで、次のいずれかを行います。

        • このジョブを特定のゾーンでのみ実行するように制限する場合は、ゾーンを選択します。

        • それ以外の場合は、[任意] を選択します。

        たとえば、[任意] を選択します（デフォルト）。

    4. 次のいずれかのマシン ファミリーを選択します。

      • 一般的なワークロードの場合は、[汎用] をクリックします。

      • 高いパフォーマンスが要求されるワークロードの場合は、[コンピューティング最適化] をクリックします。

      • メモリ使用量の多いワークロードの場合は、[メモリ最適化] をクリックします。

      たとえば、[汎用]（デフォルト）をクリックします。

    5. [シリーズ] フィールドで、このジョブの VM のマシンシリーズを選択します。

      たとえば、マシン ファミリーに [汎用] を選択した場合は、E2（デフォルト）を選択します。

    6. [マシンタイプ] フィールドで、このジョブの VM のマシンタイプを選択します。

      たとえば、マシンシリーズに E2 を選択した場合は、e2-medium（2 vCPU、4 GB メモリ）を選択します（デフォルト）。

    7. 各タスクに必要な VM リソースの量を構成します。

      1. [Cores] フィールドに、タスクあたりの vCPU の量を入力します。

        たとえば、「1」（デフォルト）と入力します。

      2. [メモリ] フィールドに、タスクあたりの RAM の容量を GB 単位で入力します。

        たとえば、「0.5」（デフォルト）と入力します。

  5. 省略可: ジョブの構成を確認するには、左側のペインで [プレビュー] をクリックします。

  6. [作成] をクリックします。

[ジョブの詳細] ページに、作成したジョブが表示されます。

gcloud

gcloud CLI を使用して基本スクリプト ジョブを作成するには、次のようにします。

  1. ジョブの構成の詳細を指定する JSON ファイルを作成します。たとえば、基本スクリプト ジョブを作成するには、次の内容の JSON ファイルを作成します。ジョブに指定できるすべてのフィールドの詳細については、projects.locations.jobs REST リソースのリファレンス ドキュメントをご覧ください。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}

    以下を置き換えます。

    • SCRIPT: 各タスクで実行するスクリプト。
    • CORES: 省略可。ミリ CPU 単位で各タスクに割り当てるコア数（特に物理コアの半分を表す vCPUs）。cpuMilli フィールドが指定されていない場合、値は 2000（2 vCPU）に設定されます。
    • MEMORY: 省略可。各タスクに割り当てるメモリ容量（MB 単位）。memoryMib フィールドが指定されていない場合、値は 2000（2 GB）に設定されます。
    • MAX_RETRY_COUNT: 省略可。タスクの再試行の最大回数。値は 0 と 10 の間の整数にする必要があります。maxRetryCount フィールドが指定されていない場合、値は 0 に設定されます。これは、タスクを再試行しないということです。 maxRetryCount フィールドの詳細については、タスクの再試行を自動化するをご覧ください。
    • MAX_RUN_DURATION: 省略可。タスクが再試行または失敗するまでに実行できる最長時間。値は秒単位で、その後に s が続きます（例: 1 時間の場合は 3600s）。maxRunDuration フィールドが指定されていない場合、値はジョブの最大実行時間に設定されます。 maxRunDuration フィールドの詳細については、タイムアウトを使用してタスクと実行可能物の実行時間を制限するをご覧ください。
    • TASK_COUNT: 省略可。ジョブのタスクの数。値は 1 とタスクグループあたりのタスク数の上限の間の整数である必要があります。taskCount フィールドが指定されていない場合、値は 1 に設定されます。
    • PARALLELISM: 省略可。ジョブが同時に実行するタスクの数。この値は、タスクの数より大きくすることはできません。また、1 と ジョブあたりの並列タスクの上限の間の整数である必要があります。parallelism フィールドが指定されていない場合、値は 1 に設定されます。

  2. gcloud batch jobs submit コマンドを使用してジョブを作成します。

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

    以下を置き換えます。

    • JOB_NAME: ジョブの名前。
    • LOCATION: ジョブのロケーション。
    • JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

たとえば、スクリプトを使用してタスクを実行するジョブを作成するには、次のようにします。

  1. hello-world-script.json という名前の現在のディレクトリに、次の内容の JSON ファイルを作成します。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

  2. 次のコマンドを実行します。

    gcloud batch jobs submit example-script-job \
  --location us-central1 \
  --config hello-world-script.json

API

Batch API を使用して基本スクリプト ジョブを作成するには、jobs.create メソッドを使用します。ジョブに指定できるすべてのフィールドの詳細については、projects.locations.jobs REST リソースのリファレンス ドキュメントをご覧ください。

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": CORES,
                    "memoryMib": MEMORY
                },
                "maxRetryCount": MAX_RETRY_COUNT,
                "maxRunDuration": "MAX_RUN_DURATION"
            },
            "taskCount": TASK_COUNT,
            "parallelism": PARALLELISM
        }
    ]
}

以下を置き換えます。

  • PROJECT_ID: プロジェクトのプロジェクト ID
  • LOCATION: ジョブのロケーション。
  • JOB_NAME: ジョブの名前。
  • SCRIPT: 各タスクで実行するスクリプト。
  • CORES: 省略可。単位はミリ CPU 単位で各タスクに割り当てるコア数（特に物理コアの半分を表す vCPUs）。cpuMilli フィールドが指定されていない場合、値は 2000（2 vCPU）に設定されます。
  • MEMORY: 省略可。各タスクに割り当てるメモリ容量（MB 単位）。memoryMib フィールドが指定されていない場合、値は 2000（2 GB）に設定されます。
  • MAX_RETRY_COUNT: 省略可。タスクの再試行の最大回数。値は 0 と 10 の間の整数にする必要があります。maxRetryCount フィールドが指定されていない場合、値は 0 に設定されます。これは、タスクを再試行しないということです。 maxRetryCount フィールドの詳細については、タスクの再試行を自動化するをご覧ください。
  • MAX_RUN_DURATION: 省略可。タスクが再試行または失敗するまでに実行できる最長時間。値は秒単位で、その後に s が続きます（例: 1 時間の場合は 3600s）。maxRunDuration フィールドが指定されていない場合、値はジョブの最大実行時間に設定されます。 maxRunDuration フィールドの詳細については、タイムアウトを使用してタスクと実行可能物の実行時間を制限するをご覧ください。
  • TASK_COUNT: 省略可。ジョブのタスクの数。値は 1 とタスクグループあたりのタスク数の上限の間の整数である必要があります。taskCount フィールドが指定されていない場合、値は 1 に設定されます。
  • PARALLELISM: 省略可。ジョブが同時に実行するタスクの数。この値は、タスクの数より大きくすることはできません。また、1 と ジョブあたりの並列タスクの上限の間の整数である必要があります。parallelism フィールドが指定されていない場合、値は 1 に設定されます。

たとえば、スクリプトを使用してタスクを実行するジョブを作成するには、次のリクエストを使用します。

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/jobs?job_id=example-script-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                },
                "maxRetryCount": 2,
                "maxRunDuration": "3600s"
            },
            "taskCount": 4,
            "parallelism": 2
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    },
    "labels": {
        "department": "finance",
        "env": "testing"
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

PROJECT_ID はプロジェクトのプロジェクト ID です。

Go

Go

詳細については、Batch Go API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

import (
	"context"
	"fmt"
	"io"

	batch "cloud.google.com/go/batch/apiv1"
	"cloud.google.com/go/batch/apiv1/batchpb"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
)

// Creates and runs a job that executes the specified script
func createScriptJob(w io.Writer, projectID, region, jobName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"

	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", err)
	}
	defer batchClient.Close()

	// Define what will be done as part of the job.
	command := &batchpb.Runnable_Script_Text{
		Text: "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 runnable.script.text and runnable.script.path is mutually exclusive.
	// command := &batchpb.Runnable_Script_Path{
	// 	Path: "/tmp/test.sh",
	// }

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 2 whole CPUs.
		CpuMilli:  2000,
		MemoryMib: 16,
	}

	taskSpec := &batchpb.TaskSpec{
		Runnables: []*batchpb.Runnable{{
			Executable: &batchpb.Runnable_Script_{
				Script: &batchpb.Runnable_Script{Command: command},
			},
		}},
		ComputeResource: resources,
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
	}

	// Tasks are grouped inside a job using TaskGroups.
	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

	// 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 := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "e2-standard-4",
				},
			},
		}},
	}

	// We use Cloud Logging as it's an out of the box available option
	logsPolicy := &batchpb.LogsPolicy{
		Destination: batchpb.LogsPolicy_CLOUD_LOGGING,
	}

	jobLabels := map[string]string{"env": "testing", "type": "script"}

	// The job's parent is the region in which the job will run
	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, region)

	job := batchpb.Job{
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           jobLabels,
		LogsPolicy:       logsPolicy,
	}

	req := &batchpb.CreateJobRequest{
		Parent: parent,
		JobId:  jobName,
		Job:    &job,
	}

	created_job, err := batchClient.CreateJob(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create job: %w", err)
	}

	fmt.Fprintf(w, "Job created: %v\n", created_job)

	return nil
}

Java

Java

詳細については、Batch Java API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.BatchServiceClient;
import com.google.cloud.batch.v1.ComputeResource;
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 CreateWithScriptNoMounting {

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

    createScriptJob(projectId, region, jobName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJob(String projectId, String region, String jobName)
      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. After completing all of your requests, call
    // the `batchServiceClient.close()` method on the client to safely
    // clean up any remaining background resources.
    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();

      // We can specify what resources are requested by each task.
      ComputeResource computeResource =
          ComputeResource.newBuilder()
              // In milliseconds per cpu-second. This means the task requires 2 whole CPUs.
              .setCpuMilli(2000)
              // In MiB.
              .setMemoryMib(16)
              .build();

      TaskSpec task =
          TaskSpec.newBuilder()
              // Jobs can be divided into tasks. In this case, we have only one task.
              .addRunnables(runnable)
              .setComputeResource(computeResource)
              .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(4).setTaskSpec(task).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
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

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

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

      CreateJobRequest createJobRequest =
          CreateJobRequest.newBuilder()
              // The job's parent is the region in which the job will run.
              .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());
    }
  }
}

Node.js

Node.js

詳細については、Batch Node.js API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
/**
 * The region you want to the job to run in. The regions that support Batch are listed here:
 * https://cloud.google.com/batch/docs/get-started#locations
 */
// const region = 'us-central-1';
/**
 * The name of the job that will be created.
 * It needs to be unique for each project and region pair.
 */
// const jobName = 'YOUR_JOB_NAME';

// 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();

// Define what will be done as part of the job.
const task = new batch.TaskSpec();
const runnable = new batch.Runnable();
runnable.script = new batch.Runnable.Script();
runnable.script.text =
  '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 runnable.script.text and runnable.script.path is mutually
// exclusive.
// runnable.script.path = '/tmp/test.sh'
task.runnables = [runnable];

// We can specify what resources are requested by each task.
const resources = new batch.ComputeResource();
resources.cpuMilli = 2000; // in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
resources.memoryMib = 16;
task.computeResource = resources;

task.maxRetryCount = 2;
task.maxRunDuration = {seconds: 3600};

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup();
group.taskCount = 4;
group.taskSpec = 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
const allocationPolicy = new batch.AllocationPolicy();
const policy = new batch.AllocationPolicy.InstancePolicy();
policy.machineType = 'e2-standard-4';
const instances = new batch.AllocationPolicy.InstancePolicyOrTemplate();
instances.policy = policy;
allocationPolicy.instances = [instances];

const job = new batch.Job();
job.name = jobName;
job.taskGroups = [group];
job.allocationPolicy = allocationPolicy;
job.labels = {env: 'testing', type: 'script'};
// We use Cloud Logging as it's an option available out of the box
job.logsPolicy = new batch.LogsPolicy();
job.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 callCreateJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

callCreateJob();

Python

Python

詳細については、Batch Python API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

from google.cloud import batch_v1

def create_script_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances.

    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/get-started#locations
        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.
    task = batch_v1.TaskSpec()
    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."
    # 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 runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    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
    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 = 4
    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
    allocation_policy = batch_v1.AllocationPolicy()
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "e2-standard-4"
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}
    # 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)

C++

C++

詳細については、Batch C++ API のリファレンス ドキュメントをご覧ください。

Batch への認証を行うには、アプリケーションのデフォルト認証情報を設定します。詳細については、ローカル開発環境の認証の設定をご覧ください。

#include "google/cloud/batch/v1/batch_client.h"

  [](std::string const& project_id, std::string const& location_id,
     std::string const& job_id) {
    // Initialize the request; start with the fields that depend on the sample
    // input.
    google::cloud::batch::v1::CreateJobRequest request;
    request.set_parent("projects/" + project_id + "/locations/" + location_id);
    request.set_job_id(job_id);
    // Most of the job description is fixed in this example; use a string to
    // initialize it.
    auto constexpr kText = R"pb(
      task_groups {
        task_count: 4
        task_spec {
          compute_resource { cpu_milli: 500 memory_mib: 16 }
          max_retry_count: 2
          max_run_duration { seconds: 3600 }
          runnables {
            script {
              text: "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
            }
          }
        }
      }
      allocation_policy {
        instances {
          policy { machine_type: "e2-standard-4" provisioning_model: STANDARD }
        }
      }
      labels { key: "env" value: "testing" }
      labels { key: "type" value: "script" }
      logs_policy { destination: CLOUD_LOGGING }
    )pb";
    auto* job = request.mutable_job();
    if (!google::protobuf::TextFormat::ParseFromString(kText, job)) {
      throw std::runtime_error("Error parsing Job description");
    }
    // Create a client and issue the request.
    auto client = google::cloud::batch_v1::BatchServiceClient(
        google::cloud::batch_v1::MakeBatchServiceConnection());
    auto response = client.CreateJob(request);
    if (!response) throw std::move(response).status();
    std::cout << "Job : " << response->DebugString() << "\n";
  }

環境変数を使用する

ジョブを実行するコンテナ イメージまたはスクリプトを作成する際に、環境変数を使用します。すべてのバッチジョブに事前に定義されたあらゆる環境変数と、ジョブの作成中に定義したあらゆるカスタム環境変数を使用できます。

事前定義された環境変数を使用する

デフォルトでは、ジョブの実行可能物は、次の事前定義された環境変数を使用できます。

  • BATCH_TASK_COUNT: このタスクグループのタスクの合計数。
  • BATCH_TASK_INDEX: タスクグループ内のこのタスクのインデックス番号。最初のタスクのインデックスは 0 で、追加のタスクごとに増加します。
  • BATCH_HOSTS_FILE: このタスクグループで実行中のすべての VM インスタンスを一覧表示するファイルのパス。この環境変数を使用するには、requireHostsFile フィールドを true に設定する必要があります。
  • BATCH_TASK_RETRY_ATTEMPT: このタスクがすでに試行された回数。タスクの最初の試行では、値が 0 になり、次の再試行ごとに増加します。タスクで許可される再試行の合計回数は、maxRetryCount フィールドの値によって決まります。未定義の場合は 0 になります。再試行の詳細については、タスクの再試行を自動化するをご覧ください。

事前定義された環境変数を使用する方法の例については、このドキュメントの基本ジョブを作成するでの実行可能物な前例をご覧ください。

カスタム環境変数を定義して使用する

必要に応じて、1 つ以上のジョブにカスタム環境変数を定義できます。

各変数は、必要なデータ範囲に基づいて特定の環境で定義します。

選択した環境では、次のいずれかの環境サブフィールドのいずれかを使用して、各変数の名前と値を定義します。

gcloud CLI または Batch API を使用して、ジョブにカスタム環境変数を定義して使用できます。次の例は、標準変数を定義して使用する 2 つのジョブを作成する方法を示しています。最初のサンプルジョブには、特定の実行可能物の変数があります。2 番目のジョブの例には、タスクごとに異なる値を持つ配列変数があります。

gcloud

各タスクが実行される実行可能ファイルに環境変数を渡すジョブを定義する場合は、実行可能環境変数を定義、使用するの例をご覧ください。それ以外で、タスクのインデックスに基づいて環境変数のリストを異なるタスクに渡すジョブを定義する場合は、タスクごとに環境変数を定義して使用する方法の例をご覧ください。

実行可能環境変数を定義、使用する

gcloud CLI を使用して環境変数を実行可能物に渡すジョブを作成するには、gcloud batch jobs submit コマンドを使用し、ジョブの構成ファイルで環境変数を指定します。

たとえば、環境変数を定義するスクリプト ジョブを作成して、それを 3 つのタスクのスクリプトに渡すには、次のリクエストを行います。

  1. hello-world-environment-variables.json という名前の現在のディレクトリに、次の内容の JSON ファイルを作成します。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                        "environment": {
                            "variables": {
                                "VARIABLE_NAME": "VARIABLE_VALUE"
                            }
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": "e2-standard-4"
                }
            }
        ]
    }
}

    以下を置き換えます。

    • VARIABLE_NAME: 各タスクに渡される環境変数の名前。慣例により、環境変数名は大文字です。
    • VARIABLE_VALUE: 省略可。各タスクに渡される環境変数の値。

  2. 次のコマンドを実行します。

    gcloud batch jobs submit example-environment-variables-job \
  --location us-central1 \
  --config hello-world-environment-variables.json

タスクごとの環境変数を定義して使用する

gcloud CLI を使用してタスク インデックスに基づいて環境変数をタスクに渡すジョブを作成するには、gcloud batch jobs submit コマンドを使用してジョブの構成ファイル内で taskEnvironments 配列項目を指定します。

たとえば、一致する名前と異なる値を持つ 3 つの環境変数の配列を含むジョブを作成し、インデックスが配列内の環境変数のインデックスと一致するタスクのスクリプトに環境変数を渡すには

  1. hello-world-task-environment-variables.json という名前の現在のディレクトリに、次の内容の JSON ファイルを作成します。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${TASK_VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "taskEnvironments": [
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_0"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_1"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_2"
                    }
                }
            ]
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": "e2-standard-4"
                }
            }
        ]
    }
}

    以下を置き換えます。

    • TASK_VARIABLE_NAME: 一致するインデックスを持つタスクに渡されるタスク環境変数の名前。慣例により、環境変数名は大文字です。
    • TASK_VARIABLE_VALUE_0: 最初のタスクに渡される環境変数の値。BATCH_TASK_INDEX は 0 です。
    • TASK_VARIABLE_VALUE_1: 2 番目のタスクに渡される環境変数の値。BATCH_TASK_INDEX は 1 です。
    • TASK_VARIABLE_VALUE_2: 3 番目のタスクに渡される環境変数の値。BATCH_TASK_INDEX は 2 です。

  2. 次のコマンドを実行します。

    gcloud batch jobs submit example-task-environment-variables-job \
  --location us-central1 \
  --config hello-world-task-environment-variables.json

API

各タスクが実行される実行可能ファイルに環境変数を渡すジョブを定義する場合は、実行可能環境変数を定義、使用するの例をご覧ください。それ以外で、タスクのインデックスに基づいて環境変数のリストを異なるタスクに渡すジョブを定義する場合は、タスクごとに環境変数を定義して使用する方法の例をご覧ください。

実行可能環境変数を定義、使用する

Batch API を使用して環境変数を実行可能なジョブに渡すジョブを作成するには、gcloud batch jobs submit コマンドを使用して、environment フィールドに環境変数を指定します。

たとえば、環境変数を含むジョブを作成して、それを 3 つのタスクのスクリプトに渡すには、次のリクエストを行います。

POST https://batch.googleapis.com/v1/projects/<var>PROJECT_ID</var>/locations/us-central1/jobs?job_id=example-environment-variables-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                        "environment": {
                            "variables": {
                                "VARIABLE_NAME": "VARIABLE_VALUE"
                            }
                        }
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "parallelism": 1
        }

    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": "e2-standard-4"
                }
            }
        ]
    }
}

以下を置き換えます。

  • PROJECT_ID: プロジェクトのプロジェクト ID
  • VARIABLE_NAME: 各タスクに渡される環境変数の名前。慣例により、環境変数名は大文字です。
  • VARIABLE_VALUE: 各タスクに渡される環境変数の値。

タスクごとの環境変数を定義して使用する

Batch API を使用してタスク インデックスに基づいて環境変数をタスクに渡すジョブを作成するには、jobs.create メソッドを使用して、taskEnvironments 配列フィールドで環境変数を指定します。

たとえば、一致する名前と異なる値を持つ 3 つの環境変数の配列を含むジョブを作成し、インデックスに基づいて 3 つのタスクのスクリプトに環境変数を渡すには、次のリクエストを作成します。

POST https://batch.googleapis.com/v1/projects/<var>PROJECT_ID</var>/locations/us-central1/jobs?job_id=example-task-environment-variables-job

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello ${TASK_VARIABLE_NAME}! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
                        },
                    }
                ],
                "computeResource": {
                    "cpuMilli": 2000,
                    "memoryMib": 16
                }
            },
            "taskCount": 3,
            "taskEnvironments": [
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_0"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_1"
                    }
                },
                {
                    "variables": {
                        "TASK_VARIABLE_NAME": "TASK_VARIABLE_VALUE_2"
                    }
                }
            ]
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "policy": { "machineType": "e2-standard-4" }
            }
        ]
    }
}

以下を置き換えます。

  • PROJECT_ID: プロジェクトのプロジェクト ID
  • TASK_VARIABLE_NAME: 一致するインデックスを持つタスクに渡される環境変数の名前。慣例により、環境変数名は大文字です。
  • TASK_VARIABLE_VALUE_0: 最初のタスクに渡される環境変数の値。BATCH_TASK_INDEX は 0 です。
  • TASK_VARIABLE_VALUE_1: 2 番目のタスクに渡される環境変数の値。BATCH_TASK_INDEX は 1 です。
  • TASK_VARIABLE_VALUE_2: 3 番目のタスクに渡される環境変数の値。BATCH_TASK_INDEX は 2 です。

次のステップ