Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

הפעלה ושימוש ביחידות 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 בצמתים זמינים לשימוש. כל צומת באשכול עם תמיכה ב-GPU מוצג. מקצים אותם למכונות וירטואליות בקטע הבא:
```
NAME       ALLOCATED   DEVICEMODEL
bm-node1   true        Tesla A100 SXM4 40GB
bm-node2   true        Tesla A100 SXM4 40GB
```

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

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

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

מספר יחידות ה-GPU הכולל שהוקצו למכונות וירטואליות ולפודים צריך להיות שווה למספר יחידות ה-GPU בצומת. לדוגמה, יכול להיות שיש לכם ארבע יחידות GPU בצומת. אם הקציתם שתי יחידות GPU למכונות וירטואליות, שתי יחידות GPU נשארות מוקצות לפודים. המערכת דוחה את מניפסט GPUAllocation אם מנסים להקצות שתי יחידות GPU למכונות וירטואליות ויחידת GPU אחת לפודים, כי יחידת 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: השם של המכונה הווירטואלית.
- ‫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