Använda AMD-GPU:er för beräkningsintensiva arbetsbelastningar i Azure Kubernetes Service (AKS)

Storlekar för AMD GPU Virtual Machine (VM) i Azure kan ge flexibilitet i prestanda och kostnader, vilket ger hög beräkningskapacitet samtidigt som du kan välja rätt konfiguration för dina arbetsbelastningskrav. AKS stöder AMD GPU-aktiverade Linux-nodpooler för att köra beräkningsintensiva Kubernetes-arbetsbelastningar.

Den här artikeln hjälper dig att etablera noder med schemaläggningsbara AMD-GPU:er på nya och befintliga AKS-kluster.

Begränsningar

AKS stöder för närvarande storleken på den Standard_ND96isr_MI300X_v5 virtuella Azure-datorn som drivs av AMD-GPU:n i MI300-serien.
Uppdatering av en befintlig nodpool för att lägga till en AMD GPU VM-storlek stöds inte på AKS.
Det går inte att uppdatera en icke-AMD GPU-aktiverad nodpool med en AMD GPU VM-storlek.
AzureLinux, Windowsoch AzureLinuxOSGuardflatcar stöds inte med AMD GPU.

Innan du börjar

Den här artikeln förutsätter att du har ett befintligt AKS-kluster. Om du inte har ett kluster skapar du ett med hjälp av Azure CLI, Azure PowerShell eller Azure Portal.
Du behöver Azure CLI version 2.72.2 eller senare installerad för att ange fältet --gpu-driver . Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera, se Installera Azure CLI.
Om du har aks-preview Azure CLI-tillägget installerat uppdaterar du versionen till 18.0.0b2 eller senare.

Anmärkning

GPU-aktiverade virtuella maskiner innehåller specialiserad hårdvara som är föremål för högre prissättning och regionsspecifik tillgänglighet. Mer information finns i prisverktyget och regionens tillgänglighet.

Hämta autentiseringsuppgifterna för klustret

Hämta autentiseringsuppgifterna för AKS-klustret med hjälp av az aks get-credentials kommandot . Följande exempelkommando hämtar autentiseringsuppgifterna för klustret myAKSCluster i myResourceGroup resursgruppen:

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

Alternativ för att använda AMD-GPU:er

Användning av AMD-GPU:er omfattar installation av olika AMD GPU-programvarukomponenter, till exempel AMD-enhets-plugin-programmet för Kubernetes, GPU-drivrutiner med mera.

Anmärkning

För närvarande hanterar inte AKS eller automatiserar inte installationen av GPU-drivrutiner eller AMD GPU-enhets plugin-programmet på AMD GPU-aktiverade nodpooler.

Registrera funktionen AKSInfinibandSupport

Om din AMD GPU VM-storlek är RDMA-aktiverad med r namngivningskonventionen (t.ex. Standard_ND96isr_MI300X_v5) måste du se till att datorerna i nodpoolen hamnar på samma fysiska Infiniband-nätverk. För att uppnå detta registrerar du funktionsflaggan AKSInfinibandSupportaz feature register med kommandot :
```
az feature register --name AKSInfinibandSupport --namespace Microsoft.ContainerService
```

Kontrollera registreringsstatusen med hjälp av az feature show kommandot:

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

Skapa en AMD GPU-aktiverad nodpool med kommandot az aks nodepool add och hoppa över standardinstallationen av drivrutinen genom att ange API-fältet --gpu-driver till värdet none:
```
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
```
Anmärkning

AKS framtvingar för närvarande användning av gpu-driver fältet för att hoppa över automatisk drivrutinsinstallation vid skapandetiden för AMD GPU-nodpoolen.

Implementera AMD GPU-Operatören på AKS

AMD GPU-operatorn automatiserar hanteringen och distributionen av alla AMD-programvarukomponenter som behövs för att etablera GPU, inklusive drivrutinsinstallation, AMD-enhets-plugin-programmet för Kubernetes, AMD-containerkörningen med mera. Eftersom AMD GPU-operatorn hanterar dessa komponenter är det inte nödvändigt att separat installera AMD-enhets plugin-programmet i AKS-klustret. Det innebär också att den automatiska GPU-drivrutinsinstallationen ska hoppas över för att använda AMD GPU-operatorn på AKS.

Följ AMD-dokumentationen för att installera GPU-operatorn.

Kontrollera statusen för AMD-GPU:er i nodpoolen kubectl get nodes med kommandot :

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

Ditt resultat ska likna följande exempelresultat:

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

Bekräfta att AMD-GPU:er kan schemaläggas

När du har skapat nodpoolen kontrollerar du att GPU:er kan schemaläggas i AKS-klustret.

Visa en lista över noderna i klustret med hjälp av kubectl get nodes kommandot .
```
kubectl get nodes
```
Bekräfta att GPU:erna är schemaläggningsbara med kommando kubectl describe node.
```
kubectl describe node aks-gpunp-00000000
```
Under avsnittet Kapacitet bör GPU:n listas som amd.com/gpu: 1. Ditt resultat bör se ut ungefär som det följande komprimerade exempelresultatet:
```
Name:               aks-gpunp-00000000
Roles:              agent
Labels:             accelerator=amd

[...]

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

Köra en AMD GPU-aktiverad arbetsbelastning

Om du vill se hur AMD GPU fungerar i praktiken kan du schemalägga en GPU-aktiverad arbetsbelastning med lämplig resursbegäran. I det här exemplet kommer vi att köra ett Tensorflow-jobb mot MNIST-datasetet.

Skapa en fil som heter samples-tf-mnist-demo.yaml och klistra in följande YAML-manifest, vilket inkluderar en resursbegränsning på amd.com/gpu: 1.

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"

Kör jobbet med kommandot kubectl apply, som tolkar manifestfilen och skapar de definierade Kubernetes-objekten.
```
kubectl apply -f samples-tf-mnist-demo.yaml
```

Visa statusen för arbetsbelastningen med GPU-stöd

Övervaka framstegen för jobbet med hjälp av kubectl get jobs-kommandot med --watch-flaggan. Det kan ta några minuter att först hämta avbildningen och bearbeta datamängden.
```
kubectl get jobs samples-tf-mnist-demo --watch
```
När kolumnen COMPLETIONS visar 1/1, har jobbet avslutats framgångsrikt, vilket visas i följande exempelutdata:
```
NAME                    COMPLETIONS   DURATION   AGE

samples-tf-mnist-demo   0/1           3m29s      3m29s
samples-tf-mnist-demo   1/1   3m10s   3m36s
```
Avsluta kubectl --watch-processen med Ctrl-C.

Hämta podens namn med kommandot kubectl get pods.

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

Rensa resurser

Ta bort de associerade Kubernetes-objekten du skapade i denna artikel genom att använda kommandot kubectl delete job.

kubectl delete jobs samples-tf-mnist-demo

Nästa steg

Utforska de olika lagringsalternativen för ditt GPU-baserade program på AKS.
Läs mer om Ray-kluster på AKS.
Använd NVIDIA GPU:er för dina beräkningsintensiva AKS-arbetsbelastningar.

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-10