Menjalankan workload full stack dalam skala besar di GKE

Autopilot

---

Tutorial ini memberikan petunjuk untuk menggunakan Helm versi 3.9.3, PostgreSQL versi 10.0.1, dan alat pengujian beban Locust. Petunjuk ini mungkin tidak merepresentasikan versi aplikasi yang lebih baru. Untuk informasi mengetahui selengkapnya, lihat dokumentasi khusus aplikasi:

• Helm
• PostgreSQL
• Locust

Tutorial ini menunjukkan cara menjalankan aplikasi web yang didukung oleh database relasional yang sangat tersedia dalam skala besar di Google Kubernetes Engine (GKE).

Aplikasi contoh yang digunakan dalam tutorial ini adalah Bank of Anthos, aplikasi web berbasis HTTP yang menyimulasikan jaringan pemrosesan pembayaran sebuah bank. Bank of Anthos menggunakan beberapa layanan agar dapat berfungsi. Tutorial ini berfokus pada frontend situs dan database PostgreSQL relasional yang mendukung layanan Bank of Anthos. Untuk mempelajari Bank of Anthos lebih lanjut, termasuk arsitektur dan layanan yang di-deploy, lihat Bank of Anthos di GitHub.

Tujuan

• Membuat dan mengonfigurasi cluster GKE.
• Men-deploy contoh aplikasi web dan database PostgreSQL yang sangat tersedia.
• Mengonfigurasi penskalaan otomatis aplikasi web dan database.
• Menyimulasikan lonjakan traffic menggunakan generator beban.
• Mengamati cara layanan tersebut meningkatkan dan menurunkan skala.

Biaya

Dalam dokumen ini, Anda akan menggunakan komponen Google Cloud yang dapat ditagih berikut:

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

Untuk membuat perkiraan biaya berdasarkan proyeksi penggunaan Anda, gunakan kalkulator harga. Pengguna baru Google Cloud mungkin memenuhi syarat untuk mendapatkan uji coba gratis.

Setelah menyelesaikan tugas yang dijelaskan dalam dokumen ini, Anda dapat menghindari penagihan berkelanjutan dengan menghapus resource yang Anda buat. Untuk mengetahui informasi selengkapnya, lihat Pembersihan.

Sebelum memulai

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. Instal Helm CLI.

Menyiapkan lingkungan

1. Clone contoh repositori yang digunakan dalam tutorial ini:

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

2. Menetapkan variabel lingkungan

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

   Ganti PROJECT_ID dengan ID project Google Cloud Anda.

Menyiapkan akun layanan dan cluster

1. Buat cluster:

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

   Mungkin perlu waktu hingga lima menit untuk memulai cluster.

2. Buat akun layanan IAM:

   gcloud iam service-accounts create bank-of-anthos
   

3. Berikan akses ke akun layanan 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]"
   

   Langkah ini memberikan akses berikut:

   • roles/cloudtrace.agent: Menulis data rekaman aktivitas seperti informasi latensi ke Pelacakan.
   • roles/monitoring.metricWriter: Menulis metrik ke Cloud Monitoring.
   • roles/iam.workloadIdentityUser: Mengizinkan akun layanan Kubernetes untuk menggunakan Workload Identity Federation for GKE agar berfungsi sebagai akun layanan IAM.

4. Konfigurasikan akun layanan Kubernetes default di namespace default untuk berfungsi sebagai akun layanan IAM yang Anda buat:

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

   Hal ini memungkinkan Pod yang menggunakan akun layanan Kubernetes default di namespace default untuk mengakses resource Google Cloud yang sama dengan akun layanan IAM.

Men-deploy Bank of Anthos dan PostgreSQL

Di bagian ini, Anda akan menginstal Bank of Anthos dan database PostgreSQL dalam mode sangat tersedia (HA), yang memungkinkan Anda menskalakan replika server database secara otomatis. Jika Anda ingin melihat skrip, diagram Helm, dan manifes Kubernetes yang digunakan di bagian ini, lihat repositori Bank of Anthos di GitHub.

1. Deploy skema database dan skrip bahasa definisi data (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. Instal PostgreSQL menggunakan contoh chart 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
   

   Perintah ini membuat cluster PostgreSQL dengan jumlah replika awal 1. Nanti dalam tutorial ini, Anda akan menskalakan cluster berdasarkan koneksi masuk. Penyelesaian operasi ini mungkin memerlukan waktu sepuluh menit atau lebih.

3. Deploy Bank of Anthos:

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

   Penyelesaian operasi ini mungkin memerlukan waktu beberapa menit.

Checkpoint: Memvalidasi penyiapan Anda

1. Pastikan semua Pod Bank of Anthos sedang berjalan:

   kubectl get pods
   

   Outputnya mirip dengan hal berikut ini:

   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. Periksa apakah Anda dapat mengakses frontend situs:

   1. Dapatkan alamat IP eksternal layanan frontend:

      kubectl get ingress frontend
      

      Outputnya mirip dengan hal berikut ini:

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

   2. Di browser, buka alamat IP eksternal. Halaman login Bank of Anthos akan ditampilkan. Jika Anda penasaran, pelajari aplikasi ini.

      Jika Anda menerima error 404, tunggu beberapa menit sampai microservice akan disediakan, lalu coba lagi.

Melakukan penskalaan otomatis pada aplikasi web dan database PostgreSQL

GKE Autopilot menskalakan resource komputasi cluster secara otomatis berdasarkan jumlah workload dalam cluster. Untuk menskalakan jumlah Pod dalam cluster secara otomatis berdasarkan metrik resource, Anda harus menerapkan Penskalaan otomatis Pod horizontal Kubernetes. Anda dapat menggunakan metrik memori dan CPU Kubernetes bawaan atau Anda dapat menggunakan metrik kustom seperti permintaan HTTP per detik atau jumlah pernyataan SELECT, yang diambil dari Cloud Monitoring.

Di bagian ini, Anda akan melakukan hal berikut:

1. Mengonfigurasi penskalaan otomatis Pod horizontal untuk microservice Bank of Anthos menggunakan metrik bawaan dan metrik kustom.
2. Menyimulasikan pemuatan ke aplikasi Bank of Anthos untuk memicu peristiwa penskalaan otomatis.
3. Mengamati bagaimana jumlah Pod dan node di cluster Anda secara otomatis meningkatkan dan menurunkan skala sebagai respons terhadap beban Anda.

Menyiapkan pengumpulan metrik kustom

Untuk membaca metrik kustom dari Monitoring, Anda harus men-deploy adaptor Custom Metrics - Stackdriver Adapter di cluster Anda.

1. Deploy adaptor:

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

2. Konfigurasikan adaptor untuk menggunakan Workload Identity Federation for GKE guna mendapatkan metrik:

   1. Konfigurasikan akun layanan 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. Anotasikan akun layanan Kubernetes yang digunakan adaptor:

      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. Mulai ulang Deployment adaptor untuk menerapkan perubahan:

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

Mengonfigurasi penskalaan otomatis untuk database

Saat men-deploy Bank of Anthos dan PostgreSQL sebelumnya dalam tutorial ini, Anda telah men-deploy database sebagai StatefulSet dengan satu replika baca/tulis utama untuk menangani semua pernyataan SQL yang masuk. Di bagian ini, Anda akan mengonfigurasi penskalaan otomatis Pod horizontal untuk menambahkan replika hanya baca standby baru untuk menangani pernyataan SELECT yang masuk. Cara yang baik untuk mengurangi beban pada setiap replika adalah dengan mendistribusikan pernyataan SELECT, yaitu operasi baca. Deployment PostgreSQL menyertakan alat bernama Pgpool-II yang mencapai load balancing ini dan meningkatkan throughput sistem.

PostgreSQL mengekspor metrik pernyataan SELECT sebagai metrik Prometheus. Anda akan menggunakan pengekspor metrik ringan bernama prometheus-to-sd untuk mengirim metrik ini ke Cloud Monitoring dalam format yang didukung.

1. Tinjau objek 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"
   

   Manifes ini melakukan hal berikut:

   • Menetapkan jumlah maksimum replika selama peningkatan skala hingga 5.
   • Menetapkan jumlah minimum selama penurunan skala ke 1.
   • Menggunakan metrik eksternal untuk membuat keputusan penskalaan. Dalam contoh ini, metrik adalah jumlah pernyataan SELECT. Peristiwa peningkatan skala terjadi jika jumlah pernyataan SELECT yang masuk melebihi 15.

2. Terapkan manifes ke cluster:

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

Mengonfigurasi penskalaan otomatis untuk antarmuka web

Di bagian Men-deploy Bank of Anthos dan PostgreSQL, Anda men-deploy antarmuka web Bank of Anthos. Saat jumlah pengguna meningkat, Service userservice akan menggunakan lebih banyak resource CPU. Di bagian ini, Anda akan mengonfigurasi penskalaan otomatis Pod horizontal untuk Deployment userservice saat Pod yang ada menggunakan lebih dari 60% CPU yang diminta, dan untuk Deployment frontend saat angkanya permintaan HTTP yang masuk ke load balancer lebih dari 5 per detik.

Mengonfigurasi penskalaan otomatis untuk Deployment userservice

1. Tinjau manifes HorizontalPodAutoscaler untuk 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
   

   Manifes ini melakukan hal berikut:

   • Menetapkan jumlah maksimum replika selama peningkatan skala hingga 50.
   • Menetapkan jumlah minimum selama penurunan skala ke 5.
   • Menggunakan metrik Kubernetes bawaan untuk membuat keputusan penskalaan. Dalam contoh ini, metriknya adalah pemakaian CPU, dan target pemanfaatannya adalah 60%, yang menghindari penggunaan yang berlebihan atau kurang.

2. Terapkan manifes ke cluster:

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

Mengonfigurasi penskalaan otomatis untuk deployment frontend

1. Tinjau manifes HorizontalPodAutoscaler untuk 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"
   

   Manifes ini menggunakan kolom berikut:

   • spec.scaleTargetRef: Resource Kubernetes yang akan diskalakan.
   • spec.minReplicas: Jumlah minimum replika, yaitu 5 dalam contoh ini.
   • spec.maxReplicas: Jumlah maksimum replika, yaitu 25 dalam contoh ini.
   • spec.metrics.*: Metrik yang akan digunakan. Dalam contoh ini, ini adalah jumlah permintaan HTTP per detik, yang merupakan metrik kustom dari Cloud Monitoring yang disediakan oleh adaptor yang Anda deploy.
   • spec.metrics.external.metric.selector.matchLabels: Label resource tertentu yang akan difilter saat penskalaan otomatis.

2. Temukan nama aturan penerusan dari load balancer ke Deployment frontend:

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

   Outputnya mirip dengan hal berikut ini:

   k8s2-fr-j76hrtv4-default-frontend-wvvf7381
   

3. Tambahkan aturan penerusan Anda ke manifes:

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

   Perintah ini menggantikan FORWARDING_RULE_NAME dengan aturan penerusan yang Anda simpan.

4. Terapkan manifes ke cluster:

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

Checkpoint: Memvalidasi penyiapan penskalaan otomatis

Dapatkan status resource HorizontalPodAutoscaler Anda:

kubectl get hpa

Outputnya mirip dengan hal berikut ini:

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

Pada tahap ini, Anda telah menyiapkan aplikasi dan mengonfigurasi penskalaan otomatis. Frontend dan database Anda kini dapat melakukan penskalaan berdasarkan metrik yang Anda berikan.

Menyimulasikan pemuatan dan mengamati penskalaan GKE

Bank of Anthos menyertakan Layanan loadgenerator yang memungkinkan Anda menyimulasikan traffic untuk menguji penskalaan aplikasi di bawah beban. Di bagian ini, Anda akan men-deploy Layanan loadgenerator, membuat beban, dan mengamati penskalaan yang dihasilkan.

Men-deploy generator pengujian beban

1. Buat variabel lingkungan dengan alamat IP load balancer Bank of Anthos:

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

   Outputnya mirip dengan hal berikut ini:

   203.0.113.9
   

2. Tambahkan alamat IP load balancer ke manifes:

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

3. Terapkan manifes ke cluster:

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

Generator beban mulai menambahkan satu pengguna setiap detik, hingga 250 pengguna.

Menyimulasikan beban

Di bagian ini, Anda akan menggunakan generator beban untuk menyimulasikan lonjakan traffic dan mengamati jumlah replika serta peningkatan jumlah node untuk mengakomodasi peningkatan beban dari waktu ke waktu. Kemudian, mengakhiri pengujian dan mengamati penurunan jumlah replika dan node sebagai respons.

1. Ekspos antarmuka web generator beban secara lokal:

   kubectl port-forward svc/loadgenerator 8080
   

   Jika Anda melihat pesan error, coba lagi saat Pod berjalan.

2. Di browser, buka antarmuka web generator beban.

   • Jika Anda menggunakan shell lokal, buka browser, lalu buka http://127.0.0.1:8080.
   • Jika Anda menggunakan Cloud Shell, klik Web preview, lalu klik Preview on port 8080.

3. Klik tab Diagram untuk mengamati performa dari waktu ke waktu.

4. Buka jendela terminal baru dan lihat jumlah replika autoscaler Pod horizontal Anda:

   kubectl get hpa -w
   

   Jumlah replika meningkat seiring dengan bertambahnya beban. Peningkatan skala mungkin memakan waktu sekitar sepuluh menit.

   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. Buka jendela terminal lain dan periksa jumlah node dalam cluster:

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

6. Jumlah node ditingkatkan dari jumlah awal tiga node untuk mengakomodasi replika baru.

7. Buka antarmuka generator beban, lalu klik Stop untuk mengakhiri pengujian.

8. Periksa lagi jumlah replika dan jumlah node, lalu amati apakah jumlahnya berkurang dengan berkurangnya beban. Penurunan skala mungkin memerlukan waktu karena periode stabilisasi default untuk replika di resource HorizontalPodAutoscaler Kubernetes adalah lima menit. Untuk mengetahui informasi selengkapnya, lihat Jendela stabilisasi.

Pembersihan

Agar tidak perlu membayar biaya pada akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus project yang berisi resource tersebut, atau simpan project dan hapus setiap resource.

Menghapus resource satu per satu

Google Cloud membuat resource, seperti load balancer, berdasarkan objek Kubernetes yang Anda buat. Untuk menghapus semua resource dalam tutorial ini, lakukan langkah berikut:

1. Hapus contoh resource Kubernetes:

   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. Hapus database PostgreSQL:

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

3. Hapus cluster GKE dan akun layanan IAM:

   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
   

Menghapus project

Perhatian: Menghapus project memiliki efek berikut:

• Semua hal dalam project akan dihapus. Jika menggunakan project yang sudah ada untuk tugas dalam dokumen ini, saat Anda menghapusnya, pekerjaan lain yang telah Anda lakukan dalam project tersebut juga akan terhapus.
• Project ID kustom hilang. Saat membuat project ini, Anda mungkin telah membuat project ID kustom yang ingin digunakan di masa mendatang. Untuk mempertahankan URL yang menggunakan project ID, seperti URL appspot.com, hapus resource yang dipilih di dalam project, bukan menghapus seluruh project.

Jika Anda berencana mempelajari beberapa arsitektur, tutorial atau panduan memulai, dengan menggunakan kembali project dapat membantu Anda agar tidak melampaui batas kuota project.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Langkah berikutnya

• Pelajari penskalaan Pod vertikal, yang dapat Anda gunakan untuk menyesuaikan permintaan resource secara otomatis untuk workload yang berjalan lama dengan rekomendasi yang didasarkan pada penggunaan historis.
• Pelajari lebih lanjut penskalaan otomatis Pod horizontal.