Halaman ini diterjemahkan oleh Cloud Translation API.

Mengaktifkan dan menggunakan GPU NVIDIA di VM dengan Runtime VM di GDC

Dokumen ini menunjukkan cara mengaktifkan dukungan GPU NVIDIA® untuk virtual machine (VM) yang berjalan menggunakan VM Runtime di GDC. Anda akan mempelajari cara menginstal driver NVIDIA di node Google Distributed Cloud, memverifikasi ketersediaan GPU, dan menetapkan GPU ke VM.

Sebelum memulai

Untuk menyelesaikan dokumen ini, Anda memerlukan akses ke resource berikut:

Akses ke cluster Google Distributed Cloud versi 1.12.0 (anthosBareMetalVersion: 1.12.0) atau yang lebih tinggi. Anda dapat menggunakan jenis cluster apa pun yang dapat menjalankan workload. Jika perlu, coba Google Distributed Cloud di Compute Engine atau lihat ringkasan pembuatan cluster.
Alat klien virtctl diinstal sebagai plugin untuk kubectl. Jika perlu, instal alat klien virtctl.

Kartu GPU Nvidia yang didukung

Google Distributed Cloud versi 1.13 atau yang lebih tinggi mendukung GPU NVIDIA berikut:

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

Menginstal driver NVIDIA di node

Sebelum VM dapat menggunakan GPU NVIDIA, Anda harus mengonfigurasi node Google Distributed Cloud untuk mendukung perangkat GPU. Untuk menginstal driver NVIDIA di node, selesaikan langkah-langkah berikut di setiap node dalam cluster yang mencakup GPU NVIDIA. Dokumen ini menggunakan versi Ubuntu yang didukung untuk node:

Hubungkan ke node Google Distributed Cloud yang ingin Anda konfigurasi untuk dukungan GPU.
Dapatkan versi kernel node Anda:
```
KERNEL_VERSION="$(uname -r)"
```

Update node Ubuntu Anda dan instal header kernel yang sesuai:

sudo apt update && \
apt install -y linux-headers-${KERNEL_VERSION}

Instal paket build-essential agar Anda dapat mengompilasi driver Nvidia pada langkah berikutnya:
```
sudo apt install -y build-essential
```
Download paket driver NVIDIA yang sesuai untuk GPU Anda. Untuk mengetahui daftar lengkap driver, lihat Download Driver NVIDIA.

Contoh berikut mendownload driver Linux x86_64 versi 470.82.01:
```
wget https://us.download.nvidia.com/tesla/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
```

Instal paket driver NVIDIA. Gunakan nama paket driver NVIDIA yang Anda download pada langkah sebelumnya:

sudo sh NVIDIA-Linux-x86_64-470.82.01.run \
  --accept-license \
  --silent \
  --no-nouveau-check

Muat modul kernel NVIDIA:
```
sudo modprobe nvidia
```
Ulangi langkah-langkah di bagian ini pada setiap node di cluster Anda yang memiliki GPU NVIDIA.

Mengaktifkan dukungan GPU di Runtime VM di GDC

Setelah menginstal driver NVIDIA di node Google Distributed Cloud, Anda mengaktifkan dukungan GPU di VM Runtime di GDC. VM Anda kemudian dapat mengakses GPU di node.

Setiap node akan di-reboot sebagai bagian dari proses berikut. VM Anda mungkin terpengaruh oleh proses mulai ulang ini. Jika memungkinkan dan dikonfigurasi untuk melakukannya, VM yang dapat dimigrasikan akan dimigrasikan ke node lain. Untuk mengetahui informasi selengkapnya, lihat cara mengonfigurasi kebijakan pengusiran untuk VM selama peristiwa pemeliharaan.

Untuk mengaktifkan dukungan GPU di VM Runtime di GDC, selesaikan langkah-langkah berikut.

Edit resource kustom VMRuntime:
```
kubectl edit vmruntime vmruntime
```

Tambahkan properti enableGPU: true ke manifes VMRuntime:

apiVersion: vm.cluster.gke.io/v1
kind: VMRuntime
metadata:
  name: vmruntime
spec:
  enabled: true
  enableGPU: true
...

Simpan dan tutup resource kustom VMRuntime di editor Anda.

Periksa status pengontrol GPU di namespace vm-system:

kubectl get pods --namespace vm-system  -w

Pengontrol akan berhasil diaktifkan dalam waktu sekitar lima menit. Tunggu hingga STATUS menampilkan Running untuk semua pengontrol GPU. Contoh output berikut menunjukkan status yang diinginkan:

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

Verifikasi bahwa GPU tersedia untuk digunakan saat semua pengontrol GPU melaporkan statusnya sebagai Running:
```
kubectl get gpuallocations --namespace vm-system
```
Contoh output berikut menunjukkan bahwa GPU di node tersedia untuk digunakan. Setiap node dalam cluster Anda dengan dukungan GPU ditampilkan. Anda akan mengalokasikannya ke VM di bagian berikutnya:
```
NAME       ALLOCATED   DEVICEMODEL
bm-node1   true        Tesla A100 SXM4 40GB
bm-node2   true        Tesla A100 SXM4 40GB
```

Mengalokasikan GPU untuk digunakan dengan VM

Dengan dukungan GPU yang dikonfigurasi di node cluster bare metal dan di VM Runtime di GDC, alokasikan GPU untuk digunakan dengan VM. Secara default, GPU dialokasikan untuk digunakan dengan pod (container).

Edit resource kustom GPUAllocation untuk digunakan dengan VM. Langkah ini menetapkan GPU pada node untuk digunakan dengan VM:
```
kubectl edit gpuallocation NODE_NAME --namespace vm-system
```
Ganti NODE_NAME dengan nama node yang ingin Anda alokasikan GPU-nya.
Konfigurasi jumlah GPU yang akan dialokasikan ke VM. Awalnya, semua GPU dialokasikan ke pod.

Jumlah total GPU yang dialokasikan ke VM dan pod harus sama dengan jumlah GPU di node. Misalnya, Anda mungkin memiliki empat GPU di node. Jika Anda mengalokasikan dua GPU ke VM, maka dua GPU tetap dialokasikan ke pod. Manifes GPUAllocation ditolak jika Anda mencoba mengalokasikan dua GPU ke VM dan satu GPU ke pod, karena satu GPU tidak dialokasikan.

Perbarui jumlah GPU pada node yang ingin Anda alokasikan untuk digunakan dengan VM, seperti yang ditunjukkan dalam contoh berikut:
```
apiVersion: gpu.cluster.gke.io/v1
kind: GPUAllocation
metadata:
  name: gpu-w2
  namespace: vm-system
spec:
  node: gpu-w2
  pod: 0
  vm: 4
```
Dalam contoh ini, keempat GPU yang diinstal di node dialokasikan ke VM. Tidak ada GPU yang dialokasikan ke pod.
Simpan dan tutup resource kustom GPUAllocation di editor Anda.

Verifikasi bahwa GPU melaporkan status ALLOCATED sebagai true:

kubectl get gpuallocations --namespace vm-system

Contoh output berikut menunjukkan bahwa GPU di node tersedia untuk digunakan:

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

Membuat VM dengan dukungan GPU

Sekarang Anda dapat membuat VM yang menggunakan GPU dari node. Di resource kustom VM, Anda menentukan nama dan jumlah GPU yang akan dialokasikan dari node.

Dapatkan nama kartu GPU dari host:

kubectl describe node NODE_NAME

Ganti NODE_NAME dengan nama host yang ingin Anda dapatkan nama GPU-nya.

Contoh output berikut menunjukkan bahwa nama GPU yang dapat dialokasikan di node ini adalah NVIDIA_A100_SXM4_40GB:

Name:               bm-node1
Roles:              worker
[...]
Allocatable:
  cpu:                                         47810m
  [...]
  memory:                                      336929400Ki
  nvidia.com/gpu-vm-NVIDIA_A100_SXM4_40GB:     1
[...]

Buat manifes VirtualMachine, seperti my-gpu-vm.yaml, di editor pilihan Anda:
```
nano my-gpu-vm.yaml
```
Salin dan tempel manifes YAML berikut:
```
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
```
Dalam file YAML ini, tentukan setelan berikut:
- VM_NAME: nama untuk VM Anda.
- GPU_NAME: nama GPU dari node yang akan dialokasikan ke VM.
  - Nama GPU ini ditampilkan dalam output perintah kubectl describe node dari langkah sebelumnya, seperti NVIDIA_A100_SXM4_40GB.
VM terhubung eth0 ke jaringan pod-network default.

Boot disk bernama VM_NAME-boot-dv harus sudah ada. Untuk mengetahui informasi selengkapnya, lihat Membuat dan mengelola disk virtual.
Simpan dan tutup manifes VM di editor Anda.
Buat VM menggunakan kubectl:
```
kubectl apply -f my-gpu-vm.yaml
```
Saat VM Anda berjalan, hubungkan ke VM dan verifikasi bahwa hardware GPU tersedia.

Langkah berikutnya

Mengedit VM di Google Distributed Cloud.