Verwenden von Windows GPUs für computeintensive Workloads in Azure Kubernetes Service (AKS) (Vorschau)

Artikel
10/14/2024

GPUs (Graphical Processing Units) werden häufig für computeintensive Workloads (also etwa für grafikintensive und visualisierungsorientierte Workloads) verwendet. AKS unterstützt GPU-fähige Windows- und Linux-Knotenpools, um computeintensive Kubernetes-Workloads auszuführen.

Dieser Artikel unterstützt Sie beim Bereitstellen von Windows-Knoten mit planbaren GPUs auf neuen und vorhandenen AKS-Clustern (Vorschau).

Unterstützte GPU-fähige virtuelle Computer (VMs)

Informationen zum Anzeigen unterstützter GPU-aktivierter VMs finden Sie unter GPU-optimierte VM-Größen in Azure. Für AKS-Knotenpools wird die Mindestgröße Standard_NC6s_v3 empfohlen. Die NVv4-Serie (basierend auf AMD-GPUs) wird von AKS nicht unterstützt.

Hinweis

GPU-fähige virtuelle Computer verfügen über spezielle Hardware, für die höhere Preise gelten und die möglicherweise nicht in allen Regionen verfügbar ist. Weitere Informationen finden Sie in der Preisübersicht sowie auf der Website zur regionalen Verfügbarkeit.

Begrenzungen

Das Aktualisieren eines vorhandenen Windows-Knotenpools zum Hinzufügen von GPU wird nicht unterstützt.
Wird unter Kubernetes, Version 1.28 und früher, nicht unterstützt.

Voraussetzungen

In diesem Artikel wird vorausgesetzt, dass Sie über einen AKS-Cluster verfügen. Wenn Sie keinen Cluster haben, erstellen Sie einen mithilfe der Azure CLI, der Azure PowerShell oder im Azure-Portal.
Azure CLI Version 1.0.0b2 oder höher muss installiert und konfiguriert sein, um das Feld --skip-gpu-driver-install mit dem Befehl az aks nodepool add zu verwenden. Führen Sie az --version aus, um die Version zu ermitteln. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI.
Azure CLI Version 9.0.0b5 oder höher muss installiert und konfiguriert sein, um das Feld --driver-type mit dem Befehl az aks nodepool add zu verwenden. Führen Sie az --version aus, um die Version zu ermitteln. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI.

Abrufen der Anmeldeinformationen für Ihren Cluster

Laden Sie die Anmeldeinformationen für den AKS-Cluster mit dem Befehl az aks get-credentials. Im folgenden Beispiel werden die Anmeldeinformationen für den Cluster myAKSCluster in der Ressourcengruppe myResourceGroup abgerufen:
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Verwenden der Windows-GPU mit automatischer Treiberinstallation

Die Verwendung von NVIDIA-GPUs umfasst die Installation verschiedener DirectX-Softwarekomponenten wie des NVIDIA-Geräte-Plug-Ins für Kubernetes, des GPU-Treibers u. v. m. Wenn Sie einen Windows-Knotenpool mit einer unterstützten GPU-fähigen VM erstellen, werden diese Komponenten und die entsprechenden NVIDIA CUDA- oder GRID-Treiber installiert. Für die VM-Größen der NC- und ND-Serie wird der CUDA-Treiber installiert. Für VM-Größen der NV-Serie wird der GRID-Treiber installiert.

Wichtig

AKS-Previewfunktionen stehen gemäß dem Self-Service- und Aktivierungsprinzip zur Verfügung. Vorschauversionen werden „wie besehen“ und „wie verfügbar“ bereitgestellt und sind von Service Level Agreements und der Herstellergarantie ausgeschlossen. AKS-Vorschauversionen werden teilweise vom Kundensupport auf Grundlage der bestmöglichen Leistung abgedeckt. Daher sind diese Funktionen nicht für die Verwendung in der Produktion vorgesehen. Weitere Informationen finden Sie in den folgenden Supportartikeln:

Installieren der Azure CLI-Erweiterung `aks-preview`

Registrieren oder aktualisieren Sie die Erweiterung „aks-preview“ mithilfe des Befehls az extension add oder az extension update.

# Register the aks-preview extension
az extension add --name aks-preview

# Update the aks-preview extension
az extension update --name aks-preview

Registrieren des `WindowsGPUPreview`-Featureflags

Registrieren Sie das Featureflag WindowsGPUPreview mithilfe des Befehls az feature register.
```
az feature register --namespace "Microsoft.ContainerService" --name "WindowsGPUPreview"
```
Es dauert einige Minuten, bis der Status Registered (Registriert) angezeigt wird.

Überprüfen Sie den Registrierungsstatus mithilfe des Befehls az feature show.

az feature show --namespace "Microsoft.ContainerService" --name "WindowsGPUPreview"

Wenn der Zustand Registered (Registriert) lautet, aktualisieren Sie die Registrierung des Ressourcenanbieters Microsoft.ContainerService mithilfe des Befehls az provider register.
```
az provider register --namespace Microsoft.ContainerService
```

Erstellen eines Windows-GPU-fähigen Knotenpools (Vorschau)

Um einen Windows-GPU-fähigen Knotenpool zu erstellen, müssen Sie eine unterstützte GPU-fähige VM-Größe verwenden und die os-type als Windows angeben. Die Standardmäßige Windows-os-sku ist Windows2022, aber alle Windows os-sku-Optionen werden unterstützt.

Erstellen Sie einen Windows-GPU-fähigen Knotenpool mit dem Befehl az aks nodepool add.

az aks nodepool add \
   --resource-group myResourceGroup \
   --cluster-name myAKSCluster \
   --name gpunp \
   --node-count 1 \
   --os-type Windows \
   --kubernetes-version 1.29.0 \
   --node-vm-size Standard_NC6s_v3

Überprüfen Sie, ob Ihre GPUs planbar sind.
Nachdem Sie bestätigt haben, dass Ihre GPUs planbar sind, können Sie Ihre GPU-Workload ausführen.

Angeben des GPU-Treibertyps (Vorschau)

Standardmäßig gibt AKS einen GPU-Treibertyp für jede unterstützte GPU-fähige VM an. Da Workload und Treiberkompatibilität für die Funktionstüchtigkeit von GPU-Workloads wichtig sind, können Sie den Treibertyp für Ihren Windows-GPU-Knoten angeben. Dieses Feature wird für Linux-GPU-Knotenpools nicht unterstützt.

Beim Erstellen eines Windows-Agentpools mit GPU-Unterstützung haben Sie die Möglichkeit, den GPU-Treibertyp mithilfe des --driver-type-Flags anzugeben.

Verfügbare Optionen:

GRID: Für Anwendungen, die Virtualisierungsunterstützung erfordern.
CUDA: Optimiert für Computingaufgaben in wissenschaftlichen Computing- und datenintensiven Anwendungen.

Hinweis

Wenn Sie das --driver-type-Flag festlegen, übernehmen Sie die Verantwortung, sicherzustellen, dass der ausgewählte Treibertyp mit der spezifischen VM-Größe und -Konfiguration Ihres Knotenpools kompatibel ist. Während AKS versucht, die Kompatibilität zu überprüfen, gibt es Szenarios, in denen die Erstellung des Knotenpools aufgrund von Inkompatibilitäten zwischen dem angegebenen Treibertyp und der zugrunde liegenden VM oder Hardware fehlschlägt.

Verwenden Sie den Befehl az aks nodepool add, um einen Windows-GPU-fähigen Knotenpool mit einem bestimmten GPU-Treibertyp zu erstellen.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --os-type Windows \
    --kubernetes-version 1.29.0 \
    --node-vm-size Standard_NC6s_v3 \
    --driver-type GRID

Der obige Befehl erstellt beispielsweise einen GPU-fähigen Knotenpool mithilfe des GPU-Treibertyps GRID. Wenn Sie diesen Treibertyp auswählen, wird der Standardwert des CUDA-Treibertyps für VM-SKUs der NC-Serie außer Kraft gesetzt.

Verwenden der Windows-GPU mit manueller Treiberinstallation

Beim Erstellen eines Windows-Knotenpools mit VM-Größen der N-Serie (NVIDIA GPU) in AKS werden der GPU-Treiber und das Kubernetes DirectX-Geräte-Plug-In automatisch installiert. Führen Sie die folgenden Schritte aus, um diese automatische Installation zu umgehen:

Überspringen der GPU-Treiberinstallation (Vorschau) mit --skip-gpu-driver-install.
Manuelle Installation des Kubernetes DirectX-Geräte-Plug-Ins.

Überspringen der GPU-Treiberinstallation (Vorschau)

AKS bietet standardmäßig eine automatische Installation von GPU-Treibern. In einigen Fällen, z. B. bei der Installation eigener Treiber, sollten Sie die Installation des GPU-Treibers überspringen.

Wichtig

Registrieren oder aktualisieren Sie die Erweiterung „aks-preview“ mithilfe des Befehls az extension add oder az extension update.

# Register the aks-preview extension
az extension add --name aks-preview

# Update the aks-preview extension
az extension update --name aks-preview

Erstellen Sie einen Knotenpool mit dem Befehl az aks nodepool add und dem Flag --skip-gpu-driver-install, um die automatische Installation des GPU-Treibers zu überspringen.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --os-type windows \
    --os-sku windows2022 \
    --skip-gpu-driver-install

Hinweis

Wenn die --node-vm-size, die Sie verwenden, noch nicht in AKS integriert ist, können Sie keine GPUs verwenden und --skip-gpu-driver-install funktioniert nicht.

Manuelles Installieren des Kubernetes DirectX-Geräte-Plug-Ins

Sie können ein DaemonSet für das Kubernetes DirectX-Geräte-Plug-In bereitstellen, das einen Pod auf jedem Knoten ausführt, um die erforderlichen Treiber für die GPUs bereitzustellen.

Fügen Sie Ihrem Cluster mithilfe des Befehls az aks nodepool add einen Knotenpool hinzu.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --os-type windows \
    --os-sku windows2022

Erstellen eines Namespace und Bereitstellen des Kubernetes DirectX-Geräte-Plug-Ins

Erstellen Sie mithilfe des Befehls kubectl create namespace einen Namespace.
```
kubectl create namespace gpu-resources
```

Erstellen Sie eine Datei namens k8s-directx-device-plugin.yaml, und fügen Sie das folgende YAML-Manifest ein, das als Teil des NVIDIA-Geräte-Plug-Ins für Kubernetes-Projekt bereitgestellt wird:

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: nvidia-device-plugin-daemonset
  namespace: gpu-resources
spec:
  selector:
    matchLabels:
      name: nvidia-device-plugin-ds
  updateStrategy:
    type: RollingUpdate
  template:
    metadata:
      # Mark this pod as a critical add-on; when enabled, the critical add-on scheduler
      # reserves resources for critical add-on pods so that they can be rescheduled after
      # a failure.  This annotation works in tandem with the toleration below.
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ""
      labels:
        name: nvidia-device-plugin-ds
    spec:
      tolerations:
      # Allow this pod to be rescheduled while the node is in "critical add-ons only" mode.
      # This, along with the annotation above marks this pod as a critical add-on.
      - key: CriticalAddonsOnly
        operator: Exists
      - key: nvidia.com/gpu
        operator: Exists
        effect: NoSchedule
      - key: "sku"
        operator: "Equal"
        value: "gpu"
        effect: "NoSchedule"
      containers:
      - image: mcr.microsoft.com/oss/nvidia/k8s-device-plugin:v0.14.1
        name: nvidia-device-plugin-ctr
        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

Erstellen Sie das DaemonSet, und vergewissern Sie sich, dass das NVIDIA-Geräte-Plug-In erfolgreich erstellt wurde, mit dem Befehl kubectl apply.
```
kubectl apply -f nvidia-device-plugin-ds.yaml
```
Nachdem Sie das NVIDIA-Geräte-Plug-In erfolgreich installiert haben, können Sie überprüfen, ob Ihre GPUs planbar sind.

Bestätigen, dass GPUs planbar sind

Nach dem Erstellen Ihres Clusters bestätigen Sie, dass GPUs in Kubernetes planbar sind.

Listen Sie die Knoten in Ihrem Cluster mit dem Befehl kubectl get nodes auf.
```
kubectl get nodes
```
Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:
```
NAME                   STATUS   ROLES   AGE   VERSION
aks-gpunp-28993262-0   Ready    agent   13m   v1.20.7
```
Vergewissern Sie sich, dass die GPUs planbar sind, mit dem Befehl kubectl describe node.
```
kubectl describe node aks-gpunp-28993262-0
```
Unter dem Abschnitt Capacity (Kapazität) sollte die GPU als microsoft.com/directx: 1 aufgelistet werden. Ihre Ausgabe sollte der folgenden gekürzten Beispielausgabe entsprechen:
```
Capacity:
[...]
 microsoft.com.directx/gpu:                 1
[...]
```

Verwenden von Container Insights zum Überwachen der GPU-Nutzung

Container Insights mit AKS überwacht die folgenden GPU-Nutzungsmetriken:

Metrikname	Metrikdimension (Tags)	Beschreibung
containerGpuDutyCycle	`container.azm.ms/clusterId`, `container.azm.ms/clusterName`, `containerName`, `gpuId`, `gpuModel`, `gpuVendor`	Der Prozentsatz der Zeit im Verlauf des letzten Beispielzeitraums (60 Sekunden), während dessen die GPU ausgelastet war/aktiv die Verarbeitung für einen Container ausgeführt hat. Der Arbeitszyklus ist eine Zahl zwischen 1 und 100.
containerGpuLimits	`container.azm.ms/clusterId`, `container.azm.ms/clusterName`, `containerName`	In jedem Container können Grenzwerte als eine oder mehrere GPUs angegeben werden. Es ist nicht möglich, einen Bruchteil einer GPU anzufordern oder einzuschränken.
containerGpuRequests	`container.azm.ms/clusterId`, `container.azm.ms/clusterName`, `containerName`	Jeder Container kann einen oder mehrere GPUs anfordern. Es ist nicht möglich, einen Bruchteil einer GPU anzufordern oder einzuschränken.
containerGpumemoryTotalBytes	`container.azm.ms/clusterId`, `container.azm.ms/clusterName`, `containerName`, `gpuId`, `gpuModel`, `gpuVendor`	Menge an GPU-Arbeitsspeicher in Bytes, die für einen bestimmten Container verwendet werden kann.
containerGpumemoryUsedBytes	`container.azm.ms/clusterId`, `container.azm.ms/clusterName`, `containerName`, `gpuId`, `gpuModel`, `gpuVendor`	Menge an GPU-Arbeitsspeicher in Bytes, die für einen bestimmten Container verwendet wird.
nodeGpuAllocatable	`container.azm.ms/clusterId`, `container.azm.ms/clusterName`, `gpuVendor`	Anzahl von GPUs in einem Knoten, die Kubernetes verwenden kann.
nodeGpuCapacity	`container.azm.ms/clusterId`, `container.azm.ms/clusterName`, `gpuVendor`	Gesamtanzahl der GPUs in einem Knoten.

Bereinigen von Ressourcen

Entfernen Sie die zugeordneten Kubernetes-Objekte, die Sie in diesem Artikel erstellt haben, mit dem Befehl kubectl delete job.
```
kubectl delete jobs windows-gpu-workload
```

Nächste Schritte

Um Apache Spark-Aufträge auszuführen, lesen Sie Ausführen von Apache Spark-Aufträgen in AKS.
Weitere Informationen zu den Features des Kubernetes-Planers finden Sie unter Best Practices für erweiterte Scheduler-Funktionen in Azure Kubernetes Service (AKS).
Weitere Informationen zu Azure Kubernetes Service und Azure Machine Learning finden Sie unter:

Freigeben über

Verwenden von Windows GPUs für computeintensive Workloads in Azure Kubernetes Service (AKS) (Vorschau)

Unterstützte GPU-fähige virtuelle Computer (VMs)

Begrenzungen

Voraussetzungen

Abrufen der Anmeldeinformationen für Ihren Cluster

Verwenden der Windows-GPU mit automatischer Treiberinstallation

Installieren der Azure CLI-Erweiterung `aks-preview`

Registrieren des `WindowsGPUPreview`-Featureflags

Erstellen eines Windows-GPU-fähigen Knotenpools (Vorschau)

Angeben des GPU-Treibertyps (Vorschau)

Verwenden der Windows-GPU mit manueller Treiberinstallation

Überspringen der GPU-Treiberinstallation (Vorschau)

Manuelles Installieren des Kubernetes DirectX-Geräte-Plug-Ins

Erstellen eines Namespace und Bereitstellen des Kubernetes DirectX-Geräte-Plug-Ins

Bestätigen, dass GPUs planbar sind

Verwenden von Container Insights zum Überwachen der GPU-Nutzung

Bereinigen von Ressourcen

Nächste Schritte

Zusätzliche Ressourcen

Freigeben über

Verwenden von Windows GPUs für computeintensive Workloads in Azure Kubernetes Service (AKS) (Vorschau)

Unterstützte GPU-fähige virtuelle Computer (VMs)

Begrenzungen

Voraussetzungen

Abrufen der Anmeldeinformationen für Ihren Cluster

Verwenden der Windows-GPU mit automatischer Treiberinstallation

Installieren der Azure CLI-Erweiterung aks-preview

Registrieren des WindowsGPUPreview-Featureflags

Erstellen eines Windows-GPU-fähigen Knotenpools (Vorschau)

Angeben des GPU-Treibertyps (Vorschau)

Verwenden der Windows-GPU mit manueller Treiberinstallation

Überspringen der GPU-Treiberinstallation (Vorschau)

Manuelles Installieren des Kubernetes DirectX-Geräte-Plug-Ins

Erstellen eines Namespace und Bereitstellen des Kubernetes DirectX-Geräte-Plug-Ins

Bestätigen, dass GPUs planbar sind

Verwenden von Container Insights zum Überwachen der GPU-Nutzung

Bereinigen von Ressourcen

Nächste Schritte

Zusätzliche Ressourcen

Installieren der Azure CLI-Erweiterung `aks-preview`

Registrieren des `WindowsGPUPreview`-Featureflags