Jalur Pembelajaran: Aplikasi yang skalabel - Penskalaan

Menyiapkan pengumpulan metrik kustom

Anda dapat mengonfigurasi Horizontal Pod Autoscaler untuk menggunakan Kubernetes bawaan dasar metrik CPU dan memori, atau Anda dapat menggunakan metrik kustom dari Cloud Monitoring seperti HTTP permintaan per detik atau jumlah pernyataan SELECT. Metrik kustom dapat bekerja tanpa perubahan aplikasi, dan memberi cluster Anda lebih banyak insight tentang keseluruhan performa dan kebutuhan aplikasi. Di tutorial ini, Anda akan mempelajari cara menggunakan metrik bawaan dan kustom.

1. Untuk memungkinkan Autoscaler Pod Horizontal membaca metrik kustom dari Monitoring, Anda harus menginstal Metrik Kustom - Adaptor Stackdriver adaptor di cluster Anda.

   Deploy metrik kustom adaptor Stackdriver ke cluster Anda:

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

2. Untuk mengizinkan adaptor Stackdriver mendapatkan metrik kustom dari cluster Anda, Anda menggunakan Workload Identity Federation untuk GKE. Pendekatan ini menggunakan IAM akun layanan yang memiliki izin untuk membaca metrik pemantauan.

   Memberikan roles/monitoring.viewer ke akun layanan IAM peran:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member "serviceAccount:scalable-apps@PROJECT_ID." \
       --role roles/monitoring.viewer
   

3. Konfigurasikan adaptor Stackdriver untuk menggunakan Workload Identity Federation untuk GKE dan akun layanan IAM yang memiliki izin untuk membaca metrik pemantauan:

   gcloud iam service-accounts add-iam-policy-binding scalable-apps@PROJECT_ID. \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
   

4. Kubernetes menyertakan sistemnya sendiri untuk akun layanan agar dapat diakses dari dalam . Untuk mengizinkan aplikasi Anda melakukan autentikasi ke layanan dan resource di luar cluster edisi Google Kubernetes Engine (GKE) Enterprise, seperti Monitoring, Anda menggunakan Workload Identity Federation untuk GKE. Pendekatan ini mengonfigurasi akun layanan Kubernetes untuk menggunakan IAM akun layanan untuk GKE.

   Anotasikan akun layanan Kubernetes yang digunakan adaptor:

   kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
       --namespace=custom-metrics \
       iam.gke.io/gcp-service-account=scalable-apps@PROJECT_ID.
   

5. Mulai ulang Deployment adaptor Stackdriver untuk menerapkan perubahan:

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

Mengonfigurasi Autoscaler Pod Horizontal

Autopilot GKE dapat melakukan penskalaan dengan beberapa cara berbeda. Di sini Anda akan melihat cara penskalaan cluster menggunakan metode berikut:

• Autoscaler Pod Horizontal: menskalakan jumlah Pod untuk workload.
• Penskalaan otomatis cluster: menskalakan resource node yang tersedia di .

Kedua metode ini dapat digunakan bersama-sama sehingga jumlah Pod untuk perubahan aplikasi, resource node untuk mendukung Pod tersebut juga akan berubah.

Implementasi lainnya tersedia untuk menskalakan Pod yang dibangun di atas Autoscaler Pod Horizontal, dan Anda juga bisa menggunakan Autoscaler Pod Vertikal untuk menyesuaikan permintaan CPU dan memori Pod, bukan jumlah Pod.

Dalam tutorial ini, Anda akan mengonfigurasi Horizontal Pod Autoscaler untuk Deployment userservice menggunakan metrik bawaan, dan untuk frontend Deployment menggunakan metrik kustom.

Untuk aplikasi Anda sendiri, bekerja samalah dengan pengembang Aplikasi dan Engineer platform untuk memahami kebutuhan mereka dan mengonfigurasi Aturan Autoscaler Pod.

Menskalakan Deployment userservice

Ketika jumlah pengguna aplikasi contoh Cymbal Bank meningkat, Layanan userservice menggunakan lebih banyak resource CPU. Anda menggunakan Objek HorizontalPodAutoscaler untuk mengontrol cara yang Anda inginkan untuk aplikasi merespons beban. Dalam manifes YAML untuk HorizontalPodAutoscaler, Anda menentukan Deployment mana yang perlu diskalakan oleh Autoscaler Pod Horizontal, metrik yang dipantau, serta jumlah minimum dan maksimum replika akan dijalankan.

1. Tinjau contoh manifes HorizontalPodAutoscaler untuk userservice Penyebaran:

   # 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
   

Menskalakan Deployment frontend

Di bagian sebelumnya, Anda telah mengonfigurasi Horizontal Pod Autoscaler di Deployment userservice berdasarkan metrik Kubernetes bawaan untuk CPU tingkat penggunaan. Untuk Deployment frontend, sebaiknya lakukan penskalaan berdasarkan jumlah permintaan HTTP yang masuk. Pendekatan ini menggunakan Adaptor Stackdriver untuk membaca metrik kustom dari Monitoring untuk objek Load Balancer Ingress HTTP(S).

1. Tinjau manifes HorizontalPodAutoscaler untuk Deployment frontend:

   # 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 Pemantauan yang disediakan oleh adaptor yang Anda deploy.
   • spec.metrics.external.metric.selector.matchLabels: Atribut label resource yang akan difilter saat penskalaan.

2. Menemukan nama aturan penerusan dari beban Ingress frontend penyeimbang:

   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
   

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. Anda kemudian dapat berhenti menghasilkan traffic dan mengamati replika dan jumlah node turun sebagai respons.

1. Sebelum memulai, periksa status Horizontal Pod Autoscaler dan melihat jumlah replika yang digunakan.

   Dapatkan status resource HorizontalPodAutoscaler Anda:

   kubectl get hpa
   

   Outputnya mirip dengan yang berikut ini yang menunjukkan bahwa ada 1 frontend dan 5 replika userservice:

   NAME                     REFERENCE                            TARGETS             MINPODS   MAXPODS   REPLICAS   AGE
   frontend                 Deployment/frontend                  <unknown>/5 (avg)   5         25        1          34s
   userservice              Deployment/userservice               0%/60%              5         50        5          4m56s
   

2. Aplikasi contoh Cymbal Bank mencakup Layanan loadgenerator. Ini Layanan terus mengirimkan permintaan yang meniru pengguna ke frontend, dan membuat akun baru secara berkala dan menyimulasikan transaksi di antara akun tersebut.

   Mengekspos antarmuka web loadgenerator secara lokal. Anda menggunakan antarmuka ini untuk melakukan simulasi beban pada aplikasi contoh Cymbal Bank:

   kubectl port-forward svc/loadgenerator 8080
   

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

3. Pada browser di komputer Anda, buka antarmuka web load generator:

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

4. Di antarmuka web generator beban, jika nilai Failures menampilkan 100%, selesaikan langkah-langkah berikut untuk memperbarui setelan pengujian:

   1. Klik tombol Stop di samping penghitung tingkat kegagalan.
   2. Di bagian Status, klik opsi untuk Pengujian baru.
   3. Perbarui nilai Host ke alamat IP traffic masuk Cymbal Bank Anda.
   4. Klik Start swarming.

5. Di antarmuka web generator pemuatan, klik tab Charts untuk mengamati performa dari waktu ke waktu. Melihat jumlah permintaan dan resource tingkat penggunaan.

6. Buka jendela terminal baru dan lihat jumlah replika frontend Anda dan userservice Pod:

   kubectl get hpa -w
   

   Jumlah replika meningkat seiring dengan bertambahnya beban. Tindakan scaleUp mungkin memakan waktu sekitar sepuluh menit karena klaster menyadari bahwa metrik yang dikonfigurasi mencapai batas yang ditentukan, dan menggunakan Pod Horizontal Autoscaler untuk meningkatkan jumlah Pod.

   Contoh output berikut menunjukkan jumlah replika yang telah bertambah saat generator beban berjalan:

   NAME                     REFERENCE                            TARGETS          MINPODS   MAXPODS   REPLICAS
   frontend                 Deployment/frontend                  5200m/5 (avg)    5         25        13
   userservice              Deployment/userservice               71%/60%          5         50        17
   

7. Buka jendela terminal lain dan periksa jumlah node dalam cluster:

   gcloud container clusters list \
       --filter='name=scalable-apps' \
       --format='table(name, currentMasterVersion, currentNodeVersion, currentNodeCount)' \
       --region="REGION"
   

   Ganti REGION dengan region yang dijalankan cluster Anda inc.

   Jumlah {i>node<i} juga telah meningkat dari jumlah awal ke untuk mengakomodasi replika baru. Peningkatan jumlah {i>node<i} ini didukung oleh GKE Autopilot. Tidak ada yang Anda perlukan untuk dikonfigurasi pada skala node ini.

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

9. 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.

Di lingkungan nyata, jumlah node dan Pod di lingkungan Anda otomatis akan menaikkan dan menurunkan skala dengan cara yang sama seperti simulasi memuat halaman. Aplikasi contoh Cymbal Bank dirancang untuk mengakomodasi penskalaan. Hubungi operator Aplikasi dan Site Reliability Engineering (SRE) Anda atau Developer aplikasi untuk melihat apakah workload mereka dapat memperoleh manfaat dari ini fitur penskalaan.