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

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

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

始める前に

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

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

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

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

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

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

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

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

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

  1. GPU マシンタイプと消費オプションを選択する
  2. GPU ドライバをインストールする
  3. 互換性のある VM リソースを定義する

ステップ 1: GPU マシンタイプと消費オプションを選択する

ジョブの要件は、優先する GPU マシンタイプと使用オプションによって異なり、各オプションは相互に依存している可能性があります。

ジョブの GPU マシンタイプと使用量オプションを選択する手順は次のとおりです。

  1. 優先度を特定して選択します。

  2. 最初の選択内容と互換性のあるものに基づいて、残りの選択を行います。

    1. 最初の選択と互換性のあるオプションを確認するには、Compute Engine ドキュメントのマシンタイプ別の消費オプションの可用性をご覧ください。

    2. 消費オプションを選択するまたはGPU マシンタイプを選択するについては、それぞれ残りのセクションをご覧ください。

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

ジョブの GPU マシンタイプを選択し、ジョブの要件を確認する手順は次のとおりです。

  1. GPU マシンタイプを選択する: 使用可能な GPU マシンタイプ（GPU タイプ、GPU の数、マシンタイプ（vCPU とメモリ）の有効な組み合わせ）とその推奨されるユースケースを確認するには、Compute Engine ドキュメントの GPU マシンタイプとアクセラレータ最適化マシン ファミリーをご覧ください。

  2. 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 とメモリのオプションは非常に柔軟性があります。 Google Cloud コンソールを使用してジョブを作成する場合を除き、ジョブのタスク要件を満たすマシンタイプを Batch に自動的に選択させることができます。
使用オプションを選択する

このセクションでは、ジョブの消費オプションを選択する方法と、各オプションのジョブ要件の概要について説明します。

Batch で使用可能な消費オプションとその要件については、次の表で説明します。この表では、ユースケースに基づいて、リソースの可用性が高い順にオプションを並べています。

まとめると、ほとんどのユーザーには、ジョブの消費オプションを次のように選択することをおすすめします。

  • 他の条件のいずれかが true でない限り、Flex Start VM（プレビュー）（要件を満たす場合は推奨）またはオンデマンドを使用します。
  • ジョブでリソースの可用性が非常に高いことが求められる場合や、削除できない未使用の予約がある場合は、カレンダー モードの予約（プレビュー）（要件を満たす場合は推奨）または予約を使用します。
  • （省略可）ワークロードのフォールト トレランスが高い場合は、Spot VM を使用してコストを削減できる可能性があります。
使用オプションとそのジョブ要件

予約

  • ユースケース: リソースの可用性を非常に高いレベルで保証したい場合や、カレンダー モードの予約を使用できない場合、または未使用の可能性がある既存の予約がすでに存在する場合は、ジョブに予約を使用することをおすすめします。

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

    予約の詳細については、Compute Engine ドキュメントをご覧ください。

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

カレンダー モードの予約（プレビュー）

  • ユースケース: カレンダー モードの予約をサポートする GPU マシンタイプを使用し、少なくとも 1 日から最大 90 日間、リソースの可用性を非常に高いレベルで保証する必要がある場合は、ジョブにカレンダー モードの予約をおすすめします。

  • 詳細: ジョブを作成する前に、使用できるカレンダー モードの予約をリクエストするか、特定する必要があります。Compute Engine がカレンダー モードで将来の予約リクエストを満たすと、自動作成されたカレンダー モードの予約には、指定された VM を予約期間全体にわたって Dynamic Workload Scheduler の料金で実行した場合と同じ費用が発生します。この料金では、オンデマンド料金から最大 53% の割引が適用されます。使用できる自動作成のカレンダー モードの予約を特定したら、カレンダー モードの予約を使用するジョブの作成は、予約を使用するジョブの作成と非常によく似ています。

    カレンダー モードの予約の詳細については、Compute Engine ドキュメントをご覧ください。

Batch は、次のすべての処理を行うジョブにカレンダー モードの予約を使用します。

Flex Start VM（プレビュー）

  • ユースケース: 割引料金と最大 7 日間の実行完了期間でベスト エフォートの可用性を許容できる場合は、Flex Start VM をおすすめします。

    オンデマンド VM や Spot VM と比較して、Flex Start VM を使用すると、多くの GPU リソースに同時にアクセスしやすくなります。たとえば、Flex Start VM は、リソースが使用できないために発生する遅延や問題を軽減することで、ジョブのスケジューリングに役立ちます。

  • 詳細: Flex Start VM を使用するジョブの作成リクエストが満たされると、VM には Dynamic Workload Scheduler の料金が適用されます。この料金では、オンデマンド料金から最大 53% の割引が適用されます。

    Compute Engine ドキュメントで Flex-start VM の詳細を確認する。

Batch は、次のすべての処理を行うジョブに Flex Start VM を使用します。

オンデマンド

  • ユースケース: デフォルトでは、他のほとんどのジョブにオンデマンドをおすすめします。1

  • 詳細: 通常、オンデマンドは Compute Engine VM にアクセスするデフォルトの方法です。オンデマンドでは、リクエスト時にリソースにアクセスできます（利用可能な場合）。リソースは、ジョブが完了するか、実行時間の上限に達するまで削除されます。

Batch は、デフォルトで他のほとんどのジョブにオンデマンドを使用します。ジョブでオンデマンドを使用するようにするには、次の操作を行います。1

  • provisioningModel フィールドを STANDARD に設定します。
  • ブロック予約。ジョブが互換性のある予約を自動的に使用しないようにするには、reservation フィールドを NO_RESERVATION に設定します。詳細については、予約済み VM を使用できないジョブを作成して実行するをご覧ください。

1例外: A3 マシンシリーズを使用するジョブの場合、デフォルトの動作は一意です。オンデマンドを使用せず、provisioningModel フィールドを未定義のままにしないことをおすすめします。代わりに、Flex-start VM のジョブ要件を使用してください。リソースの可用性が低いため、A3 マシンシリーズではオンデマンドの使用はおすすめしません。したがって、ジョブが A3 マシンシリーズを使用し、予約をブロックし、provisioningModel フィールドが未定義または STANDARD に設定されている場合、デフォルトの使用オプションは一意になります。この動作は Flex Start VM と似ており、実行時間が 7 日間に制限されます。ただし、これらのジョブは Dynamic Workload Scheduler の料金から割引を受けられないため、おすすめしません。A3 VM を使用するジョブで 7 日間の実行時間制限が許容される場合は、オンデマンドではなく Flex Start VM を使用することをおすすめします。それ以外の場合は、provisioningModel を STANDARD に設定し、reservation フィールドを NO_RESERVATION に設定せずに、ジョブが予約を使用できないことを手動で確認しない限り、A3 VM を使用するジョブでオンデマンドが使用されることを保証できません。

Spot VM

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

  • 詳細: Spot VM を使用するジョブの作成リクエストが満たされると、VM は Spot VM の料金で課金されます。この料金は頻繁に変更される可能性があり、オンデマンド料金から最大 91% の割引が適用される場合があります。ただし、Spot VM は常に利用可能であるとは限らず、いつでもプリエンプトできます。

    Compute Engine ドキュメントで Spot VM の詳細を確認する。

Batch は、次のすべての処理を行うジョブに Spot VM を使用します。

  • provisioningModel フィールドを SPOT に設定します。
  • （省略可）予約をブロックします。予約で Spot VM を使用することはできません。具体的には、ジョブで reservation フィールドを NO_RESERVATION に設定できます（この設定は省略可能です）。詳細については、予約済み VM を使用できないジョブを作成して実行するをご覧ください。

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

ジョブで GPU を使用するには、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 リソースを定義する場合は、次のすべての操作を行う必要があります。

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

    GPU マシンタイプを使用できるロケーションについては、Compute Engine ドキュメントのアクセラレータの可用性をご覧ください。

  • ジョブのマシンタイプを指定する場合は、そのマシンタイプにジョブのタスク要件に十分な vCPU とメモリが含まれていることを確認してください。 Google Cloud コンソールを使用してジョブを作成する場合は、ジョブのマシンタイプを指定する必要があります。また、アクセラレータ最適化 VM で GPU を使用するジョブを作成する場合は、ジョブのマシンタイプを指定することをおすすめします。

  • ジョブの VM リソースを定義するには、次の有効な方法を使用します。

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

GPU を使用するサンプルジョブを作成する

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

使用オプション ジョブ指示の例
予約またはカレンダー モードの予約（プレビュー）

VM 予約を使用してリソースの可用性を確保する
Flex Start VM（プレビュー）

GPU と Flex Start VM を使用する
オンデマンド VM または Spot VM

GPU マシンタイプに基づいて、次のいずれかのオプションを選択します。

GPU と Flex Start VM を使用する

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

gcloud

  1. GPU ドライバをインストールし、Flex-start VM をサポートする GPU マシンタイプを指定し、予約をブロックし、GPU マシンタイプをサポートするロケーションで実行する JSON ファイルを作成します。

    たとえば、アクセラレータ最適化 VM に Flex-start 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": {
                    "provisioningModel":"FLEX_START",
                    "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: Flex Start VM をサポートする GPU マシンタイプ。詳細については、Compute Engine ドキュメントのマシンタイプ別の消費オプションの可用性をご覧ください。

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

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

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

    以下を置き換えます。

    • JOB_NAME: ジョブの名前。

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

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

API

GPU ドライバをインストールし、Flex-start VM をサポートする GPU マシンタイプを指定し、予約をブロックし、GPU マシンタイプをサポートするロケーションで実行する v1alpha jobs.create メソッドに POST リクエストを送信します。

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

POST https://batch.googleapis.com/v1alpha/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": {
                    "provisioningModel":"FLEX_START",
                    "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: Flex Start VM をサポートする GPU マシンタイプ。詳細については、Compute Engine ドキュメントのマシンタイプ別の消費オプションの可用性をご覧ください。

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

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

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

コンソール

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

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

    ジョブリストに移動する

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

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

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

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

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

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

        たとえば、基本的なスクリプト ジョブを作成するには、次の操作を行います。

        1. [スクリプト] チェックボックスをオンにします。フィールドが表示されます。

        2. フィールドに次のスクリプトを入力します。

          echo Hello world from task ${BATCH_TASK_INDEX}.

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

      2. [タスク数] フィールドに、このジョブのタスク数を入力します。

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

      3. 省略可: [並列処理] フィールドに、同時に実行するタスクの数を入力します。

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

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

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

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

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

      • それ以外の場合は、オンデマンド VM を使用するために [標準]（デフォルト）を選択します。

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

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

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

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

        • それ以外の場合は、[任意]（デフォルト）を選択します。

    4. このジョブの VM の GPU マシンタイプを選択します。

      1. マシン ファミリー オプションで、[GPU] をクリックします。

      2. [GPU のタイプ] フィールドで、GPU のタイプを選択します。次に、[GPU の数] フィールドで、各 VM に対する GPU の数を選択します。

        アクセラレータ最適化 VM の GPU タイプのいずれかを選択した場合、[マシンタイプ] フィールドでは、選択した GPU のタイプと数に基づいて、マシンタイプのオプションが 1 つだけ表示されます。

      3. GPU ドライバを自動的にインストールするには、[GPU ドライバのインストール]（デフォルト）を選択します。

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

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

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

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

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

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

  5. 省略可: このジョブの他のフィールドを構成します。

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

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

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

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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "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 ドライバを手動でインストールする必要があります。

    • PROVISIONING_MODEL: 消費オプションのプロビジョニング モデル。オンデマンドの場合は STANDARD、Spot VM の場合は SPOT。

    • 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

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

たとえば、アクセラレータ最適化 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "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 ドライバを手動でインストールする必要があります。

  • PROVISIONING_MODEL: 消費オプションのプロビジョニング モデル。オンデマンドの場合は STANDARD、Spot VM の場合は SPOT。

  • 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 を使用するジョブは、 Google Cloud コンソール、gcloud CLI、Batch API、Java、Node.js、Python を使用して作成できます。

コンソール

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

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

    ジョブリストに移動する

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

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

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

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

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

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

        たとえば、基本的なスクリプト ジョブを作成するには、次の操作を行います。

        1. [スクリプト] チェックボックスをオンにします。フィールドが表示されます。

        2. フィールドに次のスクリプトを入力します。

          echo Hello world from task ${BATCH_TASK_INDEX}.

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

      2. [タスク数] フィールドに、このジョブのタスク数を入力します。

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

      3. 省略可: [並列処理] フィールドに、同時に実行するタスクの数を入力します。

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

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

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

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

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

      • それ以外の場合は、オンデマンド VM を使用するために [標準]（デフォルト）を選択します。

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

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

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

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

        • それ以外の場合は、[任意]（デフォルト）を選択します。

    4. このジョブの VM の GPU マシンタイプを選択します。

      1. マシン ファミリー オプションで、[GPU] をクリックします。

      2. [GPU のタイプ] フィールドで、GPU のタイプを選択します。

        N1 VM の GPU タイプのいずれかを選択すると、[シリーズ] フィールドが N1 に設定されます。

      3. [GPU の数] フィールドで、各 VM に対する GPU の数を選択します。

      4. [マシンタイプ] フィールドで、マシンタイプを選択します。

      5. GPU ドライバを自動的にインストールするには、[GPU ドライバのインストール]（デフォルト）を選択します。

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

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

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

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

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

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

  5. 省略可: このジョブの他のフィールドを構成します。

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

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

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

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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "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 ドライバを手動でインストールする必要があります。

    • PROVISIONING_MODEL: 消費オプションのプロビジョニング モデル。オンデマンドの場合は STANDARD、Spot VM の場合は SPOT。

    • 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": {
                    "provisioningModel": "PROVISIONING_MODEL",
                    "reservation": "NO_RESERVATION",
                    "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 ドライバを手動でインストールする必要があります。

  • PROVISIONING_MODEL: 消費オプションのプロビジョニング モデル。オンデマンドの場合は STANDARD、Spot VM の場合は SPOT。

  • 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)

次のステップ