מידע על הקצאת משאבים דינמית ב-GKE

אתם יכולים להשתמש בהקצאת משאבים דינמית (DRA) כדי להקצות מעבדי GPU לעומסי העבודה שלכם ב-Google Kubernetes Engine ‏(GKE). במאמר הזה מוסברים העקרונות הבסיסיים של DRA, איך משתמשים ב-DRA ב-GKE ומה היתרונות של השימוש ב-DRA.

המסמך הזה מיועד לבעלי התפקידים הבאים:

אתם צריכים להכיר את הנושאים הבאים:

מבוא ל-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.com DeviceClass למעבדי 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:

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

  1. מנהלי אשכולות מתקינים מנהלי התקנים שתומכים ב-DRA בצמתים.
  2. מנהלי אשכולות יוצרים DeviceClasses שמסננים חומרה שעומדת בדרישות ספציפיות, כמו כל ה-GPU עם יותר מ-40GB זיכרון. יכול להיות שחלק מהמכשירים יכללו גם DeviceClasses מובנים.
  3. מפעילי אפליקציות יוצרים ResourceClaimTemplates או ResourceClaims שמבקשים הגדרות מכשיר. תרחיש השימוש העיקרי לכל סוג של טענה הוא:
    • ‫ResourceClaim מאפשר לכמה Pods לשתף גישה לאותו מכשיר.
    • ‫ResourceClaimTemplate מאפשר לכמה Pods לגשת למכשירים נפרדים ודומים על ידי יצירה אוטומטית של ResourceClaims לכל Pod.
  4. מפעילי האפליקציות מוסיפים את ResourceClaimTemplates או את ResourceClaims למניפסטים של עומסי העבודה שלהם.
  5. מפעילי האפליקציה פורסים את עומס העבודה.

כשפורסים עומס עבודה שמפנה ל-ResourceClaimTemplate או ל-ResourceClaim, ‏ Kubernetes מבצע את שלבי התזמון הבאים:

  1. אם עומס העבודה מפנה אל ResourceClaimTemplate, ‏ Kubernetes יוצר אובייקט ResourceClaim חדש לכל מופע של עומס העבודה (לדוגמה, כל רפליקה ב-Deployment).
  2. המתזמן של Kubernetes משתמש ב-ResourceSlices באשכול כדי להקצות מכשירים זמינים שעומדים בדרישות ל-ResourceClaim של כל Pod.
  3. המתזמן ממקם כל Pod בצומת שיש לו גישה למכשירים שהוקצו ל-ResourceClaim של ה-Pod.
  4. ה-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 לבין ResourceClaimTemplates
‫ResourceClaims שנוצרו באופן ידני תלונות על הפרת זכויות יוצרים במשאבים שנוצרו באופן אוטומטי
בניהול שלך מנוהל על ידי Kubernetes
מאפשרת גישה לאותם מכשירים מכמה Pods נותן גישה למכשירים מ-Pod אחד
קיים באשכול באופן עצמאי, בלי קשר ל-Pods קשור למחזור החיים של ה-Pod התואם
מתאים לכמה עומסי עבודה שצריכים לשתף מכשיר ספציפי מתאים לכמה עומסי עבודה שצריכים גישה נפרדת למכשירים

השוואה בין DRA לבין הקצאת מכשירים ידנית

הקצאת מכשירים מחוברים באמצעות DRA דומה להקצאה דינמית של PersistentVolumes. ב-Kubernetes אפשר גם להקצות מכשירים באמצעות יישומי פלאגין למכשירים. השיטה הזו כוללת את השלבים הבאים:

  1. מנהל אשכול יוצר צמתים שמחוברים אליהם מכשירים, כמו מעבדים גרפיים.
  2. מנהל האשכול מעביר מידע על צמתים ספציפיים והמכשירים שמחוברים אליהם למפעילי עומסי העבודה.
  3. מפעיל של עומס עבודה מבקש מכשירים במניפסט של עומס העבודה באופן הבא:
    • בוחרים צומת עם תצורת המכשיר הנדרשת, כמו מודל ה-GPU, באמצעות השדה nodeSelector.
    • מציינים את מספר המכשירים המדויק שהקונטיינרים יצרכו באמצעות השדה resources במפרט ה-Pod.

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

בטבלה הבאה מוצגת השוואה בין DRA לבין פלאגינים של מכשירים:

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

‫DRA והתאמה לעומס (autoscaling) של התשתית

כדי לשנות באופן אוטומטי את מספר הצמתים במאגר צמתים במצב Standard, משתמשים ב-Cluster Autoscaler. אתם יכולים להפעיל את המידרוג האוטומטי של האשכול בכל מאגר צמתים שנוצר באופן ידני, כולל מאגרי צמתים עם מנהלי התקנים של DRA.

במאגרי צמתים שמשתמשים ב-DRA, ניצול המכשירים משפיע על האופן שבו המידרוג האוטומטי של האשכול מוסיף ומסיר צמתים במאגר צמתים. כדי לחשב את ניצול המכשירים במאגר צמתים, הכלי Cluster Autoscaler מתחשב בגורמים הבאים:

  • כל המכשירים במאגר משאבים צריכים להיות מקומיים לצומת ספציפי. אם ל-ResourceSlice יש מאגר של מכשירים שמחוברים לכמה צמתים, הכלי להתאמה אוטומטית של קנה המידה של האשכול מתעלם מהמכשירים האלה.
  • כל המכשירים במאגר הצמתים חשובים באותה מידה והם זהים.
  • למכשירי DRA יש עדיפות גבוהה יותר מאשר למעבד (CPU) או לזיכרון. במאגרי צמתים של DRA, המידרוג האוטומטי של האשכול מתעלם מהשימוש במעבד ובזיכרון.

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

מכשירי GKE שנתמכים ב-DRA

בטבלה הבאה מתוארים המכשירים שאפשר להקצות לעומסי עבודה באמצעות DRA ב-GKE:

מכשירים נתמכים ל-DRA ב-GKE
סוג המכשיר תיאור
מעבדי GPU כל סוג GPU שזמין במיקום שלכם. מידע נוסף זמין במאמר מיקומי GPU.
ממשקי רשת סוגים שונים של ממשקי רשת, כמו ממשקים שתומכים ב-RDMA, באמצעות התקנה של מנהל ההתקן המנוהל של DRANET. מידע נוסף זמין במאמר הקצאת משאבי רשת באמצעות DRANET בניהול GKE.

מגבלות

המגבלות הבאות חלות כשמשתמשים ב-DRA:

  • מצב הפעולה: DRA זמין רק באשכולות במצב רגיל.

  • סוג המאיץ: DRA ב-GKE תומך רק במעבדים גרפיים.

  • מעבדים גרפיים:

  • ממשקי רשת: ראו מגבלות במאמר "הקצאת משאבי רשת באמצעות DRANET בניהול GKE".

  • התאמה אוטומטית לעומס:

    • אם אתם מתקינים מנהלי התקנים של DRA של צד שלישי, כדי להשתמש ב-cluster autoscaler צריך שבמאגרי הצמתים יהיה לפחות צומת אחד. כדי למנוע ממאגרי צמתים שמשתמשים במנהלי התקנים של צד שלישי לצמצם את הפעולה לאפס צמתים, צריך להגדיר את המספר המינימלי של צמתים ל-1 לפחות.
    • יכול להיות שהמידרוג האוטומטי של האשכול לא יפעל כמו שצריך עם מנהלי התקנים של DRA של צד שלישי. אם אתם משתמשים במנהלי התקנים של צד שלישי, ודאו שהם מפרסמים מידע רק על מכשירים מקומיים לצמתים ספציפיים.
    • ב-DaemonSets במאגרי צמתים עם התאמה אוטומטית לעומס שמשתמשים ב-ResourceClaim סטטי כדי לשתף גישה למכשירים בין Pods, ההתאמה האוטומטית לעומס תומכת בעד 128 Pods של DaemonSet. כדי למנוע את ההגבלה הזו, נסו אחד מהפתרונות הבאים:
    • אם ה-Pods מפנים ל-ResourceClaims ויש להם PriorityClass שמגדיר את מדיניות ההפקעה ל-PreemptLowerPriority, זמן האחזור של ההתאמה האוטומטית לעומס עשוי לגדול. PreemptLowerPriority היא מדיניות ברירת המחדל להפקעת משאבים של PriorityClass, לכן ודאו שהשדה preemptionPolicy של PriorityClasses מוגדר במפורש ל-Never. מידע נוסף מופיע במאמר Non-preempting PriorityClass.

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

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