Azure Kubernetes Service (AKS)での機械学習操作 (MLOps) のベスト プラクティス

適用対象: ✔️ AKS 自動 ✔️ AKS Standard

MLOps は、運用環境で機械学習モデルをデプロイ、監視、管理するための一連のプラクティスです。

この記事で取り上げる主要な MLOps のベスト プラクティス:

  • コードとしてのインフラストラクチャ (IaC)
  • コンテナ化
  • モデルの管理とバージョン管理
  • Automation
  • スケーラビリティとリソース管理
  • 実行時間の長いバッチジョブの信頼性
  • セキュリティとコンプライアンス

この記事では、AKS で MLOps を使用する際に留意すべきベスト プラクティスと考慮事項について説明します。 MLOps の詳細については、 AI と機械学習ワークフローの機械学習操作 (MLOps) に関する説明を参照してください。

MLOps の AKS モードを選択する

AKS では、 AKS Automatic と AKS Standard の 2 つのクラスター モードがサポートされています。 2 日目のプラットフォーム管理を減らした運用環境対応のベースラインが必要な場合は、AKS Automatic を選択します。 クラスター インフラストラクチャとプラットフォーム構成をより詳細に制御する必要がある場合は、AKS Standard を選択します。

この記事の MLOps プラクティスは、両方のモードに適用されます。 ただし、実装の責任はモードによって異なります。AKS 自動では、より構成済みの既定値が提供されますが、AKS Standard では通常、より明示的なプラットフォーム構成とライフサイクルの所有権が必要です。

Area AKS Automatic AKS Standard
ベースライン クラスターのセットアップ 事前構成されたノードプール、ネットワーク、モニタリングをすぐに利用可能 ノード プール、CNI、および可観測スタックを手動で構成する必要があります
システムノードプールの操作 サービスによって管理されるノードの自動プロビジョニングとスケーリング オペレーターは、ノード プールのサイズ変更、スケーリング規則、メンテナンス期間を構成する必要があります
セキュリティ ベースラインの制御 既定で有効になっているネットワーク ポリシー、ポッドのセキュリティ標準、ワークロード ID オペレーターは、ネットワーク ポリシー、ポッドのセキュリティ、ID 設定を明示的に有効にして構成する必要があります
ネットワーク ベースライン 既定のイングレス パターンを使用した事前構成済み Azure CNI オーバーレイ CNI プラグインの選択、カスタム イングレス コントローラーの構成、ネットワーク トポロジの定義を柔軟に行える
操作とアップグレード ノード イメージと Kubernetes バージョンの自動アップグレード オペレーターがアップグレードのタイミングとロールアウト戦略をスケジュールして管理する
MLOps の実装に重点を置く 既定値を検証、管理、調整する プラットフォーム コントロールの設計と構成
GPU 容量とスケジューリング リージョン SKU の可用性とサブスクリプション クォータに応じて、ワークロード リソースの要求とスケジュールの制約から、対象となる GPU 容量を自動的にプロビジョニングできます オペレーターは、GPU ノード プール、ラベル、テイント、オートスケーラーの制限、ドライバー、デバイス プラグインの構成を作成して管理します
分散トレーニング 既定の Kubernetes スケジューリングと自動ノード プロビジョニングは出発点を提供しますが、学習オペレーター、ギャングスケジューラ、トポロジ チューニングは引き続きワークロード レベルで選択すべき事項です オペレーターは、トレーニング オペレーターとスケジューラを明示的にインストールし、分散ジョブの GPU ノード プール、ネットワーク、スケーリング、配置を設計します

コードとしてのインフラストラクチャ (IaC)

重要なポイント: AI パイプラインの各ステージに対して IaC テンプレートを定義してバージョンを設定し、一貫性、コスト効率、迅速なデプロイを実現します。

IaC を使用すると、さまざまな種類のアプリケーションに対して、一貫性のある再現可能なインフラストラクチャのプロビジョニングと管理が可能になります。 アプリケーションのデプロイが異なると、推論、サービス、トレーニング、および微調整モデルに必要なコンピューティング能力とリソースが異なる可能性があるため、IaC の実装は AI パイプライン全体で変更される可能性があります。 AI 開発者チームの IaC テンプレートを定義およびバージョン管理することで、ハードウェア要件を明確にし、デプロイ プロセスを加速しながら、ジョブの種類全体の一貫性とコスト効率を確保できます。

AKS Automatic では、IaC は、プラットフォームの既定値よりもワークロード定義、ポリシー ガードレール、環境の一貫性に重点を置くことができます。 AKS Standard では、IaC には通常、ネットワーク、スケーリング、運用構成の選択など、より明示的なクラスター プラットフォーム設定が含まれています。

コンテナ化

重要なポイント: コンテナー イメージにモデルの重み、メタデータ、および構成をパッケージ化して、移植性、簡略化されたバージョン管理、ストレージ コストの削減を実現します。

コンテナー イメージでモデルの重み、メタデータ、および構成を管理することで、移植性、簡略化されたバージョン管理、および時間の経過に伴うストレージ コストの削減が可能になります。 コンテナー化を使用すると、次のことができます。

  • 既存のコンテナー イメージを使用します。特に、セキュリティで保護されたコンテナー レジストリに格納されている、数百万から数十億のサイズのパラメーターと安定した拡散モデルの範囲の大規模な言語モデル (LLM) に使用します。
  • 1 つの大きなイメージを維持する代わりに、各タスクの一意の依存関係を含む複数の軽量コンテナーを使用して、パイプラインの単一障害点を回避します。
  • 基本コンテナー イメージの外部に大きなテキストデータセットとイメージ データセットを格納し、実行時に必要に応じてそれらを参照します。 Kubernetes AI Toolchain Operator (KAITO) の使用を開始 して、AKS に LLM をデプロイします。

コンテナー サプライ チェーンの制御は、両方のモードで引き続き不可欠です。 AKS Automatic で事前構成されたプラットフォームの既定値を使用していても、イメージの来歴、スキャン、ランタイムのハードニングは、依然として MLOps の中核的な責務です。

ML ワークロードの Dockerfile パターン:

タグ付けされていない基本イメージ参照の代わりに、GPU トレーニング ワークロード ( pytorch/pytorch:2.4.1-cuda12.4-cudnn9-runtime など) に対して CUDA 対応の明示的な基本イメージ タグを使用します。 再現可能なビルドと予測可能な CUDA/cuDNN 動作を保証するために、運用環境でダイジェストによって画像をピン留めします。 スケジューラの配置とランタイムの依存関係が明示的に維持されるように、CPU と GPU のイメージバリアントを個別に維持します。

モデルの管理とバージョン管理

重要なポイント: モデルを体系的にバージョン管理して、環境間の一貫性を維持し、パラメーター効率の高い微調整方法を使用して迅速な反復を可能にします。

モデルの管理とバージョン管理は、時間の経過に伴うモデルの変更を追跡するために不可欠です。 モデルをバージョン管理することで、次のことができます。

  • さまざまな環境でのデプロイを容易にするために、モデル コンテナー間で一貫性を維持します。
  • パラメーター効率の高い微調整 (PEFT) メソッドを使用して、モデルの重みのサブセットをより迅速に反復処理し、軽量コンテナーで新しいバージョンを維持します。

AKS Automatic では、事前構成済みのプラットフォーム ベースラインにより、環境パリティを簡略化できます。 AKS Standard では、多くの場合、チームはプラットフォームとデプロイの構成を通じてパリティをより明示的に適用する必要があります。

Automation

重要なポイント: データ インジェスト、モデル パフォーマンスの監視、パイプラインの再トレーニングを自動化して、手動エラーを減らし、ML ライフサイクル全体の一貫性を確保します。

自動化は、手動エラーの削減、効率の向上、ML ライフサイクル全体の一貫性の確保に役立ちます。 タスクを自動化することで、次のことができます。

  • アラート ツールを統合して、新しいデータ がアプリケーションに流れ込むにつれてベクター インジェスト フローをトリガーします。
  • モデルのパフォーマンスしきい値を設定して、低下を追跡し、再トレーニング パイプラインをトリガーします。

どちらの AKS モードにも、モデル品質トリガーに加えて、ポリシー検証、構成ドリフト検出、リリース ガバナンスの自動化が含まれます。

スケーラビリティとリソース管理

重要なポイント: 分散コンピューティング、自動スケーリング、ディザスター リカバリーの計画を通じてリソース使用量を最適化し、さまざまな AI パイプラインの需要をコスト効率に応じて処理します。

スケーラビリティとリソース管理は、AI パイプラインがアプリケーションの要求を確実に処理するために不可欠です。 リソースの使用量を最適化することで、次のことができます。

  • 分散コンピューティングと複数レベルの並列処理 (データ、モデル、パイプラインの並列処理など) を使用して、割り当てられた CPU、GPU、メモリ リソースを効率的に使用するツールを統合します。
  • コンピューティング リソースの自動スケールを有効にして、ピーク時に高いモデル要求量をサポートし、ピーク時以外の時間でスケールダウンします。
  • AKS の回復性と信頼性のベスト プラクティスに従って、ディザスター リカバリーを計画します。

AKS Automatic を使用すると、一般的なスケーリングと操作パターンのセットアップ オーバーヘッドを減らすことができますが、AKS Standard ではカスタム スケーリング アーキテクチャをより詳細に制御できます。

長時間実行されるバッチ ジョブを実行する

重要なポイント: Kubernetes Jobとして有限の作業を実行し、ポッドの外部で進行状況を保持し、終了シグナルを処理し、ジョブが複数回開始される可能性があると想定します。

ノードのアップグレード、再起動、スケールダウン イベント、リソースの負荷、プリエンプション、インフラストラクチャの障害により、実行時間の長いバッチ ジョブが中断される可能性があります。 Kubernetes Job は、障害が発生したポッドまたは削除されたポッドを置き換えますが、以前のポッドのローカル ファイルやプロセス メモリがない別のノードで置換が開始されます。 永続的な状態から再開し、安全に作業を繰り返すアプリケーションを設計します。

これらのプラクティスは、通常の CPU、メモリ、または I/O 集中型バッチ ジョブに使用します。 一括スケジュールとワークロード キューのガイダンスは、分散ワークロードで複数のワーカーが一緒に開始する必要がある場合、またはチームが共有クォータを必要とする場合に適用されます。 単一のワーカーによる、あるいは独立して並行実行されるバッチジョブでは、通常、ギャング スケジューリングは必要ありません。

チェックポイント処理、再試行、終了を構成する

次の例では、一連の作業項目を処理し、次の項目をAzure Files永続ボリュームに記録します。 ポッドの置換後にチェックポイントを復元し、プロセスが SIGTERMを受け取ったときに進行状況を保存します。

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: batch-checkpoints
spec:
  accessModes:
  - ReadWriteMany
  storageClassName: azurefile-csi
  resources:
    requests:
      storage: 10Gi
---
apiVersion: batch/v1
kind: Job
metadata:
  name: checkpointed-batch
spec:
  backoffLimit: 6
  activeDeadlineSeconds: 86400
  ttlSecondsAfterFinished: 86400
  podFailurePolicy:
    rules:
    - action: Ignore
      onPodConditions:
      - type: DisruptionTarget
  template:
    metadata:
      labels:
        app: checkpointed-batch
    spec:
      restartPolicy: Never
      terminationGracePeriodSeconds: 120
      containers:
      - name: worker
        image: ubuntu:24.04
        command:
        - /bin/bash
        - -c
        - |
          set -euo pipefail

          CHECKPOINT=/checkpoints/next-item
          NEXT_ITEM=1

          if [[ -f "${CHECKPOINT}" ]]; then
            NEXT_ITEM="$(cat "${CHECKPOINT}")"
            echo "Resuming at item ${NEXT_ITEM}."
          fi

          save_checkpoint() {
            printf '%s\n' "${NEXT_ITEM}" > "${CHECKPOINT}.tmp"
            mv "${CHECKPOINT}.tmp" "${CHECKPOINT}"
            echo "Saved checkpoint for item ${NEXT_ITEM}."
          }

          terminate() {
            echo "Received a termination signal."
            save_checkpoint
            exit 143
          }

          trap terminate TERM INT

          while (( NEXT_ITEM <= 1000 )); do
            echo "Processing item ${NEXT_ITEM}."
            sleep 10
            NEXT_ITEM=$((NEXT_ITEM + 1))
            save_checkpoint
          done

          echo "Batch completed."
        resources:
          requests:
            cpu: "1"
            memory: 1Gi
          limits:
            cpu: "1"
            memory: 1Gi
        volumeMounts:
        - name: checkpoints
          mountPath: /checkpoints
      volumes:
      - name: checkpoints
        persistentVolumeClaim:
          claimName: batch-checkpoints

サンプル ループをバッチ アプリケーションに置き換え、スループットと回復の要件を満たすストレージを選択します。 アプリケーションがAzure Blob Storageまたは別のAzure サービスに直接チェックポイントを設定する場合は、埋め込み資格情報の代わりにワークロード ID を使用します。

これらの信頼性コントロールを意図的に適用します。

  • チェックポイント処理とべき等性: 目標復旧ポイントを満たす間隔で進行状況を保存します。 チェックポイントとコミットされた出力は、コンテナー ファイル システム、 emptyDir、またはノード ローカル ストレージではなく、永続的ストレージに格納します。 同じジョブ プログラムが複数回起動する場合があるため、アトミック書き込み、べき等キー、トランザクション出力、または重複除去を使用します。
  • 再起動動作: ジョブでは、 restartPolicy: Never または OnFailureが許可されます。 Neverでは、失敗したコンテナーによって障害が発生したポッドが生成され、ジョブ コントローラーによって置換が作成されます。 OnFailureを使用すると、kubelet は同じポッド内のコンテナーを再起動できます。 失敗したポッドとログを個別に作成すると、診断が容易になり、どちらのパスも安全に再開できる場合は、 Never を使用します。
  • 再試行の制限: ワークロードが許容できる一時的な障害の数に基づいて backoffLimit を設定します。 podFailurePolicy を使用して、既知の再試行不可の終了コードでは即座に失敗させるか、または例のように、任意の中断によって再試行バジェットが消費されるのを防止します。 中断によっても Pod は停止する可能性があります。ポリシーが変更するのは、Job がその失敗をどのようにカウントするかだけです。
  • 期限: 最大合計実行時間の後にジョブを停止する必要がある場合に activeDeadlineSeconds を設定します。 期限には再試行が含まれており、 backoffLimitよりも優先されます。 予想されるランタイムより短い期限と、再試行と復旧時間を設定しないでください。 失敗したジョブは、新しいジョブとして自動的に再起動されません。
  • 正常な終了処理: アプリケーション内で SIGTERM を処理し、新しい作業の受け入れを停止し、現在の処理単位を安全に完了または中断し、出力をフラッシュし、チェックポイントを保存できるように、terminationGracePeriodSeconds を十分長く設定します。 Kubernetes は、プロセスが猶予期間を超えた場合に SIGKILL を送信するため、定期的なチェックポイントが必要なままです。
  • クリーンアップ: ttlSecondsAfterFinished 設定するか、CronJob 履歴の制限を構成して、完了したジョブとポッドが蓄積されないようにします。 ログの収集とインシデント調査に十分な期間、ジョブ レコードを保持します。

削除とノードのメンテナンスを計画する

長期にわたるジョブの復旧戦略として、強制終了の阻止を第一の手段とみなしてはなりません。 再起動可能なバッチ ジョブの場合、通常は PodDisruptionBudget (PDB) を作成しないでください。ジョブ コントローラーは、自発的な中断の後に代替ポッドを作成します。 PDB は、自発的な削除からのみ保護し、ノードの障害、リソース負荷の排除、またはプリエンプションから保護しません。 中断をゼロにする PDB は、ノードのドレインをブロックし、AKS のアップグレードを遅らせることもできます。

並列バッチ ワークロードで同時に実行されるワーカーの最小数を保持する必要があり、そのドレイン動作をテストした場合にのみ、PDB を使用します。 同様に、 cluster-autoscaler.kubernetes.io/safe-to-evict: "false" は、例外的な、非開始可能な作業にのみ使用します。 注釈はスケールダウンを防ぎ、コストを増やすことができますが、ノードの障害やメンテナンス イベントごとに保護されるわけではありません。

AKS は、古いノードを置き換える前に、そのノードのコードンを適用し、保護ゾーンをアップグレードして動作を停止させます。 サポートされている AKS メンテナンスを影響度の低い期間に合わせて計画 メンテナンス期間 を構成しますが、メンテナンスのタイミングによって計画外の中断が解消されないため、ワークロードを再起動可能な状態に保ちます。 AKS Standard の場合、個別の VM サイズ、スケーリング制限、テイント、またはアップグレードタイミングが必要な場合は、専用ユーザー ノード プールでバッチ ジョブを実行します。 プリエンプションから回復できない作業では、スポット ノード プールを避けます。 ノードのメンテナンスの前に、最近のチェックポイントが使用可能であり、別の対象となるノード プールに、代替ポッドを実行するのに十分なクォータと容量があることを確認します。

ジョブの進行状況と復旧状況の監視

実行時間の長いジョブを調査するときは、Kubernetes の状態、イベント、ログをまとめて使用します。

kubectl get job checkpointed-batch --watch
kubectl describe job checkpointed-batch
kubectl get pods -l batch.kubernetes.io/job-name=checkpointed-batch
kubectl logs job/checkpointed-batch

Prometheus と Container Insights 向け Azure Monitor マネージド サービスを有効にして、ログを保持し、ジョブの状態をポッドの再起動、エビクション、保留時間、ノードの正常性、およびリソース使用率と関連付けられるようにします。 完了した項目、失敗した項目、最後に成功したチェックポイント時間、処理レート、再試行回数、推定完了時間などのビジネス進行状況シグナルを使用してアプリケーションをインストルメント化します。 失敗したジョブ、想定時間を超過したジョブ、目標復旧時点内にチェックポイントがない場合、Pod の再作成の繰り返し、保留状態の Pod が継続している場合、ならびに処理スループットの停滞に対してアラートを出します。

セキュリティとコンプライアンス

重要なポイント: CVE スキャン、監査証跡、コンプライアンス制御を実装してデータを保護し、SOC 2、HIPAA、GDPR などの規制要件を満たします。

セキュリティとコンプライアンスは、データを保護し、AI パイプラインが規制要件を満たしていることを確認するために重要です。 セキュリティとコンプライアンスのベスト プラクティスを実装することで、次のことができます。

  • 一般的な脆弱性と露出 (CVE) のスキャンを統合して、オープンソース モデルのコンテナー イメージの一般的な脆弱性を検出します。
  • Azure Container Registry に格納されているモデル コンテナー イメージには、Microsoft Defender for Containers を使用します。
  • 取り込まれたデータ、モデルの変更、メトリックの監査証跡を維持して、組織のポリシーに準拠し続けます。
  • SOC 2 (Azureの監査ログとアクセス制御を通じて)、HIPAA (保存時および転送中の暗号化、ネットワークの分離)、GDPR (データ所在地オプションとアクセス管理ポリシーを通じて) などのコンプライアンス フレームワークをサポートします。

AKS 自動では、構成済みのセキュリティの既定値によってベースラインの体制が向上しますが、モデル レベル、データ レベル、パイプライン レベルのセキュリティ制御は引き続き必要です。

GPU ワークロードのスケジュール設定

重要なポイント: NVIDIA デバイス プラグインを介して GPU を公開し、GPU を明示的に要求し、ラベル、テイント、および容認を使用して高価な GPU ノードを分離します。

Kubernetes では、GPU が拡張リソースとしてスケジュールされます。 NVIDIA デバイス プラグインがノードに GPU を登録した後、ポッドは、nvidia.com/gpuとresources.requestsの両方でresources.limitsを設定して GPU を要求します。 次のポッドは、1 つの GPU を要求し、 accelerator=nvidiaというラベルが付いたノード プールを対象としています。

apiVersion: v1
kind: Pod
metadata:
  name: gpu-training-pod
  labels:
    app: gpu-training
spec:
  restartPolicy: Never
  nodeSelector:
    accelerator: nvidia
  tolerations:
  - key: sku
    operator: Equal
    value: gpu
    effect: NoSchedule
  containers:
  - name: trainer
    image: nvcr.io/nvidia/cuda:12.4.1-runtime-ubuntu22.04
    command:
    - /bin/bash
    - -c
    - |
      set -e
      nvidia-smi
      echo "GPU is available to the training container."
    resources:
      requests:
        cpu: "1"
        memory: 2Gi
        nvidia.com/gpu: 1
      limits:
        cpu: "1"
        memory: 2Gi
        nvidia.com/gpu: 1

拡張リソースはオーバーコミットされていません。 Kubernetes では、制限のみが指定されている場合に GPU 制限が GPU 要求として扱われますが、両方のフィールドを設定するとワークロードの意図が明示的になり、ポリシーの検証に役立ちます。

AKS GPU ノード プールをプロビジョニングする

AKS Standard の場合は、サポートされている NVIDIA GPU VM サイズの専用ユーザー ノード プールを作成します。 次のAzure CLI例では、自動スケーリングされた Standard_NC4as_T4_v3 ノード プールを作成し、前のポッドで使用されているラベルを適用し、ノードをテイントして、GPU ノードを明示的に許容しないワークロードを撃退します。

RESOURCE_GROUP=myResourceGroup
AKS_CLUSTER=myAKSCluster

az aks nodepool add \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$AKS_CLUSTER" \
  --name gpunp \
  --mode User \
  --node-vm-size Standard_NC4as_T4_v3 \
  --node-count 0 \
  --enable-cluster-autoscaler \
  --min-count 0 \
  --max-count 4 \
  --labels accelerator=nvidia workload=training \
  --node-taints sku=gpu:NoSchedule

ノード プールを作成する前に、VM SKU がクラスター リージョンで使用可能であり、サブスクリプションに十分なリージョンと VM ファミリのクォータがあることを確認します。 GPU メモリ、GPU 数、CPU 対 GPU 比、ローカル ストレージ、ネットワーク、トレーニング フレームワークで必要な CUDA 機能に基づいて NC シリーズ のサイズを選択します。 たとえば、NCas T4 v3 サイズは、多くの単一 GPU および小規模なトレーニング ワークロードに適していますが、NC A100 v4 サイズでは、より大きなモデルとマルチインスタンス GPU 構成がサポートされます。

AKS Automatic では、保留中のポッドに応答して、対象となる GPU 容量をプロビジョニングできます。 ワークロードは引き続き nvidia.com/gpuを要求する必要があり、ノード セレクター、アフィニティ、容認、トポロジの制約、サブスクリプション クォータ、リージョン SKU の可用性が満たされている必要があります。 固定 VM SKU、カスタム ノード プールのライフサイクル、または GPU プールのスケーリングとトポロジの詳細な制御が必要な場合は、AKS Standard を使用します。

NVIDIA デバイス プラグインを確認またはインストールする

AKS GPU 構成では、マネージド GPU ドライバーとデバイス プラグインの統合を提供できます。 別のプラグインをインストールする前に、有効な構成を確認します。

kubectl get nodes -L accelerator,kubernetes.azure.com/agentpool
kubectl get daemonsets --all-namespaces | grep -i nvidia
kubectl describe node | grep -A5 -E "Capacity:|Allocatable:|nvidia.com/gpu"

同じノードで複数の NVIDIA デバイス プラグイン DaemonSet を実行しないでください。 AKS 構成でプラグインが管理されない場合、次のスタンドアロン DaemonSet によって NVIDIA GPU が kubelet に登録されます。 NVIDIA ドライバーと Kubernetes バージョンでサポートされているデバイス プラグインのバージョンをインストールします。

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nvidia-device-plugin
  namespace: kube-system
  labels:
    app.kubernetes.io/name: nvidia-device-plugin
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: nvidia-device-plugin
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      labels:
        app.kubernetes.io/name: nvidia-device-plugin
    spec:
      priorityClassName: system-node-critical
      nodeSelector:
        accelerator: nvidia
      tolerations:
      - operator: Exists
      containers:
      - name: nvidia-device-plugin
        image: nvcr.io/nvidia/k8s-device-plugin:v0.17.1
        args:
        - --fail-on-init-error=false
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop:
            - ALL
        volumeMounts:
        - name: device-plugin
          mountPath: /var/lib/kubelet/device-plugins
      volumes:
      - name: device-plugin
        hostPath:
          path: /var/lib/kubelet/device-plugins
          type: Directory

トレーニング ジョブを送信する前に、各 GPU ノードの割り当て可能なリソースの下に nvidia.com/gpu が表示されることを確認します。

MIG を使用して A100 GPU と H100 GPU をパーティション分割する

NVIDIA マルチインスタンス GPU (MIG) では、サポートされている A100 または H100 GPU を分離された GPU インスタンスにパーティション分割できます。 MIG は、ハイパーパラメーターのチューニングや、物理 GPU 全体を必要としない小規模な微調整ジョブに役立ちます。 すべての GPU メモリ、最大相互接続帯域幅、またはインストールされている GPU でサポートされていないプロファイルを必要とするワークロードには、完全な GPU を使用します。

宣言型 MIG ライフサイクル管理が必要な場合は、NVIDIA GPU オペレーターと MIG マネージャーを使用します。 オペレーターは、影響を受けるノードのデバイス プラグインと MIG 構成を所有する必要があります。2 つ目のスタンドアロン デバイス プラグインと組み合わせないでください。 正確なプロファイル名とインスタンス数は、GPU モデルとメモリ容量によって異なります。 次の構成では、サポートされている 80 GB A100 または H100 構成で 7 つの 1g.10gb インスタンスが作成されます。

apiVersion: v1
kind: Namespace
metadata:
  name: gpu-operator
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: mig-parted-config
  namespace: gpu-operator
data:
  config.yaml: |
    version: v1
    mig-configs:
      all-disabled:
      - devices: all
        mig-enabled: false
      hptuning-1g10gb:
      - devices: all
        mig-enabled: true
        mig-devices:
          "1g.10gb": 7
---
apiVersion: v1
kind: Namespace
metadata:
  name: ml-training
---
apiVersion: batch/v1
kind: Job
metadata:
  name: mig-hyperparameter-trial
  namespace: ml-training
  labels:
    workload: hyperparameter-tuning
spec:
  backoffLimit: 2
  template:
    metadata:
      labels:
        workload: hyperparameter-tuning
    spec:
      restartPolicy: Never
      nodeSelector:
        accelerator: nvidia
        nvidia.com/mig.config: hptuning-1g10gb
        nvidia.com/mig.config.state: success
      tolerations:
      - key: sku
        operator: Equal
        value: gpu
        effect: NoSchedule
      containers:
      - name: trial
        image: nvcr.io/nvidia/cuda:12.4.1-runtime-ubuntu22.04
        command:
        - /bin/bash
        - -c
        - |
          set -e
          nvidia-smi
          echo "Starting one hyperparameter trial on a MIG instance."
          sleep 30
        resources:
          requests:
            cpu: "2"
            memory: 8Gi
            nvidia.com/mig-1g.10gb: 1
          limits:
            cpu: "2"
            memory: 8Gi
            nvidia.com/mig-1g.10gb: 1

ConfigMap を使用するように GPU オペレーターの MIG マネージャーを構成し、ワークロードが MIG プロファイルという名前を要求するときに MIG 戦略を使用し、ターゲット ノードにラベルを付けます。

kubectl label nodes \
  -l accelerator=nvidia \
  nvidia.com/mig.config=hptuning-1g10gb \
  --overwrite

MIG レイアウトを変更すると、GPU を既に使用しているワークロードが中断されます。 Cordon とターゲット ノードをドレインし、メンテナンス期間中に構成を適用し、要求されたプロファイルが、ジョブを送信する前にノードの割り当て可能なリソースに存在することを確認します。

テイントとトレランスを使用して GPU ワークロードを分離する

NoScheduleテイントは、通常のアプリケーション ポッドを高価な GPU ノードから遠ざけます。 ノード プールの作成例は、 sku=gpu:NoSchedule適用されます。 次の完全なジョブには、一致する容認とノード セレクターが含まれています。

apiVersion: batch/v1
kind: Job
metadata:
  name: isolated-gpu-training
spec:
  backoffLimit: 3
  template:
    metadata:
      labels:
        app: isolated-gpu-training
    spec:
      restartPolicy: Never
      nodeSelector:
        accelerator: nvidia
        workload: training
      tolerations:
      - key: sku
        operator: Equal
        value: gpu
        effect: NoSchedule
      containers:
      - name: trainer
        image: nvcr.io/nvidia/cuda:12.4.1-runtime-ubuntu22.04
        command:
        - /bin/bash
        - -c
        - |
          set -e
          nvidia-smi
          sleep 60
        resources:
          requests:
            cpu: "4"
            memory: 16Gi
            nvidia.com/gpu: 1
          limits:
            cpu: "4"
            memory: 16Gi
            nvidia.com/gpu: 1

容認ではスケジューリングが許可されますが、GPU ノードにポッドを強制的に適用することはありません。 容認を GPU リソース要求とノード セレクターまたはノード アフィニティとペアにします。 ネットワーク、監視、ストレージ、デバイス プラグインなどの必要なプラットフォーム DaemonSet が GPU テイントを許容していることを確認します。

分散トレーニング ワークロードを実行する

重要なポイント: トレーニング オペレーターを使用してワーカーの ID とジョブのライフサイクルを管理し、マルチノード間のネットワーク通信を検証し、すべてのワーカーを同時に起動する必要がある場合はギャングアドミッションを使用します。

分散トレーニングでは、複数のプロセスを使用して、データ、モデルの状態、またはパイプラインのステージを分割します。 Kubernetes では、オペレーターはワーカー ポッドの作成、ランデブー構成の挿入、レプリカの状態の追跡、失敗したワーカーの再起動、ジョブのクリーンアップを行うことができます。 個々のチームが非管理クラスター全体の CRD をインストールできるようにするのではなく、プラットフォームの IaC とリリース プロセスを通じてトレーニング オペレーターをインストールおよびバージョン管理します。

ポータブル CUDA トレーニング イメージを構築する

次の Dockerfile は、コンテナー化セクションで識別される Dockerfile パターンを展開します。 イメージには CUDA ランタイムと PyTorch ライブラリが含まれていますが、互換性のある NVIDIA ドライバーは AKS GPU ノードに残ります。

FROM pytorch/pytorch:2.4.1-cuda12.4-cudnn9-runtime

WORKDIR /workspace

COPY requirements.txt .
RUN python -m pip install --no-cache-dir -r requirements.txt

COPY train.py .

ENTRYPOINT ["python", "/workspace/train.py"]

本番環境では、ベース イメージを不変のダイジェストで固定します。 データセットと頻繁に変更されるチェックポイントをイメージの外部に保持し、結果のイメージをスキャンしてからAzure Container Registryにプッシュします。

PyTorchJob を実行する

Kubeflow トレーニング オペレーターは、 PyTorchJob CRD を提供します。 このマニフェストを適用する前に、Kubernetes バージョンと互換性のある Training Operator リリースをインストールします。 次の 2 つのレプリカの例では、1 つのマスターと 1 つのワーカーで NCCL all-reduce 操作を実行します。

apiVersion: v1
kind: Namespace
metadata:
  name: ml-training
  labels:
    purpose: ml-training
---
apiVersion: kubeflow.org/v1
kind: PyTorchJob
metadata:
  name: pytorch-nccl-example
  namespace: ml-training
spec:
  runPolicy:
    cleanPodPolicy: None
  pytorchReplicaSpecs:
    Master:
      replicas: 1
      restartPolicy: OnFailure
      template:
        metadata:
          labels:
            training-job: pytorch-nccl-example
        spec:
          nodeSelector:
            accelerator: nvidia
          tolerations:
          - key: sku
            operator: Equal
            value: gpu
            effect: NoSchedule
          containers:
          - name: pytorch
            image: pytorch/pytorch:2.4.1-cuda12.4-cudnn9-runtime
            command:
            - python
            - -c
            - |
              import os
              import torch
              import torch.distributed as dist

              torch.cuda.set_device(0)
              dist.init_process_group(backend="nccl")
              value = torch.tensor(
                  [float(dist.get_rank() + 1)],
                  device="cuda"
              )
              dist.all_reduce(value)
              print(
                  f"rank={dist.get_rank()} "
                  f"world_size={dist.get_world_size()} "
                  f"all_reduce_sum={value.item()}"
              )
              dist.destroy_process_group()
            env:
            - name: NCCL_DEBUG
              value: INFO
            - name: NCCL_SOCKET_IFNAME
              value: eth0
            - name: NCCL_IB_DISABLE
              value: "1"
            - name: TORCH_NCCL_ASYNC_ERROR_HANDLING
              value: "1"
            resources:
              requests:
                cpu: "4"
                memory: 16Gi
                nvidia.com/gpu: 1
              limits:
                cpu: "4"
                memory: 16Gi
                nvidia.com/gpu: 1
    Worker:
      replicas: 1
      restartPolicy: OnFailure
      template:
        metadata:
          labels:
            training-job: pytorch-nccl-example
        spec:
          nodeSelector:
            accelerator: nvidia
          tolerations:
          - key: sku
            operator: Equal
            value: gpu
            effect: NoSchedule
          containers:
          - name: pytorch
            image: pytorch/pytorch:2.4.1-cuda12.4-cudnn9-runtime
            command:
            - python
            - -c
            - |
              import os
              import torch
              import torch.distributed as dist

              torch.cuda.set_device(0)
              dist.init_process_group(backend="nccl")
              value = torch.tensor(
                  [float(dist.get_rank() + 1)],
                  device="cuda"
              )
              dist.all_reduce(value)
              print(
                  f"rank={dist.get_rank()} "
                  f"world_size={dist.get_world_size()} "
                  f"all_reduce_sum={value.item()}"
              )
              dist.destroy_process_group()
            env:
            - name: NCCL_DEBUG
              value: INFO
            - name: NCCL_SOCKET_IFNAME
              value: eth0
            - name: NCCL_IB_DISABLE
              value: "1"
            - name: TORCH_NCCL_ASYNC_ERROR_HANDLING
              value: "1"
            resources:
              requests:
                cpu: "4"
                memory: 16Gi
                nvidia.com/gpu: 1
              limits:
                cpu: "4"
                memory: 16Gi
                nvidia.com/gpu: 1

実稼働トレーニングの場合は、インライン テストをバージョン管理されたトレーニング イメージとスクリプトに置き換えます。 レプリカ数を、トレーニング フレームワークに必要な GPU とプロセスの数に合わせます。

TFJob を実行する

トレーニング オペレーターは、 TFJob CRD も提供します。 次の例では、 MultiWorkerMirroredStrategyを使用して、2 つの GPU ワーカー間で同期 TensorFlow トレーニングを実行します。

apiVersion: v1
kind: Namespace
metadata:
  name: ml-training
  labels:
    purpose: ml-training
---
apiVersion: kubeflow.org/v1
kind: TFJob
metadata:
  name: tensorflow-multiworker-example
  namespace: ml-training
spec:
  runPolicy:
    cleanPodPolicy: None
  tfReplicaSpecs:
    Worker:
      replicas: 2
      restartPolicy: OnFailure
      template:
        metadata:
          labels:
            training-job: tensorflow-multiworker-example
        spec:
          nodeSelector:
            accelerator: nvidia
          tolerations:
          - key: sku
            operator: Equal
            value: gpu
            effect: NoSchedule
          containers:
          - name: tensorflow
            image: tensorflow/tensorflow:2.16.1-gpu
            command:
            - python
            - -c
            - |
              import tensorflow as tf

              strategy = tf.distribute.MultiWorkerMirroredStrategy()
              print("workers:", strategy.num_replicas_in_sync)

              with strategy.scope():
                  model = tf.keras.Sequential([
                      tf.keras.layers.Input(shape=(32,)),
                      tf.keras.layers.Dense(64, activation="relu"),
                      tf.keras.layers.Dense(1)
                  ])
                  model.compile(
                      optimizer="adam",
                      loss="mean_squared_error"
                  )

              features = tf.random.normal([4096, 32])
              labels = tf.random.normal([4096, 1])
              dataset = (
                  tf.data.Dataset.from_tensor_slices((features, labels))
                  .shuffle(4096)
                  .repeat()
                  .batch(64)
              )
              model.fit(dataset, epochs=2, steps_per_epoch=32)
            resources:
              requests:
                cpu: "4"
                memory: 16Gi
                nvidia.com/gpu: 1
              limits:
                cpu: "4"
                memory: 16Gi
                nvidia.com/gpu: 1

パラメーター サーバートレーニングでは、TensorFlow 分散戦略に従って、レプリカの種類 Chief、 Worker、および PS を定義します。 レプリカ数を増やす前に、結果として得られるネットワークとパラメーター サーバーのボトルネックを測定します。

KAITO を使用してモデルを微調整する

KAITO は、モデルのデプロイと微調整のための AKS に重点を置いたワークスペースの抽象化を提供します。 Workspaceを適用する前に、KAITO アドオンを有効にするか、互換性のある KAITO リリースをインストールします。 選択したプリセット、VM SKU、および微調整方法が、インストールされている KAITO バージョンでサポートされていることを確認します。

次のワークスペースは、A100 GPU VM を要求し、パブリックにアクセス可能なデータセットを使用して、サポートされている Phi-3 プリセットの QLoRA 微調整を開始します。

apiVersion: kaito.sh/v1beta1
kind: Workspace
metadata:
  name: workspace-tuning-phi-3-mini
resource:
  instanceType: Standard_NC24ads_A100_v4
  labelSelector:
    matchLabels:
      apps: phi-3-mini-tuning
tuning:
  preset:
    name: phi-3-mini-4k-instruct
  method: qlora
  input:
    urls:
    - https://huggingface.co/datasets/yahma/alpaca-cleaned/resolve/main/alpaca_data_cleaned.json

KAITO では、モデル プリセット構成と、ワークスペースに必要な GPU インフラストラクチャを調整できます。 運用環境では、承認済みのAzure ストレージ アカウントにトレーニング データセットを格納し、サポートされている場合はプライベート アクセスとワークロード ID を使用し、結果のモデルを管理モデル レジストリまたはAzure Container Registryに保持します。 ワークスペース マニフェスト、入力データセットのバージョン、プリセット バージョン、アダプター構成、出力イメージ ダイジェストを 1 つのバージョン管理されたトレーニング レコードとして扱います。

AKS CNI との NCCL 通信を構成する

NVIDIA 集合通信ライブラリ (NCCL) は、all-reduce などの一括操作を処理します。 AKS CNI の移植可能な TCP ベースラインの場合は、ポッド ネットワーク インターフェイス (通常は eth0) を使用し、 NCCL_IB_DISABLE=1から開始します。 サポートされている RDMA 対応 VM サイズでは、記載されている NVIDIA とAzure RDMA 構成を使用し、NCCL_IB_DISABLE=0設定する前に検証します。

次のベースライン環境変数を使用します。

  • NCCL_SOCKET_IFNAME=eth0 はポッド ネットワーク インターフェイスを選択します。
  • NCCL_DEBUG=INFO は検証中に診断情報を提供します。 チューニング後にログ レベルを下げます。
  • NCCL_IB_DISABLE=1 は、RDMA が構成されていない場合に TCP ソケットを選択します。
  • TORCH_NCCL_ASYNC_ERROR_HANDLING=1 は、非同期通信エラーの後に無期限にハングするのではなく、PyTorch を終了するのに役立ちます。

ネットワーク ポリシーが有効になっている場合は、レプリカ間で必要なすべてのランデブーおよび NCCL トラフィックを許可します。 NCCL は動的ポートをネゴシエーションできるため、ポートを狭い範囲に固定するポリシーを適用すると、学習ジョブがハングアップする可能性があります。 次のポリシーでは、PyTorch ジョブのレプリカ間でのみポッド間の無制限の通信が許可され、DNS 解決が許可されます。

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-pytorch-nccl
  namespace: ml-training
spec:
  podSelector:
    matchLabels:
      training-job: pytorch-nccl-example
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          training-job: pytorch-nccl-example
  egress:
  - to:
    - podSelector:
        matchLabels:
          training-job: pytorch-nccl-example
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - protocol: UDP
      port: 53
    - protocol: TCP
      port: 53

スケールアウトする前に、NCCL をモデル トレーニングとは別にベンチマークします。各ワーカー数で、帯域幅、待機時間、GPU 使用率、トレーニング スループットをすべて削減して比較します。 通信やデータの読み込みがボトルネックになると、ワーカーが増えるとパフォーマンスが低下する可能性があります。

ギャング スケジューリングとワークロード キューを使用する

重要なポイント: 分散ワーカーをグループとして受け入れ、テナントごとの GPU クォータを適用して、一部のワーカーだけがスケジュールされたジョブが残りのワーカーを待っている間に GPU を占有したままにならないようにします。

既定の Kubernetes スケジューラは、ポッドを個別に配置します。 すべてのワーカーが稼働するまで処理を進められない分散ジョブでは、部分配置によって GPU リソースが無駄になる可能性があります。 Kueue は、ポッドの実行を開始する前に、アドミッション制御とクォータ管理を提供します。 Volcano は、スケジューラと、PodGroup に基づく全か無かのスケジューリング モデルを提供します。

AKS Automatic では、既定の Kubernetes スケジューラと自動ノード プロビジョニングが開始点として提供されます。 正確なリソース要求を使用して通常のジョブまたはオペレーターが管理するトレーニング ジョブを送信し、プラットフォームが適格な容量をプロビジョニングできるようにします。 この動作では、すべてのワーカーのアトミック アドミッションが保証されるわけではありません。 ワークロードでギャング スケジューリング、キューイング、チームクォータ、公平共有、またはカスタムのプリエンプション動作が必要な場合は、Kueue または Volcano をインストールします。

Kueue を使用してマルチテナント GPU クォータを割り当てる

Kubernetes バージョンと互換性のある Kueue バージョンをインストールし、使用するワークロードの種類の統合を有効にします。 次のマニフェストにより、以下が作成されます:

  • ResourceFlavorラベルが付けられたノードに関連付けられている GPU accelerator=nvidia。
  • チームA向けの4基のGPU ClusterQueue
  • チームB向けの2基のGPU ClusterQueue。
  • 各チームに 1 つの名前空間単位の LocalQueue。
  • Kueue が、要求されたリソースが使用可能な場合にのみ許可する 2 ワーカー ジョブ。
apiVersion: v1
kind: Namespace
metadata:
  name: team-a
---
apiVersion: v1
kind: Namespace
metadata:
  name: team-b
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ResourceFlavor
metadata:
  name: nvidia-gpu
spec:
  nodeLabels:
    accelerator: nvidia
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ClusterQueue
metadata:
  name: team-a-gpu
spec:
  namespaceSelector:
    matchLabels:
      kubernetes.io/metadata.name: team-a
  queueingStrategy: BestEffortFIFO
  resourceGroups:
  - flavors:
    - name: nvidia-gpu
      resources:
      - name: cpu
        nominalQuota: "64"
      - name: memory
        nominalQuota: 256Gi
      - name: nvidia.com/gpu
        nominalQuota: "4"
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: ClusterQueue
metadata:
  name: team-b-gpu
spec:
  namespaceSelector:
    matchLabels:
      kubernetes.io/metadata.name: team-b
  queueingStrategy: BestEffortFIFO
  resourceGroups:
  - flavors:
    - name: nvidia-gpu
      resources:
      - name: cpu
        nominalQuota: "32"
      - name: memory
        nominalQuota: 128Gi
      - name: nvidia.com/gpu
        nominalQuota: "2"
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: LocalQueue
metadata:
  name: gpu-queue
  namespace: team-a
spec:
  clusterQueue: team-a-gpu
---
apiVersion: kueue.x-k8s.io/v1beta1
kind: LocalQueue
metadata:
  name: gpu-queue
  namespace: team-b
spec:
  clusterQueue: team-b-gpu
---
apiVersion: batch/v1
kind: Job
metadata:
  name: team-a-two-gpu-training
  namespace: team-a
  labels:
    kueue.x-k8s.io/queue-name: gpu-queue
spec:
  suspend: true
  completions: 2
  parallelism: 2
  backoffLimit: 2
  template:
    metadata:
      labels:
        app: team-a-two-gpu-training
    spec:
      restartPolicy: Never
      tolerations:
      - key: sku
        operator: Equal
        value: gpu
        effect: NoSchedule
      containers:
      - name: worker
        image: nvcr.io/nvidia/cuda:12.4.1-runtime-ubuntu22.04
        command:
        - /bin/bash
        - -c
        - |
          set -e
          nvidia-smi
          echo "Kueue admitted this worker."
          sleep 120
        resources:
          requests:
            cpu: "4"
            memory: 16Gi
            nvidia.com/gpu: 1
          limits:
            cpu: "4"
            memory: 16Gi
            nvidia.com/gpu: 1

ClusterQueue クォータは、Azure サブスクリプション クォータではなく、スケジュール クォータです。 AKS クラスターが基になる VM 容量をプロビジョニングできることと、AZURE GPU クォータが、許可された集計ワークロードに対して十分であることを確認します。 チームが未使用のクォータを互いに借用できる場合は、コーホートと Kueue のフェアシェア機能を使用します。

別の方法として火山を使用する

Volcano は、ギャングスケジューリング、キュー、ジョブのライフサイクル ポリシーを備えた専用のバッチ Scheduler を求める場合の代替手段です。 CRD を適用する前に、クラスターと互換性のある Volcano リリースをインストールします。 次の Volcano ジョブでは、ジョブを実行する前に両方の GPU ワーカーを使用できる必要があります。

apiVersion: batch.volcano.sh/v1alpha1
kind: Job
metadata:
  name: volcano-gpu-training
  namespace: default
spec:
  minAvailable: 2
  schedulerName: volcano
  policies:
  - event: PodEvicted
    action: RestartJob
  - event: PodFailed
    action: RestartJob
  tasks:
  - replicas: 2
    name: worker
    template:
      metadata:
        labels:
          app: volcano-gpu-training
      spec:
        restartPolicy: OnFailure
        nodeSelector:
          accelerator: nvidia
        tolerations:
        - key: sku
          operator: Equal
          value: gpu
          effect: NoSchedule
        containers:
        - name: worker
          image: nvcr.io/nvidia/cuda:12.4.1-runtime-ubuntu22.04
          command:
          - /bin/bash
          - -c
          - |
            set -e
            nvidia-smi
            echo "All Volcano workers were admitted."
            sleep 120
          resources:
            requests:
              cpu: "4"
              memory: 16Gi
              nvidia.com/gpu: 1
            limits:
              cpu: "4"
              memory: 16Gi
              nvidia.com/gpu: 1

テスト済みの相互運用性設計がない限り、1 つのプライマリ キューおよびグループ スケジューリング システムで標準化します。 そうでないと、複数のアドミッションコントローラーまたはスケジューラがある場合、Pending とプリエンプションの動作を把握することが難しくなる可能性があります。

トレーニングと推論の優先順位を構成する

待機時間に依存する推論では、通常、中断可能なバッチ トレーニングよりも高い優先順位が必要です。 次の PriorityClass リソースを使用すると、推論ポッドは優先順位の低いポッドを割り込む一方で、バッチ トレーニング ポッドが他のワークロードを割り込むのを防ぐことができます。

apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: training-batch
value: 10000
globalDefault: false
preemptionPolicy: Never
description: Batch training can wait and can be preempted by higher-priority workloads.
---
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: inference-critical
value: 100000
globalDefault: false
preemptionPolicy: PreemptLowerPriority
description: Latency-sensitive production inference can preempt lower-priority workloads.

ポッド テンプレートの spec.priorityClassName を使用してクラスを割り当てます。 Kubernetes ポッドの優先度と Kueue ワークロードの優先順位は、さまざまなステージに影響します。Kueue はキューの受付を制御し、Kubernetes の優先順位は、受付後のスケジュールとポッドのプリエンプションに影響します。 両方のポリシーを調整して、同じビジネス優先度を表します。

プリエンプションにより、優先順位の低いポッドが終了します。 割り込むことができるトレーニング ワークロードでは、チェックポイントを永続的ストレージに書き込み、重複する作業を許容し、ノード ローカル ファイルに依存せずに復旧する必要があります。

共有メモリとリソース管理を構成する

重要なポイント: コンテナー ランタイムの小さな既定の /dev/shmを置き換え、監視された使用率からのリソース要求を設定し、完全な GPU ワークロード要件に関するノード スケーリングを構成します。

ML データ ローダーの /dev/shm を増やす

PyTorch データ ローダー、TensorFlow 入力パイプライン、NCCL、および Python マルチプロセスでは、POSIX 共有メモリを使用できます。 /dev/shmのコンテナーの既定値は、多くの場合、マルチプロセス トレーニングでは小さすぎるため、ワーカーのクラッシュ、バス エラー、または明らかなトレーニングハングを引き起こす可能性があります。

emptyDirでメモリベースの/dev/shmをマウントし、明示的なsizeLimitを設定します。

apiVersion: batch/v1
kind: Job
metadata:
  name: shared-memory-training
spec:
  backoffLimit: 2
  template:
    metadata:
      labels:
        app: shared-memory-training
    spec:
      restartPolicy: Never
      nodeSelector:
        accelerator: nvidia
      tolerations:
      - key: sku
        operator: Equal
        value: gpu
        effect: NoSchedule
      containers:
      - name: trainer
        image: pytorch/pytorch:2.4.1-cuda12.4-cudnn9-runtime
        command:
        - /bin/bash
        - -c
        - |
          set -e
          df -h /dev/shm
          python -c '
          import multiprocessing as mp
          import torch

          def worker(index):
              value = torch.ones(1024, 1024)
              print(f"worker={index}, sum={value.sum().item()}")

          if __name__ == "__main__":
              processes = [mp.Process(target=worker, args=(i,)) for i in range(4)]
              for process in processes:
                  process.start()
              for process in processes:
                  process.join()
                  if process.exitcode != 0:
                      raise SystemExit(process.exitcode)
          '
        volumeMounts:
        - name: shared-memory
          mountPath: /dev/shm
        resources:
          requests:
            cpu: "8"
            memory: 16Gi
            nvidia.com/gpu: 1
          limits:
            cpu: "8"
            memory: 16Gi
            nvidia.com/gpu: 1
      volumes:
      - name: shared-memory
        emptyDir:
          medium: Memory
          sizeLimit: 8Gi

メモリベースの emptyDir 使用量は、ポッドのメモリ使用量にカウントされます。 コンテナーのメモリ制限を設定するときに、予想される共有メモリ使用量の最大値を含めます。 /dev/shmが有効なメモリ予算を超えて増加した場合、そのメモリ制限を超えたためにポッドを削除または終了できます。

観察された使用率から CPU とメモリのサイズを変更する

代表的なモデル、バッチ サイズ、シーケンスの長さ、データ ローダーのコンカレンシー、拡張、チェックポイントの動作に基づくベンチマークから始めます。 次に、監視データを使用して調整します。

  • GPU 入力パイプラインを提供し続けるのに十分な高さに CPU 要求を設定します。 永続的な GPU アイドル期間は、CPU またはストレージの不足を示す可能性があります。
  • 安定したワーキング セット使用量に加えて、安全マージンに近いメモリ要求を設定します。 /dev/shm、ページ キャッシュの動作、フレームワーク アロケーターのオーバーヘッド、チェックポイントのシリアル化のピークが含まれます。
  • 観測されたピークを超えるメモリ制限を設定します。 原因を見つけずに制限を繰り返し増やすのではなく、 OOMKilled イベントを調査します。
  • 厳しいCPU制限を使用する前に、CPUスロットリングを評価してください。 CPU の制限が低すぎると、平均 CPU 使用率が許容できる場合でも GPU 使用率が低下する可能性があります。
  • サービス品質の保証がノードのパッキングよりも重要な場合は、予測可能で価値の高いトレーニング ジョブに対して要求と制限を等しく設定します。
  • モデル サイズ、精度、バッチ サイズ、ワーカー数、データ パイプラインに対する重要な変更をすべてプロファイリングします。

短期間の平均ではなく、トレーニング全体を通じたパーセンタイルを使用してください。 スタートアップ、検証、チェックポイント、データ シャッフルの各フェーズでは、多くの場合、リソースのピークが異なります。

GPU ノード プールのクラスター自動スケーリングを構成する

AKS Standard の場合は、GPU ユーザー ノード プールでクラスター オートスケーラーを有効にし、最小容量と最大容量を定義します。

RESOURCE_GROUP=myResourceGroup
AKS_CLUSTER=myAKSCluster
GPU_NODE_POOL=gpunp

az aks nodepool update \
  --resource-group "$RESOURCE_GROUP" \
  --cluster-name "$AKS_CLUSTER" \
  --name "$GPU_NODE_POOL" \
  --enable-cluster-autoscaler \
  --min-count 0 \
  --max-count 8

サポートされているクラスター オートスケーラー プロファイルの設定は、クラスター スコープで調整できます。 トレーニングワークロードとサービスワークロードの両方に対するプロファイルの変更をテストします。

az aks update \
  --resource-group "$RESOURCE_GROUP" \
  --name "$AKS_CLUSTER" \
  --cluster-autoscaler-profile \
    scan-interval=20s \
    scale-down-unneeded-time=10m \
    scale-down-delay-after-add=15m \
    max-graceful-termination-sec=120

保留中の GPU ポッドは、その完全なスケジュール要件がノード プール テンプレートと一致する場合にのみスケールアップをトリガーします。 スケールアップが発生しない場合は、GPU リソース要求、VM 容量、ラベル、テイント、容認、アフィニティ、トポロジ制約、永続ボリューム トポロジ、最大ノード数、Azure クォータを確認します。

スケールからゼロへのスケールは中断可能なトレーニング プールに適していますが、VM のプロビジョニング、イメージ プル、データセットマウント、モデル初期化の待機時間が追加されます。 スタートアップ待機時間がサービス目標に重大な影響を与える場合は、0 以外の最小値を維持します。 ポッドの中断予算、削除不可能なポッド、ローカル ストレージ、および長い終了猶予期間により、スケールダウンが遅れる可能性があります。

AKS 自動では、サービス ベースラインの一部としてノードのプロビジョニングとスケーリングが管理されます。 手動の GPU ノード プール オートスケーラーを構成する代わりに、正確なポッド要求とサポートされる制約に焦点を当てます。

データセットとチェックポイントを格納する

重要なポイント: アクセス パターン、スループット、共有、回復の要件に基づいてストレージを選択し、チェックポイントをノードの外部に保持して、トレーニングが削除またはプリエンプションから回復できるようにします。

大規模なデータセット、モデル成果物、チェックポイントをコンテナー イメージから除外します。 ワークロードに基づいてストレージ インターフェイスを選択します。

  • Azure Blob Storageは、大規模なオブジェクト データセット、モデル成果物、および大容量データ リポジトリに使用します。
  • 複数のワーカー ノードで共有 POSIX スタイルのファイル システムが必要な場合は、Azure Filesを使用します。
  • ReadWriteOnceで十分な高パフォーマンスの単一ノードの読み取り/書き込みチェックポイントまたはキャッシュ ワークロードには、Azure Disk を使用します。
  • ノード ローカルエフェメラル ストレージは、再構築可能なキャッシュと一時ファイルにのみ使用します。

Azure BLOB CSI ドライバーを使用して大規模なデータセットにアクセスする

まだ有効になっていない場合は、AKS Standard で Azure BLOB CSI ドライバーを有効にします。

RESOURCE_GROUP=myResourceGroup
AKS_CLUSTER=myAKSCluster

az aks update \
  --resource-group "$RESOURCE_GROUP" \
  --name "$AKS_CLUSTER" \
  --enable-blob-driver

次の例では、NFS を介して公開される Premium Azure BLOB コンテナーを動的に作成し、トレーニング ポッドにマウントします。 既存の管理データセットの場合は、空の動的コンテナーを作成する代わりに、静的に定義されたボリュームまたは BlobFuse 構成と、適切な ID とプライベート ネットワーク コントロールを使用します。

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ml-azureblob-nfs
provisioner: blob.csi.azure.com
parameters:
  protocol: nfs
  skuName: Premium_LRS
reclaimPolicy: Delete
allowVolumeExpansion: true
volumeBindingMode: Immediate
mountOptions:
- -o attr_timeout=120
- -o entry_timeout=120
- -o negative_timeout=120
- -o actimeo=120
- -o noresvport
- -o nconnect=4
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: blob-training-dataset
  namespace: default
spec:
  accessModes:
  - ReadWriteMany
  storageClassName: ml-azureblob-nfs
  resources:
    requests:
      storage: 1Ti
---
apiVersion: batch/v1
kind: Job
metadata:
  name: inspect-blob-dataset
  namespace: default
spec:
  backoffLimit: 2
  template:
    metadata:
      labels:
        app: inspect-blob-dataset
    spec:
      restartPolicy: Never
      containers:
      - name: dataset-reader
        image: ubuntu:24.04
        command:
        - /bin/bash
        - -c
        - |
          set -e
          echo "Mounted dataset path:"
          df -h /mnt/dataset
          find /mnt/dataset -maxdepth 2 -type f | head -100
        volumeMounts:
        - name: dataset
          mountPath: /mnt/dataset
      volumes:
      - name: dataset
        persistentVolumeClaim:
          claimName: blob-training-dataset

代表的なシャード サイズとアクセス パターンに対してプロトコルとマウントのオプションをベンチマークします。 多数の小さなファイルを読み取るワーカーの多くは、大規模なシャードを順番にストリーミングする場合とは異なる結果を生み出す可能性があります。 そうしないと複数回のエポックで同じオブジェクトをダウンロードすることになる場合は、データセットを適切なサイズのシャードに前処理しておき、ノードローカルのキャッシュ領域を使用することを検討してください。

Azure Filesとトレーニング データを共有する

Azure Filesでは、ReadWriteManyがサポートされています。これにより、異なるノード上の分散ワーカーが同じ共有をマウントできます。 Premium Azure Filesは、ワークロードで予測可能なファイル システム パフォーマンスが必要であり、選択したリージョンで必要な冗長性オプションがサポートされている場合に適しています。

次のマニフェストは、Premium Azure Files のファイル共有を作成し、それを 2 つの並列ワーカー ポッドにマウントします。

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ml-azurefile-premium
provisioner: file.csi.azure.com
parameters:
  skuName: Premium_LRS
reclaimPolicy: Delete
allowVolumeExpansion: true
volumeBindingMode: Immediate
mountOptions:
- dir_mode=0770
- file_mode=0660
- uid=1000
- gid=1000
- mfsymlinks
- cache=strict
- actimeo=30
- nosharesock
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: shared-training-data
  namespace: default
spec:
  accessModes:
  - ReadWriteMany
  storageClassName: ml-azurefile-premium
  resources:
    requests:
      storage: 100Gi
---
apiVersion: batch/v1
kind: Job
metadata:
  name: shared-data-workers
  namespace: default
spec:
  completions: 2
  parallelism: 2
  completionMode: Indexed
  backoffLimitPerIndex: 2
  template:
    metadata:
      labels:
        app: shared-data-workers
    spec:
      restartPolicy: Never
      securityContext:
        runAsUser: 1000
        runAsGroup: 1000
        fsGroup: 1000
      containers:
      - name: worker
        image: ubuntu:24.04
        command:
        - /bin/bash
        - -c
        - |
          set -e
          WORKER_INDEX="${JOB_COMPLETION_INDEX:-0}"
          echo "worker=${WORKER_INDEX}" \
            > "/mnt/shared/worker-${WORKER_INDEX}.txt"
          ls -la /mnt/shared
        volumeMounts:
        - name: shared-data
          mountPath: /mnt/shared
      volumes:
      - name: shared-data
        persistentVolumeClaim:
          claimName: shared-training-data

すべてのワーカーが、何百万ものファイルを含むディレクトリを繰り返し列挙しないようにします。 マニフェストまたは確定的なシャードの割り当てを使用して、各ワーカーが読み取るオブジェクトを認識します。

永続的ストレージへのチェックポイント

チェックポイントには、モデルの重み、オプティマイザーの状態、スケジューラの状態、スケーラーの状態、エポックまたはステップ番号、乱数ジェネレーターの状態、サポートされている場合のデータ ローダーの位置など、正しく再開するのに十分な状態が含まれている必要があります。 チェックポイントを定期的に書き込み、正常終了する前に書き込みます。

次のジョブは、アトミック PyTorch チェックポイントをAzure Filesに書き込み、コンテナーの再起動またはポッドの置換後に最新のチェックポイントを復元し、SIGTERMを処理して、プリエンプションが最近の進行状況を維持できるようにします。

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ml-checkpoints-azurefile
provisioner: file.csi.azure.com
parameters:
  skuName: Premium_LRS
reclaimPolicy: Retain
allowVolumeExpansion: true
volumeBindingMode: Immediate
mountOptions:
- dir_mode=0770
- file_mode=0660
- uid=1000
- gid=1000
- mfsymlinks
- cache=strict
- actimeo=30
- nosharesock
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: model-checkpoints
  namespace: default
spec:
  accessModes:
  - ReadWriteMany
  storageClassName: ml-checkpoints-azurefile
  resources:
    requests:
      storage: 100Gi
---
apiVersion: batch/v1
kind: Job
metadata:
  name: checkpointed-pytorch-training
  namespace: default
spec:
  backoffLimit: 6
  template:
    metadata:
      labels:
        app: checkpointed-pytorch-training
    spec:
      restartPolicy: OnFailure
      terminationGracePeriodSeconds: 120
      securityContext:
        runAsUser: 1000
        runAsGroup: 1000
        fsGroup: 1000
      containers:
      - name: trainer
        image: pytorch/pytorch:2.4.1-cuda12.4-cudnn9-runtime
        command:
        - python
        - -c
        - |
          import os
          import signal
          import sys
          import time
          import torch

          checkpoint_path = "/checkpoints/latest.pt"
          temporary_path = "/checkpoints/latest.pt.tmp"
          state = {"epoch": 0, "value": torch.tensor([0.0])}

          if os.path.exists(checkpoint_path):
              state = torch.load(checkpoint_path, map_location="cpu")
              print(f"Restored epoch {state['epoch']}", flush=True)

          def save_checkpoint():
              torch.save(state, temporary_path)
              os.replace(temporary_path, checkpoint_path)
              print(f"Saved epoch {state['epoch']}", flush=True)

          def terminate(signum, frame):
              print(f"Received signal {signum}", flush=True)
              save_checkpoint()
              sys.exit(143)

          signal.signal(signal.SIGTERM, terminate)
          signal.signal(signal.SIGINT, terminate)

          for epoch in range(state["epoch"] + 1, 21):
              state["epoch"] = epoch
              state["value"] += 1
              time.sleep(10)
              if epoch % 2 == 0:
                  save_checkpoint()

          save_checkpoint()
          print("Training completed.", flush=True)
        volumeMounts:
        - name: checkpoints
          mountPath: /checkpoints
        resources:
          requests:
            cpu: "1"
            memory: 2Gi
          limits:
            cpu: "1"
            memory: 2Gi
      volumes:
      - name: checkpoints
        persistentVolumeClaim:
          claimName: model-checkpoints

運用チェックポイントには、 Retain 再利用ポリシーまたは個別に管理されたストレージ アカウントを使用します。そのため、PVC を削除しても、意図せずに唯一の復旧ポイントが削除されることはありません。 分散データ並列トレーニングでは、通常、ランク 0 でグローバル チェックポイントを書き込むか、フレームワークでサポートされているシャード チェックポイント形式を使用します。 複数のランクが同じファイルを同時に書き込むのを防ぎます。

非運用環境の実行中にワーカー ポッドを意図的に削除して、復旧をテストします。 コントローラーがワークロードを再作成し、新しいポッドが同じ永続ボリュームをマウントし、トレーニングが予想される手順から再開されることを確認します。

GPU 使用率とトレーニング スループットを監視する

重要なポイント: GPU コンピューティング、GPU メモリ、データ パイプラインのスループット、ステップ期間、チェックポイント アクティビティを一緒に監視して、コンピューティングの飽和と CPU、ネットワーク、またはストレージのボトルネックを区別できるようにします。

Prometheus と Container Insights Azure Monitorマネージド サービスを有効にして、Kubernetes の状態、コンテナー ログ、ノードの正常性、および Prometheus メトリックを関連付けます。 アラート、リテンション期間、運用ダッシュボードを設計するときは、 AKS の監視のベスト プラクティス を使用します。

NVIDIA GPU メトリックの収集

NVIDIA Data Center GPU Manager (DCGM) エクスポーターは、NVIDIA GPU の Prometheus メトリックを公開します。 NVIDIA GPU オペレーターが既に DCGM エクスポーターをデプロイしている場合は、重複するエクスポーターをデプロイしないでください。 Azure Monitor のマネージド Prometheus が既存のエクスポーターをスクレイプするように構成します。

次のPodMonitorでは、Azure Monitorマネージド Prometheus CRD を使用し、gpu-operator名前空間の DCGM エクスポーター ポッドを対象とします。 インストールされているエクスポーターで使用されているラベルと一致するようにラベル セレクターを調整します。

apiVersion: azmonitoring.coreos.com/v1
kind: PodMonitor
metadata:
  name: nvidia-dcgm-exporter
  namespace: gpu-operator
spec:
  selector:
    matchLabels:
      app: nvidia-dcgm-exporter
  podMetricsEndpoints:
  - port: metrics
    interval: 30s
    scrapeTimeout: 10s

モニターを適用する前に、エクスポーター サービスまたはポッド ポート名を確認します。 一般的な DCGM メトリックは次のとおりです。

Metric Purpose
DCGM_FI_DEV_GPU_UTIL GPU がアクティブな時間の割合
DCGM_FI_DEV_FB_USED 使用されたフレーム バッファー メモリ
DCGM_FI_DEV_FB_FREE フレーム バッファー メモリを解放する
DCGM_FI_DEV_MEM_COPY_UTIL メモリ コピー エンジンの使用率
DCGM_FI_DEV_POWER_USAGE GPU の電力消費量
DCGM_FI_DEV_GPU_TEMP GPU 温度
DCGM_FI_DEV_XID_ERRORS NVIDIA XID エラー イベント

メトリックの可用性は、GPU、ドライバー、DCGM、エクスポーターのバージョンによって異なります。

トレーニング スループット メトリックをエクスポートする

ワークロード レベルのメトリックを使用してトレーニング アプリケーションをインストルメント化します。 有用なメトリックは次のとおりです。

  • ml_training_samples_total 処理された累積サンプルまたはトークンの場合。
  • ml_training_steps_total 完了したオプティマイザーステップ用。
  • ml_training_step_duration_seconds ステップ遅延用。
  • ml_training_checkpoint_duration_seconds はチェックポイント レイテンシ用です。
  • ml_training_data_wait_seconds 入力データを待機している時間。
  • モデル固有の損失、学習率、勾配標準、検証メトリック。

次の実行可能な例では、ポート 8000で合成トレーニング メトリックを公開します。 シミュレーションを、実際のトレーニング ループによって出力されるメトリックに置き換えます。

apiVersion: v1
kind: Namespace
metadata:
  name: ml-observability
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: training-metrics-server
  namespace: ml-observability
data:
  server.py: |
    import http.server
    import threading
    import time

    state = {
        "samples": 0,
        "steps": 0,
        "last_step_duration": 0.0,
    }

    def train():
        while True:
            started = time.time()
            time.sleep(1)
            state["samples"] += 256
            state["steps"] += 1
            state["last_step_duration"] = time.time() - started

    class MetricsHandler(http.server.BaseHTTPRequestHandler):
        def do_GET(self):
            if self.path != "/metrics":
                self.send_response(404)
                self.end_headers()
                return

            body = (
                "# HELP ml_training_samples_total Samples processed.\n"
                "# TYPE ml_training_samples_total counter\n"
                f"ml_training_samples_total{{job_name=\"metrics-demo\"}} "
                f"{state['samples']}\n"
                "# HELP ml_training_steps_total Training steps completed.\n"
                "# TYPE ml_training_steps_total counter\n"
                f"ml_training_steps_total{{job_name=\"metrics-demo\"}} "
                f"{state['steps']}\n"
                "# HELP ml_training_step_duration_seconds "
                "Duration of the most recent training step.\n"
                "# TYPE ml_training_step_duration_seconds gauge\n"
                f"ml_training_step_duration_seconds"
                f"{{job_name=\"metrics-demo\"}} "
                f"{state['last_step_duration']}\n"
            ).encode("utf-8")

            self.send_response(200)
            self.send_header("Content-Type", "text/plain; version=0.0.4")
            self.send_header("Content-Length", str(len(body)))
            self.end_headers()
            self.wfile.write(body)

        def log_message(self, format, *args):
            return

    threading.Thread(target=train, daemon=True).start()
    http.server.ThreadingHTTPServer(("0.0.0.0", 8000), MetricsHandler).serve_forever()
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: training-metrics-demo
  namespace: ml-observability
spec:
  replicas: 1
  selector:
    matchLabels:
      app: training-metrics-demo
  template:
    metadata:
      labels:
        app: training-metrics-demo
    spec:
      containers:
      - name: metrics
        image: python:3.12-slim
        command:
        - python
        - /app/server.py
        ports:
        - name: metrics
          containerPort: 8000
        readinessProbe:
          httpGet:
            path: /metrics
            port: metrics
          initialDelaySeconds: 2
          periodSeconds: 10
        resources:
          requests:
            cpu: 50m
            memory: 64Mi
          limits:
            cpu: 200m
            memory: 128Mi
        volumeMounts:
        - name: application
          mountPath: /app
          readOnly: true
      volumes:
      - name: application
        configMap:
          name: training-metrics-server
---
apiVersion: azmonitoring.coreos.com/v1
kind: PodMonitor
metadata:
  name: training-metrics-demo
  namespace: ml-observability
spec:
  selector:
    matchLabels:
      app: training-metrics-demo
  podMetricsEndpoints:
  - port: metrics
    path: /metrics
    interval: 30s
    scrapeTimeout: 10s

実際の分散ジョブの場合は、モデル名、モデル バージョン、ジョブ名、実行 ID、レプリカ ロール、チームなどの安定したラベルを含めます。 高カーディナリティラベルは監視コストとクエリ待ち時間を増やすので、サンプル ID、要求 ID、生データセット パスなどの無制限のラベルは使用しないでください。

GPU とスループットのダッシュボードを構築する

開始点として次のような PromQL クエリを使用し、エクスポーターに対してメトリック ラベルを検証します。

avg by (namespace, pod, gpu) (
  avg_over_time(DCGM_FI_DEV_GPU_UTIL[5m])
)

次のクエリでは、フレーム バッファーメモリ使用量をパーセンテージで計算します。

100 *
DCGM_FI_DEV_FB_USED
/
(DCGM_FI_DEV_FB_USED + DCGM_FI_DEV_FB_FREE)

次のクエリでは、1 秒あたりに処理されたトレーニング サンプルが計算されます。

sum by (job_name) (
  rate(ml_training_samples_total[5m])
)

次のクエリでは、平均ステップ期間が表示されます。

avg by (job_name) (
  ml_training_step_duration_seconds
)

これらのシグナルを一緒に解釈します。

  • GPU 使用率が低く、データ待機時間が長い場合は、通常、ストレージ、ネットワーク、前処理、または CPU 不足を示します。
  • 予想されるスループットで GPU 使用率が高い場合は、アクセラレータが効果的に使用されていることを示します。
  • 高い GPU メモリとメモリ不足エラーの繰り返しは、バッチ サイズ、シーケンスの長さ、アクティブ化メモリ、オプティマイザーの状態、または断片化に調整が必要であることを示します。
  • 安定した GPU 使用率でスループットが低下すると、シーケンスの長さ、通信のオーバーヘッド、熱的な動作、またはモデルの計算の変化を示す可能性があります。
  • 割り当てられた GPU の GPU 使用率が低い場合は、アイドル容量が減ったり、キューに入れたり、MIG でパーティション分割されたりする可能性があることを示します。
  • チェックポイント期間が長いと、プリエンプションのコストが高くなり、復旧後に繰り返される作業の量が増える可能性があります。

継続的な GPU の低利用状態、上限近くに達した GPU メモリ、XID エラー、停滞したトレーニング スループット、失敗したワーカー、保留中のギャングスケジュールされたワークロード、および想定される目標復旧時点(RPO)内に完了していないチェックポイントに対するアラートを作成します。

よく寄せられる質問 (FAQ)

AKS Automatic と AKS Standard for MLOps の違いは何ですか?

AKS Automatic では、ノード プール、ネットワーク、セキュリティ、アップグレードの構成済みの既定値が提供されるため、MLOps チームはワークロード定義とガバナンスに集中できます。 AKS Standard では、これらのプラットフォーム コンポーネントを手動で構成する必要がありますが、カスタム アーキテクチャとスケーリング要件をより詳細に制御できます。

AKS で ML モデルをバージョン管理するにはどうすればよいですか?

モデルの重み、メタデータ、および構成をセマンティック バージョン タグを使用してコンテナー イメージにパッケージ化して、モデルのバージョンを設定します。 これらのイメージをAzure Container Registryに格納し、環境間の一貫性を確保するために、Kubernetes 配置マニフェストで特定のバージョンを参照します。

AKS で GPU ワークロードをスケジュールするにはどうすればよいですか?

GPU ノードが nvidia.com/gpuをアドバタイズできるように、NVIDIA デバイス プラグインが使用可能であることを確認します。 AKS Standard では、サポートされている VM サイズ (Standard_NC シリーズ SKU など) を使用して専用 GPU ユーザー ノード プールをプロビジョニングし、ノード ラベル、 NoSchedule テイント、クラスター オートスケーラーの制限を構成します。 各トレーニング ポッドで、 nvidia.com/gpuを要求し、対象となる GPU ノードを選択し、一致する容認を追加します。 AKS Automatic では、サポートされている SKU、リージョンでの可用性、スケジューリングの制約、および Azure サブスクリプションのクォータを条件として、Pod の要求に基づいて対象となる GPU 容量をプロビジョニングできます。

AKS で分散トレーニング ジョブを実行するにはどうすればよいですか?

Kubeflow トレーニング オペレーターをインストールし、分散レプリカ、ランデブー構成、再起動動作、ジョブの状態を管理するための PyTorchJob または TFJob を送信します。 KAITO は、サポートされているモデルの微調整ワークフローに対して AKS に重点を置いたワークスペース抽象化を提供し、GPU インフラストラクチャをモデル プリセットと調整できます。 マルチノード PyTorch トレーニングの場合は、AKS CNI ポッド ネットワーク経由で NCCL を構成してベンチマークし、ネットワーク ポリシーを介してワーカー間トラフィックを許可し、選択した VM SKU とワークロードで必要な場合にサポートされる RDMA 構成を使用します。

複数のチーム間で GPU クォータを管理するにはどうすればよいですか?

Kueue をインストールし、CPU、メモリ、およびClusterQueueクォータを使用してnvidia.com/gpuリソースを定義し、各チームの名前空間をLocalQueueを介して割り当てられたクォータにマップします。 チームが未使用のキャパシティを借用できる場合は、Kueue コホートまたは公平共有を利用します。 Volcano は、ワーカーを全か無かで割り当てるバッチ Scheduler が必要な場合の代替となります。 キューの優先順位を Kubernetes PriorityClass リソースと連動させることで、遅延に敏感な推論が中断可能なトレーニングをプリエンプトできるようにします。そして、プリエンプト可能なトレーニング ジョブが永続ストレージ上のチェックポイントから確実に復旧できるようにします。

AKS で実行時間の長いバッチ ジョブを実行するためのベスト プラクティスは何ですか?

有限の作業には Kubernetes Job を使用し、スケジュールされた作業には CronJob を使用します。 チェックポイントとコミット済みの出力をポッドの外部に保持し、処理を冪等にし、SIGTERM を処理し、明示的なリソース要求、再試行制限、期限、およびクリーンアップポリシーを設定します。 ノードのメンテナンスまたは障害によってポッドが置き換えられると想定し、置換によってチェックポイントが正しく復元されることをテストします。 ジョブの状態、ポッド イベント、ログ、チェックポイントの有効期間、スループット、再試行の動作を監視します。 通常の再起動可能なジョブでは、ギャングスケジューリングや PDB は必要としません。 これらのコントロールは、並列ワーカーが一緒に開始するか、テスト済みの最小コンカレンシーを維持する必要がある場合にのみ使用します。

AKS でのアプリケーションのデプロイと操作の他の領域でのベスト プラクティスについて説明します。