במהלך מחזור החיים של אשכול GKE שפועל לאורך זמן, מתרחשות מדי פעם הפרעות לעומסי העבודה בגלל שיבושים בתשתית ש-Google Cloud מנפיקה. האירועים האוטומטיים האלה יכולים להתרחש בתגובה להחלטות תזמון (אירועי הפקעה), או לעדכוני צמתים, שכוללים שדרוגים אוטומטיים של צומתי GKE (אירועי תחזוקה), או תיקון של בעיות שזוהו (אירועי סיום).
במאמר הזה נסביר מה המשמעות של שיבושים בצמתים ב-GKE ואיך לצמצם את ההשפעה של השיבושים בצמתים ב-GKE.
למידע נוסף על מעקב אחרי התראות ואירועים של תחזוקה, ראו מעקב אחרי אירועי תחזוקה.
המסמך הזה רלוונטי לסוגי המכונות הבאים:
- סוגי מכונות עם מעבדי GPU או TPU מצורפים
- סוגי מכונות H4D
- מכונות מסוג Z3 עם יותר מ-18TiB של Titanium SSD מחובר.
- מכונות מסוג Z4D עם יותר מ-42TiB של Titanium SSD מחובר.
- מכונות מסוג Z4M עם יותר מ-48TiB של Titanium SSD מחובר, או כל מכונת Z4M שמשתמשת ב-Cloud RDMA.
- מכונות Bare Metal מסדרת המכונות C4A. מידע נוסף זמין בקטע דרישות ומגבלות במסמך "עומסי עבודה של Arm ב-GKE".
- מכונות Bare Metal מסדרת המכונות C4D.
- צומתי Confidential GKE שמשתמשים בסוגי מכונות שלא תומכים במיגרציה פעילה.
המסמך הזה מיועד לאדמינים ולמפעילים של פלטפורמות שמנהלים את מחזור החיים של התשתית הטכנית הבסיסית. במאמר תפקידים ומשימות נפוצים של משתמשי GKE מפורטים תפקידים נפוצים ודוגמאות למשימות שמוזכרות בתוכן של Google Cloud .
מה המשמעות של הפסקת תשתית ב-GKE?
אשכולות GKE מנהלים את מחזור החיים של צומתי GKE. הצמתים האלה מוקצים במכונות וירטואליות של Compute Engine, שבהן מתרחשות מדי פעם ההפרעות הבאות:
תיקון בעיות שזוהו (
TerminationEvent): האירועים האלה מתרחשים כי Google Cloud מזהה בעיה ומשבש את התשתית של האשכול. אירועיTerminationEventלא תומכים בכיבוי מבוקר. אירועיTerminationEventמופעלים בגלל הבעיות הבאות:- תיקון אוטומטי מתרחש כש-GKE מתקן צומת אחרי כמה בדיקות תקינות שנכשלו.
- HostError: שגיאה בחומרה או בתוכנה במכונה הפיזית שגורמת ל-VM להפסיק לפעול.
אירועי תחזוקה או שדרוג (
MaintenanceEvent): האירועים האלה מתרחשים כש- Google Cloud צריך להפריע למכונה וירטואלית כדי לבצע תחזוקה. האירועים האלה מופעלים על ידי משימות התחזוקה הבאות:- אירועי תחזוקה מתרחשים כש- Google Cloud משדרגת את המארח הבסיסי.
- עדכוני צמתים, כולל שדרוגים אוטומטיים של צמתים, מתרחשים כש-GKE מעדכן את ההגדרות של הצומת, כמו גרסת GKE.
במאמר סוגי שינויים מוסבר איך אתם ו-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.
ניהול השיבושים בצמתים במהלך אירועי תחזוקה של מארחים מתבצע בתהליך עבודה בן שלושה שלבים:
- זיהוי תחזוקה מתוזמנת של מארח: באמצעות תוויות של צומתי GKE, נקודות קצה של מטא-נתונים או יומנים.
- פעולה בהתאם לעבודות התחזוקה שזוהו: אם מתוזמנות עבודות תחזוקה, צריך להעריך את התשתית ואת עומסי העבודה ולקבוע מהי הפעולה הטובה ביותר לתרחיש לדוגמה. מבצעים את הפעולה המתאימה, כמו לאפשר למערכת לטפל באירוע התחזוקה באופן אוטומטי, להתחיל באופן ידני את תחזוקת המארח או לתזמר אסטרטגיות תחזוקה.
- אימות התוצאה של אירוע התחזוקה: מוודאים שאירוע התחזוקה התחיל כמו שצריך, כשהוא מתחיל ב-Compute Engine לפי לוח הזמנים או כשאתם מתחילים אותו ידנית.
זיהוי פעולות תחזוקה מתוזמנות במארח
כדי לעקוב אחרי אירועי תחזוקה קרובים ולזהות אותם, צריך להציג את ההתראות גם מ-GKE וגם מ-Compute Engine.
למידע נוסף על מעקב אחרי התראות ואירועים של תחזוקה, ראו מעקב אחרי אירועי תחזוקה.
ביצוע פעולות בהתאם לתחזוקה שזוהתה
אם מופיעה התראה על תחזוקה מתוזמנת קרובה של צומת אחד או יותר באשכול, תוכלו להשתמש בעץ ההחלטות הבא כדי לקבוע מהי הדרך הטובה ביותר להתמודד עם השיבוש:
תחזוקה אוטומטית: מאפשרים ל-Compute Engine להתחיל את אירוע התחזוקה לפי לוח הזמנים. המכונות הווירטואליות שלכם יעברו באופן אוטומטי מיגרציה פעילה ברקע, עם הפרעה מינימלית או ללא הפרעה בכלל.
- אם המכונה המארחת תומכת במיגרציה פעילה, מומלץ לאפשר לאירוע התחזוקה להתרחש באופן אוטומטי.
- אם עומסי העבודה פועלים בצמתים גמישים במצב חוסר פעילות, אתם יכולים לבצע אופטימיזציה של תזמון התחזוקה באופן אוטומטי על ידי הגדרת תחזוקה אופורטוניסטית. כך העדכונים הנדרשים מופעלים רק בזמנים שבהם המכשיר לא בשימוש.
התחלה ידנית של אירוע תחזוקה במארח: כדי לקבוע מהי הדרך הטובה ביותר לטפל באופן ידני בשיבוש, צריך לענות על השאלות הבאות:
האם הצמתים המושפעים הם מכונות וירטואליות בודדות או מבודדות?
- כן (אני מפעיל/ה מכונה וירטואלית אחת או מבודדת):
- אם אתם לא צריכים אמצעי בקרה מדויקים על התזמון, תנו ל-Compute Engine להתחיל את אירוע התחזוקה לפי לוח הזמנים (אוטומטי כברירת מחדל).
- כדי למנוע הפקעה לא צפויה, הפעילו ידנית את אירוע התחזוקה של המארח בצומת הספציפי בזמן שנוח לכם, למשל בחלונות זמן של תנועה מועטה.
- לא (אני מריץ מאגר צמתים של מאיצים): בוחרים אחת מהאפשרויות בשלב הבא.
- כן (אני מפעיל/ה מכונה וירטואלית אחת או מבודדת):
בוחרים אחת מהאפשרויות הבאות בהתאם לתרחיש לדוגמה:
אם מאגר המאיצים מריץ משימות אימון משולבות של 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 מבצע את הפעולות הבאות:
- Taints (פגמים) בצומת.
- פינוי פודים בצורה חלקה.
- מבקשת מ-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 מבצע סגירה הדרגתית של צומת כשיש השבתה קרובה של צומת:
- בתוך 60 שניות, יקרו הדברים הבאים:
- רכיבי המערכת מחילים את תווית הצומת
cloud.google.com/active-node-maintenanceשמוגדרת ל-ONGOINGכדי לציין שעומסי העבודה נעצרים. - GKE מחיל את ה-taint על הצומת כדי למנוע תזמון של Pods חדשים בצומת. ל-taint יש את המפתח
cloud.google.com/impending-node-termination:NoSchedule. אנחנו ממליצים לא לשנות את עומסי העבודה כדי לסבול את הכתם הזה, בגלל הסיום הידוע שמתרחש.
- רכיבי המערכת מחילים את תווית הצומת
- הרכיב maintenance-handler מתחיל לפנות Pods, קודם את ה-Pods של עומסי העבודה ואחר כך את ה-Pods של המערכת (לדוגמה, kube-system).
- GKE שולח אות כיבוי
SIGTERMלפודים של עומסי עבודה שפועלים בצומת, כדי להתריע על כיבוי קרוב. פודים יכולים להשתמש בהתראה הזו כדי לסיים את כל המשימות שמתבצעות. GKE עושה כמיטב יכולתו כדי לסיים את הפעילות של הפודים האלה בצורה תקינה. - בסיום הפינוי, 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, למשך פרק זמן מסוים.
המאמרים הבאים
- במאמר מעקב אחרי אירועי תחזוקה מוסבר איך עוקבים אחרי התראות ואירועים שקשורים לתחזוקה.
- איך פורסים עומסי עבודה של GPU ב-Autopilot
- איך פורסים עומסי עבודה של TPU ב-GKE Autopilot
- מידע על תהליך ההעברה של מכונות וירטואליות פעילות במהלך אירועי תחזוקה
- איך עוקבים אחרי אירועי תחזוקה