התקנת דרייברים של GPU

אחרי שיוצרים מכונה וירטואלית (VM) עם GPU אחד או יותר, המערכת צריכה מנהלי התקנים (דרייברים) של NVIDIA כדי שהאפליקציות יוכלו לגשת למכשיר. מוודאים שלמופעי מכונה וירטואלית (VM) יש מספיק מקום פנוי בכונן. כשיוצרים את מכונת ה-VM החדשה, צריך לבחור לפחות 40 GB לדיסק האתחול.

יש שתי אפשרויות להתקנת מנהלי ההתקנים:

  • אם אתם צריכים מעבדי GPU להאצת חומרה של גרפיקה תלת-ממדית, כמו שולחן עבודה מרוחק או גיימינג, תוכלו לעיין במאמר בנושא התקנת דרייברים למעבדי NVIDIA RTX Virtual Workstations (vWS).

  • עבור עומסי עבודה אחרים, צריך לפעול לפי ההוראות במסמך הזה כדי להתקין את מנהל ההתקנים (דרייבר) של NVIDIA.

גרסאות של דרייבר NVIDIA, ערכת הכלים CUDA וזמן הריצה של CUDA

יכול להיות שתצטרכו רכיבים שונים של מנהלי התקנים וזמן ריצה עם גרסאות שונות בסביבה שלכם. הם כוללים את הרכיבים הבאים:

  • דרייבר NVIDIA
  • ערכת הכלים CUDA
  • CUDA runtime

במהלך ההתקנה של הרכיבים האלה, תוכלו להגדיר את הסביבה בהתאם לצרכים שלכם. לדוגמה, אם יש לכם גרסה קודמת של TensorFlow שפועלת בצורה הכי טובה עם גרסה קודמת של ערכת הכלים של CUDA, אבל ה-GPU שבו אתם רוצים להשתמש דורש גרסה עדכנית יותר של מנהל ההתקנים של NVIDIA, אתם יכולים להתקין גרסה קודמת של ערכת הכלים של CUDA יחד עם גרסה עדכנית יותר של מנהל ההתקנים של NVIDIA.

עם זאת, חשוב לוודא שהגרסאות של מנהל ההתקנים (דרייבר) של NVIDIA ושל ערכת הכלים של CUDA תואמות. למידע על תאימות של ערכת הכלים של CUDA והדרייבר של NVIDIA, אפשר לעיין במסמכי NVIDIA בנושא תאימות ל-CUDA.

הסבר על ענפי הדרייברים של NVIDIA

‫NVIDIA מספקת את שלושת ענפי הדרייברים הבאים:

  • ענף תמיכה לטווח ארוך (LTSB): בענף הזה יש עדיפות ליציבות ולצמצום התחזוקה, עם מחזור חיים מורחב של תמיכה למשך שלוש שנים. גרסת ה-LTSB העדכנית שנבדקה ואומתה על ידי Google היא R580, שתאריך סיום התמיכה שלה הוא באוגוסט 2028.
  • ענף הייצור (PB): הענף הזה מספק שיפורים בביצועים ותמיכה בחומרה העדכנית ביותר. היא תומכת באופן מלא בעומסי עבודה של ייצור, אבל מחזור החיים שלה קצר יותר – עד שנה. הגרסה האחרונה של PB שנבדקה ואומתה על ידי Google היא R570, והתמיכה בה תסתיים בפברואר 2026.
  • ענף תכונות חדש (NFB): הענף הזה מיועד למראשוני המשתמשים שרוצים לבדוק תכונות חדשות, ולא מומלץ לשימוש בסביבות ייצור.

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

כדי לקבוע את הענף הטוב ביותר של מנהל ההתקן (דרייבר) של NVIDIA עבור סוג המכונה של ה-GPU, אפשר להיעזר בטבלה שבקטע הזה.

בטבלה הבאה, הסימן EOS מציין ש-NVIDIA מפרטת את ההסתעפות הזו כהסתעפות שמגיעה לסוף התמיכה. ‫N/A מציין שמערכת ההפעלה (OS) שצוינה לא יכולה לפעול בסוג המכונה.

סוג מכונה מודל GPU סניפים נתמכים הענף המומלץ
(תאריך סוף התמיכה)
הגורם המניע המינימלי להמלצה על ענף
A4X Max NVIDIA Blackwell GB300 Superchip R580 ואילך R580 (אוגוסט 2028)
  • ‫Linux: ‏ 580.95.05 ואילך
  • Windows: לא רלוונטי
A4X NVIDIA Blackwell GB200 Superchip ‫R570 ואילך R580 (אוגוסט 2028)
  • ‫Linux: ‏ 580.82.07 ואילך
  • Windows: לא רלוונטי
A4 NVIDIA Blackwell B200 ‫R570 ואילך R580 (אוגוסט 2028)
  • ‫Linux: ‏ 580.82.07 ואילך
  • Windows: לא רלוונטי
A3 Ultra NVIDIA H200 ‫R570 ואילך R580 (אוגוסט 2028)
  • ‫Linux: ‏ 580.82.07 ואילך
  • Windows: לא רלוונטי
‫A3 Mega, ‏ High, ‏ Edge NVIDIA H100 ‫R535 ואילך R535 (יוני 2026)
  • ‫Linux: ‏ 535.230.02 ואילך
  • Windows: לא רלוונטי
G4 NVIDIA RTX PRO 6000 R580 ואילך R580 (אוגוסט 2028)
  • ‫Linux: ‏ 580.95.05 ואילך
  • ‫Windows: ‏ 581.42 ואילך
G2 NVIDIA L4 ‫R535 ואילך R535 (יוני 2026)
  • ‫Linux: ‏ 535.230.02 ואילך
  • ‫Windows: ‏ 538.67 ואילך
‫A2 Standard, ‏ A2 Ultra NVIDIA A100 ‫R535 ואילך R535 (יוני 2026)
  • ‫Linux: ‏ 535.230.02 ואילך
  • ‫Windows: ‏ 538.67 ואילך
N1 NVIDIA T4 ‫R535 ואילך R535 (יוני 2026)
  • ‫Linux: ‏ 535.230.02 ואילך
  • ‫Windows: ‏ 538.67 ואילך
N1 ‫NVIDIA V100, ‏ P100, ‏ P4 ‫R35 עד R5801 R535 (יוני 2026)
  • ‫Linux: ‏ 535.230.02 ואילך
  • ‫Windows: ‏ 538.67 ואילך

1NVIDIA הודיעה ש-R580 הוא הענף האחרון של מנהלי ההתקנים שתומך בארכיטקטורה של Pascal‏ (P4 ו-P100) ו-Volta‏ (V100).

התקנת דרייברים של GPU במכונות וירטואליות באמצעות מדריכים של CUDA Toolkit

אחת הדרכים להתקין את הדרייבר של NVIDIA ברוב המכונות הווירטואליות היא להתקין את CUDA Toolkit.

כדי להתקין את CUDA Toolkit:

  1. בוחרים גרסה של CUDA Toolkit שתומכת בגרסת הדרייבר שדרושה לכם.

    סוג מכונה מודל GPU ערכת הכלים המומלצת של CUDA
    A4X Max NVIDIA Blackwell GB300 Superchip ‫CUDA 13.0 ואילך
    A4X NVIDIA Blackwell GB200 Superchip ‫CUDA 12.8.1 ואילך
    A4 NVIDIA Blackwell B200 ‫CUDA 12.8.1 ואילך
    A3 Ultra NVIDIA H200 ‫CUDA 12.4 ואילך
    G4 NVIDIA RTX PRO 6000 ‫CUDA 13.1 ואילך
    G2 NVIDIA L4 ‫CUDA 12.2.2 ואילך
    ‫A3 Mega, ‏ High, ‏ Edge NVIDIA H100 ‫CUDA 12.2.2 ואילך
    ‫A2 Standard, ‏ A2 Ultra NVIDIA A100 ‫CUDA 12.2.2 ואילך
    N1 NVIDIA T4 ‫CUDA 12.2.2 ואילך
    N1 ‫NVIDIA V100, ‏ P100, ‏ P4 ‫CUDA 12.2.2 עד CUDA 12 (גרסה סופית)1

    1CUDA Toolkit 12 הוא האחרון שתומך בארכיטקטורת Pascal‏ (P4 ו-P100) ובארכיטקטורת Volta‏ (V100). ‫NVIDIA הודיעה שהחל מגרסה 13.0 הראשית של CUDA Toolkit, לא תהיה יותר תמיכה בהידור אופליין ובספרייה של הארכיטקטורות האלה. מידע נוסף זמין בהערות הגרסה של מנהל ההתקן NVIDIA 13.0.

  2. מתחברים ל-VM שבה רוצים להתקין את מנהל ההתקן.

  3. ב-VM, מורידים ומתקינים את CUDA Toolkit. כדי למצוא את חבילת CUDA Toolkit והוראות התקנה, אפשר לעיין בארכיון CUDA Toolkit במסמכי NVIDIA.

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

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

Linux

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

מערכות הפעלה נתמכות

סקריפט ההתקנה של Linux נבדק במערכות ההפעלה הבאות:

  • ‫Debian 12 ו-13
  • ‫Red Hat Enterprise Linux‏ (RHEL) 8 ו-9
  • ‫Rocky Linux 8 ו-9
  • ‫Ubuntu 22 ו-24

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

כדי להתקין את הדרייברים של ה-GPU ואת CUDA Toolkit, מבצעים את השלבים הבאים:

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

    כדי לעצור את סוכן תפעול, מריצים את הפקודה הבאה:

    sudo systemctl stop google-cloud-ops-agent
  2. מוודאים ש-Python 3 מותקן במערכת ההפעלה.

  3. מורידים את סקריפט ההתקנה.

    curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
  4. מריצים את סקריפט ההתקנה.

    sudo python3 cuda_installer.pyz install_driver --installation-mode=INSTALLATION_MODE --installation-branch=BRANCH

    • INSTALLATION_MODE: שיטת ההתקנה. משתמשים באחד מהערכים הבאים:
      • repo: (ברירת מחדל) מתקין את הדרייבר ממאגר החבילות הרשמי של NVIDIA.
      • binary: מתקין את הדרייבר באמצעות חבילת ההתקנה הבינארית.
    • BRANCH: הענף של מנהל ההתקן שרוצים להתקין. משתמשים באחד מהערכים הבאים:
      • prod: (ברירת מחדל) ענף הייצור. הסתעפות זו מתאימה לשימוש בסביבות ייצור עבור מעבדי GPU ארגוניים ומעבדי GPU במרכזי נתונים.
      • nfb: ענף התכונה החדש. ההסתעפות הזו כוללת את העדכונים האחרונים למשתמשים הראשונים. הסתעפות הזו לא מומלצת לסביבות ייצור.
      • lts: הענף של התמיכה לטווח ארוך (LTS). הענף הזה מתוחזק למשך תקופה ארוכה יותר מענף ייצור רגיל.

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

  5. מאמתים את ההתקנה. איך בודקים שהדרייבר של ה-GPU מותקן

  6. אפשר גם להשתמש בכלי הזה כדי להתקין את CUDA Toolkit. כדי להתקין את CUDA Toolkit, מריצים את הפקודה הבאה:

    sudo python3 cuda_installer.pyz install_cuda --installation-mode=INSTALLATION_MODE --installation-branch=BRANCH

    חשוב לוודא שאתם משתמשים באותם ערכים של INSTALLATION_MODE ו-BRANCH שהשתמשתם בהם במהלך התקנת הדרייבר.

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

  7. מאמתים את ההתקנה של CUDA toolkit.

    python3 cuda_installer.pyz verify_cuda
  8. אחרי שמסיימים את ההתקנה, צריך להפעיל מחדש את המכונה הווירטואלית.

‫Linux (סקריפט לטעינה בזמן ההפעלה)

אפשר להשתמש בהוראות האלה כדי להתקין דרייברים של GPU במהלך ההפעלה של מכונה וירטואלית.

מערכות הפעלה נתמכות

סקריפט ההתקנה של Linux נבדק במערכות ההפעלה הבאות:

  • ‫Debian 12 ו-13
  • ‫Red Hat Enterprise Linux‏ (RHEL) 8 ו-9
  • ‫Rocky Linux 8 ו-9
  • ‫Ubuntu 22 ו-24

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

אפשר להשתמש בסקריפט לטעינה בזמן ההפעלה הבא כדי להפוך את ההתקנה של מנהל ההתקן ושל CUDA Toolkit לאוטומטית:

#!/bin/bash
if test -f /opt/google/cuda-installer
then
  exit
fi

mkdir -p /opt/google/cuda-installer
cd /opt/google/cuda-installer/ || exit

if test -f cuda_installation
then
  exit
fi

curl -fSsL -O https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz
python3 cuda_installer.pyz install_cuda

אפשר להוסיף את הדגלים --installation-mode INSTALLATION_MODE ו---installation-branch BRANCH לפקודת ההתקנה כדי לציין את מצב ההתקנה ואת ענף מנהל ההתקן שרוצים להתקין.

  • INSTALLATION_MODE: שיטת ההתקנה. משתמשים באחד מהערכים הבאים:
    • repo: (ברירת מחדל) מתקין את הדרייבר ממאגר החבילות הרשמי של NVIDIA.
    • binary: מתקין את הדרייבר באמצעות חבילת ההתקנה הבינארית.
  • BRANCH: הענף של מנהל ההתקן שרוצים להתקין. משתמשים באחד מהערכים הבאים:
    • prod: (ברירת מחדל) ענף הייצור. הסתעפות זו מתאימה לשימוש בסביבות ייצור עבור מעבדי GPU ארגוניים ומעבדי GPU במרכזי נתונים.
    • nfb: ענף התכונה החדש. ההסתעפות הזו כוללת את העדכונים האחרונים למשתמשים הראשונים. הסתעפות הזו לא מומלצת לסביבות ייצור.
    • lts: הענף של התמיכה לטווח ארוך (LTS). הענף הזה מתוחזק למשך תקופה ארוכה יותר מענף ייצור רגיל.

Windows

אפשר להשתמש בסקריפט ההתקנה הזה במופעי GPU שמופעל בהם אתחול מאובטח. הוא תומך ב-Windows Server 2019 ומעלה.

הסקריפט הזה מתקין מנהל התקן שתואם ל-NVIDIA RTX Virtual Workstation‏ (vWS). אם אין לכם רישיון ל-vWS, התכונות של vWS לא יהיו זמינות במופע שלכם.

פותחים טרמינל ב-PowerShell כאדמין, ואז מבצעים את השלבים הבאים:

  1. מורידים את הסקריפט.

    Invoke-WebRequest https://github.com/GoogleCloudPlatform/compute-gpu-installation/raw/main/windows/install_gpu_driver.ps1 -OutFile C:\install_gpu_driver.ps1
  2. מריצים את הסקריפט.

    C:\install_gpu_driver.ps1

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

    הסקריפט הזה מתקין את מנהלי ההתקנים במיקום ברירת המחדל הבא במכונה הווירטואלית: C:\Program Files\NVIDIA Corporation\.

  3. מאמתים את ההתקנה. איך בודקים שהדרייבר של ה-GPU מותקן

התקנת דרייברים של GPU (מכונות וירטואליות עם אתחול מאובטח)

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

תמיכה ב-GPU

ההליכים שמתוארים בקטע הזה תומכים בכל דגמי ה-GPU שזמינים ב-Compute Engine.

אי אפשר להשתמש בהליכים האלה כדי להתקין דרייברים במקרים של אתחול מאובטח שבהם מצורפים כרטיסי GPU עם גרסאות NVIDIA RTX Virtual Workstations (vWS).

אם אתם משתמשים במכונה וירטואלית של Windows או במכונה וירטואלית של Linux שלא מופעלת בה הפעלה מאובטחת, כדאי לעיין באחת מההוראות הבאות:

ההתקנה של מנהל ההתקן במכונה וירטואלית עם אתחול מאובטח שונה במכונות וירטואליות של Linux, כי במכונות וירטואליות כאלה נדרש שכל מודולי הליבה יהיו חתומים על ידי אישור מהימן.

התקנה

אפשר להשתמש באחת מהאפשרויות הבאות כדי להתקין מנהלי התקנים עם אישורים מהימנים:

  • יוצרים אישור מהימן לנהגים. כדי לבחור באפשרות הזו, צריך לבחור אחת מהאפשרויות הבאות:
    • שיטה אוטומטית: משתמשים בכלי ליצירת קובצי אימג' כדי ליצור קובצי אימג' של אתחול שכוללים אישורים מהימנים עבור מנהלי ההתקנים
    • שיטה ידנית: יוצרים אישור משלכם ומשתמשים בו כדי לחתום על מודולי הליבה של מנהל ההתקן של ה-GPU
  • שימוש במנהלי התקנים שחתומים מראש עם אישור מהימן קיים. השיטה הזו תומכת רק ב-Ubuntu.

חתימה עצמית (אוטומטית)

מערכות הפעלה נתמכות:

שיטת החתימה העצמית האוטומטית הזו נבדקה במערכות ההפעלה הבאות:

  • ‫Debian 12 ו-13
  • ‫Red Hat Enterprise Linux‏ (RHEL) 8 ו-9
  • ‫Rocky Linux 8 ו-9
  • ‫Ubuntu 22 ו-24

הליך

כדי ליצור תמונת מערכת הפעלה עם אישורים בחתימה עצמית, מבצעים את השלבים הבאים:

    1. In the Google Cloud console, activate Cloud Shell.

      Activate Cloud Shell

      At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

    2. מורידים את הכלי cuda_installer. כדי להוריד את הגרסה האחרונה של הסקריפט, מריצים את הפקודה הבאה:

      curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
      
    3. כדי ליצור קובץ אימג' שבו מופעל אתחול מאובטח, מריצים את הפקודה הבאה. תהליך יצירת התמונה יכול להימשך עד 20 דקות.

      PROJECT=PROJECT_ID
      ZONE=ZONE
      BASE_IMAGE=BASE_IMAGE_NAME
      SECURE_BOOT_IMAGE=IMAGE_NAME
      
      python3 cuda_installer.pyz build_image \
        --project $PROJECT \
        --vm-zone $ZONE \
        --base-image $BASE_IMAGE $SECURE_BOOT_IMAGE
      

      מחליפים את מה שכתוב בשדות הבאים:

      • PROJECT_ID: מזהה הפרויקט שבו רוצים ליצור את התמונה
      • ZONE: האזור שבו תיצור מכונה וירטואלית זמנית. לדוגמה us-west4-a.
      • IMAGE_NAME: השם של האימג' שייווצר.
      • BASE_IMAGE_NAME: בוחרים באחת מהאפשרויות הבאות:

        • debian-12 או debian-13
        • rhel-8 או rhel-9
        • rocky-8 או rocky-9
        • ubuntu-22 או ubuntu-24

      אפשר גם להוסיף את הדגל --family NAME כדי להוסיף את התמונה החדשה למשפחת תמונות.

      כדי לראות את כל האפשרויות להתאמה אישית של התמונה, מריצים את הפקודה python3 cuda_installer.pyz build_image --help. אפשר גם לעיין במסמכי התיעוד של cuda_installer ב-GitHub.

    4. מאמתים את התמונה. כדי לוודא שהתמונה כוללת את האפשרות Secure Boot (אתחול מאובטח) ושהיא יכולה ליצור מופעי GPU עם מנהלי התקנים (דרייברים) של NVIDIA, פועלים לפי השלבים הבאים.

      1. יוצרים מכונת VM לבדיקה כדי לוודא שהתמונה מוגדרת בצורה תקינה ושהדרייברים של ה-GPU נטענים בהצלחה. בדוגמה הבאה נוצר סוג מכונה N1 עם מאיץ NVIDIA T4 יחיד שמצורף אליה. עם זאת, אתם יכולים להשתמש בכל סוג מכונת GPU נתמך שתבחרו.

        TEST_INSTANCE_NAME=TEST_INSTANCE_NAME
        ZONE=ZONE
        
        gcloud compute instances create $TEST_INSTANCE_NAME \
         --project=$PROJECT \
         --zone=$ZONE \
         --machine-type=n1-standard-4 \
         --accelerator=count=1,type=nvidia-tesla-t4 \
         --create-disk=auto-delete=yes,boot=yes,device-name=$TEST_INSTANCE_NAME,image=projects/$PROJECT/global/images/$SECURE_BOOT_IMAGE,mode=rw,size=100,type=pd-balanced \
         --shielded-secure-boot \
         --shielded-vtpm \
         --shielded-integrity-monitoring \
         --maintenance-policy=TERMINATE
        

        מחליפים את מה שכתוב בשדות הבאים:

      2. כדי לבדוק שההפעלה המאובטחת מופעלת, מריצים את הפקודה mokutil --sb-state במכונה הווירטואלית לבדיקה באמצעות gcloud compute ssh.

        gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_INSTANCE_NAME --command "mokutil --sb-state"
        
      3. מריצים את הפקודה nvidia-smi במכונת ה-VM לבדיקה באמצעות gcloud compute ssh כדי לוודא שהדרייבר מותקן.

        gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_INSTANCE_NAME --command "nvidia-smi"
        

        אם התקנתם את CUDA Toolkit, תוכלו להשתמש בכלי cuda_installer כדי לאמת את ההתקנה באופן הבא:

        gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_INSTANCE_NAME --command "python3 cuda_installer.pyz verify_cuda"
        
    5. מפנים שטח אחסון. אחרי שמוודאים שהתמונה המותאמת אישית פועלת, אין צורך לשמור את המכונה הווירטואלית של האימות. כדי למחוק את מכונת ה-VM, מריצים את הפקודה הבאה:

      gcloud compute instances delete --zone=$ZONE --project=$PROJECT $TEST_INSTANCE_NAME
      
    6. אופציונלי: כדי למחוק את קובץ האימג' של הדיסק שיצרתם, מריצים את הפקודה הבאה:

      gcloud compute images delete --project=$PROJECT $SECURE_BOOT_IMAGE
      
    7. חתימה עצמית (ידנית)

      מערכות הפעלה נתמכות

      שיטת החתימה העצמית הידנית הזו נבדקה במערכות ההפעלה הבאות:

      • ‫Debian 12 ו-13
      • ‫Red Hat Enterprise Linux‏ (RHEL) 8 ו-9
      • ‫Rocky Linux 8 ו-9
      • ‫Ubuntu 22 ו-24

      סקירה כללית

      תהליך ההתקנה, החתימה ויצירת התמונה הוא כזה:

      1. יוצרים אישור משלכם לשימוש בחתימה על מנהל ההתקן.
      2. יוצרים מכונה וירטואלית כדי להתקין ולחתום על הדרייבר של ה-GPU. כדי ליצור את המכונה הווירטואלית, אפשר להשתמש במערכת ההפעלה הרצויה. כשיוצרים את המכונה הווירטואלית (VM), צריך להשבית את האתחול המאובטח. אין צורך לצרף יחידות GPU למכונה הווירטואלית.
      3. מתקינים את מנהל ההתקן של GPU וחותמים עליו, ומתקינים את ערכת הכלים של CUDA (אופציונלי).
      4. יוצרים קובץ אימג' של הדיסק על סמך המכונה עם מנהל ההתקן בחתימה עצמית, ומוסיפים את האישור לרשימת האישורים המהימנים.
      5. משתמשים בתמונה כדי ליצור מכונות וירטואליות עם GPU שמופעל בהן Secure Boot.

      יצירת תמונות

        1. In the Google Cloud console, activate Cloud Shell.

          Activate Cloud Shell

          At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

        2. יוצרים אישור משלכם באמצעות OpenSSL. ב-OpenSSL, החתימה והאימות של Secure Boot מתבצעים באמצעות אישורי X.509 רגילים בקידוד Distinguished Encoding Rules‏ (DER). מריצים את הפקודה הבאה כדי ליצור אישור X.509 חדש בחתימה עצמית וקובץ מפתח פרטי מסוג RSA.

          openssl req -new -x509 -newkey rsa:2048 -keyout private.key -outform DER -out public.der -noenc -days 36500 -subj "/CN=Graphics Drivers Secure Boot Signing"
          
        3. יוצרים מכונה וירטואלית כדי להתקין את מנהל ההתקן בחתימה עצמית. כשיוצרים את המכונה הווירטואלית, לא צריך לצרף יחידות GPU או להפעיל את האתחול המאובטח. כדי שתהליך ההתקנה יצליח, אפשר להשתמש בסוג מכונה רגיל E2 עם נפח פנוי של 40GB לפחות.

          INSTANCE_NAME=BUILD_INSTANCE_NAME
          DISK_NAME=IMAGE_NAME
          ZONE=ZONE
          PROJECT=PROJECT_ID
          OS_IMAGE=IMAGE_DETAILS
          
          # Create the build VM
          gcloud compute instances create $INSTANCE_NAME \
           --zone=$ZONE \
           --project=$PROJECT \
           --machine-type=e2-standard-4 \
           --create-disk=auto-delete=yes,boot=yes,name=$DISK_NAME,$OS_IMAGE,mode=rw,size=100,type=pd-balanced \
           --no-shielded-secure-boot
          

          מחליפים את מה שכתוב בשדות הבאים:

          • BUILD_INSTANCE_NAME: השם של מופע מכונת ה-VM ששימש לבניית האימג'.
          • IMAGE_NAME: השם של קובץ האימג' של הדיסק.
          • ZONE: האזור שבו תיצור את המכונה הווירטואלית.
          • PROJECT_ID: מזהה הפרויקט שבו רוצים להשתמש כדי ליצור את תמונת הדיסק החדשה.
          • IMAGE_DETAILS: משפחת התמונות והפרויקט של תמונת מערכת ההפעלה הבסיסית שנבחרה:

            • ‫Debian 12: "image-family=debian-12,image-project=debian-cloud"
            • ‫Debian 13: "image-family=debian-13,image-project=debian-cloud"
            • ‫RHEL 8: "image-family=rhel-8,image-project=rhel-cloud"
            • ‫RHEL 9: "image-family=rhel-9,image-project=rhel-cloud"
            • ‫Rocky Linux 8: "image-family=rocky-linux-8,image-project=rocky-linux-cloud"
            • ‫Rocky Linux 9: ‏ "image-family=rocky-linux-9,image-project=rocky-linux-cloud"
            • ‫Ubuntu 22: ‏ "image-family=ubuntu-2204-lts-amd64,image-project=ubuntu-os-cloud"
            • ‫Ubuntu 24: "image-family=ubuntu-2404-lts-amd64,image-project=ubuntu-os-cloud"
        4. מעתיקים את קובץ המפתח הפרטי שנוצר אל המכונה הווירטואלית. כדי לחתום על קובץ הדרייבר, צריך שזוג המפתחות שנוצר יהיה זמין במכונה הווירטואלית.

          gcloud compute scp --zone $ZONE --project $PROJECT private.key $INSTANCE_NAME:~/private.key
          gcloud compute scp --zone $ZONE --project $PROJECT public.der $INSTANCE_NAME:~/public.der
          
        5. מתקינים את מנהל ההתקן וחותמים עליו. ההתקנה והחתימה של מנהל ההתקן ושל CUDA Toolkit מתבצעות על ידי סקריפט ההתקנה שמשמש גם להתקנות שלא נעשה בהן שימוש באתחול מאובטח. כדי להתקין ולחתום על מנהל ההתקן, מבצעים את השלבים הבאים:

          1. מתחברים למכונה הווירטואלית באמצעות SSH:

            gcloud compute ssh --zone $ZONE --project $PROJECT $INSTANCE_NAME
            
          2. מוודאים שהמפתחות הפרטי והציבורי הועתקו בצורה תקינה:

            ls private.key public.der
            
          3. מורידים את סקריפט ההתקנה של מנהל ההתקן:

            curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
            
          4. בודקים שהתקנת מנהל ההתקן מוגדרת עם חתימה. מכונת ה-build מופעלת מחדש במהלך ההגדרה. אחרי שמפעילים מחדש את מכונת ה-build, מתחברים למכונה הווירטואלית באמצעות SSH ומריצים מחדש את הסקריפט כדי להמשיך בהתקנה.

            sudo python3 cuda_installer.pyz install_driver --secure-boot-pub-key=public.der --secure-boot-priv-key=private.key --ignore-no-gpu
            

            אם רוצים להתקין את CUDA Toolkit באותו הזמן, אפשר לעשות זאת באמצעות הפקודה הבאה.

            sudo python3 cuda_installer.pyz install_cuda --ignore-no-gpu
            

            יכול להיות שיופיעו הודעות שגיאה או אזהרה. התוצאות האלה מתקבלות כשלא מזוהה GPU, וזה צפוי. המערכת תופעל מחדש אחרי השלמת ההתקנה של CUDA Toolkit. אחרי החיבור מחדש, אפשר להמשיך לשלבים הבאים.

          5. מסירים את קובצי האישורים, כי הם כבר לא נחוצים במכונה הזמנית. כדי לשפר את רמת האבטחה, כדאי להשתמש בפקודה shred במקום בפקודה rm. המפתחות לא צריכים להיות בתמונת הדיסק הסופית.

            shred -uz private.key public.der
            
          6. משביתים את המכונה הווירטואלית כדי שאפשר יהיה להשתמש בדיסק שלה ליצירת האימג' החדש.

            sudo shutdown now
            
        6. מכינים את קובץ האימג' של דיסק הבסיס. כדי ליצור תמונת דיסק חדשה שאפשר להשתמש בה כדי ליצור מכונות עם הפעלה מאובטחת, צריך להגדיר את התמונה כך שתהיה לה גישה למפתח החדש שיצרתם. קובץ האימג' החדש של הדיסק עדיין מקבל את האישורים שמוגדרים כברירת מחדל, שמשמשים את מערכת ההפעלה. כדי להכין את תמונת הבסיס, מבצעים את השלבים הבאים.

          1. מורידים את אישורי ברירת המחדל. משתמשים בפקודות הבאות כדי להוריד את האישורים MicWinProPCA2011_2011-10-19.crt ו-MicCorUEFCA2011_2011-06-27.crt:

            curl -L https://storage.googleapis.com/compute-gpu-installation-us/certificates/MicCorUEFCA2011_2011-06-27.crt --output MicCorUEFCA2011_2011-06-27.crt
            curl -L https://storage.googleapis.com/compute-gpu-installation-us/certificates/MicWinProPCA2011_2011-10-19.crt --output MicWinProPCA2011_2011-10-19.crt
            
          2. מאמתים את האישורים:

            cat <<EOF >>check.sha1
            46def63b5ce61cf8ba0de2e6639c1019d0ed14f3  MicCorUEFCA2011_2011-06-27.crt
            580a6f4cc4e4b669b9ebdc1b2b3e087b80d0678d  MicWinProPCA2011_2011-10-19.crt
            EOF
            
            sha1sum -c check.sha1
            
          3. יוצרים תמונה שמבוססת על הדיסק של המכונה הווירטואלית הזמנית. אתם יכולים להוסיף את האפשרות --family=IMAGE_FAMILY_NAME כדי שהתמונה תוגדר כתמונה האחרונה במשפחה נתונה של תמונות. יצירת התמונה החדשה עשויה להימשך כמה דקות.

            מריצים את הפקודה הבאה באותה ספרייה שבה נמצאים קובץ public.der והאישורים שהורדתם.

            SECURE_BOOT_IMAGE=IMAGE_NAME
            
            gcloud compute images create $SECURE_BOOT_IMAGE \
            --source-disk=$DISK_NAME \
            --source-disk-zone=$ZONE \
            --project=$PROJECT  \
            --signature-database-file=MicWinProPCA2011_2011-10-19.crt,MicCorUEFCA2011_2011-06-27.crt,public.der \
            --guest-os-features="UEFI_COMPATIBLE"
            

            כדי לוודא שהמפתח הציבורי של האישור מצורף לתמונה החדשה הזו, מריצים את הפקודה הבאה:

            gcloud compute images describe --project=$PROJECT $SECURE_BOOT_IMAGE
            
        7. מאמתים את התמונה החדשה. אתם יכולים ליצור מכונת GPU וירטואלית באמצעות תמונת הדיסק החדשה. בשלב הזה, מומלץ להשתמש בסוג מכונה N1 עם מאיץ T4 יחיד שמופעל בו Secure Boot. עם זאת, התמונה תומכת גם בסוגים אחרים של GPU ובסוגים אחרים של מכונות.

          1. יוצרים מכונת VM עם GPU לניסוי:

            TEST_GPU_INSTANCE=TEST_GPU_INSTANCE_NAME
            ZONE=ZONE
            
            gcloud compute instances create $TEST_GPU_INSTANCE \
            --project=$PROJECT \
            --zone=$ZONE \
            --machine-type=n1-standard-4 \
            --accelerator=count=1,type=nvidia-tesla-t4 \
            --create-disk=auto-delete=yes,boot=yes,device-name=$TEST_GPU_INSTANCE,image=projects/$PROJECT/global/images/$SECURE_BOOT_IMAGE,mode=rw,size=100,type=pd-balanced \
            --shielded-secure-boot \
            --shielded-vtpm \
            --shielded-integrity-monitoring \
            --maintenance-policy=TERMINATE
            

            מחליפים את מה שכתוב בשדות הבאים:

            • TEST_GPU_INSTANCE_NAME: השם של מופע המכונה הווירטואלית עם GPU
              שיוצרים כדי לבדוק את התמונה החדשה.
            • ZONE: אזור עם מעבדי T4 GPU או מעבד GPU אחר לבחירתכם. מידע נוסף זמין במאמר בנושא אזורים ותחומים של GPU.
          2. מריצים את הפקודה mokutil --sb-state במכונה הווירטואלית לבדיקה באמצעות gcloud compute ssh כדי לוודא שההפעלה המאובטחת מופעלת.

            gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_GPU_INSTANCE --command "mokutil --sb-state"
            
          3. מריצים את הפקודה nvidia-smi ב-VM לבדיקה באמצעות gcloud compute ssh כדי לוודא שהדרייבר מותקן.

            gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_GPU_INSTANCE --command "nvidia-smi"
            

            אם התקנתם את CUDA Toolkit, תוכלו להשתמש בכלי cuda_installer כדי לאמת את ההתקנה באופן הבא:

            gcloud compute ssh --project=$PROJECT --zone=$ZONE $TEST_GPU_INSTANCE --command "python3 cuda_installer.pyz verify_cuda"
            
        8. מפנים שטח אחסון. אחרי שמוודאים שהתמונה החדשה פועלת, אין צורך לשמור את המכונה הווירטואלית הזמנית או את המכונה הווירטואלית לאימות. התמונה של הדיסק שיצרת לא תלויה בהם בשום צורה. כדי למחוק אותם, מריצים את הפקודה הבאה:

          gcloud compute instances delete --zone=$ZONE --project=$PROJECT $INSTANCE_NAME
          gcloud compute instances delete --zone=$ZONE --project=$PROJECT $TEST_GPU_INSTANCE
          

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

          כשאין יותר צורך בקבצים בדיסק, מומלץ להסיר אותם בצורה בטוחה באמצעות הכלי shred. מריצים את הפקודה הבאה:

          # Safely delete the key pair from your system
          shred -uz private.key public.der
          
        9. חתימה מראש (Ubuntu בלבד)

          ההוראות האלה זמינות רק למכונות וירטואליות של Linux עם הפעלה מאובטחת שפועלות במערכות הפעלה Ubuntu 18.04,‏ 20.04 ו-22.04. אנחנו עובדים על הוספת תמיכה במערכות הפעלה נוספות של Linux.

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

          1. מתחברים ל-VM שבה רוצים להתקין את מנהל ההתקן.

          2. מעדכנים את המאגר.

             sudo apt-get update
            
          3. מחפשים את חבילת מודול הליבה העדכנית ביותר של NVIDIA או את הגרסה הרצויה. החבילה הזו מכילה מודולים של ליבת NVIDIA שנחתמו על ידי מפתח Ubuntu. אם רוצים למצוא גרסה קודמת, משנים את המספר של הפרמטר tail כדי לקבל גרסה קודמת. לדוגמה, מציינים tail -n 2.

            ‫Ubuntu PRO ו-LTS

            ב-Ubuntu PRO וב-LTS, מריצים את הפקודה הבאה:

            NVIDIA_DRIVER_VERSION=$(sudo apt-cache search 'linux-modules-nvidia-[0-9]+-gcp$' | awk '{print $1}' | sort | tail -n 1 | head -n 1 | awk -F"-" '{print $4}')
            

            Ubuntu PRO FIPS

            ב-Ubuntu PRO FIPS, מריצים את הפקודות הבאות:

            1. הפעלת עדכוני FIPS של Ubuntu.

              sudo ua enable fips-updates
              
            2. כיבוי והפעלה מחדש

              sudo shutdown -r now
              
            3. להוריד את החבילה העדכנית.

              NVIDIA_DRIVER_VERSION=$(sudo apt-cache search 'linux-modules-nvidia-[0-9]+-gcp-fips$' | awk '{print $1}' | sort | tail -n 1 | head -n 1 | awk -F"-" '{print $4}')
              

            כדי לבדוק את הגרסה של מנהל ההתקנים שנבחרה, מריצים את הפקודה echo $NVIDIA_DRIVER_VERSION. הפלט הוא מחרוזת גרסה כמו 455.

          4. מתקינים את חבילת מודול הליבה ואת הדרייבר המתאים של NVIDIA.

             sudo apt install linux-modules-nvidia-${NVIDIA_DRIVER_VERSION}-gcp nvidia-driver-${NVIDIA_DRIVER_VERSION}
            

            אם הפקודה נכשלה עם השגיאה package not found error, יכול להיות שהמאגר לא כולל את מנהל ההתקן העדכני של NVIDIA. מנסים שוב את השלב הקודם ובוחרים גרסה קודמת של הדרייבר על ידי שינוי מספר הזנב.

          5. מוודאים שהדרייבר של NVIDIA מותקן. יכול להיות שתצטרכו להפעיל מחדש את מכונת ה-VM.

          6. אם הפעלתם מחדש את המערכת כדי לאמת את גרסת NVIDIA. אחרי האתחול מחדש, צריך להריץ מחדש את הפקודה שבה השתמשתם בשלב 3 כדי לאפס את המשתנה NVIDIA_DRIVER_VERSION.

          7. מגדירים את APT לשימוש במאגר החבילות של NVIDIA.

            1. כדי לעזור ל-APT לבחור את יחסי התלות הנכונים, צריך להצמיד את המאגרים באופן הבא:

              sudo tee /etc/apt/preferences.d/cuda-repository-pin-600 > /dev/null <<EOL
              Package: nsight-compute
              Pin: origin *ubuntu.com*
              Pin-Priority: -1
              Package: nsight-systems Pin: origin *ubuntu.com* Pin-Priority: -1
              Package: nvidia-modprobe Pin: release l=NVIDIA CUDA Pin-Priority: 600
              Package: nvidia-settings Pin: release l=NVIDIA CUDA Pin-Priority: 600
              Package: * Pin: release l=NVIDIA CUDA Pin-Priority: 100 EOL

            2. מתקינים את software-properties-common. הפעולה הזו נדרשת אם משתמשים בתמונות מינימליות של Ubuntu.

              sudo apt install software-properties-common
              
            3. מגדירים את גרסת Ubuntu.

              Ubuntu 18.04

              ב-Ubuntu 18.04, מריצים את הפקודה הבאה:

              export UBUNTU_VERSION=ubuntu1804/x86_64

              Ubuntu 20.04

              ב-Ubuntu 20.04, מריצים את הפקודה הבאה:

              export UBUNTU_VERSION=ubuntu2004/x86_64

              Ubuntu 22.04

              ב-Ubuntu 22.04, מריצים את הפקודה הבאה:

              export UBUNTU_VERSION=ubuntu2204/x86_64
            4. מורידים את חבילת cuda-keyring.

              wget https://developer.download.nvidia.com/compute/cuda/repos/$UBUNTU_VERSION/cuda-keyring_1.0-1_all.deb
            5. מתקינים את חבילת cuda-keyring.

              sudo dpkg -i cuda-keyring_1.0-1_all.deb
            6. מוסיפים את מאגר NVIDIA.

              sudo add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/$UBUNTU_VERSION/ /"

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

          8. מאתרים את הגרסה התואמת של מנהל ההתקן של CUDA.

            הסקריפט הבא קובע את הגרסה העדכנית ביותר של דרייבר CUDA שתואמת לדרייבר NVIDIA שהתקנו זה עתה:

             CUDA_DRIVER_VERSION=$(apt-cache madison cuda-drivers | awk '{print $3}' | sort -r | while read line; do
                if dpkg --compare-versions $(dpkg-query -f='${Version}\n' -W nvidia-driver-${NVIDIA_DRIVER_VERSION}) ge $line ; then
                   echo "$line"
                   break
                fi
             done)
            

            כדי לבדוק את הגרסה של מנהל ההתקנים של CUDA, מריצים את הפקודה echo $CUDA_DRIVER_VERSION. הפלט הוא מחרוזת גרסה כמו 455.32.00-1.

          9. מתקינים את הדרייברים של CUDA עם הגרסה שזוהתה בשלב הקודם.

             sudo apt install cuda-drivers-${NVIDIA_DRIVER_VERSION}=${CUDA_DRIVER_VERSION} cuda-drivers=${CUDA_DRIVER_VERSION}
            

          10. אופציונלי: מעכבים חבילות dkms.

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

            כדי להשהות חבילות dkms, מריצים את הפקודה הבאה:

             sudo apt-get remove dkms && sudo apt-mark hold dkms
            
          11. מתקינים את CUDA Toolkit ואת זמן הריצה.

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

             CUDA_VERSION=$(apt-cache showpkg cuda-drivers | grep -o 'cuda-runtime-[0-9][0-9]-[0-9],cuda-drivers [0-9\\.]*' | while read line; do
                if dpkg --compare-versions ${CUDA_DRIVER_VERSION} ge $(echo $line | grep -Eo '[[:digit:]]+\.[[:digit:]]+') ; then
                   echo $(echo $line | grep -Eo '[[:digit:]]+-[[:digit:]]')
                   break
                fi
             done)
            

            כדי לבדוק את גרסת CUDA, מריצים את הפקודה echo $CUDA_VERSION. הפלט הוא מחרוזת גרסה כמו 11-1.

          12. מתקינים את חבילת CUDA.

             sudo apt install cuda-${CUDA_VERSION}
            
          13. מאמתים את ההתקנה של CUDA.

             sudo nvidia-smi
             /usr/local/cuda/bin/nvcc --version
            

            הפקודה הראשונה מדפיסה את פרטי ה-GPU. הפקודה השנייה מדפיסה את גרסת המהדר של CUDA שהותקנה.

אימות ההתקנה של הדרייבר של ה-GPU

אחרי שמסיימים את שלבי ההתקנה של מנהל ההתקן, צריך לוודא שהוא הותקן ואותחל בצורה תקינה.

Linux

מתחברים למופע Linux ומשתמשים בפקודה nvidia-smi כדי לוודא שהדרייבר פועל בצורה תקינה.

sudo nvidia-smi

הפלט אמור להיראות כך:

  +-----------------------------------------------------------------------------------------+
  | NVIDIA-SMI 580.82.07              Driver Version: 580.82.07      CUDA Version: 13.0     |
  +-----------------------------------------+------------------------+----------------------+
  | GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
  | Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
  |                                         |                        |               MIG M. |
  |=======================================+====================+====================|
  |   0  Tesla T4                       On  |   00000000:00:04.0 Off |                    0 |
  | N/A   53C    P8             17W /   70W |       0MiB /  15360MiB |      0%      Default |
  |                                         |                        |                  N/A |
  +-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+ | Processes: | | GPU GI CI PID Type Process name GPU Memory | | ID ID Usage | |=========================================================================================| | No running processes found | +-----------------------------------------------------------------------------------------+

אם הפקודה הזו נכשלת, צריך לבדוק אם כרטיסי ה-GPU מצורפים למכונה הווירטואלית. כדי לבדוק אם יש מכשירי NVIDIA PCI, מריצים את הפקודה הבאה:

sudo lspci | grep -i "nvidia"

Windows Server

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

nvidia-smi

הפלט אמור להיראות כך:

+---------------------------------------------------------------------------------------+
| NVIDIA-SMI 538.67                 Driver Version: 538.67       CUDA Version: 12.2     |
|-----------------------------------------+----------------------+----------------------+
| GPU  Name                     TCC/WDDM  | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |         Memory-Usage | GPU-Util  Compute M. |
|                                         |                      |               MIG M. |
|=========================================+======================+======================|
|   0  NVIDIA L4                    WDDM  | 00000000:00:03.0 Off |                    0 |
| N/A   66C    P8              17W /  72W |    128MiB / 23034MiB |      0%      Default |
|                                         |                      |                  N/A |
+-----------------------------------------+----------------------+----------------------+

+---------------------------------------------------------------------------------------+
| Processes:                                                                            |
|  GPU   GI   CI        PID   Type   Process name                            GPU Memory |
|        ID   ID                                                             Usage      |
|=======================================================================================|
|    0   N/A  N/A      4888    C+G   ...CBS_cw5n1h2txyewy\TextInputHost.exe    N/A      |
|    0   N/A  N/A      5180    C+G   ....Search_cw5n1h2txyewy\SearchApp.exe    N/A      |
+---------------------------------------------------------------------------------------+

מה השלב הבא?