הפעלה ושימוש ביחידות GPU של NVIDIA במכונות וירטואליות עם VM Runtime ב-GDC

במאמר הזה מוסבר איך להפעיל תמיכה ב-GPU של NVIDIA®‎ במכונות וירטואליות (VM) שפועלות באמצעות VM Runtime ב-GDC. במאמר הזה מוסבר איך להתקין את הדרייברים של NVIDIA בצמתים של Google Distributed Cloud, איך לוודא שה-GPU זמין ואיך להקצות GPU למכונות וירטואליות.

לפני שמתחילים

כדי להשלים את המסמך הזה, תצטרכו גישה למקורות המידע הבאים:

גישה ל-Google Distributed Cloud מגרסה 1.12.0‏ (anthosBareMetalVersion: 1.12.0) ואילך של אשכול. אפשר להשתמש בכל סוג של אשכול שיכול להריץ עומסי עבודה. אם צריך, אפשר לנסות את Google Distributed Cloud ב-Compute Engine או לעיין בסקירה הכללית על יצירת אשכולות.
כלי הלקוח virtctl מותקן כפלאגין של kubectl. במקרה הצורך, מתקינים את כלי הלקוח virtctl.

כרטיסי Nvidia GPU נתמכים

ב-Google Distributed Cloud מגרסה 1.13 ואילך יש תמיכה במעבדי ה-GPU הבאים של NVIDIA:

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

התקנת דרייברים של NVIDIA בצמתים

כדי שהמכונות הווירטואליות יוכלו להשתמש ב-GPU של NVIDIA, צריך להגדיר את הצמתים של Google Distributed Cloud כך שיתמכו במכשירי ה-GPU. כדי להתקין את הדרייברים של NVIDIA בצמתים, צריך לבצע את השלבים הבאים בכל צומת באשכול שכולל GPU של NVIDIA. במסמך הזה אנחנו משתמשים בגרסת Ubuntu נתמכת לצמתים:

מתחברים לצומת Google Distributed Cloud שרוצים להגדיר בו תמיכה ב-GPU.
כדי לקבל את גרסת הליבה של הצומת:
```
KERNEL_VERSION="$(uname -r)"
```
מעדכנים את צומת Ubuntu ומתקינים את כותרות הליבה המתאימות:
```
sudo apt update && \
apt install -y linux-headers-${KERNEL_VERSION}
```
מתקינים את חבילת build-essential כדי שיהיה אפשר לקמפל את מנהלי ההתקנים של Nvidia בשלב הבא:
```
sudo apt install -y build-essential
```
מורידים את חבילת הדרייברים המתאימה של NVIDIA ל-GPU. רשימה מלאה של הדרייברים זמינה בהורדות של דרייברים של NVIDIA.

בדוגמה הבאה מורידים את הדרייבר של גרסה Linux x86_64‏ 470.82.01:
```
wget https://us.download.nvidia.com/tesla/470.82.01/NVIDIA-Linux-x86_64-470.82.01.run
```
מתקינים את חבילת מנהלי ההתקנים של NVIDIA. משתמשים בשם של חבילת מנהלי ההתקנים (דרייברים) של NVIDIA שהורדתם בשלב הקודם:
```
sudo sh NVIDIA-Linux-x86_64-470.82.01.run \
  --accept-license \
  --silent \
  --no-nouveau-check
```
טוענים את מודול הליבה של NVIDIA:
```
sudo modprobe nvidia
```
חוזרים על השלבים שבקטע הזה בכל צומת באשכול שיש בו GPU של NVIDIA.

הפעלת תמיכה ב-GPU ב-VM Runtime ב-GDC

אחרי שמתקינים את מנהלי ההתקנים(דרייברים) של NVIDIA בצמתים של Google Distributed Cloud, מפעילים את התמיכה ב-GPU ב-VM Runtime ב-GDC. לאחר מכן, המכונות הווירטואליות יכולות לגשת למעבדי ה-GPU בצמתים.

כל צומת מופעל מחדש כחלק מהתהליך הבא. יכול להיות שהמכונות הווירטואליות שלכם יושפעו מתהליך ההפעלה מחדש הזה. אם אפשר וההגדרה מאפשרת זאת, מכונות וירטואליות שניתנות להעברה מועברות לצמתים אחרים. מידע נוסף זמין במאמר בנושא הגדרת מדיניות ההוצאה של מכונות וירטואליות במהלך אירועי תחזוקה.

כדי להפעיל תמיכה ב-GPU ב-VM Runtime ב-GDC, צריך לבצע את השלבים הבאים.

עורכים את VMRuntime המשאב המותאם אישית:
```
kubectl edit vmruntime vmruntime
```

מוסיפים את המאפיין enableGPU: true למניפסט VMRuntime:

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

שומרים וסוגרים את המשאב המותאם אישית VMRuntime בכלי העריכה.

בודקים את הסטטוס של בקרי ה-GPU במרחב השמות vm-system:

kubectl get pods --namespace vm-system  -w

הפעלת הבקרים נמשכת כחמש דקות. מחכים עד שהסמל STATUS יופיע Running בכל בקרי ה-GPU. בדוגמה הבאה של פלט אפשר לראות את המצב הרצוי:

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

מוודאים שמעבדי ה-GPU זמינים לשימוש כשכל בקרי ה-GPU מדווחים על הסטטוס Running:
```
kubectl get gpuallocations --namespace vm-system
```
בדוגמה הבאה של הפלט אפשר לראות שהמעבדים הגרפיים בצמתים זמינים לשימוש. כל צומת באשכול עם תמיכה ב-GPU מוצג. מקצים אותם ל-VM בקטע הבא:
```
NAME       ALLOCATED   DEVICEMODEL
bm-node1   true        Tesla A100 SXM4 40GB
bm-node2   true        Tesla A100 SXM4 40GB
```

הקצאת יחידות GPU לשימוש במכונות וירטואליות

אחרי שמגדירים תמיכה ב-GPU בצמתים של אשכול Bare Metal וב-VM Runtime ב-GDC, מקצים את יחידות ה-GPU לשימוש במכונות וירטואליות. כברירת מחדל, יחידות GPU מוקצות לשימוש עם פודים (קונטיינרים).

עורכים את GPUAllocation המשאב המותאם אישית לשימוש עם מכונות וירטואליות. בשלב הזה מקצים את יחידות ה-GPU בצמתים לשימוש במכונות וירטואליות:
```
kubectl edit gpuallocation NODE_NAME --namespace vm-system
```
מחליפים את NODE_NAME בשם הצומת שרוצים להקצות ממנו GPU.
הגדרת מספר יחידות ה-GPU להקצאה למכונות וירטואליות. בהתחלה, כל יחידות ה-GPU מוקצות לפודים.

המספר הכולל של יחידות ה-GPU שהוקצו למכונות וירטואליות ול-pods צריך להיות שווה למספר יחידות ה-GPU בצומת. לדוגמה, יכול להיות שיש ארבע יחידות GPU בצומת. אם מקצים שתי יחידות GPU למכונות וירטואליות, שתי יחידות GPU יישארו מוקצות לפודים. ה-manifest‏ GPUAllocation נדחה אם מנסים להקצות שני GPUs למכונות וירטואליות ו-GPU אחד ל-pods, כי נשאר GPU אחד שלא הוקצה.

מעדכנים את מספר יחידות ה-GPU בצומת שרוצים להקצות לשימוש במכונות וירטואליות, כמו בדוגמה הבאה:
```
apiVersion: gpu.cluster.gke.io/v1
kind: GPUAllocation
metadata:
  name: gpu-w2
  namespace: vm-system
spec:
  node: gpu-w2
  pod: 0
  vm: 4
```
בדוגמה הזו, כל ארבע יחידות ה-GPU שמותקנות בצומת מוקצות למכונות וירטואליות. לא מוקצים מעבדי GPU ל-Pods.
שומרים וסוגרים את המשאב המותאם אישית GPUAllocation בכלי העריכה.

מוודאים שהסטטוס של כרטיסי ה-GPU הוא ALLOCATED:true

kubectl get gpuallocations --namespace vm-system

בדוגמה הבאה של הפלט אפשר לראות שהמעבדים הגרפיים בצמתים זמינים לשימוש:

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

יצירת מכונה וירטואלית עם תמיכה ב-GPU

עכשיו אפשר ליצור מכונה וירטואלית שמשתמשת ב-GPU מהצומת. במשאב המותאם אישית של מכונה וירטואלית, מציינים את השם ואת הכמות של יחידות ה-GPU להקצאה מהצומת.

מקבלים את השם של כרטיס ה-GPU מהמארח:

kubectl describe node NODE_NAME

מחליפים את NODE_NAME בשם המארח שממנו רוצים לקבל את שם ה-GPU.

בדוגמה הבאה של פלט אפשר לראות ששם ה-GPU שניתן להקצאה בצומת הזה הוא NVIDIA_A100_SXM4_40GB:

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

יוצרים מניפסט VirtualMachine, כמו my-gpu-vm.yaml, בכלי העריכה שבוחרים:
```
nano my-gpu-vm.yaml
```
מעתיקים ומדביקים את קובץ המניפסט הבא בפורמט YAML:
```
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
```
בקובץ ה-YAML הזה, מגדירים את ההגדרות הבאות:
- ‫VM_NAME: השם של ה-VM.
- ‫GPU_NAME: שם ה-GPU מהצומת להקצאה למכונה הווירטואלית.
  - שם ה-GPU הזה מוצג בפלט של הפקודה kubectl describe node מהשלב הקודם, כמו NVIDIA_A100_SXM4_40GB.
המכונה הווירטואלית מתחברת לרשת eth0 שמוגדרת כברירת מחדל pod-network.

דיסק האתחול בשם VM_NAME-boot-dv חייב להיות קיים. מידע נוסף זמין במאמר בנושא יצירה וניהול של דיסקים וירטואליים.
שומרים את מניפסט המכונה הווירטואלית וסוגרים את העורך.
יוצרים את המכונה הווירטואלית באמצעות kubectl:
```
kubectl apply -f my-gpu-vm.yaml
```
כשהמכונה הווירטואלית פועלת, מתחברים אליה ומוודאים שחומרת ה-GPU זמינה.

המאמרים הבאים

עריכת מכונה וירטואלית ב-Google Distributed Cloud

הפעלה ושימוש ביחידות GPU של NVIDIA במכונות וירטואליות עם VM Runtime ב-GDC קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.