GPU を使用するジョブを作成して実行する

このドキュメントでは、画像処理装置（GPU）を使用するジョブを作成して実行する方法について説明します。GPU の機能と制限事項の詳細については、Compute Engine ドキュメントの GPU についてをご覧ください。

Batch ジョブを作成するときに、必要に応じて GPU を使用して特定のワークロードを高速化できます。GPU を使用するジョブの一般的なユースケースには、集中的なデータ処理と人工知能ワークロード（AI）（機械学習（ML）など）が含まれています。

始める前に

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

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

    ロールの付与については、プロジェクト、フォルダ、組織へのアクセスを管理するをご覧ください。

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

GPU を使用するジョブを作成する

GPU を使用するジョブを作成するには、次の操作を行います。

  1. GPU を使用するジョブの要件を計画する。
  2. 特定した要件と方法を使用してジョブを作成します。推奨されるオプションを使用してジョブを作成する方法の例については、このドキュメントの GPU を使用するジョブの例を作成するをご覧ください。

GPU を使用するジョブの要件を計画する

GPU を使用するジョブを作成する前に、次のセクションで説明するように、ジョブの要件を計画します。

  1. GPU マシンタイプとプロビジョニング方法を選択する
  2. GPU ドライバをインストールする
  3. 互換性のある VM リソースを定義する

ステップ 1: GPU マシンタイプとプロビジョニング方法を選択する

ジョブの要件は、使用する GPU マシンタイプとプロビジョニング方法によって異なり、それぞれのオプションは相互に依存している場合があります。要件と優先度に基づいて、最初に GPU マシンタイプを選択するか、最初にプロビジョニング方法を選択します。一般に、GPU マシンタイプは主にパフォーマンスと基本料金に影響し、プロビジョニング方法は主にリソースの可用性と追加費用または割引に影響します。

GPU マシンタイプを選択する

使用可能な GPU マシンタイプ（GPU タイプ、GPU の数、マシンタイプ（vCPU とメモリ）の有効な組み合わせ）とそのユースケースについては、Compute Engine ドキュメントの GPU マシンタイプのページをご覧ください。

ジョブで GPU マシンタイプを指定するために必要なフィールドは、次の表のカテゴリによって異なります。

GPU マシンタイプとそのジョブ要件

アクセラレータ最適化 VM の GPU: アクセラレータ最適化マシン ファミリーのマシンタイプを使用する VM には、特定のタイプと数の GPU が自動的に接続されます。

アクセラレータ最適化 VM で GPU を使用するには、マシンタイプを指定することをおすすめします。各アクセラレータ最適化マシンタイプは、特定のタイプと数の GPU のみをサポートしているため、アクセラレータ最適化マシンタイプに加えてこれらの値を指定しても、機能的には同等です。

具体的には、Batch はアクセラレータ最適化 VM の GPU のタイプと数のみを指定するサポートも行いますが、その場合、vCPU とメモリのオプションが非常に制限されることがあります。そのため、使用可能な vCPU とメモリのオプションがジョブのタスク要件と互換性があることを確認することをおすすめします。

N1 VM の GPU: これらの GPU では、各 VM にアタッチするタイプと量を指定する必要があります。また、N1 マシンシリーズのマシンタイプを持つ VM にアタッチする必要があります。

N1 VM で GPU を使用するには、少なくとも GPU のタイプと GPU の数を指定することをおすすめします。値の組み合わせが、N1 マシンタイプの有効な GPU オプションのいずれかに一致していることを確認します。特定の種類と数の GPU を使用する N1 VM の vCPU とメモリのオプションは非常に柔軟であるため、必要に応じて、ジョブのタスク要件を満たすマシンタイプをバッチに選択させることができます。
プロビジョニング方法を選択する

Batch は、ジョブがリクエストするリソースのタイプに基づいて、GPU を使用するジョブの VM リソースをプロビジョニングするためにさまざまな方法を使用します。使用可能なプロビジョニング方法とその要件については、次の表をご覧ください。この表には、ユースケースに基づいて、リソースの可用性が最も高い順にリストされています。

要約すると、ほとんどのユーザーには次のことをおすすめします。

  • 予約なしで A3 GPU マシンタイプを使用する場合は、Dynamic Workload Scheduler for Batch（プレビュー版）を使用します。

  • 他のすべての GPU マシンタイプには、デフォルトのプロビジョニング方法を使用します。デフォルトのプロビジョニング方法は通常オンデマンドです。ただし、プロジェクトにジョブが自動的に使用できる未使用の予約がある場合は例外です。

プロビジョニング方法とそのジョブ要件

予約

  • ユースケース: リソースの可用性を非常に高いレベルで保証する場合や、未使用の既存の予約がすでにある場合は、ジョブの予約をおすすめします。

  • 詳細: 予約では、予約を削除するまで、指定された VM の実行と同じ料金で VM の費用が発生します。予約を使用している VM に対しては別途料金は発生しませんが、予約には使用量に関係なく料金が発生します。

バッチは、未使用の予約を使用できるジョブに予約を使用します。予約とその要件の詳細については、VM 予約を使用してリソースの可用性を確保するをご覧ください。

バッチ用の動的ワークロード スケジューラ（プレビュー）

  • ユースケース: 予約を使用せずに A3 マシンシリーズのマシンタイプを持つ VM で GPU を使用する場合は、Dynamic Workload Scheduler を使用することをおすすめします。

  • 詳細: Dynamic Workload Scheduler を使用すると、AI ワークロードと ML ワークロードを高速化する多くのリソースに同時にアクセスできます。たとえば、Dynamic Workload Scheduler は、リソースの使用不可が原因で発生する遅延や問題を軽減することで、ジョブのスケジューリングに役立ちます。

バッチは、次のすべての処理を行う Job に Dynamic Workload Scheduler を使用します。

  • A3 GPU マシンタイプを指定します。
  • 予約をブロックする。具体的には、ジョブで reservation フィールドを NO_RESERVATION に設定する必要があります。詳細については、予約済み VM を使用できないジョブを作成して実行するをご覧ください。
  • Spot VM は使用しないでください。具体的には、ジョブで provisioningModel フィールドを省略するか、provisioningModel フィールドを STANDARD に設定します。

オンデマンド

  • ユースケース: 他のすべてのジョブにはオンデマンドをおすすめします。

  • 詳細: 通常、Compute Engine VM にアクセスするデフォルトの方法はオンデマンドです。オンデマンドでは、リソースを 1 つの VM ずつリクエストし、（利用可能な場合）すぐにアクセスできます。

Batch は、他のすべてのジョブにオンデマンドを使用します。

Spot VM

  • ユースケース: Spot VM を使用して、フォールト トレラントなワークロードのコストを削減することをおすすめします。

  • 詳細: Spot VM を使用すると大幅な割引が提供されますが、常に利用可能であるとは限らず、いつでもプリエンプトされる可能性があります。詳細については、Compute Engine ドキュメントの Spot VM をご覧ください。

Batch は、provisioningModel フィールドを SPOT に設定するジョブに Spot VM を使用します。

ステップ 2: GPU ドライバをインストールする

必要な GPU ドライバをインストールするには、以下のいずれかの方法を選択します。

  • GPU ドライバを自動的にインストールする（可能であれば推奨）: 例に示すように、Batch でサードパーティのロケーションから必要な GPU ドライバをフェッチさせ、ユーザーに代わってインストールする場合は、ジョブの installGpuDrivers フィールドを true に設定します。この方法は、ジョブでドライバを手動でインストールする必要がない場合に推奨されます。

    必要に応じて、Batch がインストールする GPU ドライバのバージョンを指定する場合は、driverVersion フィールドも設定します。

  • GPU ドライバを手動でインストールする: 次のいずれかに該当する場合は、この方法が必要です。

    必要な GPU ドライバを手動でインストールするには、次の方法をおすすめします。

    1. GPU ドライバを含むカスタム VM イメージを作成します。

      1. GPU ドライバをインストールするには、使用する OS に基づいてインストール スクリプトを実行します。

      2. ジョブにコンテナで実行可能なファイルがあり、Container-Optimized OS を使用していない場合は、NVIDIA Container Toolkit もインストールする必要があります。

    2. GPU を使用するジョブを作成して送信する場合は、GPU ドライバを含むカスタム VM イメージを指定し、ジョブの installGpuDrivers フィールドを false（デフォルト）に設定します。

ステップ 3: 互換性のある VM リソースを定義する

ジョブの VM リソースを定義するための要件とオプションについては、ジョブリソースをご覧ください。

要約すると、GPU を使用するジョブの VM リソースを定義するときに、次のすべての操作を行う必要があります。

  • ジョブの VM のロケーションで GPU マシンタイプを使用できることを確認します。

    GPU マシンタイプを使用できる場所については、Compute Engine ドキュメントの リージョンとゾーン別の GPU の可用性をご覧ください。

  • ジョブのマシンタイプを指定する場合は、ジョブのタスク要件に十分な vCPU とメモリがマシンタイプに含まれていることを確認してください。アクセラレータ最適化 VM で GPU を使用する場合は、ジョブのマシンタイプを指定することをおすすめします。N1 VM で GPU を使用する場合は、省略可能です。

  • 有効な方法を使用して、ジョブの VM リソースを定義してください。

    • instances[].policy フィールドを使用して VM リソースを直接定義します（可能であれば推奨）。この方法は例で説明しています。
    • instances[].instanceTemplate フィールドを使用して、テンプレートで VM リソースを定義します。この方法は、カスタム イメージから GPU ドライバを手動でインストールする場合に必要です。詳細については、VM インスタンス テンプレートを使用したジョブリソースの定義をご覧ください。

GPU を使用するジョブの例を作成する

以降のセクションでは、推奨されるオプションを使用して、各 GPU マシンタイプのサンプルジョブを作成する方法について説明します。具体的には、サンプルジョブはすべて GPU ドライバを自動的にインストールし、すべて VM リソースを直接定義し、プロビジョニング方法を指定するか、デフォルトのプロビジョニング方法を使用します。

Dynamic Workload Scheduler for Batch（プレビュー版）で A3 VM に GPU を使用する

gcloud CLI または Batch API を使用して、Dynamic Workload Scheduler を介して A3 VM に GPU を使用するジョブを作成できます。

gcloud

  1. GPU ドライバをインストールし、A3 マシンシリーズのマシンタイプを指定し、予約をブロックし、GPU マシンタイプがあるロケーションで実行する JSON ファイルを作成します。

    たとえば、Dynamic Workload Scheduler を介して A3 VM の GPU を使用する基本的なスクリプト ジョブを作成するには、次の内容の JSON ファイルを作成します。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    次のように置き換えます。

    • INSTALL_GPU_DRIVERS: true に設定すると、Batch は policy フィールドで指定した GPU タイプに必要なドライバをサードパーティの場所からフェッチし、Batch がユーザーに代わってインストールします。このフィールドを false（デフォルト）に設定した場合、このジョブに対して GPU を使用するために GPU ドライバを手動でインストールする必要があります。

    • MACHINE_TYPE: A3 マシンシリーズのマシンタイプ。

    • ALLOWED_LOCATIONS: 必要に応じて、allowedLocations[] フィールドを使用して、ジョブの VM の実行が許可されるリージョンまたはリージョン内の特定のゾーンを指定できます。たとえば、regions/us-central1 はリージョン us-central1 内のすべてのゾーンを許可します。このジョブに必要な GPU マシンタイプを提供するロケーションを指定してください。それ以外の場合は、このフィールドを省略する場合は、ジョブのロケーションで GPU マシンタイプが提供されていることを確認してください。

  2. ジョブを作成して実行するには、gcloud batch jobs submit コマンドを使用します:

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

    以下を置き換えます。

    • JOB_NAME: ジョブの名前。

    • LOCATION: ジョブのロケーション。

    • JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

API

jobs.create メソッドに対して POST リクエストを送信して、GPU ドライバをインストールし、A3 マシンシリーズのマシンタイプを指定し、予約をブロックし、GPU マシンタイプがあるロケーションで実行します。

たとえば、Dynamic Workload Scheduler を介して A3 VM の GPU を使用する基本的なスクリプト ジョブを作成するには、次のリクエストを行います。

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE",
                    "reservation": "NO_RESERVATION"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

次のように置き換えます。

  • PROJECT_ID: プロジェクトのプロジェクト ID

  • LOCATION: ジョブのロケーション。

  • JOB_NAME: ジョブの名前。

  • INSTALL_GPU_DRIVERS: true に設定すると、Batch は policy フィールドで指定した GPU タイプに必要なドライバをサードパーティの場所からフェッチし、Batch がユーザーに代わってインストールします。このフィールドを false（デフォルト）に設定した場合、このジョブに対して GPU を使用するために GPU ドライバを手動でインストールする必要があります。

  • MACHINE_TYPE: A3 マシンシリーズのマシンタイプ。

  • ALLOWED_LOCATIONS: 必要に応じて、allowedLocations[] フィールドを使用して、ジョブの VM の実行が許可されるリージョンまたはリージョン内の特定のゾーンを指定できます。たとえば、regions/us-central1 はリージョン us-central1 内のすべてのゾーンを許可します。このジョブに必要な GPU マシンタイプを提供するロケーションを指定してください。それ以外の場合は、このフィールドを省略する場合は、ジョブのロケーションで GPU マシンタイプが提供されていることを確認してください。

アクセラレータ最適化 VM に GPU を使用する

アクセラレータ最適化 VM に GPU を使用するジョブは、gcloud CLI、Batch API、Java、Node.js、Python を使用して作成できます。

gcloud

  1. GPU ドライバをインストールし、アクセラレータ最適化マシン ファミリーからマシンタイプを指定し、GPU マシンタイプがあるロケーションで実行する JSON ファイルを作成します。

    たとえば、アクセラレータ用に最適化された VM に GPU を使用する基本的なスクリプト ジョブを作成するには、次の内容の JSON ファイルを作成します。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    次のように置き換えます。

    • INSTALL_GPU_DRIVERS: true に設定すると、Batch は policy フィールドで指定した GPU タイプに必要なドライバをサードパーティの場所からフェッチし、Batch がユーザーに代わってインストールします。このフィールドを false（デフォルト）に設定した場合、このジョブに対して GPU を使用するために GPU ドライバを手動でインストールする必要があります。

    • MACHINE_TYPE: アクセラレータ最適化マシン ファミリーのマシンタイプ。

    • ALLOWED_LOCATIONS: 必要に応じて、allowedLocations[] フィールドを使用して、ジョブの VM の実行が許可されるリージョンまたはリージョン内の特定のゾーンを指定できます。たとえば、regions/us-central1 はリージョン us-central1 内のすべてのゾーンを許可します。このジョブに必要な GPU マシンタイプを提供するロケーションを指定してください。それ以外の場合は、このフィールドを省略する場合は、ジョブのロケーションで GPU マシンタイプが提供されていることを確認してください。

  2. ジョブを作成して実行するには、gcloud batch jobs submit コマンドを使用します:

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

    以下を置き換えます。

    • JOB_NAME: ジョブの名前。

    • LOCATION: ジョブのロケーション。

    • JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

API

jobs.create メソッドに POST リクエストを送信して GPU ドライバをインストールし、アクセラレータ最適化マシン ファミリーからマシンタイプを指定し、GPU マシンタイプがあるロケーションで実行します。

たとえば、アクセラレータ用に最適化された VM で GPU を使用する基本的なスクリプト ジョブを作成するには、次のリクエストを行います。

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "machineType": "MACHINE_TYPE"
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

次のように置き換えます。

  • PROJECT_ID: プロジェクトのプロジェクト ID

  • LOCATION: ジョブのロケーション。

  • JOB_NAME: ジョブの名前。

  • INSTALL_GPU_DRIVERS: true に設定すると、Batch は policy フィールドで指定した GPU タイプに必要なドライバをサードパーティの場所からフェッチし、Batch がユーザーに代わってインストールします。このフィールドを false（デフォルト）に設定した場合、このジョブに対して GPU を使用するために GPU ドライバを手動でインストールする必要があります。

  • MACHINE_TYPE: アクセラレータ最適化マシン ファミリーのマシンタイプ。

  • ALLOWED_LOCATIONS: 必要に応じて、allowedLocations[] フィールドを使用して、ジョブの VM の実行が許可されるリージョンまたはリージョン内の特定のゾーンを指定できます。たとえば、regions/us-central1 はリージョン us-central1 内のすべてのゾーンを許可します。このジョブに必要な GPU マシンタイプを提供するロケーションを指定してください。それ以外の場合は、このフィールドを省略する場合は、ジョブのロケーションで GPU マシンタイプが提供されていることを確認してください。

Java


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
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.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJob {

  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";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // Accelerator-optimized machine types are available to Batch jobs. See the list
    // of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
    String machineType = "g2-standard-4";

    createGpuJob(projectId, region, jobName, installGpuDrivers, machineType);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, 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();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run.
      // Read more about machine types here: https://cloud.google.com/compute/docs/machine-types
      InstancePolicy instancePolicy =
          InstancePolicy.newBuilder().setMachineType(machineType).build();  

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(instancePolicy)
                      .build())
              .build();

      Job job =
          Job.newBuilder()
              .addTaskGroups(taskGroup)
              .setAllocationPolicy(allocationPolicy)
              .putLabels("env", "testing")
              .putLabels("type", "script")
              // We use Cloud Logging as it's an out of the box available option.
              .setLogsPolicy(
                  LogsPolicy.newBuilder().setDestination(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-gpu-job';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-l4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'g2-standard-4';

// 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}.'],
  }),
});

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.
// In this case, we tell the system to use "g2-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,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, 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_gpu_job(project_id: str, region: str, job_name: str) -> batch_v1.Job:
    """
    This method shows how to create a sample Batch Job that will run
    a simple command on Cloud Compute instances on GPU machines.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use to run the job. Regions that are
            available for Batch are listed on: https://cloud.google.com/batch/docs/get-started#locations
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

    # Policies are used to define on what kind of virtual machines the tasks will run on.
    # In this case, we tell the system to use "g2-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 = "g2-standard-4"

    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

N1 VM で GPU を使用する

N1 VM で GPU を使用するジョブは、gcloud CLI、Batch API、Java、Node.js、Python を使用して作成できます。

gcloud

  1. GPU ドライバをインストールし、accelerators[] フィールドの type と count のサブフィールドを定義し、GPU マシンタイプがあるロケーションで実行する JSON ファイルを作成します。

    たとえば、N1 VM で GPU を使用し、Batch が正確な N1 マシンタイプを選択できるようにする基本的なスクリプト ジョブを作成するには、次の内容の JSON ファイルを作成します。

    {
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "echo Hello world from task ${BATCH_TASK_INDEX}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

    次のように置き換えます。

    • INSTALL_GPU_DRIVERS: true に設定すると、Batch は policy フィールドで指定した GPU タイプに必要なドライバをサードパーティの場所からフェッチし、Batch がユーザーに代わってインストールします。このフィールドを false（デフォルト）に設定した場合、このジョブに対して GPU を使用するために GPU ドライバを手動でインストールする必要があります。

    • GPU_TYPE: GPU タイプ。使用可能な GPU タイプのリストは、gcloud compute accelerator-types list コマンドを使用することで表示できます。このフィールドは、N1 VM の GPU にのみ使用します。

    • GPU_COUNT: 指定したタイプの GPU の数。有効なオプションの詳細については、N1 マシンシリーズの GPU マシンタイプをご覧ください。このフィールドは、N1 VM の GPU にのみ使用します。

    • ALLOWED_LOCATIONS: 必要に応じて、allowedLocations[] フィールドを使用して、ジョブの VM の実行が許可されるリージョンまたはリージョン内の特定のゾーンを指定できます。たとえば、regions/us-central1 はリージョン us-central1 内のすべてのゾーンを許可します。このジョブに必要な GPU マシンタイプを提供するロケーションを指定してください。それ以外の場合は、このフィールドを省略する場合は、ジョブのロケーションで GPU マシンタイプが提供されていることを確認してください。

  2. ジョブを作成して実行するには、gcloud batch jobs submit コマンドを使用します:

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

    以下を置き換えます。

    • JOB_NAME: ジョブの名前。

    • LOCATION: ジョブのロケーション。

    • JSON_CONFIGURATION_FILE: ジョブの構成の詳細を含む JSON ファイルへのパス。

API

GPU ドライバをインストールし、accelerators[] フィールドの type と count サブフィールドを定義し、GPU マシンタイプがあるロケーションを使用する jobs.create メソッドに対して POST リクエストを作成します。

たとえば、N1 VM で GPU を使用し、Batch が正確な N1 マシンタイプを選択できるようにする基本的なスクリプト ジョブを作成するには、次のリクエストを行います。

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}."
                        }
                    }
                ]
            },
            "taskCount": 3,
            "parallelism": 1
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "installGpuDrivers": INSTALL_GPU_DRIVERS,
                "policy": {
                    "accelerators": [
                        {
                            "type": "GPU_TYPE",
                            "count": GPU_COUNT
                        }
                    ]
                }
            }
        ],
        "location": {
            "allowedLocations": [
                "ALLOWED_LOCATIONS"
            ]
        }
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

次のように置き換えます。

  • PROJECT_ID: プロジェクトのプロジェクト ID

  • LOCATION: ジョブのロケーション。

  • JOB_NAME: ジョブの名前。

  • INSTALL_GPU_DRIVERS: true に設定すると、Batch は policy フィールドで指定した GPU タイプに必要なドライバをサードパーティの場所からフェッチし、Batch がユーザーに代わってインストールします。このフィールドを false（デフォルト）に設定した場合、このジョブに対して GPU を使用するために GPU ドライバを手動でインストールする必要があります。

  • GPU_TYPE: GPU タイプ。使用可能な GPU タイプのリストは、gcloud compute accelerator-types list コマンドを使用することで表示できます。このフィールドは、N1 VM の GPU にのみ使用します。

  • GPU_COUNT: 指定したタイプの GPU の数。有効なオプションの詳細については、N1 マシンシリーズの GPU マシンタイプをご覧ください。このフィールドは、N1 VM の GPU にのみ使用します。

  • ALLOWED_LOCATIONS: 必要に応じて、allowedLocations[] フィールドを使用して、ジョブの VM の実行が許可されるリージョンまたはリージョン内の特定のゾーンを指定できます。たとえば、regions/us-central1 はリージョン us-central1 内のすべてのゾーンを許可します。このジョブに必要な GPU マシンタイプを提供するロケーションを指定してください。それ以外の場合は、このフィールドを省略する場合は、ジョブのロケーションで GPU マシンタイプが提供されていることを確認してください。

Java


import com.google.cloud.batch.v1.AllocationPolicy;
import com.google.cloud.batch.v1.AllocationPolicy.Accelerator;
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.protobuf.Duration;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateGpuJobN1 {

  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";
    // Optional. When set to true, Batch fetches the drivers required for the GPU type
    // that you specify in the policy field from a third-party location,
    // and Batch installs them on your behalf. If you set this field to false (default),
    // you need to install GPU drivers manually to use any GPUs for this job.
    boolean installGpuDrivers = false;
    // The GPU type. You can view a list of the available GPU types
    // by using the `gcloud compute accelerator-types list` command.
    String gpuType = "nvidia-tesla-t4";
    // The number of GPUs of the specified type.
    int gpuCount = 2;

    createGpuJob(projectId, region, jobName, installGpuDrivers, gpuType, gpuCount);
  }

  // Create a job that uses GPUs
  public static Job createGpuJob(String projectId, String region, String jobName,
                                  boolean installGpuDrivers, String gpuType, int gpuCount)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (BatchServiceClient batchServiceClient = BatchServiceClient.create()) {
      // Define what will be done as part of the job.
      Runnable runnable =
          Runnable.newBuilder()
              .setScript(
                  Script.newBuilder()
                      .setText(
                          "echo Hello world! This is task ${BATCH_TASK_INDEX}. "
                                  + "This job has a total of ${BATCH_TASK_COUNT} tasks.")
                      // You can also run a script from a file. Just remember, that needs to be a
                      // script that's already on the VM that will be running the job.
                      // Using setText() and setPath() is mutually exclusive.
                      // .setPath("/tmp/test.sh")
                      .build())
              .build();

      TaskSpec task = TaskSpec.newBuilder()
                  // Jobs can be divided into tasks. In this case, we have only one task.
                  .addRunnables(runnable)
                  .setMaxRetryCount(2)
                  .setMaxRunDuration(Duration.newBuilder().setSeconds(3600).build())
                  .build();

      // Tasks are grouped inside a job using TaskGroups.
      // Currently, it's possible to have only one task group.
      TaskGroup taskGroup = TaskGroup.newBuilder()
          .setTaskCount(3)
          .setParallelism(1)
          .setTaskSpec(task)
          .build();

      // Accelerator describes Compute Engine accelerators to be attached to the VM.
      Accelerator accelerator = Accelerator.newBuilder()
          .setType(gpuType)
          .setCount(gpuCount)
          .build();

      // Policies are used to define on what kind of virtual machines the tasks will run on.
      AllocationPolicy allocationPolicy =
          AllocationPolicy.newBuilder()
              .addInstances(
                  InstancePolicyOrTemplate.newBuilder()
                      .setInstallGpuDrivers(installGpuDrivers)
                      .setPolicy(InstancePolicy.newBuilder().addAccelerators(accelerator))
                      .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-gpu-job-n1';
// The GPU type. You can view a list of the available GPU types
// by using the `gcloud compute accelerator-types list` command.
const gpuType = 'nvidia-tesla-t4';
// The number of GPUs of the specified type.
const gpuCount = 1;
// Optional. When set to true, Batch fetches the drivers required for the GPU type
// that you specify in the policy field from a third-party location,
// and Batch installs them on your behalf. If you set this field to false (default),
// you need to install GPU drivers manually to use any GPUs for this job.
const installGpuDrivers = false;
// Accelerator-optimized machine types are available to Batch jobs. See the list
// of available types on: https://cloud.google.com/compute/docs/accelerator-optimized-machines
const machineType = 'n1-standard-16';

// 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}.'],
  }),
});

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.
// In this case, we tell the system to use "g2-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,
  // Accelerator describes Compute Engine accelerators to be attached to the VM
  accelerators: [
    new batch.AllocationPolicy.Accelerator({
      type: gpuType,
      count: gpuCount,
      installGpuDrivers,
    }),
  ],
});

const allocationPolicy = new batch.AllocationPolicy.InstancePolicyOrTemplate({
  instances: [{installGpuDrivers, 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 callCreateBatchGPUJobN1() {
  // Construct request
  const request = {
    parent,
    jobId: jobName,
    job,
  };

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

await callCreateBatchGPUJobN1();

Python

from google.cloud import batch_v1


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

    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
        zone: name of the zone you want to use to run the job. Important in regard to GPUs availability.
            GPUs availability can be found here: https://cloud.google.com/compute/docs/gpus/gpu-regions-zones
        job_name: the name of the job that will be created.
            It needs to be unique for each project and region pair.

    Returns:
        A job object representing the job created.
    """
    client = batch_v1.BatchServiceClient()

    # Define what will be done as part of the job.
    task = batch_v1.TaskSpec()
    runnable = batch_v1.Runnable()
    runnable.script = batch_v1.Runnable.Script()
    runnable.script.text = "echo Hello world! This is task ${BATCH_TASK_INDEX}. This job has a total of ${BATCH_TASK_COUNT} tasks."
    # You can also run a script from a file. Just remember, that needs to be a script that's
    # already on the VM that will be running the job. Using runnable.script.text and runnable.script.path is mutually
    # exclusive.
    # runnable.script.path = '/tmp/test.sh'
    task.runnables = [runnable]

    # We can specify what resources are requested by each task.
    resources = batch_v1.ComputeResource()
    resources.cpu_milli = 2000  # in milliseconds per cpu-second. This means the task requires 2 whole CPUs.
    resources.memory_mib = 16  # in MiB
    task.compute_resource = resources

    task.max_retry_count = 2
    task.max_run_duration = "3600s"

    # Tasks are grouped inside a job using TaskGroups.
    # Currently, it's possible to have only one task group.
    group = batch_v1.TaskGroup()
    group.task_count = 4
    group.task_spec = task

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

    accelerator = batch_v1.AllocationPolicy.Accelerator()
    # Note: not every accelerator is compatible with instance type
    # Read more here: https://cloud.google.com/compute/docs/gpus#t4-gpus
    accelerator.type_ = "nvidia-tesla-t4"
    accelerator.count = 1

    policy.accelerators = [accelerator]
    instances = batch_v1.AllocationPolicy.InstancePolicyOrTemplate()
    instances.policy = policy
    instances.install_gpu_drivers = True
    allocation_policy = batch_v1.AllocationPolicy()
    allocation_policy.instances = [instances]

    location = batch_v1.AllocationPolicy.LocationPolicy()
    location.allowed_locations = ["zones/us-central1-b"]
    allocation_policy.location = location

    job = batch_v1.Job()
    job.task_groups = [group]
    job.allocation_policy = allocation_policy
    job.labels = {"env": "testing", "type": "container"}
    # We use Cloud Logging as it's an out of the box available option
    job.logs_policy = batch_v1.LogsPolicy()
    job.logs_policy.destination = batch_v1.LogsPolicy.Destination.CLOUD_LOGGING

    create_request = batch_v1.CreateJobRequest()
    create_request.job = job
    create_request.job_id = job_name
    # The job's parent is the region in which the job will run
    create_request.parent = f"projects/{project_id}/locations/{region}"

    return client.create_job(create_request)

次のステップ