Halaman ini diterjemahkan oleh Cloud Translation API.

Jalur Pembelajaran: Aplikasi yang skalabel - Penskalaan

Kumpulan tutorial ini ditujukan untuk admin dan Operator IT yang ingin men-deploy, menjalankan, dan mengelola lingkungan aplikasi modern yang berjalan di edisi Google Kubernetes Engine (GKE) Enterprise. Selama mempelajari serangkaian tutorial ini, Anda akan mempelajari cara mengonfigurasi pemantauan dan pemberitahuan, menskalakan workload, dan menyimulasikan 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

Ringkasan dan tujuan

Aplikasi konsumen seperti Cymbal Bank sering kali memiliki jumlah pengguna yang berbeda-beda pada waktu yang berbeda. Idealnya, situs Anda mampu mengatasi lonjakan traffic tanpa memperlambat atau mengalami masalah lain, tetapi organisasi tidak harus mengeluarkan uang untuk resource Cloud yang sebenarnya tidak mereka butuhkan. Solusi yang disediakan Google Cloud untuk hal ini adalah penskalaan otomatis.

Dalam tutorial ini, Anda akan mempelajari cara mengonfigurasi cluster dan beban kerja di cluster GKE untuk melakukan penskalaan menggunakan metrik Kubernetes bawaan dan metrik kustom dari Cloud Monitoring dan Cloud Trace. Anda akan mempelajari cara menyelesaikan tugas-tugas berikut:

Mengaktifkan metrik kustom di Cloud Monitoring untuk Trace.
- Dengan metrik kustom, Anda dapat melakukan penskalaan menggunakan data pemantauan tambahan atau input eksternal di luar kemampuan cluster Kubernetes, seperti traffic jaringan atau kode respons HTTP.
Konfigurasi Autoscaler Pod Horizontal, yakni fitur GKE yang dapat otomatis meningkatkan atau mengurangi jumlah Pod untuk suatu workload, bergantung pada metrik yang ditentukan.
Menyimulasikan beban aplikasi dan melihat penskalaan otomatis cluster dan respons Autoscaler Pod Horizontal.

Biaya

Dengan mengaktifkan GKE Enterprise dan men-deploy aplikasi contoh Cymbal Bank untuk rangkaian tutorial ini, Anda akan dikenai biaya per cluster untuk GKE Enterprise di Google Cloud seperti yang tercantum di halaman Harga hingga Anda menonaktifkan GKE Enterprise atau menghapus project.

Anda juga bertanggung jawab atas biaya Google Cloud lainnya yang timbul saat menjalankan aplikasi contoh Cymbal Bank, seperti biaya untuk VM dan Trace Compute Engine.

Sebelum memulai

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

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

Anda juga perlu membuat akun layanan IAM dan memberikan beberapa izin agar Autoscaler Pod Horizontal dapat berfungsi dengan benar:

Membuat akun layanan IAM. Akun layanan ini digunakan dalam tutorial untuk memberikan akses ke metrik kustom yang memungkinkan Autoscaler Pod Horizontal dapat 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.iam.gserviceaccount.com"

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

gcloud iam service-accounts add-iam-policy-binding "scalable-apps@PROJECT_ID.iam.gserviceaccount.com" \
  --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 agar berfungsi sebagai akun layanan IAM.

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.iam.gserviceaccount.com
```
Dengan konfigurasi ini, Pod yang menggunakan akun layanan Kubernetes default dapat mengakses resource Google Cloud yang sama dengan akun layanan IAM dalam namespace default.

Menyiapkan pengumpulan metrik kustom

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

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

Deploy adaptor Stackdriver metrik kustom ke cluster Anda:
```
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter.yaml
```
Agar adaptor Stackdriver dapat mendapatkan metrik kustom dari cluster Anda, gunakan Workload Identity. Pendekatan ini menggunakan akun layanan IAM yang memiliki izin untuk membaca metrik pemantauan.

Berikan peran roles/monitoring.viewer kepada akun layanan IAM:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:scalable-apps@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
```

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

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

Kubernetes menyertakan sistemnya sendiri untuk akun layanan untuk akses dalam cluster. 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. Pendekatan ini mengonfigurasi akun layanan Kubernetes agar menggunakan akun layanan IAM 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.iam.gserviceaccount.com
```

Mulai ulang Deployment adaptor Stackdriver untuk menerapkan perubahan:

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

Mengonfigurasi Autoscaler Pod Horizontal

GKE Autopilot dapat melakukan penskalaan dalam beberapa cara. Dalam tutorial ini, Anda akan melihat cara cluster Anda dapat menskalakan menggunakan metode berikut:

Autoscaler Pod Horizontal: menskalakan jumlah Pod untuk beban kerja.
Autoscaler cluster: menskalakan resource node yang tersedia di cluster.

Kedua metode ini dapat bekerja sama sehingga jumlah Pod untuk aplikasi Anda berubah, resource node untuk mendukung Pod tersebut juga berubah.

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

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

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

Menskalakan Deployment `userservice`

Saat jumlah pengguna aplikasi contoh Cymbal Bank meningkat, Layanan userservice akan menggunakan lebih banyak resource CPU. Anda menggunakan objek HorizontalPodAutoscaler untuk mengontrol cara aplikasi merespons pemuatan. Dalam manifes YAML untuk HorizontalPodAutoscaler, Anda menentukan Deployment yang akan digunakan oleh Autoscaler Pod Horizontal yang akan diskalakan, metrik apa yang harus dipantau, serta jumlah replika minimum dan maksimum yang ingin dijalankan.

Tinjau contoh 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.

Terapkan manifes ke cluster:

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

Menskalakan Deployment `frontend`

Di bagian sebelumnya, Anda telah mengonfigurasi Autoscaler Pod Horizontal pada Deployment userservice berdasarkan metrik Kubernetes bawaan untuk pemanfaatan CPU. Untuk Deployment frontend, sebaiknya Anda melakukan penskalaan berdasarkan jumlah permintaan HTTP yang masuk. Pendekatan ini menggunakan adaptor Stackdriver untuk membaca metrik kustom dari Monitoring untuk objek Ingress Load Balancer 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 Monitoring yang disediakan oleh adaptor yang Anda deploy.
spec.metrics.external.metric.selector.matchLabels: Label resource spesifik yang akan difilter saat melakukan penskalaan.

Temukan nama aturan penerusan dari load balancer Ingress 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

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. Selanjutnya, Anda dapat berhenti menghasilkan traffic serta mengamati penurunan skala replika dan jumlah node sebagai respons.

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

Dapatkan status resource HorizontalPodAutoscaler Anda:

kubectl get hpa

Outputnya mirip dengan yang berikut ini yang menunjukkan ada 1 replika 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. Layanan ini terus mengirimkan permintaan yang meniru pengguna ke frontend, serta membuat akun baru secara berkala dan menyimulasikan transaksi di antara akun tersebut.

Mengekspos antarmuka web loadgenerator secara lokal. Anda menggunakan antarmuka ini untuk menyimulasikan beban pada aplikasi contoh Cymbal Bank:
```
kubectl port-forward svc/loadgenerator 8080
```
Jika Anda melihat pesan error, coba lagi saat Pod berjalan.
Di browser di komputer, 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.
Di antarmuka web generator pemuatan, 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 masuknya Cymbal Bank Anda.
4. Klik Mulai swarming.
Di antarmuka web generator pemuatan, klik tab Diagram untuk mengamati performa dari waktu ke waktu. Lihat jumlah permintaan dan pemanfaatan resource.
Buka jendela terminal baru dan lihat jumlah replika Pod frontend dan userservice:
```
kubectl get hpa -w
```
Jumlah replika meningkat seiring dengan bertambahnya beban. Tindakan scaleUp mungkin memerlukan waktu sekitar sepuluh menit karena cluster menyadari bahwa metrik yang dikonfigurasi mencapai batas yang ditentukan, dan menggunakan Horizontal Pod Autoscaler untuk meningkatkan jumlah Pod.

Contoh output berikut menunjukkan jumlah replika yang telah meningkat seiring 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 tempat cluster Anda berjalan.

Jumlah node juga telah meningkat dari jumlah awal untuk mengakomodasi replika baru. Peningkatan jumlah node ini didukung oleh GKE Autopilot. Anda tidak perlu mengonfigurasi 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.

Dalam lingkungan nyata, jumlah node dan Pod di lingkungan Anda akan otomatis ditingkatkan dan diturunkan dengan cara yang sama seperti simulasi beban ini. Aplikasi contoh Cymbal Bank dirancang untuk mengakomodasi penskalaan semacam ini. Hubungi operator Aplikasi dan Site Reliability Engineering (SRE) atau Developer aplikasi Anda untuk mengetahui apakah beban kerja mereka dapat memperoleh manfaat dari fitur penskalaan ini.

Pembersihan

Kumpulan tutorial untuk Cymbal Bank dirancang untuk diselesaikan satu per satu. Seiring progres Anda dalam mengikuti serangkaian tutorial, Anda akan mempelajari keterampilan baru dan menggunakan produk serta layanan Google Cloud tambahan.

Jika ingin berhenti sejenak sebelum melanjutkan ke tutorial berikutnya dan agar tidak menimbulkan tagihan ke akun Google Cloud Anda untuk resource yang digunakan dalam tutorial ini, hapus 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 dalam tutorial berikutnya.