Dela via

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

  • Artikel

Grafiska bearbetningsenheter (GPU:er) används ofta för beräkningsintensiva arbetsbelastningar, till exempel grafik- och visualiseringsarbetsbelastningar. AKS stöder 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 GPU:er på nya och befintliga AKS-kluster.

GPU-aktiverade virtuella datorer som stöds

Information om hur du visar GPU-aktiverade virtuella datorer som stöds finns i GPU-optimerade VM-storlekar i Azure. 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.

Kommentar

GPU-aktiverade virtuella datorer innehåller specialiserad maskinvara med högre pris- och regionstillgä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äkerhetskorrigeringar. Se din aktuella AKS API-version för standardbeteendet för node OS-uppgraderingskanalen.

Kommentar

För AKS API version 2023-06-01 eller senare är standardkanalen för nod-OS-uppgradering NodeImage. För tidigare versioner är standardkanalen Ingen. Mer information finns i Automatisk uppgradering.

  • NVadsA10 v5-serien är inte en rekommenderad SKU för GPU VHD.
  • Det går inte att uppdatera en befintlig nodpool för att lägga till 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.0.64 eller senare installerad och konfigurerad. Kör az --version för att hitta versionen. Om du behöver installera eller uppgradera kan du läsa Installera Azure CLI.

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 omfattar installation av olika NVIDIA-programvarukomponenter, till exempel NVIDIA-enhets-plugin-programmet för Kubernetes, GPU-drivrutinsinstallation med mera.

Kommentar

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 PLUGIN-program för NVIDIA-enheter krävs när du använder GPU:er på AKS. I vissa fall hanteras installationen automatiskt, till exempel när du använder NVIDIA GPU-operatorn eller AKS GPU-avbildningen (förhandsversion). Du kan också installera PLUGIN-programmet för NVIDIA-enheten manuellt.

Installera PLUGIN-programmet för NVIDIA-enheten manuellt

Du kan distribuera en DaemonSet för NVIDIA-enhetens plugin-program, som kör en podd på varje nod för att tillhandahålla nödvändiga drivrutiner för GPU:erna. Det här är den rekommenderade metoden när du använder GPU-aktiverade nodpooler för Azure Linux.

Om du vill använda os-standard-SKU:n skapar du nodpoolen utan att ange en OS-SKU. Nodpoolen är konfigurerad för standardoperativsystemet baserat på Kubernetes-versionen av klustret.

  1. 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-taint i nodpoolen.
    • --enable-cluster-autoscaler: Aktiverar autoskalning av kluster.
    • --min-count: Konfigurerar autoskalning av kluster för att underhålla minst en nod i nodpoolen.
    • --max-count: Konfigurerar autoskalning av kluster för att underhålla högst tre noder i nodpoolen.

    Kommentar

    Taints- och VM-storlekar kan bara anges för nodpooler när nodpoolen skapas, men du kan uppdatera autoskalningsinställningarna 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: kube-system
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.15.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 plugin-programmet för NVIDIA-enheten har skapats med 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 installationen av GPU-drivrutinen (förhandsversion)

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.

Viktigt!

AKS-förhandsversionsfunktioner är tillgängliga via självbetjäning och anmäl dig. Förhandsversioner tillhandahålls "som är" och "som tillgängliga", och de undantas från serviceavtalen och den begränsade garantin. AKS-förhandsversioner omfattas delvis av kundsupport på bästa sätt. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:

  1. Registrera eller uppdatera aks-preview-tillägget med hjälp av az extension add kommandot eller az extension update .

    # Register the aks-preview extension
az extension add --name aks-preview

# Update the aks-preview extension
az extension update --name aks-preview

  2. Skapa en nodpool med az aks nodepool add kommandot med --skip-gpu-driver-install flaggan för att hoppa över automatisk GPU-drivrutinsinstallation.

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

    --skip-gpu-driver-install När du lägger till flaggan när nodpoolen skapas hoppar du över den automatiska GPU-drivrutinsinstallationen. Befintliga noder ändras inte. Du kan skala nodpoolen till noll och sedan säkerhetskopiera för att ändringen ska börja gälla.

Använda NVIDIA GPU-operator med AKS

NVIDIA GPU-operatören automatiserar hanteringen av alla NVIDIA-programvarukomponenter som behövs för att etablera GPU, inklusive drivrutinsinstallation, NVIDIA-enhets plugin-programmet för Kubernetes, NVIDIA-containerkörningen med mera. Eftersom GPU-operatorn hanterar dessa komponenter är det inte nödvändigt att installera PLUGIN-programmet för NVIDIA-enheten manuellt. Det innebär också att den automatiska GPU-drivrutinsinstallationen på AKS inte längre krävs.

  1. Hoppa över automatisk GPU-drivrutinsinstallation genom att skapa en nodpool med kommandot az aks nodepool add med --skip-gpu-driver-install. --skip-gpu-driver-install När du lägger till flaggan när nodpoolen skapas hoppar du över den automatiska GPU-drivrutinsinstallationen. Befintliga noder ändras inte. Du kan skala nodpoolen till noll och sedan säkerhetskopiera för att ändringen ska börja gälla.

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

  3. Nu när du har installerat GPU-operatorn kan du kontrollera att dina GPU:er kan schemaläggas och köra en GPU-arbetsbelastning.

Varning

Vi rekommenderar inte att du installerar daemonuppsättningen för NVIDIA-enhetsinsticksprogrammet manuellt med kluster med AKS GPU-avbildningen.

Kommentar

Det kan finnas ytterligare saker att tänka på när du använder NVIDIA GPU-operatorn och distribuerar på SPOT-instanser. Se https://github.com/NVIDIA/gpu-operator/issues/577

Använda AKS GPU-avbildningen (förhandsversion)

Kommentar

AKS GPU-avbildningen (förhandsversion) dras tillbaka den 10 januari 2025. Det anpassade huvudet som används nedan är inte längre tillgängligt, vilket innebär att du inte kommer att kunna skapa nya GPU-aktiverade nodpooler med hjälp av AKS GPU-avbildningen. Vi rekommenderar att du migrerar till eller använder GPU-standardkonfigurationen i stället för den dedikerade GPU-avbildningen eftersom den dedikerade GPU-avbildningen 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.

AKS tillhandahåller en fullständigt konfigurerad AKS-avbildning som innehåller NVIDIA-enhets-plugin-programmet för Kubernetes. AKS GPU-avbildningen är för närvarande endast tillgänglig på Ubuntu 18.04.

Viktigt!

AKS-förhandsversionsfunktioner är tillgängliga via självbetjäning och anmäl dig. Förhandsversioner tillhandahålls "som är" och "som tillgängliga", och de undantas från serviceavtalen och den begränsade garantin. AKS-förhandsversioner omfattas delvis av kundsupport på bästa sätt. Därför är dessa funktioner inte avsedda för produktionsanvändning. Mer information finns i följande supportartiklar:

  1. aks-preview Installera Azure CLI-tillägget med kommandot az extension add .

    az extension add --name aks-preview

  2. Uppdatera till den senaste versionen av tillägget med kommandot az extension update .

    az extension update --name aks-preview

  3. Registrera funktionsflaggan GPUDedicatedVHDPreview az feature register med kommandot .

    az feature register --namespace "Microsoft.ContainerService" --name "GPUDedicatedVHDPreview"

    Det tar några minuter för statusen att visa Registrerad.

  4. Kontrollera registreringsstatusen az feature show med kommandot .

    az feature show --namespace "Microsoft.ContainerService" --name "GPUDedicatedVHDPreview"

  5. När statusen visar Registrerad uppdaterar du registreringen av resursprovidern Microsoft.ContainerService med hjälp av az provider register kommandot .

    az provider register --namespace Microsoft.ContainerService

    Nu när du har uppdaterat klustret så att det använder AKS GPU-avbildningen kan du lägga till en nodpool för GPU-noder i klustret.

  6. Lägg till en nodpool 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 \
    --aks-custom-headers UseGPUDedicatedVHD=true \
    --enable-cluster-autoscaler \
    --min-count 1 \
    --max-count 3

    Föregående exempelkommando 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-taint i nodpoolen.
    • --aks-custom-headers: Anger en specialiserad AKS GPU-avbildning, UseGPUDedicatedVHD=true. Om din GPU-sku kräver virtuella datorer av generation 2 använder du --aks-custom-headers UseGPUDedicatedVHD=true,usegen2vm=true i stället.
    • --enable-cluster-autoscaler: Aktiverar autoskalning av kluster.
    • --min-count: Konfigurerar autoskalning av kluster för att underhålla minst en nod i nodpoolen.
    • --max-count: Konfigurerar autoskalning av kluster för att underhålla högst tre noder i nodpoolen.

    Kommentar

    Taints- och VM-storlekar kan bara anges för nodpooler när nodpoolen skapas, men du kan uppdatera autoskalningsinställningarna när som helst.

  7. Nu när du har skapat en nodpool med GPU-avbildningen kan du kontrollera att dina GPU:er kan schemaläggas och köra en GPU-arbetsbelastning.

Bekräfta att GPU:er kan schemaläggas

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

    Dina utdata bör se ut ungefär som följande exempelutdata:

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

  2. Bekräfta att GPU:erna kan schemaläggas med kommandot kubectl describe node .

    kubectl describe node aks-gpunp-28993262-0

    Under avsnittet Kapacitet bör GPU:n lista som nvidia.com/gpu: 1. Dina utdata bör se ut ungefär som följande komprimerade exempelutdata:

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

[...]

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

Köra en GPU-aktiverad arbetsbelastning

Om du vill se GPU:n i praktiken kan du schemalägga en GPU-aktiverad arbetsbelastning med lämplig resursbegäran. I det här exemplet kör vi ett Tensorflow-jobb mot MNIST-datauppsättningen.

  1. Skapa en fil med namnet samples-tf-mnist-demo.yaml och klistra in följande YAML-manifest, som innehåller en resursgräns på nvidia.com/gpu: 1:

    Kommentar

    Om du får ett versionsmatchningsfel vid anrop till drivrutiner, till exempel "CUDA-drivrutinsversionen är otillräcklig för CUDA-körningsversionen", läser du kompatibilitetsdiagrammet för NVIDIA-drivrutinsmatrisen.

    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 parsar manifestfilen och skapar de definierade Kubernetes-objekten.

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

Visa status för den GPU-aktiverade arbetsbelastningen

  1. Övervaka förloppet för jobbet med kommandot kubectl get jobs 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 slutförts, 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. kubectl --watch Avsluta processen med Ctrl-C.

  3. Hämta namnet på podden med kommandot kubectl get pods .

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

  4. Visa utdata från den GPU-aktiverade arbetsbelastningen kubectl logs med kommandot .

    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

Använda Container Insights för att övervaka GPU-användning

Container Insights med AKS övervakar följande GPU-användningsstatistik:

Måttnamn Måttdimension (taggar) beskrivning
containerGpuDutyCycle container.azm.ms/clusterId, container.azm.ms/clusterName, containerName, gpuId, , , gpuModelgpuVendor Procentandel av tiden under den senaste exempelperioden (60 sekunder) under vilken GPU:n var upptagen/bearbetade aktivt för en container. Arbetscykeln är ett tal mellan 1 och 100.
containerGpuLimits container.azm.ms/clusterId, , container.azm.ms/clusterNamecontainerName Varje container kan ange gränser som en eller flera GPU:er. Det går inte att begära eller begränsa en bråkdel av en GPU.
containerGpuRequests container.azm.ms/clusterId, , container.azm.ms/clusterNamecontainerName Varje container kan begära en eller flera GPU:er. Det går inte att begära eller begränsa en bråkdel av en GPU.
containerGpumemoryTotalBytes container.azm.ms/clusterId, container.azm.ms/clusterName, containerName, gpuId, , , gpuModelgpuVendor Mängden GPU-minne i byte som är tillgängligt för användning för en specifik container.
containerGpumemoryUsedBytes container.azm.ms/clusterId, container.azm.ms/clusterName, containerName, gpuId, , , gpuModelgpuVendor Mängden GPU-minne i byte som används av en specifik container.
nodeGpuAllocatable container.azm.ms/clusterId, , container.azm.ms/clusterNamegpuVendor Antal GPU:er i en nod som kan användas av Kubernetes.
nodeGpuCapacity container.azm.ms/clusterId, , container.azm.ms/clusterNamegpuVendor Totalt antal GPU:er i en nod.

Rensa resurser

  • Ta bort de associerade Kubernetes-objekten som du skapade i den här artikeln med hjälp av kubectl delete job kommandot .

    kubectl delete jobs samples-tf-mnist-demo

Nästa steg