Halaman ini diterjemahkan oleh Cloud Translation API.

Jalur Pembelajaran: Aplikasi skalabel - Penskalaan

Rangkaian tutorial ini ditujukan untuk Operator dan administrator IT yang ingin men-deploy, menjalankan, dan mengelola lingkungan aplikasi modern yang berjalan di edisi Google Kubernetes Engine (GKE) Enterprise. Seiring Anda melanjutkan rangkaian tutorial ini, Anda akan mempelajari cara mengonfigurasi pemantauan dan pemberitahuan, menskalakan beban kerja, dan menyimulasikan kegagalan, semuanya menggunakan aplikasi contoh microservice Cymbal Bank:

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

Ringkasan dan tujuan

Aplikasi konsumen seperti Cymbal Bank sering kali memiliki jumlah pengguna yang bervariasi pada waktu yang berbeda. Idealnya, situs Anda dapat mengatasi lonjakan traffic tanpa memperlambat atau mengalami masalah lain, tetapi tanpa organisasi harus menghabiskan 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 diskalakan 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.
- Metrik kustom memungkinkan Anda menskalakan menggunakan data pemantauan tambahan atau input eksternal di luar kesadaran cluster Kubernetes, seperti traffic jaringan atau kode respons HTTP.
Konfigurasikan Horizontal Pod Autoscaler, fitur GKE yang dapat otomatis meningkatkan atau menurunkan jumlah Pod untuk workload bergantung pada metrik yang ditentukan.
Simulasikan beban aplikasi dan lihat respons autoscaler cluster dan Horizontal Pod Autoscaler.

Biaya

Mengaktifkan GKE Enterprise dan men-deploy aplikasi contoh Cymbal Bank untuk rangkaian tutorial ini berarti Anda akan dikenai biaya per cluster untuk GKE Enterprise di Google Cloud seperti yang tercantum di halaman Harga kami 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 tagihan untuk VM Compute Engine dan Trace.

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 selesaikan rangkaian tutorial ini untuk Cymbal Bank secara berurutan. Seiring Anda menyelesaikan serangkaian tutorial, Anda akan mempelajari keterampilan baru dan menggunakan produk dan layanan Google Cloud tambahan.

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

Buat akun layanan IAM. Akun layanan ini digunakan dalam tutorial untuk memberikan akses ke metrik kustom yang memungkinkan Horizontal Pod Autoscaler menentukan kapan harus menskalakan ke atas atau ke bawah:
```
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 for GKE 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.
```
Konfigurasi ini memungkinkan Pod yang menggunakan akun layanan Kubernetes default di namespace default untuk mengakses resource Google Cloud yang sama dengan akun layanan IAM.

Menyiapkan pengumpulan metrik kustom

Anda dapat mengonfigurasi Horizontal Pod Autoscaler untuk menggunakan metrik CPU dan memori Kubernetes bawaan 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 kustom.

Agar Horizontal Pod Autoscaler dapat membaca metrik kustom dari Monitoring, Anda harus menginstal adaptor Custom Metrics - Stackdriver Adapter di cluster Anda.

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 harus menggunakan Workload Identity Federation untuk GKE. 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." \
    --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 guna mendapatkan akses dalam cluster. Agar aplikasi Anda dapat melakukan autentikasi ke layanan dan resource di luar cluster edisi Enterprise Google Kubernetes Engine (GKE), seperti Monitoring, Anda harus menggunakan Workload Identity Federation untuk GKE. Pendekatan ini mengonfigurasi akun layanan Kubernetes untuk 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.
```

Mulai ulang Deployment adaptor Stackdriver untuk menerapkan perubahan:

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

Mengonfigurasi Horizontal Pod Autoscaler

GKE Autopilot dapat diskalakan dengan beberapa cara. Dalam tutorial ini, Anda akan melihat cara cluster Anda dapat diskalakan menggunakan metode berikut:

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

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

Implementasi lain tersedia untuk menskalakan Pod yang dibuat di atas Horizontal Pod Autoscaler, dan Anda juga dapat menggunakan Vertical Pod Autoscaler 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 Deployment frontend menggunakan metrik kustom.

Untuk aplikasi Anda sendiri, bekerja samalah dengan developer Aplikasi dan engineer Platform untuk memahami kebutuhan mereka dan mengonfigurasi aturan Penskalaan Otomatis Pod Horizontal.

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 Anda merespons pemuatan. Dalam manifes YAML untuk HorizontalPodAutoscaler, Anda menentukan Deployment yang akan diskalakan oleh Horizontal Pod Autoscaler, metrik yang akan dipantau, dan jumlah minimum dan maksimum replika yang ingin Anda jalankan.

Tinjau manifes contoh 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 Horizontal Pod Autoscaler di Deployment userservice berdasarkan metrik Kubernetes bawaan untuk penggunaan CPU. Untuk Deployment frontend, sebaiknya Anda menskalakan 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 tertentu yang akan difilter saat penskalaan.

Temukan nama aturan penerusan dari load balancer frontend Ingress:

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

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

Dapatkan status resource HorizontalPodAutoscaler Anda:

kubectl get hpa

Output-nya mirip dengan 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 menyertakan Layanan loadgenerator. Layanan ini terus mengirim permintaan yang meniru pengguna ke frontend, dan secara berkala membuat akun baru dan menyimulasikan transaksi di antara akun tersebut.

Ekspos 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 beban, jika nilai Kegagalan menampilkan 100%, selesaikan langkah-langkah berikut untuk memperbarui setelan pengujian:
1. Klik tombol Berhenti di samping penghitung rasio kegagalan.
2. Di bagian Status, klik opsi untuk Pengujian baru.
3. Perbarui nilai Host ke alamat IP ingress Cymbal Bank Anda.
4. Klik Start swarming.
Di antarmuka web generator beban, klik tab Diagram untuk mengamati performa dari waktu ke waktu. Lihat jumlah permintaan dan penggunaan resource.
Buka jendela terminal baru dan lihat jumlah replika Pod frontend dan userservice Anda:
```
kubectl get hpa -w
```
Jumlah replika meningkat seiring dengan bertambahnya beban. Tindakan scaleUp mungkin memerlukan waktu sekitar sepuluh menit saat cluster mengenali bahwa metrik yang dikonfigurasi mencapai nilai minimum yang ditentukan, dan menggunakan Horizontal Pod Autoscaler untuk menskalakan jumlah Pod.

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

Jumlah node juga telah meningkat dari jumlah awal untuk mengakomodasi replika baru. Peningkatan jumlah node ini didukung oleh GKE Autopilot. Tidak ada yang perlu Anda konfigurasikan untuk 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 akan otomatis diskalakan naik dan turun dengan cara yang sama seperti dengan beban simulasi ini. Aplikasi contoh Cymbal Bank dirancang untuk mengakomodasi jenis penskalaan ini. Hubungi operator Aplikasi dan engineer keandalan situs (SRE) atau developer Aplikasi untuk melihat apakah beban kerja mereka dapat memanfaatkan fitur penskalaan ini.

Pembersihan

Rangkaian tutorial untuk Cymbal Bank dirancang untuk diselesaikan satu per satu. Seiring Anda menyelesaikan serangkaian tutorial, Anda akan mempelajari keterampilan baru dan menggunakan produk dan layanan Google Cloud tambahan.

Jika Anda ingin beristirahat sebelum melanjutkan ke tutorial berikutnya dan menghindari biaya pada 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.