מידע על יצירה אוטומטית של מאגרי צמתים

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

אתם כבר אמורים להכיר את המושגים הבאים:

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

מהי יצירה אוטומטית של מאגרי צמתים?

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

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

איך זה עובד

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

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

‫GKE מגדיר מאגרי צמתים חדשים על סמך פרמטרים כמו:

  • בקשות למשאבים של מעבד (CPU), זיכרון ואחסון זמני ב-Pods ובקונטיינרים, כולל Pods שמנוהלים על ידי DaemonSets.
  • בקשות ל-GPU ול-TPU במפרטים של Pod או ב-ComputeClasses.
  • דרישות חומרה, כמו סוגי מכונות או סוגי דיסקים לאתחול, במפרטים של פודים בהמתנה או ב-ComputeClasses.
  • Tolerations במפרטים של Pods בהמתנה שיש להם בוררי צמתים תואמים.

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

הגדרת מטא-נתונים של צומת

בנוסף, GKE מגדיר מטא-נתונים של צמתים (כמו תוויות, הערות ו-taints של צמתים) על סמך הדרישות של עומס העבודה, כמו בדוגמאות הבאות:

  • אם מבקשים את סדרת המכונות N2, ‏GKE מוסיף את תווית הצומת cloud.google.com/machine-family: n2 לכל אחד מהצמתים.
  • אם בוחרים ComputeClass ב-Pod, ‏ GKE מוסיף תווית צומת עם המפתח cloud.google.com/compute-class שמוגדר לשם של אותו ComputeClass.

  • אם ל-Pod יש גם toleration וגם בורר צמתים לאותה תווית צומת, GKE מוסיף לצמתים שנוצרו באופן אוטומטי taints של צמתים ל-tolerations האלה.

מחיקה של מאגרי צמתים שנוצרו באופן אוטומטי

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

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

העדפות להתאמה לעומס ב-GKE

ההעדפות הבאות חלות כש-GKE משנה את קנה המידה של התשתית באופן אוטומטי:

  • צמצום הבזבוז של משאבי המחשוב: GKE משתמש בקיבולת המשאבים של מאגרי הצמתים הקיימים שנוצרו באופן אוטומטי באשכול, כדי לקבוע באיזה סוג מכונה להשתמש במאגרי הצמתים החדשים. ככל שגודל האשכול גדל, GKE מעדיף להשתמש בסוגי מכונות גדולים יותר למאגרי צמתים חדשים, כדי שיותר Pods יוכלו לפעול בכל צומת במאגר הצמתים.
  • אופטימיזציה של יכולת ההתאמה לעומס (scalability) וזמן האחזור: GKE תמיד נותן עדיפות להגדלת מאגרי צמתים תואמים קיימים במקום ליצור מאגרי צמתים חדשים. העדיפות הזו מתחזקת ככל שמספר מאגרי הצמתים הנפרדים באשכול גדל. כשמספר מאגרי הצמתים הנפרדים מתקרב למגבלות הנתמכות לזמן אחזור אופטימלי וליכולת התאמה לעומס (scalability), GKE מוריד את העדיפות של יצירת מאגרי צמתים חדשים.

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

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

אתם יכולים לשלוט באופן ידני בגודל המינימלי של המכונות ש-GKE משתמש בהן למאגרי הצמתים שנוצרו באופן אוטומטי, באמצעות ComputeClass שיש לו את השדה priorities.machineFamily ואת השדה priorities.minCores או השדה priorities.minMemoryGb.

שיטות להפעלת יצירה אוטומטית של מאגרי צמתים

‫GKE יכול ליצור באופן אוטומטי מאגרי צמתים ל-ComputeClasses ספציפיים או לכל עומס עבודה שמשתמש בהגדרה תואמת, בהתאם לאופן שבו אתם מגדירים את האשכול.

שיטות הפעלה
ברמת עומס העבודה (מומלץ)

ב-GKE מגרסה 1.33.3-gke.1136000 ואילך, אפשר להשתמש ב-ComputeClasses כדי להפעיל יצירה אוטומטית של מאגרי צמתים בלי להשתמש בהקצאת צמתים אוטומטית ברמת האשכול. ‫GKE יוצר מאגרי צמתים חדשים רק לעומסי עבודה שבוחרים ComputeClasses ספציפיים שהופעלה בהם יצירה אוטומטית. עומסי העבודה הקיימים באשכול לא מושפעים.

גם בגרסאות GKE שקודמות ל-1.33.3-gke.1136000, מומלץ להשתמש ב-ComputeClasses כדי לבקש ולהגדיר תשתית לעומסי העבודה. ‫ComputeClasses מספקים יכולות ייחודיות ונותנים לכם דרך גמישה לבצע אופטימיזציה של ההתאמה לעומס באשכול. מידע נוסף זמין במאמר מידע על ComputeClasses בהתאמה אישית.
ברמת האשכול

הפעלת הקצאת צמתים אוטומטית (NAP) לכל האשכול. אתם צריכים להגדיר מגבלות למשאבים כמו מעבד (CPU) וזיכרון באשכול. המגבלות האלה חלות על כל האשכול. צריך להגדיר את האשכול כדי להפעיל יצירה אוטומטית של מאגרי צמתים בגרסאות GKE שקודמות ל-1.33.3-gke.1136000.

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

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

  1. מפרט ComputeClass או Pod: אם מציינים הגדרה (כמו סוג מכונה) במפרט ComputeClass או Pod, מערכת GKE משתמשת בהגדרה הזו.
  2. ברירת המחדל של הקצאת צמתים אוטומטית ברמת האשכול: אם לא צוינה הגדרה ב-ComputeClass או במפרט Pod, ‏GKE בודק אם הגדרתם ערך ברירת מחדל להקצאת צמתים אוטומטית באשכול. אם קיים ערך ברירת מחדל ברמת האשכול, GKE משתמש בערך הזה.
  3. ברירת מחדל ברמת האשכול: אם הגדרה לא צוינה ב-ComputeClasses, במפרטי Pod או כערך ברירת מחדל להקצאת צמתים אוטומטית ברמת האשכול, GKE משתמש בערך ברירת המחדל ש-Google Cloud מגדיר לאשכול.

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

  1. ‫GKE בודק אם סוג המכונה מצוין במפרט של ה-Pod או ב-ComputeClass של ה-Pod.
  2. אם לא צוין סוג מכונה במפרט של ה-Pod או ב-ComputeClass, ‏GKE בודק אם הגדרתם סוג מכונה כברירת מחדל להקצאת צמתים אוטומטית באשכול.
  3. אם לא הגדרתם סוג מכונה כברירת מחדל להקצאת צמתים אוטומטית, GKE משתמש בסוג המכונה שמוגדר כברירת מחדל באשכול.

ברוב המקרים, מומלץ להשתמש רק בשיטת ההפעלה ComputeClass. בקטעים הבאים מפורטות שיטות ההגדרה האלה, כולל מגבלות ושיקולים.

הפעלה ברמת עומס העבודה באמצעות ComputeClasses

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

  • ‫nodePoolAutoCreation: מאפשרים ל-GKE ליצור באופן אוטומטי מאגרי צמתים לפי הצורך. עדיין אפשר לבצע פעולות במאגרי הצמתים. ‫GKE מיישם רק את ההגדרות או האילוצים שאתם מגדירים.
  • ‫autopilot: הרצת עומסי העבודה שבוחרים את ComputeClass הזה במצב אוטומטי. בדומה לאשכול Autopilot, ‏GKE מנהל את הצמתים בשבילכם ומטמיע אילוצים והגדרות שונות של Autopilot. אם אתם משתמשים בשדה autopilot, אתם יכולים לדלג על המסמך הזה. מידע נוסף זמין במאמר מידע על עומסי עבודה במצב אוטומטי ב-Standard.

באשכולות שמשתמשים בגרסת GKE‏ 1.33.3-gke.1136000 ואילך, אתם יכולים להשתמש בשדות האלה ב-ComputeClass בלי להפעיל הקצאת צמתים אוטומטית ברמת האשכול.

אם מגדירים יצירה אוטומטית של מאגרי צמתים ב-ComputeClass בלי להפעיל הקצאת צמתים אוטומטית לאשכול, GKE יוצר מאגרי צמתים חדשים רק לעומסי עבודה שמשתמשים ב-ComputeClass. עומסי עבודה אחרים לא מושפעים.

במניפסט הבא של ComputeClass, מופעלת יצירה אוטומטית של מאגרי צמתים לכל Pod שמשתמש ב-ComputeClass:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: example-computeclass
spec:
  priorities:
  - machineFamily: n4
  - machineFamily: c4
  whenUnsatisfiable: ScaleUpAnyway
  nodePoolAutoCreation:
    enabled: true

הפעלה ברמת האשכול באמצעות הקצאת צמתים אוטומטית (NAP)

כדי להפעיל יצירה אוטומטית של מאגרי צמתים לכל האשכול, מפעילים את התכונה הקצאת צמתים אוטומטית לאשכול באמצעות Kubernetes Engine API. הקצאת צמתים אוטומטית מאפשרת ל-GKE ליצור מאגרי צמתים חדשים לפי הצורך לכל עומס עבודה באשכול, על סמך מפרטי Pod או הגדרות ComputeClass. ‫GKE לא מנהל מאגרי צמתים קיימים באשכול, אבל אפשר לסמן מאגרי צמתים ספציפיים להקצאת משאבים אוטומטית אחרי שמפעילים את הקצאת הצמתים האוטומטית באשכול.

כדאי להפעיל הקצאת צמתים אוטומטית במצבים כמו:

  • אתם רוצים ש-GKE ייצור באופן אוטומטי מאגרי צמתים באשכול שפועלת בו גרסה של GKE שקודמת ל-1.33.3-gke.1136000.

  • אתם רוצים להגדיר באופן ידני מגבלות על משאבים ברמת האשכול. בגרסאות GKE שקודמות ל-1.33.3-gke.1136000, צריך להגדיר מגבלות משאבים ברמת האשכול גם אם משתמשים ב-ComputeClasses.

  • אתם רוצים להשתמש בתכונות או בהגדרות ספציפיות שלא נתמכות ב-ComputeClasses.

  • אתם רוצים להגדיר ערכי ברירת מחדל להגדרות של צומת לכל האשכול.

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

מגבלות על משאבים ברמת האשכול עם הקצאת צמתים אוטומטית (NAP)

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

מגבלות המשאבים האלה ברמת האשכול נדרשות רק אם מפעילים הקצאת צמתים אוטומטית באשכול. באשכולות שמשתמשים בגרסה 1.33.3-gke.1136000 של GKE ואילך, אתם יכולים להשתמש ביצירה אוטומטית של מאגרי צמתים ב-ComputeClasses בלי להפעיל הקצאת צמתים אוטומטית.

אם האשכול עומד בדרישות האלה, מומלץ להשתמש רק ב-ComputeClasses כדי להגדיר מאגרי צמתים שנוצרו באופן אוטומטי.

הגדרות ברירת המחדל למאגרי צמתים שנוצרו באופן אוטומטי

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

  • הגדרות ברירת מחדל ברמת עומס העבודה: אתם יכולים להשתמש בשדה spec.nodePoolConfig ובשדה spec.priorityDefaults במפרט של ComputeClass כדי להגדיר ערכי ברירת מחדל להגדרות ספציפיות של צמתים. ערכי ברירת המחדל האלה חלים רק על מאגרי הצמתים ש-GKE יוצר בשביל ComputeClass.
  • הגדרות ברירת מחדל ברמת האשכול: אתם יכולים להגדיר ערכי ברירת מחדל למאגרי צמתים שנוצרו באופן אוטומטי כשאתם מגדירים הקצאת צמתים אוטומטית. כדי לציין ערכי ברירת מחדל, משתמשים ב-CLI של gcloud או בקובץ תצורה בפורמט YAML.

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

הגדרות ברירת מחדל ברמת האשכול באמצעות קובץ תצורה

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

  • קובץ התצורה לדוגמה הבא מפעיל תיקון אוטומטי ושדרוג אוטומטי של צמתים לכל מאגר צמתים חדש שנוצר באופן אוטומטי:

    management:
  autoRepair: true
  autoUpgrade: true

  • בקובץ התצורה לדוגמה הבא, מגדירים את מגבלות המשאבים ברמת האשכול להקצאת צמתים אוטומטית, וקובעים כמה הגדרות ברירת מחדל:

    resourceLimits:
  - resourceType: 'cpu'
    minimum: 4
    maximum: 10
  - resourceType: 'memory'
    maximum: 64
  - resourceType: 'nvidia-tesla-t4'
    maximum: 4
management:
  autoRepair: true
  autoUpgrade: true
shieldedInstanceConfig:
  enableSecureBoot: true
  enableIntegrityMonitoring: true
diskSizeGb: 100

    קובץ התצורה הזה מגדיר את ערכי ברירת המחדל הבאים:

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

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

תרחישים לדוגמה של יצירה אוטומטית של מאגרי צמתים

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

בחירת סדרת מכונות או סוג מכונה

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

  • ‫ComputeClasses: משתמשים בmachineFamily או בmachineType כללי עדיפות.
  • מפרטי Pod: לסדרת מכונות, משתמשים בבורר צמתים לתווית הצומת cloud.google.com/machine-family. לסוג מכונה, משתמשים גם בתווית הצומת cloud.google.com/machine-family וגם בתווית הצומת node.kubernetes.io/instance-type. מידע נוסף זמין במאמר בחירת סדרת מכונות או סוג מכונה.

אם לא בוחרים מכונה באופן מפורש, GKE משתמש בסדרת המכונות E2 או בסוג מכונה שתואם לחומרה שעומס העבודה דורש. לדוגמה, ב-GKE משתמשים בסוגי מכונות GPU ל-GPU ובמכונות מיוחדות למשאבי TPU.

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

סדרות מכונות נתמכות

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

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

סדרת מכונות גרסאות GKE נתמכות
סדרת מכונות C4
  • ‫1.28.15-gke.1159000 ואילך
  • ‫1.29.10-gke.1227000 ואילך
  • ‫1.30.3-gke.1225000 ואילך
סדרת המכונות C4A (מכונות וירטואליות)
  • ‫1.30.7-gke.1136000 ואילך
  • ‫1.31.3-gke.1056000 ואילך
מכונות C4A ללא מערכת הפעלה
  • ‫c4a-highmem-96-metal: ‏‎1.35.3-gke.1389000 ואילך
  • ‫c4a-standard-96-metal: לא נתמך
סדרת המכונות C4D (מכונות וירטואליות) ‫1.32.3-gke.1717000 ואילך
מכונות Bare Metal מסוג C4D ‫1.37.0-gke.4713000 ואילך
סדרת המכונות C4N ‫1.36.0-gke.3009002 ואילך
סדרת מכונות N4 ‫1.29.3 ואילך
סדרת המכונות N4A ‫1.34.1-gke.3403001 ואילך
סדרת המכונות N4D
  • ‫1.33.12-gke.1208000 ואילך
  • ‫1.34.1-gke.2037000 ואילך
סדרת המכונות Z3 ‫1.29 ואילך
סדרת המכונות Z4D ‫1.36.3-gke.1244000 ואילך
סדרת המכונות Z4M ‫1.37.0-gke.4713000 ואילך

סדרות מכונות אחרות נתמכות בכל הגרסאות של GKE.

בחירת GPU

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

  • ComputeClasses:
    1. משתמשים בכלל העדיפות gpu כדי להגדיר את ה-GPU.
    2. מבקשים משאבי GPU ב-Pods.
  • מפרט של Pod:
    1. הגדרת מגבלות GPU ברמת האשכול להקצאת צמתים אוטומטית.
    2. משתמשים בבוררי צמתים כדי להגדיר את ה-GPU.
    3. מבקשים משאבי GPU ב-Pods.

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

דרישות לגבי גרסת GKE ל-GPU

בחירת Cloud TPU

אתם יכולים לבקש משאבי Cloud TPU למאגרי צמתים שנוצרו באופן אוטומטי באחת מהדרכים הבאות:

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

דרישות הגרסה של GKE ל-Cloud TPU

יצירה אוטומטית של מאגרי צמתים תומכת ב-Cloud TPU הבאים רק בגרסאות ספציפיות של GKE:

  • ‫TPU v3: גרסה 1.31.0 ואילך.
  • ‫TPU v5 ו-TPU v4: גרסה 1.29.0 ואילך.
  • ‫TPU Trillium: גרסה 1.32.0 ואילך.
  • ‫Ironwood (TPU7x): ‏ 1.34.1-gke.2541000 ואילך.

סוגים אחרים של Cloud TPU נתמכים בכל הגרסאות של GKE. למידע נוסף על גרסאות GKE שזמינות ליחידות TPU, קראו את המאמר אימות הזמינות של TPU ב-GKE.

התאמה אוטומטית לעומס של מאגר צמתים ב-Cloud TPU

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

  • מאגר צמתים של פרוסות TPU במארח יחיד: GKE מוסיף או מסיר צומתי TPU במאגר הצמתים הקיים. מאגר הצמתים יכול להכיל כל מספר של צומתי TPU בין אפס לגודל המקסימלי של מאגר הצמתים, כפי שנקבע על ידי הדגלים --max-nodes ו---total-max-nodes של ההתאמה האוטומטית לעומס. לכל צומתי ה-TPU במאגר הצמתים יש את אותו סוג מכונה ואותה טופולוגיה. למידע נוסף על יצירת מאגר צמתים של פרוסות TPU במארח יחיד, ראו יצירת מאגר צמתים של פרוסות TPU במארח יחיד.
  • מאגר צמתים של פרוסת TPU עם כמה מארחים: GKE מגדיל באופן אטומי את מאגר הצמתים מאפס למספר הצמתים שנדרש כדי לעמוד בטופולוגיית ה-TPU. לדוגמה, במאגר צומתי TPU עם סוג המכונה ct5lp-hightpu-4t וטופולוגיה של 16x16, במאגר הצמתים תמיד יהיו 64 צמתים או אפס צמתים. אם אין עומסי עבודה של TPU במאגר הצמתים, GKE מקטין את מאגר הצמתים. כדי להקטין את מאגר הצמתים, GKE מסיר את כל הפודים המתוזמנים ואת כל הצמתים במאגר הצמתים. למידע נוסף על יצירת מאגר צמתים של פרוסות TPU עם כמה מארחים, ראו יצירת מאגר צמתים של פרוסות TPU עם כמה מארחים.

הגדרת מאגר צמתים של Cloud TPU

‫GKE משתמש בהגדרות ב-Pod או ב-ComputeClass כדי לקבוע את ההגדרות של צומתי ה-TPU. המניפסט הבא הוא דוגמה למפרט פריסה שמבקש יחידות TPU במפרט Pod. אם ההגדרה של הקצאת צמתים אוטומטית ברמת האשכול מופעלת, הפריסה הזו מפעילה יצירה אוטומטית של מאגר צמתים. כשיוצרים את ה-Deployment לדוגמה, GKE יוצר מאגר צמתים שמכיל פרוסת TPU v4 עם טופולוגיית 2x2x2 ושתי מכונות ct4p-hightpu-4t.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tpu-workload
  labels:
    app: tpu-workload
spec:
  replicas: 2
  template:
    spec:
      nodeSelector:
        cloud.google.com/gke-tpu-accelerator: tpu-v4-podslice
        cloud.google.com/gke-tpu-topology: 2x2x2
      containers:
      - name: tpu-job
        image: us-docker.pkg.dev/cloud-tpu-images/jax-ai-image/tpu:latest
        ports:
        - containerPort: 8431 # Port to export TPU runtime metrics, if supported.
        securityContext:
          privileged: true # Required for GKE versions earlier than 1.28 to access TPUs.
        command:
        - bash
        - -c
        - |
          python -c 'import jax; print("Total TPU chips:", jax.device_count())'
        resources:
          requests:
            google.com/tpu: 4
          limits:
            google.com/tpu: 4
        ports:
        - containerPort: 80

במניפסט הזה, השדות הבאים מגדירים את תצורת ה-TPU:

  • ‫cloud.google.com/gke-tpu-accelerator: הגרסה והסוג של ה-TPU. לדוגמה, משתמשים ב-tpu7x-standard-4t ל-Ironwood (TPU7x).
  • ‫cloud.google.com/gke-tpu-topology: הטופולוגיה עם המספר והסידור הפיזי של שבבי TPU בתוך פרוסת TPU. לדוגמה, משתמשים ב-2x2x2.
  • ‫limits.google.com/tpu: מספר שבבי ה-TPU לכל מכונה וירטואלית. לדוגמה, אם משתמשים ב-tpu7x-standard-4t, מספר שבבי ה-TPU לכל מכונה וירטואלית הוא 4.

בחירת VM במודל Spot

אפשר לבחור מכונות וירטואליות (VM) במודל Spot למאגרי צמתים שנוצרו באופן אוטומטי באחת מהדרכים הבאות:

  • ‫ComputeClasses: משתמשים בשדה spot בכלל עדיפות.
  • מפרט Pod: משתמשים ב-toleration לתווית הצומת cloud.google.com/gke-spot="true" עם האפקט NoSchedule. מוסיפים בורר צמתים לתוויות הצמתים cloud.google.com/gke-spot=true או cloud.google.com/gke-provisioning=spot. לחלופין, אתם יכולים לבחור מכונות וירטואליות זמניות באמצעות תווית הצומת cloud.google.com/gke-preemptible ב-toleration ובבורר הצמתים. עם זאת, אנחנו ממליצים מאוד להשתמש במקום זאת במכונות וירטואליות (VM) במודל Spot.

הגדרת אחסון זמני

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

  • ‫ComputeClasses: משתמשים בשדות storage.bootDiskSize ו-storage.bootDiskType בכלל עדיפות. אפשר לקבוע הגדרות שונות של דיסק אתחול ל-ComputeClasses שונים.
  • מפרטי Pod: משתמשים בשדות diskSizeGb ו-diskType בקובץ התצורה ברמת האשכול. בשיטה הזו אי אפשר לשלוט בגודל ובסוג של דיסק האתחול של פודים ספציפיים.

מידע נוסף זמין במאמר דיסקי אתחול מותאמים אישית. אם לא משנים באופן מפורש את הגדרות דיסק האתחול, ברירת המחדל היא נפח של pd-balanced בקיבולת של 100GiB.

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

הפרדת עומסי עבודה

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

  • ‫ComputeClasses: הצמתים ש-GKE יוצר ל-ComputeClass ספציפי יכולים להריץ רק Pods שבוחרים את ה-ComputeClass הזה. אתם לא צריכים לשנות את המפרטים של ה-Pod. אפשר להפריד בין הפודים ב-ComputeClass באמצעות קרבה ודחייה בין פודים.
  • מפרטי Pod: אם מפעילים הקצאת צמתים אוטומטית באשכול, אפשר להגדיר הפרדת עומסי עבודה באמצעות שדות במפרט ה-Pod. במהלך היצירה האוטומטית של מאגר הצמתים, יכול להיות ש-GKE ייצור מאגרי צמתים עם תוויות וטיינטים אם כל התנאים הבאים מתקיימים:
    • ה-Pod משתמש בבורר צמתים כדי לבקש מפתח וערך של תווית צומת בהתאמה אישית. אי אפשר להשתמש בתוויות של צומתי מערכת כדי להפריד בין עומסי עבודה.
    • ל-Pod יש toleration לאותו מפתח של תווית צומת.
    • ההשפעה של הסבילות היא NoSchedule, NoExecute או לא צוינה.

מידע נוסף על הגדרת השדות האלה ועל המגבלות מופיע במאמר הגדרת הפרדת עומסי עבודה ב-GKE.

מגבלות

  • כל המגבלות של מידרוג אוטומטי של אשכולות חלות גם על יצירה אוטומטית של מאגרי צמתים.
  • באשכולות שיש בהם יותר מ-200 מאגרי צמתים, יכול להיות שזמן ההשהיה במהלך התאמה אוטומטית לעומס יהיה ארוך יותר. כל הגדרה שמפעילה יצירה של מאגר צמתים חדש, כמו הפרדת עומסי עבודה או שימוש בכמה ComputeClasses, מגדילה את המספר הזה. מידע נוסף על מגבלות של אשכולות מופיע בקטע מגבלות ושיטות מומלצות במאמר "תכנון אשכולות גדולים".
  • כל מגבלות המשאבים שאתם מגדירים לאשכול כשאתם מפעילים הקצאת צמתים אוטומטית חלות גם על מאגרי הצמתים ש-GKE יוצר בשביל ComputeClasses.
  • ההגדרות הבאות לא נתמכות ב-ComputeClasses:
    • שדרוגי מתח או שדרוגי כחול-ירוק.
    • תקינות הצומת ואתחול מאובטח.
  • כדי להפעיל יצירה אוטומטית של מאגרי צמתים ל-ComputeClass בגרסאות GKE שקודמות ל-1.33.3-gke.1136000, צריך להפעיל גם הקצאת צמתים אוטומטית ברמת האשכול. המגבלה הזו לא חלה על גרסה 1.33.3-gke.1136000 של GKE ואילך.

הגדרות לא נתמכות

‫GKE לא יוצר מאגרי צמתים חדשים שמשתמשים בהגדרות הבאות:

הכלי Cluster Autoscaler יכול לשנות את קנה המידה של צמתים במאגרי צמתים קיימים שמשתמשים בהגדרות האלה.

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