הרצה של עומסי עבודה מלאים בקנה מידה גדול ב-GKE

הכנת הסביבה

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

   git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git
   cd bank-of-anthos/
   

2. הגדרת משתני סביבה:

   PROJECT_ID=PROJECT_ID
   GSA_NAME=bank-of-anthos
   GSA_EMAIL=bank-of-anthos@${PROJECT_ID}.iam.gserviceaccount.com
   KSA_NAME=default
   

   מחליפים את PROJECT_ID במזהה הפרויקט ב- Google Cloud .

הגדרת האשכול וחשבונות השירות

1. יצירת אשכול:

   gcloud container clusters create-auto bank-of-anthos --location=us-central1
   

   יכול להיות שיחלפו עד חמש דקות עד שהאשכול יתחיל לפעול.

2. יוצרים חשבון שירות ב-IAM:

   gcloud iam service-accounts create bank-of-anthos
   

3. נותנים גישה לחשבון השירות ב-IAM:

   gcloud projects add-iam-policy-binding PROJECT_ID \
     --role roles/cloudtrace.agent \
     --member "serviceAccount:bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com"
   gcloud projects add-iam-policy-binding PROJECT_ID \
     --role roles/monitoring.metricWriter \
     --member "serviceAccount:bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com"
   gcloud iam service-accounts add-iam-policy-binding "bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com" \
     --role roles/iam.workloadIdentityUser \
     --member "serviceAccount:PROJECT_ID.svc.id.goog[default/default]"
   

   בשלב הזה ניתנת הגישה הבאה:

   • ‫roles/cloudtrace.agent: כתיבת נתוני מעקב כמו מידע על זמן האחזור אל Trace.
   • ‫roles/monitoring.metricWriter: כתיבת מדדים ל-Cloud Monitoring.
   • ‫roles/iam.workloadIdentityUser: מאפשרים לחשבון שירות של Kubernetes להשתמש ב-איחוד זהויות של עומסי עבודה ל-GKE כדי לפעול כחשבון שירות של IAM.

4. מגדירים את חשבון השירות של Kubernetes default במרחב השמות default כך שיפעל כחשבון השירות של IAM שיצרתם:

   kubectl annotate serviceaccount default \
       iam.gke.io/gcp-service-account=bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com
   

   כך קבוצות ה-Pod שמשתמשות בdefaultחשבון השירות של Kubernetes במרחב השמות default יכולות לגשת לאותם Google Cloud משאבים של חשבון השירות של IAM.

פריסת Bank of Anthos ו-PostgreSQL

בקטע הזה מתקינים את Bank of Anthos ואת מסד הנתונים PostgreSQL במצב זמינות גבוהה (HA), שמאפשר להגדיר קנה מידה אוטומטי של העתקים של שרת מסד הנתונים. אם אתם רוצים לראות את הסקריפטים, את תרשים Helm ואת מניפסטים של Kubernetes שבהם נעשה שימוש בקטע הזה, תוכלו לעיין במאגר Bank of Anthos ב-GitHub.

1. פורסים את סכימת מסד הנתונים ואת הסקריפט של שפת הגדרת הנתונים (DDL):

   kubectl create configmap initdb \
       --from-file=src/accounts/accounts-db/initdb/0-accounts-schema.sql \
       --from-file=src/accounts/accounts-db/initdb/1-load-testdata.sql \
       --from-file=src/ledger/ledger-db/initdb/0_init_tables.sql \
       --from-file=src/ledger/ledger-db/initdb/1_create_transactions.sh
   

2. מתקינים את PostgreSQL באמצעות תרשים ה-Helm לדוגמה:

   helm repo add bitnami https://charts.bitnami.com/bitnami
   helm install accounts-db bitnami/postgresql-ha \
       --version 10.0.1 \
       --values extras/postgres-hpa/helm-postgres-ha/values.yaml \
       --set="postgresql.initdbScriptsCM=initdb" \
       --set="postgresql.replicaCount=1" \
       --wait
   

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

3. פורסים את Bank of Anthos:

   kubectl apply -f extras/jwt/jwt-secret.yaml
   kubectl apply -f extras/postgres-hpa/kubernetes-manifests
   

   הפעולה הזו עשויה להימשך כמה דקות.

נקודת ביניים: אימות ההגדרה

1. בודקים שכל ה-Pods של Bank of Anthos פועלים:

   kubectl get pods
   

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

   NAME                                  READY   STATUS
   accounts-db-pgpool-57ffc9d685-c7xs8   3/3     Running
   accounts-db-postgresql-0              1/1     Running
   balancereader-57b59769f8-xvp5k        1/1     Running
   contacts-54f59bb669-mgsqc             1/1     Running
   frontend-6f7fdc5b65-h48rs             1/1     Running
   ledgerwriter-cd74db4cd-jdqql          1/1     Running
   pgpool-operator-5f678457cd-cwbhs      1/1     Running
   transactionhistory-5b9b56b5c6-sz9qz   1/1     Running
   userservice-f45b46b49-fj7vm           1/1     Running
   

2. בודקים שאפשר לגשת לחלק הקדמי של האתר:

   1. קבלת כתובת ה-IP החיצונית של שירות frontend:

      kubectl get ingress frontend
      

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

      NAME       CLASS    HOSTS   ADDRESS         PORTS   AGE
      frontend   <none>   *       203.0.113.9     80      12m
      

   2. בדפדפן, עוברים לכתובת ה-IP החיצונית. מוצג דף הכניסה של Bank of Anthos. אם אתם רוצים לדעת יותר, אתם יכולים לעיין בבקשה.

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

שינוי קנה מידה אוטומטי של אפליקציית האינטרנט ומסד הנתונים של PostgreSQL

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

בקטע הזה תלמדו:

1. הגדרת התאמה אופקית של קבוצות Pod לעומס (horizontal Pod autoscaling) למיקרו-שירותים של Bank of Anthos באמצעות מדדים מובנים ומדדים מותאמים אישית.
2. מדמים עומס באפליקציית Bank of Anthos כדי להפעיל אירועים של שינוי גודל אוטומטי.
3. שימו לב איך מספר ה-Pods והצמתים באשכול גדל וקטן באופן אוטומטי בתגובה לעומס.

הגדרת איסוף של מדדים מותאמים אישית

כדי לקרוא מדדים מותאמים אישית מ-Monitoring, צריך לפרוס את המתאם Custom Metrics - Stackdriver Adapter באשכול.

1. פורסים את המתאם:

   kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter.yaml
   

2. מגדירים את המתאם כך שישתמש באיחוד זהויות של עומסי עבודה ל-GKE כדי לקבל מדדים:

   1. מגדירים את חשבון השירות ב-IAM:

      gcloud projects add-iam-policy-binding PROJECT_ID \
          --member "serviceAccount:bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com" \
          --role roles/monitoring.viewer
      gcloud iam service-accounts add-iam-policy-binding bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com \
          --role roles/iam.workloadIdentityUser \
          --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
      

   2. מוסיפים הערה לחשבון השירות ב-Kubernetes שבו המתאם משתמש:

      kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
          --namespace=custom-metrics \
        iam.gke.io/gcp-service-account=bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com
      

   3. מפעילים מחדש את הפריסה של המתאם כדי להפיץ את השינויים:

      kubectl rollout restart deployment custom-metrics-stackdriver-adapter \
          --namespace=custom-metrics
      

הגדרת התאמה אוטומטית של נפח האחסון למסד הנתונים

כשפרסתם את Bank of Anthos ואת PostgreSQL מוקדם יותר במדריך הזה, פרסתם את מסד הנתונים כ-StatefulSet עם עותק ראשי אחד לקריאה/כתיבה כדי לטפל בכל הצהרות ה-SQL הנכנסות. בקטע הזה מגדירים את ההתאמה האופקית של קבוצות Pod לעומס כדי להוסיף רפליקות חדשות במצב המתנה לקריאה בלבד, שיטפלו בהצהרות SELECT נכנסות. דרך טובה להפחית את העומס על כל עותק היא לפזר את הצהרות SELECT, שהן פעולות קריאה. פריסת PostgreSQL כוללת כלי בשם Pgpool-II שמבצע את איזון העומסים הזה ומשפר את קצב העברת הנתונים של המערכת.

מערכת PostgreSQL מייצאת את מדד הצהרת ה-SELECT כמדד Prometheus. תשתמשו בכלי קל לייצוא מדדים בשם prometheus-to-sd כדי לשלוח את המדדים האלה ל-Cloud Monitoring בפורמט נתמך.

1. בודקים את אובייקט HorizontalPodAutoscaler:

   # Copyright 2022 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #      http://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ---
   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: accounts-db-postgresql
   spec:
     behavior:
       scaleUp:
         stabilizationWindowSeconds: 0
         policies:
         - type: Percent
           value: 100
           periodSeconds: 5
         selectPolicy: Max
     scaleTargetRef:
       apiVersion: apps/v1
       kind: StatefulSet
       name: accounts-db-postgresql
     minReplicas: 1
     maxReplicas: 5
     metrics:
     - type: External
       external:
         metric:
           name: custom.googleapis.com|mypgpool|pgpool2_pool_backend_stats_select_cnt
         target:
             type: AverageValue
             averageValue: "15"
   

   קובץ המניפסט הזה:

   • ההגדרה הזו קובעת את המספר המקסימלי של העותקים במהלך הגדלה עד 5.
   • ההגדרה הזו קובעת את המספר המינימלי של מכונות במהלך הקטנת הקיבולת ל-1.
   • משתמש במדד חיצוני כדי לקבל החלטות לגבי הרחבת הפעילות. בדוגמה הזו, המדד הוא מספר הצהרות SELECT. אירוע של הגדלת הקיבולת מתרחש אם מספר הצהרות ה-SELECT הנכנסות עולה על 15.

2. מחילים את המניפסט על האשכול:

   kubectl apply -f extras/postgres-hpa/hpa/postgresql-hpa.yaml
   

הגדרת התאמה אוטומטית של נפח האחסון לממשק האינטרנט

בקטע Deploy Bank of Anthos and PostgreSQL (פריסת Bank of Anthos ו-PostgreSQL), פרסתם את ממשק האינטרנט של Bank of Anthos. ככל שמספר המשתמשים גדל, שירות userservice צורך יותר משאבי CPU. בקטע הזה, מגדירים את ההתאמה האופקית של קבוצות Pod לעומס עבור Deployment (פריסה) userservice כשקבוצות ה-Pod הקיימות משתמשות ביותר מ-60% מהמעבד (CPU) המבוקש שלהן, ועבור Deployment (פריסה) frontend כשמספר בקשות ה-HTTP הנכנסות למאזן העומסים (LB) גבוה מ-5 לשנייה.

הגדרת התאמה אוטומטית לעומס (autoscaling) לפריסת userservice

1. בודקים את המניפסט של HorizontalPodAutoscaler Deployment:‎ userservice

   # Copyright 2022 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #      http://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ---
   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: userservice
   spec:
     behavior:
       scaleUp:
         stabilizationWindowSeconds: 0
         policies:
           - type: Percent
             value: 100
             periodSeconds: 5
         selectPolicy: Max
     scaleTargetRef:
       apiVersion: apps/v1
       kind: Deployment
       name: userservice
     minReplicas: 5
     maxReplicas: 50
     metrics:
       - type: Resource
         resource:
           name: cpu
           target:
             type: Utilization
             averageUtilization: 60
   

   קובץ המניפסט הזה:

   • ההגדרה הזו קובעת את המספר המקסימלי של העותקים במהלך הגדלה עד 50.
   • ההגדרה הזו קובעת את המספר המינימלי של מכונות במהלך הקטנת הקיבולת ל-5.
   • משתמש במדד מובנה של Kubernetes כדי לקבל החלטות לגבי שינוי גודל. בדוגמה הזו, המדד הוא ניצול המעבד (CPU), וניצול היעד הוא 60%, כדי להימנע מניצול יתר ומתת-ניצול.

2. מחילים את המניפסט על האשכול:

   kubectl apply -f extras/postgres-hpa/hpa/userservice.yaml
   

הגדרת התאמה אוטומטית לעומס (autoscaling) לפריסת הקצה הקדמי

1. בודקים את המניפסט של HorizontalPodAutoscaler Deployment:‎ userservice

   # Copyright 2022 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #      http://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ---
   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: frontend
   spec:
     behavior:
       scaleUp:
         stabilizationWindowSeconds: 0
         policies:
           - type: Percent
             value: 100
             periodSeconds: 5
         selectPolicy: Max
     scaleTargetRef:
       apiVersion: apps/v1
       kind: Deployment
       name: frontend
     minReplicas: 5
     maxReplicas: 25
     metrics:
       - type: External
         external:
           metric:
             name: loadbalancing.googleapis.com|https|request_count
             selector:
               matchLabels:
                 resource.labels.forwarding_rule_name: FORWARDING_RULE_NAME
           target:
             type: AverageValue
             averageValue: "5"
   

   קובץ המניפסט הזה כולל את השדות הבאים:

   • ‫spec.scaleTargetRef: משאב ב-Kubernetes לשינוי גודל.
   • ‫spec.minReplicas: מספר העותקים המינימלי, שהוא 5 בדוגמה הזו.
   • ‫spec.maxReplicas: המספר המקסימלי של העותקים, שהוא 25 בדוגמה הזו.
   • ‫spec.metrics.*: המדד שבו רוצים להשתמש. בדוגמה הזו, זהו מספר בקשות ה-HTTP לשנייה, שהוא מדד מותאם אישית מ-Cloud Monitoring שמסופק על ידי המתאם שפרסתם.
   • ‫spec.metrics.external.metric.selector.matchLabels: תווית המשאב הספציפית לסינון כשמשתמשים בשינוי גודל אוטומטי.

2. מאתרים את השם של כלל ההעברה ממאזן העומסים אל הפריסה frontend:

   export FW_RULE=$(kubectl get ingress frontend -o=jsonpath='{.metadata.annotations.ingress\.kubernetes\.io/forwarding-rule}')
   echo $FW_RULE
   

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

   k8s2-fr-j76hrtv4-default-frontend-wvvf7381
   

3. מוסיפים את כלל ההעברה למניפסט:

   sed -i "s/FORWARDING_RULE_NAME/$FW_RULE/g" "extras/postgres-hpa/hpa/frontend.yaml"
   

   הפקודה הזו מחליפה את FORWARDING_RULE_NAME בכלל ההעברה ששמרתם.

4. מחילים את המניפסט על האשכול:

   kubectl apply -f extras/postgres-hpa/hpa/frontend.yaml
   

נקודת ביניים: אימות ההגדרה של התאמה לעומס (autoscaling)

קבלת המצב של משאבי HorizontalPodAutoscaler:

kubectl get hpa

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

NAME                     REFERENCE                            TARGETS             MINPODS   MAXPODS   REPLICAS   AGE
accounts-db-postgresql   StatefulSet/accounts-db-postgresql   10905m/15 (avg)     1         5         2          5m2s
contacts                 Deployment/contacts                  1%/70%              1         5         1          11m
frontend                 Deployment/frontend                  <unknown>/5 (avg)   5         25        1          34s
userservice              Deployment/userservice               0%/60%              5         50        5          4m56s

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

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

‫Bank of Anthos כולל loadgenerator שירות שמאפשר לדמות תנועה כדי לבדוק את קנה המידה של האפליקציה תחת עומס. בקטע הזה תפרסו את שירות loadgenerator, תיצרו עומס ותצפו בשינוי הגודל שיתקבל.

פריסת מחולל בדיקות העומס

1. יוצרים משתנה סביבה עם כתובת ה-IP של מאזן העומסים של Bank of Anthos:

   export LB_IP=$(kubectl get ingress frontend -o=jsonpath='{.status.loadBalancer.ingress[0].ip}')
   echo $LB_IP
   

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

   203.0.113.9
   

2. מוסיפים את כתובת ה-IP של מאזן העומסים למניפסט:

   sed -i "s/FRONTEND_IP_ADDRESS/$LB_IP/g" "extras/postgres-hpa/loadgenerator.yaml"
   

3. מחילים את המניפסט על האשכול:

   kubectl apply -f  extras/postgres-hpa/loadgenerator.yaml
   

מחולל העומסים מתחיל להוסיף משתמש אחד בכל שנייה, עד 250 משתמשים.

סימולציה של עומס

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

1. חושפים את ממשק האינטרנט של גנרטור העומסים באופן מקומי:

   kubectl port-forward svc/loadgenerator 8080
   

   אם מופיעה הודעת שגיאה, נסו שוב כשה-Pod פועל.

2. בדפדפן, פותחים את ממשק האינטרנט של מחולל העומסים.

   • אם אתם משתמשים במעטפת מקומית, פותחים דפדפן ועוברים אל http://127.0.0.1:8080.
   • אם אתם משתמשים ב-Cloud Shell, לוחצים על preview Web preview ואז על Preview on port 8080.

3. לוחצים על הכרטיסייה תרשימים כדי לראות את הביצועים לאורך זמן.

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

   kubectl get hpa -w
   

   מספר העותקים גדל ככל שהעומס גדל. הגדלת הקיבולת עשויה להימשך כעשר דקות.

   NAME                     REFERENCE                            TARGETS          MINPODS   MAXPODS   REPLICAS
   accounts-db-postgresql   StatefulSet/accounts-db-postgresql   8326m/15 (avg)   1         5         5
   contacts                 Deployment/contacts                  51%/70%          1         5         2
   frontend                 Deployment/frontend                  5200m/5 (avg)    5         25        13
   userservice              Deployment/userservice               71%/60%          5         50        17
   

5. פותחים חלון טרמינל נוסף ובודקים את מספר הצמתים באשכול:

   gcloud container clusters list \
       --filter='name=bank-of-anthos' \
       --format='table(name, currentMasterVersion, currentNodeVersion, currentNodeCount)' \
       --location="us-central1"
   

6. מספר הצמתים גדל מהכמות ההתחלתית של שלושה צמתים כדי לאכלס את העותקים החדשים.

7. פותחים את הממשק של מחולל העומסים ולוחצים על Stop (הפסקה) כדי לסיים את הבדיקה.

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