Verwenden Sie GPUs für rechenintensive Workloads im Azure Kubernetes Service (AKS)

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 Linux-Knotenpools, um computeintensive Kubernetes-Workloads auszuführen.

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

Unterstützte GPU-fähige VMs

Informationen zum Anzeigen der verfügbaren GPU-fähigen VMs finden Sie unter GPU-optimierte VM-Größen in Azure. Wenn eine GPU-VM-Größe nicht in unserer Liste der unterstützten VM-Größen enthalten ist, installiert AKS nicht die erforderlichen GPU-Softwarekomponenten oder bietet Unterstützung. AKS ermöglicht die Verwendung von nicht unterstützten GPU-VM-Größen, nachdem die automatische GPU-Treiberinstallation übersprungen wurde.

Überprüfen Sie die verfügbaren und unterstützten VM-Größen mithilfe des az vm list-skus Befehls.

az vm list-skus --location <your-location> --output table

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.

Einschränkungen

• Bei Verwendung eines Azure Linux-GPU-Knotenpools werden keine automatischen Sicherheitspatches angewandt. Weitere Informationen zum Standardverhalten des Upgradekanals für das Knotenbetriebssystem finden Sie in Ihrer aktuellen AKS-API-Version.
• Flatcar Container Linux für AKS wird nicht mit NVIDIA GPU auf AKS unterstützt.
• Azure Linux mit OS Guard für AKS wird nicht mit NVIDIA GPU auf AKS unterstützt.

• Das Aktualisieren eines vorhandenen Knotenpools zum Hinzufügen der GPU-VM-Größe wird auf AKS nicht unterstützt.

Bevor Sie anfangen

• 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.
• Sie benötigen die Azure CLI-Version 2.72.2 oder höher installiert, um das --gpu-driver Feld festzulegen. Führen Sie az --version aus, um die Version zu ermitteln. Wenn Sie eine Installation oder ein Upgrade durchführen müssen, finden Sie weitere Informationen unter Azure CLI installieren.
• Wenn Sie die aks-preview Azure CLI-Erweiterung installiert haben, aktualisieren Sie die Version auf 18.0.0b2 oder höher.

Holen Sie sich die 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

Optionen für die Verwendung von NVIDIA GPUs

Die Verwendung von NVIDIA-GPUs umfasst die Installation verschiedener NVIDIA-Softwarekomponenten wie des NVIDIA-Geräte-Plug-Ins für Kubernetes, des GPU-Treibers u. v. m.

Installation des NVIDIA-Geräte-Plug-Ins

Bei Verwendung von GPUs in AKS ist die Installation des NVIDIA-Geräte-Plug-Ins erforderlich. In einigen Fällen erfolgt die Installation automatisch, z. B. bei Verwendung des NVIDIA-GPU-Operators. Alternativ können Sie das NVIDIA-Geräte-Plug-In auch manuell installieren.

Manuelles Installieren des NVIDIA-Geräte-Plug-Ins

Sie können ein DaemonSet für das NVIDIA-Geräte-Plug-In bereitstellen, das einen Pod auf jedem Knoten ausführt, um die erforderlichen Treiber für die GPUs bereitzustellen. Dies ist der empfohlene Ansatz bei der Verwendung von GPU-fähigen Knotenpools für Azure Linux.

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --node-vm-size Standard_NC6s_v3 \
    --node-taints sku=gpu:NoSchedule \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --os-sku AzureLinux \
    --node-vm-size Standard_NC6s_v3 \
    --node-taints sku=gpu:NoSchedule \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

1. Erstellen Sie mithilfe des Befehls kubectl create namespace einen Namespace.

   kubectl create namespace gpu-resources
   

2. Erstellen Sie eine Datei namens nvidia-device-plugin-ds.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:
         labels:
           name: nvidia-device-plugin-ds
       spec:
         tolerations:
         - key: "sku"
           operator: "Equal"
           value: "gpu"
           effect: "NoSchedule"
         # 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.
         # See https://kubernetes.io/docs/tasks/administer-cluster/guaranteed-scheduling-critical-addon-pods/
         priorityClassName: "system-node-critical"
         containers:
         - image: nvcr.io/nvidia/k8s-device-plugin:v0.18.0
           name: nvidia-device-plugin-ctr
           env:
             - name: FAIL_ON_INIT_ERROR
               value: "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
   

3. 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
   

4. Nachdem Sie das NVIDIA-Geräte-Plug-In erfolgreich installiert haben, können Sie überprüfen, ob Ihre GPUs planbar sind, und eine GPU-Workload ausführen.

GPU-Treiberinstallation überspringen

Wenn Sie die Installation der NVIDIA-Treiber steuern oder den NVIDIA GPU Operator verwenden möchten, können Sie die Standardinstallation des GPU-Treibers überspringen. Microsoft unterstützt oder verwaltet nicht die Wartung und Kompatibilität der NVIDIA-Treiber als Teil der Knotenimagebereitstellung.

1. Erstellen Sie einen Knotenpool mit dem Befehl az aks nodepool add und setzen Sie das Feld --gpu-driver auf none, um die Standardinstallation des GPU-Treibers zu überspringen.

   az aks nodepool add \
       --resource-group myResourceGroup \
       --cluster-name myAKSCluster \
       --name gpunp \
       --node-count 1 \
       --gpu-driver none \
       --node-vm-size Standard_NC6s_v3 \
       --enable-cluster-autoscaler \
       --min-count 1 \
       --max-count 3
   

   Wenn Sie das --gpu-driver API-Feld während der Erstellung des Knotenpools auf none setzen, wird die automatische Installation des GPU-Treibers übersprungen. Vorhandene Knoten werden nicht geändert. Sie können den Knotenpool auf null skalieren und dann wieder hochskalieren, um die Änderung wirksam werden zu lassen.

   Wenn der Fehler angezeigt unrecognized arguments: --gpu-driver none wird, aktualisieren Sie die Azure CLI-Version. Weitere Informationen finden Sie im Artikel zu den Vorbereitungsmaßnahmen.

2. Sie können optional den NVIDIA GPU-Operator mit den folgenden Schritten installieren.

Bestätigen, dass GPUs planbar sind

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

1. 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
   

2. Stellen Sie sicher, dass die GPUs planbar sind, indem Sie den Befehl kubectl describe node verwenden.

   kubectl describe node aks-gpunp-28993262-0
   

   Unter dem Abschnitt Capacity (Kapazität) sollte die GPU als nvidia.com/gpu: 1 aufgelistet werden. Ihre Ausgabe sollte der folgenden gekürzten Beispielausgabe entsprechen:

   Name:               aks-gpunp-28993262-0
   Roles:              agent
   Labels:             accelerator=nvidia
   
   [...]
   
   Capacity:
   [...]
    nvidia.com/gpu:                 1
   [...]
   

Ausführen einer GPU-fähigen Workload

Um die GPU in Aktion zu sehen, können Sie eine GPU-fähige Workload mit der entsprechenden Ressourcenanforderung planen. In diesem Beispiel führen wir einen TensorFlow-Auftrag für das MNIST-Dataset aus.

1. Erstellen Sie eine Datei mit dem Namen samples-tf-mnist-demo.yaml, und fügen Sie das folgende YAML-Manifest ein, das ein Ressourcenlimit von nvidia.com/gpu: 1 enthält:

   Hinweis

   Wenn Sie beim Aufruf von Treibern einen Versionskonfliktfehler erhalten, z. B., dass die CUDA-Treiberversion für die CUDA-Laufzeitversion nicht ausreicht, überprüfen Sie das NVIDIA-Treibermatrix-Kompatibilitätsdiagramm.

   apiVersion: batch/v1
   kind: Job
   metadata:
     labels:
       app: samples-tf-mnist-demo
     name: samples-tf-mnist-demo
   spec:
     template:
       metadata:
         labels:
           app: samples-tf-mnist-demo
       spec:
         containers:
         - name: samples-tf-mnist-demo
           image: mcr.microsoft.com/azuredocs/samples-tf-mnist-demo:gpu
           args: ["--max_steps", "500"]
           imagePullPolicy: IfNotPresent
           resources:
             limits:
              nvidia.com/gpu: 1
         restartPolicy: OnFailure
         tolerations:
         - key: "sku"
           operator: "Equal"
           value: "gpu"
           effect: "NoSchedule"
   

2. Führen Sie den Auftrag mithilfe des kubectl apply-Befehls aus, der die Manifestdatei analysiert und die definierten Kubernetes-Objekte erstellt.

   kubectl apply -f samples-tf-mnist-demo.yaml
   

Zeigen Sie den Status der GPU-fähigen Arbeitslast an

1. Überwachen Sie den Fortschritt des Auftrags mithilfe des Befehls kubectl get jobs und des Flags --watch. Es kann einige Minuten dauern, um zunächst das Image zu pullen und das Dataset zu verarbeiten.

   kubectl get jobs samples-tf-mnist-demo --watch
   

   Wenn in der Spalte ABSCHLÜSSE der Wert 1/1 angezeigt wird, wurde der Auftrag erfolgreich abgeschlossen, wie in der folgenden Beispielausgabe gezeigt:

   NAME                    COMPLETIONS   DURATION   AGE
   
   samples-tf-mnist-demo   0/1           3m29s      3m29s
   samples-tf-mnist-demo   1/1   3m10s   3m36s
   

2. Beenden Sie den kubectl --watch-Prozess mit STRG+C.

3. Rufen Sie den Namen des Pods mit dem Befehl kubectl get pods ab.

   kubectl get pods --selector app=samples-tf-mnist-demo
   

4. Zeigen Sie die Ausgabe der GPU-fähigen Workload mit dem Befehl kubectl logs an.

   kubectl logs samples-tf-mnist-demo-smnr6
   

   Die folgende komprimierte Beispielausgabe der Podprotokolle bestätigt, dass das entsprechende GPU-Gerät, Tesla K80, ermittelt wurde:

   2019-05-16 16:08:31.258328: I tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA
   2019-05-16 16:08:31.396846: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1030] Found device 0 with properties:
   name: Tesla K80 major: 3 minor: 7 memoryClockRate(GHz): 0.8235
   pciBusID: 2fd7:00:00.0
   totalMemory: 11.17GiB freeMemory: 11.10GiB
   2019-05-16 16:08:31.396886: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1120] Creating TensorFlow device (/device:GPU:0) -> (device: 0, name: Tesla K80, pci bus id: 2fd7:00:00.0, compute capability: 3.7)
   2019-05-16 16:08:36.076962: I tensorflow/stream_executor/dso_loader.cc:139] successfully opened CUDA library libcupti.so.8.0 locally
   Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.
   Extracting /tmp/tensorflow/input_data/train-images-idx3-ubyte.gz
   Successfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.
   Extracting /tmp/tensorflow/input_data/train-labels-idx1-ubyte.gz
   Successfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.
   Extracting /tmp/tensorflow/input_data/t10k-images-idx3-ubyte.gz
   Successfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.
   Extracting /tmp/tensorflow/input_data/t10k-labels-idx1-ubyte.gz
   Accuracy at step 0: 0.1081
   Accuracy at step 10: 0.7457
   Accuracy at step 20: 0.8233
   Accuracy at step 30: 0.8644
   Accuracy at step 40: 0.8848
   Accuracy at step 50: 0.8889
   Accuracy at step 60: 0.8898
   Accuracy at step 70: 0.8979
   Accuracy at step 80: 0.9087
   Accuracy at step 90: 0.9099
   Adding run metadata for 99
   Accuracy at step 100: 0.9125
   Accuracy at step 110: 0.9184
   Accuracy at step 120: 0.922
   Accuracy at step 130: 0.9161
   Accuracy at step 140: 0.9219
   Accuracy at step 150: 0.9151
   Accuracy at step 160: 0.9199
   Accuracy at step 170: 0.9305
   Accuracy at step 180: 0.9251
   Accuracy at step 190: 0.9258
   Adding run metadata for 199
   [...]
   Adding run metadata for 499
   

Aktualisieren eines Knotenpools

Unabhängig davon, ob Sie die Knotenpools aktualisieren oder aufrüsten möchten, werden Sie möglicherweise feststellen, dass es keinen --gpu-driver Parameter für einen der beiden Vorgänge gibt. Möglicherweise tritt ein Fehler wie unrecognized arguments: --gpu-driver none auf, wenn Sie versuchen, den Parameter zu übergeben. Der Parameter muss nicht aufgerufen werden, da der Wert von solchen Vorgängen nicht betroffen ist.

Wenn Sie ihren Knotenpool zum ersten Mal erstellen, wird der von Ihnen deklarierte --gpu-driver Parameter nicht durch Upgrade-/Updatevorgänge beeinträchtigt. Wenn Sie keine Treiber installieren möchten und --gpu-driver None beim Erstellen Ihres Knotenpools ausgewählt haben, werden in nachfolgenden Updates/Upgrades keine Treiber installiert.

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 samples-tf-mnist-demo

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:
  • Konfigurieren eines Kubernetes-Clusters für ML-Modelltraining oder -bereitstellung
  • Bereitstellen eines Modells mit einem Onlineendpunkt
  • High-Performance-Bereitstellung mit Triton Inference Server
  • Labs für Kubernetes und Kubeflow.