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

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.

Lernziele

  • 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:

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.

Hinweis

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. Installieren Sie die Google Cloud CLI.

  3. Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren: 

    gcloud init

  4. Create or select a Google Cloud 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. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  6. Aktivieren Sie die GKE API: 

    gcloud services enable container.googleapis.com
    7.
  7. Installieren Sie die Google Cloud CLI.

  8. Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren: 

    gcloud init

  9. Create or select a Google Cloud 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. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  11. Aktivieren Sie die GKE API: 

    gcloud services enable container.googleapis.com
    12.
  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

    Google Cloud-Projekt löschen:

    gcloud projects delete PROJECT_ID

Nächste Schritte