אתם יכולים להשתמש בהקצאת משאבים דינמית (DRA) כדי להקצות מעבדי GPU לעומסי העבודה שלכם ב-Google Kubernetes Engine (GKE). במאמר הזה מוסברים העקרונות הבסיסיים של DRA, איך משתמשים ב-DRA ב-GKE ומה היתרונות של השימוש ב-DRA.
המסמך הזה מיועד לבעלי התפקידים הבאים:
- מנהלי פלטפורמות שרוצים להפחית את המורכבות והתקורה של הגדרת תשתית עם מכשירי חומרה ייעודיים.
- מפעילי אפליקציות ומהנדסי מערכות מידע שמריצים עומסי עבודה כמו AI/ML או מחשוב עתיר ביצועים (HPC).
אתם צריכים להכיר את הנושאים הבאים:
מבוא ל-DRA
DRA היא תכונה מובנית ב-Kubernetes שמאפשרת לבקש, להקצות ולשתף חומרה באשכול בין קבוצות Pod וקונטיינרים. ה-DRA משפר את חוויית ההקצאה של חומרה מצורפת, כמו מאיצים, בכך שהוא מאפשר לספקי מכשירים ולמנהלי פלטפורמות להצהיר על מחלקות של מכשירים שאפשר לבקש ולהקצות. מפעילי אפליקציות יכולים לבקש הגדרות ספציפיות למכשירים במחלקות האלה, ואז לבקש את ההגדרות האלה בעומסי העבודה שלהם. Kubernetes ו-GKE מנהלים את תזמון ה-Pod, הקצאות הצמתים והקצאת המכשירים על סמך בקשות של עומסי עבודה.
לדוגמה, מנהל פלטפורמה יכול להגדיר סוג מכשיר שיש לו רק מעבדי GPU מסוג NVIDIA A100. מפעילי האפליקציות יכולים לסנן את המכשירים בקבוצת המכשירים הזו לפי דרישות עומס העבודה, למשל סינון לפי זיכרון GPU בנפח של 80GB לפחות. כשמפעיל האפליקציה פורס עומס עבודה שמבקש את ההגדרה המסוננת, GKE ממקם את ה-Pods בצמתים שעומדים בקריטריונים שנבחרו. בדוגמה הזו, GKE מוצא צמתים שיש בהם מעבדי GPU זמינים מסוג A100 (80GB). מפעיל האפליקציה לא צריך לבחור צמתים ספציפיים או תצורות מכשירים ספציפיות במניפסט של עומס העבודה.
היתרונות של DRA
בלי DRA, הקצאת מכשירי חומרה ב-Kubernetes מסתמכת על פלאגינים של מכשירים. כדי לצרף משאבי חומרה ל-Pods באמצעות פלאגינים של מכשירים, משתמשים בתוויות של צמתים כדי למקם Pods בצמתים ספציפיים. בנוסף, כדי להקצות את כל המשאבים של צומת לפוד אחד, צריך לבקש את המספר המדויק של המכשירים שמחוברים לצמתים.
עם DRA, הקצאת מכשירים ל-Pods דומה להקצאת אמצעי אחסון. אתם מגדירים סוגי מכשירים, מבקשים מכשירים מהסוגים האלה ואז מקצים את המכשירים שביקשתם לעומסי עבודה. ה-DRA מספק ממשק הרבה יותר גמיש לסינון מכשירים לפי עומס העבודה והצרכים העסקיים. לגישת ה-DRA, שבה משתמשים בביטויים ובתבניות כדי לתבוע חומרה ולתזמן Pods, יש את היתרונות הבאים:
- הקצאת מכשירים דקלרטיבית: מנהלי פלטפורמות יכולים להגדיר מכשירים לסוגים ספציפיים של עומסי עבודה או צוותים.
- הפחתת המורכבות בין הצוותים: כשאדמינים של פלטפורמות מקצים צמתים עם הגדרות חומרה מיוחדות, מפעילי האפליקציות לא צריכים לדעת לאילו צמתים יש הגדרות ספציפיות. מנהלי הפלטפורמה לא צריכים לתייג צמתים או להעביר מידע על צמתים ומכשירים ספציפיים למפעילים.
- פחות מורכבות למפתחים: Kubernetes מתזמן Pods על סמך הגדרת מכשיר הבדיקה הווירטואלי שאליו מפנים. מפעילי האפליקציות לא צריכים לבחור צמתים ספציפיים בעומסי העבודה שלהם, וגם לא צריכים לוודא שכל Pod מבקש בדיוק את מספר המכשירים שמחוברים לצמתים האלה.
- ניהול תשתית מרכזי: מנהלי פלטפורמה יכולים להגדיר באופן מרכזי הגדרות חומרה שעומדות בדרישות עסקיות ספציפיות. לדוגמה, מנהל פלטפורמה יכול להצהיר על הגדרה עם ביצועים גבוהים שכוללת מעבדי GPU מסוג H100, לצד הגדרה קטנה של הסקת מסקנות שכוללת מעבדי GPU מסוג Tesla T4.
- בחירת חומרה גמישה: אתם יכולים להשתמש בביטויי CEL כדי לסנן מכשירים עם מאפיינים ספציפיים. השימוש בביטויים מאפשר לסנן מכשירים שמתאימים לעומסי עבודה ספציפיים.
מתי כדאי להשתמש ב-DRA
הסיבה העיקרית לשימוש ב-DRA ב-GKE היא הגמישות שבה אפשר לבקש מכשירים לעומסי עבודה. אתם יכולים לכתוב מניפסט פעם אחת ולפרוס את עומס העבודה באשכולות שונים עם סוגי מכשירים שונים, בלי לשנות את המניפסט. הגמישות הזו אידיאלית לתרחישים לדוגמה כמו:
- שיפור הגמישות, היעילות והזמינות של קיבולת המחשוב של ה-GPU: לעומסי עבודה שצריכים גישה לחומרת GPU, אתם יכולים להשתמש ב-DRA כדי לבקש כל GPU זמין באשכול במקום לציין דגם GPU. אם לעומסי העבודה האלה יש דרישות ספציפיות לזיכרון GPU (VRAM), אתם יכולים לבקש כל GPU באשכול שיש לו כמות מינימלית של זיכרון. סוג כזה של בקשה גמישה מרחיב את קבוצת צומתי ה-GPU שעומס העבודה יכול לפעול בהם, וכך מפחית את הסיכון שעומס העבודה לא יתוזמן בגלל משאבים לא זמינים.
אופטימיזציה של זמינות הצמתים במהלך התאמה לעומס (scaling): כמות המכשירים שעומס העבודה דורש עשויה להשתנות בהתאם לגורמים כמו סוג המכשיר והיכולות שלו. אתם יכולים להשתמש ב-ComputeClasses של GKE כדי למקם פודים מואצים במאגרי צמתים ספציפיים, בהתאם לזמינות המכשירים. לאחר מכן תוכלו להגדיר את ה-Pods כך שידרשו את המכשירים בכל צומת ש-GKE ממקם בו את ה-Pods.
שימוש ב-DRA עם ComputeClasses מאפשר לכם לצמצם את הסיכון לעומסי עבודה לא מתוזמנים, וגם עוזר לכם להריץ עומסי עבודה בחומרה שעברה אופטימיזציה.
הסברים על המונחים
ב-Kubernetes בקוד פתוח ובספקי Kubernetes מנוהלים כמו GKE, משתמשים בסוגים הבאים של ממשקי API ל-DRA:
- ResourceSlice
- ResourceSlice מפרט מכשיר חומרה אחד או יותר באשכול שהצמתים יכולים לגשת אליהם. לדוגמה, בצומת שיכול לגשת ל-GPU יחיד, ב-ResourceSlice מופיעים ה-GPU ושם הצומת. מנהלי ההתקנים של DRA בכל צומת יוצרים ResourceSlices. המתזמן של Kubernetes משתמש ב-ResourceSlices כדי להחליט אילו מכשירים להקצות כדי לענות על בקשות של עומסי עבודה.
- DeviceClass
-
DeviceClass מגדיר קטגוריה של מכשירים, כמו מעבדים גרפיים, שאפשר לבקש לעומסי עבודה.
חלק ממנהלי ההתקנים מספקים DeviceClasses מובנים, כמו
gpu.nvidia.comDeviceClass למעבדי GPU של NVIDIA. מנהלי פלטפורמה יכולים גם ליצור DeviceClasses בהתאמה אישית שמגדירים תצורות ספציפיות של מכשירים. - ResourceClaim
-
בעזרת ResourceClaim, פוד או משתמש יכולים לבקש משאבי חומרה על ידי סינון לפי פרמטרים מסוימים ב-DeviceClass. כשעומס עבודה מפנה ל-ResourceClaim, Kubernetes מקצה מכשירים שתואמים לפרמטרים שצוינו ל-ResourceClaim הזה.
לדוגמה, נניח שאתם יוצרים ResourceClaim ל-GPU אחד מסוג A100 (40GB) ואז פורסים עומס עבודה שבוחר את ה-ResourceClaim הזה. Kubernetes מקצה GPU זמין מסוג A100 (40GB) ל-ResourceClaim ומתזמן את ה-Pod בצומת שיכול לגשת ל-GPU הזה.
- ResourceClaimTemplate
-
ResourceClaimTemplate מגדיר תבנית שפודים יכולים להשתמש בה כדי ליצור באופן אוטומטי ResourceClaims חדשים לכל פוד. התבניות האלה שימושיות כשיש כמה עומסי עבודה שצריכים גישה להגדרות דומות של מכשירים, במיוחד כשמשתמשים בבקר של עומסי עבודה כמו Deployments או StatefulSets.
מפעילי האפליקציות פורסים את ResourceClaimTemplates ואז מפנים לתבניות בעומסי העבודה. Kubernetes יוצר ResourceClaims לכל Pod על סמך התבנית שצוינה, מקצה מכשירים ומתזמן את ה-Pods. כשה-Pods מסתיימים, Kubernetes מנקה את ה-ResourceClaims התואמים.
מידע נוסף על סוגי ה-API של DRA זמין במאמר טרמינולוגיה של DRA.
איך פועלת התכונה "הקצאת משאבים דינמית" (DRA)
השימוש ב-DRA באשכולות ובעומסי העבודה דומה לשימוש ב-StorageClasses, ב-PersistentVolumeClaims וב-PersistentVolumes כדי להקצות נפחים באופן דינמי לפודים.
בתרשים הבא מוצגים השלבים שמנהלי אשכולות ומפעילי אפליקציות מבצעים כדי להקצות מכשירים באמצעות DRA:
בתרשים הזה, מנהלי האשכולות ומפעילי האפליקציות מבצעים את הפעולות הבאות:
- מנהלי אשכולות מתקינים מנהלי התקנים שתומכים ב-DRA בצמתים.
- מנהלי אשכולות יוצרים DeviceClasses שמסננים חומרה שעומדת בדרישות ספציפיות, כמו כל ה-GPU עם יותר מ-40GB זיכרון. יכול להיות שחלק מהמכשירים יכללו גם DeviceClasses מובנים.
- מפעילי אפליקציות יוצרים ResourceClaimTemplates או ResourceClaims שמבקשים הגדרות מכשיר. תרחיש השימוש העיקרי לכל סוג של טענה הוא:
- ResourceClaim מאפשר לכמה Pods לשתף גישה לאותו מכשיר.
- ResourceClaimTemplate מאפשר לכמה Pods לגשת למכשירים נפרדים ודומים על ידי יצירה אוטומטית של ResourceClaims לכל Pod.
- מפעילי האפליקציות מוסיפים את ResourceClaimTemplates או את ResourceClaims למניפסטים של עומסי העבודה שלהם.
- מפעילי האפליקציה פורסים את עומס העבודה.
כשפורסים עומס עבודה שמפנה ל-ResourceClaimTemplate או ל-ResourceClaim, Kubernetes מבצע את שלבי התזמון הבאים:
- אם עומס העבודה מפנה אל ResourceClaimTemplate, Kubernetes יוצר אובייקט
ResourceClaimחדש לכל מופע של עומס העבודה (לדוגמה, כל רפליקה ב-Deployment). - המתזמן של Kubernetes משתמש ב-ResourceSlices באשכול כדי להקצות מכשירים זמינים שעומדים בדרישות ל-ResourceClaim של כל Pod.
- המתזמן ממקם כל Pod בצומת שיש לו גישה למכשירים שהוקצו ל-ResourceClaim של ה-Pod.
- ה-
kubeletבצומת היעד קורא למנהל ההתקן של ה-DRA בצומת כדי לצרף את החומרה שהוקצתה ל-Pod, כדי למלא את בקשת המשאבים שלו.
מתי להשתמש ב-ResourceClaims וב-ResourceClaimTemplates
אתם יכולים להשתמש ב-ResourceClaims או ב-ResourceClaimTemplates כדי לציין ל-Kubernetes שאתם רוצים מכשירים שעומדים בדרישות ספציפיות. כשמפנים ל-ResourceClaim ב-Pod, Kubernetes מקצה מכשירים למשאב ה-API המתאים של ResourceClaim בשרת ה-API של Kubernetes. ההקצאה הזו מתבצעת גם אם אתם יצרתם את ה-ResourceClaim וגם אם Kubernetes יצר את ה-ResourceClaim מ-ResourceClaimTemplate.
אם יוצרים ResourceClaim ואז מפנים אליו בכמה Pods, כל ה-Pods האלה יכולים לגשת למכשירים ש-Kubernetes מקצה ל-ResourceClaim הזה. לדוגמה, הגישה המשותפת הזו יכולה לקרות אם אתם מפנים ל-ResourceClaim ספציפי במניפסט של פריסה שיש לה כמה רפליקות. עם זאת, אם המכשירים שהוקצו לא מוגדרים לשיתוף על ידי כמה תהליכים, הגישה המשותפת הזו למכשירים בין Pods עלולה לגרום להתנהגות לא מכוונת.
כדי להקצות מכשירים נפרדים ל-Pods, אפשר להשתמש ב-ResourceClaimTemplate, שהיא תבנית ש-Kubernetes משתמש בה כדי ליצור באופן אוטומטי ResourceClaims נפרדים. לדוגמה, אם מפנים ל-ResourceClaimTemplate ב-Deployment שיש לו כמה רפליקות, Kubernetes יוצר ResourceClaim נפרד לכל Pod משוכפל. כתוצאה מכך, כל Pod מקבל מכשיר משלו במקום לשתף את הגישה למכשיר עם Pods אחרים. ה-ResourceClaims שנוצרים אוטומטית קשורים למשך החיים של ה-Pod התואם, ונמחקים כשה-Pod מסתיים. אם יש לכם Pods עצמאיים שצריכים גישה להגדרות דומות של מכשירים, אתם יכולים להשתמש ב-ResourceClaimTemplate כדי להקצות מכשירים לכל Pod בנפרד.
בטבלה הבאה מתוארים כמה הבדלים בין יצירה ידנית של ResourceClaims לבין יצירה של ResourceClaims על ידי Kubernetes מ-ResourceClaimTemplate:
| ResourceClaims שנוצרו באופן ידני | תלונות על הפרת זכויות יוצרים במשאבים שנוצרו באופן אוטומטי |
|---|---|
| בניהול שלך | מנוהל על ידי Kubernetes |
| מאפשרת גישה לאותם מכשירים מכמה Pods | נותן גישה למכשירים מ-Pod אחד |
| קיים באשכול באופן עצמאי, בלי קשר ל-Pods | קשור למחזור החיים של ה-Pod התואם |
| מתאים לכמה עומסי עבודה שצריכים לשתף מכשיר ספציפי | מתאים לכמה עומסי עבודה שצריכים גישה נפרדת למכשירים |
השוואה בין DRA לבין הקצאת מכשירים ידנית
הקצאת מכשירים מחוברים באמצעות DRA דומה להקצאה דינמית של PersistentVolumes. ב-Kubernetes אפשר גם להקצות מכשירים באמצעות יישומי פלאגין למכשירים. השיטה הזו כוללת את השלבים הבאים:
- מנהל אשכול יוצר צמתים שמחוברים אליהם מכשירים, כמו מעבדים גרפיים.
- מנהל האשכול מעביר מידע על צמתים ספציפיים והמכשירים שמחוברים אליהם למפעילי עומסי העבודה.
- מפעיל של עומס עבודה מבקש מכשירים במניפסט של עומס העבודה באופן הבא:
- בוחרים צומת עם תצורת המכשיר הנדרשת, כמו מודל ה-GPU, באמצעות השדה
nodeSelector. - מציינים את מספר המכשירים המדויק שהקונטיינרים יצרכו באמצעות השדה
resourcesבמפרט ה-Pod.
- בוחרים צומת עם תצורת המכשיר הנדרשת, כמו מודל ה-GPU, באמצעות השדה
בשיטת ההקצאה הידנית הזו, מפעילי האפליקציות ומנהלי האשכולות צריכים לתקשר ביניהם לגבי הצמתים או מאגרי הצמתים הספציפיים שיש להם הגדרות מכשיר מסוימות. הם צריכים לתאם את הבקשות לעומסי עבודה כך שיתאימו למכשירים בצמתים, אחרת הפריסה תיכשל. לעומת זאת, ב-DRA אפשר להשתמש בביטויים כדי לסנן מכשירים בצורה גמישה על סמך מאפיינים, ומפעילי עומסי העבודה לא צריכים לדעת את ההגדרות המדויקות של הצמתים באשכול.
בטבלה הבאה מוצגת השוואה בין DRA לבין פלאגינים של מכשירים:
| DRA | הקצאה ידנית |
|---|---|
| בחירת מכשירים גמישה באמצעות ביטויי CEL | בחירת צומת ספציפי באמצעות בוררים ובקשות משאבים |
| החלטות תזמון שמתקבלות על ידי Kubernetes | החלטות לגבי תזמון שהמפעיל מקבל באמצעות בוררי צמתים |
| סינון המכשירים נפרד מיצירת עומס העבודה | צריך לבצע סינון מכשירים במניפסט של עומס העבודה |
| סינון מכשירים מרוכז וכיתות לפי צרכים, בניהול של מנהלי הפלטפורמה | סינון מכשירים מבודדים לפי מפעילי אפליקציות |
| מפעילי האפליקציה לא צריכים לדעת את קיבולת הצומת, את פרטי התווית של הצומת או את דגמי המכשירים המחוברים לכל צומת | מפעילי אפליקציות צריכים לדעת לאילו צמתים מחוברים דגמים ספציפיים וכמויות מסוימות של מכשירים מסוימים. |
DRA והתאמה לעומס (autoscaling) של התשתית
כדי לשנות באופן אוטומטי את מספר הצמתים במאגר צמתים במצב Standard, משתמשים ב-Cluster Autoscaler. אתם יכולים להפעיל את המידרוג האוטומטי של האשכול בכל מאגר צמתים שנוצר באופן ידני, כולל מאגרי צמתים עם מנהלי התקנים של DRA.
במאגרי צמתים שמשתמשים ב-DRA, ניצול המכשירים משפיע על האופן שבו המידרוג האוטומטי של האשכול מוסיף ומסיר צמתים במאגר צמתים. כדי לחשב את ניצול המכשירים במאגר צמתים, הכלי Cluster Autoscaler מתחשב בגורמים הבאים:
- כל המכשירים במאגר משאבים צריכים להיות מקומיים לצומת ספציפי. אם ל-ResourceSlice יש מאגר של מכשירים שמחוברים לכמה צמתים, הכלי להתאמה אוטומטית של קנה המידה של האשכול מתעלם מהמכשירים האלה.
- כל המכשירים במאגר הצמתים חשובים באותה מידה והם זהים.
- למכשירי DRA יש עדיפות גבוהה יותר מאשר למעבד (CPU) או לזיכרון. במאגרי צמתים של DRA, המידרוג האוטומטי של האשכול מתעלם מהשימוש במעבד ובזיכרון.
הגורמים האלה יכולים להוביל להתנהגות שונה של צמצום אנכית בהתאם לעומס במאגרי צמתים של DRA, בהשוואה למאגרי צמתים אחרים.
מכשירי GKE שנתמכים ב-DRA
בטבלה הבאה מתוארים המכשירים שאפשר להקצות לעומסי עבודה באמצעות DRA ב-GKE:
| סוג המכשיר | תיאור |
|---|---|
| מעבדי GPU | כל סוג GPU שזמין במיקום שלכם. מידע נוסף זמין במאמר מיקומי GPU. |
| ממשקי רשת | סוגים שונים של ממשקי רשת, כמו ממשקים שתומכים ב-RDMA, באמצעות התקנה של מנהל ההתקן המנוהל של DRANET. מידע נוסף זמין במאמר הקצאת משאבי רשת באמצעות DRANET בניהול GKE. |
מגבלות
המגבלות הבאות חלות כשמשתמשים ב-DRA:
מצב הפעולה: DRA זמין רק באשכולות במצב רגיל.
סוג המאיץ: DRA ב-GKE תומך רק במעבדים גרפיים.
מעבדים גרפיים:
- אי אפשר להשתמש במעבדי GPU עם שיתוף זמן, במעבדי GPU עם כמה מופעים במקביל או ב-Multi-Process Service (MPS).
- בצמתים שמשתמשים במנהלי ההתקנים של DRA GPU, אי אפשר להשתמש בחבילת המדדים המנוהלת של NVIDIA Data Center GPU Manager (DCGM) כדי לשלוח מדדי DCGM ל-Cloud Monitoring.
- מנהל ההתקן של ה-GPU ל-DRA הוא בבעלות NVIDIA, ולא בבעלות GKE. למידע נוסף, עיינו במסמכי התיעוד של NVIDIA.
ממשקי רשת: ראו מגבלות במאמר "הקצאת משאבי רשת באמצעות DRANET בניהול GKE".
התאמה אוטומטית לעומס:
- אם אתם מתקינים מנהלי התקנים של DRA של צד שלישי, כדי להשתמש ב-cluster autoscaler צריך שבמאגרי הצמתים יהיה לפחות צומת אחד. כדי למנוע ממאגרי צמתים שמשתמשים במנהלי התקנים של צד שלישי לצמצם את הפעולה לאפס צמתים, צריך להגדיר את המספר המינימלי של צמתים ל-
1לפחות. - יכול להיות שהמידרוג האוטומטי של האשכול לא יפעל כמו שצריך עם מנהלי התקנים של DRA של צד שלישי. אם אתם משתמשים במנהלי התקנים של צד שלישי, ודאו שהם מפרסמים מידע רק על מכשירים מקומיים לצמתים ספציפיים.
- ב-DaemonSets במאגרי צמתים עם התאמה אוטומטית לעומס שמשתמשים ב-ResourceClaim סטטי כדי לשתף גישה למכשירים בין Pods, ההתאמה האוטומטית לעומס תומכת בעד 128 Pods של DaemonSet. כדי למנוע את ההגבלה הזו, נסו אחד מהפתרונות הבאים:
- כדי למנוע ממאגר הצמתים להתאים את הגודל ליותר מ-128 צמתים, מגדירים את המספר המקסימלי של צמתים.
- משתמשים בשדה
adminAccess(בטא) ב-ResourceClaim, שמאפשר ל-DaemonSet לגשת למכשירים שנמצאים בשימוש.
- אם ה-Pods מפנים ל-ResourceClaims ויש להם PriorityClass שמגדיר את מדיניות ההפקעה ל-
PreemptLowerPriority, זמן האחזור של ההתאמה האוטומטית לעומס עשוי לגדול.PreemptLowerPriorityהיא מדיניות ברירת המחדל להפקעת משאבים של PriorityClass, לכן ודאו שהשדהpreemptionPolicyשל PriorityClasses מוגדר במפורש ל-Never. מידע נוסף מופיע במאמר Non-preempting PriorityClass.
- אם אתם מתקינים מנהלי התקנים של DRA של צד שלישי, כדי להשתמש ב-cluster autoscaler צריך שבמאגרי הצמתים יהיה לפחות צומת אחד. כדי למנוע ממאגרי צמתים שמשתמשים במנהלי התקנים של צד שלישי לצמצם את הפעולה לאפס צמתים, צריך להגדיר את המספר המינימלי של צמתים ל-
מיומנויות מומלצות להבנה ולשימוש ב-DRA
בקטע הזה מפורטות המלצות לאדמינים של פלטפורמות או למפעילי אפליקציות שרוצים להשתמש ב-DRA כדי להקצות מכשירים לעומסי עבודה. הקצאת משאבים דינמית משנה באופן משמעותי את השיטה שבה מבקשים מכשירים מחוברים, גם ב-GKE וגם ב-Kubernetes. כדי ליהנות מתרחישי שימוש מתקדמים יותר, כמו חלופה בין מכשירים או סינון ובחירה של מכשירים ברמה מפורטת, כדאי לפעול לפי ההנחיות הבאות:
למידת CEL: באמצעות DRA, אתם יכולים להשתמש בביטויי CEL כדי לבצע סינון מפורט של מכשירים בבקשות להקצאת משאבים וב-DeviceClasses. מקורות המידע הבאים יכולים לעזור לכם ללמוד את CEL:
מידע על ComputeClasses ב-GKE: אתם יכולים להשתמש ב-ComputeClasses עם DRA כדי לענות על צרכים עסקיים, כמו הקצאת מכונות וירטואליות במודל Spot להרצת עומסי עבודה של הסקת מסקנות שמבקשים מעבדים גרפיים חסכוניים. במקורות המידע הבאים מוסבר על ComputeClasses: