Freigeben über

Verwenden von AMD-GPUs für rechenintensive Workloads in Azure Kubernetes Service (AKS)

AMD GPU Virtual Machine (VM)- Größen in Azure können Flexibilität in Bezug auf Leistung und Kosten bieten und gleichzeitig eine hohe Rechenkapazität bieten, sodass Sie die richtige Konfiguration für Ihre Workloadanforderungen auswählen können. AKS unterstützt AMD GPU-fähige Linux-Knotenpools, um rechenintensive Kubernetes-Workloads auszuführen.

Dieser Artikel hilft Ihnen, Knoten mit planbaren AMD-GPUs in neuen und bestehenden AKS-Clustern bereitzustellen.

Einschränkungen

  • AKS unterstützt derzeit die Größe des Standard_ND96isr_MI300X_v5 virtuellen Azure-Computers, die von der AMD GPU der MI300-Serie unterstützt wird.
  • Das Aktualisieren eines vorhandenen Knotenpools zum Hinzufügen einer AMD GPU-VM-Größe wird auf AKS nicht unterstützt.
  • Das Aktualisieren eines Knotenpools ohne AMD-GPU-Unterstützung mit einer VM-Größe „AMD-GPU“ wird nicht unterstützt.
  • AzureLinux und Windows werden noch nicht mit AMD GPU 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. Informationen zum Installieren oder Upgrade finden Sie unter [Installieren von Azure CLI][install-azure-cli].
  • Wenn Sie die aks-preview Azure CLI-Erweiterung installiert haben, aktualisieren Sie die Version auf 18.0.0b2 oder höher.

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 Tool [preise][azure-pricing] und [Regionsverfügbarkeit][azure-availability].

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. Der folgende Beispielbefehl ruft die Anmeldeinformationen für den Cluster myAKSCluster in der myResourceGroup Ressourcengruppe ab:

az aks get-credentials --resource-group myResourceGroup --name myAKSCluster

Optionen für die Verwendung von AMD GPUs

Die Verwendung von AMD GPUs umfasst die Installation verschiedener AMD GPU-Softwarekomponenten wie das AMD-Geräte-Plug-In für Kubernetes, GPU-Treiber und vieles mehr.

Hinweis

Derzeit verwaltet oder automatisiert AKS weder die Installation von GPU-Treibern noch das AMD GPU-Geräte-Plug-In auf AMD GPU-fähigen Knotenpools.

Registrieren des Features "AKSInfinibandSupport"

  1. Wenn die VM-Größe „AMD-GPU“ RDMA-fähig mit der r Namenskonvention (z. B. Standard_ND96isr_MI300X_v5) ist, müssen Sie sicherstellen, dass die Computer im Knotenpool sich auf demselben physischen Infiniband-Netzwerk befinden. Um dies zu erreichen, registrieren Sie das AKSInfinibandSupport Feature-Flag mithilfe des az feature register Befehls:

    az feature register --name AKSInfinibandSupport --namespace Microsoft.ContainerService

  2. Überprüfen Sie den Registrierungsstatus mit dem Befehl az feature show:

    az feature show \
--namespace "Microsoft.ContainerService" \
--name AKSInfinibandSupport

  3. Erstellen Sie einen AMD GPU-fähigen Knotenpool mithilfe des az aks nodepool add Befehls, und überspringen Sie die Standardtreiberinstallation, indem Sie das API-Feld --gpu-driver auf den Wert nonefestlegen:

    az aks nodepool add \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --name gpunp \
    --node-count 1 \
    --node-vm-size Standard_ND96isr_MI300X_v5 \
    --gpu-driver none

    Hinweis

    AKS erzwingt derzeit die Verwendung des gpu-driver Feldes, um die automatische Treiberinstallation bei der Erstellung des AMD GPU-Knotenpools zu überspringen.

Stellen Sie den AMD GPU Operator auf AKS bereit

Der AMD GPU-Operator automatisiert die Verwaltung und Bereitstellung aller AMD-Softwarekomponenten, die für die Bereitstellung von GPU erforderlich sind, einschließlich treiberinstallation, des AMD-Geräte-Plug-Ins für Kubernetes, der AMD-Containerlaufzeit und vieles mehr. Da der AMD GPU-Operator diese Komponenten verarbeitet, ist es nicht erforderlich, das AMD-Geräte-Plug-In auf Ihrem AKS-Cluster separat zu installieren. Dies bedeutet auch, dass die automatische GPU-Treiberinstallation übersprungen werden sollte, um den AMD GPU-Operator auf AKS zu verwenden.

  1. Folgen Sie der AMD-Dokumentation, um den GPU-Operator zu installieren.

  2. Überprüfen Sie den Status der AMD-GPUs in Ihrem Knotenpool mithilfe des kubectl get nodes Befehls:

    kubectl get nodes -o custom-columns=NAME:.metadata.name,GPUs:.status.capacity.'amd\.com/gpu'

    Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

    NAME                    STATUS   ROLES   AGE    VERSION
aks-gpunp-00000000      Ready    agent   2m4s   v1.31.7

Vergewissern Sie sich, dass die AMD-GPUs einplanbar sind.

Vergewissern Sie sich nach dem Erstellen des Knotenpools, dass GPUs in Ihrem AKS-Cluster geplant werden können.

  1. Listen Sie die Knoten in Ihrem Cluster mit dem Befehl kubectl get nodes auf.

    kubectl get nodes

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

    kubectl describe node aks-gpunp-00000000

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

    Name:               aks-gpunp-00000000
Roles:              agent
Labels:             accelerator=amd

[...]

Capacity:
[...]
 amd.com/gpu:                 1
[...]

Ausführen einer AMD GPU-fähigen Workload

Um die AMD-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 amd.com/gpu: 1 enthält:

    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:
           amd.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, bis das Bild abgerufen und das Dataset verarbeitet wird.

    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

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