Halaman ini diterjemahkan oleh Cloud Translation API.

Jalur Pembelajaran: Aplikasi yang skalabel - Penskalaan

Kumpulan tutorial ini ditujukan untuk administrator IT dan Operator yang ingin untuk men-deploy, menjalankan, dan mengelola lingkungan aplikasi modern yang berjalan Edisi Google Kubernetes Engine (GKE) Enterprise. Saat Anda terus mempelajari rangkaian tutorial ini, Anda akan belajar cara mengonfigurasi pemantauan dan pemberitahuan, menskalakan workload, dan melakukan simulasi kegagalan, semuanya menggunakan aplikasi microservice contoh Cymbal Bank:

Membuat cluster dan men-deploy aplikasi contoh
Memantau dengan Google Cloud Managed Service for Prometheus
Menskalakan workload (tutorial ini)
Menyimulasikan kegagalan
Pusatkan manajemen perubahan

Ringkasan dan tujuan

Aplikasi konsumen seperti Cymbal Bank sering kali memiliki berbagai jumlah pengguna di waktu yang berbeda. Idealnya, situs web Anda mampu mengatasi lonjakan traffic tanpa melambat atau memiliki masalah lain, tapi tanpa organisasi memiliki untuk menghabiskan uang pada resource {i>Cloud<i} yang sebenarnya tidak mereka butuhkan. Solusi yang yang disediakan Google Cloud untuk ini adalah penskalaan otomatis.

Dalam tutorial ini, Anda akan mempelajari cara mengonfigurasi cluster dan workload secara Cluster GKE yang akan diskalakan menggunakan kedua metrik Kubernetes bawaan dan metrik kustom dari Cloud Monitoring dan Cloud Trace. Anda akan mempelajari cara menyelesaikan tugas berikut:

Mengaktifkan metrik kustom di Cloud Monitoring for Trace.
- Metrik kustom memungkinkan Anda melakukan penskalaan menggunakan data pemantauan tambahan atau input eksternal di luar awareness cluster Kubernetes, seperti lalu lintas jaringan atau kode respons HTTP.
Mengonfigurasi Horizontal Pod Autoscaler, fitur GKE yang dapat meningkatkan atau mengurangi jumlah Pod secara otomatis untuk suatu workload bergantung pada metrik yang ditentukan.
Menyimulasikan pemuatan aplikasi dan melihat autoscaler cluster dan Pod Horizontal Autoscaler merespons.

Biaya

Mengaktifkan GKE Enterprise dan men-deploy contoh Cymbal Bank untuk rangkaian tutorial ini berarti Anda mengeluarkan biaya per-cluster biaya untuk GKE Enterprise di Google Cloud seperti yang tercantum dalam Halaman harga hingga Anda menonaktifkan GKE Enterprise atau menghapus project.

Anda juga bertanggung jawab atas biaya Google Cloud lainnya yang timbul saat menjalankan Contoh aplikasi Cymbal Bank, seperti biaya untuk VM Compute Engine dan Me-La-Cak.

Sebelum memulai

Untuk mempelajari cara menskalakan deployment, Anda harus menyelesaikan tutorial pertama untuk membuat cluster GKE yang menggunakan Autopilot dan men-deploy contoh aplikasi berbasis microservice contoh Cymbal Bank.

Sebaiknya Anda menyelesaikan rangkaian tutorial ini secara berurutan untuk Cymbal Bank. Saat Anda terus mempelajari serangkaian tutorial, Anda mempelajari keterampilan baru dan menggunakan produk dan layanan Google Cloud tambahan.

Anda juga perlu membuat akun layanan IAM dan memberikan beberapa yang memungkinkan Horizontal Pod Autoscaler berfungsi dengan benar:

Buat akun layanan IAM. Akun layanan ini digunakan di tutorial untuk memberikan akses ke metrik kustom yang mengizinkan Autoscaler Pod untuk menentukan kapan harus meningkatkan atau menurunkan skala:
```
gcloud iam service-accounts create scalable-apps
```

Berikan akses ke akun layanan IAM untuk melakukan tindakan penskalaan yang diperlukan:

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

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

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

Akses berikut diberikan ke akun layanan IAM:

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 untuk GKE untuk bertindak sebagai layanan IAM menggunakan akun layanan.

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=scalable-apps@PROJECT_ID.
```
Konfigurasi ini mengizinkan Pod yang menggunakan layanan Kubernetes default akun di namespace default untuk mengakses resource Google Cloud yang sama resource seperti akun layanan IAM.

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.

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
```
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
```

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

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

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.

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.

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

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.

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

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.

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.

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

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.
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 Web preview, lalu klik Preview on port 8080.
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.
Di antarmuka web generator pemuatan, klik tab Charts untuk mengamati performa dari waktu ke waktu. Melihat jumlah permintaan dan resource tingkat penggunaan.
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
```
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.
Buka antarmuka generator beban, lalu klik Stop untuk mengakhiri pengujian.
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.

Pembersihan

Kumpulan tutorial untuk Cymbal Bank dirancang untuk diselesaikan satu setelah lainnya. Saat Anda terus mempelajari rangkaian tutorial, Anda belajar keterampilan baru dan menggunakan produk dan layanan Google Cloud tambahan.

Jika Anda ingin istirahat sebelum melanjutkan ke tutorial berikutnya dan menghindari menimbulkan biaya ke akun Google Cloud Anda untuk resource yang digunakan dalam menghapus project yang Anda buat.

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 berbagai arsitektur, tutorial, atau panduan memulai, menggunakan kembali project dapat membantu agar Anda tidak melampaui batas kuota project.

Di konsol Google Cloud, buka halaman Manage resource.
Buka Manage resource
Pada daftar project, pilih project yang ingin Anda hapus, lalu klik Delete.
Pada dialog, ketik project ID, lalu klik Shut down untuk menghapus project.

Langkah selanjutnya

Pelajari cara menyimulasikan kegagalan di GKE Enterprise di tutorial berikutnya.