הפעלת יחידות GPU עם כמה מופעים במקביל

בדף הזה מוסבר איך להגדיל את רמת הניצול ולהפחית את העלויות באמצעות הפעלת כרטיסי GPU מרובי-מופע. בהגדרה הזו, מחלקים מעבד גרפי (GPU) מסוג NVIDIA GB200,‏ B200,‏ H200,‏ H100,‏ A100 או RTX PRO 6000 כדי לשתף GPU יחיד בין כמה קונטיינרים ב-Google Kubernetes Engine‏ (GKE).

לפני שקוראים את הדף הזה, חשוב להכיר מושגים ב-Kubernetes כמו Pods,‏ nodes,‏ deployments ו-namespaces, ומושגים ב-GKE כמו node pools,‏ autoscaling ו-auto-provisioning.

מבוא

‫Kubernetes מקצה GPU מלא אחד לכל קונטיינר, גם אם הקונטיינר צריך רק חלק מה-GPU בשביל עומס העבודה שלו. זה עלול להוביל לבזבוז משאבים ולחריגה מהתקציב, במיוחד אם אתם משתמשים ב-GPU מהדור האחרון. כדי לשפר את השימוש ב-GPU, מעבדי GPU עם כמה מופעים במקביל מאפשרים לחלק GPU נתמך יחיד לעד שבע פרוסות (slice). אפשר להקצות כל פרוסה למאגר אחד בצומת באופן עצמאי, עד שבעה מאגרים לכל GPU. יחידות GPU עם כמה מופעים מספקות בידוד חומרה בין עומסי העבודה, ואיכות שירות (QoS) עקבית וצפויה לכל הקונטיינרים שפועלים ב-GPU.

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

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

יחידות GPU נתמכות

סוגי ה-GPU הבאים תומכים ב-GPU מרובה מופעים:

• ‫NVIDIA GB200 (גרסה ‎1.33.0-gke.1636000 ואילך)
• ‫NVIDIA B200‏ (180GB) (גרסה ‎1.32.2-gke.1586000 ואילך)
• NVIDIA H200 (141GB)
• NVIDIA H100 (80GB)‎
• NVIDIA A100 (80GB)
• NVIDIA A100 (40GB)
• NVIDIA RTX PRO 6000
  • למחיצות ללא סיומות: 1.34.0-gke.1662000 ואילך
  • למחיצות עם סיומות:
    • ‫1.35 ואילך: 1.35.3-gke.1389000 ואילך
    • ‫1.34: 1.34.6-gke.1154000 ואילך

חלוקת GPU לכמה מופעים במקביל

כל אחד ממעבדי ה-GPU מסוג GB200,‏ B200,‏ H200,‏ H100 ו-A100 מורכב משבע יחידות מחשוב ושמונה יחידות זיכרון, שאפשר לחלק למקרים של GPU בגדלים שונים. כדי להגדיר את גודל המחיצות של ה-GPU, משתמשים בתחביר הבא: [compute]g.[memory]gb. לדוגמה, גודל מחיצה של GPU‏ 1g.5gb מתייחס למכונת GPU עם יחידת מחשוב אחת (שביעית ממעבדי הסטרימינג המרובים ב-GPU) ויחידת זיכרון אחת (5 GB). אפשר לציין את גודל המחיצה של ה-GPU כשפורסים עומס עבודה של Autopilot או כשיוצרים אשכול רגיל.

ב-NVIDIA RTX PRO 6000, ‏ GKE תומך בפרופילי MIG שמפורטים בטבלה עם הסיומות שמופיעות בה. מידע נוסף זמין במאמר בנושא פרופילי MIG של RTX PRO 6000 Blackwell.

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

בטבלה הבאה מפורטים גדלי המחיצות שנתמכים ב-GKE:

כל GPU בכל צומת במאגר הצמתים מחולק באותו אופן. לדוגמה, נניח שיש מאגר צמתים עם שני צמתים, ארבע יחידות GPU בכל צומת וגודל מחיצה של 1g.5gb. ‫GKE יוצר שבע מחיצות בגודל 1g.5gb בכל GPU. מכיוון שיש ארבע יחידות GPU בכל צומת, יש 28 1g.5gb מחיצות GPU זמינות בכל צומת. מכיוון שיש שני צמתים במאגר הצמתים, יש בסך הכול 56 1g.5gb מחיצות של יחידות GPU זמינות בכל מאגר הצמתים.

כדי ליצור אשכול GKE Standard עם יותר מסוג אחד של מחיצת GPU, צריך ליצור כמה מאגרי צמתים. לדוגמה, אם רוצים צמתים עם חלוקות GPU של 1g.5gb ו-3g.20gb באשכול, צריך ליצור שתי קבוצות של צמתים: אחת עם גודל חלוקת ה-GPU שמוגדר ל-1g.5gb, והשנייה עם 3g.20gb.

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

כל צומת מסומן בגודל של מחיצות ה-GPU שזמינות בצומת. התוויות האלה מאפשרות לעומסי עבודה לטרגט צמתים עם גודל המחיצה הנדרש של ה-GPU. לדוגמה, בצומת עם 1g.5gb מכונות GPU, התווית של הצומת היא:

cloud.google.com/gke-gpu-partition-size=1g.5gb

איך זה עובד

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

1. יצירת אשכול עם מעבדי GPU מרובי-מופעים מופעלים.
2. התקנה ידנית של מנהלי התקנים.
3. בודקים כמה משאבי GPU יש בצומת.
4. פריסת קונטיינרים באמצעות יחידות GPU עם כמה מופעים.

תמחור

יחידות GPU מרובות מופעים זמינות רק ביחידות GPU מסוג GB200,‏ B200,‏ H200,‏ H100,‏ A100 ו-RTX PRO 6000, והן כפופות לתמחור ה-GPU המתאים בנוסף לכל מוצר אחר שמשמש להפעלת עומסי העבודה. אפשר לצרף רק יחידות GPU שלמות לצמתים באשכול לצורך חלוקה למחיצות. למידע על תמחור של יחידות GPU, אפשר לעיין בדף תמחור של יחידות GPU.

מגבלות

• לא מומלץ להשתמש במחיצות GPU מרובות מופעים עם GKE לעומסי עבודה לא מהימנים.
• יש תמיכה מלאה בהרחבת משאבים אוטומטית ובהקצאת מחיצות GPU אוטומטית ב-GKE מגרסה 1.20.7-gke.400 ואילך. בגרסאות קודמות רק מאגרי צמתים עם צומת אחד לפחות יכולים להתרחב אוטומטית על סמך הביקוש לגדלים ספציפיים של מחיצות GPU מעומסי עבודה.
• מדדי השימוש ב-GPU (לדוגמה, duty_cycle) לא זמינים עבור יחידות GPU מרובות מופעים.
• ב-Multi-instance, מעבדי GPU פיזיים מחולקים למכונות נפרדות, שכל אחת מהן מבודדת מהאחרות ברמת החומרה. קונטיינר שמשתמש במופע GPU מרובה מופעים יכול לגשת רק למשאבי המעבד והזיכרון שזמינים למופע הזה.
• כל Pod יכול לצרוך עד מכונה אחת של GPU עם כמה מופעים במקביל.
• אי אפשר להפעיל מעבדי GPU מרובי-מכונות עם סוגי מכונות G4 שיש להם פחות מ-GPU אחד.

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

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

• מפעילים את ממשק Google Kubernetes Engine API.
הפעלת Google Kubernetes Engine API
• כדי להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז לאתחל את ה-CLI של gcloud. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שגרסאות קודמות של ה-CLI של gcloud לא יתמכו בהרצת הפקודות שמופיעות במסמך הזה.

• ב-Autopilot, יש תמיכה ב-GPU מרובה מופעים ב-GKE בגרסה 1.29.3-gke.1093000 ואילך.
• צריך לוודא שיש לכם מכסת GPU מסוג NVIDIA A100 מספקת. איך מבקשים להגדיל את המכסה
• אם רוצים להשתמש ב-GPU עם כמה מופעים במקביל ב-Autopilot, אפשר לקרוא מידע נוסף על שימוש ב-GPU עם Autopilot במאמר פריסת עומסי עבודה של GPU ב-Autopilot.
• ‫GKE מקצה את מחלקת המחשוב Accelerator לכל עומסי העבודה של GPU עם כמה מופעים במקביל באשכולות Autopilot.

יצירת אשכול עם הפעלת מעבדי GPU מרובי-מופעים

אם אתם משתמשים ב-GKE Standard, אתם צריכים להפעיל GPU מרובה מופעים באשכול. באשכולות Autopilot שמופעלת בהם גרסה 1.29.3-gke.1093000 ואילך, כרטיסי GPU מרובי-מופעים מופעלים כברירת מחדל. כדי להשתמש ביחידות GPU מרובות מופעים ב-Autopilot, אפשר לעיין בקטע פריסת קונטיינרים באמצעות יחידות GPU מרובות מופעים בדף הזה.

כשיוצרים אשכול רגיל עם מעבדי GPU מרובי-מכונות, צריך לציין את gpuPartitionSize יחד עם acceleratorType ו-acceleratorCount. הערך של acceleratorType חייב להיות אחד מהערכים הבאים:

• nvidia-gb200
• nvidia-b200
• nvidia-h200-141gb
• nvidia-h100-80gb
• nvidia-a100-80gb
• nvidia-tesla-a100
• nvidia-rtx-pro-6000

בדוגמה הבאה מוצג איך ליצור אשכול GKE עם צומת אחד ושבע מחיצות GPU בגודל 1g.5gb בצומת. בשלבים האחרים בדף הזה נעשה שימוש בגודל מחיצה של GPU של 1g.5gb, שיוצר שבע מחיצות בכל GPU. אפשר גם להשתמש בכל אחד מגודלי המחיצות הנתמכים של ה-GPU שצוינו קודם.

אפשר להשתמש ב-Google Cloud CLI או ב-Terraform.

gcloud container clusters create CLUSTER_NAME  \
    --project=PROJECT_ID  \
    --location CONTROL_PLANE_LOCATION  \
    --cluster-version=CLUSTER_VERSION  \
    --accelerator type=nvidia-tesla-a100,count=1,gpu-partition-size=1g.5gb,gpu-driver-version=DRIVER_VERSION  \
    --machine-type=a2-highgpu-1g  \
    --num-nodes=1

resource "google_container_cluster" "default" {
  name               = "gke-standard-zonal-gpu"
  location           = "us-central1-a"
  initial_node_count = 1

  node_config {
    guest_accelerator {
      type               = "nvidia-tesla-a100"
      count              = 1
      gpu_partition_size = "1g.5gb"
      gpu_driver_installation_config {
        gpu_driver_version = "LATEST"
      }
    }
    machine_type = "a2-highgpu-1g"
  }
}

התחברות לאשכול

מגדירים את kubectl להתחברות לאשכול שנוצר:

gcloud container clusters get-credentials CLUSTER_NAME

התקנת מנהלי התקנים

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

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

בודקים כמה משאבי GPU יש בצומת

מריצים את הפקודה הבאה כדי לוודא שהקיבולת והמספר של משאבי nvidia.com/gpu שניתן להקצות הם 7:

kubectl describe nodes

הפלט של הפקודה:

...
Capacity:
  ...
  nvidia.com/gpu:             7
Allocatable:
  ...
  nvidia.com/gpu:             7

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

אפשר לפרוס עד קונטיינר אחד לכל מכשיר GPU עם כמה מופעים במקביל בצומת. בדוגמה הזו, עם גודל מחיצה של 1g.5gb, יש שבע מחיצות GPU של כמה מופעים במקביל שזמינות בצומת. לכן אפשר לפרוס עד שבעה קונטיינרים שמבקשים מעבדי GPU בצומת הזה.

בדוגמה הבאה מופעל מאגר התגים cuda:11.0.3-base-ubi7 ומופעלת הפקודה nvidia-smi כדי להדפיס את ה-UUID של ה-GPU במאגר התגים. בדוגמה הזו יש שבעה מאגרי תגים, וכל מאגר תגים מקבל מחיצה אחת של GPU. בדוגמה הזו, גם בורר הצמתים cloud.google.com/gke-gpu-partition-size מוגדר לטרגוט צמתים עם מחיצות GPU‏ 1g.5gb.

1. שומרים את קובץ המניפסט לדוגמה הבא בשם cuda-simple.yaml:

   טייס אוטומטי

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: cuda-simple
   spec:
     replicas: 7
     selector:
       matchLabels:
         app: cuda-simple
     template:
       metadata:
         labels:
           app: cuda-simple
       spec:
         nodeSelector:
           cloud.google.com/gke-gpu-partition-size: 1g.5gb
           cloud.google.com/gke-accelerator: nvidia-tesla-a100
           cloud.google.com/gke-accelerator-count: "1"
         containers:
         - name: cuda-simple
           image: nvidia/cuda:11.0.3-base-ubi7
           command:
           - bash
           - -c
           - |
             /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
           resources:
             limits:
               nvidia.com/gpu: 1
         

   קובץ המניפסט הזה:

   • שליחת בקשה לסוג ה-GPU‏ nvidia-tesla-a100 על ידי הגדרת בורר הצמתים cloud.google.com/gke-accelerator.
   • פיצול ה-GPU לגודל המחיצה 1g.5gb.
   • מצרפים GPU יחיד לצומת על ידי הגדרת cloud.google.com/gke-accelerator-count node selector.

   רגילה

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: cuda-simple
   spec:
     replicas: 7
     selector:
       matchLabels:
         app: cuda-simple
     template:
       metadata:
         labels:
           app: cuda-simple
       spec:
         nodeSelector:
           cloud.google.com/gke-gpu-partition-size: 1g.5gb
         containers:
         - name: cuda-simple
           image: nvidia/cuda:11.0.3-base-ubi7
           command:
           - bash
           - -c
           - |
             /usr/local/nvidia/bin/nvidia-smi -L; sleep 300
           resources:
             limits:
               nvidia.com/gpu: 1
         

   קובץ המניפסט הזה:

   • בקשה ל-GPU יחיד עם גודל מחיצה של 1g.5gb.

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

   kubectl apply -f cuda-simple.yaml
   

3. מוודאים שכל שבעת ה-Pods פועלים:

   kubectl get pods
   

   הפלט של הפקודה:

   NAME                           READY   STATUS    RESTARTS   AGE
   cuda-simple-849c47f6f6-4twr2   1/1     Running   0          7s
   cuda-simple-849c47f6f6-8cjrb   1/1     Running   0          7s
   cuda-simple-849c47f6f6-cfp2s   1/1     Running   0          7s
   cuda-simple-849c47f6f6-dts6g   1/1     Running   0          7s
   cuda-simple-849c47f6f6-fk2bs   1/1     Running   0          7s
   cuda-simple-849c47f6f6-kcv52   1/1     Running   0          7s
   cuda-simple-849c47f6f6-pjljc   1/1     Running   0          7s
   

4. כדי לראות את ה-UUID של ה-GPU, מציגים את היומנים באמצעות השם של כל Pod מהפקודה הקודמת:

   kubectl logs cuda-simple-849c47f6f6-4twr2
   

   זה הפלט של הפקודה:

   GPU 0: A100-SXM4-40GB (UUID: GPU-45eafa61-be49-c331-f8a2-282736687ab1)
     MIG 1g.5gb Device 0: (UUID: MIG-GPU-45eafa61-be49-c331-f8a2-282736687ab1/11/0)
   

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

• מידע נוסף על יחידות GPU
• איך מגדירים שיתוף זמן במעבדים גרפיים
• מידע נוסף על ריבוי דיירים באשכול
• מידע נוסף על שיטות מומלצות לשימוש ב-multi-tenancy בארגונים