このページは Cloud Translation API によって翻訳されました。

ストレージボリュームを使用するジョブを作成して実行する

このドキュメントでは、1 つ以上の外部ストレージボリュームを使用する Batch ジョブを作成して実行する方法について説明します。外部ストレージオプションには、新規または既存の永続ディスク、新しいローカル SSD、既存の Cloud Storage バケット、Filestore ファイル共有などの既存のネットワークファイルシステム（NFS）があります。

外部ストレージボリュームを追加するかどうかにかかわらず、ジョブの各 Compute Engine VM にはブートディスクがあります。このディスクは、ジョブのオペレーティングシステム（OS）イメージと指示のストレージを提供します。ジョブのブートディスクの構成については、VM OS 環境の概要をご覧ください。

準備

Batch を以前に使用したことがない場合は、Batch を使ってみるを確認し、プロジェクトとユーザーの前提条件を完了して Batch を有効にします。
ジョブの作成に必要な権限を取得するには、次の IAM ロールを付与するよう管理者に依頼してください。
- プロジェクトに対する Batch ジョブ編集者（roles/batch.jobsEditor）
- ジョブのサービスアカウントのサービスアカウントユーザー（roles/iam.serviceAccountUser）。これは、デフォルトでは Compute Engine のデフォルトのサービスアカウントです。
- Cloud Storage バケットを使用するジョブを作成する: バケットに対する Storage オブジェクト閲覧者（roles/storage.objectViewer）
ロールの付与については、プロジェクト、フォルダ、組織へのアクセス権の管理をご覧ください。

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

ストレージボリュームを使用するジョブを作成する

必要に応じて、ジョブは次のタイプの外部ストレージボリュームのいずれかのうちの 1 つ以上を使用できます。すべてのタイプのストレージボリュームと、それぞれの相違と制限の詳細については、Compute Engine VM のストレージオプションのドキュメントをご覧ください。

永続ディスク: ゾーンまたはリージョン、永続ブロックストレージ
ローカル SSD: 高パフォーマンスかつ一時的なローカルブロックストレージ。
Cloud Storage バケット: 入手可能なオブジェクトストレージ
ネットワークファイルシステム（NFS） : ネットワークファイルシステムプロトコルに従う分散ファイルシステム（たとえば、Filestore ファイル共有）これは、 Google Cloudでホストされる高性能 NFS です。

ジョブが各ストレージボリュームを使用できるようにするには、ジョブの定義にそれを含めて、実行可能物にマウントパス（mountPath）を指定します。ストレージボリュームを使用するジョブを作成する方法を学習するには、次のセクションの 1 つ以上をご覧ください。

永続ディスクを使用する
ローカル SSD を使用する
Cloud Storage バケットを使用する
ネットワークファイルシステムを使用する

永続ディスクを使用する

永続ディスクを使用するジョブには次の制限があります。

すべての永続ディスク: すべての永続ディスクの制限を確認してください。

新規と既存の永続ディスク: ジョブ内の各永続ディスクは新規（ジョブで定義および作成された）と、既存（プロジェクトですでに作成されていて、ジョブで指定された）のいずれかでありえます。永続ディスクを使用するには、ジョブの VM にフォーマットしてマウントする必要があります。VM は永続ディスクと同じ場所に存在する必要があります。 Batch はジョブに含めた永続ディスクをマウントし、新しい永続ディスクをフォーマットしますが、ジョブで使用する既存の永続ディスクをフォーマットしてマウントを解除する必要があります。

サポートされるロケーションオプション、フォーマットオプション、マウントオプションは、次の表に示すように、新規の永続ディスクと既存の永続ディスクの間で異なります。

新規の永続ディスク既存の永続ディスク

書式設定オプション

	新規の永続ディスク	既存の永続ディスク
書式設定オプション	永続ディスクは、`ext4` ファイルシステムで自動的にフォーマットされます。	`ext4` ファイルシステムをジョブに使用する前に、永続ディスクをフォーマットする必要があります。
マウントオプション	すべてのオプションがサポートされています。	書き込み以外のすべてのオプションがサポートされています。これは、マルチライターモードの制限によるものです。永続ディスクをジョブに使用する前に、アタッチされている VM から永続ディスクを取り外す必要があります。
ロケーションのオプション	ゾーン永続ディスクを作成することのみできます。ジョブの任意の場所を選択できます。永続ディスクは、プロジェクトが実行されているゾーンに作成されます。	ゾーン永続ディスクとリージョン永続ディスクを選択できます。ジョブのロケーション（または、指定されている場合はジョブの許可されたロケーションのみ）を、ジョブの永続ディスクのすべてを含むロケーションのみに設定する必要があります。たとえば、ゾーン永続ディスクの場合、ジョブのロケーションは、ディスクのゾーンにする必要があります。リージョン永続ディスクの場合、ジョブのロケーションは、ディスクのリージョンと、ゾーンが指定されている場合、リージョン永続ディスクが配置されている特定のゾーンの一方または両方、のいずれかである必要があります。

永続ディスクは、ext4 ファイルシステムで自動的にフォーマットされます。

ext4 ファイルシステムをジョブに使用する前に、永続ディスクをフォーマットする必要があります。

マウントオプション

すべてのオプションがサポートされています。

書き込み以外のすべてのオプションがサポートされています。これは、マルチライターモードの制限によるものです。

永続ディスクをジョブに使用する前に、アタッチされている VM から永続ディスクを取り外す必要があります。

ロケーションのオプション

ゾーン永続ディスクを作成することのみできます。

ジョブの任意の場所を選択できます。永続ディスクは、プロジェクトが実行されているゾーンに作成されます。

ゾーン永続ディスクとリージョン永続ディスクを選択できます。

ジョブのロケーション（または、指定されている場合はジョブの許可されたロケーションのみ）を、ジョブの永続ディスクのすべてを含むロケーションのみに設定する必要があります。たとえば、ゾーン永続ディスクの場合、ジョブのロケーションは、ディスクのゾーンにする必要があります。リージョン永続ディスクの場合、ジョブのロケーションは、ディスクのリージョンと、ゾーンが指定されている場合、リージョン永続ディスクが配置されている特定のゾーンの一方または両方、のいずれかである必要があります。

インスタンステンプレート: このジョブの作成中に VM インスタンステンプレートを使用する場合は、インスタンステンプレートで、このジョブ用の任意の永続ディスクをアタッチする必要があります。それ以外で、インスタンステンプレートを使用しない場合は、ジョブ定義で任意の永続ディスクを直接アタッチする必要があります。

永続ディスクを使用するジョブは、Google Cloud コンソール、gcloud CLI、Batch API、C++、Go、Java、Node.js、Python を使用して作成できます。

コンソール

Google Cloud コンソールを使用して、次の例では、us-central1-a ゾーンにある既存のゾーン永続ディスクからファイルを読み取るスクリプトを実行するジョブを作成します。このスクリプトの例は、ジョブにルートディレクトリに example.txt という名前のテキストファイルを含むゾーン永続ディスクが存在することを前提としています。

（省略可）サンプルゾーン永続ディスクを作成する

サンプルスクリプトの実行に使用できるゾーン永続ディスクを作成する場合は、ジョブを作成する前に次の操作を行います。

example-disk という名前の新しい空の永続ディスクを us-central1-a ゾーンの Linux VM にアタッチし、VM に対してコマンドを実行してディスクをフォーマットしてマウントします。手順については、VM に永続ディスクを追加するをご覧ください。

まだ VM から切断しないでください。
永続ディスクに example.txt を作成するには、VM で次のコマンドを実行します。
1. 現在の作業ディレクトリを永続ディスクのルートディレクトリに変更するには、次のコマンドを入力します。
```
cd VM_MOUNT_PATH
```
  VM_MOUNT_PATH は、前の手順で永続ディスクがこの VM にマウントされたディレクトリのパス（/mnt/disks/example-disk など）に置き換えます。
2. Enter キーを押します。
3. example.txt という名前のファイルを作成して定義するには、次のコマンドを入力します。
```
cat > example.txt
```
4. Enter キーを押します。
5. ファイルの内容を入力します。たとえば、「Hello world!」と入力します。
6. ファイルを保存するには、Ctrl+D（macOS の場合は Command+D）を押します。
完了したら、VM から接続できます。
ディスクを VM から切断します。
- VM が不要になった場合は、VM を削除できます。これにより、永続ディスクが自動的に切り離されます。
- それ以外の場合は、永続ディスクを切断します。手順については、ブートディスクの切断と再接続を参照し、VM のブートディスクではなく、example-disk 永続ディスクを切断します。

既存のゾーン永続ディスクを使用するジョブを作成する

Google Cloud コンソールを使用して既存のゾーン永続ディスクを使用するジョブを作成するには、次の操作を行います。

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

ジョブリストに移動する
[ 作成] をクリックします。[バッチジョブを作成する] ページが開きます。左側のペインで、[ジョブの詳細] ページが選択されています。
[ジョブの詳細] ページを構成します。
1. 省略可: [ジョブ名] フィールドで、ジョブ名をカスタマイズします。
  
  たとえば、「example-disk-job」と入力します。
2. [タスクの詳細] セクションを構成します。
  1. [新しい実行可能物] ウィンドウで、このジョブを実行するためのスクリプトまたはコンテナを少なくとも 1 つ追加します。
    
    たとえば、example.txt という名前で、このジョブで使用する永続ディスクのルートディレクトリにあるファイルのコンテンツを出力するスクリプトを実行するには、次のようにします。
    1. [スクリプト] チェックボックスをオンにします。テキストボックスが表示されます。
    2. テキストボックスに次のスクリプトを入力します。
      echo "Here is the content of the example.txt file in the persistent disk." cat MOUNT_PATH/example.txt
      MOUNT_PATH は、このジョブの VM に永続ディスクをマウントする予定のパス（/mnt/disks/example-disk など）に置き換えます。
    3. [完了] をクリックします。
  2. [タスク数] フィールドに、このジョブのタスク数を入力します。
    
    たとえば、「1」（デフォルト）と入力します。
  3. [並列処理] フィールドに、同時に実行するタスクの数を入力します。
    
    たとえば、「1」（デフォルト）と入力します。
[リソースの仕様] ページを構成します。
1. 左側のペインで [リソースの仕様] をクリックします。[リソースの仕様] ページが開きます。
2. このジョブのロケーションを選択します。既存のゾーン永続ディスクを使用するには、ジョブの VM が同じゾーンに配置されている必要があります。
  1. [リージョン] フィールドでリージョンを選択します。
    
    たとえば、サンプルゾーン永続ディスクを使用するには、[us-central1 (Iowa)]（デフォルト）を選択します。
  2. [ゾーン] フィールドでゾーンを選択します。
    
    たとえば、us-central1-a (Iowa) を選択します。
[その他の構成] ページを構成します。
1. 左側のペインで [その他の構成] をクリックします。 [その他の構成] ページが開きます。
2. このジョブにマウントする既存のゾーン永続ディスクごとに、次の操作を行います。
  1. [ストレージボリューム] セクションで、[新しいボリュームを追加] をクリックします。 [新しいボリューム] ウィンドウが表示されます。
  2. [新しいボリューム] ウィンドウで、次の操作を行います。
    1. [ボリュームのタイプ] セクションで、[永続ディスク]（デフォルト）を選択します。
    2. [ディスク] リストで、このジョブにマウントする既存のゾーン永続ディスクを選択します。ディスクは、このジョブと同じゾーンに配置する必要があります。
      
      たとえば、用意しておいた既存のゾーン永続ディスクを選択します。この永続ディスクは us-central1-a ゾーンにあり、example.txt ファイルを含んでいる必要があります。
    3. 省略可: このゾーン永続ディスクの名前を変更する場合は、次の操作を行います。
      1. [デバイス名をカスタマイズする] を選択します。
      2. [デバイス名] フィールドに、ディスクの新しい名前を入力します。
    4. [マウントパス] フィールドに、この永続ディスクのマウントパス（MOUNT_PATH）を入力します。
      
      たとえば、次のように入力します。
      /mnt/disks/EXISTING_PERSISTENT_DISK_NAME
      EXISTING_PERSISTENT_DISK_NAME は、ディスクの名前に置き換えます。ゾーン永続ディスクの名前を変更した場合は、新しい名前を使用します。
      
      たとえば、EXISTING_PERSISTENT_DISK_NAME を example-disk に置き換えます。
    5. [完了] をクリックします。
省略可: このジョブの他のフィールドを構成します。
省略可: ジョブ構成を確認するには、左側のペインで [プレビュー] をクリックします。
[作成] をクリックします。

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

gcloud

次の例では、gcloud CLI を使用して、既存の永続ディスクと新しい永続ディスクをアタッチしてマウントするジョブを作成します。ジョブには 3 つのタスクがあり、それぞれが output_task_TASK_INDEX.txt という名前の新しい永続ディスクにファイルを作成するスクリプトを実行します。ここで TASK_INDEX は、各タスクのインデックス（0、1、2）です。

gcloud CLI を使用して永続ディスクを使用するジョブを作成するには、gcloud batch jobs submit コマンドを使用します。ジョブの JSON 構成ファイルで、instances フィールドに永続ディスクを指定し、volumes フィールドで永続ディスクをマウントします。

JSON ファイルを作成します。

このジョブにインスタンステンプレートを使用していない場合は、次の内容の JSON ファイルを作成します。

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

以下を置き換えます。

PROJECT_ID: プロジェクトのプロジェクト ID
EXISTING_PERSISTENT_DISK_NAME: 既存の永続ディスクの名前。
EXISTING_PERSISTENT_DISK_LOCATION: 既存の永続ディスクのロケーション。既存のゾーン永続ディスクの場合、ジョブのロケーションは、ディスクのゾーンにする必要があります。既存のリージョン永続ディスクごとに、ジョブのロケーションは、ディスクのリージョンと、ゾーンが指定されている場合、リージョン永続ディスクが配置されている特定のゾーンの一方または両方、のいずれかである必要があります。既存の永続ディスクを指定しない場合は、任意のロケーションを選択できます。allowedLocations フィールドの詳細。
NEW_PERSISTENT_DISK_SIZE: 新規の永続ディスクのサイズ（GB）。許可されるサイズは永続ディスクのタイプによって異なりますが、最小値はたいてい 10 GB（10）、最大値はたいてい 64 TB（64000）です。
NEW_PERSISTENT_DISK_TYPE: ディスクタイプ新しい永続ディスクの pd-standard、pd-balanced、pd-ssd、または pd-extreme のいずれかです。ブート以外の永続ディスクのデフォルトのディスクタイプは pd-standard です。
NEW_PERSISTENT_DISK_NAME: 新規の永続ディスクの名前。

このジョブ用の VM インスタンステンプレートを使用している場合、前述のとおり JSON ファイルを作成しますが、ただし instances フィールドは次のように置き換えます。
```
"instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
```
ここで、INSTANCE_TEMPLATE_NAME は、このジョブ用のインスタンステンプレートの名前です。永続ディスクを使用するジョブの場合、このインスタンステンプレートで、ジョブで使用する永続ディスクを定義してアタッチする必要があります。この例の場合、テンプレートで NEW_PERSISTENT_DISK_NAME という名前の新規の永続ディスクを定義してアタッチし、EXISTING_PERSISTENT_DISK_NAME という名前の既存の永続ディスクをアタッチする必要があります。

次のコマンドを実行します。
```
gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE
```
以下を置き換えます。
- JOB_NAME: ジョブの名前。
- LOCATION: ジョブのロケーション。
- JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

API

次の例では、Batch API を使用して、既存の永続ディスクと新しい永続ディスクをアタッチしてマウントするジョブを作成します。ジョブには 3 つのタスクがあり、それぞれが output_task_TASK_INDEX.txt という名前の新しい永続ディスクにファイルを作成するスクリプトを実行します。ここで TASK_INDEX は、各タスクのインデックス（0、1、2）です。

Batch API を使用して永続ディスクを使用するジョブを作成するには、jobs.create メソッドを使用します。リクエストで、instances フィールドに永続ディスクを指定し、volumes フィールドで永続ディスクをマウントします。

このジョブにインスタンステンプレートを使用していない場合は、次のリクエストを行います。

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

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "disks": [
                        {
                            "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                            "existingDisk": "projects/PROJECT_ID/EXISTING_PERSISTENT_DISK_LOCATION/disks/EXISTING_PERSISTENT_DISK_NAME"
                        },
                        {
                            "newDisk": {
                                "sizeGb": NEW_PERSISTENT_DISK_SIZE,
                                "type": "NEW_PERSISTENT_DISK_TYPE"
                            },
                            "deviceName": "NEW_PERSISTENT_DISK_NAME"
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "EXISTING_PERSISTENT_DISK_LOCATION"
            ]
        }
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "NEW_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/NEW_PERSISTENT_DISK_NAME",
                        "mountOptions": "rw,async"
                    },
                    {

                        "deviceName": "EXISTING_PERSISTENT_DISK_NAME",
                        "mountPath": "/mnt/disks/EXISTING_PERSISTENT_DISK_NAME"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

以下を置き換えます。

PROJECT_ID: プロジェクトのプロジェクト ID
LOCATION: ジョブのロケーション。
JOB_NAME: ジョブの名前。
EXISTING_PERSISTENT_DISK_NAME: 既存の永続ディスクの名前。
EXISTING_PERSISTENT_DISK_LOCATION: 既存の永続ディスクのロケーション。既存のゾーン永続ディスクの場合、ジョブのロケーションは、ディスクのゾーンにする必要があります。既存のリージョン永続ディスクごとに、ジョブのロケーションは、ディスクのリージョンと、ゾーンが指定されている場合、リージョン永続ディスクが配置されている特定のゾーンの一方または両方、のいずれかである必要があります。既存の永続ディスクを指定しない場合は、任意のロケーションを選択できます。allowedLocations フィールドの詳細。
NEW_PERSISTENT_DISK_SIZE: 新規の永続ディスクのサイズ（GB）。許可されるサイズは永続ディスクのタイプによって異なりますが、最小値はたいてい 10 GB（10）、最大値はたいてい 64 TB（64000）です。
NEW_PERSISTENT_DISK_TYPE: ディスクタイプ新しい永続ディスクの pd-standard、pd-balanced、pd-ssd、または pd-extreme のいずれかです。ブート以外の永続ディスクのデフォルトのディスクタイプは pd-standard です。
NEW_PERSISTENT_DISK_NAME: 新規の永続ディスクの名前。

このジョブ用の VM インスタンステンプレートを使用している場合、前述のとおり JSON ファイルを作成しますが、ただし instances フィールドは次のように置き換えます。
```
"instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...
```
ここで、INSTANCE_TEMPLATE_NAME は、このジョブ用のインスタンステンプレートの名前です。永続ディスクを使用するジョブの場合、このインスタンステンプレートで、ジョブで使用する永続ディスクを定義してアタッチする必要があります。この例の場合、テンプレートで NEW_PERSISTENT_DISK_NAME という名前の新規の永続ディスクを定義してアタッチし、EXISTING_PERSISTENT_DISK_NAME という名前の既存の永続ディスクをアタッチする必要があります。

C++

C++ 用 Cloud クライアントライブラリを使用して新規または既存の永続ディスクを使用する Batch ジョブを作成するには、CreateJob 関数を使用します。また、これには次の内容を含めます。

ジョブの VM に永続ディスクをアタッチするには、次のいずれかを追加します。
- このジョブに VM インスタンステンプレートを使用していない場合は、set_remote_path メソッドを使用します。
- このジョブに VM インスタンステンプレートを使用する場合は、set_instance_template メソッドを使用します。
永続ディスクをジョブにマウントするには、deviceName フィールドと mountPath フィールドとともに volumes フィールドを使用します。新しい永続ディスクの場合は、mountOptions フィールドも使用して書き込みを有効にします。

同様のユースケースのコードサンプルについては、Cloud Storage バケットを使用するをご覧ください。

Go

Go 用 Cloud クライアントライブラリを使用して新規または既存の永続ディスクを使用する Batch ジョブを作成するには、CreateJob 関数を使用します。また、次の内容を含めます。

ジョブの VM に永続ディスクをアタッチするには、次のいずれかを追加します。
- このジョブに VM インスタンステンプレートを使用していない場合は、AllocationPolicy_AttachedDisk タイプを含めます。
- このジョブに VM インスタンステンプレートを使用している場合は、AllocationPolicy_InstancePolicyOrTemplate_InstanceTemplate タイプを含めます。
永続ディスクをジョブにマウントするには、Volume タイプを Volume_DeviceName タイプと MountPath フィールドとともにを使用します。新しい永続ディスクの場合は、MountOptions フィールドも使用して書き込みを有効にします。

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 with persistent disk
func createJobWithPD(w io.Writer, projectID, jobName, pdName string) error {
	// jobName := job-name
	// pdName := disk-name
	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("batchClient error: %w", err)
	}
	defer batchClient.Close()

	runn := &batchpb.Runnable{
		Executable: &batchpb.Runnable_Script_{
			Script: &batchpb.Runnable_Script{
				Command: &batchpb.Runnable_Script_Text{
					Text: "echo Hello world from script 1 for task ${BATCH_TASK_INDEX}",
				},
			},
		},
	}
	volume := &batchpb.Volume{
		MountPath: fmt.Sprintf("/mnt/disks/%v", pdName),
		Source: &batchpb.Volume_DeviceName{
			DeviceName: pdName,
		},
	}

	// The disk type of the new persistent disk, either pd-standard,
	// pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced
	disk := &batchpb.AllocationPolicy_Disk{
		Type:   "pd-balanced",
		SizeGb: 10,
	}

	taskSpec := &batchpb.TaskSpec{
		ComputeResource: &batchpb.ComputeResource{
			// CpuMilli is milliseconds per cpu-second. This means the task requires 1 CPU.
			CpuMilli:  1000,
			MemoryMib: 16,
		},
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Runnables:     []*batchpb.Runnable{runn},
		Volumes:       []*batchpb.Volume{volume},
	}

	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

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

	// Policies are used to define on what kind of virtual machines the tasks will run on.
	// Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					MachineType: "n1-standard-1",
					Disks: []*batchpb.AllocationPolicy_AttachedDisk{
						{
							Attached: &batchpb.AllocationPolicy_AttachedDisk_NewDisk{
								NewDisk: disk,
							},
							DeviceName: pdName,
						},
					},
				},
			},
		}},
	}

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

	job := &batchpb.Job{
		Name:             jobName,
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           labels,
		LogsPolicy:       logsPolicy,
	}

	request := &batchpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, "us-central1"),
		JobId:  jobName,
		Job:    job,
	}

	created_job, err := batchClient.CreateJob(ctx, request)
	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 用 Cloud クライアントライブラリを使用して新規または既存の永続ディスクを使用する Batch ジョブを作成するには、CreateJobRequest クラスを使用します。また、次の内容を含めます。

ジョブの VM に永続ディスクをアタッチするには、次のいずれかを追加します。
- このジョブに VM インスタンステンプレートを使用していない場合は、setDisksメソッドを使用します。
- このジョブに VM インスタンステンプレートを使用している場合は、setInstanceTemplate メソッドを使用します。
永続ディスクをジョブにマウントするには、Volume クラスを setDeviceName メソッドと setMountPath メソッドとともに使用します。新しい永続ディスクの場合は、setMountOptions メソッドも使用して書き込みを有効にします。

たとえば、次のコードサンプルを使用します。


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.AttachedDisk;
import com.google.cloud.batch.v1.AllocationPolicy.Disk;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicy;
import com.google.cloud.batch.v1.AllocationPolicy.InstancePolicyOrTemplate;
import com.google.cloud.batch.v1.AllocationPolicy.LocationPolicy;
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.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.cloud.batch.v1.Volume;
import com.google.common.collect.Lists;
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 CreatePersistentDiskJob {

  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 size of the new persistent disk in GB.
    // The allowed sizes depend on the type of persistent disk,
    // but the minimum is often 10 GB (10) and the maximum is often 64 TB (64000).
    int diskSize = 10;
    // The name of the new persistent disk.
    String newPersistentDiskName = "DISK-NAME";
    // The name of an existing persistent disk.
    String existingPersistentDiskName = "EXISTING-DISK-NAME";
    // The location of an existing persistent disk. For more info :
    // https://cloud.google.com/batch/docs/create-run-job-storage#gcloud
    String location = "regions/us-central1";
    // The disk type of the new persistent disk, either pd-standard,
    // pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced.
    String newDiskType = "pd-balanced";

    createPersistentDiskJob(projectId, region, jobName, newPersistentDiskName,
            diskSize, existingPersistentDiskName, location, newDiskType);
  }

  // Creates a job that attaches and mounts an existing persistent disk and a new persistent disk
  public static Job createPersistentDiskJob(String projectId, String region, String jobName,
                                            String newPersistentDiskName, int diskSize,
                                            String existingPersistentDiskName,
                                            String location, String newDiskType)
      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.
      String text = "echo Hello world from task ${BATCH_TASK_INDEX}. "
              + ">> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt";
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(text)
                      // 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.
              .addAllVolumes(volumes(newPersistentDiskName, existingPersistentDiskName))
              .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();

      // Policies are used to define the type of virtual machines the tasks will run on.
      InstancePolicy policy = InstancePolicy.newBuilder()
              .addAllDisks(attachedDisks(newPersistentDiskName, diskSize, newDiskType,
                  projectId, location, existingPersistentDiskName))
              .build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setPolicy(policy))
                  .setLocation(LocationPolicy.newBuilder().addAllowedLocations(location))
              .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 option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(LogsPolicy.Destination.CLOUD_LOGGING))
              .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());

      return result;
    }
  }

  // Creates link to existing disk and creates configuration for new disk
  private static Iterable<AttachedDisk> attachedDisks(String newPersistentDiskName, int diskSize,
                                                      String newDiskType, String projectId,
                                                      String existingPersistentDiskLocation,
                                                      String existingPersistentDiskName) {
    AttachedDisk newDisk = AttachedDisk.newBuilder()
            .setDeviceName(newPersistentDiskName)
            .setNewDisk(Disk.newBuilder().setSizeGb(diskSize).setType(newDiskType))
            .build();

    String diskPath = String.format("projects/%s/%s/disks/%s", projectId,
            existingPersistentDiskLocation, existingPersistentDiskName);

    AttachedDisk existingDisk = AttachedDisk.newBuilder()
            .setDeviceName(existingPersistentDiskName)
            .setExistingDisk(diskPath)
            .build();

    return Lists.newArrayList(existingDisk, newDisk);
  }

  // Describes a volume and parameters for it to be mounted to a VM.
  private static Iterable<Volume> volumes(String newPersistentDiskName,
                                          String existingPersistentDiskName) {
    Volume newVolume = Volume.newBuilder()
            .setDeviceName(newPersistentDiskName)
            .setMountPath("/mnt/disks/" + newPersistentDiskName)
            .addMountOptions("rw")
            .addMountOptions("async")
            .build();

    Volume existingVolume = Volume.newBuilder()
            .setDeviceName(existingPersistentDiskName)
            .setMountPath("/mnt/disks/" + existingPersistentDiskName)
            .build();

    return Lists.newArrayList(newVolume, existingVolume);
  }
}

Node.js

Node.js 用 Cloud クライアントライブラリを使用して新規または既存の永続ディスクを使用する Batch ジョブを作成するには、createJob メソッドを使用します。また、次の内容を含めます。

ジョブの VM に永続ディスクをアタッチするには、次のいずれかを追加します。
- このジョブに VM インスタンステンプレートを使用していない場合は、AllocationPolicy.AttachedDisk クラスを含めます。
- このジョブに VM インスタンステンプレートを使用している場合は、instanceTemplate プロパティを含めます。
永続ディスクをジョブにマウントするには、Volume クラスを deviceName プロパティと mountPath プロパティとともに使用します。新しい永続ディスクの場合は、mountOptions プロパティも使用して書き込みを有効にします。

// 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();
// The name of the job that will be created.
// It needs to be unique for each project and region pair.
const jobName = 'batch-create-persistent-disk-job';
// 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 an existing persistent disk.
const existingPersistentDiskName = 'existing-persistent-disk-name';
// The name of the new persistent disk.
const newPersistentDiskName = 'new-persistent-disk-name';
// The size of the new persistent disk in GB.
// The allowed sizes depend on the type of persistent disk,
// but the minimum is often 10 GB (10) and the maximum is often 64 TB (64000).
const diskSize = 10;
// The location of an existing persistent disk. For more info :
// https://cloud.google.com/batch/docs/create-run-job-storage#gcloud
const location = 'regions/us-central1';
// The disk type of the new persistent disk, either pd-standard,
// pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced.
const newDiskType = 'pd-balanced';

// 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}.' +
        '>> /mnt/disks/NEW_PERSISTENT_DISK_NAME/output_task_${BATCH_TASK_INDEX}.txt',
    ],
  }),
});

// Define volumes and their parameters to be mounted to a VM.
const newVolume = new batch.Volume({
  deviceName: newPersistentDiskName,
  mountPath: `/mnt/disks/${newPersistentDiskName}`,
  mountOptions: ['rw', 'async'],
});

const existingVolume = new batch.Volume({
  deviceName: existingPersistentDiskName,
  mountPath: `/mnt/disks/${existingPersistentDiskName}`,
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  volumes: [newVolume, existingVolume],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

const newDisk = new batch.AllocationPolicy.Disk({
  type: newDiskType,
  sizeGb: diskSize,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
// Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  disks: [
    // Create configuration for new disk
    new batch.AllocationPolicy.AttachedDisk({
      deviceName: newPersistentDiskName,
      newDisk,
    }),
    // Create link to existing disk
    new batch.AllocationPolicy.AttachedDisk({
      existingDisk: `projects/${projectId}/${location}/disks/${existingPersistentDiskName}`,
      deviceName: existingPersistentDiskName,
    }),
  ],
});

const locationPolicy = new batch.AllocationPolicy.LocationPolicy({
  allowedLocations: [location],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{policy: instancePolicy}],
  location: locationPolicy,
});

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 callCreateBatchPersistentDiskJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchPersistentDiskJob();

Python

Python 用 Cloud クライアントライブラリを使用して新規または既存の永続ディスクを使用する Batch ジョブを作成するには、CreateJob 関数を使用します。また、次の内容を含めます。

ジョブの VM に永続ディスクをアタッチするには、次のいずれかを追加します。
- このジョブに VM インスタンステンプレートを使用していない場合は、AttachedDisk クラスを含めます。
- このジョブに VM インスタンステンプレートを使用している場合は、instance_template 属性を使用します。
永続ディスクをジョブにマウントするには、Volume クラスを device_name 属性と mount_path 属性とともにを使用します。新しい永続ディスクの場合は、mount_options 属性も使用して書き込みを有効にします。

たとえば、次のコードサンプルを使用します。

from google.cloud import batch_v1


def create_with_pd_job(
    project_id: str,
    region: str,
    job_name: str,
    disk_name: str,
    zone: str,
    existing_disk_name=None,
) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances with mounted persistent disk.

    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.
        disk_name: name of the disk to be mounted for your Job.
        existing_disk_name(optional): existing disk name, which you want to attach to a job

    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 from task ${BATCH_TASK_INDEX}. >> /mnt/disks/"
        + disk_name
        + "/output_task_${BATCH_TASK_INDEX}.txt"
    )
    task.runnables = [runnable]
    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    volume = batch_v1.Volume()
    volume.device_name = disk_name
    volume.mount_path = f"/mnt/disks/{disk_name}"
    task.volumes = [volume]

    if existing_disk_name:
        volume2 = batch_v1.Volume()
        volume2.device_name = existing_disk_name
        volume2.mount_path = f"/mnt/disks/{existing_disk_name}"
        task.volumes.append(volume2)

    # 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

    disk = batch_v1.AllocationPolicy.Disk()
    # The disk type of the new persistent disk, either pd-standard,
    # pd-balanced, pd-ssd, or pd-extreme. For Batch jobs, the default is pd-balanced
    disk.type_ = "pd-balanced"
    disk.size_gb = 10

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # Read more about local disks here: https://cloud.google.com/compute/docs/disks/persistent-disks
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-1"

    attached_disk = batch_v1.AllocationPolicy.AttachedDisk()
    attached_disk.new_disk = disk
    attached_disk.device_name = disk_name
    policy.disks = [attached_disk]

    if existing_disk_name:
        attached_disk2 = batch_v1.AllocationPolicy.AttachedDisk()
        attached_disk2.existing_disk = (
            f"projects/{project_id}/zones/{zone}/disks/{existing_disk_name}"
        )
        attached_disk2.device_name = existing_disk_name
        policy.disks.append(attached_disk2)

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy

    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = [f"zones/{zone}"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "script"}

    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)

ローカル SSD を使用する

ローカル SSD を使用するジョブには次の制限があります。

すべてのローカル SSD すべてのローカル SSD の制限を確認します。
インスタンステンプレート: このジョブの作成中に VM インスタンステンプレートを指定する場合は、インスタンステンプレートで、このジョブ用の任意の永続ディスクをアタッチする必要があります。それ以外で、インスタンステンプレートを使用しない場合は、ジョブ定義で任意の永続ディスクを直接アタッチする必要があります。

ローカル SSD を使用するジョブは、gcloud CLI、Batch API、Java、Python を使用して作成できます。次の例は、ローカル SSD を作成、アタッチ、マウントするジョブを作成する方法を示しています。このジョブには、次の 3 つのタスクがあります。各タスクはスクリプトを実行して output_task_TASK_INDEX.txt というローカル SSD にファイルを作成します。TASK_INDEX は各タスクのインデックスです: 0、1、および 2。

gcloud

gcloud CLI を使用してローカル SSD を使用するジョブを作成するには、gcloud batch jobs submit コマンドを使用します。ジョブの JSON 構成ファイルで、instances フィールドにローカル SSD を作成してアタッチし、volumes フィールドにローカル SSD をマウントします。

JSON ファイルを作成します。

このジョブにインスタンステンプレートを使用していない場合は、次の内容の JSON ファイルを作成します。

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

以下を置き換えます。

MACHINE_TYPE: マシンタイプで、ジョブの VM の事前定義されたもの、またはカスタムのものでありえます。ローカル SSD の許容数は、ジョブの VM のマシンタイプによって異なります。
LOCAL_SSD_NAME: このジョブ用に作成されたローカル SSD の名前。
LOCAL_SSD_SIZE: すべてのローカル SSD のサイズ（GB 単位）。各ローカル SSD は 375 GB であるため、この値は 375 GB の倍数である必要があります。たとえば、2 つのローカル SSD の場合、この値を 750 GB に設定します。

このジョブ用の VM インスタンステンプレートを使用している場合、前述のとおり JSON ファイルを作成しますが、ただし instances フィールドは次のように置き換えます。
```
"instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
```
ここで、INSTANCE_TEMPLATE_NAME は、このジョブ用のインスタンステンプレートの名前です。ローカル SSD を使用するジョブの場合、このインスタンステンプレートで、ジョブで使用するローカル SSD を定義してアタッチする必要があります。この例の場合、テンプレートで LOCAL_SSD_NAME という名前のローカル SSD を定義し、アタッチする必要があります。

次のコマンドを実行します。
```
gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE
```
以下を置き換えます。
- JOB_NAME: ジョブの名前。
- LOCATION: ジョブのロケーション。
- JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

API

Batch API を使用してローカル SSD を使用するジョブを作成するには、jobs.create メソッドを使用します。リクエストでは、instances フィールドにローカル SSD を作成してアタッチし、volumes フィールドにローカル SSD をマウントします。

このジョブにインスタンステンプレートを使用していない場合は、次のリクエストを行います。

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

{
    "allocationPolicy": {
        "instances": [
            {
                "policy": {
                    "machineType": MACHINE_TYPE,
                    "disks": [
                        {
                            "newDisk": {
                                "sizeGb": LOCAL_SSD_SIZE,
                                "type": "local-ssd"
                            },
                            "deviceName": "LOCAL_SSD_NAME"
                        }
                    ]
                }
            }
        ]
    },
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> /mnt/disks/LOCAL_SSD_NAME/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "deviceName": "LOCAL_SSD_NAME",
                        "mountPath": "/mnt/disks/LOCAL_SSD_NAME",
                        "mountOptions": "rw,async"
                    }
                ]
            },
            "taskCount":3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

以下を置き換えます。

PROJECT_ID: プロジェクトのプロジェクト ID
LOCATION: ジョブのロケーション。
JOB_NAME: ジョブの名前。
MACHINE_TYPE: マシンタイプで、ジョブの VM の事前定義されたもの、またはカスタムのものでありえます。ローカル SSD の許容数は、ジョブの VM のマシンタイプによって異なります。
LOCAL_SSD_NAME: このジョブ用に作成されたローカル SSD の名前。
LOCAL_SSD_SIZE: すべてのローカル SSD のサイズ（GB 単位）。各ローカル SSD は 375 GB であるため、この値は 375 GB の倍数である必要があります。たとえば、2 つのローカル SSD の場合、この値を 750 GB に設定します。

このジョブ用の VM インスタンステンプレートを使用している場合、前述のとおり JSON ファイルを作成しますが、ただし instances フィールドは次のように置き換えます。
```
"instances": [
    {
        "instanceTemplate": "INSTANCE_TEMPLATE_NAME"
    }
],
...
```
ここで、INSTANCE_TEMPLATE_NAME は、このジョブ用のインスタンステンプレートの名前です。ローカル SSD を使用するジョブの場合、このインスタンステンプレートで、ジョブで使用するローカル SSD を定義してアタッチする必要があります。この例の場合、テンプレートで LOCAL_SSD_NAME という名前のローカル SSD を定義し、アタッチする必要があります。

Go

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 with local SSD
// Note: local SSD does not guarantee Local SSD data persistence.
// More details here: https://cloud.google.com/compute/docs/disks/local-ssd#data_persistence
func createJobWithSSD(w io.Writer, projectID, jobName, ssdName string) error {
	// jobName := job-name
	// ssdName := disk-name
	ctx := context.Background()
	batchClient, err := batch.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("batchClient error: %w", err)
	}
	defer batchClient.Close()

	runn := &batchpb.Runnable{
		Executable: &batchpb.Runnable_Script_{
			Script: &batchpb.Runnable_Script{
				Command: &batchpb.Runnable_Script_Text{
					Text: "echo Hello world from script 1 for task ${BATCH_TASK_INDEX}",
				},
			},
		},
	}
	volume := &batchpb.Volume{
		MountPath: fmt.Sprintf("/mnt/disks/%v", ssdName),
		Source: &batchpb.Volume_DeviceName{
			DeviceName: ssdName,
		},
	}

	// The size of all the local SSDs in GB. Each local SSD is 375 GB,
	// so this value must be a multiple of 375 GB.
	// For example, for 2 local SSDs, set this value to 750 GB.
	disk := &batchpb.AllocationPolicy_Disk{
		Type:   "local-ssd",
		SizeGb: 375,
	}

	taskSpec := &batchpb.TaskSpec{
		ComputeResource: &batchpb.ComputeResource{
			// CpuMilli is milliseconds per cpu-second. This means the task requires 1 CPU.
			CpuMilli:  1000,
			MemoryMib: 16,
		},
		MaxRunDuration: &durationpb.Duration{
			Seconds: 3600,
		},
		MaxRetryCount: 2,
		Runnables:     []*batchpb.Runnable{runn},
		Volumes:       []*batchpb.Volume{volume},
	}

	taskGroups := []*batchpb.TaskGroup{
		{
			TaskCount: 4,
			TaskSpec:  taskSpec,
		},
	}

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

	allocationPolicy := &batchpb.AllocationPolicy{
		Instances: []*batchpb.AllocationPolicy_InstancePolicyOrTemplate{{
			PolicyTemplate: &batchpb.AllocationPolicy_InstancePolicyOrTemplate_Policy{
				Policy: &batchpb.AllocationPolicy_InstancePolicy{
					// The allowed number of local SSDs depends on the machine type for your job's VMs.
					// In this case, we tell the system to use "n1-standard-1" machine type, which require to attach local ssd manually.
					// Read more about local disks here: https://cloud.google.com/compute/docs/disks/local-ssd#lssd_disk_options
					MachineType: "n1-standard-1",
					Disks: []*batchpb.AllocationPolicy_AttachedDisk{
						{
							Attached: &batchpb.AllocationPolicy_AttachedDisk_NewDisk{
								NewDisk: disk,
							},
							DeviceName: ssdName,
						},
					},
				},
			},
		}},
	}

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

	job := &batchpb.Job{
		Name:             jobName,
		TaskGroups:       taskGroups,
		AllocationPolicy: allocationPolicy,
		Labels:           labels,
		LogsPolicy:       logsPolicy,
	}

	request := &batchpb.CreateJobRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, "us-central1"),
		JobId:  jobName,
		Job:    job,
	}

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

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

Java


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.AttachedDisk;
import com.google.cloud.batch.v1.AllocationPolicy.Disk;
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.CreateJobRequest;
import com.google.cloud.batch.v1.Job;
import com.google.cloud.batch.v1.LogsPolicy;
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.cloud.batch.v1.Volume;
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 CreateLocalSsdJob {

  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 local SSD created for this job.
    String localSsdName = "SSD-NAME";
    // The machine type, which can be predefined or custom, of the job's VMs.
    // The allowed number of local SSDs depends on the machine type
    // for your job's VMs are listed on: https://cloud.google.com/compute/docs/disks#localssds
    String machineType = "c3d-standard-8-lssd";
    // The size of all the local SSDs in GB. Each local SSD is 375 GB,
    // so this value must be a multiple of 375 GB.
    // For example, for 2 local SSDs, set this value to 750 GB.
    int ssdSize = 375;

    createLocalSsdJob(projectId, region, jobName, localSsdName, ssdSize, machineType);
  }

  // Create a job that uses local SSDs
  public static Job createLocalSsdJob(String projectId, String region, String jobName,
                                      String localSsdName, int ssdSize, String machineType)
      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();

      Volume volume = Volume.newBuilder()
          .setDeviceName(localSsdName)
          .setMountPath("/mnt/disks/" + localSsdName)
          .addMountOptions("rw")
          .addMountOptions("async")
          .build();

      TaskSpec task = TaskSpec.newBuilder()
          // Jobs can be divided into tasks. In this case, we have only one task.
          .addVolumes(volume)
          .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();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      InstancePolicy policy = InstancePolicy.newBuilder()
          .setMachineType(machineType)
          .addDisks(AttachedDisk.newBuilder()
              .setDeviceName(localSsdName)
              // For example, local SSD uses type "local-ssd".
              // Persistent disks and boot disks use "pd-balanced", "pd-extreme", "pd-ssd"
              // or "pd-standard".
              .setNewDisk(Disk.newBuilder().setSizeGb(ssdSize).setType("local-ssd")))
          .build();

      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setPolicy(policy)
                      .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(LogsPolicy.Destination.CLOUD_LOGGING))
              .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());

      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 = 'batch-local-ssd-job';
// The name of a local SSD created for this job.
const localSsdName = 'ssd-name';
// The machine type, which can be predefined or custom, of the job's VMs.
// The allowed number of local SSDs depends on the machine type
// for your job's VMs are listed on: https://cloud.google.com/compute/docs/disks#localssds
const machineType = 'c3d-standard-8-lssd';
// The size of all the local SSDs in GB. Each local SSD is 375 GB,
// so this value must be a multiple of 375 GB.
// For example, for 2 local SSDs, set this value to 750 GB.
const ssdSize = 375;

// 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}. This job has a total of ${BATCH_TASK_COUNT} tasks.',
    ],
  }),
});

const task = new batch.TaskSpec({
  runnables: [runnable],
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  taskSpec: task,
});

// Policies are used to define on what kind of virtual machines the tasks will run on.
const instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType,
  disks: [
    new batch.AllocationPolicy.AttachedDisk({
      deviceName: localSsdName,
      // For example, local SSD uses type "local-ssd".
      // Persistent disks and boot disks use "pd-balanced", "pd-extreme", "pd-ssd"
      // or "pd-standard".
      newDisk: new batch.AllocationPolicy.AttachedDisk({
        type: 'local-ssd',
        sizeGb: ssdSize,
      }),
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{policy: instancePolicy}],
});

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 callCreateBatchGPUJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchGPUJob();

Python

from google.cloud import batch_v1


def create_local_ssd_job(
    project_id: str, region: str, job_name: str, ssd_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 with mounted local SSD.
    Note: local SSD does not guarantee Local SSD data persistence.
    More details here: https://cloud.google.com/compute/docs/disks/local-ssd#data_persistence

    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.
        ssd_name: name of the local ssd to be mounted for your Job.

    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."
    task.runnables = [runnable]
    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    volume = batch_v1.Volume()
    volume.device_name = ssd_name
    volume.mount_path = f"/mnt/disks/{ssd_name}"
    task.volumes = [volume]

    # 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

    disk = batch_v1.AllocationPolicy.Disk()
    disk.type_ = "local-ssd"
    # The size of all the local SSDs in GB. Each local SSD is 375 GB,
    # so this value must be a multiple of 375 GB.
    # For example, for 2 local SSDs, set this value to 750 GB.
    disk.size_gb = 375
    assert disk.size_gb % 375 == 0

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # The allowed number of local SSDs depends on the machine type for your job's VMs.
    # In this case, we tell the system to use "n1-standard-1" machine type, which require to attach local ssd manually.
    # Read more about local disks here: https://cloud.google.com/compute/docs/disks/local-ssd#lssd_disk_options
    policy = batch_v1.AllocationPolicy.InstancePolicy()
    policy.machine_type = "n1-standard-1"

    attached_disk = batch_v1.AllocationPolicy.AttachedDisk()
    attached_disk.new_disk = disk
    attached_disk.device_name = ssd_name
    policy.disks = [attached_disk]

    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": "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)

Cloud Storage バケットを使用する

既存の Cloud Storage バケットを使用するジョブを作成するには、次のいずれかの方法を選択します。

推奨: このセクションに示すように、ジョブの定義でバケットを指定することで、ジョブの VM にバケットを直接マウントします。ジョブを実行すると、Cloud Storage FUSE を使用してバケットがジョブの VM に自動的にマウントされます。
gcloud CLI または Cloud Storage API 用のクライアントライブラリを使用して、Cloud Storage バケットに直接アクセスするタスクを含むジョブを作成します。VM から Cloud Storage バケットに直接アクセスする方法については、Cloud Storage バケットからのデータの書き込みと読み取りについての Compute Engine のドキュメントをご覧ください。

バケットを使用するジョブを作成する前に、バケットを作成するか、既存のバケットを特定します。詳しくは、バケットを作成するとバケットを一覧表示するをご覧ください。

Cloud Storage バケットを使用するジョブは、Google Cloud コンソール、gcloud CLI、Batch API、C++、Go、Java、Node.js、Python を使用して作成できます。

次の例は、Cloud Storage バケットをマウントするジョブを作成する方法を示しています。このジョブには以下の 3 つのタスクがあります。各タスクはスクリプトを実行して、output_task_TASK_INDEX.txt というバケット内にファイルを作成します。ここで TASK_INDEX は各タスクのインデックスです: 0、1、および 2。

コンソール

Google Cloud コンソールを使用して Cloud Storage バケットを使用するジョブを作成するには、次の操作を行います。

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

ジョブリストに移動する
[ 作成] をクリックします。[バッチジョブを作成する] ページが開きます。左側のペインで、[ジョブの詳細] ページが選択されています。
[ジョブの詳細] ページを構成します。
1. 省略可: [ジョブ名] フィールドで、ジョブ名をカスタマイズします。
  
  たとえば、「example-bucket-job」と入力します。
2. [タスクの詳細] セクションを構成します。
  1. [新しい実行可能物] ウィンドウで、このジョブを実行するためのスクリプトまたはコンテナを少なくとも 1 つ追加します。
    
    たとえば、次の操作を行います。
    1. [スクリプト] チェックボックスをオンにします。テキストボックスが表示されます。
    2. テキストボックスに次のスクリプトを入力します。
      echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt
      MOUNT_PATH は、このジョブの実行可能物が既存の Cloud Storage バケットへのアクセスに使用するマウントパスに置き換えます。パスは /mnt/disks/ で始まり、選択したディレクトリまたはパスがそれに続く必要があります。たとえば、my-bucket という名前のディレクトリでこのバケットを表す場合は、マウントパスを /mnt/disks/my-bucket に設定します。
    3. [完了] をクリックします。
  2. [タスク数] フィールドに、このジョブのタスク数を入力します。
    
    たとえば、「3」と入力します。
  3. [並列処理] フィールドに、同時に実行するタスクの数を入力します。
    
    たとえば、「1」（デフォルト）と入力します。
[その他の構成] ページを構成します。
1. 左側のペインで [その他の構成] をクリックします。 [その他の構成] ページが開きます。
2. このジョブにマウントする Cloud Storage バケットごとに、次の操作を行います。
  1. [ストレージボリューム] セクションで、[新しいボリュームを追加] をクリックします。 [新しいボリューム] ウィンドウが表示されます。
  2. [新しいボリューム] ウィンドウで、次の操作を行います。
    1. [ボリュームのタイプ] セクションで、[Cloud Storage バケット] を選択します。
    2. [ストレージのバケット名] フィールドに、既存のバケットの名前を入力します。
      
      たとえば、このジョブの実行可能物に指定したバケットを入力します。
    3. [マウントパス] フィールドに、実行可能物で指定したバケットのマウントパス（MOUNT_PATH）を入力します。
    4. [完了] をクリックします。
省略可: このジョブの他のフィールドを構成します。
省略可: ジョブ構成を確認するには、左側のペインで [プレビュー] をクリックします。
[作成] をクリックします。

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

gcloud

gcloud CLI を使用して Cloud Storage バケットを使用するジョブを作成するには、gcloud batch jobs submit コマンドを使用します。ジョブの JSON 構成ファイルで、volumes フィールドでバケットをマウントします。

たとえば、Cloud Storage にファイルを出力するジョブを作成するには、次のようにします。

JSON ファイルを作成し、次の内容を追加します。

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

以下を置き換えます。

BUCKET_PATH: このジョブがアクセスするバケットディレクトリのパスで、バケットの名前で始まる必要があります。たとえば、BUCKET_NAME という名前のバケットの場合、パス BUCKET_NAME はバケットのルートディレクトリ、そしてパス BUCKET_NAME/subdirectory は subdirectory サブディレクトリです。
MOUNT_PATH: ジョブの実行可能物がこのバケットにアクセスするのに使用するマウントパス。パスは /mnt/disks/ で始まり、選択したディレクトリまたはパスがそれに続く必要があります。たとえば、my-bucket という名前のディレクトリでこのバケットを表す場合は、マウントパスを /mnt/disks/my-bucket に設定します。

次のコマンドを実行します。
```
gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE
```
以下を置き換えます。
- JOB_NAME: ジョブの名前。
- LOCATION: ジョブのロケーション。
- JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

API

Batch API を使用して Cloud Storage バケットを使用するジョブを作成するには、jobs.create メソッドを使用し、volumes フィールドでバケットをマウントします。

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

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "gcs": {
                            "remotePath": "BUCKET_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
            "destination": "CLOUD_LOGGING"
    }
}

以下を置き換えます。

PROJECT_ID: プロジェクトのプロジェクト ID
LOCATION: ジョブのロケーション。
JOB_NAME: ジョブの名前。
BUCKET_PATH: このジョブがアクセスするバケットディレクトリのパスで、バケットの名前で始まる必要があります。たとえば、BUCKET_NAME という名前のバケットの場合、パス BUCKET_NAME はバケットのルートディレクトリ、そしてパス BUCKET_NAME/subdirectory は subdirectory サブディレクトリです。
MOUNT_PATH: ジョブの実行可能物がこのバケットにアクセスするのに使用するマウントパス。パスは /mnt/disks/ で始まり、選択したディレクトリまたはパスがそれに続く必要があります。たとえば、my-bucket という名前のディレクトリでこのバケットを表す場合は、マウントパスを /mnt/disks/my-bucket に設定します。

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, std::string const& bucket_name) {
    // 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, and then override the GCS remote path.
    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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
            }
          }
          volumes { mount_path: "/mnt/share" }
        }
      }
      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");
    }
    job->mutable_task_groups(0)
        ->mutable_task_spec()
        ->mutable_volumes(0)
        ->mutable_gcs()
        ->set_remote_path(bucket_name);
    // 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";
  }

Go

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

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 createScriptJobWithBucket(w io.Writer, projectID, region, jobName, bucketName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// jobName := "some-job"
	// jobName := "some-bucket"

	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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt",
	}

	// Specify the Google Cloud Storage bucket to mount
	volume := &batchpb.Volume{
		Source: &batchpb.Volume_Gcs{
			Gcs: &batchpb.GCS{
				RemotePath: bucketName,
			},
		},
		MountPath:    "/mnt/share",
		MountOptions: []string{},
	}

	// We can specify what resources are requested by each task.
	resources := &batchpb.ComputeResource{
		// CpuMilli is milliseconds per cpu-second. This means the task requires 50% of a single CPUs.
		CpuMilli:  500,
		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,
		Volumes:       []*batchpb.Volume{volume},
	}

	// 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

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

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.GCS;
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.cloud.batch.v1.Volume;
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 CreateWithMountedBucket {

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

    // Name of the bucket to be mounted for your Job.
    String bucketName = "BUCKET_NAME";

    createScriptJobWithBucket(projectId, region, jobName, bucketName);
  }

  // This method shows how to create a sample Batch Job that will run
  // a simple command on Cloud Compute instances.
  public static void createScriptJobWithBucket(String projectId, String region, String jobName,
      String bucketName)
      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 from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // 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();

      Volume volume = Volume.newBuilder()
          .setGcs(GCS.newBuilder()
              .setRemotePath(bucketName)
              .build())
          .setMountPath("/mnt/share")
          .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 50% of a single CPUs.
              .setCpuMilli(500)
              // 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)
              .addVolumes(volume)
              .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")
              .putLabels("mount", "bucket")
              // 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

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

/**
 * 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';
/**
 * The name of the bucket to be mounted.
 */
// const bucketName = 'YOUR_BUCKET_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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt';
// 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];

const gcsBucket = new batch.GCS();
gcsBucket.remotePath = bucketName;
const gcsVolume = new batch.Volume();
gcsVolume.gcs = gcsBucket;
gcsVolume.mountPath = '/mnt/share';
task.volumes = [gcsVolume];

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

await callCreateJob();

Python

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

from google.cloud import batch_v1


def create_script_job_with_bucket(
    project_id: str, region: str, job_name: str, bucket_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.
        bucket_name: name of the bucket to be mounted for your Job.

    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 from task ${BATCH_TASK_INDEX}. >> /mnt/share/output_task_${BATCH_TASK_INDEX}.txt"
    task.runnables = [runnable]

    gcs_bucket = batch_v1.GCS()
    gcs_bucket.remote_path = bucket_name
    gcs_volume = batch_v1.Volume()
    gcs_volume.gcs = gcs_bucket
    gcs_volume.mount_path = "/mnt/share"
    task.volumes = [gcs_volume]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 500  # in milliseconds per cpu-second. This means the task requires 50% of a single 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", "mount": "bucket"}
    # 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)

ネットワークファイルシステムを使用する

Google Cloud コンソール、gcloud CLI、または Batch API を使用して、Filestore ファイル共有などの既存のネットワークファイルシステム（NFS）を使用するジョブを作成できます。

NFS を使用するジョブを作成する前に、ジョブの VM と NFS の間のトラフィックを許可するようにネットワークのファイアウォールが適切に構成されていることを確認してください。詳細については、Filestore のファイアウォールルールの構成をご覧ください。

次の例では、NFS を指定してマウントするジョブを作成する方法を示しています。このジョブには以下の 3 つのタスクがあります。各タスクはスクリプトを実行して、output_task_TASK_INDEX.txt という NFS 内にファイルを作成します。ここで TASK_INDEX は各タスクのインデックスです: 0、1、および 2。

コンソール

Google Cloud コンソールを使用して NFS を使用するジョブを作成するには、次の操作を行います。

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

ジョブリストに移動する
[ 作成] をクリックします。[バッチジョブを作成する] ページが開きます。左側のペインで、[ジョブの詳細] ページが選択されています。
[ジョブの詳細] ページを構成します。
1. 省略可: [ジョブ名] フィールドで、ジョブ名をカスタマイズします。
  
  たとえば、「example-nfs-job」と入力します。
2. [タスクの詳細] セクションを構成します。
  1. [新しい実行可能物] ウィンドウで、このジョブを実行するためのスクリプトまたはコンテナを少なくとも 1 つ追加します。
    
    たとえば、次の操作を行います。
    1. [スクリプト] チェックボックスをオンにします。テキストボックスが表示されます。
    2. テキストボックスに次のスクリプトを入力します。
      echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt
      MOUNT_PATH は、ジョブの実行可能物がこの NFS へのアクセスに使用するマウントパスに置き換えます。パスは /mnt/disks/ で始まり、選択したディレクトリまたはパスがそれに続く必要があります。たとえば、my-nfs という名前のディレクトリでこの NFS を表す場合は、マウントパスを /mnt/disks/my-nfs に設定します。
    3. [完了] をクリックします。
  2. [タスク数] フィールドに、このジョブのタスク数を入力します。
    
    たとえば、「3」と入力します。
  3. [並列処理] フィールドに、同時に実行するタスクの数を入力します。
    
    たとえば、「1」（デフォルト）と入力します。
[その他の構成] ページを構成します。
1. 左側のペインで [その他の構成] をクリックします。 [その他の構成] ページが開きます。
2. このジョブにマウントする Cloud Storage バケットごとに、次の操作を行います。
  1. [ストレージボリューム] セクションで、[新しいボリュームを追加] をクリックします。 [新しいボリューム] ウィンドウが表示されます。
  2. [新しいボリューム] ウィンドウで、次の操作を行います。
    1. [ボリュームのタイプ] セクションで、[ネットワークファイルシステム] を選択します。
    2. [ファイルサーバー] フィールドに、このジョブの実行可能物で指定した NFS が配置されているサーバーの IP アドレスを入力します。
      
      たとえば、NFS が Filestore ファイル共有の場合は、Filestore インスタンスの IP アドレスを指定します。これは、Filestore インスタンスを記述することで取得できます。
    3. [リモートパス] フィールドに、前の手順で指定した NFS にアクセスできるパスを入力します。
      
      NFS ディレクトリのパスは、/ で始まり、その後に NFS のルートディレクトリが続く必要があります。
    4. [マウントパス] フィールドに、前の手順で指定した NFS（MOUNT_PATH）のマウントパスを入力します。
3. [完了] をクリックします。
省略可: このジョブの他のフィールドを構成します。
省略可: ジョブ構成を確認するには、左側のペインで [プレビュー] をクリックします。
[作成] をクリックします。

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

gcloud

gcloud CLI を使用して NFS を使用するジョブを作成するには、gcloud batch jobs submit コマンドを使用します。ジョブの JSON 構成ファイルで、volumes フィールドで NFS をマウントします。

JSON ファイルを作成し、次の内容を追加します。

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

以下を置き換えます。

NFS_IP_ADDRESS: NFS の IP アドレス。たとえば、NFS が Filestore ファイル共有の場合は、Filestore インスタンスの IP アドレスを指定します。これは、Filestore インスタンスを記述することで取得できます。
NFS_PATH: このジョブがアクセスする NFS ディレクトリのパスであり、/ で始まり、NFS のルートディレクトリがそれに続く必要があります。たとえば、FILE_SHARE_NAME という名前の Filestore ファイル共有の場合、パス /FILE_SHARE_NAME は、ファイル共有のルートディレクトリ、そしてパス /FILE_SHARE_NAME/subdirectory は subdirectory サブディレクトリを表します。
MOUNT_PATH: ジョブの実行可能物がこの NFS にアクセスするのに使用するマウントパス。パスは /mnt/disks/ で始まり、選択したディレクトリまたはパスがそれに続く必要があります。たとえば、my-nfs という名前のディレクトリでこの NFS を表す場合は、マウントパスを /mnt/disks/my-nfs に設定します。

次のコマンドを実行します。
```
gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE
```
以下を置き換えます。
- JOB_NAME: ジョブの名前。
- LOCATION: ジョブのロケーション。
- JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

API

Batch API を使用して NFS を使用するジョブを作成するには、jobs.create メソッドを使用し、volumes フィールドで NFS をマウントします。

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

   {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}. >> MOUNT_PATH/output_task_${BATCH_TASK_INDEX}.txt"
                        }
                    }
                ],
                "volumes": [
                    {
                        "nfs": {
                            "server": "NFS_IP_ADDRESS",
                            "remotePath": "NFS_PATH"
                        },
                        "mountPath": "MOUNT_PATH"
                    }
                ]
            },
            "taskCount": 3
        }
    ],
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

以下を置き換えます。

PROJECT_ID: プロジェクトのプロジェクト ID
LOCATION: ジョブのロケーション。
JOB_NAME: ジョブの名前。
NFS_IP_ADDRESS: ネットワークファイルシステムの IP アドレス。たとえば、NFS が Filestore ファイル共有の場合は、Filestore インスタンスの IP アドレスを指定します。これは、Filestore インスタンスを記述することで取得できます。
NFS_PATH: このジョブがアクセスする NFS ディレクトリのパスであり、/ で始まり、NFS のルートディレクトリがそれに続く必要があります。たとえば、FILE_SHARE_NAME という名前の Filestore ファイル共有の場合、パス /FILE_SHARE_NAME はファイル共有のルートディレクトリ、そしてパス /FILE_SHARE_NAME/subdirectory はサブディレクトリを表します。
MOUNT_PATH: ジョブの実行可能物がこの NFS にアクセスするのに使用するマウントパス。パスは /mnt/disks/ で始まり、選択したディレクトリまたはパスがそれに続く必要があります。たとえば、my-nfs という名前のディレクトリでこの NFS を表す場合は、マウントパスを /mnt/disks/my-nfs に設定します。

Java


import com.google.cloud.batch.v1.AllocationPolicy;
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.NFS;
import com.google.cloud.batch.v1.Runnable;
import com.google.cloud.batch.v1.TaskGroup;
import com.google.cloud.batch.v1.TaskSpec;
import com.google.cloud.batch.v1.Volume;
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 CreateScriptJobWithNfs {

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

    // The path of the NFS directory that you want this job to access.
    String nfsPath = "NFS_PATH";
    // The IP address of the Network File System.
    String nfsIpAddress = "NFS_IP_ADDRESS";

    createScriptJobWithNfs(projectId, region, jobName, nfsPath, nfsIpAddress);
  }

  // This method shows how to create a batch script job that specifies and mounts a NFS.
  public static Job createScriptJobWithNfs(String projectId, String region, String jobName,
                                            String nfsPath, String nfsIpAddress)
      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(
                  Runnable.Script.newBuilder()
                      .setText(
                          "echo Hello world from task ${BATCH_TASK_INDEX}. >> "
                              + "/mnt/share/output_task_${BATCH_TASK_INDEX}.txt")
                      // 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();

      // Describes a volume and parameters for it to be mounted to a VM.
      Volume volume = Volume.newBuilder()
          .setNfs(NFS.newBuilder()
              .setServer(nfsIpAddress)
              .setRemotePath(nfsPath)
              .build())
          .setMountPath("/mnt/share")
          .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 50% of a single CPUs.
              .setCpuMilli(500)
              // 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)
              .addVolumes(volume)
              .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
      AllocationPolicy.InstancePolicy instancePolicy =
          AllocationPolicy.InstancePolicy.newBuilder().setMachineType("e2-standard-4").build();

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

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              .putLabels("mount", "bucket")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(LogsPolicy.newBuilder()
                      .setDestination(LogsPolicy.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());

      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 = 'batch-nfs-job';
// The path of the NFS directory that you want this job to access.
const nfsPath = '/your_nfs_path';
// The IP address of the Network File System.
const nfsIpAddress = '0.0.0.0';
// The mount path that the job's tasks use to access the NFS.
const mountPath = '/mnt/disks';

// 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 from task ${BATCH_TASK_INDEX}. >> ' +
        '/mnt/share/output_task_${BATCH_TASK_INDEX}.txt',
    ],
  }),
});

// Define a volume that uses NFS.
const volume = new batch.Volume({
  nfs: new batch.NFS({
    server: nfsIpAddress,
    remotePath: nfsPath,
  }),
  mountPath,
});

// 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],
  volumes: [volume],
  computeResource,
  maxRetryCount: 2,
  maxRunDuration: {seconds: 3600},
});

// Tasks are grouped inside a job using TaskGroups.
const group = new batch.TaskGroup({
  taskCount: 3,
  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 instancePolicy = new batch.AllocationPolicy.InstancePolicy({
  machineType: 'e2-standard-4',
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{policy: instancePolicy}],
});

const job = new batch.Job({
  name: jobName,
  taskGroups: [group],
  allocationPolicy,
  labels: {env: 'testing', type: 'script'},
  // 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 callCreateBatchNfsJob() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchNfsJob();

Python

from google.cloud import batch_v1


def create_job_with_network_file_system(
    project_id: str,
    region: str,
    job_name: str,
    mount_path: str,
    nfs_ip_address: str,
    nfs_path: str,
) -> batch_v1.Job:
    """
    Creates a Batch job with status events that mounts a Network File System (NFS).
    Function mounts an NFS volume using the provided NFS server, IP address and path.

    Args:
        project_id (str): project ID or project number of the Cloud project you want to use.
        region (str): 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
        job_name (str): the name of the job that will be created.
            It needs to be unique for each project and region pair.
        mount_path (str): The mount path that the job's tasks use to access the NFS.
        nfs_ip_address (str): The IP address of the NFS server (e.g., Filestore instance).
            Documentation on how to create a
            Filestore instance is available here: https://cloud.google.com/filestore/docs/create-instance-gcloud
        nfs_path (str): The path of the NFS directory that the job accesses.
            The path must start with a / followed by the root directory of the NFS.

    Returns:
        batch_v1.Job: The created Batch job object containing configuration details.
    """
    client = batch_v1.BatchServiceClient()

    # Create a runnable with a script that writes a message to a file
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = f"echo Hello world from task ${{BATCH_TASK_INDEX}}. >> {mount_path}/output_task_${{BATCH_TASK_INDEX}}.txt"

    # Define a volume that uses NFS
    volume = batch_v1.Volume()
    volume.nfs = batch_v1.NFS(server=nfs_ip_address, remote_path=nfs_path)
    volume.mount_path = mount_path

    # Create a task specification and assign the runnable and volume to it
    task = batch_v1.TaskSpec()
    task.runnables = [runnable]
    task.volumes = [volume]

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

    # Create a task group and assign the task specification to it
    group = batch_v1.TaskGroup()
    group.task_count = 1
    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 the job and assign the task group and allocation policy to it
    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 the job request and set the job and job ID
    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)

次のステップ

ジョブの作成または実行で問題が発生した場合は、トラブルシューティングをご覧ください。
ジョブとタスクを表示する。
別のジョブ作成オプションを学習する。

ストレージ ボリュームを使用するジョブを作成して実行する

準備

ストレージ ボリュームを使用するジョブを作成する

永続ディスクを使用する

コンソール

（省略可）サンプルゾーン永続ディスクを作成する

既存のゾーン永続ディスクを使用するジョブを作成する

gcloud

API

C++

Go

Java

Node.js

Python

ローカル SSD を使用する

gcloud

API

Go

Java

Node.js

Python

Cloud Storage バケットを使用する

コンソール

gcloud

API

C++

C++

Go

Go

Java

Java

Node.js

Node.js

Python

Python

ネットワーク ファイル システムを使用する

コンソール

gcloud

API

Java

Node.js

Python

次のステップ

ストレージボリュームを使用するジョブを作成して実行する

ストレージボリュームを使用するジョブを作成する

ネットワークファイルシステムを使用する