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

Linux

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

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

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

• ‫Debian 12 ו-Debian 13
• ‫Red Hat Enterprise Linux‏ (RHEL) גרסאות 8, 9 ו-10
• ‫Rocky Linux 8, ‏ 9 ו-10
• ‫Ubuntu 22, ‏ 24 ו-26

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

כדי להתקין את מנהלי ההתקנים של ה-GPU ואת ערכת הכלים של CUDA:

1. אם אתם משתמשים בגרסה 2.38.0 או בגרסה חדשה יותר של סוכן תפעול לאיסוף מדדי GPU במכונה של Compute Engine, אתם צריכים לעצור את הסוכן לפני שתוכלו להתקין או לשדרג את מנהלי ההתקנים של ה-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. אנחנו ממליצים על המצב הזה למופעי מחשוב שמנוהלים על ידי כלים אוטומטיים לתיקון מערכת ההפעלה, כי Dynamic Kernel Module Support ‏ (DKMS) בונה מחדש את מנהל ההתקן באופן אוטומטי כשמעדכנים את הליבה.
     • ‫binary: מתקין את הדרייבר באמצעות תוכנת ההתקנה העצמאית של NVIDIA .run ונועל את חבילות המטא של ליבת מערכת ההפעלה של האורח (apt-mark hold ב-Ubuntu וב-Debian, או exclude=kernel* ב-/etc/dnf/dnf.conf ב-Red Hat Enterprise Linux (RHEL) וב-Rocky Linux) כדי למנוע מעדכוני ליבה לא מכוונים לשבש את הדרייבר. מנהל ההתקנה משתמש באופן אוטומטי במצב binary כשמציינים את --installation-branch=lts או את --force-version, או כשמתקינים את מנהל ההתקן במכונה וירטואלית של NVIDIA RTX Virtual Workstation (vWS).
   • ‫BRANCH: הענף של מנהל ההתקן שרוצים להתקין. משתמשים באחד מהערכים הבאים:
     • ‫prod: (ברירת מחדל) הענף של סביבת הייצור. הענף הזה מתאים לשימוש בסביבות ייצור עבור כרטיסי GPU ארגוניים וכרטיסי GPU למרכזי נתונים.
     • ‫nfb: הענף החדש של התכונה. ההסתעפות הזו כוללת את העדכונים האחרונים למשתמשים שרוצים להתנסות בגרסאות חדשות. אנחנו לא ממליצים להשתמש בהסתעפות הזו בסביבות ייצור.
     • ‫lts: ענף התמיכה לטווח ארוך, שמשתמש במצב התקנה binary. ‫NVIDIA מתחזקת את הענף הזה למשך תקופה ארוכה יותר מענף ייצור רגיל.

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

   python3 cuda_installer.pyz list_driver_versions

   כדי להתקין גרסה ספציפית של מנהל ההתקן, משתמשים באפשרות --force-version.

   sudo python3 cuda_installer.pyz install_driver --force-version DRIVER_VERSION

   מחליפים את DRIVER_VERSION בגרסת הדרייבר שרוצים להתקין.

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

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

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

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

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

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

7. מאמתים את ההתקנה של ערכת הכלים של CUDA.

   python3 cuda_installer.pyz verify_cuda

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

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

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

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

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

• ‫Debian 12 ו-Debian 13
• ‫Red Hat Enterprise Linux‏ (RHEL) גרסאות 8, 9 ו-10
• ‫Rocky Linux 8, ‏ 9 ו-10
• ‫Ubuntu 22, ‏ 24 ו-26

אם משתמשים בסקריפט הזה במערכות הפעלה אחרות, יכול להיות שההתקנה תיכשל. הסקריפט הזה יכול להתקין את הדרייבר של 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_driver
# Or uncomment the line below to also install CUDA Toolkit
# python3 cuda_installer.pyz install_cuda

כדי להתקין רק את מנהל ההתקן בלי CUDA Toolkit, מחליפים את install_cuda בשורה האחרונה של הסקריפט ב-install_driver.

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

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

• ‫INSTALLATION_MODE: שיטת ההתקנה. משתמשים באחד מהערכים הבאים:
  • ‫repo: (ברירת המחדל) התקנת הדרייבר ממאגר החבילות הרשמי של NVIDIA. אנחנו ממליצים על המצב הזה למופעי מחשוב שמנוהלים על ידי כלים אוטומטיים לתיקון מערכת ההפעלה, כי Dynamic Kernel Module Support ‏ (DKMS) בונה מחדש את מנהל ההתקן באופן אוטומטי כשמעדכנים את הליבה.
  • ‫binary: מתקין את הדרייבר באמצעות תוכנת ההתקנה העצמאית של NVIDIA .run ונועל את חבילות המטא של ליבת מערכת ההפעלה של האורח (apt-mark hold ב-Ubuntu וב-Debian, או exclude=kernel* ב-/etc/dnf/dnf.conf ב-Red Hat Enterprise Linux (RHEL) וב-Rocky Linux) כדי למנוע מעדכוני ליבה לא מכוונים לשבש את הדרייבר. מנהל ההתקנה משתמש באופן אוטומטי במצב binary כשמציינים את --installation-branch=lts או את --force-version, או כשמתקינים את מנהל ההתקן במכונה וירטואלית של NVIDIA RTX Virtual Workstation (vWS).
• ‫BRANCH: הענף של מנהל ההתקן שרוצים להתקין. משתמשים באחד מהערכים הבאים:
  • ‫prod: (ברירת מחדל) הענף של סביבת הייצור. הענף הזה מתאים לשימוש בסביבות ייצור עבור כרטיסי GPU ארגוניים וכרטיסי GPU למרכזי נתונים.
  • ‫nfb: הענף החדש של התכונה. ההסתעפות הזו כוללת את העדכונים האחרונים למשתמשים שרוצים להתנסות בגרסאות חדשות. אנחנו לא ממליצים להשתמש בהסתעפות הזו בסביבות ייצור.
  • ‫lts: ענף התמיכה לטווח ארוך, שמשתמש במצב התקנה binary. ‫NVIDIA מתחזקת את הענף הזה למשך תקופה ארוכה יותר מענף ייצור רגיל.

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

python3 cuda_installer.pyz list_driver_versions

כדי להתקין גרסה ספציפית של מנהל ההתקן, משתמשים באפשרות --force-version.

sudo python3 cuda_installer.pyz install_driver --force-version DRIVER_VERSION

מחליפים את DRIVER_VERSION בגרסת הדרייבר שרוצים להתקין.

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

‫Windows (אוטומטי)

כדי להתקין באופן אוטומטי מנהלי התקנים של GPU בהפעלה הראשונה של מכונת Windows, מגדירים את מפתח המטא-נתונים sysprep-specialize-script-url של המכונה החדשה לערך https://github.com/GoogleCloudPlatform/compute-gpu-installation/raw/main/windows/install_gpu_driver.ps1.

מידע נוסף על שימוש בסקריפטים להפעלה במכונות Windows זמין במאמר שימוש בסקריפטים להפעלה במכונות וירטואליות של Windows.

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

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

מערכות ההפעלה שאפשר להשתמש בהן:

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

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

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

• ‫Debian 12 ו-Debian 13
• ‫Red Hat Enterprise Linux‏ (RHEL) גרסאות 8, 9 ו-10
• ‫Rocky Linux 8, ‏ 9 ו-10
• ‫Ubuntu 22, ‏ 24 ו-26

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

הליך

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

1. במסוף Cloud de Confiance , מפעילים את Cloud Shell.

   הפעלת Cloud Shell

   בחלק התחתון של Cloud de Confiance המסוף יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

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

   curl -L https://storage.googleapis.com/compute-gpu-installation-us/installer/latest/cuda_installer.pyz --output cuda_installer.pyz
   

3. כדי ליצור קובץ אימג' עם Secure Boot מופעל, מריצים את הפקודה הבאה. תהליך יצירת התמונה יכול להימשך עד 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 או rhel-10
     • ‫rocky-8, rocky-9 או rocky-10
     • ubuntu-22 או ubuntu-24

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

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

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

   1. יוצרים מכונה וירטואלית לבדיקה כדי לוודא שהתמונה מוגדרת כמו שצריך ושהדרייברים של ה-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
      

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

      • ‫TEST_INSTANCE_NAME: שם למופע של מכונה וירטואלית לבדיקה
      • ‫ZONE: אזור עם יחידות GPU מסוג T4 או יחידות GPU לבחירתכם. מידע נוסף זמין במאמר בנושא אזורים ותחומים של GPU.

   2. כדי לבדוק אם האתחול המאובטח מופעל, מריצים את הפקודה mokutil --sb-state ב-VM לבדיקה באמצעות 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
   

חתימה עצמית (ידנית)

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

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

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

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

• ‫Debian 12 ו-Debian 13
• ‫Red Hat Enterprise Linux‏ (RHEL) גרסאות 8, 9 ו-10
• ‫Rocky Linux 8, ‏ 9 ו-10
• ‫Ubuntu 22, ‏ 24 ו-26

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

סקירה כללית

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

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

יצירת תמונות

1. מפעילים את Cloud Shell במסוף Cloud de Confiance .

   הפעלת Cloud Shell

   בחלק התחתון של מסוף Cloud de Confiance יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

2. יוצרים אישור משלכם באמצעות OpenSSL. ב-OpenSSL, החתימה והאימות של האתחול המאובטח מתבצעים באמצעות אישורי 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. יוצרים מכונה וירטואלית כדי להתקין את מנהל ההתקן בחתימה עצמית. כשיוצרים את ה-VM, לא צריך לצרף יחידות 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: השם של המופע של המכונה הווירטואלית שמשמש ליצירת האימג'.
   • ‫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"
     • ‫RHEL 10: "image-family=rhel-10,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"
     • ‫Rocky Linux 10: ‏ "image-family=rocky-linux-10,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
      
      curl -L https://storage.googleapis.com/compute-gpu-installation-us/certificates/windows_uefi_ca_2023.crt --output windows_uefi_ca_2023.crt
      curl -L https://storage.googleapis.com/compute-gpu-installation-us/certificates/microsoft_uefi_ca_2023.crt --output microsoft_uefi_ca_2023.crt
      

   2. מאמתים את האישורים:

      cat <<EOF >>check.sha1
      46def63b5ce61cf8ba0de2e6639c1019d0ed14f3  MicCorUEFCA2011_2011-06-27.crt
      b5eeb4a6706048073f0ed296e7f580a790b59eaa  microsoft_uefi_ca_2023.crt
      580a6f4cc4e4b669b9ebdc1b2b3e087b80d0678d  MicWinProPCA2011_2011-10-19.crt
      45a0fa32604773c82433c3b7d59e7466b3ac0c67  windows_uefi_ca_2023.crt
      EOF
      
      sha1sum -c check.sha1
      

   3. יוצרים קובץ אימג' שמבוסס על הדיסק של ה-VM הזמני. אפשר להוסיף את --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,windows_uefi_ca_2023.crt,microsoft_uefi_ca_2023.crt,public.der \
      --guest-os-features="UEFI_COMPATIBLE"
      

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

      gcloud compute images describe --project=$PROJECT $SECURE_BOOT_IMAGE
      

7. מאמתים את התמונה החדשה. אתם יכולים ליצור VM עם GPU באמצעות קובץ האימג' החדש. בשלב הזה, מומלץ להשתמש בסוג מכונה N1 עם מאיץ T4 יחיד שמופעל בו Secure Boot. עם זאת, קובץ האימג' תומך גם בסוגים אחרים של מעבדים גרפיים וסוגי מכונות.

   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: אזור שיש בו מעבדי GPU מסוג T4 או מעבדי 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
   

חתימה מראש (Ubuntu בלבד)

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

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

1. מתחברים למכונה הווירטואלית שבה רוצים להתקין את הדרייבר.

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

    sudo apt-get update
   

3. מחפשים את החבילה של מודול הליבה (kernel) של 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. אחרי האתחול מחדש, צריך לאפס את המשתנה NVIDIA_DRIVER_VERSION על ידי הפעלה מחדש של הפקודה שבה השתמשתם בשלב 3.

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.

    אחרי שמפעילים את האתחול המאובטח, צריך לחתום על כל מודולי הליבה כדי לטעון אותם. מודולים של ליבה (kernel) שנוצרו על ידי dkms לא פועלים ב-VM כי הם לא חתומים כראוי כברירת מחדל. השלב הזה אופציונלי, אבל הוא יכול לעזור למנוע התקנה בטעות של חבילות 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 שהותקנה.

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 581.42                 Driver Version: 581.42       CUDA Version: 12.8     |
|-----------------------------------------+----------------------+----------------------+
| 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      |
+---------------------------------------------------------------------------------------+