Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Jalur Pembelajaran: Aplikasi yang skalabel - Penskalaan

Autopilot

Kumpulan tutorial ini ditujukan untuk administrator dan Operator IT yang ingin men-deploy, menjalankan, dan mengelola lingkungan aplikasi modern yang berjalan di Google Kubernetes Engine (GKE). Saat Anda mengikuti kumpulan 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
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 melambat atau mengalami masalah lain, tetapi tanpa organisasi harus menghabiskan uang untuk resource Cloud yang sebenarnya tidak mereka butuhkan. Solusi yang Google Cloud menyediakan hal ini adalah penskalaan otomatis.

Dalam tutorial ini, Anda akan mempelajari cara mengonfigurasi cluster dan workload di cluster GKE untuk menskalakan menggunakan 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 untuk Trace.
- Metrik kustom memungkinkan Anda menskalakan menggunakan data pemantauan tambahan atau input eksternal di luar pengetahuan cluster Kubernetes, seperti traffic jaringan atau kode respons HTTP.
Mengonfigurasi Horizontal Pod Autoscaler, fitur GKE yang dapat otomatis menambah atau mengurangi jumlah Pod untuk workload, bergantung pada metrik yang ditentukan.
Menyimulasikan beban aplikasi dan melihat respons autoscaler cluster dan Horizontal Pod Autoscaler.

Biaya

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

Anda juga bertanggung jawab atas biaya Google Cloud lain yang dikeluarkan saat menjalankan aplikasi contoh Cymbal Bank, seperti biaya 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 kumpulan tutorial ini untuk aplikasi yang dapat diskalakan secara berurutan. Saat Anda mengikuti kumpulan tutorial ini, Anda akan mempelajari keterampilan baru dan menggunakan tambahan Google Cloud produk dan layanan.

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 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 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.iam.gserviceaccount.com
```
Konfigurasi ini memungkinkan Pod yang menggunakan default akun layanan Kubernetes di namespace default untuk mengakses resource yang sama Google Cloud 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 memberikan lebih banyak insight kepada cluster Anda tentang performa dan kebutuhan aplikasi secara keseluruhan. Dalam tutorial ini, Anda akan mempelajari cara menggunakan metrik bawaan dan kustom.

Untuk mengizinkan Horizontal Pod Autoscaler membaca metrik kustom dari Monitoring, Anda harus menginstal Custom Metrics - Stackdriver Adapter adaptor 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
```
Untuk mengizinkan adaptor Stackdriver mendapatkan metrik kustom dari cluster Anda, gunakan Workload Identity Federation for GKE. Pendekatan ini menggunakan akun layanan IAM yang memiliki izin untuk membaca metrik pemantauan.

Berikan peran roles/monitoring.viewer ke 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 Federation for GKE 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 Google Kubernetes Engine, seperti Monitoring, gunakan Workload Identity Federation for 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.iam.gserviceaccount.com
```

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 menskalakan dengan beberapa cara. Dalam tutorial ini, Anda akan melihat cara cluster Anda dapat menskalakan menggunakan metode berikut:

Horizontal Pod Autoscaler: menskalakan jumlah Pod untuk workload.
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, bekerjasamalah 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 Anda merespons beban. Dalam manifes YAML untuk HorizontalPodAutoscaler, Anda menentukan Deployment yang akan diskalakan oleh Horizontal Pod Autoscaler, metrik yang akan dipantau, serta jumlah replika minimum dan maksimum 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 mengonfigurasi Horizontal Pod Autoscaler pada Deployment userservice berdasarkan metrik Kubernetes bawaan untuk pemakaian CPU. Untuk Deployment frontend, Anda mungkin ingin menskalakan berdasarkan jumlah permintaan HTTP 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 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. Kemudian, Anda dapat berhenti membuat 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

Outputnya 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 serta 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 Anda, 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 Failures menampilkan 100%, selesaikan langkah-langkah berikut untuk memperbarui setelan pengujian:
1. Klik tombol Stop di samping penghitung rasio kegagalan.
2. Di bagian Status, klik opsi untuk New test.
3. Perbarui nilai Host ke alamat IP Ingress Cymbal Bank Anda.
4. Klik Start swarming.
Di antarmuka web generator beban, klik tab Charts 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 karena cluster mengenali bahwa metrik yang dikonfigurasi mencapai batas yang ditentukan, dan menggunakan Horizontal Pod Autoscaler untuk meningkatkan jumlah Pod.

Output contoh berikut menunjukkan 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)' \
    --location="CONTROL_PLANE_LOCATION"
```
Ganti CONTROL_PLANE_LOCATION dengan lokasi Compute Engine dari bidang kontrol cluster Anda. Berikan region untuk cluster regional, atau zona untuk cluster zona.

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 konfigurasi 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. Perkecil skala mungkin memerlukan waktu karena periode stabilisasi default untuk replika di resource HorizontalPodAutoscaler Kubernetes adalah lima menit.

Di lingkungan yang sebenarnya, jumlah node dan Pod di lingkungan Anda akan otomatis meningkat dan menurun dengan cara yang sama seperti beban yang disimulasikan ini. Aplikasi contoh Cymbal Bank dirancang untuk mengakomodasi penskalaan semacam ini. Hubungi operator Aplikasi dan site reliability engineering (SRE) atau Developer Aplikasi untuk melihat apakah workload mereka dapat memanfaatkan fitur penskalaan ini.

Pembersihan

Kumpulan tutorial untuk Cymbal Bank dirancang untuk diselesaikan satu per satu. Saat Anda mengikuti kumpulan tutorial ini, Anda akan mempelajari keterampilan baru dan menggunakan tambahan Google Cloud produk dan layanan.

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

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

Langkah berikutnya

Pelajari cara menyimulasikan kegagalan di GKE dalam tutorial berikutnya.