Freigeben über

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 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 im Preistool und zur regionalen Verfügbarkeit.

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.

Hinweis

Für AKS-API-Version 2023-06-01 oder höher ist der Standardkanal für das Upgrades des Knotenbetriebssystems NodeImage. Bei früheren Versionen lautet der Standardkanal None. Weitere Informationen finden Sie unter Automatische Upgrades.

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

Hinweis

Das AKS GPU-Image (Vorschau) wird ab dem 10. Januar 2025 eingestellt. Der benutzerdefinierte Header ist nicht mehr verfügbar. Dies bedeutet, dass Sie keine neuen GPU-fähigen Knotenpools mit dem AKS GPU-Image erstellen können. Da das GPU-Image nicht mehr unterstützt wird, empfehlen wir, stattdessen zur GPU-Standardkonfiguration zu migrieren oder diese zu verwenden. Weitere Informationen finden Sie in den AKS-Versionshinweisen, oder sehen Sie sich diese Einstellungsankündigung in unserer öffentlichen AKS-Roadmap an.

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.

Hinweis

Standardmäßig verwaltet Microsoft automatisch die Version der NVIDIA-Treiber als Teil der Knotenimagebereitstellung, und AKS unterstützt und verwaltet sie. Während die NVIDIA-Treiber standardmäßig auf GPU-fähigen Knoten installiert sind, müssen Sie das Geräte-Plug-In installieren.

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.

Um die Standardbetriebssystem-SKU zu verwenden, erstellen Sie den Knotenpool, ohne eine Betriebssystem-SKU anzugeben. Der Knotenpool wird basierend auf der Kubernetes-Version des Clusters für das Standardbetriebssystem konfiguriert.

  1. 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 \
    --node-vm-size Standard_NC6s_v3 \
    --node-taints sku=gpu:NoSchedule \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

    Dieser Beispielbefehl fügt myAKSCluster in myResourceGroup einen Knotenpool namens gpunp hinzu und verwendet Parameter, um die folgenden Knotenpooleinstellungen zu konfigurieren:

    • --node-vm-size: legt die VM-Größe für den Knoten im Knotenpool auf Standard_NC6s_v3 fest.
    • --node-taints: Gibt einen sku=gpu:NoSchedule-Taint für den Knotenpool an.
    • --enable-cluster-autoscaler: Aktiviert die Autoskalierung für Cluster.
    • --min-count: Konfiguriert die automatische Clusterskalierung so, dass mindestens ein Knoten im Knotenpool beibehalten wird.
    • --max-count: Konfiguriert die automatische Clusterskalierung so, dass höchstens drei Knoten im Knotenpool beibehalten werden.

    Hinweis

    Taints und VM-Größen können für Knotenpools nur während ihrer Erstellung festgelegt werden, aber Sie können die Autoskalierungseinstellungen jederzeit aktualisieren.

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

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