הצבת Pods של GKE באזורים ספציפיים

בדף הזה מוסבר איך להגדיר ל-Google Kubernetes Engine ‏(GKE) להריץ את ה-Pods בצמתים באזורים ספציפיים ב- Google Cloud באמצעות טופולוגיה אזורית. סוג כזה של מיקום שימושי במצבים כמו:

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

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

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

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

טופולוגיה אזורית מובנית ב-Kubernetes עם תווית הצומת topology.kubernetes.io/zone: ZONE. כדי להורות ל-GKE למקם Pod באזור ספציפי, משתמשים באחת מהשיטות הבאות:

  • ‫nodeAffinity: מציינים כלל nodeAffinity במפרט של ה-Pod לאזור אחד או יותר ב- Google Cloud . השיטה הזו גמישה יותר מ-nodeSelector כי היא מאפשרת למקם Pods בכמה אזורים.
  • ‫nodeSelector: מציינים nodeSelector במפרט של ה-Pod לאזור Google Cloud יחיד.

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

לתשומת ליבכם

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

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

תמחור

טופולוגיה אזורית היא יכולת תזמון של Kubernetes, והיא מוצעת ללא עלות נוספת ב-GKE.

לפרטים על המחירים, ראו התמחור של GKE.

לפני שמתחילים

לפני שמתחילים, חשוב לוודא שביצעתם את המשימות הבאות:

  • מפעילים את Google Kubernetes Engine API.
  • הפעלת Google Kubernetes Engine API
  • כדי להשתמש ב-Google Cloud CLI למשימה הזו, מתקינים ואז מאתחלים את ה-CLI של gcloud. אם כבר התקנתם את ה-CLI של gcloud, הריצו את הפקודה gcloud components update כדי לקבל את הגרסה העדכנית. יכול להיות שבגרסאות קודמות של ה-CLI של gcloud אי אפשר להריץ את הפקודות שבמסמך הזה.
  • מוודאים שיש לכם אשכול GKE קיים באותו אזור (Google Cloud ) שבו נמצאים התחומים שבהם אתם רוצים למקם את ה-Pods. כדי ליצור אשכול חדש, קראו את המאמר יצירת אשכול Autopilot.

הצבת Pods בכמה אזורים באמצעות nodeAffinity

‫Kubernetes nodeAffinity מספק מנגנון בקרה גמיש לתזמון שתומך בכמה בוררי תוויות ובאופרטורים לוגיים. כדאי להשתמש ב-nodeAffinity אם רוצים לאפשר לפודים לפעול באחד מהאזורים (לדוגמה, ב-us-central1-a או ב-us-central1-f).

  1. שומרים את המניפסט הבא בתור multi-zone-affinity.yaml:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-deployment
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: nginx-multi-zone
      template:
        metadata:
          labels:
            app: nginx-multi-zone
        spec:
          containers:
          - name: nginx
            image: nginx:latest
            ports:
            - containerPort: 80
          affinity:
            nodeAffinity:
              requiredDuringSchedulingIgnoredDuringExecution:
                nodeSelectorTerms:
                - matchExpressions:
                  - key: topology.kubernetes.io/zone
                    operator: In
                    values:
                    - us-central1-a
                    - us-central1-f
    

    המניפסט הזה יוצר פריסה עם שלוש רפליקות וממקם את הפודים ב-us-central1-a או ב-us-central1-f, בהתאם לזמינות של הצומת.

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

    אופציונלי: אם אתם מקצים מכונות וירטואליות של TPU, השתמשו באזור AI, כמו us-central1-ai1a. אזורי AI הם מיקומים ייעודיים שמותאמים לעומסי עבודה של AI או למידת מכונה בתוך Google Cloud אזורים.

  2. יוצרים את הפריסה:

    kubectl create -f multi-zone-affinity.yaml
    

    ‫GKE יוצר את הפודים בצמתים באחד מהאזורים שצוינו. יכול להיות שכמה Pods יפעלו באותו צומת. אפשר להשתמש בPod anti-affinity כדי להורות ל-GKE למקם כל Pod בצומת נפרד.

הצבת Pods באזור אחד באמצעות nodeSelector

כדי למקם Pods באזור אחד, משתמשים ב-nodeSelector במפרט של ה-Pod. ‫nodeSelector מקביל לכלל requiredDuringSchedulingIgnoredDuringExecution nodeAffinity שצוין בו אזור אחד.

  1. שומרים את המניפסט הבא בתור single-zone-selector.yaml:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-singlezone
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: nginx-singlezone
      template:
        metadata:
          labels:
            app: nginx-singlezone
        spec:
          nodeSelector:
            topology.kubernetes.io/zone: "us-central1-a"
          containers:
          - name: nginx
            image: nginx:latest
            ports:
            - containerPort: 80
    

    המניפסט הזה מורה ל-GKE למקם את כל הרפליקות בפריסה באזור us-central1-a.

  2. יוצרים את הפריסה:

    kubectl create -f single-zone-selector.yaml
    

תעדוף מיקום Pod באזורים נבחרים באמצעות מחלקת מחשוב

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

שימוש בעדיפות של אזורי מיקום

כדי להגדיר העדפות אזוריות במחלקות מחשוב באמצעות עדיפות של אזורי מיקום, נדרשת גרסת GKE‏ 1.33.1-gke.1545000 ואילך.

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

השלבים האלה מבוססים על ההנחה שהאשכול נמצא באזור us-central1. אם האשכול נמצא באזור אחר, צריך לשנות את ערכי האזורים במניפסט לאזורים חוקיים באזור של האשכול.

  1. שומרים את המניפסט הבא בתור zones-custom-compute-class.yaml:

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: zones-custom-compute-class
    spec:
      priorities:
      - location:
        zones: [us-central1-a, us-central1-b]
      - location:
        zones: [us-central1-c]
      activeMigration:
        optimizeRulePriority: true
      nodePoolAutoCreation:
        enabled: true
      whenUnsatisfiable: ScaleUpAnyway
    

    המניפסט הזה של מחלקת המחשוב משנה את אופן ההתאמה לעומס (scaling) באופן הבא:

    1. ‫GKE מנסה למקם פודים ב-us-central1-a או ב-us-central1-b.
    2. אם אין קיבולת זמינה ב-us-central1-a וב-us-central1-b, ‏GKE מנסה למקם את הפודים ב-us-central1-c.
    3. אם אין קיבולת זמינה ב-us-central1-c, השדה whenUnsatisfiable: ScaleUpAnyway גורם ל-GKE למקם את ה-Pods בכל אזור זמין ב-region.
    4. אם תחום עם עדיפות גבוהה יותר במחלקת המחשוב יהיה זמין מאוחר יותר, השדה activeMigration.optimizeRulePriority: true יגרום ל-GKE להעביר את ה-Pods לתחום הזה מכל תחום עם עדיפות נמוכה יותר. ההעברה הזו משתמשת בתקציב לשיבוש Pod כדי להבטיח את זמינות השירות.
  2. יוצרים את מחלקת המחשוב בהתאמה אישית:

    kubectl create -f zones-custom-compute-class.yaml
    

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

  3. שומרים את המניפסט הבא בתור custom-compute-class-deployment.yaml:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-zonal-preferences
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: nginx-zonal-preferences
      template:
        metadata:
          labels:
            app: nginx-zonal-preferences
        spec:
          nodeSelector:
            cloud.google.com/compute-class: "zones-custom-compute-class"
          containers:
          - name: nginx
            image: nginx:latest
            ports:
            - containerPort: 80
    
  4. יוצרים את הפריסה:

    kubectl create -f custom-compute-class-deployment.yaml
    

שימוש בעדיפות של zoneTypes למיקום

כדי להגדיר העדפות אזוריות במחלקות מחשוב באמצעות עדיפות של סוגי אזורי מיקום, נדרשת גרסת GKE‏ 1.35.2-gke.1842000 ואילך. אם תבחרו סוג אזור לפודים, המערכת תשתמש במאגר צמתים חדש או תיצור מאגר כזה, בהתאם להגדרות שלכם, שיתפרס על פני כל האזורים מסוג מסוים.

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

  • ‫STANDARD: למטרות כלליות, אזורים (zones) ב- Google Cloud . מומלץ לעומסי עבודה שלא קשורים ללמידת מכונה.
  • ‫AI: אזורים ייעודיים שעברו אופטימיזציה לקיבולת של AI או מאיצים. מומלץ לעומסי עבודה של AI/ML.
  • ‫CLUSTER_DEFAULT: האזורים שצוינו ב-autoprovisioning-locations של האשכול (או המיקומים של האשכול אם הוא ריק).

מידע נוסף על אזורים רגילים ואזורי AI

הגבלות על שילוב שדות

אי אפשר לשלב את השדה zoneTypes עם השדה location.zones או עם השדה reservations.specific באותה רשומת עדיפות. אפשר להשתמש בשדה zoneTypes ובשדה location.zones באותה מחלקת מחשוב, כל עוד הם מופיעים ברשומות נפרדות של עדיפות.

בנוסף, השדה priorityDefaults חל על כל עדיפות במחלקת המחשוב. כתוצאה מהכלל הזה, אם מגדירים את השדה zoneTypes בשדה priorityDefaults, אי אפשר להשתמש בשדה location.zones או בשדה reservations.specific באף עדיפות.

דוגמה תקינה: עדיפויות נפרדות

הדוגמה הבאה תקינה כי zones ו-zoneTypes צוינו ברשומות עדיפות נפרדות:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: valid-zonal-preferences
spec:
  priorities:
  - location:
      zones: [us-central1-a]
  - location:
      zoneTypes: [AI]

דוגמה לא תקינה: עדיפות זהה

הדוגמה הבאה לא תקינה כי zones ו-zoneTypes צוינו באותה רשומת עדיפות:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: invalid-same-priority
spec:
  priorities:
  - location:
      zones: [us-central1-a]
      zoneTypes: [AI] # Error: mutually exclusive

דוגמה לא חוקית: התנגשות עם ברירות המחדל

הדוגמה הבאה לא תקינה כי הגדרת השדה zoneTypes בקטע priorityDefaults מתנגשת עם השדה zones ברשומת העדיפות:

apiVersion: cloud.google.com/v1
kind: ComputeClass
metadata:
  name: invalid-defaults-conflict
spec:
  priorityDefaults:
    location:
      zoneTypes: [AI]
  priorities:
  - location:
      zones: [us-central1-a] # Error: merges with defaults

דוגמה לשימוש

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

  1. שומרים את המניפסט הבא בתור zone-types-custom-compute-class.yaml:

    apiVersion: cloud.google.com/v1
    kind: ComputeClass
    metadata:
      name: zone-types-custom-compute-class
    spec:
      priorities:
      - location:
        zones: [us-central1-c]
      - location:
        zoneTypes:
        - AI
      - location:
        zoneTypes:
        - CLUSTER_DEFAULT
      activeMigration:
        optimizeRulePriority: true
      nodePoolAutoCreation:
        enabled: true
      whenUnsatisfiable: ScaleUpAnyway
    

    המניפסט הזה של מחלקת המחשוב משנה את אופן ההתאמה לעומס (scaling) באופן הבא:

    1. ‫GKE מנסה למקם פודים באחד מהאזורים של us-central1-c.
    2. אם אין קיבולת זמינה ב-us-central1-c, ‏GKE מנסה למקם Pods בכל אזור AI במחוז.
    3. אם באף אחד מהאזורים של AI אין קיבולת זמינה, GKE מנסה למקם פודים באחד מהאזורים של CLUSTER_DEFAULT.
    4. אם באף אחד מהאזורים של CLUSTER_DEFAULT אין קיבולת זמינה, השדה whenUnsatisfiable: ScaleUpAnyway גורם ל-GKE למקם את ה-Pods בכל אזור זמין באזור.
    5. אם תחום עם עדיפות גבוהה יותר במחלקת המחשוב יהיה זמין מאוחר יותר, השדה activeMigration.optimizeRulePriority: true יגרום ל-GKE להעביר את ה-Pods לתחום הזה מכל תחום עם עדיפות נמוכה יותר. ההעברה הזו משתמשת בתקציב לשיבוש Pod כדי להבטיח את זמינות השירות.
  2. יוצרים את מחלקת המחשוב בהתאמה אישית:

    kubectl create -f zone-types-custom-compute-class.yaml
    

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

  3. שומרים את המניפסט הבא בתור custom-compute-class-deployment.yaml:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-zonal-preferences
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: nginx-zonal-preferences
      template:
        metadata:
          labels:
            app: nginx-zonal-preferences
        spec:
          nodeSelector: cloud.google.com/compute-class: "zone-types-custom-compute-class"
          containers:
          - name: nginx
            image: nginx:latest
            ports:
            - containerPort: 80
    
  4. יוצרים את הפריסה:

    kubectl create -f custom-compute-class-deployment.yaml
    

איך NAP מעריך את zoneTypes

כדי להחליט אם להשתמש מחדש במאגר צמתים קיים או ליצור מאגר חדש, הקצאת צמתים אוטומטית (NAP) בדרך כלל דורשת התאמה מדויקת בין האזורים הקיימים של מאגר הצמתים לבין ה-zoneTypes שביקשתם. אם מעדכנים עדיפות כך שתכלול סוגי אזורים רחבים יותר (למשל, מעבר מ-[AI] ל-[AI, STANDARD]), הקצאת המשאבים האוטומטית של NAP תיצור מאגר צמתים חדש שיתאים בדיוק לצורה החדשה.

חיתוך בהתאם לסוג המכונה

אם סוג מכונה (כמו h3-standard-88) זמין רק בקבוצת משנה של האזורים שמוגדרים לפי סוג (לדוגמה, רק ב-us-central1-a), GKE מקצר אוטומטית את רשימת המיקומים של מאגר הצמתים כך שתכלול רק אזורים שבהם החומרה הזו קיימת פיזית.

אזורי יעד של AI

אזורי AI הם אזורים ייעודיים שמשמשים לעומסי עבודה של אימון והסקת מסקנות של AI/ML. באזורים האלה יש קיבולת משמעותית של מאיצי למידת מכונה. מידע נוסף זמין במאמרי העזרה בנושא אזורי AI.

במסמך הזה ובמסמכי התיעוד של GKE, המונחים "אזורים רגילים" או "אזורים" מתייחסים לאזורים שאינם אזורי AI בתוך אזור Google Cloud .

לפני שאתם משתמשים באזור AI ב-GKE, כדאי להביא בחשבון את המאפיינים הבאים:

  • כדי להשתמש באזור AI עם אשכולות GKE קיימים, מישור הבקרה צריך להריץ את גרסה 1.36.4-gke.1495002 ואילך, או את גרסה 1.37.1-gke.1552000 ואילך. הגרסאות האלה מאפשרות למישור הבקרה לזהות את האזור ולרשום צמתים. אם במישור הבקרה פועלת גרסה 1.35 או גרסה קודמת, או גרסה שקודמת לגרסאות המינימליות האלה, שדרגו את מישור הבקרה לפני שאתם יוצרים מאגרי צמתים באזור ה-AI. אם אי אפשר לשדרג, פנו אל Cloud Customer Care.
  • אזורי AI מופרדים פיזית מאזורים רגילים כדי לספק שטח אחסון וחשמל נוספים. ההפרדה הזו עלולה לגרום לזמן אחזור ארוך יותר, שבדרך כלל אפשר לסבול בעומסי עבודה של AI/ML.
  • לאזורי AI יש סיומת עם הסימון ai. לדוגמה, אזור AI ב-us-central1 נקרא us-central1-ai1a.
  • בשלב הזה יש תמיכה רק במכונות וירטואליות של TPU.
  • מישור הבקרה של האשכול פועל באזור סטנדרטי אחד או יותר באותו אזור שבו נמצא אזור ה-AI.
  • אתם יכולים להריץ מכונות וירטואליות בלי יחידות TPU מצורפות באזור AI רק אם אתם עומדים בדרישות הבאות:

    • כבר פועלים עומסי עבודה אחרים שמשתמשים ב-TPU VM באותו אזור.
    • המכונות הווירטואליות שהן לא TPU VM הן VM במודל Spot, שקשורות למקום שמור או שהן חלק ממאגר צמתים עם יחס ספציפי בין מכונות וירטואליות עם מאיצים למכונות וירטואליות לשימוש כללי.
  • אזורי AI חולקים רכיבים, כמו חיבורים לרשת והשקות של תוכנות, עם אזורים רגילים שיש להם את אותה סיומת באותו אזור. לעומסי עבודה בזמינות גבוהה, מומלץ להשתמש באזורים שונים. לדוגמה, אל תשתמשו גם ב-us-central1-ai1a וגם ב-us-central1-a לזמינות גבוהה.

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

  • ‫(מומלץ) ComputeClasses: הגדרת העדיפות הגבוהה ביותר לבקשת יחידות TPU על פי דרישה באזור AI. בעזרת ComputeClasses אתם יכולים להגדיר רשימה של הגדרות חומרה לעומסי העבודה שלכם, לפי סדר עדיפויות. לדוגמה, ראו מידע על ComputeClasses.
  • הקצאת צמתים אוטומטית (NAP): משתמשים ב-nodeSelector או ב-nodeAffinity במפרט של ה-Pod כדי להורות ל-NAP ליצור מאגר צמתים באזור ה-AI. אם עומס העבודה לא מטרגט באופן מפורש אזור AI, הקצאת הצמתים האוטומטית מתייחסת רק לאזורים רגילים או לאזורים מ---autoprovisioning-locations כשיוצרים מאגרי צמתים חדשים. ההגדרה הזו עוזרת לוודא שעומסי עבודה שלא מריצים מודלים של AI או למידת מכונה יישארו באזורים רגילים, אלא אם תגדירו אחרת באופן מפורש. דוגמה למניפסט שמשתמש ב-nodeSelector מופיעה במאמר הגדרת אזורי ברירת המחדל לצמתים שנוצרו באופן אוטומטי.
  • ‫GKE Standard: אם אתם מנהלים ישירות את מאגרי הצמתים, השתמשו באזור AI בדגל --node-locations כשאתם יוצרים מאגר צמתים. לדוגמה, ראו פריסת עומסי עבודה של TPU ב-GKE Standard.

אימות מיקום ה-Pod

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

  1. מציגים את הפודים:

    kubectl get pods -o wide
    

    הפלט הוא רשימה של Pods שפועלים וצומת GKE תואם.

  2. תיאור הצמתים:

    kubectl describe node NODE_NAME | grep "topology.kubernetes.io/zone"
    

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

    הפלט אמור להיראות כך:

    topology.kubernetes.io/zone: us-central1-a
    

אם אתם רוצים ש-GKE יפזר את הפודים באופן שווה בין כמה אזורים כדי לשפר את יתירות הכשל בכמה דומיינים של כשל, השתמשו ב-topologySpreadConstraints.

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