Creare un pool di nodi GPU a istanze multipla nel servizio Azure Kubernetes (AKS)

Articolo
11/24/2024

La GPU A100 di NVIDIA può essere divisa in un massimo di sette istanze indipendenti. Ogni istanza ha un proprio multiprocessore stream (SM), responsabile dell'esecuzione di istruzioni in parallelo e della memoria GPU. Per altre informazioni su NVIDIA A100, vedere GPU NVIDIA A100.

Questo articolo illustra come creare un pool di nodi GPU a più istanze usando una dimensione di macchina virtuale compatibile con MIG in un cluster del servizio Azure Kubernetes servizio Azure Kubernetes.

Prerequisiti e limitazioni

Un account Azure con una sottoscrizione attiva. Se non si ha un account, è possibile crearne uno gratuito.
Interfaccia della riga di comando di Azure versione 2.2.0 o successiva installata e configurata. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.
Client della riga di comando kubernetes, kubectl, installato e configurato. Se si usa Azure Cloud Shell, kubectl è già installato. Se si vuole installarlo in locale, è possibile usare il comando az aks install-cli.
Helm v3 installato e configurato. Per altre informazioni, vedere Installazione di Helm.
I pool di nodi GPU a istanze multipli non sono attualmente supportati in Azure Linux.
Non è possibile usare la scalabilità automatica del cluster con pool di nodi GPU a istanze multipli.

Profili di istanza GPU

I profili di istanza GPU definiscono la modalità di partizionamento delle GPU. La tabella seguente mostra il profilo dell'istanza GPU disponibile per: Standard_ND96asr_v4

Nome profilo	Frazione di SM	Frazione di memoria	Numero di istanze create
MIG 1g.5gb	07/01	1/8	7
MIG 2g.10gb	2/7	2/8	3
MIG 3g.20gb	3/7	4/8	2
MIG 4g.20gb	4/7	4/8	1
MIG 7g.40gb	7/7	8/8	1

Ad esempio, il profilo dell'istanza GPU di indica che ogni istanza gpu MIG 1g.5gb ha 1g SM (multiprocessor di streaming) e 5 GB di memoria. In questo caso, la GPU viene partizionata in sette istanze.

I profili di istanza GPU disponibili per questa dimensione di macchina virtuale includono MIG1g, MIG2gMIG3g, MIG4g, e MIG7g.

Importante

Non è possibile modificare il profilo dell'istanza GPU applicata dopo la creazione del pool di nodi.

Creare un cluster del servizio Azure Kubernetes

Creare un gruppo di risorse di Azure usando il comando az group create.
```
az group create --name myResourceGroup --location southcentralus
```

Creare un cluster del servizio Azure Kubernetes usando il comando az aks create.

az aks create \
    --resource-group myResourceGroup \
    --name myAKSCluster \
    --generate-ssh-keys

Configurare kubectl per connettersi al cluster del servizio Azure Kubernetes usando il comando az aks get-credentials.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Creare un pool di nodi GPU a istanze multipla

È possibile usare l'interfaccia della riga di comando di Azure o una richiesta HTTP all'API arm per creare il pool di nodi.

Interfaccia della riga di comando di Azure
Richiesta HTTP

Creare un pool di nodi GPU a più istanze usando il comando az aks nodepool add e specificare il profilo dell'istanza GPU. L'esempio seguente crea un pool di nodi con le dimensioni della Standard_ND96asr_v4 macchina virtuale GPU compatibili con MIG.
```
az aks nodepool add \
    --name aks-mignode \
    --resource-group myResourceGroup \
    --cluster-name myAKSCluster \
    --node-vm-size Standard_ND96asr_v4 \
    --node-count 1 \
    --gpu-instance-profile MIG1g
```

Creare un pool di nodi GPU a istanze multipla inserendo il profilo dell'istanza GPU nel corpo della richiesta.

{
    "properties": {
        "count": 1,
        "vmSize": "Standard_ND96asr_v4",
        "type": "VirtualMachineScaleSets",
        "gpuInstanceProfile": "MIG1g"
    }
}

Determinare la strategia GPU a istanze multipla

Prima di installare i plug-in NVIDIA, è necessario specificare la strategia DIG (Multi-Instance GPU) da usare per il partizionamento GPU: strategia singola o strategia mista. Le due strategie non influiscono sulla modalità di esecuzione dei carichi di lavoro della CPU, ma sulla modalità di visualizzazione delle risorse GPU.

Strategia singola: la singola strategia considera ogni istanza GPU come GPU. Se si usa questa strategia, le risorse GPU vengono visualizzate come nvidia.com/gpu: 1.
Strategia mista: la strategia mista espone le istanze GPU e il profilo dell'istanza GPU. Se si usa questa strategia, la risorsa GPU viene visualizzata come nvidia.com/mig1g.5gb: 1.

Installare i componenti del plug-in del dispositivo NVIDIA e dell'individuazione delle funzionalità GPU (GFD)

Impostare la strategia MIG come variabile di ambiente. È possibile usare una singola strategia o mista.
```
# Single strategy
export MIG_STRATEGY=single

# Mixed strategy
export MIG_STRATEGY=mixed
```
Aggiungere il repository helm del plug-in del dispositivo NVIDIA usando i helm repo add comandi e helm repo update .
```
helm repo add nvdp https://nvidia.github.io/k8s-device-plugin
helm repo update
```

Installare il plug-in del dispositivo NVIDIA usando il helm install comando .

helm install nvdp nvdp/nvidia-device-plugin \
--version=0.15.0 \
--generate-name \
--set migStrategy=${MIG_STRATEGY} \
--set gfd.enabled=true \
--namespace nvidia-device-plugin \
--create-namespace

Nota

L'installazione Helm del plug-in del dispositivo NVIDIA versione 0.15.0 e successive consolida il plug-in del dispositivo e i repository GFD. L'installazione helm separata del componente software GFD non è consigliata in questa esercitazione.

Confermare la funzionalità GPU a istanze multipla

Verificare la kubectl connessione al cluster usando il kubectl get comando per restituire un elenco di nodi del cluster.
```
kubectl get nodes -o wide
```
Verificare che il nodo abbia funzionalità GPU a istanze multipla usando il comando kubectl describe node. Il comando di esempio seguente descrive il nodo denominato aks-mignode, che usa MIG1g come profilo di istanza GPU.
```
kubectl describe node aks-mignode
```
L'output dovrebbe essere simile all'output di esempio seguente:
```
# Single strategy output
Allocatable:
    nvidia.com/gpu: 56

# Mixed strategy output
Allocatable:
    nvidia.com/mig-1g.5gb: 56
```

Pianifica il lavoro

Gli esempi seguenti sono basati sull'immagine di base CUDA versione 12.1.1 per Ubuntu 22.04, contrassegnata come 12.1.1-base-ubuntu22.04.

Strategia singola

Creare un file denominato single-strategy-example.yaml e copiarlo nel manifesto seguente.

apiVersion: v1
kind: Pod
metadata:
  name: nvidia-single
spec:
  containers:
  - name: nvidia-single
    image: nvidia/cuda:12.1.1-base-ubuntu22.04
    command: ["/bin/sh"]
    args: ["-c","sleep 1000"]
    resources:
      limits:
        "nvidia.com/gpu": 1

Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del manifesto YAML.
```
kubectl apply -f single-strategy-example.yaml
```

Verificare i dispositivi GPU allocati usando il comando kubectl exec. Questo comando restituisce un elenco dei nodi del cluster.

kubectl exec nvidia-single -- nvidia-smi -L

L'esempio seguente è simile all'output che mostra distribuzioni e servizi creati correttamente:

GPU 0: NVIDIA A100 40GB PCIe (UUID: GPU-48aeb943-9458-4282-da24-e5f49e0db44b)
MIG 1g.5gb     Device  0: (UUID: MIG-fb42055e-9e53-5764-9278-438605a3014c)
MIG 1g.5gb     Device  1: (UUID: MIG-3d4db13e-c42d-5555-98f4-8b50389791bc)
MIG 1g.5gb     Device  2: (UUID: MIG-de819d17-9382-56a2-b9ca-aec36c88014f)
MIG 1g.5gb     Device  3: (UUID: MIG-50ab4b32-92db-5567-bf6d-fac646fe29f2)
MIG 1g.5gb     Device  4: (UUID: MIG-7b6b1b6e-5101-58a4-b5f5-21563789e62e)
MIG 1g.5gb     Device  5: (UUID: MIG-14549027-dd49-5cc0-bca4-55e67011bd85)
MIG 1g.5gb     Device  6: (UUID: MIG-37e055e8-8890-567f-a646-ebf9fde3ce7a)

Strategia mista

Creare un file denominato mixed-strategy-example.yaml e copiarlo nel manifesto seguente.

apiVersion: v1
kind: Pod
metadata:
  name: nvidia-mixed
spec:
  containers:
  - name: nvidia-mixed
    image: nvidia/cuda:12.1.1-base-ubuntu22.04
    command: ["/bin/sh"]
    args: ["-c","sleep 100"]
    resources:
      limits:
        "nvidia.com/mig-1g.5gb": 1

Distribuire l'applicazione usando il comando kubectl apply e specificare il nome del manifesto YAML.
```
kubectl apply -f mixed-strategy-example.yaml
```
Verificare i dispositivi GPU allocati usando il comando kubectl exec. Questo comando restituisce un elenco dei nodi del cluster.
```
kubectl exec nvidia-mixed -- nvidia-smi -L
```
L'esempio seguente è simile all'output che mostra distribuzioni e servizi creati correttamente:
```
GPU 0: NVIDIA A100 40GB PCIe (UUID: GPU-48aeb943-9458-4282-da24-e5f49e0db44b)
MIG 1g.5gb     Device  0: (UUID: MIG-fb42055e-9e53-5764-9278-438605a3014c)
```

Importante

Il tag latest per le immagini CUDA è stato deprecato nell'hub Docker. Fare riferimento al repository NVIDIA per le immagini più recenti e i tag corrispondenti.

Risoluzione dei problemi

Se non viene visualizzata la funzionalità GPU a più istanze dopo la creazione del pool di nodi, verificare che la versione dell'API non sia precedente alla versione 2021-08-01.

Passaggi successivi

Per altre informazioni sulle GPU in servizio Azure Kubernetes, vedere:

Condividi tramite