הסבר על תחזוקת המארח ב-GKE

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

במאמר הזה נסביר מה המשמעות של שיבושים בצמתים ב-GKE ואיך לצמצם את ההשפעה של השיבושים בצמתים ב-GKE.

למידע נוסף על מעקב אחרי התראות ואירועים של תחזוקה, ראו מעקב אחרי אירועי תחזוקה.

המסמך הזה רלוונטי לסוגי המכונות הבאים:

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

מה המשמעות של הפסקת תשתית ב-GKE?

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

  • תיקון בעיות שזוהו (TerminationEvent): האירועים האלה מתרחשים כי Google Cloud מזהה בעיה ומשבש את התשתית של האשכול. אירועי TerminationEvent לא תומכים בכיבוי מבוקר. אירועי TerminationEvent מופעלים בגלל הבעיות הבאות:

    • תיקון אוטומטי מתרחש כש-GKE מתקן צומת אחרי כמה בדיקות תקינות שנכשלו.
    • HostError: שגיאה בחומרה או בתוכנה במכונה הפיזית שגורמת ל-VM להפסיק לפעול.
  • אירועי תחזוקה או שדרוג (MaintenanceEvent): האירועים האלה מתרחשים כש- Google Cloud צריך להפריע למכונה וירטואלית כדי לבצע תחזוקה. האירועים האלה מופעלים על ידי משימות התחזוקה הבאות:

    במאמר סוגי שינויים מוסבר איך אתם ו-GKE מנהלים את השינויים במהלך מחזור החיים של האשכול.

  • תגובה להחלטות תזמון (PreemptionEvent): האירועים האלה מתרחשים כש- Google Cloud צריך להפסיק את פעולת המכונות הווירטואליות כדי לפנות קיבולת למשאבים בעדיפות גבוהה יותר. אירועי PreemptionEvent יכולים להיות כל אחד מהבאים:

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

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

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

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

  • סוגי מכונות עם מעבדי GPU ומעבדי TPU מצורפים.
  • סוגי מכונות H4D.
  • סוגי מכונות C4A Bare Metal‏ (c4a-standard-96-metal ו-c4a-highmem-96-metal).
  • מכונות פיזיות מסוג C4D (‏c4d-standard-384-metal, c4d-highcpu-384-metal ו-c4d-highmem-384-metal).
  • סוגי מכונות Z3 עם יותר מ-18 TiB של Titanium SSD מחובר.
  • סוגי מכונות Z4D עם יותר מ-42 TiB של Titanium SSD מחובר.
  • סוגי מכונות Z4M עם יותר מ-48 TiB של Titanium SSD מחובר, או כל מכונות Z4M שמשתמשות ב-Cloud RDMA.

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

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

ניהול אירועי תחזוקה

בהמשך המסמך מוסבר איך לנהל שיבושים ב-MaintenanceEvent.

ניהול השיבושים בצמתים במהלך אירועי תחזוקה של מארחים מתבצע בתהליך עבודה בן שלושה שלבים:

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

זיהוי פעולות תחזוקה מתוזמנות במארח

כדי לעקוב אחרי אירועי תחזוקה קרובים ולזהות אותם, צריך להציג את ההתראות גם מ-GKE וגם מ-Compute Engine.

למידע נוסף על מעקב אחרי התראות ואירועים של תחזוקה, ראו מעקב אחרי אירועי תחזוקה.

ביצוע פעולות בהתאם לתחזוקה שזוהתה

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

  1. תחזוקה אוטומטית: מאפשרים ל-Compute Engine להתחיל את אירוע התחזוקה לפי לוח הזמנים. המכונות הווירטואליות שלכם יעברו באופן אוטומטי מיגרציה פעילה ברקע, עם הפרעה מינימלית או ללא הפרעה בכלל.

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

    1. האם הצמתים המושפעים הם מכונות וירטואליות בודדות או מבודדות?

      • כן (אני מפעיל/ה מכונה וירטואלית אחת או מבודדת):
        • אם אתם לא צריכים אמצעי בקרה מדויקים על התזמון, תנו ל-Compute Engine להתחיל את אירוע התחזוקה לפי לוח הזמנים (אוטומטי כברירת מחדל).
        • כדי למנוע הפקעה לא צפויה, הפעילו ידנית את אירוע התחזוקה של המארח בצומת הספציפי בזמן שנוח לכם, למשל בחלונות זמן של תנועה מועטה.
      • לא (אני מריץ מאגר צמתים של מאיצים): בוחרים אחת מהאפשרויות בשלב הבא.
    2. בוחרים אחת מהאפשרויות הבאות בהתאם לתרחיש לדוגמה:

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

      • אם מאגר המאיצים מריץ נקודות קצה (endpoints) של הסקה או של הצגת מודעות AI/ML בזמינות גבוהה: מטמיעים את האסטרטגיה המתגלגלת. תיאום של תחזוקת מארחים מתוזמנת ושדרוגי גרסאות בקבוצות מתגלגלות בתוך גבולות האזור או המאגר, באמצעות רפליקות פעילות כדי להגן על הסכמי ה-SLA.

הפעלה ידנית של אירוע תחזוקה של מארח במכונות וירטואליות בודדות או מבודדות

אם ל-Compute Engine יש אירוע תחזוקה של מארח שאפשר לתזמן מחדש לצומת, אתם יכולים להתחיל את אירוע התחזוקה על ידי החלת התווית cloud.google.com/perform-maintenance=true על הצומת. לדוגמה, אפשר להתחיל את אירוע התחזוקה בתקופה של פעילות נמוכה.

התווית cloud.google.com/perform-maintenance=true יכולה להתחיל אירוע תחזוקה שכבר תוכנן, אבל רק בזמן מוקדם יותר מזה שתוכנן במקור. כדי להפעיל מחדש את מערכת ההפעלה של האורח באותו מארח, קראו את המאמר הפעלה מחדש של מערכת ההפעלה של האורח בצומת GKE. כדי להחליף מארח פגום שלא תוכנן עם שגיאות GPU מתמשכות, ראו דיווח על מארחים פגומים דרך GKE.

כדי להשתמש בתווית cloud.google.com/perform-maintenance=true כדי להתחיל מיד אירוע תחזוקה, הצומת צריך לעמוד בתנאים הבאים:

  • אירוע תחזוקה מתוזמן: לצומת יש אירוע תחזוקה בהמתנה, שמצוין על ידי התראה של Compute Engine, ולצומת יש את התווית cloud.google.com/scheduled-maintenance-time.
  • אפשר לשנות את מועד האירוע: במטא-נתונים של האירוע מופיעה ההתראה can_reschedule=TRUE. אם אי אפשר לתזמן מחדש את האירוע, להגדרת התווית cloud.google.com/perform-maintenance=true אין השפעה, והתחזוקה מתבצעת בזמן שנקבע במקור.

אם צומת עומד בתנאים האלה, מגדירים את תווית הצומת cloud.google.com/perform-maintenance לערך true באמצעות הפקודה הבאה:

kubectl label nodes NODE_NAME cloud.google.com/perform-maintenance=true

מחליפים את NODE_NAME בשם הצומת.

כשמחילים את התווית הזו, GKE מבצע את הפעולות הבאות:

  1. Taints (פגמים) בצומת.
  2. פינוי פודים בצורה חלקה.
  3. מבקשת מ-Compute Engine להתחיל את אירוע התחזוקה באופן מיידי, במקום להמתין למועד המתוזמן.

אימות התוצאה של אירוע התחזוקה

אחרי שזיהיתם אירוע תחזוקה קרוב והחלטתם מהי דרך הפעולה הטובה ביותר, אתם יכולים לאמת את התוצאה של אירוע התחזוקה.

‫Compute Engine מתחיל את אירוע התחזוקה לפי לוח הזמנים

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

תחילת פעולת תחזוקה שנקבעה מראש

כשהתחזוקה המתוזמנת מתחילה, Compute Engine מעדכן את המטא-נתונים בספרייה http://metadata.google.internal/computeMetadata/v1/instance/attributes/. ‫Compute Engine מעדכן את תוויות המטא-נתונים באופן הבא:

  • ההגדרה maintenance-event נקבעת לערך TERMINATE_ON_HOST_MAINTENANCE.
  • ב-upcoming-maintenance, מגדירים את maintenance_status ל-ONGOING.

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

המדד הבא של מערכת GKE מדווח על מספר ההפרעות לצומת GKE מאז הדגימה האחרונה (המדד נדגם כל 60 שניות):

  • kubernetes.io/node/interruption_count

השדות interruption_type (כמו TerminationEvent,‏ MaintenanceEvent או PreemptionEvent) ו-interruption_reason (כמו HostError,‏ Eviction או AutoRepair) יכולים לעזור להבין למה הצומת הופסק.

כדי לקבל פירוט של ההפסקות והסיבות להן בצומתי TPU באשכולות בפרויקט, השתמשו בשאילתת PromQL הבאה:

  sum by (interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_interruption_count{monitored_resource="k8s_node"}[${__interval}]))

כדי לראות רק את אירועי התחזוקה של המארח, מעדכנים את השאילתה כדי לסנן את הערך HW/SW Maintenance של interruption_reason. משתמשים בשאילתת PromQL הבאה:

  sum by (interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_interruption_count{monitored_resource="k8s_node", interruption_reason="HW/SW Maintenance"}[${__interval}]))

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

  sum by (node_pool_name,interruption_type,interruption_reason)(
    sum_over_time(
      kubernetes_io:node_pool_interruption_count{monitored_resource="k8s_node_pool", interruption_reason="HW/SW Maintenance", node_pool_name=NODE_POOL_NAME }[${__interval}]))

הגדרות מתקדמות לצמצום ההפרעות

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

הפעלת הטיפול בשיבושים

apiVersion: v1
kind: ConfigMap
metadata:
  name: gke-disruption-handling
  namespace: kube-system
data:
  maintenance-experience.yaml: |
    gracefulTermination: true

כדי להפעיל את הטיפול בשיבושים, יוצרים קובץ בשם maintenance-config.yaml עם ה-ConfigMap הזה. מחילים את ConfigMap על האשכול באמצעות הפקודה הבאה:

kubectl apply -f my-configmap.yaml

הגדרת GKE לסיום תקין של עומסי העבודה

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

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

כדי להגדיר את תקופת החסד לסיום, מגדירים את תקופת החסד לסיום (בשניות) בשדה spec.terminationGracePeriodSeconds במניפסט של ה-Pod. לדוגמה, כדי לקבל התראה של 10 דקות, מגדירים את השדה spec.terminationGracePeriodSeconds במניפסט של ה-Pod ל-600 שניות, באופן הבא:

    spec:
      terminationGracePeriodSeconds: 600

מומלץ להגדיר תקופת חסד לסיום שתהיה ארוכה מספיק כדי שכל המשימות המתמשכות יסתיימו במסגרת הזמן של ההתראה. אם עומס העבודה משתמש במסגרת למידת מכונה כמו MaxText,‏ Pax או JAX עם Orbax, עומסי העבודה יכולים לתעד את אות הכיבוי SIGTERM ולהתחיל תהליך של נקודת ביקורת. מידע נוסף זמין במאמר נקודת בדיקה אוטומטית של TPU.

תהליך הסגירה המבוקרת

כשמתחיל אירוע תחזוקה ידני, Compute Engine מעדכן את מפתח המטא-נתונים maintenance-event כדי לאותת על ההשבתה הקרובה של המכונה. ‫GKE מתחיל סגירה מבוקרת.

תהליך העבודה הבא מראה איך GKE מבצע סגירה הדרגתית של צומת כשיש השבתה קרובה של צומת:

  1. בתוך 60 שניות, יקרו הדברים הבאים:
    1. רכיבי המערכת מחילים את תווית הצומת cloud.google.com/active-node-maintenance שמוגדרת ל-ONGOING כדי לציין שעומסי העבודה נעצרים.
    2. ‫GKE מחיל את ה-taint על הצומת כדי למנוע תזמון של Pods חדשים בצומת. ל-taint יש את המפתח cloud.google.com/impending-node-termination:NoSchedule. אנחנו ממליצים לא לשנות את עומסי העבודה כדי לסבול את הכתם הזה, בגלל הסיום הידוע שמתרחש.
  2. הרכיב maintenance-handler מתחיל לפנות Pods, קודם את ה-Pods של עומסי העבודה ואחר כך את ה-Pods של המערכת (לדוגמה, kube-system).
  3. ‫GKE שולח אות כיבוי SIGTERM לפודים של עומסי עבודה שפועלים בצומת, כדי להתריע על כיבוי קרוב. פודים יכולים להשתמש בהתראה הזו כדי לסיים את כל המשימות שמתבצעות. ‫GKE עושה כמיטב יכולתו כדי לסיים את הפעילות של הפודים האלה בצורה תקינה.
  4. בסיום הפינוי, GKE מעדכן את הערך של התווית cloud.google.com/active-node-maintenance ל-terminating כדי לציין שהצומת מוכן לסיום.

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

איך בודקים את ההתקדמות של סגירה הדרגתית פעילה

אפשר לסנן את היומנים של GKE לפי האירועים הבאים של סיום תקין:

  • כשהמכונה הווירטואלית מזהה שיבוש בגלל סיום קרוב של צומת, כמו אירוע תחזוקה של מארח ב-Compute Engine, ‏GKE מגדיר את cloud.google.com/active-node-maintenance לערך ONGOING כשהפסקת עומסי העבודה מתבצעת, ולערך terminating כשהפסקת עומסי העבודה מסתיימת והצומת מוכן לסיום.
  • כדי להגביל את התזמון של עומסי עבודה חדשים, GKE מחיל את ה-taint‏ cloud.google.com/impending-node-termination:NoSchedule.

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

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

יצירת מאגר צמתים חדש עם תחזוקה אופורטוניסטית

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

gcloud beta container node-pools create NODE_POOL_NAME \
    --cluster CLUSTER_NAME \
    --accelerator ACCELERATOR_ARG \
    --machine-type MACHINE_TYPE \
    --num-nodes NODE_COUNT \
    --zone ZONE \
    --project=PROJECT_ID \
    --opportunistic-maintenance=node-idle-time=NODE_IDLE_TIME,min-nodes=MIN_NODES,window=WINDOW

מחליפים את הערכים הבאים:

  • ‫NODE_POOL_NAME: השם של מאגר הצמתים ב-GKE.
  • ‫CLUSTER_NAME : השם של אשכול GKE.
  • ‫NODE_IDLE_TIME : משך הזמן שבו צומת יכול להישאר במצב חוסר פעילות (כלומר, לא פועלים עומסי עבודה שצורכים מאיצים) לפני שמופעלת תחזוקה. הערך מייצג את משך הזמן בשניות, עם עד תשע ספרות אחרי הנקודה העשרונית, ומסתיים בתו s, לדוגמה: 80000s.
  • ‫MIN_NODES : המספר המינימלי של צמתים שצריכים להיות זמינים במאגר צמתים. האפשרות הזו חוסמת את התחזוקה אם היא גורמת לכך שמספר הצמתים הפועלים יהיה נמוך מהערך הזה, לדוגמה: 10.
  • ‫WINDOW : חלון הזמן, בשניות, שבו אפשר להריץ תחזוקה אופורטוניסטית. הערך מסתיים בתו s. לדוגמה, אם הערך הוא 14 ימים, או 1209600s, אפשר להריץ תחזוקה אופורטוניסטית רק בשבועיים שלפני תאריך התחזוקה המתוזמנת. ערך של 28 ימים, או 2419200s, מאפשר להריץ תחזוקה אופורטוניסטית בכל שלב במהלך חלון הזמן המתוזמן לתחזוקה. חלון הזמן לתחזוקת המארח ב-Compute Engine שונה מחלונות הזמן לתחזוקה ב-GKE, שקובעים מתי אפשר לבצע תחזוקה של אשכול GKE ומוגדרים בנפרד.

הגדרה לדוגמה לתחזוקה אופורטוניסטית

הנה דוגמה: יש לכם מאגר צמתים עם ארבעה צמתים, והגדרת התחזוקה האופורטוניסטית היא --opportunistic-maintenance=node-idle-time=600s,window=2419200s,min-nodes=3. במקרה כזה:

  • ב-node1 פועל עומס עבודה של GPU. הצומת הזה לא במצב של חוסר פעילות, ולכן המערכת מדלגת עליו.
  • ‫node2 לא פעיל במשך 60 שניות. הצומת הזה לא היה במצב חוסר פעילות מספיק זמן, ולכן המערכת דילגה עליו.
  • node3 לא פעיל במשך 600 שניות. הצומת הזה עומד בדרישה של מצב חוסר פעילות.
  • node4 לא פעיל במשך 600 שניות. הצומת הזה עומד בדרישה של מצב חוסר פעילות.

גם node3 וגם node4 עומדים בדרישה של מצב חוסר פעילות. עם זאת, רק אחד מהצמתים האלה יפעיל תחזוקה אופורטוניסטית, כי הערך של האפשרות min-nodes מוגדר ל-3.

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

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

kubectl describe node NODE_NAME | grep node.gke.io/opportunistic-config

מחליפים את NODE_NAME בשם הצומת שרוצים לבדוק.

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

kubectl describe node NODE_NAME | grep node.gke.io/maintenance-state

אם הצומת מופעל על ידי תחזוקה אופורטוניסטית, ההערה maintenance-state מציגה את opportunistic-triggered בתור true.

מגבלות

חשוב לשים לב למגבלות הבאות של תחזוקה אופורטוניסטית:

  • אפשר להשתמש בתכונה הזו רק עם מאגרי צמתים של GPU ו-TPU.
  • תחזוקה אופורטוניסטית לא תואמת למידרוג אוטומטי של אשכולות, כי המידרוג האוטומטי של אשכולות כבר מצמצם אנכית בהתאם לעומס (scale down) צמתים לא פעילים.
  • במאגרי צומתי TPU עם כמה מארחים, הערך של ההגדרה min-nodes-per-pool צריך להיות 0 כי מאגרי הצמתים האלה הם אטומיים.
  • הגרסה המינימלית הנתמכת של GKE היא 1.33.3-gke.1118000.
  • יש תמיכה רק בתחזוקה מתוכננת שכוללת את ההתראה can_reschedule=TRUE.
  • כדי להשבית את התכונה הזו, צריך ליצור מחדש את מאגר הצמתים בלי הדגלים המתאימים. אפשר גם להשבית את התכונה באופן ידני בצמתים ספציפיים באמצעות cloud.google.com/opportunistic-disable=true.
  • במקרים נדירים, יכול להיות שפעולות התחזוקה בצומת יימשכו יותר זמן. לקוחות שמשתמשים בתכונה הזו עשויים לחוות פחות צמתים זמינים, עד לערך של ההגדרה min-nodes-per-pool, למשך פרק זמן מסוים.

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