HPA - Tambah Jumlah Replika jika Dibutuhkan Secara Otomatis

Pada artikel sebelumnya, kita telah membahas tentang CronJob yang memungkinkan kita menjalankan Job secara terjadwal. Kali ini, kita akan membahas tentang Horizontal Pod Autoscaler (HPA), sebuah resource Kubernetes yang memungkinkan aplikasi kita untuk skala secara otomatis berdasarkan kebutuhan.

Apa itu Horizontal Pod Autoscaler?

Horizontal Pod Autoscaler (HPA) adalah resource Kubernetes yang secara otomatis menambah atau mengurangi jumlah replika Pod dalam sebuah Deployment, ReplicaSet, atau StatefulSet berdasarkan metrik tertentu, seperti penggunaan CPU atau memori.

Bayangkan kamu memiliki sebuah aplikasi web yang pada jam-jam tertentu mengalami lonjakan traffic. Tanpa HPA, kamu perlu secara manual menambah jumlah replika untuk menangani lonjakan tersebut, lalu menguranginya kembali ketika traffic sudah normal. Dengan HPA, proses ini menjadi otomatis.

Bagaimana HPA Bekerja?

HPA bekerja dengan siklus kontrol yang terus-menerus:

Mengumpulkan Metrik: HPA mengumpulkan metrik dari Metrics Server atau sumber metrik lainnya.
Menghitung Jumlah Replika yang Diinginkan: Berdasarkan metrik yang dikumpulkan, HPA menghitung jumlah replika yang dibutuhkan.
Menyesuaikan Jumlah Replika: HPA memperbarui jumlah replika pada target (Deployment, ReplicaSet, atau StatefulSet).

Rumus dasar yang digunakan HPA untuk menghitung jumlah replika adalah:

desiredReplicas = ceil[currentReplicas * (currentMetricValue / desiredMetricValue)]

Misalnya, jika kita memiliki 2 replika dengan penggunaan CPU rata-rata 90%, dan target penggunaan CPU adalah 50%, maka:

desiredReplicas = ceil[2 * (90% / 50%)] = ceil[2 * 1.8] = ceil[3.6] = 4

Jadi, HPA akan menambah jumlah replika menjadi 4.

Jenis-jenis Metrik

HPA dapat menggunakan beberapa jenis metrik untuk membuat keputusan scaling:

1. Resource Metrics

Metrik resource adalah metrik yang terkait dengan penggunaan resource oleh Pod, seperti CPU dan memori. Ini adalah jenis metrik yang paling umum digunakan.

2. Custom Metrics

Metrik kustom adalah metrik yang didefinisikan oleh pengguna dan disediakan oleh adapter metrik kustom. Contohnya adalah jumlah request per detik, panjang antrian, atau metrik bisnis lainnya.

3. External Metrics

Metrik eksternal adalah metrik yang berasal dari sistem eksternal, seperti layanan cloud atau sistem monitoring eksternal.

4. Object Metrics

Metrik objek adalah metrik yang terkait dengan objek Kubernetes lainnya, seperti Ingress atau Service.

Membuat HPA

Untuk membuat HPA, kita perlu memastikan bahwa Metrics Server sudah terpasang di klaster Kubernetes kita. Metrics Server adalah komponen yang mengumpulkan metrik resource dari kubelet dan menyediakannya melalui Kubernetes Metrics API.

HPA Berbasis CPU

Berikut adalah contoh HPA yang menskalakan Deployment berdasarkan penggunaan CPU:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: frontend-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: frontend
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

HPA di atas akan menskalakan Deployment frontend antara 2 dan 10 replika, dengan target penggunaan CPU rata-rata 50%.

HPA Berbasis Memori

Kita juga bisa menskalakan berdasarkan penggunaan memori:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: frontend-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: frontend
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 60

HPA dengan Multiple Metrics

Kita juga bisa menggunakan beberapa metrik sekaligus:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: frontend-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: frontend
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 60

Dalam kasus ini, HPA akan menskalakan berdasarkan metrik yang membutuhkan jumlah replika terbanyak.

Parameter HPA

Berikut adalah beberapa parameter penting dalam HPA:

minReplicas dan maxReplicas

Parameter ini menentukan batas minimum dan maksimum jumlah replika yang dapat dibuat oleh HPA.

metrics

Parameter ini menentukan metrik yang digunakan untuk membuat keputusan scaling.

behavior

Parameter ini mengontrol bagaimana scaling dilakukan, termasuk kebijakan scaling up dan scaling down.

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: frontend-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: frontend
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
      - type: Percent
        value: 100
        periodSeconds: 15
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60

Dalam contoh di atas:

scaleUp: HPA dapat menambah hingga 100% dari jumlah replika saat ini setiap 15 detik.
scaleDown: HPA dapat mengurangi hingga 10% dari jumlah replika saat ini setiap 60 detik, dan akan menunggu 300 detik sebelum mempertimbangkan untuk mengurangi replika lagi.

Perilaku Scaling

HPA memiliki beberapa parameter yang mengontrol perilaku scaling:

Stabilization Window

Jendela stabilisasi adalah periode waktu di mana HPA akan mempertimbangkan nilai metrik tertinggi (untuk scale down) atau terendah (untuk scale up) sebelum membuat keputusan scaling. Ini membantu mencegah flapping (scaling up dan down secara berulang-ulang).

Scaling Policies

Kebijakan scaling mengontrol seberapa cepat scaling dapat terjadi. Kita bisa menentukan berapa banyak replika yang dapat ditambah atau dikurangi dalam periode waktu tertentu.

Contoh Lengkap

Mari kita lihat contoh lengkap penggunaan HPA dengan sebuah aplikasi web:

Pertama, kita buat Deployment untuk aplikasi web:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app
        image: nginx:latest
        resources:
          requests:
            cpu: 100m
            memory: 128Mi
          limits:
            cpu: 200m
            memory: 256Mi
        ports:
        - containerPort: 80

Kemudian, kita buat Service untuk mengekspos aplikasi:

apiVersion: v1
kind: Service
metadata:
  name: web-app
spec:
  selector:
    app: web-app
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP

Terakhir, kita buat HPA:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 0
      policies:
      - type: Percent
        value: 100
        periodSeconds: 15
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60

Simpan ketiga file YAML di atas dan terapkan ke klaster:

kubectl apply -f web-app-deployment.yaml
kubectl apply -f web-app-service.yaml
kubectl apply -f web-app-hpa.yaml

Verifikasi bahwa HPA telah dibuat:

kubectl get hpa

Output akan terlihat seperti ini:

NAME          REFERENCE            TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
web-app-hpa   Deployment/web-app   0%/50%    2         10        2          1m

Menguji HPA

Untuk menguji HPA, kita perlu menghasilkan beban pada aplikasi kita. Salah satu cara adalah dengan menggunakan tool seperti hey atau ab (Apache Benchmark).

Pertama, kita perlu mengekspos aplikasi kita agar bisa diakses dari luar klaster:

kubectl port-forward svc/web-app 8080:80

Kemudian, di terminal lain, kita bisa menggunakan hey untuk menghasilkan beban:

hey -z 5m -c 50 http://localhost:8080

Perintah di atas akan mengirim request ke aplikasi kita selama 5 menit dengan 50 koneksi konkuren.

Pantau HPA dan jumlah replika:

kubectl get hpa web-app-hpa --watch

Kita akan melihat bahwa penggunaan CPU meningkat dan HPA mulai menambah jumlah replika.

Best Practices dan Keterbatasan

Berikut adalah beberapa best practices dan keterbatasan yang perlu diperhatikan saat menggunakan HPA:

Best Practices

Tentukan resource requests yang tepat: HPA menggunakan resource requests sebagai dasar untuk menghitung penggunaan resource. Pastikan resource requests mencerminkan kebutuhan aplikasi dengan tepat.
Gunakan stabilization window: Stabilization window membantu mencegah flapping. Gunakan nilai yang sesuai dengan karakteristik aplikasi kamu.
Kombinasikan dengan Cluster Autoscaler: Jika kamu menggunakan Kubernetes di cloud, kombinasikan HPA dengan Cluster Autoscaler untuk menskalakan node secara otomatis.
Uji dengan beban yang realistis: Uji HPA dengan pola beban yang mencerminkan penggunaan aplikasi di dunia nyata.

Keterbatasan

Latency metrik: Ada delay antara perubahan beban dan HPA menerima metrik terbaru. Ini bisa menyebabkan respons yang lambat terhadap lonjakan traffic yang tiba-tiba.
Scaling berdasarkan prediksi tidak didukung: HPA hanya bereaksi terhadap metrik saat ini, bukan prediksi beban di masa depan.
Ketergantungan pada Metrics Server: HPA membutuhkan Metrics Server atau sumber metrik lainnya untuk berfungsi.

Kesimpulan

Horizontal Pod Autoscaler adalah alat yang sangat berguna untuk menskalakan aplikasi secara otomatis berdasarkan kebutuhan. Dengan HPA, kita bisa memastikan aplikasi kita memiliki sumber daya yang cukup untuk menangani beban, sekaligus mengoptimalkan penggunaan sumber daya klaster.

Dalam seri artikel Kubernetes ini, kita telah membahas berbagai komponen penting Kubernetes, mulai dari konsep dasar seperti Pod dan Namespace, hingga komponen yang lebih kompleks seperti Deployment, Service, ConfigMap, Secret, DaemonSet, Job, CronJob, dan akhirnya HPA. Dengan pemahaman tentang komponen-komponen ini, kamu sekarang memiliki fondasi yang kuat untuk membangun dan mengelola aplikasi di Kubernetes.

Semoga seri artikel ini bermanfaat bagi kamu yang baru memulai perjalanan dengan Kubernetes. Jangan lupa untuk mencoba contoh-contoh di atas di klaster Minikube kamu!

Cappy Hoding! 🖖🏾

Apa itu Horizontal Pod Autoscaler?#

Bagaimana HPA Bekerja?#

Jenis-jenis Metrik#

1. Resource Metrics#

2. Custom Metrics#

3. External Metrics#

4. Object Metrics#

Membuat HPA#

HPA Berbasis CPU#

HPA Berbasis Memori#

HPA dengan Multiple Metrics#

Parameter HPA#

minReplicas dan maxReplicas#

metrics#

behavior#

Perilaku Scaling#

Stabilization Window#

Scaling Policies#

Contoh Lengkap#

Menguji HPA#

Best Practices dan Keterbatasan#

Best Practices#

Keterbatasan#

Kesimpulan#