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

טייס אוטומטי רגילה

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

לפני שקוראים את הדף הזה, חשוב להכיר מושגים ב-Kubernetes כמו Pods,‏ nodes,‏ deployments ו-namespaces, ומושגים ב-GKE כמו מאגרי צמתים,‏ התאמה אוטומטית לעומס ו-הקצאת משאבים אוטומטית.

מבוא

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

במקרה של אפליקציות CUDA®‎, מעבדי GPU עם כמה מופעים הם ברוב המקרים שקופים. כל מחיצת 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 מסוג NVIDIA GB200,‏ B200,‏ H200 או H100 באמצעות מעבדי GPU מרובי-מופעים, אי אפשר להשתמש בטכנולוגיות GPUDirect (כולל TCPX,‏ TCPXO ו-RDMA).

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

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

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

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

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

גודל המחיצה	מכונות וירטואליות עם GPU
GPU: NVIDIA GB200 (nvidia-gb200)
1g.23gb	7
1g.47gb	4
2g.47gb	3
3g.93gb	2
4g.93gb	1
7g.186gb	1
מעבד גרפי (GPU): NVIDIA B200 ‏(nvidia-b200)
1g.23gb	7
1g.45gb	4
2g.45gb	3
3g.90gb	2
4g.90gb	1
7g.180gb	1
מעבד גרפי (GPU): NVIDIA H200 (141GB) (nvidia-h200-141gb)
1g.18gb	7
1g.35gb	4
2g.35gb	3
3g.71gb	2
4g.71gb	1
7g.141gb	1
‫GPU: ‏NVIDIA H100 (80GB) (nvidia-h100-80gb ו-nvidia-h100-mega-80gb)
1g.10gb	7
1g.20gb	4
2g.20gb	3
3g.40gb	2
7g.80gb	1
GPU: NVIDIA A100 (80GB) (nvidia-a100-80gb)
1g.10gb	7
2g.20gb	3
3g.40gb	2
7g.80gb	1
GPU: NVIDIA A100 (40GB) (nvidia-tesla-a100)
1g.5gb	7
2g.10gb	3
3g.20gb	2
7g.40gb	1
‫GPU: ‏NVIDIA RTX PRO 6000‏ (nvidia-rtx-pro-6000)
1g.24gb	4
1g.24gb.me	1
1g.24gb.gfx	4
1g.24gb.me.all	1
1g.24gb-me	4
2g.48gb	2
2g.48gb.gfx	2
2g.48gb.me.all	1
2g.48gb-me	2
4g.96gb	1
4g.96gb.gfx	1

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

כדי ליצור אשכול GKE Standard עם יותר מסוג אחד של מחיצת GPU, צריך ליצור כמה מאגרי צמתים. לדוגמה, אם רוצים צמתים עם מחיצות GPU בגודל 1g.5gb ו-3g.20gb באשכול, צריך ליצור שני מאגרי צמתים: אחד עם מחיצת GPU בגודל 1g.5gb והשני עם מחיצת GPU בגודל 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 לעומסי עבודה לא מהימנים.
• יש תמיכה מלאה בהתאמה אוטומטית לעומס (autoscaling) ובהקצאת משאבים אוטומטית של מחיצות GPU ב-GKE מגרסה 1.20.7-gke.400 ואילך. בגרסאות קודמות, רק מאגרי צמתים עם צומת אחד לפחות יכולים לעבור התאמה אוטומטית לעומס (automatic scaling) על סמך הביקוש לגדלים ספציפיים של מחיצות GPU מעומסי עבודה.
• מדדי השימוש ב-GPU (לדוגמה, duty_cycle) לא זמינים עבור יחידות GPU מרובות מופעים.
• ב-Multi-instance, מעבדי GPU פיזיים מחולקים למכונות נפרדות, שכל אחת מהן מבודדת מהאחרות ברמת החומרה. קונטיינר שמשתמש במכונה של GPU עם כמה מופעים במקביל יכול לגשת רק למשאבי המעבד (CPU) והזיכרון שזמינים לאותה מכונה.
• כל Pod יכול לצרוך רק מופע אחד של GPU עם כמה מופעים במקביל.
• אי אפשר להריץ GPU עם כמה מופעים במקביל עם סוגי מכונות G4 שיש להן פחות מ-GPU אחד.

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

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

• מפעילים את ממשק ה-API של Google Kubernetes Engine.
הפעלת Google Kubernetes Engine API
• כדי להשתמש ב-CLI של Google Cloud למשימה הזו, צריך להתקין ואז לאתחל את ה-CLI של gcloud. אם התקנתם בעבר את ה-CLI של gcloud, מריצים את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שבגרסאות קודמות של ה-CLI של gcloud אי אפשר להריץ את הפקודות שבמסמך הזה.
  הערה: אם ה-CLI של gcloud כבר מותקן, צריך להגדיר את המאפיין compute/region. אם אתם משתמשים בעיקר באשכולות אזוריים, הגדירו במקום זאת את compute/zone. אם מגדירים מיקום ברירת מחדל, אפשר להימנע משגיאות ב-CLI של gcloud כמו One of [--zone, --region] must be supplied: Please specify location. יכול להיות שתצטרכו לציין את המיקום בפקודות מסוימות אם המיקום של האשכול שונה מברירת המחדל שהגדרתם.

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

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

אם אתם משתמשים ב-GKE Standard, אתם צריכים להפעיל באשכול מעבדי GPU עם כמה מופעים במקביל. באשכולות Autopilot, כברירת מחדל מופעלים מעבדים גרפיים עם כמה מופעים במקביל. כדי להשתמש ב-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

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

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

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

• ‫CLUSTER_NAME: השם של האשכול החדש.
• ‫PROJECT_ID: מזהה הפרויקט ב- Google Cloud .
• ‫CONTROL_PLANE_LOCATION: המיקום של מישור הבקרה של האשכול ב-Compute Engine. באשכולות אזוריים צריך לציין אזור, ובאשכולות של תחומים צריך לציין תחום.
• ‫CLUSTER_VERSION: הגרסה חייבת להיות 1.19.7-gke.2503 או גרסה חדשה יותר.
• ‫DRIVER_VERSION: גרסת הדרייבר של NVIDIA להתקנה. יכול להיות אחת מהאפשרויות הבאות:
  • ‫default: התקנת גרסת ברירת המחדל של הדרייבר לגרסת GKE.
  • ‫latest: התקנת גרסת הדרייבר העדכנית ביותר שזמינה לגרסת GKE שלכם. זמין רק לצמתים שמשתמשים במערכת הפעלה שמותאמת לקונטיינרים.
  • ‫disabled: דילוג על התקנה אוטומטית של מנהל ההתקן. חובה להתקין מנהל התקן באופן ידני אחרי שיוצרים את האשכול. אם לא מציינים את gpu-driver-version, זו האפשרות שמוגדרת כברירת מחדל.

Terraform

כדי ליצור אשכול עם כרטיסי GPU מרובים שמופעלים באמצעות Terraform, אפשר לעיין בדוגמה הבאה:

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"
  }
}

מידע נוסף על שימוש ב-Terraform זמין במאמר תמיכה ב-Terraform ב-GKE.

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

מגדירים את 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 בצומת הזה.

זהירות: אם צומתי GKE כוללים גם צומתי GPU עם כמה מופעים במקביל וגם צומתי GPU בלי כמה מופעים במקביל, צריך להשתמש בהעדפה שלילית לצומת בפודים שלא צריכים GPU עם כמה מופעים במקביל. התכונה Node anti-affinity עוזרת לוודא שה-Pods האלה לא ינחתו בטעות בצמתים עם GPU מרובה מופעים.

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

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.

   רגילה

   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
• איך מגדירים שיתוף זמן במעבדים גרפיים
• מידע נוסף על ריבוי דיירים באשכול
• מידע נוסף על שיטות מומלצות לריבוי דיירים בארגון