Anthos Clusters on Bare Metal sind jetzt Google Distributed Cloud (nur Software) für Bare Metal. Weitere Informationen finden Sie in der Produktübersicht.

Diese Seite wurde von der Cloud Translation API übersetzt.

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:

Zugriff auf Google Distributed Cloud-Cluster Version 1.12.0 (anthosBareMetalVersion: 1.12.0) oder höher. Sie können einen beliebigen Clustertyp verwenden, der Arbeitslasten ausführen kann. Probieren Sie bei Bedarf Google Distributed Cloud in Compute Engine aus oder lesen Sie die Übersicht zum Erstellen von Clustern.
Das virtctl-Clienttool, das als Plug-in für kubectl installiert wurde. Installieren Sie bei Bedarf das virtctl-Clienttool.

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:

Stellen Sie eine Verbindung zu Ihrem Google Distributed Cloud-Knoten her, den Sie für die GPU-Unterstützung konfigurieren möchten.
Rufen Sie die Kernel-Version Ihres Knotens ab:
```
KERNEL_VERSION="$(uname -r)"
```
Aktualisieren Sie den Ubuntu-Knoten und installieren Sie die entsprechenden Kernel-Header:
```
sudo apt update && \
apt install -y linux-headers-${KERNEL_VERSION}
```
Installieren Sie das Paket build-essential, damit Sie die Nvidia-Treiber in einem folgenden Schritt kompilieren können:
```
sudo apt install -y build-essential
```
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
```
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
```
Laden Sie das NVIDIA-Kernelmodul:
```
sudo modprobe nvidia
```
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.

Bearbeiten Sie die benutzerdefinierte VMRuntime-Ressource:
```
kubectl edit vmruntime vmruntime
```

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

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

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

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.

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.
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.
Speichern und schließen Sie die benutzerdefinierte GPUAllocation-Ressource in Ihrem Editor.

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.

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

Erstellen Sie in einem Editor Ihrer Wahl ein VirtualMachine-Manifest wie my-gpu-vm.yaml.
```
nano my-gpu-vm.yaml
```
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.
Speichern und schließen Sie das VM-Manifest in Ihrem Editor.
Erstellen Sie die VM mit kubectl:
```
kubectl apply -f my-gpu-vm.yaml
```
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

VM in Google Distributed Cloud bearbeiten