פריסת שער חיצוני מרובה אשכולות

במסמך הזה נסביר באמצעות דוגמה מעשית איך לפרוס שער חיצוני לכמה אשכולות, כדי לנתב תעבורת נתונים לאפליקציה שפועלת בשני אשכולות שונים של GKE באמצעות HTTPRoute. כדי להעביר תנועת TLS מוצפנת ישירות לקצוות עורפיים מרובי אשכולות באמצעות TLSRoute בלי לסיים את ה-TLS ב-Gateway, קראו את המאמר פריסת Gateway מסוג TLS passthrough.

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

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

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

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

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

  1. פריסת אשכולות GKE.

  2. רושמים את האשכולות ל-fleet (אם הם עדיין לא רשומים).

  3. מפעילים את בקרי השירות מרובה האשכולות והשער מרובה האשכולות.

לסיום, לפני שמשתמשים בבקר בסביבה שלכם, כדאי לעיין במגבלות ובבעיות הידועות של בקר GKE Gateway.

שער חיצוני, במספר אשכולות ובמספר אזורים

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

‫store.example.com נפרס בשני אשכולות GKE ונחשף לאינטרנט באמצעות שער לכמה אשכולות

בשלבים הבאים:

  1. פורסים את האפליקציה לדוגמה store באשכולות gke-west-1 ו-gke-east-1.
  2. מגדירים שירותים בכל אשכול לייצוא ל-fleet (שירותים מרובי אשכולות).
  3. פורסים שער חיצוני מרובה אשכולות ו-HTTPRoute באשכול ההגדרות (gke-west-1).

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

  • בקשות אל /west מנותבות לפודים של store באשכול gke-west-1.
  • בקשות אל /east מנותבות לפודים של store באשכול gke-east-1.
  • בקשות לכל נתיב אחר מנותבות לאחד מהאשכולות, בהתאם לתקינות, לקיבולת ולקרבה שלו ללקוח ששלח את הבקשה.

פריסת אפליקציית ההדגמה

  1. יוצרים את המרחב השמות והפריסה של store בכל שלושת האשכולות שנפרסו בהכנת הסביבה לשערים מרובי-אשכולות:

    kubectl apply --context gke-west-1 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/main/gateway/gke-gateway-controller/multi-cluster-gateway/store.yaml
    kubectl apply --context gke-west-2 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/main/gateway/gke-gateway-controller/multi-cluster-gateway/store.yaml
    kubectl apply --context gke-east-1 -f https://raw.githubusercontent.com/GoogleCloudPlatform/gke-networking-recipes/main/gateway/gke-gateway-controller/multi-cluster-gateway/store.yaml
    

    הוא פורס את המשאבים הבאים בכל אשכול:

    namespace/store created
    deployment.apps/store created
    

    כל הדוגמאות בדף הזה מתייחסות לאפליקציה שנפרסה בשלב הזה. לפני שממשיכים לשלבים הבאים, חשוב לוודא שהאפליקציה פרוסה בכל שלושת האשכולות. בדוגמה הזו נעשה שימוש רק באשכולות gke-west-1 ו-gke-east-1, ובאשכול gke-west-2 נעשה שימוש בדוגמה אחרת.

שירותים בכמה אשכולות

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

שירותים מרובי אשכולות (MCS) הם תקן API לשירותים שפועלים באשכולות שונים, והבקר שלהם ב-GKE מספק זיהוי שירותים באשכולות של GKE. בקר ה-Gateway מרובה האשכולות משתמש במשאבי MCS API כדי לקבץ Pods לשירות שאפשר להפנות אליו מכמה אשכולות או שמתפרס על פני כמה אשכולות.

ה-API של שירותים בכמה אשכולות מגדיר את המשאבים הבאים בהתאמה אישית:

  • ServiceExports ממפה לשירות Kubernetes, ומייצא את נקודות הקצה של השירות הזה לכל האשכולות שרשומים ב-fleet. כשיש לשירות ServiceExport תואם, המשמעות היא שאפשר להפנות לשירות באמצעות שער מרובה אשכולות.
  • הבקר של השירותים בכמה אשכולות יוצר באופן אוטומטי את ServiceImports. ‫ServiceExport ו-ServiceImport מגיעים בזוגות. אם קיים ServiceExport ב-fleet, נוצר ServiceImport תואם כדי לאפשר גישה ל-Service שממופה ל-ServiceExport מכל האשכולות.

ככה פועל ייצוא השירותים. ב-gke-west-1 יש שירות של חנות שבוחר קבוצה של Pods באשכול הזה. נוצר ServiceExport באשכול, שמאפשר גישה לפודים ב-gke-west-1 מהאשכולות האחרים ב-fleet. ה-ServiceExport ממפה וחושף שירותים שיש להם את אותו שם ומרחב שמות כמו למשאב ServiceExport.

apiVersion: v1
kind: Service
metadata:
  name: store
  namespace: store
spec:
  selector:
    app: store
  ports:
  - port: 8080
    targetPort: 8080
---
kind: ServiceExport
apiVersion: net.gke.io/v1
metadata:
  name: store
  namespace: store

בתרשים הבא מוצג מה שקורה אחרי פריסת ServiceExport. אם קיים זוג של ServiceExport ו-Service, בקר ה-Service מרובה האשכולות פורס ServiceImport תואם לכל אשכול GKE ב-fleet. ה-ServiceImport הוא הייצוג המקומי של השירות store בכל אשכול. כך ה-Pod של client ב-gke-east-1 יכול להשתמש ב-ClusterIP או בשירותים ללא ראש כדי להגיע ל-Pods של store ב-gke-west-1. כשמשתמשים בשירותים מרובי-אשכולות בצורה הזו, הם מספקים איזון עומסים ממזרח למערב בין אשכולות בלי צורך בשירות LoadBalancer פנימי. כדי להשתמש בשירותים מרובי-אשכולות לאיזון עומסים בין אשכולות, קראו את המאמר הגדרת שירותים מרובי-אשכולות.

התכונה "שירותים מרובי אשכולות" מייצאת שירותים בין אשכולות, וכך מאפשרת תקשורת בין אשכולות.

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

kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1
metadata:
  name: store-route
  namespace: store
  labels:
    gateway: multi-cluster-gateway
spec:
  parentRefs:
  - kind: Gateway
    namespace: store
    name: external-http
  hostnames:
  - "store.example.com"
  rules:
  - backendRefs:
    - group: net.gke.io
      kind: ServiceImport
      name: store
      port: 8080

בתרשים הבא מוצג איך HTTPRoute מנתב את התנועה של store.example.com לפודים של store ב-gke-west-1 וב-gke-east-1. מאזן העומסים מתייחס אליהם כמאגר אחד של שרתי קצה עורפי. אם ה-Pods מאחד האשכולות לא תקינים, לא נגישים או שאין להם קיבולת תעבורה, עומס התעבורה מאוזן ל-Pods שנותרו באשכול השני. אפשר להוסיף או להסיר אשכולות חדשים באמצעות Service ו-ServiceExport של store. הפעולה הזו מוסיפה או מסירה באופן שקוף Pods לקצה העורפי, בלי שינויים מפורשים בהגדרות הניתוב.

משאב MCS

שירותי ייצוא

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

  1. מחילים את המניפסט הבא על אשכול gke-west-1 כדי ליצור את השירותים store ו-store-west-1 ואת ServiceExports:

    cat << EOF | kubectl apply --context gke-west-1 -f -
    apiVersion: v1
    kind: Service
    metadata:
      name: store
      namespace: store
    spec:
      selector:
        app: store
      ports:
      - port: 8080
        targetPort: 8080
    ---
    kind: ServiceExport
    apiVersion: net.gke.io/v1
    metadata:
      name: store
      namespace: store
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: store-west-1
      namespace: store
    spec:
      selector:
        app: store
      ports:
      - port: 8080
        targetPort: 8080
    ---
    kind: ServiceExport
    apiVersion: net.gke.io/v1
    metadata:
      name: store-west-1
      namespace: store
    EOF
    
  2. מחילים את המניפסט הבא על אשכול gke-east-1 כדי ליצור את השירותים store ו-store-east-1 ואת ServiceExports:

    cat << EOF | kubectl apply --context gke-east-1 -f -
    apiVersion: v1
    kind: Service
    metadata:
      name: store
      namespace: store
    spec:
      selector:
        app: store
      ports:
      - port: 8080
        targetPort: 8080
    ---
    kind: ServiceExport
    apiVersion: net.gke.io/v1
    metadata:
      name: store
      namespace: store
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: store-east-1
      namespace: store
    spec:
      selector:
        app: store
      ports:
      - port: 8080
        targetPort: 8080
    ---
    kind: ServiceExport
    apiVersion: net.gke.io/v1
    metadata:
      name: store-east-1
      namespace: store
    EOF
    
  3. מוודאים שה-ServiceExports הנכונים נוצרו באשכולות.

    kubectl get serviceexports --context CLUSTER_NAME --namespace store
    

    מחליפים את CLUSTER_NAME ב-gke-west-1 וב-gke-east-1. הפלט אמור להיראות כך:

    # gke-west-1
    NAME           AGE
    store          2m40s
    store-west-1   2m40s
    
    # gke-east-1
    NAME           AGE
    store          2m25s
    store-east-1   2m25s
    

    הפלט מראה שהשירות store מכיל Pods של store בשני האשכולות, והשירותים store-west-1 ו-store-east-1 מכילים רק Pods של store באשכולות שלהם. השירותים החופפים האלה משמשים לטירגוט ה-Pods בכמה אשכולות או קבוצת משנה של Pods באשכול אחד.

  4. אחרי כמה דקות, מוודאים שה-ServiceImports הנלווים נוצרו באופן אוטומטי על ידי בקר השירותים מרובי האשכולות בכל האשכולות ב-fleet.

    kubectl get serviceimports --context CLUSTER_NAME --namespace store
    

    מחליפים את CLUSTER_NAME ב-gke-west-1 וב-gke-east-1. הפלט אמור להיראות כך:

    # gke-west-1
    NAME           TYPE           IP                  AGE
    store          ClusterSetIP   ["10.112.31.15"]    6m54s
    store-east-1   ClusterSetIP   ["10.112.26.235"]   5m49s
    store-west-1   ClusterSetIP   ["10.112.16.112"]   6m54s
    
    # gke-east-1
    NAME           TYPE           IP                  AGE
    store          ClusterSetIP   ["10.72.28.226"]    5d10h
    store-east-1   ClusterSetIP   ["10.72.19.177"]    5d10h
    store-west-1   ClusterSetIP   ["10.72.28.68"]     4h32m
    

    זה מוכיח שאפשר לגשת לכל שלושת השירותים משני האשכולות ב-fleet. עם זאת, מכיוון שיש רק אשכול הגדרות פעיל אחד לכל צי, אפשר לפרוס רק שערים ו-HTTPRoutes שמפנים ל-ServiceImports האלה ב-gke-west-1. כאשר HTTPRoute באשכול ההגדרות מפנה ל-ServiceImports האלה כ-backend, השער יכול להעביר תנועה לשירותים האלה, לא משנה מאיזה אשכול הם יוצאו.

פריסת השער ו-HTTPRoute

אחרי פריסת האפליקציות, אפשר להגדיר שער באמצעות GatewayClass של gke-l7-global-external-managed-mc. השער הזה יוצר מאזן עומסים של אפליקציות (ALB) חיצוני שמוגדר להפיץ את התנועה בין אשכולות היעד.

  1. מחילים את המניפסט הבא של Gateway על אשכול ההגדרות, gke-west-1 בדוגמה הזו:

    cat << EOF | kubectl apply --context gke-west-1 -f -
    kind: Gateway
    apiVersion: gateway.networking.k8s.io/v1
    metadata:
      name: external-http
      namespace: store
    spec:
      gatewayClassName: gke-l7-global-external-managed-mc
      listeners:
      - name: http
        protocol: HTTP
        port: 80
        allowedRoutes:
          kinds:
          - kind: HTTPRoute
    EOF
    

    הגדרת השער הזו פורסת משאבים של מאזן עומסים חיצוני של אפליקציות (ALB) עם מוסכמת השמות הבאה: gkemcg1-NAMESPACE-GATEWAY_NAME-HASH.

    המשאבים שנוצרים כברירת מחדל בהגדרה הזו הם:

    • מאזן עומסים אחד: gkemcg1-store-external-http-HASH
    • כתובת IP ציבורית אחת: gkemcg1-store-external-http-HASH
    • כלל העברה אחד: gkemcg1-store-external-http-HASH
    • ‫2 שירותים לקצה העורפי:
      • שירות ברירת המחדל לקצה העורפי של 404: gkemcg1-store-gw-serve404-HASH
      • שירות ברירת המחדל לקצה העורפי של 500: gkemcg1-store-gw-serve500-HASH
    • ‫1 בדיקת תקינות:
      • בדיקת תקינות 404 שמוגדרת כברירת מחדל: gkemcg1-store-gw-serve404-HASH
    • 0 כללי ניתוב (URLmap ריק)

    בשלב הזה, כל בקשה ל-GATEWAY_IP:80 תוביל לדף ברירת מחדל שבו מוצגת ההודעה הבאה: fault filter abort.

  2. מחילים את המניפסט הבא של HTTPRoute על אשכול ההגדרות, gke-west-1 בדוגמה הזו:

    cat << EOF | kubectl apply --context gke-west-1 -f -
    kind: HTTPRoute
    apiVersion: gateway.networking.k8s.io/v1
    metadata:
      name: public-store-route
      namespace: store
      labels:
        gateway: external-http
    spec:
      hostnames:
      - "store.example.com"
      parentRefs:
      - name: external-http
      rules:
      - matches:
        - path:
            type: PathPrefix
            value: /west
        backendRefs:
        - group: net.gke.io
          kind: ServiceImport
          name: store-west-1
          port: 8080
      - matches:
        - path:
            type: PathPrefix
            value: /east
        backendRefs:
          - group: net.gke.io
            kind: ServiceImport
            name: store-east-1
            port: 8080
      - backendRefs:
        - group: net.gke.io
          kind: ServiceImport
          name: store
          port: 8080
    EOF
    

    בשלב הזה, כל בקשה ל-GATEWAY_IP:80 תוביל לדף ברירת מחדל שבו מוצגת ההודעה הבאה: fault filter abort.

    אחרי הפריסה, ה-HTTPRoute הזה מגדיר את התנהגות הניתוב הבאה:

    • בקשות אל /west מנותבות אל Pods של store באשכול gke-west-1, כי Pods שנבחרו על ידי store-west-1 ServiceExport קיימים רק באשכול gke-west-1.
    • בקשות אל /east מנותבות אל Pods של store באשכול gke-east-1, כי Pods שנבחרו על ידי store-east-1 ServiceExport קיימים רק באשכול gke-east-1.
    • בקשות לכל נתיב אחר מנותבות לפודים של store בכל אחד מהאשכולות, בהתאם לתקינות, לקיבולת ולקרבה ללקוח ששלח את הבקשה.
    • בקשות ל-‎GATEWAY_IP:80‎ מובילות לדף ברירת מחדל שבו מוצגת ההודעה הבאה: fault filter abort.

    באמצעות HTTPRoute אפשר לנתב לקבוצות משנה שונות של אשכולות באמצעות שירותים חופפים

    שימו לב שאם כל ה-Pods באשכול מסוים לא תקינים (או לא קיימים), תנועת הנתונים לשירות store תישלח רק לאשכולות שיש בהם Pods של store. הקיום של ServiceExport ו-Service באשכול מסוים לא מבטיח שתעבורת הנתונים תישלח לאשכול הזה. הפודים צריכים להיות קיימים ולהגיב בחיוב לבדיקת התקינות של מאזן העומסים, אחרת מאזן העומסים פשוט ישלח תנועה לפודים תקינים של store באשכולות אחרים.

    משאבים חדשים נוצרים עם ההגדרה הזו:

    • ‫3 שירותים לקצה העורפי:
      • שירות הקצה העורפי של store: gkemcg1-store-store-8080-HASH
      • שירות הקצה העורפי של store-east-1: gkemcg1-store-store-east-1-8080-HASH
      • שירות הקצה העורפי של store-west-1: gkemcg1-store-store-west-1-8080-HASH
    • ‫3 בדיקות תקינות:
      • בדיקת התקינות של store: gkemcg1-store-store-8080-HASH
      • בדיקת התקינות של store-east-1: gkemcg1-store-store-east-1-8080-HASH
      • בדיקת התקינות של store-west-1: gkemcg1-store-store-west-1-8080-HASH
    • כלל ניתוב אחד ב-URLmap:
      • כלל הניתוב store.example.com:
      • מארח אחד: store.example.com
      • כמה matchRules לניתוב לשירותים החדשים לקצה העורפי

בתרשים הבא מוצגים המשאבים שפרסתם בשני האשכולות. מכיוון ש-gke-west-1 הוא אשכול הגדרות השער, זהו האשכול שבו בקר השער עוקב אחרי השער, HTTPRoutes ו-ServiceImports. לכל אשכול יש ServiceImport של store ו-ServiceImport נוסף שספציפי לאשכול הזה. שניהם מצביעים על אותם Pods. כך אפשר לציין ב-HTTPRoute בדיוק לאן תעבורת הנתונים צריכה להגיע – ל-Pods של store באשכול ספציפי או ל-Pods של store בכל האשכולות.

זהו מודל המשאבים של Gateway ו-Multi-cluster Service בשני האשכולות

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

מתבצע אימות של הפריסה

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

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

    kubectl describe gateways.gateway.networking.k8s.io external-http --context gke-west-1 --namespace store
    

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

    Name:         external-http
    Namespace:    store
    Labels:       <none>
    Annotations:  networking.gke.io/addresses: /projects/PROJECT_NUMBER/global/addresses/gkemcg1-store-external-http-laup24msshu4
                  networking.gke.io/backend-services:
                    /projects/PROJECT_NUMBER/global/backendServices/gkemcg1-store-gw-serve404-80-n65xmts4xvw2, /projects/PROJECT_NUMBER/global/backendServices/gke...
                  networking.gke.io/firewalls: /projects/PROJECT_NUMBER/global/firewalls/gkemcg1-l7-default-global
                  networking.gke.io/forwarding-rules: /projects/PROJECT_NUMBER/global/forwardingRules/gkemcg1-store-external-http-a5et3e3itxsv
                  networking.gke.io/health-checks:
                    /projects/PROJECT_NUMBER/global/healthChecks/gkemcg1-store-gw-serve404-80-n65xmts4xvw2, /projects/PROJECT_NUMBER/global/healthChecks/gkemcg1-s...
                  networking.gke.io/last-reconcile-time: 2023-10-12T17:54:24Z
                  networking.gke.io/ssl-certificates:
                  networking.gke.io/target-http-proxies: /projects/PROJECT_NUMBER/global/targetHttpProxies/gkemcg1-store-external-http-94oqhkftu5yz
                  networking.gke.io/target-https-proxies:
                  networking.gke.io/url-maps: /projects/PROJECT_NUMBER/global/urlMaps/gkemcg1-store-external-http-94oqhkftu5yz
    API Version:  gateway.networking.k8s.io/v1
    Kind:         Gateway
    Metadata:
      Creation Timestamp:  2023-10-12T06:59:32Z
      Finalizers:
        gateway.finalizer.networking.gke.io
      Generation:        1
      Resource Version:  467057
      UID:               1dcb188e-2917-404f-9945-5f3c2e907b4c
    Spec:
      Gateway Class Name:  gke-l7-global-external-managed-mc
      Listeners:
        Allowed Routes:
          Kinds:
            Group:  gateway.networking.k8s.io
            Kind:   HTTPRoute
          Namespaces:
            From:  Same
        Name:      http
        Port:      80
        Protocol:  HTTP
    Status:
      Addresses:
        Type:   IPAddress
        Value:  34.36.127.249
      Conditions:
        Last Transition Time:  2023-10-12T07:00:41Z
        Message:               The OSS Gateway API has deprecated this condition, do not depend on it.
        Observed Generation:   1
        Reason:                Scheduled
        Status:                True
        Type:                  Scheduled
        Last Transition Time:  2023-10-12T07:00:41Z
        Message:
        Observed Generation:   1
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
        Last Transition Time:  2023-10-12T07:00:41Z
        Message:
        Observed Generation:   1
        Reason:                Programmed
        Status:                True
        Type:                  Programmed
        Last Transition Time:  2023-10-12T07:00:41Z
        Message:               The OSS Gateway API has altered the "Ready" condition semantics and reservedit for future use.  GKE Gateway will stop emitting it in a future update, use "Programmed" instead.
        Observed Generation:   1
        Reason:                Ready
        Status:                True
        Type:                  Ready
      Listeners:
        Attached Routes:  1
        Conditions:
          Last Transition Time:  2023-10-12T07:00:41Z
          Message:
          Observed Generation:   1
          Reason:                Programmed
          Status:                True
          Type:                  Programmed
          Last Transition Time:  2023-10-12T07:00:41Z
          Message:               The OSS Gateway API has altered the "Ready" condition semantics and reservedit for future use.  GKE Gateway will stop emitting it in a future update, use "Programmed" instead.
          Observed Generation:   1
          Reason:                Ready
          Status:                True
          Type:                  Ready
        Name:                    http
        Supported Kinds:
          Group:  gateway.networking.k8s.io
          Kind:   HTTPRoute
    Events:
      Type    Reason  Age                    From                   Message
      ----    ------  ----                   ----                   -------
      Normal  UPDATE  35m (x4 over 10h)      mc-gateway-controller  store/external-http
      Normal  SYNC    4m22s (x216 over 10h)  mc-gateway-controller  SYNC on store/external-http was a success
    
  2. אחרי שהשער נפרס בהצלחה, מאחזרים את כתובת ה-IP החיצונית מהשער של external-http.

    kubectl get gateways.gateway.networking.k8s.io external-http -o=jsonpath="{.status.addresses[0].value}" --context gke-west-1 --namespace store
    

    בשלבים הבאים, מחליפים את VIP בכתובת ה-IP שמתקבלת כפלט.

  3. הפניית התנועה לנתיב הבסיס של הדומיין. כך מתבצע איזון עומסים של התנועה אל store ServiceImport, שנמצא באשכולות gke-west-1 ו-gke-east-1. מאזן העומסים שולח את התנועה לאזור הכי קרוב אליכם, ויכול להיות שלא תראו תגובות מהאזור השני.

    curl -H "host: store.example.com" http://VIP
    

    הפלט מאשר שהבקשה טופלה על ידי Pod מאשכול gke-east-1:

    {
      "cluster_name": "gke-east-1",
      "zone": "us-east1-b",
      "host_header": "store.example.com",
      "node_name": "gke-gke-east-1-default-pool-7aa30992-t2lp.c.agmsb-k8s.internal",
      "pod_name": "store-5f5b954888-dg22z",
      "pod_name_emoji": "⏭",
      "project_id": "agmsb-k8s",
      "timestamp": "2021-06-01T17:32:51"
    }
    
  4. אחר כך שולחים תנועה לנתיב /west. הפעולה הזו מנתבת את התנועה אל store-west-1 ServiceImport, שכולל רק Pods שפועלים באשכול gke-west-1. ‫ServiceImport ספציפי לאשכול, כמו store-west-1, מאפשר לבעלי האפליקציה לשלוח תנועה באופן מפורש לאשכול ספציפי, במקום לאפשר למאזן העומסים לקבל את ההחלטה.

    curl -H "host: store.example.com" http://VIP/west
    

    הפלט מאשר שהבקשה טופלה על ידי Pod מאשכול gke-west-1:

    {
      "cluster_name": "gke-west-1", 
      "zone": "us-west1-a", 
      "host_header": "store.example.com",
      "node_name": "gke-gke-west-1-default-pool-65059399-2f41.c.agmsb-k8s.internal",
      "pod_name": "store-5f5b954888-d25m5",
      "pod_name_emoji": "🍾",
      "project_id": "agmsb-k8s",
      "timestamp": "2021-06-01T17:39:15",
    }
    
  5. בסיום, שולחים תנועה לנתיב /east.

    curl -H "host: store.example.com" http://VIP/east
    

    הפלט מאשר שהבקשה טופלה על ידי Pod מאשכול gke-east-1:

    {
      "cluster_name": "gke-east-1",
      "zone": "us-east1-b",
      "host_header": "store.example.com",
      "node_name": "gke-gke-east-1-default-pool-7aa30992-7j7z.c.agmsb-k8s.internal",
      "pod_name": "store-5f5b954888-hz6mw",
      "pod_name_emoji": "🧜🏾",
      "project_id": "agmsb-k8s",
      "timestamp": "2021-06-01T17:40:48"
    }
    

הסרת המשאבים

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

  1. מוחקים את האשכולות.

  2. ביטול הרישום של האשכולות ב-Fleet, אם לא צריך לרשום אותם למטרה אחרת.

  3. השבתת התכונה multiclusterservicediscovery:

    gcloud container fleet multi-cluster-services disable
    
  4. השבתת Multi Cluster Ingress:

    gcloud container fleet ingress disable
    
  5. משביתים את ממשקי ה-API:

    gcloud services disable \
        multiclusterservicediscovery.googleapis.com \
        multiclusteringress.googleapis.com \
        trafficdirector.googleapis.com \
        --project=PROJECT_ID
    

פתרון בעיות

אין שרת upstream תקין

התסמין:

הבעיה הבאה יכולה להתרחש כשיוצרים שער אבל לא מצליחים לגשת לשירותים לקצה העורפי (קוד תגובה 503):

no healthy upstream

הסיבה:

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

פתרון עקיף:

כדי לפתור את הבעיה, התאימו אישית את בדיקת התקינות בהתאם לדרישות של האפליקציה (לדוגמה, /health) באמצעות HealthCheckPolicy.

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