NVIDIA GPUS in VMs mit VM-Laufzeit auf GDC aktivieren und verwenden

In diesem Dokument erfahren Sie, wie Sie die Unterstützung von NVIDIA® GPU für virtuelle Maschinen (VMs) aktivieren, die mit VM-Laufzeit auf GDC ausgeführt werden. Sie erfahren, wie Sie die NVIDIA-Treiber auf Ihren Google Distributed Cloud-Knoten installieren, prüfen, ob die GPUs verfügbar sind, und VMs GPUs zuweisen.

Hinweise

Um dieses Dokument abzuschließen, benötigen Sie Zugriff auf die folgenden Ressourcen:

Unterstützte Nvidia-GPU-Karten

Google Distributed Cloud Version 1.13 oder höher unterstützt die folgenden NVIDIA-GPUs:

  • T4
  • Tesla P4
  • Tesla V100 SXM2 32 GB
  • A100 SXM4 40 GB
  • A100 PCIe 40 GB
  • A100 SXM4 80 GB
  • A100 PCIe-80 GB

NVIDIA-Treiber auf Knoten installieren

Bevor Ihre VMs die NVIDIA-GPUs verwenden können, müssen Sie Ihre Google Distributed Cloud-Knoten für die Unterstützung der GPU-Geräte konfigurieren. Führen Sie die folgenden Schritte auf jedem Knoten in Ihrem Cluster aus, der eine NVIDIA-GPU enthält, um die NVIDIA-Treiber auf den Knoten zu installieren. In diesem Dokument wird eine unterstützte Ubuntu-Version für die Knoten verwendet:

  1. Stellen Sie eine Verbindung zu Ihrem Google Distributed Cloud-Knoten her, den Sie für die GPU-Unterstützung konfigurieren möchten.
  2. Rufen Sie die Kernel-Version Ihres Knotens ab:

    KERNEL_VERSION="$(uname -r)"
    
  3. Aktualisieren Sie den Ubuntu-Knoten und installieren Sie die entsprechenden Kernel-Header:

    sudo apt update && \
    apt install -y linux-headers-${KERNEL_VERSION}
    
  4. Installieren Sie das Paket build-essential, damit Sie die Nvidia-Treiber in einem folgenden Schritt kompilieren können:

    sudo apt install -y build-essential
    
  5. Laden Sie das entsprechende NVIDIA-Treiberpaket für Ihre GPU herunter. Eine vollständige Liste der Treiber finden Sie unter NVIDIA-Treiber-Downloads.

    Im folgenden Beispiel wird der Treiber 470.82.01 in der Version Linux x86_64 heruntergeladen:

    wget https://us.download.nvidia.com/tesla/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
    
  6. Installieren Sie das NVIDIA-Treiberpaket. Verwenden Sie den Namen des NVIDIA-Treiberpakets, das Sie im vorherigen Schritt heruntergeladen haben:

    sudo sh NVIDIA-Linux-x86_64-470.82.01.run \
      --accept-license \
      --silent \
      --no-nouveau-check
    
  7. Laden Sie das NVIDIA-Kernelmodul:

    sudo modprobe nvidia
    
  8. Wiederholen Sie die Schritte in diesem Abschnitt auf jedem Knoten in einem Cluster mit einer NVIDIA-GPU.

GPU-Unterstützung in VM-Laufzeit auf GDC aktivieren

Nachdem Sie die NVIDIA-Treiber auf Ihren Google Distributed Cloud-Knoten installiert haben, aktivieren Sie die GPU-Unterstützung in der VM-Laufzeit auf GDC. Ihre VMs können dann auf die GPUs auf den Knoten zugreifen.

Jeder Knoten wird im Rahmen des folgenden Prozesses neu gestartet. Ihre VMs sind möglicherweise von diesem Neustart betroffen. Wenn möglich und für diesen Zweck konfiguriert, werden migrierbare VMs zu anderen Knoten migriert. Weitere Informationen finden Sie unter Bereinigungsrichtlinie für VMs während Wartungsereignissen konfigurieren.

Führen Sie die folgenden Schritte aus, um die GPU-Unterstützung in der VM-Laufzeit auf GDC zu aktivieren.

  1. Bearbeiten Sie die benutzerdefinierte VMRuntime-Ressource:

    kubectl edit vmruntime vmruntime
    
  2. Fügen Sie dem VMRuntime-Manifest das Attribut enableGPU: true hinzu:

    apiVersion: vm.cluster.gke.io/v1
    kind: VMRuntime
    metadata:
      name: vmruntime
    spec:
      enabled: true
      enableGPU: true
    ...
    
  3. Speichern und schließen Sie die benutzerdefinierte VMRuntime-Ressource in Ihrem Editor.

  4. Prüfen Sie den Status der GPU-Controller im vm-system-Namespace:

    kubectl get pods --namespace vm-system  -w
    

    Es dauert ungefähr fünf Minuten, bis die Controller aktiviert sind. Warten Sie, bis STATUS für alle GPU-Controller Running anzeigt. Die folgende Beispielausgabe zeigt den gewünschten Zustand:

    NAME                                          READY  STATUS    RESTARTS     AGE
    gpu-controller-controller-manager-gwvcb       2/2    Running   0            10m
    kubevirt-gpu-dp-daemonset-2lfkl               1/1    Running   0            10m
    kubevm-gpu-driver-daemonset-5fwh6             1/1    Running   0            10m
    nvidia-gpu-dp-daemonset-9zq2w                 1/1    Running   0            10m
    nvidia-mig-manager-5g7pz                      1/1    Running   0            10m
    vm-controller-controller-manager-7b6df6979b   2/2    Running   2 (13m ago)  14m
    
  5. Prüfen Sie, ob die GPUs zum Verwenden verfügbar sind, wenn die GPU-Controller alle ihren Status als Running melden:

    kubectl get gpuallocations --namespace vm-system
    

    Die folgende Beispielausgabe zeigt, dass die GPUs auf den Knoten verwendet werden können. Jeder Knoten in Ihrem Cluster mit GPU-Unterstützung wird angezeigt. Sie weisen sie im nächsten Abschnitt VMs zu:

    NAME       ALLOCATED   DEVICEMODEL
    bm-node1   true        Tesla A100 SXM4 40GB
    bm-node2   true        Tesla A100 SXM4 40GB
    

GPUs zur Verwendung mit VMs zuweisen

Wenn die GPU-Unterstützung in den Anthos Clusters on Bare Metal-Knoten und in der VM-Laufzeit auf GDC konfiguriert ist, weisen Sie die GPUs zur Verwendung mit VMs zu. GPUs werden standardmäßig für die Verwendung mit Pods (Containern) zugewiesen.

  1. Bearbeiten Sie die benutzerdefinierte GPUAllocation-Ressource zur Verwendung mit VMs. In diesem Schritt werden die GPUs auf den Knoten für die Verwendung mit VMs zugewiesen:

    kubectl edit gpuallocation NODE_NAME --namespace vm-system
    

    Ersetzen Sie NODE_NAME durch den Namen des Knotens, von dem Sie GPUs zuweisen möchten.

  2. Konfigurieren Sie die Anzahl der GPUs, die VMs zugewiesen werden sollen. Anfänglich werden alle GPUs Pods zugewiesen.

    Die Gesamtzahl der GPUs, die VMs und Pods zugewiesen werden, muss der Anzahl der GPUs im Knoten entsprechen. Beispielsweise kann Ihr Knoten vier GPUs haben. Wenn Sie VMs zwei GPUs zuweisen, bleiben zwei GPUs den Pods zugewiesen. Das GPUAllocation-Manifest wird zurückgewiesen, wenn Sie versuchen, zwei GPUs zu VMs und eine GPU zu Pods zuzuweisen, da eine GPU nicht zugewiesen wird.

    Aktualisieren Sie die Anzahl der GPUs auf dem Knoten, die Sie für die Verwendung mit VMs zuweisen möchten, wie im folgenden Beispiel gezeigt:

    apiVersion: gpu.cluster.gke.io/v1
    kind: GPUAllocation
    metadata:
      name: gpu-w2
      namespace: vm-system
    spec:
      node: gpu-w2
      pod: 0
      vm: 4
    

    In diesem Beispiel werden alle vier auf dem Knoten installierten GPUs VMs zugewiesen. Es werden keine GPUs zu Pods zugewiesen.

  3. Speichern und schließen Sie die benutzerdefinierte GPUAllocation-Ressource in Ihrem Editor.

  4. Prüfen Sie, ob die GPUs ihren Status ALLOCATED als true melden:

    kubectl get gpuallocations --namespace vm-system
    

    Die folgende Beispielausgabe zeigt, dass die GPUs auf den Knoten verwendet werden können:

    NAME     ALLOCATED   DEVICEMODEL
    gpu-w1   true        Tesla A100 SXM4 40GB
    gpu-w2   true        Tesla A100 SXM4 40GB
    

VM mit GPU-Unterstützung erstellen

Sie können jetzt eine VM erstellen, die die GPU vom Knoten verwendet. In der benutzerdefinierten VM-Ressource geben Sie den Namen und die Anzahl der GPUs an, die vom Knoten zugewiesen werden sollen.

  1. Rufen Sie den Namen der GPU-Karte vom Host ab:

    kubectl describe node NODE_NAME
    

    Ersetzen Sie NODE_NAME durch den Namen des Hosts, von dem Sie den GPU-Namen abrufen möchten.

    Die folgende Beispielausgabe zeigt, dass der zuweisbare GPU-Name auf diesem Knoten NVIDIA_A100_SXM4_40GB lautet:

    Name:               bm-node1
    Roles:              worker
    [...]
    Allocatable:
      cpu:                                         47810m
      [...]
      memory:                                      336929400Ki
      nvidia.com/gpu-vm-NVIDIA_A100_SXM4_40GB:     1
    [...]
    
  2. Erstellen Sie in einem Editor Ihrer Wahl ein VirtualMachine-Manifest wie my-gpu-vm.yaml.

    nano my-gpu-vm.yaml
    
  3. Kopieren Sie das folgende YAML-Manifest und fügen Sie es ein:

    apiVersion: vm.cluster.gke.io/v1
    kind: VirtualMachine
    metadata:
      name: VM_NAME
    spec:
      interfaces:
        - name: eth0
          networkName: pod-network
          default: true
      disks:
        - virtualMachineDiskName: VM_NAME-boot-dv
          boot: true
          gpu:
            model: nvidia.com/gpu-vm-GPU_NAME
            quantity: 1
    

    Legen Sie in dieser YAML-Datei die folgenden Einstellungen fest:

    • VM_NAME: der Name Ihrer VM.
    • GPU_NAME: der GPU-Name vom Knoten, der der VM zugewiesen werden soll.
      • Dieser GPU-Name wird in der Ausgabe des Befehls kubectl describe node aus einem vorherigen Schritt angezeigt, z. B. NVIDIA_A100_SXM4_40GB.

    Die VM verbindet eth0 mit dem Standardnetzwerk pod-network.

    Das Bootlaufwerk mit dem Namen VM_NAME-boot-dv muss bereits vorhanden sein. Weitere Informationen finden Sie unter Virtuelle Laufwerke erstellen und verwalten.

  4. Speichern und schließen Sie das VM-Manifest in Ihrem Editor.

  5. Erstellen Sie die VM mit kubectl:

    kubectl apply -f my-gpu-vm.yaml
    
  6. Wenn die VM ausgeführt wird, stellen Sie eine Verbindung zur VM her und prüfen Sie, ob die GPU-Hardware verfügbar ist.

Nächste Schritte