Erstellen eines GPU-Knotenpools mit mehreren Instanzen in Azure Kubernetes Service (AKS)

Artikel
12/03/2024

Die A100-GPU von NVIDIA kann in bis zu sieben unabhängige Instanzen unterteilt werden. Jede Instanz verfügt über einen eigenen Stream Multiprocessor (SM), der für die parallele Ausführung von Anweisungen und für den GPU-Speicher verantwortlich ist. Weitere Informationen zu NVIDIA A100 finden Sie unter NVIDIA A100-GPU.

Dieser Artikel führt Sie durch das Erstellen eines GPU-Knotenpools mit mehreren Instanzen mithilfe einer MIG-kompatiblen VM-Größe in einem Azure Kubernetes Service (AKS)-Cluster.

Voraussetzungen und Einschränkungen

Ein Azure-Konto mit einem aktiven Abonnement. Falls Sie über keins verfügen, können Sie ein kostenloses Konto erstellen.
Installation und Konfiguration der Azure CLI, Version 2.2.0 oder höher. Führen Sie az --version aus, um die Version zu ermitteln. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI.
Installation und Konfiguration des Kubernetes-Befehlszeilenclients kubectl. Bei Verwendung von Azure Cloud Shell ist kubectl bereits installiert. Wenn Sie eine lokale Installation bevorzugen, können Sie den Befehl az aks install-cli verwenden.
Installation und Konfiguration von Helm 3. Weitere Informationen finden Sie unter Installing Helm (Installieren von Helm).
GPU-Knotenpools mit mehreren Instanzen werden derzeit unter Azure Linux nicht unterstützt.
Sie können die Clusterautoskalierung nicht mit GPU-Knotenpools mehrere Instanzen verwenden.

GPU-Instanzprofile

GPU-Instanzprofile definieren, wie GPUs partitioniert werden. Die folgende Tabelle zeigt das verfügbare GPU-Instanzprofil für Standard_ND96asr_v4:

Profilname	Anteil von SM	Anteil des Arbeitsspeichers	Anzahl erstellter Instanzen
MIG 1g.5gb	1/7	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

Beispielsweise gibt das GPU-Instanzprofil von MIG 1g.5gb an, dass jede GPU-Instanz 1G SM (Streaming-Multiprozessoren) und 5 GB Arbeitsspeicher aufweist. In diesem Fall wird die GPU in sieben Instanzen partitioniert.

Die verfügbaren GPU-Instanzprofile für diese VM-Größe sind MIG1g, MIG2g, MIG3g, MIG4g und MIG7g.

Wichtig

Das angewendete GPU-Instanzprofil kann nach der Erstellung des Knotenpools nicht mehr geändert werden.

Erstellen eines AKS-Clusters

Erstellen Sie mithilfe des Befehls az group create eine Azure-Ressourcengruppe.
```
az group create --name myResourceGroup --location southcentralus
```

Erstellen Sie mit dem Befehl az aks create einen AKS-Cluster.

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

Konfigurieren Sie kubectl, um mithilfe des Befehls az aks get-credentials eine Verbindung mit Ihrem AKS-Cluster herzustellen.
```
az aks get-credentials --resource-group myResourceGroup --name myAKSCluster
```

Erstellen eines GPU-Knotenpools mit mehreren Instanzen

Sie können entweder die Azure CLI oder eine HTTP-Anforderung an die ARM-API verwenden, um den Knotenpool zu erstellen.

Azure-Befehlszeilenschnittstelle
HTTP-Anforderung

Erstellen Sie einen GPU-Knotenpool mit mehreren Instanzen über den Befehl az aks nodepool add, und geben Sie das GPU-Instanzprofil an. Im folgenden Beispiel wird ein Knotenpool mit der Standard_ND96asr_v4-MIG-kompatiblen GPU-VM-Größe erstellt.
```
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
```

Erstellen Sie einen GPU-Knotenpool mit mehreren Instanzen, indem Sie das GPU-Instanzprofil im Anforderungstext platzieren.

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

Festlegen der Strategie für GPU mit mehreren Instanzen (MIG)

Bevor Sie die NVIDIA-Plug-Ins installieren, müssen Sie angeben, welche MIG-Strategie (GPU mit mehreren Instanzen) für die GPU-Partitionierung verwendet werden soll: Einzelstrategie oder Gemischte Strategie. Die beiden Strategien wirken sich nicht auf die Ausführung von CPU-Workloads aus, sondern darauf, wie GPU-Ressourcen angezeigt werden.

Einzelstrategie: Die Einzelstrategie behandelt jede GPU-Instanz als GPU. Wenn Sie diese Strategie verwenden, werden die GPU-Ressourcen als nvidia.com/gpu: 1 angezeigt.
Gemischte Strategie: Die gemischte Strategie macht die GPU-Instanzen und das GPU-Instanzprofil verfügbar. Wenn Sie diese Strategie verwenden, werden die GPU-Ressourcen als nvidia.com/mig1g.5gb: 1 angezeigt.

Installieren der Komponenten für NVIDIA-Geräte-Plug-In und GPU Feature Discovery (GFD)

Legen Sie Ihre MIG-Strategie als Umgebungsvariable fest. Sie können entweder die Einzelstrategie oder die gemischte Strategie verwenden.
```
# Single strategy
export MIG_STRATEGY=single

# Mixed strategy
export MIG_STRATEGY=mixed
```
Fügen Sie das NVIDIA-Geräte-Plug-In-Helm-Repository mit den Befehlen helm repo add und helm repo update hinzu.
```
helm repo add nvdp https://nvidia.github.io/k8s-device-plugin
helm repo update
```

Installieren Sie das NVIDIA-Geräte-Plug-In mithilfe des Befehls helm install.

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

Hinweis

Die Helm-Installation des NVIDIA Device Plugin Version 0.15.0 und höher konsolidiert das Geräte-Plug-In und die GFD-Repositorys. Eine separate Helm-Installation der GFD-Softwarekomponente wird in diesem Tutorial nicht empfohlen.

Bestätigen der GPU-Funktion für mehrere Instanzen

Überprüfen Sie die Verbindung kubectl mit Ihrem Cluster mithilfe des Befehls kubectl get, um eine Liste der Clusterknoten zurückzugeben.
```
kubectl get nodes -o wide
```
Vergewissern Sie sich mithilfe des Befehls kubectl describe node, dass der Knoten über eine GPU-Funktion mit mehreren Instanzen verfügt. Der folgende Beispielbefehl beschreibt den Knoten namens aks-mignode, der MIG1g als GPU-Instanzprofil verwendet.
```
kubectl describe node aks-mignode
```
Ihre Ausgabe sollte in etwa wie die folgende Beispielausgabe aussehen:
```
# Single strategy output
Allocatable:
    nvidia.com/gpu: 56

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

Planen der Arbeit

Die folgenden Beispiele basieren auf der CUDA-Basisimageversion 12.1.1 für Ubuntu 22.04, gekennzeichnet als 12.1.1-base-ubuntu22.04.

Einzelne Strategie

Erstellen Sie eine Datei namens single-strategy-example.yaml, und fügen Sie das folgende Manifest ein.

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

Stellen Sie die Anwendung über den Befehl „kubectl apply“ bereit, und geben Sie den Namen Ihres YAML-Manifests an.
```
kubectl apply -f single-strategy-example.yaml
```

Überprüfen Sie die zugeordneten GPU-Geräte mithilfe des Befehls kubectl exec. Dieser Befehl gibt eine Liste der Clusterknoten zurück.

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

Das folgende Beispiel ähnelt einer Ausgabe, die erfolgreich erstellte Bereitstellungen und Dienste anzeigt:

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)

Gemischte Strategie

Erstellen Sie eine Datei namens mixed-strategy-example.yaml, und fügen Sie das folgende Manifest ein.

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

Stellen Sie die Anwendung über den Befehl „kubectl apply“ bereit, und geben Sie den Namen Ihres YAML-Manifests an.
```
kubectl apply -f mixed-strategy-example.yaml
```
Überprüfen Sie die zugeordneten GPU-Geräte mithilfe des Befehls kubectl exec. Dieser Befehl gibt eine Liste der Clusterknoten zurück.
```
kubectl exec nvidia-mixed -- nvidia-smi -L
```
Das folgende Beispiel ähnelt einer Ausgabe, die erfolgreich erstellte Bereitstellungen und Dienste anzeigt:
```
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)
```

Wichtig

Das Tag latest für CUDA-Images gilt auf Docker Hub als veraltet. Die neuesten Images und entsprechenden Tags finden Sie im NVIDIA-Repository.

Problembehandlung

Wenn nach dem Erstellen des Knotenpools keine GPU-Funktion mit mehreren Instanzen angezeigt wird, vergewissern Sie sich, dass die API-Version nicht älter als 2021-08-01 ist.

Nächste Schritte

Weitere Informationen zu GPUs im Azure Kubernetes Service finden Sie unter:

Freigeben über