Dela via

Använd GPU:er för beräkningsintensiva arbetslaster på Azure Kubernetes Service (AKS)

Grafiska processorer (GPU:er) används ofta för beräkningsintensiva arbetsbelastningar, såsom grafik- och visualiseringsarbetsbelastningar. AKS stöder Linux-nodpooler med GPU för att köra beräkningsintensiva Kubernetes-arbetslaster.

Den här artikeln hjälper dig att provisionera noder med schemaläggningsbara GPU:er i nya och befintliga AKS-kluster.

Viktigt!

Från och med den 30 november 2025 har Azure Kubernetes Service (AKS) inte längre stöd för eller tillhandahåller säkerhetsuppdateringar för Azure Linux 2.0. Azure Linux 2.0-nodbilden är låst i 202512.06.0-versionen. Från och med den 31 mars 2026 tas nodbilder bort och du kan inte skala dina nodpooler. Migrera till en Azure Linux-version som stöds genom att uppgradera dina nodpooler till en Kubernetes-version som stöds eller migrera till osSku AzureLinux3. Mer information finns i [Pensionering] Azure Linux 2.0-nodpooler på AKS.

Stödda GPU-aktiverade virtuella maskiner

Information om hur du visar tillgängliga GPU-aktiverade virtuella datorer finns i GPU-optimerade VM-storlekar i Azure. Om en GPU VM-storlek inte finns i vår lista över vm-storlekar som stöds installerar AKS inte de nödvändiga GPU-programvarukomponenterna eller ger stöd. AKS tillåter användning av GPU VM-storlekar som inte stöds när du har hoppat över den automatiska GPU-drivrutinsinstallationen.

Kontrollera tillgängliga och stödda VM-storlekar med hjälp av az vm list-skus kommandot.

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

För AKS-nodpooler rekommenderar vi en minsta storlek på Standard_NC6s_v3. NVv4-serien (baserad på AMD-GPU:er) stöds inte på AKS.

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.

Begränsningar

  • Om du använder en Azure Linux GPU-aktiverad nodpool tillämpas inte automatiska säkerhetspatchar. Referera till din nuvarande AKS API-version för standardbeteendet hos uppgraderingskanalen för nodens operativsystem.
  • Flatcar Container Linux för AKS stöds inte med NVIDIA GPU på AKS.
  • Azure Linux med OS Guard för AKS stöds inte med NVIDIA GPU på AKS.

Anmärkning

För AKS API-version 2023-06-01 eller senare är standardkanalen för uppgradering av nodens operativsystem NodeImage. För tidigare versioner är standardkanalen None. Mer information finns i Automatisk uppgradering.

  • Att uppdatera en befintlig nodpool för att lägga till GPU VM-storlek stöds inte i AKS.

Anmärkning

AKS GPU-bilden (förhandsvisning) tas ur bruk från och med den 10 januari 2025. Den anpassade rubriken är inte längre tillgänglig, vilket betyder att du inte kan skapa nya GPU-aktiverade nodpooler med AKS GPU-avbildningen. Vi rekommenderar att migrera till eller använda standardkonfigurationen för GPU istället för GPU-bilden, eftersom GPU-bilden inte längre stöds. Mer information finns i viktig information om AKS eller visa det här meddelandet om tillbakadragande i vår offentliga AKS-översikt.

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.

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 myAKSCluster i resursgruppen myResourceGroup:

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

Alternativ för att använda NVIDIA GPU:er

Användning av NVIDIA GPU:er innebär installation av olika NVIDIA-programvarukomponenter, såsom NVIDIA-enhetsplugin för Kubernetes, installation av GPU-drivrutiner och mer.

Anmärkning

Som standard underhåller Microsoft automatiskt versionen av NVIDIA-drivrutinerna som en del av nodbilddistributionen, och AKS stöder och hanterar den. Nvidia-drivrutinerna installeras som standard på GPU-kompatibla noder, men du måste installera plugin-programmet för enheten.

Installation av NVIDIA-enhetsplugin

Installation av NVIDIA-enhetsplugin krävs vid användning av GPU:er på AKS. I vissa fall hanteras installationen automatiskt, som när man använder NVIDIA GPU Operator. Alternativt kan du manuellt installera NVIDIA-enhetspluginen.

Installera manuellt NVIDIA-enhetsplugin

Du kan distribuera ett DaemonSet för NVIDIA-enhetspluginen, som kör en pod på varje nod för att tillhandahålla de nödvändiga drivrutinerna för GPU:erna. Detta är den rekommenderade metoden när du använder nodpooler med GPU för Azure Linux.

För att använda standard-OS SKU skapar du nodpoolen utan att ange ett OS SKU. Nodpoolen är konfigurerad för standardoperativsystemet baserat på Kubernetes-versionen av klustret.

Lägg till en nodpool i klustret med kommandot az aks nodepool add .

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

Det här kommandot lägger till en nodpool med namnet gpunp i myAKSCluster i myResourceGroup och använder parametrar för att konfigurera följande nodpoolinställningar:

  • --node-vm-size: Anger vm-storleken för noden i nodpoolen till Standard_NC6s_v3.
  • --node-taints: Anger en sku=gpu:NoSchedule fläck på nodpoolen.
  • --enable-cluster-autoscaler: Aktiverar klusterautoskalaren.
  • --min-count: Konfigurerar klusterautoskalaren för att bevara minst en nod i nodpoolen.
  • --max-count: Konfigurerar klusterautoscalern så att den håller ett maximalt antal av tre noder i nodpoolen.

Anmärkning

Taints och VM-storlekar kan endast sättas för nodpooler under skapandet av nodpoolerna, men du kan uppdatera autoskalningsinställningar när som helst.

  1. Skapa ett namnområde med kommandot kubectl create namespace .

    kubectl create namespace gpu-resources

  2. Skapa en fil med namnet nvidia-device-plugin-ds.yaml och klistra in följande YAML-manifest som tillhandahålls som en del av NVIDIA-enhetens plugin-program för Kubernetes-projektet:

    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. Skapa DaemonSet och bekräfta att NVIDIA-enhetspluginen har skapats framgångsrikt med hjälp av kommandot kubectl apply.

    kubectl apply -f nvidia-device-plugin-ds.yaml

  4. Nu när du har installerat plugin-programmet för NVIDIA-enheten kan du kontrollera att dina GPU:er kan schemaläggas och köra en GPU-arbetsbelastning.

Hoppa över installation av GPU-drivrutin

Om du vill styra installationen av NVIDIA-drivrutinerna eller använda NVIDIA GPU-operatorn kan du hoppa över GPU-standardinstallationen. Microsoft stöder eller hanterar inte underhåll och kompatibilitet för NVIDIA-drivrutinerna som en del av nodbildsdistributionen.

Anmärkning

gpu-driver API-fältet är ett föreslaget alternativ för kunder som tidigare använde nodpoolstaggen--skip-gpu-driver-install.

  • Nodpoolstaggen --skip-gpu-driver-install på AKS dras tillbaka den 14 augusti 2025. När man skapar en ny nodpool kan det befintliga beteendet att hoppa över automatisk installation av GPU-drivrutiner replikeras genom att ställa in fältet --gpu-driver till none.
  • Efter den 14 augusti 2025 kommer du inte att kunna etablera AKS GPU-aktiverade nodpooler med nodpoolstaggen --skip-gpu-driver-install för att kringgå det här standardbeteendet. Mer information finns i skip-gpu-driver ta bort taggar.

  1. Skapa en nodpool med kommandot az aks nodepool add och ange --gpu-driver-fältet till none för att hoppa över standardinstallation av GPU-drivrutinen.

    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

    Om du anger API-fältet --gpu-driver till none när nodpoolen skapas hoppar den automatiska GPU-drivrutinsinstallationen. Befintliga noder ändras inte. Du kan skala ned nodpoolen till noll och sedan återställa den för att genomföra ändringen.

    Om du får felet unrecognized arguments: --gpu-driver none uppdaterar du Azure CLI-versionen. Mer information finns i Innan du börjar.

  2. Du kan också installera NVIDIA GPU-operatorn genom att följa dessa steg.

Bekräfta att GPU:er är schemaläggningsbara

När du har skapat klustret bekräftar du att GPU:er kan schemaläggas i Kubernetes.

  1. Visa en lista över noderna i klustret med hjälp av kubectl get nodes kommandot .

    kubectl get nodes

    Ditt resultat ska likna följande exempelresultat:

    NAME                   STATUS   ROLES   AGE   VERSION
aks-gpunp-28993262-0   Ready    agent   13m   v1.20.7

  2. Bekräfta att GPU:erna är schemaläggningsbara med kommando kubectl describe node.

    kubectl describe node aks-gpunp-28993262-0

    Under avsnittet Kapacitet bör GPU:n listas som nvidia.com/gpu: 1. Ditt resultat bör se ut ungefär som det följande komprimerade exempelresultatet:

    Name:               aks-gpunp-28993262-0
Roles:              agent
Labels:             accelerator=nvidia

[...]

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

Kör en GPU-aktiverad arbetsbelastning

För att se GPU:n i aktion kan du schemalägga en arbetsbelastning med GPU-stöd med lämplig resursförfrågan. I det här exemplet kommer vi att köra ett Tensorflow-jobb mot MNIST-datasetet.

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

    Anmärkning

    Om du får ett versionsfel när du anropar drivrutiner, som till exempel "CUDA-drivrutinsversionen är otillräcklig för CUDA-runtime-versionen", granska NVIDIA:s kompatibilitetsmatris för drivrutiner.

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

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

  2. Avsluta kubectl --watch-processen med Ctrl-C.

  3. Hämta podens namn med kommandot kubectl get pods.

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

  4. Visa resultatet av den GPU-aktiverade arbetsbelastningen med kommandot kubectl logs.

    kubectl logs samples-tf-mnist-demo-smnr6

    Följande komprimerade exempelutdata från poddloggarna bekräftar att lämplig GPU-enhet, Tesla K80, har identifierats:

    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

Uppgradera en nodpool

Oavsett om du vill uppdatera eller uppgradera dina nodpooler kanske du märker att det inte finns någon --gpu-driver parameter för någon av dessa åtgärder. Du kan stöta på ett fel som unrecognized arguments: --gpu-driver none om du försöker skicka parametern. Du behöver inte anropa parametern eftersom värdet inte påverkas av några sådana åtgärder.

När du först skapar nodpoolen påverkas inte den parameter som du deklarerar för --gpu-driver av uppgraderings-/uppdateringsåtgärder. Om du inte vill att några drivrutiner ska installeras och väljs --gpu-driver None när du skapar nodpoolen installeras inte drivrutiner i efterföljande uppdateringar/uppgraderingar.

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

  • Last updated on