A4X を使用するカスタム AI 最適化 GKE クラスタを作成する

このドキュメントでは、A4X 仮想マシン（VM）を使用して AI ワークロードと ML ワークロードをサポートする、AI 最適化 Google Kubernetes Engine（GKE）クラスタを作成する方法について説明します。

A4X マシンシリーズでは、NVIDIA Multi-Node NVLink（MNNVL） システム（ラック スケールのソリューション）を使用して、 大規模な AI/ML クラスタを実行できます。これにより、GPU の電力とパフォーマンスが向上します。詳細については、クラスタ管理 機能をご覧ください。

GKE は、組織の多様なワークロードを実行するための単一のプラットフォーム サーフェスを提供し、複数のプラットフォームを管理する運用上の負担を軽減します。高性能な分散型事前トレーニング、モデルのファインチューニング、モデル推論、アプリケーションの提供、サポート サービスなどのワークロードを実行できます。

このドキュメントでは、ワークロードのニーズに基づいてクラスタを最大限に柔軟に構成するために、Google Cloud CLI を使用して GKE クラスタを作成する方法について説明します。また、Cluster Toolkit を使用して、多くのユースケースのベスト プラクティスを反映したデフォルト設定でクラスタを迅速にデプロイすることもできます。詳細については、 デフォルト 構成で AI に最適化された GKE クラスタを作成するをご覧ください。GPUDirect RDMA の有無にかかわらずワークロードの実行に使用できる A4 または A3 Ultra を使用するクラスタを作成するには、A4 または A3 Ultra を使用する AI 最適化カスタム GKE クラスタを作成するをご覧ください。

始める前に

作業を始める前に、次のタスクが完了していることを確認してください。

  • Google Kubernetes Engine API を有効にする。
    • Google Kubernetes Engine API の有効化
  • このタスクに Google Cloud CLI を使用する場合は、gcloud CLI をインストールして初期化する。gcloud CLI をインストール済みの場合は、gcloud components update コマンドを実行して最新のバージョンを取得します。以前のバージョンの gcloud CLI では、このドキュメントのコマンドを実行できない場合があります。

必要なロール

GKE クラスタの作成と管理に必要な権限を取得するには、プロジェクトに対する次の IAM ロールの付与を管理者に依頼してください。

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

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

容量を取得する

A4X VM の容量は、将来の予約を作成することで取得できます。将来の予約の詳細については、[消費オプションを選択する]の表の [AI Hypercomputer での将来の予約] 列をご覧ください。

将来の予約で容量を取得するには、[AI Hypercomputer での将来の予約] 行を容量を取得する方法の表でご覧ください。

要件

A4X VM を使用する AI 最適化 GKE クラスタには、次の要件が適用されます。

  • A4X の場合は、次のいずれかのバージョンを使用する必要があります。

    • 1.33 以降の場合は、GKE バージョン 1.33.4-gke.1036000 以降を使用します。
    • 1.32 の場合は、GKE バージョン 1.32.8-gke.1108000 以降を使用します。

    これらのバージョンを使用すると、A4X で次のものが使用されます。

    • R580。A4X の最小 GPU ドライバ バージョン。デフォルトで有効になっています。
    • Coherent Driver-based Memory Management（CDMM）。デフォルトで有効になっています。NVIDIA は、メモリの過剰報告を解決するために、Kubernetes クラスタでこのモードを有効にすることを推奨しています。CDMM を使用すると、オペレーティング システム（OS）ではなくドライバを介して GPU メモリを管理できます。このアプローチでは、GPU メモリの OS オンライン化を回避し、GPU メモリを Non-Uniform Memory Access（NUMA）ノードとして OS に公開できます。CDMM が有効になっている場合、マルチインスタンス GPU はサポートされません。CDMM の詳細については、ハードウェアとソフトウェア サポートをご覧ください。
    • GPUDirect RDMA と MNNVL。A4X ノードプールで A4X のネットワーキング機能を使用できるようにすることをおすすめします。

  • GKE ノードでは Container-Optimized OS ノードイメージを使用する必要があります。Ubuntu と Windows のノードイメージはサポートされません。

  • GKE ワークロードでは、使用可能なすべての GPU を使用する必要があります。また、Pod では、単一の GKE ノードで使用可能なすべてのセカンダリ NIC を使用する必要があります。 複数の Pod が単一の GKE ノードで RDMA を共有することはできません。

  • A4X を使用してクラスタを作成するには、予約にバインドされた プロビジョニング モデルを使用する必要があります。他のプロビジョニング モデルはサポートされていません。

  • GPUDirect RDMA は、NCCL Fast Socket または GPUDirect TCPX/TCPXO と互換性がありません。GPUDirect RDMA を使用するクラスタで NCCL Fast Socket を有効にしたり、TCPX/TCPXO プラグインをインストールしたりしないでください。

クラスタの作成に関する考慮事項

クラスタを作成するときは、次の情報を考慮してください。

  • クラスタのロケーションを選択する:
    • 選択したマシンタイプが使用可能なロケーションを使用していることを確認します。詳細については、 GPU のロケーションをご覧ください。
    • 高密度予約の場合は、ゾーンクラスタを作成できます。この場合は、 --region フラグを --zone=COMPUTE_ZONE フラグに置き換えます。 COMPUTE_ZONE はコントロール プレーンのゾーンです。
    • リージョン クラスタでノードプールを作成する場合は、--node-locations フラグを使用して GKE ノードのゾーンを指定できます。
  • ドライバ バージョンを選択する:
    • ドライバ バージョンは、次のいずれかの値になります。
      • default: GKE ノード バージョンのデフォルトのドライバ バージョンをインストールします。デフォルトの ドライバ バージョンの要件の詳細については、要件セクションをご覧ください。
      • latest: GKE バージョンに対応する最新のドライバ バージョンをインストールします。このオプションは、Container-Optimized OS を使用するノードでのみ使用できます。
      • disabled: ドライバの自動インストールをスキップします。ノードプールを作成した後に、 手動でドライバをインストールする 必要があります。
    • GKE ノード バージョンのデフォルトと最新の GPU ドライバ バージョンの詳細については、 NVIDIA GPU ドライバを手動でインストールするの表をご覧ください。

  • 予約アフィニティを選択する:

    • 予約の名前や予約内の特定のブロックの名前など、予約に関する情報を確認できます。これらの値を確認するには、将来の予約リクエストを表示するをご覧ください。
    • --reservation-affinity フラグには、specific または any の値を指定できます。ただし、高性能な分散 AI ワークロードの場合は、特定の予約を使用することをおすすめします。

    • 共有予約を含む特定の予約を使用する場合は、shared reservations、 --reservation フラグの値を次の形式で指定します。

      projects/PROJECT_ID/reservations/RESERVATION_NAME/reservationBlocks/BLOCK_NAME

      次の値を置き換えます。

      • PROJECT_ID: 実際の Google Cloud プロジェクト ID。
      • RESERVATION_NAME: 予約の名前。
      • BLOCK_NAME: 予約内の特定のブロックの名前。

      VM が BLOCK_NAME 内の単一のサブブロックに配置されるように、サブブロックをターゲットとする予約を使用するには、パスの末尾に次の内容を追加します。

      /reservationSubBlocks/SUB_BLOCK_NAME

      SUB_BLOCK_NAME は、サブブロックの名前に置き換えます。

A4X と GPUDirect RDMA を使用する AI 最適化 GKE クラスタを作成する

分散 AI ワークロードの場合、複数の GPU ノードがリンクされて 1 台のコンピュータとして動作することがよくあります。A4X は、NVIDIA GB200 NVL72 ラックスケール アーキテクチャに基づくエクサスケール プラットフォームです。このマシンタイプでは、AI ワークロードに高性能なクラウド エクスペリエンスを提供することで、複数の GPU 間でのスケーリングとコラボレーションが可能になります。ネットワーク帯域幅や NIC の配置など、A4X のネットワークのアーキテクチャの詳細については、A4X マシン タイプをご覧ください。

A4X と GPUDirect RDMA を使用して GKE Standard クラスタを作成するには、次のセクションで説明する次の手順を完了します。

  1. VPC とサブネットを作成する
  2. マルチネットワーキングを使用して GKE クラスタを作成する
  3. GKE ネットワーク オブジェクトを作成する
  4. ワークロード ポリシーの作成
  5. A4X を使用してノードプールを作成する
  6. RDMA バイナリをインストールして NCCL を構成する
  7. NVIDIA Compute Domain CRD と DRA ドライバをインストールする

VPC とサブネットを作成する

A4X VM の構成は次のとおりです。

  • NVLink NVLink で接続された 1 仮想マシンあたり 4 個の NVIDIA B200 GPU
  • 2 つの Arm ベースの NVIDIA Grace CPU
  • GPU 間ネットワーキング用の 4 つの 400 Gbps CX-7 ネットワーク インターフェース カード（NIC）
  • 外部サービス用の 2 つの 200 Gbps Google Titanium ネットワーク インターフェース カード（NIC）

分散トレーニングなどの AI ワークロードと ML ワークロードでは、ジョブの完了時間を短縮してパフォーマンスを最適化するために、強力なアクセラレーションが必要となります。高性能、高スループット、低レイテンシを必要とするワークロードの場合、GPUDirect RDMA は、GPU 間でペイロードを転送するために必要なネットワーク ホップを削減します。このアプローチでは、使用可能なネットワーク帯域幅をより効率的に使用できます。

CPU に関連付けられている Google Titanium NIC の 1 つは GKE のデフォルト ネットワークを使用するため、デフォルト ネットワークに十分な IP アドレス範囲がある限り、この NIC 用に新しい VPC を作成する必要はありません。

次のコマンドを使用して、2 番目の CPU Titanium NIC（gVNIC）用に 1 つの VPC を作成し、4 つの CX-7 RDMA NIC 用に別の VPC を作成できます。

ネットワーク帯域幅を最大化するため、追加の GVNIC 用の VPC を作成するコマンドでは、最大伝送単位（MTU）が 8896 に設定されます。RDMA VPC のデフォルトは、推奨設定の 8896 です。詳細については、MTU 設定と GPU マシンタイプをご覧ください。

  1. デプロイに合わせて環境変数を設定します。

    export REGION="COMPUTE_REGION"
export ZONE="COMPUTE_ZONE"
export PROJECT="PROJECT_ID"
export GVNIC_NETWORK_PREFIX="GVNIC_NETWORK_PREFIX"
export RDMA_NETWORK_PREFIX="RDMA_NETWORK_PREFIX"

    次の変数を置き換えます。

    • COMPUTE_REGION: クラスタのリージョン。
    • COMPUTE_ZONE: ノードプールのゾーン。
    • PROJECT_ID: 実際の Google Cloud プロジェクト ID。
    • GVNIC_NETWORK_PREFIX: GVNIC ネットワークの接頭辞（例: a4x-gvnic）。
    • RDMA_NETWORK_PREFIX: RDMA ネットワークの接頭辞（例: a4x-rdma）。

  2. 2 つの VPC ネットワークを作成します。

    # Create a VPC for the additional GVNIC
gcloud compute --project=${PROJECT} \
  networks create \
  GVNIC_NETWORK_PREFIX-net \
  --subnet-mode=custom \
  --mtu=8896

gcloud compute --project=${PROJECT} \
  networks subnets create \
  GVNIC_NETWORK_PREFIX-sub \
  --network=GVNIC_NETWORK_PREFIX-net \
  --region=${REGION} \
  --range=192.168.0.0/24

gcloud compute --project=${PROJECT} \
  firewall-rules create \
  GVNIC_NETWORK_PREFIX-internal \
  --network=GVNIC_NETWORK_PREFIX-net \
  --action=ALLOW \
  --rules=tcp:0-65535,udp:0-65535,icmp \
  --source-ranges=192.168.0.0/16

# Create HPC VPC for the RDMA NICs with 4 subnets.
gcloud compute --project=${PROJECT} \
  networks create RDMA_NETWORK_PREFIX-net \
  --network-profile=${ZONE}-vpc-roce \
  --subnet-mode=custom

# Create subnets for the HPC VPC.
for N in $(seq 0 3); do
  gcloud compute --project=${PROJECT} \
    networks subnets create \
    RDMA_NETWORK_PREFIX-sub-$N \
    --network=RDMA_NETWORK_PREFIX-net \
    --region=${REGION} \
    --range=192.168.$((N+1)).0/24 &  # offset to avoid overlap with gvnics
done

マルチネットワーキングを使用して GKE クラスタを作成する

  1. マルチネットワーキングを使用して GKE Standard クラスタを作成します。

    gcloud container clusters create CLUSTER_NAME \
    --enable-dataplane-v2 --enable-ip-alias --location=COMPUTE_REGION \
    --enable-multi-networking --cluster-version=CLUSTER_VERSION \
    --enable-kubernetes-unstable-apis=resource.k8s.io/v1beta1/deviceclasses,resource.k8s.io/v1beta1/resourceclaims,resource.k8s.io/v1beta1/resourceclaimtemplates,resource.k8s.io/v1beta1/resourceslices \
    [--services-ipv4-cidr=SERVICE_CIDR \
    --cluster-ipv4-cidr=POD_CIDR]

    このコマンドを準備するときは、次の操作を行います。

    • GKE バージョン 1.34 以降を実行するクラスタを作成する場合は、DRA を有効にするために使用される --enable-kubernetes-unstable-apis フラグを削除します。このフラグは、バージョン 1.32 または 1.33 を実行するクラスタを作成する場合にのみ必要です。ベータ版 API を有効にすると、ベータ版 API が非推奨になり、以降の Kubernetes マイナー バージョンで削除されるまで、ベータ版 API から移行する必要があります。詳細については、ベータ版 API の非推奨をご覧ください。

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

      • CLUSTER_NAME: クラスタの名前。
      • CLUSTER_VERSION: 新しいクラスタのバージョン。GKE のどのバージョンが構成をサポートしているかについては、 このドキュメントの 要件をご覧ください。
      • COMPUTE_REGION: コンピューティング リージョンの名前。

    • 必要に応じて、サービスと Pod のセカンダリ CIDR の範囲を明示的に指定できます。これらのオプション フラグを使用する場合は、次の変数を置き換えます。

      • SERVICE_CIDR: Service のセカンダリ CIDR の範囲。
      • POD_CIDR: Pod のセカンダリ CIDR の範囲。

      これらのフラグを使用する場合は、CIDR の範囲が追加のノード ネットワークのサブネット範囲と重複してないことを確認する必要があります。たとえば、 SERVICE_CIDR=10.65.0.0/19 と POD_CIDR=10.64.0.0/19 を考えてみましょう。詳細については、Pod の IPv4 アドレス範囲を追加するをご覧ください。

  2. 次のセクションで kubectl コマンドを実行するには、クラスタに接続します。

    gcloud container clusters get-credentials CLUSTER_NAME --location=COMPUTE_REGION

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

    • CLUSTER_NAME: クラスタの名前。
    • COMPUTE_REGION: コンピューティング リージョンの名前。

    詳細については、kubectl をインストールしてクラスタ アクセスを構成するをご覧ください。

GKE ネットワーク オブジェクトを作成する

前のセクションで作成した VPC ネットワークは、GKE ネットワーク パラメータ セットを使用して構成する必要があります。具体的には、2 番目の CPU Titanium NIC（gVNIC）を NetDevice モードで構成し、4 つの CX-7 RDMA NIC をそれぞれ RDMA モードで構成する必要があります。

このコマンドでは、次の名前を使用します。

  • CPU Titanium NIC（gVNIC）VPC は GVNIC_NETWORK_PREFIX-net という名前で、サブネットは GVNIC_NETWORK_PREFIX-sub という名前です。
  • CX-7 RDMA NIC の VPC は RDMA_NETWORK_PREFIX-net という名前で、サブネットは RDMA_NETWORK_PREFIX-sub-[0…3] という名前です。

次のコマンドを実行して、GKE ネットワーク オブジェクトを作成します。

kubectl apply -f - <<EOF
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: GVNIC_NETWORK_PREFIX-net
  vpcSubnet: GVNIC_NETWORK_PREFIX-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: RDMA_NETWORK_PREFIX-net
  vpcSubnet: RDMA_NETWORK_PREFIX-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
EOF

ワークロード ポリシーの作成

パーティションを作成するには、ワークロード ポリシーが必要です。詳細については、 MIG の ワークロード ポリシーをご覧ください。

accelerator_topology フィールドが 1x72 に設定された HIGH_THROUGHPUT ワークロード ポリシーを作成します。

gcloud beta compute resource-policies create workload-policy WORKLOAD_POLICY_NAME \
    --type HIGH_THROUGHPUT \
    --accelerator-topology 1x72 \
    --project PROJECT \
    --region COMPUTE_REGION

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

  • WORKLOAD_POLICY_NAME: ワークロード ポリシーの名前。
  • PROJECT: プロジェクトの名前。
  • COMPUTE_REGION: コンピューティング リージョンの名前。

A4X を使用してノードプールを作成する

GKE GPU デバイス プラグインを使用するノードプールを作成することをおすすめします。このプラグインは、GKE 管理の GPU リソース管理を提供します。このアプローチには次のようなメリットがあります。

  • デプロイとアップグレードが容易
  • ドライバの自動インストール
  • 指標やパーティション分割された GPU など、GKE 管理の GPU 機能
  • 重要なセキュリティの脆弱性の修正

または、ユースケースで必要な場合は、NVIDIA GPU Operator を使用することもできます。詳細については、NVIDIA GPU Operator を使用する理由をご覧ください。

GKE GPU デバイス プラグインを使用して A4X ノードプールを作成する

GKE GPU デバイス プラグインを使用する A4X ノードプールを作成します。

gcloud container node-pools create NODE_POOL_NAME \
    --location COMPUTE_REGION \
    --node-locations COMPUTE_ZONE \
    --cluster CLUSTER_NAME \
    --num-nodes=NODE_COUNT \
    --machine-type MACHINE_TYPE \
    --accelerator type=nvidia-gb200,count=4,gpu-driver-version=DRIVER_VERSION \
    --additional-node-network network=GVNIC_NETWORK_PREFIX-net,subnetwork=GVNIC_NETWORK_PREFIX-sub \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-0 \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-1 \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-2 \
    --additional-node-network network=RDMA_NETWORK_PREFIX-net,subnetwork=RDMA_NETWORK_PREFIX-sub-3 \
    --scopes "https://www.googleapis.com/auth/cloud-platform" \
    --reservation-affinity=specific \
    --reservation=RESERVATION_NAME/reservationBlocks/BLOCK_NAME \
    --placement-policy=WORKLOAD_POLICY_NAME

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

  • NODE_POOL_NAME: ノードプールの名前。
  • COMPUTE_REGION: クラスタのリージョン。
  • COMPUTE_ZONE: ノードプールのゾーン。
  • CLUSTER_NAME: クラスタの名前。
  • NODE_COUNT: ノードプールのノード数。18 個以下のノード数にする必要があります。NVLink ドメインを使用して、1 つのサブブロックで 1x72 の GPU トポロジを取得するには、18 個のノードを使用することをおすすめします。
  • MACHINE_TYPE: ローカル SSD が必要かどうかによって、a4x-highgpu-4g または a4x-highgpu-4g-nolssd。
  • DRIVER_VERSION: インストールする NVIDIA ドライバのバージョン。default、latest、disabled のいずれかの値を指定できます。
  • RESERVATION_NAME: 予約の名前。この値を確認するには、 将来の予約リクエストを表示するをご覧ください。
  • BLOCK_NAME: 予約内の特定のブロックの名前。この値を確認するには、 将来の予約リクエストを表示するをご覧ください。
  • WORKLOAD_POLICY_NAME: 前に作成したワークロード ポリシーの名前。

NVIDIA GPU Operator を使用して A4X ノードプールを作成する

または、NVIDIA GPU Operator を使用するには、次の手順を行います。

  1. 前のセクションの gcloud container node-pools create コマンドを次の変更を加えて実行します。

    • gpu-driver-version=latest を gpu-driver-version=disabled に変更します。NVIDIA GPU Operator を使用する場合は、GPU ドライバの自動インストールはサポートされていないため、この変更により自動インストールはスキップされます。
    • --node-labels="gke-no-default-nvidia-gpu-device-plugin=true" を設定して 、GKE 管理の GPU デバイス プラグインの DaemonSet を無効にします。

  2. GKE GPU ドライバ インストーラ DaemonSet マニフェストを適用します。このマニフェストは、各 A4X ノードに GPU ドライバ インストーラ Pod をデプロイします。

    kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

  3. Google Kubernetes Engine（GKE）で NVIDIA GPU Operator を使用して GPU スタックを管理します。

    1. GPU ノード プールを作成して設定するの手順で、認証情報を取得する手順から始まる手順に沿って操作します。

    2. NVIDIA GPU Operatorをインストールします。 すべての手順を完了しますが、Helm を使用して NVIDIA GPU Operator をインストールする参照セクションのコマンドを置き換えます。代わりに次のコマンドを使用します。

      helm install --wait --generate-name \
  -n gpu-operator \
  nvidia/gpu-operator \
  --version="25.3.0" \
  -f <(cat <<EOF
hostPaths:
  driverInstallDir: /home/kubernetes/bin/nvidia
toolkit:
  installDir: /home/kubernetes/bin/nvidia
cdi:
  enabled: true
  default: true
driver:
  enabled: false

daemonsets:
  tolerations:
    - key: nvidia.com/gpu
      operator: Equal
      value: present
      effect: NoSchedule
    - key: kubernetes.io/arch
      operator: Equal
      value: arm64
      effect: NoSchedule

node-feature-discovery:
  worker:
    tolerations:
      - key: kubernetes.io/arch
        operator: Equal
        value: arm64
        effect: NoSchedule
      - key: "node-role.kubernetes.io/master"
        operator: "Equal"
        value: ""
        effect: "NoSchedule"
      - key: "node-role.kubernetes.io/control-plane"
        operator: "Equal"
        value: ""
        effect: "NoSchedule"
      - key: nvidia.com/gpu
        operator: Exists
        effect: NoSchedule
EOF
)

RDMA バイナリをインストールして NCCL を構成する

次の DaemonSet を適用して、各ノードに RDMA バイナリと NCCL ライブラリをインストールします。基盤となる各 VM に、RDMA バイナリは /home/kubernetes/bin/gib ディレクトリにインストールされ、NCCL ライブラリは /home/kubernetes/bin/nvidia/lib64 ディレクトリにインストールされます。

  kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/gpudirect-rdma/nccl-rdma-installer-a4x.yaml

NVIDIA Compute Domain CRD と DRA ドライバをインストールする

次の手順では、NVIDIA Compute Domain CRD と DRA ドライバをインストールして、MNNVL を使用できるようにします。詳細については、GPU 用の NVIDIA DRA ドライバ をご覧ください。

  1. 開発環境に Helm がインストールされていることを確認する。Helm は Cloud Shell に事前にインストールされています。

    特定の Helm バージョンの要件はありません。次のコマンドを使用すると、Helm がインストールされていることを確認できます。

    helm version

    出力が Command helm not found のようになる場合は、次のコマンドを実行して Helm CLI をインストールできます。

    curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 \
  && chmod 700 get_helm.sh \
  && ./get_helm.sh

  2. NVIDIA Helm リポジトリを追加します。

    helm repo add nvidia https://helm.ngc.nvidia.com/nvidia \
  && helm repo update

  3. DRA ドライバの ResourceQuota を作成します。

    export POD_QUOTA=POD_QUOTA

kubectl create ns nvidia-dra-driver-gpu

kubectl apply -n nvidia-dra-driver-gpu -f - << EOF
apiVersion: v1
kind: ResourceQuota
metadata:
  name: nvidia-dra-driver-gpu-quota
spec:
  hard:
    pods: ${POD_QUOTA}
  scopeSelector:
    matchExpressions:
    - operator: In
      scopeName: PriorityClass
      values:
        - system-node-critical
        - system-cluster-critical
EOF

    POD_QUOTA は、クラスタ内の A4X ノード数の 2 倍以上の数に置き換えます。たとえば、クラスタに 18 個の A4X ノードがある場合は、変数を 37 以上に設定する必要があります。

  4. DRA ドライバをインストールします。

    helm install nvidia-dra-driver-gpu nvidia/nvidia-dra-driver-gpu \
    --version="DRA_DRIVER_VERSION" \
    --create-namespace \
    --namespace nvidia-dra-driver-gpu \
    -f <(cat <<EOF
nvidiaDriverRoot: /home/kubernetes/bin/nvidia
resources:
  gpus:
    enabled: false

controller:
  affinity:
      nodeAffinity:
        requiredDuringSchedulingIgnoredDuringExecution:
          nodeSelectorTerms:
          - matchExpressions:
            - key: "nvidia.com/gpu"
              operator: "DoesNotExist"

kubeletPlugin:
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
          - matchExpressions:
              - key: cloud.google.com/gke-accelerator
                operator: In
                values:
                  - nvidia-gb200
              - key: kubernetes.io/arch
                operator: In
                values:
                  - arm64

  tolerations:
    - key: nvidia.com/gpu
      operator: Equal
      value: present
      effect: NoSchedule
    - key: kubernetes.io/arch
      operator: Equal
      value: arm64
      effect: NoSchedule
EOF
)

    DRA_DRIVER_VERSION は、バージョン 25.3.1 以降に置き換えます。使用可能な NVIDIA DRA ドライバ バージョンのリストは、helm search repo nvidia/nvidia-dra-driver-gpu --versions コマンドを実行すると確認できます。または、 GitHub リリースノートを確認して、使用可能なバージョンを見つけます。

マルチネットワーキング、RDMA、IMEX ドメイン用にワークロード マニフェストを構成する

  1. Pod メタデータに次のアノテーションを追加します。

    metadata:
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"}
      ]

  2. Arm ノードでスケジュールするノード アフィニティ ルールを追加します。

    spec:
affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/arch
          operator: In
          values:
          - arm64

    詳細については、単一アーキテクチャにワークロードをスケジュールするをご覧ください。

  3. 次の Volume を Pod 仕様に追加します。

    spec:
volumes:
  - name: library-dir-host
    hostPath:
      path: /home/kubernetes/bin/nvidia
  - name: gib
    hostPath:
      path: /home/kubernetes/bin/gib

  4. GPU をリクエストするコンテナに、次のボリューム マウント、環境変数、リソースを追加します。ワークロード コンテナは、4 つの GPU すべてをリクエストする必要があります。

    containers:
- name: my-container
  volumeMounts:
    - name: library-dir-host
      mountPath: /usr/local/nvidia
    - name: gib
   mountPath: /usr/local/gib
  env:
    - name: LD_LIBRARY_PATH
      value: /usr/local/nvidia/lib64
  resources:
    limits:
      nvidia.com/gpu: 4

  5. ワークロードの ComputeDomain リソースを作成します。

    apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-compute-domain-channel

    NUM_NODES は、ワークロードに必要なノード数に置き換えます。

  6. Pod が使用する ResourceClaimTemplate を指定します。

    spec:
  ...
  volumes:
    ...
  containers:
    - name: my-container
      ...
      resources:
        limits:
          nvidia.com/gpu: 4
  claims:
          - name: compute-domain-channel
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-compute-domain-channel

  7. 必要な環境変数をすべて設定して NCCL を構成します。ワークロード コンテナから次のシェル スクリプトを使用します。

    source /usr/local/gib/scripts/set_nccl_env.sh

完成した Pod 仕様は次のようになります。

apiVersion: resource.nvidia.com/v1beta1
kind: ComputeDomain
metadata:
  name: a4x-compute-domain
spec:
  numNodes: NUM_NODES
  channel:
    resourceClaimTemplate:
      name: a4x-compute-domain-channel
---
apiVersion: apps/v1
kind: Pod
metadata:
  name: my-pod
  labels:
    k8s-app: my-pod
  annotations:
    networking.gke.io/default-interface: 'eth0'
    networking.gke.io/interfaces: |
      [
        {"interfaceName":"eth0","network":"default"},
        {"interfaceName":"eth2","network":"rdma-0"},
        {"interfaceName":"eth3","network":"rdma-1"},
        {"interfaceName":"eth4","network":"rdma-2"},
        {"interfaceName":"eth5","network":"rdma-3"},
      ]
spec:
  ...
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: kubernetes.io/arch
            operator: In
            values:
            - arm64
  volumes:
    - name: library-dir-host
      hostPath:
        path: /home/kubernetes/bin/nvidia
    - name: gib
      hostPath:
        path: /home/kubernetes/bin/gib
  containers:
    - name: my-container
      volumeMounts:
        - name: library-dir-host
          mountPath: /usr/local/nvidia
        - name: gib
       mountPath: /usr/local/gib
      env:
        - name: LD_LIBRARY_PATH
          value: /usr/local/nvidia/lib64
      resources:
        limits:
          nvidia.com/gpu: 4
        claims:
          - name: compute-domain-channel
        ...
resourceClaims:
  - name: compute-domain-channel
    resourceClaimTemplateName: a4x-compute-domain-channel

ネットワーク パフォーマンスをテストする

プロビジョニングされたクラスタの機能を検証することをおすすめします。これを行うには、NCCL/gIB テストを使用します。これは、Google 環境向けに最適化された NVIDIA Collective Communications Library（NCCL）テストです。

次のステップ