במאמר הזה נסביר איך להגדיל את קיבולת המחשוב ולקבל משאבי חומרה ב- Google Cloud כדי לשמור על הביצועים, לשלוט בעלויות ולמנוע זמני השבתה. כדי להתמודד עם ביקוש משתנה, אתם יכולים להתאים אוטומטית לעומס את מכונות Compute Engine, לתזמר קונטיינרים ב-Google Kubernetes Engine (GKE) או עומסי עבודה באשכולות, לשריין קיבולת מראש ולפזר את התנועה בין המשאבים.
ההמלצות במסמך הזה רלוונטיות לכל אפשרויות המחשוב הזמינות, חוץ מ-Cloud Run ו-Batch, שמנהלים ומשנים את קנה המידה של תשתית המחשוב בשבילכם. למידע נוסף על אפשרויות המחשוב שאפשר להשתמש בהן ב- Google Cloud לפני ההרחבה, קראו את המאמר בחירת אפשרויות מחשוב.
אפשרויות התאמה לעומס (scaling) של תשתית המחשוב
כדי לשנות את היקף קיבולת המחשוב ולשפר את הזמינות של המשאבים, אתם יכולים לבחור מבין התכונות שנתמכות בשירות המחשוב שלכם. אתם יכולים לשלב כמה תכונות – כמו הזמנות, כלים להתאמה לעומס ואיזון עומסים – כדי להתאים לדרישות של עומס העבודה. כדי להשוות בין התכונות האלה זו לצד זו על סמך המטרה שלהן, אפשרויות המחשוב הנתמכות, הטריגרים ותרחישי השימוש, עיינו בקטע השוואה בין אפשרויות ההתאמה לעומס במסמך הזה.
כל שירות מחשוב משנה את הקיבולת ועוזר לכם לקבל משאבים באמצעות האפשרויות הבאות:
כל אפשרויות המחשוב: בכל שירותי המחשוב, חוץ מ-Cloud Run להזמנות, אתם יכולים לקבל רמה גבוהה של הבטחה לזמינות החומרה מראש, ולנתב בקשות של משתמשים בין קצוות עורפיים תקינים. אפשר להשתמש באפשרויות הבאות:
מקומות שמורים: בקשת קיבולת באזור ספציפי לשימוש מיידי או לתאריך עתידי. הזמנות מקום הן לא כלי להתאמה לעומס (autoscaler), אבל הן מספקות רמה גבוהה של ודאות שחומרה כמו יחידות עיבוד גרפיות (GPU), יחידות עיבוד Tensor (TPU) ודיסקים מקומיים של SSD זמינה כשהעומסים שלכם מתרחבים אופקית (scale out).
חלוקת תנועה באמצעות Cloud Load Balancing: חלוקת הבקשות הנכנסות בין מכונות, מאגרי צמתים או קונטיינרים תקינים, וניתוב התנועה למשאבים חדשים כשהקיבולת גדלה.
Compute Engine: אתם משנים את הקיבולת כשאתם יוצרים מכונות וירטואליות (VM) או מכונות Bare Metal, או כשאתם משתמשים בקבוצות של מופעי מכונה מנוהלים (MIG). קבוצת MIG מנהלת קבוצה של מכונות Compute כישות אחת, ויכולה להוסיף או להסיר קיבולת על סמך העומס, לוחות הזמנים או הזמינות של החומרה. לעומסי עבודה שדורשים בידוד חומרה, אתם יכולים גם להגדיר התאמה אוטומטית לעומס (scaling) של קבוצות צומתי דייר יחיד בשרתים פיזיים ייעודיים. אפשר להשתמש באפשרויות הבאות:
התאמה לעומס (autoscaling) של MIG: הוספה או הסרה של מכונות ב-MIG על סמך השימוש ב-CPU, הקיבולת של מאזן העומסים, מדדי Cloud Monitoring, לוחות זמנים או תחזיות.
הפעלה גמישה של מכונות ב-MIG: דירוג של כמה סוגי מכונות ב-MIG כדי לשפר את הזמינות של המשאבים.
מצב Bulk ובקשות לשינוי כמות ב-MIG: הוספה של כל המכונות המבוקשות ב-MIG בו-זמנית כשהקיבולת המלאה זמינה, כולל מכונות GPU, TPU ו-H4D עם Flex-start VM.
מאגרי המתנה בקבוצות MIG: שמירה על מאגר המתנה של מכונות מושהות או מופסקות שהוגדרו מראש בקבוצת MIG, כדי להאיץ את ההרחבה האופקית בהתאם לעומס (scale out). כשהתנועה או השימוש ב-CPU עולים, קבוצת ה-MIG מפעילה מחדש או מפעילה את המכונות במקום ליצור מכונות חדשות.
יצירת מכונות בכמות גדולה: יצירת כמה מכונות בבקשת API אחת, עם בחירה אוטומטית של אזור וסוג מכונה.
התאמה אוטומטית לעומס של קבוצת שרתים לדייר יחיד: הוספה או הסרה של שרתים פיזיים ייעדיים לדייר יחיד, בהתאם לדרישה של מכונות, כדי לשמור על בידוד החומרה ולבצע אופטימיזציה של העלויות של "החברה מביאה את הרישיון שלה" (BYOL).
כלי תזמור בהתאמה אישית: לשלוח קריאה ל-Compute Engine API מתזמנים משלכם או מתזמנים בקוד פתוח כדי ליצור, לשנות את הגודל ולמחוק מכונות על סמך תורים של משימות ייעודיות או כללים עסקיים.
Cluster Director: Google פורסת אשכולות מנוהלים לעומסי עבודה של בינה מלאכותית (AI), למידת מכונה (ML) ומחשוב עתיר ביצועים (HPC) שמשתמשים בתזמור של Slurm או בתזמור מנוהל של משאבי מחשוב שמגובה בקבוצות MIG אזוריות. באשכולות Slurm, מתזמן Slurm יוצר צומתי מחשוב דינמיים כשמשימות בתור חורגות מצומתי בסיס סטטיים, ומשבית אותם אחרי חמש דקות של חוסר פעילות. באשכולות מחשוב מנוהלים, אתם מריצים עומסי עבודה דרך SSH או משלבים מתזמן משלכם, ומשנים את הקיבולת כשאתם מתאימים את גודלי היעד של קבוצות MIG. אפשר להשתמש באפשרויות הבאות:
תזמור אשכולות: התאמה אוטומטית לעומס של צומתי מחשוב דינמיים במחיצות Slurm מנוהלות, על סמך הביקוש בתור המשימות, או הקצאת אשכולות מחשוב מנוהלים שמגובים על ידי קבוצות MIG אזוריות כדי להריץ עומסי עבודה באמצעות SSH או לשלב מתזמן משלכם.
שינוי אשכולות פעילים: עדכון אשכול פעיל כדי להגדיל את מספר הצמתים הסטטיים או הדינמיים המקסימליים, לשנות את הגודל של קבוצות מכונות מנוהלות (MIG) או להוסיף קבוצות כאלה, להוסיף הגדרות של משאבי מחשוב או להוסיף מחיצות וקבוצות צמתים בלי לשבש את המשימות הפעילות.
אפשרויות לצריכת קיבולת: קבלת צומתי מחשוב באשכול באמצעות מקומות שמורים לעתיד של בלוקים של קיבולת, מקומות שמורים לעתיד במצב תזמון, Flex-start VM, VM במודל Spot או מכונות מחשוב על פי דרישה.
Cluster Toolkit: אתם מגדירים אשכולות של AI, ML ו-HPC בניהול עצמי כקוד, באמצעות תוכניות אב של YAML ומודולים של Terraform שמתוזמרים על ידי Slurm או GKE. הקיבולת משתנה בהתאם לתורים של משימות Slurm או לביקוש ל-Kubernetes Pod, או כשעורכים ופורסים מחדש את תרשים האשכול. אפשר להשתמש באפשרויות הבאות:
קבוצות דינמיות של צמתים ב-Slurm: הגדרת המודול
slurm-nodeset-dynamicכך ש-Slurm יוצר ומוחק מכונות זמניות בהתאם למשימות בתור.התאמה אוטומטית לעומס של מאגר הצמתים ב-GKE: הגדירו את המספר המינימלי והמקסימלי של הצמתים בתוכנית באמצעות המודול
gke-node-pool, כדי ש-GKE יוסיף או יסיר צמתים בהתאם לשינויים בביקוש ל-Pod.הגדרה מחדש של תוכניות פעילות: עדכון ופריסה מחדש של תוכניות כדי להוסיף או לשנות את הגודל של מחיצות וצמתים סטטיים באשכול Slurm פעיל, או כדי לשנות את הגודל של מאגרי צמתים באשכול GKE שנפרס.
מחיצות Slurm עם כמה הקצאות: מקבצים כמה קבוצות של צמתים שמגובים בהקצאות למחיצת Slurm אחת, כדי שמשימות גדולות יתפרסו על פני הקצאות נפרדות.
GKE: הקיבולת משתנה בשתי שכבות. מגדילים אוטומטית את עומסי העבודה בהתאם לשינויים בביקוש, על ידי שינוי מספר הרפליקות של Pod או בקשות המעבד (CPU) והזיכרון של הקונטיינר. מגדילי קנה מידה אוטומטיים של תשתית מוסיפים או מסירים צמתים ומאגרי צמתים בסיסיים. במצב אוטומטי, Google מנהלת את קיבולת הצמתים בשבילכם. במצב רגיל, אתם מגדירים את ההתאמה האוטומטית לעומס של האשכול, את היצירה האוטומטית של מאגרי הצמתים ואת המשאבים המותאמים אישית של
ComputeClass. התכונה "מאיצים להפעלה" גם מקצרת את הזמן שנדרש ל-Pods חדשים לפני שהם יכולים לטפל בתנועה. אפשר להשתמש באפשרויות הבאות:קיבולת של צמתים ואשכולות: התאמת מספר הצמתים, יצירת מאגרי צמתים וקבלת חומרה עם התכונות הבאות:
ComputeClasses בהתאמה אישית: הגדרת כללים חלופיים לחומרה לפי סדר עדיפויות, מכונות וירטואליות במחיר Spot או העדפות Flex-start, צריכת הזמנות, העברה פעילה לחומרה בעדיפות גבוהה יותר ויצירה אוטומטית של מאגרי צמתים ברמת עומס העבודה.
מידרוג אוטומטי של אשכולות: הוספה או הסרה של צמתים במאגרי צמתים קיימים במצב ידני, כשה-Pods ממתינים למשאבים או כשהצמתים לא מנוצלים מספיק.
יצירה אוטומטית של מאגרי צמתים: יצירה ומחיקה של מאגרי צמתים במקביל, על סמך הדרישות של Pods בהמתנה ל-CPU, לזיכרון, ל-GPU, ל-TPU או לאזור.
הקצאת משאבים בהתחלה גמישה (Flex-start): קבלת מעבדי GPU, מעבדי TPU וצומתי H4D למשך עד שבעה ימים, צומת אחרי צומת או בבת אחת באמצעות הקצאת משאבים בהמתנה, והחלפת צמתים שתוקפם פג באמצעות ComputeClasses.
מאגרים זמניים למשאבי מחשוב: הקצאה מראש של צומתי המתנה פעילים או מושעים, כולל מאגרים זמניים פעילים שתואמים לסדרי העדיפויות של
ComputeClass, כדי שפודים בהמתנה יתוזמנו בלי לחכות לצמתים חדשים.פלטפורמת מחשוב מותאמת לקונטיינרים: הקצאת צמתים ומיקום Pod מהירים יותר באמצעות
Balancedו-Scale-OutComputeClasses לאשכולות Autopilot ולעומסי עבודה במצב Autopilot באשכולות Standard.צמתים של דייר יחיד ב-GKE: מריצים מאגרי צמתים במצב Standard בשרתים פיזיים ייעודיים כדי לעמוד בדרישות הבידוד או הרישוי.
קיבולת של Pod ועומס עבודה: התאמת רפליקות של Pod, גודלי קונטיינרים ותורים של אצווה באמצעות התכונות הבאות:
התאמה אופקית של קבוצות Pod לעומס (HPA): הוספה או הסרה של רפליקות של Pod על סמך השימוש ב-CPU, השימוש בזיכרון או מדדים בהתאמה אישית.
התאמה אנכית של קבוצות Pod לעומס (VPA): התאמת הבקשות והמגבלות של המעבד (CPU) והזיכרון של הקונטיינר על סמך היסטוריית השימוש.
התאמה רב-ממדית לעומס (autoscaling) של Pod (MPA): שילוב של HPA במעבד (CPU) ו-VPA בזיכרון לאותו עומס עבודה בו-זמנית.
מדדים בהתאמה אישית ומדדים חיצוניים: הפעלת החלטות לגבי שינוי קנה מידה של HPA ממדדי אפליקציות או משירותים חיצוניים כמו Pub/Sub ו-Cloud Load Balancing.
צמצום הפעולה לאפס: צמצום הפעולה של Pods ומאגרי צמתים לא פעילים לאפס רפליקות, והפעלה שלהם מחדש כשהביקוש מתחדש במדדים מותאמים אישית וחיצוניים של HPA או בטריגרים של Kubernetes Event-driven Autoscaling (KEDA).
תורי משימות ב-Kueue: הוספה לתור של עומסי עבודה באצווה וב-AI, שיתוף של מכסות משאבים בין צוותים ותיאום של הקצאת צמתים בו-זמנית.
האצת ההפעלה: קיצור זמני הטעינה של המודל והאתחול של הקונטיינר במהלך הרחבה אופקית בהתאם לעומס (scale out) באמצעות התכונות הבאות:
Cloud Storage FUSE עם סטרימינג במקביל: טעינת קטגוריות של Cloud Storage כמערכות קבצים מקומיות עם קריאות במקביל ומטמוני קבצים.
האצת המעבד בזמן אתחול: הקצאת מעבד זמני נוסף לקונטיינרים בזמן שהם מבצעים אתחול, ואז החזרת בקשות המעבד לערכי הבסיס.
סטרימינג של קובצי אימג': סטרימינג של בלוקים של קובצי אימג' של קונטיינרים על פי דרישה מ-Artifact Registry, כדי שהפודים יתחילו לפעול בלי לחכות להורדה של קובץ האימג' כולו.
דיסקי אתחול משניים: חיבור של נפחי Persistent Disk שנטענו מראש עם קובצי אימג' של קונטיינרים או נתוני מודלים לצמתים במקביל במהלך אתחול הצומת.
שינוי גודל של Pod במקום: עדכון הקצאות המעבד (CPU) והזיכרון בקונטיינרים פעילים בלי להפעיל מחדש את ה-Pod.
תמונות מצב של Pod: שחזור רפליקות של Pod מנקודות בדיקה שמורות של הזיכרון ומערכת הקבצים, במקום אתחול קר.
Run:ai Model Streamer: סטרימינג של משקלי מודל AI בפורמט
safetensorsמ-Cloud Storage או מנפחי אחסון קבועים במקביל לזיכרון GPU או TPU.Volume Populator: טעינה מראש של נפחי Google Cloud Hyperdisk ML עם משקלי מודלים ומערכי נתונים מ-Cloud Storage לפני שה-Pods מתחילים.
Google Cloud VMware Engine: Google מנהלת אשכולות ייעודיים של ענן פרטי ב-VMware, שבהם הקיבולת גדלה או קטנה כשמארחי ESXi פיזיים מצטרפים לאשכול או עוזבים אותו. כדי להוסיף או להסיר מארחי ESXi כששימוש מתמשך במעבד (CPU), בזיכרון או באחסון vSAN חורג מהספים שהגדרתם, השתמשו בכללי מדיניות להתאמה לעומס.
השוואה בין אפשרויות ההתאמה לעומס (scaling)
כדי לבחור את אפשרות ההתאמה לעומס או את אפשרות השגת המשאבים שמתאימה לדרישות התפעוליות שלכם, השוו בין התכונות בטבלה הבאה:
| אפשרות התאמה לעומס (scaling) | המטרה העיקרית | אפשרויות המחשוב הנתמכות | אפשרויות התאמה תואמות | טריגר להתאמה לעומס (scaling) | תרחישים לדוגמה |
|---|---|---|---|---|---|
| הזמנות | שמירת קיבולת באזור לשימוש מיידי או לתאריך עתידי, עם רמת זמינות גבוהה | כל אפשרויות המחשוב, חוץ מ-Cloud Run | כל אפשרויות ההתאמה | בקשה ידנית או בקשה להזמנה ביומן; לא מידרוג אוטומטי |
|
| חלוקת תנועה באמצעות Cloud Load Balancing | חלוקת התנועה הנכנסת בין מכונות, מאגרי צמתים או קונטיינרים תקינים | כל אפשרויות המחשוב | כל אפשרויות ההתאמה | בקשות נכנסות של משתמשים ובדיקות תקינות של קצה עורפי |
|
| התאמה אוטומטית לעומס (scaling) של MIG | הוספה או הסרה של מכונות ב-MIG בהתאם לעומס העבודה המשתנה | Compute Engine | הזמנות, הפעלה גמישה של מכונות ב-MIG, מאגרי המתנה ב-MIG, התאמה לעומס (autoscaling) של קבוצות צמתים של שרתים לדייר יחיד (sole-tenant), כלי מותאם אישית לניהול תזמור (orchestrator) | שימוש במעבד (CPU), קיבולת של מאזן העומסים, מדדים של Cloud Monitoring, לוחות זמנים או תחזיות |
|
| הפעלה גמישה של מכונות ב-MIG | דירוג של כמה סוגי מכונות ב-MIG כדי לשפר את הזמינות של המשאבים | Compute Engine | התאמה אוטומטית לעומס (autoscaling) של קבוצות MIG, מקומות שמורים, VM במודל Spot | כשאין מספיק קיבולת בסוגי המכונות הראשיים במהלך יצירה או הרחבה אופקית של מכונות ב-MIG |
|
| מצב Bulk ובקשות לשינוי כמות בקבוצות MIG | הוספה של כל המכונות המבוקשות ב-MIG בו-זמנית, כשהקיבולת המלאה תהיה זמינה | Compute Engine ו-Cluster Director | הזמנות, שינוי אשכולות בזמן אמת, כלי תזמור בהתאמה אישית | גודל היעד שמוגדר במצב Bulk או יצירה של בקשה לשינוי כמות, שמתמלאת כשקיבולת החומרה המלאה זמינה |
|
| מאגרי מכונות במצב המתנה בקבוצות MIG | להחזיק מאגר המתנה של מכונות מושהות או מופסקות שהוגדרו מראש, כדי להאיץ את ההרחבה האופקית של קבוצת המכונות המנוהלת (MIG) | Compute Engine | התאמה אוטומטית לעומס (autoscaling) בקבוצות MIG, הזמנות | שינוי גודל ידני או דרישה להרחבה אופקית בהתאם לעומס (scale out) של קבוצת מכונות מנוהלות (MIG), שמחדשת או מתחילה מכונות מאגר (pooled) של Compute Engine |
|
| יצירת כמות גדולה של מכונות | יצירת כמה מכונות בבקשת API אחת, עם בחירה אוטומטית של אזור ומכונה | Compute Engine | מקומות שמורים, VM במודל Spot, כלי תזמור בהתאמה אישית | בקשה להוספה בכמות גדולה באמצעות API יחיד או Google Cloud CLI |
|
| התאמה לעומס (autoscaling) של קבוצת שרתים לדייר יחיד (sole-tenant) | התאמה אוטומטית לעומס (Autoscale) של שרתים פיזיים ייעודיים לעומסי עבודה מבודדים | Compute Engine ו-GKE | מקומות שמורים, התאמה אוטומטית לעומס (automatic scaling) של MIG, כלי תזמור בהתאמה אישית, מידרוג אוטומטי של אשכולות | הביקוש למשאבים של מכונות אורח |
|
| תזמור בהתאמה אישית | לשלוט ביצירה של מכונות, בגודל היעד של קבוצות MIG ובמחיקה שלהן באמצעות מתזמן משלכם, כמו Ray, SkyPilot או HTCondor. | Compute Engine ו-Cluster Director | מקומות שמורים, התאמה לעומס (autoscaling) של קבוצות מנוהלות של מכונות (MIG), מצב Bulk ובקשות לשינוי כמות בקבוצות מנוהלות של מכונות, יצירת מכונות בכמות גדולה, התאמה לעומס של קבוצות של צומתי דייר יחיד (sole-tenant), שינוי אשכולות בזמן אמת | מדדים עסקיים בהתאמה אישית או תורים של מתזמנים חיצוניים |
|
| תזמור Slurm וצמתים דינמיים | התאמה אוטומטית לעומס של צומתי מחשוב דינמיים במחיצות Slurm למשימות באצווה, ל-AI ול-HPC | Cluster Director ו-Cluster Toolkit | מקומות שמורים, Flex-start VM, VM במודל Spot, שינוי אשכולות בזמן אמת, הגדרה מחדש של תוכניות בזמן אמת | משימות Slurm בתור וזמני קצובים לתפוגה של צומת לא פעיל |
|
| שינוי אשכולות בזמן אמת | הוספה או שינוי של הגודל של מחיצות, קבוצות צמתים, קבוצות של מכונות מנוהלות (MIG) או מגבלות של צמתים סטטיים ודינמיים באשכול פעיל | Cluster Director | תזמור Slurm וצמתים דינמיים, מצב Bulk ובקשות לשינוי כמות ב-MIG, תזמור בהתאמה אישית, הזמנות | בקשה לעדכון אשכול באשכול פעיל |
|
| הגדרה מחדש של תוכנית בזמן אמת | עדכון ופריסה מחדש של תוכניות כדי להוסיף או לשנות את הגודל של מחיצות Slurm, צמתים סטטיים או מאגרי צמתים של GKE באשכול פעיל | Cluster Toolkit | תזמור Slurm וצמתים דינמיים, התאמה אוטומטית לעומס (autoscaling) באשכול, הזמנות | עדכון ופריסה מחדש של תוכנית באשכול פעיל |
|
| ComputeClasses בהתאמה אישית | הגדרת כללי חומרה חלופיים לפי עדיפות, צריכת קיבולת והעברת צמתים | GKE במצב Standard ובמצב Autopilot | התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, הקצאת משאבים מסוג "התחלה גמישה" (Flex-start) ב-GKE, הזמנות, מאגרים זמניים למשאבי מחשוב | פודים בהמתנה שתואמים לבורר ComputeClass או
זמינות של חומרה בעדיפות גבוהה יותר |
|
| Cluster autoscaler | הוספה או הסרה של צמתים במאגרי צמתים קיימים | GKE במצב Standard ותוכניות של Cluster Toolkit ל-GKE | ComputeClasses בהתאמה אישית, מקומות שמורים, התאמה אוטומטית לעומס של קבוצת שרתים לדייר יחיד, HPA, VPA, מאגרים זמניים למשאבי מחשוב, צמצום הפעולה לאפס | תרמילים בהמתנה או ניצול חלקי של צמתים |
|
| יצירה אוטומטית של מאגרי צמתים | יצירה ומחיקה של מאגרי צמתים במקביל כדי להתאים לדרישות החומרה של Pod | GKE: מנוהל במצב Autopilot, ניתן להגדרה במצב Standard | ComputeClasses בהתאמה אישית, הזמנות, הקצאת משאבים מסוג Flex-start ב-GKE, HPA, VPA, מאגרים זמניים למשאבי מחשוב | פודים בהמתנה שדורשים סדרות מכונות, מאיצים או אזורים שלא קיימים במאגרי הצמתים הקיימים |
|
| הקצאת משאבים בהתחלה גמישה ב-GKE | אפשר לקבל צומתי GPU, TPU ו-H4D כשהקיבולת מתפנה, לכל צומת בנפרד או לכולם בבת אחת באמצעות הקצאת משאבים בהמתנה | GKE במצב Standard ובמצב Autopilot | ComputeClasses בהתאמה אישית, יצירה אוטומטית של מאגרי צמתים, מידרוג אוטומטי של אשכולות, תורי משימות של Kueue | פודים בהמתנה או אובייקטים של ProvisioningRequest בתור כשקיבולת החומרה נפתחת |
|
| מאגרים זמניים למשאבי מחשוב | הקצאה מראש של צומתי המתנה פעילים או מושעים לצורך מיקום וזמינות מהירים של Pod | GKE במצב Standard ובמצב Autopilot | ComputeClasses בהתאמה אישית, מידרוג אוטומטי של אשכולות, יצירה אוטומטית של מאגרי צמתים, HPA, מקומות שמורים | צריכת הקיבולת של צומת מאגר נתונים זמני על ידי Pods מתוזמנים |
|
| פלטפורמת מחשוב שמותאמת לקונטיינרים | האצת המוכנות של הצמתים והמיקום של Pods באמצעות תשתית מנוהלת ו-ComputeClasses מסוג Balanced או Scale-Out |
GKE: אשכולות Autopilot ועומסי עבודה במצב Autopilot באשכולות Standard | יצירה אוטומטית של מאגרי צמתים, HPA, VPA, מאגרים זמניים למשאבי מחשוב, מקומות שמורים | פודים בהמתנה שדורשים קיבולת מחשוב נוספת |
|
| HPA | הוספה או הסרה של רפליקות של Pod בהתאם לעומס העבודה | GKE במצב Standard ובמצב Autopilot | התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, MPA, מדדים מותאמים אישית וחיצוניים, צמצום הפעולה לאפס | שימוש במעבד (CPU), שימוש בזיכרון או מדדים מותאמים אישית וחיצוניים |
|
| VPA | התאמת הבקשות והמגבלות של המעבד (CPU) והזיכרון של הקונטיינר על סמך השימוש | GKE במצב Standard ובמצב Autopilot | התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, MPA, שינוי גודל של Pod במקום, הזמנות | היסטוריית השימוש במעבד (CPU) ובזיכרון של הקונטיינר |
|
| MPA | התאמה של מספר הרפליקות של Pod לפי בקשות למעבד (CPU) ולזיכרון של קונטיינר בו-זמנית | GKE במצב Standard ובמצב Autopilot | התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, מדדים מותאמים אישית ומדדים חיצוניים | שינויים בו-זמניים בביקוש למעבד (CPU) ובשימוש בזיכרון של הקונטיינר |
|
| מדדים מותאמים אישית ומדדים חיצוניים | שינוי קנה המידה של רפליקות של Pod על סמך אותות של אפליקציה או שירות חיצוני | GKE במצב Standard ובמצב Autopilot | HPA, MPA, צמצום הפעולה לאפס, מידרוג אוטומטי של אשכולות, יצירה אוטומטית של מאגרי צמתים | מדדי אפליקציה או מדדי תנועה ותור חיצוניים |
|
| צמצום הפעולה לאפס | הפחתה בהתאם לעומס של מאגרי צמתים ו-Pods לא פעילים לאפס, והפעלה שלהם לפי דרישה או לפי אירועים | GKE במצב Standard ובמצב Autopilot | HPA, מדדים מותאמים אישית וחיצוניים, מידרוג אוטומטי של אשכול, יצירה אוטומטית של מאגר צמתים | היעדר ביקוש או ביקוש חדש במדדים מותאמים אישית וחיצוניים של HPA או בטריגרים של KEDA |
|
| תורי משימות ב-Kueue | הוספת משימות באצווה לתור, אכיפת מכסות לצוותים ותיאום הקצאת צמתים בו-זמנית | GKE במצב Standard ובמצב Autopilot | הקצאת משאבים מסוג Flex-start ב-GKE, ComputeClasses בהתאמה אישית, התאמה אוטומטית לעומס (automatic scaling) של אשכולות, יצירה אוטומטית של מאגרי צמתים | משימות באצווה שהתקבלו כשמכסת האשכול וקיבולת החומרה נפתחו |
|
| Cloud Storage FUSE עם סטרימינג במקביל | טעינת קטגוריות של Cloud Storage כמערכות קבצים עם קריאות ומטמונים מקבילים | GKE במצב Standard ובמצב Autopilot | HPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, קובצי snapshot של Pod | הפעלת Pod וקריאת קבצים ברצף מקטגוריות שנטענו |
|
| האצת המעבד בזמן אתחול | הקצאת מעבד (CPU) נוסף באופן זמני לקונטיינרים במהלך האתחול | GKE במצב Standard ובמצב Autopilot | HPA, VPA, התאמה אוטומטית לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים | שלב ההפעלה והאתחול של הקונטיינר |
|
| סטרימינג של תמונות | העברת בלוקים של קובצי אימג' של קונטיינרים לפי דרישה מ-Artifact Registry במהלך הפעלת Pod | GKE במצב Standard ובמצב Autopilot | HPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, מאגרים זמניים למשאבי מחשוב | שליפת קובץ אימג' של קונטיינר מ-Artifact Registry כש-Pod מתחיל לפעול |
|
| דיסקי אתחול משניים | צירוף של אמצעי אחסון מסוג Persistent Disk שנטענו מראש עם קובצי אימג' של קונטיינרים או נתוני מודלים בזמן ההפעלה של הצומת | GKE במצב Standard ובמצב Autopilot | ComputeClasses בהתאמה אישית, HPA, כלי להתאמה לעומס (autoscaler) של אשכולות, הקצאה אוטומטית של מאגרי צמתים, מאגרים זמניים למשאבי מחשוב | אתחול צומת במאגר צמתים שמוגדר עם קובצי אימג' של דיסק אתחול משני |
|
| שינוי הגודל של Pod במקום | עדכון הקצאות המעבד והזיכרון של קונטיינר פעיל בלי להפעיל מחדש את ה-Pod | GKE במצב Standard ובמצב Autopilot | VPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים | עדכון בקשות ומגבלות של מעבד (CPU) או זיכרון של קונטיינר |
|
| תמונות מצב של Pod | שחזור רפליקות של Pod מנקודות בדיקה שמורות של זיכרון ומערכת קבצים | GKE במצב Standard ובמצב Autopilot | HPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, מאגרים זמניים למשאבי מחשוב | יצירת רפליקה של Pod מתמונת מצב שמורה |
|
| Run:ai Model Streamer | העברת טנזורים של מודלים בסטרימינג במקביל לזיכרון של GPU או TPU | GKE במצב Standard ובמצב Autopilot | HPA, התאמה אוטומטית לעומס (automatic scaling) של אשכולות, יצירה אוטומטית של מאגרי צמתים, Volume Populator | בקשות להפעלת שרת הסקת מסקנות של AI ולטעינת מודלים |
|
| Volume Populator | טעינה מראש של נתונים מ-Cloud Storage לנפחי Hyperdisk ML | GKE במצב Standard ובמצב Autopilot | HPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, קובצי snapshot של Pod | יצירת PersistentVolumeClaim שמפנה למשאב GCPDataSource |
|
| כללי מדיניות של התאמה אוטומטית לעומס | הוספה או הסרה של מארחי ESXi באשכול ענן פרטי של VMware | VMware Engine | Cloud Load Balancing | שימוש מתמשך במעבד (CPU), בזיכרון או בנפח אחסון נדרש של vSAN |
|
שיטות מומלצות ליכולת התאמה לעומס (scalability)
כדי לתכנן תשתית שניתנת להתאמה בלי צווארי בקבוק או מחסור בקיבולת, כדאי ליישם את השיטות המומלצות שבקטע הזה על קיבולת המחשוב, תכנון הרשת והארכיטקטורה של האפליקציה.
תכנון קיבולת המחשוב והזמינות שלה
כדי להכין את התשתית לעלייה בביקוש ולשפר את הזמינות של החומרה, כדאי ליישם את השיטות הבאות:
הערכת הצרכים של עומס העבודה: לפני שמגדירים את ההתאמה האוטומטית לעומס, צריך למדוד את השימוש הבסיסי ואת התנודות בשיא. כדי לבדוק את היסטוריית השימוש, לחזות את הביקוש ולהגדיר מגבלות מינימום ומקסימום מדויקות למכונות, אתם יכולים להשתמש ב-Capacity Planner.
תכנון להשגת משאבים: כשמבקשים חומרה נדירה כמו GPU או TPU, צריך לייעל את הקצאת המשאבים בשלושת הממדים הבאים:
גמישות במיקום: פיזור עומסי עבודה בין אזורים באמצעות קבוצות MIG אזוריות.
גמישות בסוגי המכונות: מאפשרים כמה סדרות של מכונות באמצעות גמישות במכונות MIG או ComputeClasses בהתאמה אישית ב-GKE.
גמישות בזמן: השתמשו בהקצאת משאבים מסוג "התחלה גמישה" (Flex-start) כשהמשימות יכולות להמתין לקיבולת.
שימוש במקומות שמורים כדי להבטיח קיבולת גבוהה: לתעבורת נתונים בסיסית, לאירועי שיא של הרחבת העומס או ליחידות GPU ו-TPU נדירות, שריינו קיבולת מראש. הזמנות מספקות רמה גבוהה של ודאות שהמשאבים זמינים באזור היעד כשעומסי העבודה מתרחבים אופקית (scale out). אם משימה אחת ב-Slurm חורגת מהזמנה אחת, צריך לפרוס את המחיצות של Cluster Toolkit על פני כמה הזמנות.
חימום מראש של קיבולת פנויה לעומסי עבודה שרגישים לזמן אחזור: אם האפליקציה לא יכולה להמתין להקצאה של מכונות חדשות במהלך עליות פתאומיות בתנועה, כדאי לשמור על קיבולת פנויה שמוכנה לשימוש. מגדירים מאגרים זמניים למשאבי מחשוב ב-GKE כדי להקצות מראש צמתים פעילים או צמתים במצב המתנה, או משתמשים במאגרים במצב המתנה בקבוצות של מכונות מנוהלות (MIG) ב-Compute Engine כדי להמשיך את הפעילות של מכונות מושעות בלי עיכובים שנובעים מהפעלה מלאה של מערכת ההפעלה.
איך מעצבים רשתות שניתנות להרחבה
כדי להעביר נתונים בין משאבים מותאמים בלי עיכובים או ניצול מלא של הכתובות, כדאי ליישם את השיטות הבאות ברשת:
הקצאת מספיק כתובות IP: מוודאים שיש ברשתות המשנה מספיק כתובות IP פנויות למספר המקסימלי של המכונות או הצמתים במגבלות של המנגנון להתאמה לעומס. ב-GKE, צריך לבדוק גם את טווחי ה-IP המשניים של Pods ו-Services. אם נגמרות כתובות ה-IP ברשת המשנה, המערכות להתאמה אוטומטית של קנה המידה לא יכולות ליצור מכונות או Pods חדשים.
בחירת ממשקי רשת עם קצב העברת נתונים גבוה: לעומסי עבודה שמעבירים קבוצות נתונים גדולות או משקלי מודלים בין צמתים, בחרו בקרים של כרטיסי רשת עם רוחב פס גבוה, כמו כרטיס ממשק רשת וירטואלי של Google או גישה ישירה מרוחקת לזיכרון (RDMA). הממשקים האלה מפחיתים את התקורה של המעבד (CPU) ומגדילים את רוחב הפס בין מכונות מותאמות לעומס.
אופטימיזציה של מיקום המכונות: כשמדובר באימון AI עם כמה צמתים או במשימות HPC, כדאי לקבץ מכונות בשרתים פיזיים קרובים באמצעות מדיניות למיקום קומפקטי או מיקום שמותאם לטופולוגיה ב-Cluster Director וב-Cluster Toolkit. מיקום פיזי קרוב מפחית את מספר הדילוגים ברשת ואת זמן האחזור בין צמתים מרובים. בשירותי אינטרנט עמידים בכשלים, כדאי לפזר את המכונות בין אזורים שונים כדי שהפסקה זמנית בשירות באזור אחד לא תשבש את תעבורת הנתונים.
תכנון אפליקציות שניתנות להרחבה
כדי שהאפליקציות יוכלו להתרחב ולהצטמצם בלי להפריע למשתמשים, כדאי ליישם את שיטות הארכיטקטורה הבאות:
שמירה על שכבות אפליקציה ללא מצב (stateless): אחסון נתוני סשן של משתמשים, נקודות ביקורת וקבצים משותפים באחסון חיצוני או במסדי נתונים, במקום בדיסקים של מכונות מקומיות. העיצוב הזה מאפשר למגדילי קנה מידה אוטומטיים להוסיף או להסיר מכונות ו-Pods בכל שלב בלי לאבד נתונים.
הפרדת רכיבים באמצעות תורים ומיקרו-שירותים: פיצול עומסי עבודה מונוליתיים לשירותים עצמאיים שמחוברים באמצעות מאזני עומסים או תורי הודעות כמו Pub/Sub. הארכיטקטורה הזו מאפשרת לכם להתאים את קנה המידה של כל שירות לפי הביקוש שלו – כולל עד לאפס עם מגדילי קנה מידה מבוססי-אירועים – ולספוג פרצי תנועה בלי עומס יתר על קצוות עורפיים במורד הזרם.
קיצור זמני ההפעלה של הקונטיינר וטעינת המודל: צמצום העיכוב בין יצירת המשאבים לבין המוכנות לתנועה, כדי שהקיבולת המוגדלת תטפל בבקשות באופן מיידי. ב-GKE, אפשר להעביר בסטרימינג או לטעון מראש קובצי אימג' של קונטיינרים ולהשתמש ב-CPU startup boost או בתמונות מצב של Pod כדי להאיץ את ההפעלה של זמן הריצה. לעומסי עבודה של AI, אפשר להעביר בסטרימינג משקלי מודלים מ-Cloud Storage FUSE, מ-Run:ai Model Streamer או מנפחים שאוכלסו מראש.