Full-Stack-Arbeitslasten in großem Maßstab in GKE ausführen

Autopilot

---

Diese Anleitung enthält Anweisungen zum Arbeiten mit Helm-Version 3.9.3, PostgreSQL-Version 10.0.1 und dem Locust-Lasttest-Tool. Die Anleitung bezieht sich möglicherweise nicht auf neuere Versionen der Anwendung. Weitere Informationen finden Sie in der anwendungsspezifischen Dokumentation:

• Helm
• PostgreSQL
• Locust

In dieser Anleitung erfahren Sie, wie Sie eine Webanwendung ausführen, die von einer hochverfügbaren relationalen Datenbank in großem Maßstab in Google Kubernetes Engine (GKE) unterstützt wird.

Die in dieser Anleitung verwendete Beispielanwendung ist Bank of Anthos, eine HTTP-basierte Webanwendung, die das Zahlungsabwicklungsnetzwerk einer Bank simuliert. Bank of Anthos verwendet mehrere Dienste. In dieser Anleitung geht es um das Frontend der Website und die relationalen PostgreSQL-Datenbanken, die die Bank of Anthos-Dienste unterstützen. Weitere Informationen zu Bank of Anthos, einschließlich seiner Architektur und der bereitgestellten Dienste, finden Sie unter Bank of Anthos auf GitHub.

Ziele

• GKE-Cluster erstellen und konfigurieren
• Beispielwebanwendung und eine hochverfügbare PostgreSQL-Datenbank bereitstellen
• Autoscaling der Webanwendung und der Datenbank konfigurieren
• Traffic-Spitzen mit einem Lastgenerator simulieren
• Beobachten, wie die Dienste vertikal und horizontal skaliert werden

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

• GKE Autopilot
• Internal passthrough Network Load Balancer
• Cloud Trace

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Hinweise

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

5. Make sure that billing is enabled for your Google Cloud project.

6. Enable the GKE API:

   gcloud services enable container.googleapis.com

7. Install the Google Cloud CLI.

8. To initialize the gcloud CLI, run the following command:

   gcloud init

9. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

10. Make sure that billing is enabled for your Google Cloud project.

11. Enable the GKE API:

    gcloud services enable container.googleapis.com

12. Installieren Sie die Helm-Befehlszeile.

Umgebung vorbereiten

1. Klonen Sie das in dieser Anleitung verwendete Beispiel-Repository:

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

2. Legen Sie Umgebungsvariablen fest:

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

   Ersetzen Sie PROJECT_ID durch Ihre Google Cloud-Projekt-ID.

Cluster und Dienstkonten einrichten

1. Erstellen Sie einen Cluster.

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

   Es kann bis zu fünf Minuten dauern, bis der Cluster startet.

2. Erstellen Sie ein IAM-Dienstkonto:

   gcloud iam service-accounts create bank-of-anthos
   

3. Gewähren Sie Zugriff auf das IAM-Dienstkonto:

   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]"
   

   Mit diesem Schritt wird der folgende Zugriff gewährt:

   • roles/cloudtrace.agent: Trace-Daten wie Latenzinformationen in Trace schreiben.
   • roles/monitoring.metricWriter: Messwerte in Cloud Monitoring schreiben.
   • roles/iam.workloadIdentityUser: Einem Kubernetes-Dienstkonto erlauben, die Workload Identity-Föderation für GKE zu verwenden, um als IAM-Dienstkonto zu fungieren.

4. Konfigurieren Sie das Kubernetes-Dienstkonto default im Namespace default so, dass es als von Ihnen erstelltes IAM-Dienstkonto fungiert:

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

   Dadurch können Pods, die das Kubernetes-Dienstkonto default im Namespace default verwenden, auf dieselben Google Cloud-Ressourcen wie das IAM-Dienstkonto zugreifen.

Bank of Anthos und PostgreSQL bereitstellen

In diesem Abschnitt installieren Sie Bank of Anthos und eine PostgreSQL-Datenbank im hochverfügbaren Modus (HA), sodass Sie Replikate des Datenbankservers automatisch skalieren können. Wenn Sie sich die in diesem Abschnitt verwendeten Skripts, Helm-Diagramme und Kubernetes-Manifeste ansehen möchten, rufen Sie das Bank of Anthos-Repository auf GitHub auf.

1. Stellen Sie das Datenbankschema und ein DDL-Script (Data Definition Language, Datendefinitionssprache) bereit:

   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. Verwenden Sie das Beispiel-Helm-Diagramm, um PostgreSQL zu installieren:

   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
   

   Mit diesem Befehl wird ein PostgreSQL-Cluster mit einer anfänglichen Replikatanzahl von 1 erstellt. Später in dieser Anleitung skalieren Sie den Cluster basierend auf eingehenden Verbindungen. Dieser Vorgang kann zehn Minuten oder länger dauern.

3. Stellen Sie Bank of Anthos bereit:

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

   Dieser Vorgang kann einige Minuten dauern.

Prüfpunkt: Einrichtung validieren

1. Prüfen Sie, ob alle Bank of Anthos-Pods ausgeführt werden:

   kubectl get pods
   

   Die Ausgabe sieht in etwa so aus:

   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. Prüfen Sie, ob Sie auf das Website-Frontend zugreifen können:

   1. Rufen Sie die externe IP-Adresse des frontend-Dienstes ab:

      kubectl get ingress frontend
      

      Die Ausgabe sieht in etwa so aus:

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

   2. Rufen Sie in einem Browser die externe IP-Adresse auf. Die Anmeldeseite von Bank of Anthos wird angezeigt. Wenn Sie neugierig sind, sehen Sie sich die Anwendung an.

      Wenn Sie einen 404-Fehler erhalten, warten Sie einige Minuten, bis die Mikrodienste bereitgestellt wurden, und versuchen Sie es noch einmal.

Webanwendung und PostgreSQL-Datenbank automatisch skalieren

GKE Autopilot skaliert die Cluster-Computing-Ressourcen anhand der Anzahl der Arbeitslasten im Cluster. Wenn Sie die Anzahl der Pods im Cluster anhand von Ressourcenmesswerten automatisch skalieren möchten, müssen Sie das horizontale Pod-Autoscaling von Kubernetes implementieren. Sie können die integrierten Kubernetes-CPU- und -Arbeitsspeichermesswerte oder benutzerdefinierte Messwerte wie die HTTP-Anfragen pro Sekunde oder die Anzahl der SELECT-Anweisungen aus Cloud Monitoring verwenden.

In diesem Abschnitt tun Sie Folgendes:

1. Konfigurieren Sie das horizontale Pod-Autoscaling für die Bank of Anthos-Mikrodienste mit integrierten und benutzerdefinierten Messwerten.
2. Simulieren Sie die Last der Bank of Anthos-Anwendung, um Autoscaling-Ereignisse auszulösen.
3. Beobachten Sie, wie die Anzahl der Pods und Knoten in Ihrem Cluster automatisch entsprechend Ihrer Last skaliert wird.

Erfassung benutzerdefinierter Messwerte einrichten

Wenn Sie benutzerdefinierte Messwerte aus Monitoring lesen möchten, müssen Sie in Ihrem Cluster den Adapter Benutzerdefinierte Messwerte – Stackdriver-Adapter bereitstellen.

1. Stellen Sie den Adapter bereit:

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

2. Konfigurieren Sie den Adapter für die Verwendung der Workload Identity-Föderation für GKE, um Messwerte abzurufen:

   1. Konfigurieren Sie das IAM-Dienstkonto:

      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. Annotieren Sie dann das vom Adapter verwendete Kubernetes-Dienstkonto:

      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. Starten Sie das Adapter-Deployment neu, um die Änderungen zu übernehmen:

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

Autoscaling für die Datenbank konfigurieren

Wenn Sie in dieser Anleitung Bank of Anthos und PostgreSQL bereitgestellt haben, haben Sie die Datenbank als StatefulSet mit einem primären Lese-/Schreibreplikat für die Verarbeitung aller eingehenden SQL-Anweisungen bereitgestellt. In diesem Abschnitt konfigurieren Sie das horizontale Pod-Autoscaling, um neue schreibgeschützte Standby-Replikate für den Standby-Cluster zum Verarbeiten eingehender SELECT-Anweisungen hinzuzufügen. Eine gute Möglichkeit, die Last auf jedem Replikat zu reduzieren, besteht darin, SELECT-Anweisungen zu verteilen, bei denen es sich um Lesevorgänge handelt. Die PostgreSQL-Bereitstellung enthält ein Tool namens Pgpool-II, das dieses Load-Balancing erreicht und den Durchsatz des Systems verbessert.

PostgreSQL exportiert den SELECT-Anweisungsmesswert als Prometheus-Messwert. Sie verwenden einen einfachen Messwert-Exporter mit dem Namen prometheus-to-sd, um diese Messwerte in einem unterstützten Format an Cloud Monitoring zu senden.

1. Überprüfen Sie das Objekt 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"
   

   Das Manifest tut Folgendes:

   • Legt die maximale Anzahl von Replikaten beim Hochskalieren auf 5 fest.
   • Legt die Mindestanzahl von Replikaten beim Herunterskalieren auf 1 fest.
   • Verwendet einen externen Messwert, um Skalierungsentscheidungen zu treffen. In diesem Beispiel ist der Messwert die Anzahl der SELECT-Anweisungen. Ein Hochskalierungsereignis tritt auf, wenn die Anzahl eingehender SELECT-Anweisungen mehr als 15 beträgt.

2. Wenden Sie das Manifest auf den Cluster an:

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

Autoscaling für die Weboberfläche konfigurieren

Unter Bank of Anthos und PostgreSQL bereitstellen haben Sie die Bank of Anthos-Weboberfläche bereitgestellt. Wenn die Anzahl der Nutzer zunimmt, verbraucht der userservice-Service mehr CPU-Ressourcen. In diesem Abschnitt konfigurieren Sie das horizontale Pod-Autoscaling für das userservice-Deployment, wenn die vorhandenen Pods mehr als 60 % der angeforderten CPU verwenden, und das frontend-Deployment, wenn die Anzahl der eingehenden HTTP-Anfragen an den Load-Balancer bei mehr als 5 Anfragen pro Sekunde liegt.

Autoscaling für das userservice-Deployment konfigurieren

1. Überprüfen Sie das HorizontalPodAutoscaler-Manifest für das userservice-Deployment:

   # 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
   

   Das Manifest tut Folgendes:

   • Legt die maximale Anzahl von Replikaten beim Hochskalieren auf 50 fest.
   • Legt die Mindestanzahl von Replikaten beim Herunterskalieren auf 5 fest.
   • Verwendet einen integrierten Kubernetes-Messwert, um Skalierungsentscheidungen zu treffen. In diesem Beispiel ist der Messwert die CPU-Auslastung und die Zielauslastung beträgt 60 %. Damit werden eine Über- und eine Unterauslastung vermieden.

2. Wenden Sie das Manifest auf den Cluster an:

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

Autoscaling für die Frontend-Bereitstellung konfigurieren

1. Überprüfen Sie das HorizontalPodAutoscaler-Manifest für das userservice-Deployment:

   # 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"
   

   Dieses Manifest verwendet die folgenden Felder:

   • spec.scaleTargetRef: Die Kubernetes-Ressource, die skaliert werden soll.
   • spec.minReplicas: Die Mindestanzahl von Replikaten, also 5 in diesem Beispiel.
   • spec.maxReplicas: Die maximale Anzahl von Replikaten, also 25 in diesem Beispiel.
   • spec.metrics.*: Der zu verwendende Messwert. In diesem Beispiel ist dies die Anzahl der HTTP-Anfragen pro Sekunde, ein benutzerdefinierter Messwert von Cloud Monitoring, der von dem von Ihnen bereitgestellten Adapter zur Verfügung gestellt wird.
   • spec.metrics.external.metric.selector.matchLabels: Das spezifische Ressourcenlabel, nach dem beim Autoscaling gefiltert werden soll.

2. Suchen Sie den Namen der Weiterleitungsregel vom Load-Balancer zum frontend-Deployment:

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

   Die Ausgabe sieht in etwa so aus:

   k8s2-fr-j76hrtv4-default-frontend-wvvf7381
   

3. Fügen Sie dem Manifest Ihre Weiterleitungsregel hinzu:

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

   Mit diesem Befehl wird FORWARDING_RULE_NAME durch Ihre gespeicherte Weiterleitungsregel ersetzt.

4. Wenden Sie das Manifest auf den Cluster an:

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

Prüfpunkt: Autoscaling-Einrichtung validieren

Rufen Sie den Zustand Ihrer HorizontalPodAutoscaler-Ressourcen ab:

kubectl get hpa

Die Ausgabe sieht in etwa so aus:

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

An diesem Punkt haben Sie Ihre Anwendung eingerichtet und das Autoscaling konfiguriert. Ihr Frontend und Ihre Datenbank können jetzt anhand der von Ihnen bereitgestellten Messwerte skaliert werden.

Last simulieren und GKE-Skalierung beobachten

Bank of Anthos enthält einen loadgenerator-Service, mit dem Sie den Traffic simulieren können, um die Skalierung Ihrer Anwendung unter Last zu testen. In diesem Abschnitt stellen Sie den loadgenerator-Service bereit, generieren eine Last und beobachten die resultierende Skalierung.

Lasttestgenerator bereitstellen

1. Erstellen Sie eine Umgebungsvariable mit der IP-Adresse des Bank of Anthos-Load-Balancers:

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

   Die Ausgabe sieht in etwa so aus:

   203.0.113.9
   

2. Fügen Sie dem Manifest die IP-Adresse des Load-Balancers hinzu:

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

3. Wenden Sie das Manifest auf den Cluster an:

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

Der Lastgenerator beginnt mit dem Hinzufügen eines Nutzers pro Sekunde bis hin zu 250 Nutzern.

Last simulieren

In diesem Abschnitt verwenden Sie einen Lastgenerator, um Traffic-Spitzen zu simulieren und zu beobachten, wie die Anzahl der Replikate und die Knotenanzahl vertikal skaliert werden, um die erhöhte Last im Laufe der Zeit zu bewältigen. Anschließend beenden Sie den Test und beobachten, wie die Replikat- und die Knotenanzahl als Reaktion herunterskaliert werden.

1. Machen Sie die Weboberfläche des Lastgenerators lokal verfügbar:

   kubectl port-forward svc/loadgenerator 8080
   

   Wenn eine Fehlermeldung angezeigt wird, versuchen Sie es noch einmal, wenn der Pod ausgeführt wird.

2. Öffnen Sie in einem Browser die Weboberfläche des Lastgenerators.

   • Wenn Sie eine lokale Shell verwenden, öffnen Sie einen Browser und rufen Sie http://127.0.0.1:8080 auf.
   • Wenn Sie Cloud Shell verwenden, klicken Sie auf Webvorschau und dann auf Vorschau auf Port 8080.

3. Klicken Sie auf den Tab Diagramme, um die Leistung im Zeitverlauf zu beobachten.

4. Öffnen Sie ein neues Terminalfenster und beobachten Sie die Anzahl der Replikate Ihrer horizontalen Pod-Autoscalings:

   kubectl get hpa -w
   

   Die Anzahl der Replikate erhöht sich, wenn die Last zunimmt. Das Hochskalieren kann etwa zehn Minuten dauern.

   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. Öffnen Sie ein anderes Terminalfenster und prüfen Sie die Anzahl der Knoten im Cluster:

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

6. Die Anzahl der Knoten wurde von der Startmenge von drei Knoten aus erhöht, um die neuen Replikate unterzubringen.

7. Öffnen Sie die Benutzeroberfläche des Lastgenerators und klicken Sie auf Beenden, um den Test zu beenden.

8. Prüfen Sie die Replikatanzahl und die Knotenanzahl noch einmal und beobachten Sie, wie sich die Zahlen mit der geringeren Last verringern. Das Herunterskalieren kann einige Zeit dauern, da das standardmäßige Stabilisierungsfenster für Replikate in der Kubernetes-HorizontalPodAutoscaler-Ressource fünf Minuten beträgt. Weitere Informationen finden Sie unter Stabilisierungsfenster.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Einzelne Ressourcen löschen

Google Cloud erstellt Ressourcen wie Load-Balancer basierend auf den von Ihnen erstellten Kubernetes-Objekten. So löschen Sie alle Ressourcen in dieser Anleitung:

1. Löschen Sie die Kubernetes-Beispielressourcen:

   kubectl delete \
       -f extras/postgres-hpa/loadgenerator.yaml \
       -f extras/postgres-hpa/hpa \
       -f extras/postgres-hpa/kubernetes-manifests \
       -f extras/jwt/jwt-secret.yaml \
       -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter.yaml
   

2. Löschen Sie die PostgreSQL-Datenbank:

   helm uninstall accounts-db
   kubectl delete pvc -l "app.kubernetes.io/instance=accounts-db"
   kubectl delete configmaps initdb
   

3. Löschen Sie den GKE-Cluster und das IAM-Dienstkonto:

   gcloud iam service-accounts delete "bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com" --quiet
   gcloud container clusters delete "bank-of-anthos" --region="us-central1" --quiet
   

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

• Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
• Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Nächste Schritte

• Erfahren Sie mehr über vertikales Pod-Autoscaling, mit dem Sie Ressourcenanforderungen für lang andauernde Arbeitslasten automatisch mit Empfehlungen anpassen können, die auf der bisherigen Nutzung basieren.
• Weitere Informationen zum horizontalen Pod-Autoscaling