סקירה כללית של הגדלת הביקוש

במאמר הזה נסביר איך להגדיל את קיבולת המחשוב ולקבל משאבי חומרה ב- 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, או כשעורכים ופורסים מחדש את תרשים האשכול. אפשר להשתמש באפשרויות הבאות:

  • ‫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-Out ComputeClasses לאשכולות Autopilot ולעומסי עבודה במצב Autopilot באשכולות Standard.

      • צמתים של דייר יחיד ב-GKE: מריצים מאגרי צמתים במצב Standard בשרתים פיזיים ייעודיים כדי לעמוד בדרישות הבידוד או הרישוי.

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

    • האצת ההפעלה: קיצור זמני הטעינה של המודל והאתחול של הקונטיינר במהלך הרחבה אופקית בהתאם לעומס (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 כל אפשרויות ההתאמה בקשה ידנית או בקשה להזמנה ביומן; לא מידרוג אוטומטי
  • אירועים מתוכננים של צמיחה ושיא בהיקף השימוש
  • העברות גדולות
  • גיבוי ותוכנית התאוששות מאסון (DR)
  • משאבים עם ביקוש גבוה, כמו מעבדי GPU ו-TPU
חלוקת תנועה באמצעות Cloud Load Balancing חלוקת התנועה הנכנסת בין מכונות, מאגרי צמתים או קונטיינרים תקינים כל אפשרויות המחשוב כל אפשרויות ההתאמה בקשות נכנסות של משתמשים ובדיקות תקינות של קצה עורפי
  • אפליקציות אינטרנט וממשקי API עם נפח תנועה גבוה
  • זמינות במספר אזורים ובמספר אזורים גיאוגרפיים
  • הרחבה אופקית בהתאם לעומס (scale out) ללא זמן השבתה
התאמה אוטומטית לעומס (scaling) של MIG הוספה או הסרה של מכונות ב-MIG בהתאם לעומס העבודה המשתנה Compute Engine הזמנות, הפעלה גמישה של מכונות ב-MIG, מאגרי המתנה ב-MIG, התאמה לעומס (autoscaling) של קבוצות צמתים של שרתים לדייר יחיד (sole-tenant), כלי מותאם אישית לניהול תזמור (orchestrator) שימוש במעבד (CPU), קיבולת של מאזן העומסים, מדדים של Cloud Monitoring, לוחות זמנים או תחזיות
  • שירותי אינטרנט וממשקי API
  • עומסי עבודה של אצוות מקבילות
  • זמינות גבוהה בכמה אזורים
  • מיקרו-שירותים (microservices) בלי שמירת מצב (stateless)
הפעלה גמישה של מכונות ב-MIG דירוג של כמה סוגי מכונות ב-MIG כדי לשפר את הזמינות של המשאבים Compute Engine התאמה אוטומטית לעומס (autoscaling) של קבוצות MIG, מקומות שמורים, VM במודל Spot כשאין מספיק קיבולת בסוגי המכונות הראשיים במהלך יצירה או הרחבה אופקית של מכונות ב-MIG
  • זמינות גבוהה יותר של מכונות
  • איזון בין עלות לביצועים בסדרות מכונות
  • עומסי עבודה של אתרים ללא שמירת מצב (stateless) ושל אצווה (batch)
מצב Bulk ובקשות לשינוי כמות בקבוצות MIG הוספה של כל המכונות המבוקשות ב-MIG בו-זמנית, כשהקיבולת המלאה תהיה זמינה ‫Compute Engine ו-Cluster Director הזמנות, שינוי אשכולות בזמן אמת, כלי תזמור בהתאמה אישית גודל היעד שמוגדר במצב Bulk או יצירה של בקשה לשינוי כמות, שמתמלאת כשקיבולת החומרה המלאה זמינה
  • אימון מבוזר של מודלים של AI או למידת מכונה
  • משימות עם כמה צמתים שדורשות את כל המכונות בו-זמנית
  • עומסי עבודה גמישים בזמן של GPU,‏ TPU ו-H4D
מאגרי מכונות במצב המתנה בקבוצות 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 בתור וזמני קצובים לתפוגה של צומת לא פעיל
  • עומסי עבודה של HPC
  • אימון מודלים של AI/ML בקנה מידה גדול
  • תורי סימולציה באצווה
שינוי אשכולות בזמן אמת הוספה או שינוי של הגודל של מחיצות, קבוצות צמתים, קבוצות של מכונות מנוהלות (MIG) או מגבלות של צמתים סטטיים ודינמיים באשכול פעיל Cluster Director תזמור Slurm וצמתים דינמיים, מצב Bulk ובקשות לשינוי כמות ב-MIG, תזמור בהתאמה אישית, הזמנות בקשה לעדכון אשכול באשכול פעיל
  • הרחבת אשכול בסיסי בלי לשבש את העבודה
  • הוספה של קבוצות צמתים של GPU,‏ TPU או CPU ושל קבוצות מופעי מכונה מנוהלים (MIG) באשכולות פעילים
הגדרה מחדש של תוכנית בזמן אמת עדכון ופריסה מחדש של תוכניות כדי להוסיף או לשנות את הגודל של מחיצות Slurm, צמתים סטטיים או מאגרי צמתים של GKE באשכול פעיל Cluster Toolkit תזמור Slurm וצמתים דינמיים, התאמה אוטומטית לעומס (autoscaling) באשכול, הזמנות עדכון ופריסה מחדש של תוכנית באשכול פעיל
  • הרחבת אשכולות של תשתית כקוד בלי לשבש את העבודה
  • מחיצות Slurm עם כמה הקצאות
ComputeClasses בהתאמה אישית הגדרת כללי חומרה חלופיים לפי עדיפות, צריכת קיבולת והעברת צמתים ‫GKE במצב Standard ובמצב Autopilot התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, הקצאת משאבים מסוג "התחלה גמישה" (Flex-start) ב-GKE, הזמנות, מאגרים זמניים למשאבי מחשוב פודים בהמתנה שתואמים לבורר ComputeClass או זמינות של חומרה בעדיפות גבוהה יותר
  • זמינות גבוהה בסדרות GPU,‏ TPU או CPU
  • מעבר ממקומות שמורים למכונות וירטואליות במודל התחלה גמישה (Flex-start) או VM במודל Spot
  • העברה פעילה חזרה לחומרה המועדפת
Cluster autoscaler הוספה או הסרה של צמתים במאגרי צמתים קיימים ‫GKE במצב Standard ותוכניות של Cluster Toolkit ל-GKE ‫ComputeClasses בהתאמה אישית, מקומות שמורים, התאמה אוטומטית לעומס של קבוצת שרתים לדייר יחיד, HPA, ‏ VPA, מאגרים זמניים למשאבי מחשוב, צמצום הפעולה לאפס תרמילים בהמתנה או ניצול חלקי של צמתים
  • עומסי עבודה בקונטיינרים עם תנועה משתנה
  • עליות פתאומיות בביקוש
יצירה אוטומטית של מאגרי צמתים יצירה ומחיקה של מאגרי צמתים במקביל כדי להתאים לדרישות החומרה של Pod ‫GKE: מנוהל במצב Autopilot, ניתן להגדרה במצב Standard ‫ComputeClasses בהתאמה אישית, הזמנות, הקצאת משאבים מסוג Flex-start ב-GKE, ‏ HPA, ‏ VPA, מאגרים זמניים למשאבי מחשוב פודים בהמתנה שדורשים סדרות מכונות, מאיצים או אזורים שלא קיימים במאגרי הצמתים הקיימים
  • עומסי עבודה מגוונים על מעבדי GPU,‏ TPU או CPU
  • אשכולות עם כמה דיירים שיוצרים כמה מאגרי צמתים במקביל
הקצאת משאבים בהתחלה גמישה ב-GKE אפשר לקבל צומתי GPU,‏ TPU ו-H4D כשהקיבולת מתפנה, לכל צומת בנפרד או לכולם בבת אחת באמצעות הקצאת משאבים בהמתנה ‫GKE במצב Standard ובמצב Autopilot ‫ComputeClasses בהתאמה אישית, יצירה אוטומטית של מאגרי צמתים, מידרוג אוטומטי של אשכולות, תורי משימות של Kueue פודים בהמתנה או אובייקטים של ProvisioningRequest בתור כשקיבולת החומרה נפתחת
  • אימון וכוונון של מודלים של AI/ML
  • עומסי עבודה של הסקת מסקנות באצווה
  • הקצאת מאיצים בו-זמנית לכמה צמתים
מאגרים זמניים למשאבי מחשוב הקצאה מראש של צומתי המתנה פעילים או מושעים לצורך מיקום וזמינות מהירים של Pod ‫GKE במצב Standard ובמצב Autopilot ‫ComputeClasses בהתאמה אישית, מידרוג אוטומטי של אשכולות, יצירה אוטומטית של מאגרי צמתים, HPA, מקומות שמורים צריכת הקיבולת של צומת מאגר נתונים זמני על ידי Pods מתוזמנים
  • אפליקציות שרגישות לזמן אחזור
  • עומסי עבודה של הסקת מסקנות וסוכנים ב-AI
  • עליות חדות ופתאומיות בתנועה
פלטפורמת מחשוב שמותאמת לקונטיינרים האצת המוכנות של הצמתים והמיקום של Pods באמצעות תשתית מנוהלת ו-ComputeClasses מסוג Balanced או Scale-Out ‫GKE: אשכולות Autopilot ועומסי עבודה במצב Autopilot באשכולות Standard יצירה אוטומטית של מאגרי צמתים, HPA, ‏ VPA, מאגרים זמניים למשאבי מחשוב, מקומות שמורים פודים בהמתנה שדורשים קיבולת מחשוב נוספת
  • הרחבה אופקית מהירה של אשכולות בהתאם לעומס (scale out)
  • עומסי עבודה עם ביקוש משתנה למשאבים
  • פעולות בתשתית מנוהלת
HPA הוספה או הסרה של רפליקות של Pod בהתאם לעומס העבודה ‫GKE במצב Standard ובמצב Autopilot התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, MPA, מדדים מותאמים אישית וחיצוניים, צמצום הפעולה לאפס שימוש במעבד (CPU), שימוש בזיכרון או מדדים מותאמים אישית וחיצוניים
  • אפליקציות ללא שמירת מצב (stateless)
  • שירותי אינטרנט וממשקי API
  • נפח בקשות משתנה
VPA התאמת הבקשות והמגבלות של המעבד (CPU) והזיכרון של הקונטיינר על סמך השימוש ‫GKE במצב Standard ובמצב Autopilot התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, MPA, שינוי גודל של Pod במקום, הזמנות היסטוריית השימוש במעבד (CPU) ובזיכרון של הקונטיינר
  • אפליקציות עם שמירת מצב (stateful)
  • עומסי עבודה עם צרכים לא ודאיים במשאבים
  • אופטימיזציה של משאבי קונטיינרים
MPA התאמה של מספר הרפליקות של Pod לפי בקשות למעבד (CPU) ולזיכרון של קונטיינר בו-זמנית ‫GKE במצב Standard ובמצב Autopilot התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, מדדים מותאמים אישית ומדדים חיצוניים שינויים בו-זמניים בביקוש למעבד (CPU) ובשימוש בזיכרון של הקונטיינר
  • שירותים ללא שמירת מצב (stateless) עם תנועה משתנה וצרכי זיכרון משתנים
מדדים מותאמים אישית ומדדים חיצוניים שינוי קנה המידה של רפליקות של Pod על סמך אותות של אפליקציה או שירות חיצוני ‫GKE במצב Standard ובמצב Autopilot HPA, ‏ MPA, צמצום הפעולה לאפס, מידרוג אוטומטי של אשכולות, יצירה אוטומטית של מאגרי צמתים מדדי אפליקציה או מדדי תנועה ותור חיצוניים
  • עובדים שמבוססים על תורים, כמו צרכני Pub/Sub
  • ממשקי API באינטרנט שמוגבלים על ידי זמן אחזור
  • יעדי תפוקה של הסקת AI
צמצום הפעולה לאפס הפחתה בהתאם לעומס של מאגרי צמתים ו-Pods לא פעילים לאפס, והפעלה שלהם לפי דרישה או לפי אירועים ‫GKE במצב Standard ובמצב Autopilot ‫HPA, מדדים מותאמים אישית וחיצוניים, מידרוג אוטומטי של אשכול, יצירה אוטומטית של מאגר צמתים היעדר ביקוש או ביקוש חדש במדדים מותאמים אישית וחיצוניים של HPA או בטריגרים של KEDA
  • עומסי עבודה לסירוגין או עומסי עבודה מתפרצים
  • משימות באצווה מבוססות-אירועים
  • אין עלויות מחשוב בזמן חוסר פעילות
תורי משימות ב-Kueue הוספת משימות באצווה לתור, אכיפת מכסות לצוותים ותיאום הקצאת צמתים בו-זמנית ‫GKE במצב Standard ובמצב Autopilot הקצאת משאבים מסוג Flex-start ב-GKE, ‏ ComputeClasses בהתאמה אישית, התאמה אוטומטית לעומס (automatic scaling) של אשכולות, יצירה אוטומטית של מאגרי צמתים משימות באצווה שהתקבלו כשמכסת האשכול וקיבולת החומרה נפתחו
  • ניהול מכסות GPU ו-TPU לכמה צוותים
  • משימות אצווה ואימון AI בתור
‫Cloud Storage FUSE עם סטרימינג במקביל טעינת קטגוריות של Cloud Storage כמערכות קבצים עם קריאות ומטמונים מקבילים ‫GKE במצב Standard ובמצב Autopilot ‫HPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, קובצי snapshot של Pod הפעלת Pod וקריאת קבצים ברצף מקטגוריות שנטענו
  • אימון והסקת מסקנות של AI בתפוקה גבוהה מ-Cloud Storage
  • גישה לנקודת ביקורת עם כמה צמתים
האצת המעבד בזמן אתחול הקצאת מעבד (CPU) נוסף באופן זמני לקונטיינרים במהלך האתחול ‫GKE במצב Standard ובמצב Autopilot ‫HPA, ‏ VPA, התאמה אוטומטית לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים שלב ההפעלה והאתחול של הקונטיינר
  • אפליקציות שדורשות שימוש גבוה ב-CPU בזמן ההפעלה, כמו חימום של מכונה וירטואלית של Java
  • הרחבה אופקית של ממשקי API שרגישים לזמן אחזור
סטרימינג של תמונות העברת בלוקים של קובצי אימג' של קונטיינרים לפי דרישה מ-Artifact Registry במהלך הפעלת Pod ‫GKE במצב Standard ובמצב Autopilot ‫HPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, מאגרים זמניים למשאבי מחשוב שליפת קובץ אימג' של קונטיינר מ-Artifact Registry כש-Pod מתחיל לפעול
  • קובצי אימג' גדולים של קונטיינרים ל-AI/ML
  • הרחבה אופקית מהירה של מיקרו-שירותים (microservices)
דיסקי אתחול משניים צירוף של אמצעי אחסון מסוג Persistent Disk שנטענו מראש עם קובצי אימג' של קונטיינרים או נתוני מודלים בזמן ההפעלה של הצומת ‫GKE במצב Standard ובמצב Autopilot ‫ComputeClasses בהתאמה אישית, HPA, כלי להתאמה לעומס (autoscaler) של אשכולות, הקצאה אוטומטית של מאגרי צמתים, מאגרים זמניים למשאבי מחשוב אתחול צומת במאגר צמתים שמוגדר עם קובצי אימג' של דיסק אתחול משני
  • משקלי מודלים או מערכי נתונים שנטענו מראש בצמתים
  • שמירת שכבות של קובץ אימג' של קונטיינר בסיסי במטמון
שינוי הגודל של Pod במקום עדכון הקצאות המעבד והזיכרון של קונטיינר פעיל בלי להפעיל מחדש את ה-Pod ‫GKE במצב Standard ובמצב Autopilot ‫VPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים עדכון בקשות ומגבלות של מעבד (CPU) או זיכרון של קונטיינר
  • אפליקציות עם שמירת מצב (stateful) או אפליקציות שפועלות לאורך זמן
  • שינוי קנה מידה אנכי בלי ניתוקים או אובדן מצב
תמונות מצב של Pod שחזור רפליקות של Pod מנקודות בדיקה שמורות של זיכרון ומערכת קבצים ‫GKE במצב Standard ובמצב Autopilot ‫HPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, מאגרים זמניים למשאבי מחשוב יצירת רפליקה של Pod מתמונת מצב שמורה
  • שרתי הסקת AI עם זמני טעינה ארוכים של מודלים
  • אפליקציות עם זמן אתחול איטי
  • הרחבה אופקית מהירה בהתאם לעומס (scale out) במהלך עליות חדות בביקוש
Run:ai Model Streamer העברת טנזורים של מודלים בסטרימינג במקביל לזיכרון של GPU או TPU ‫GKE במצב Standard ובמצב Autopilot ‫HPA, התאמה אוטומטית לעומס (automatic scaling) של אשכולות, יצירה אוטומטית של מאגרי צמתים, Volume Populator בקשות להפעלת שרת הסקת מסקנות של AI ולטעינת מודלים
  • הסקת מסקנות ממודל שפה גדול (LLM) באמצעות vLLM
  • הרחבה אופקית מהירה של רפליקות GPU ו-TPU בהתאם לעומס (scale out)
Volume Populator טעינה מראש של נתונים מ-Cloud Storage לנפחי Hyperdisk ML ‫GKE במצב Standard ובמצב Autopilot ‫HPA, התאמה לעומס (autoscaling) באשכול, יצירה אוטומטית של מאגר צמתים, קובצי snapshot של Pod יצירת PersistentVolumeClaim שמפנה למשאב GCPDataSource
  • משקלים של מודלים של AI או ML שנטענו מראש
  • גישה משותפת לקריאה בלבד למערך נתונים בכמה צמתים
כללי מדיניות של התאמה אוטומטית לעומס הוספה או הסרה של מארחי ESXi באשכול ענן פרטי של VMware VMware Engine Cloud Load Balancing שימוש מתמשך במעבד (CPU), בזיכרון או בנפח אחסון נדרש של vSAN
  • אשכולות VMware שהועברו עם עומס משתנה
  • עומסי עבודה ב-vSphere שדורשים הרבה נפח אחסון או משאבי מחשוב

שיטות מומלצות ליכולת התאמה לעומס (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 או מנפחים שאוכלסו מראש.