Cara Install Horizontal Pod Autoscaler (HPA) di Kubernetes

Pengantar

Dalam dunia Kubernetes, kebutuhan untuk menangani lonjakan traffic secara otomatis menjadi hal yang sangat penting, dan di sinilah Horizontal Pod Autoscaler (HPA) berperan. HPA memungkinkan Kubernetes untuk menambah atau mengurangi jumlah pod secara otomatis berdasarkan penggunaan resource seperti CPU atau memory, sehingga kamu tidak perlu lagi melakukan scaling secara manual karena sistem akan menyesuaikan jumlah pod sesuai beban kerja aplikasi. Hal ini sangat bermanfaat untuk menjaga performa tetap optimal sekaligus menghemat resource. Menguasai cara install dan menggunakan HPA juga penting karena membantu aplikasi tetap stabil saat traffic tinggi, menghemat resource saat beban rendah, mendukung sistem auto scaling modern, serta banyak digunakan dalam implementasi DevOps dan arsitektur cloud-native. Pada artikel ini, kamu akan mempelajari cara mengaktifkan Horizontal Pod Autoscaler di Kubernetes secara bertahap dan mudah dipahami.

Persiapan Sebelum Install HPA

Sebelum mulai, pastikan beberapa hal berikut sudah siap:

Kubernetes cluster sudah berjalan
Deployment aplikasi sudah ada (contoh: nginx)
Resource request pada pod sudah dikonfigurasi

Install Metrics Server

Install Metrics Server
HPA (Horizontal Pod Autoscaler) membutuhkan Metrics Server untuk membaca penggunaan resource seperti CPU dan memory.
Jalankan perintah berikut:
```
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
```
Verifikasi Metrics Server
```
kubectl get pods -n kube-system
```
Pastikan terdapat pod seperti berikut dengan status Running:
```
metrics-server-xxxx   Running
```
Test Metrics

Cek penggunaan resource node:
```
kubectl top nodes
```
Atau cek penggunaan resource pod:
```
kubectl top pods
```
Jika muncul data penggunaan CPU dan memory, berarti Metrics Server sudah aktif dan siap digunakan untuk HPA.

Konfigurasi Resource pada Deployment

Agar HPA (Horizontal Pod Autoscaler) dapat bekerja dengan baik, setiap pod harus memiliki konfigurasi resource request dan limit. Tanpa ini, HPA tidak dapat menghitung penggunaan CPU atau memory secara akurat.

1. Edit deployment:
```
kubectl edit deployment nginx
```
2. Tambahkan konfigurasi berikut pada bagian container:
```
resources:
  requests:
    cpu: "100m"
    memory: "64Mi"
  limits:
    cpu: "200m"
    memory: "128Mi"
```
  Penjelasan:
  - requests : Resource minimum yang dijamin untuk pod
  - limits : Batas maksimum resource yang bisa digunakan pod
  - 100m CPU = 0.1 core
  Setelah konfigurasi ini ditambahkan, HPA dapat mulai memantau penggunaan resource dan melakukan scaling secara otomatis.

Membuat Horizontal Pod Autoscaler (HPA)

Setelah Metrics Server aktif dan resource pada deployment sudah dikonfigurasi, langkah selanjutnya adalah membuat HPA. HPA berfungsi untuk menambah atau mengurangi jumlah pod secara otomatis berdasarkan penggunaan resource seperti CPU.

Jalankan perintah berikut:
```
kubectl autoscale deployment nginx \
--cpu-percent=50 \
--min=1 \
--max=3
```
Penjelasan:
- --cpu-percent=50 : Target penggunaan CPU adalah 50%
- --min=1 : Minimal jumlah pod adalah 1
- --max=3 : Maksimal jumlah pod adalah 3
Cek Status HPA
```
kubectl get hpa
```
Contoh output:
```
NAME    REFERENCE          TARGETS   MINPODS   MAXPODS   REPLICAS
nginx   Deployment/nginx   10%/50%   1         3         1
```
Pada kolom TARGETS, angka pertama menunjukkan penggunaan CPU saat ini, sedangkan angka kedua adalah target yang telah ditentukan.
Cara Kerja HPA
HPA akan memonitor penggunaan CPU secara terus-menerus dan melakukan scaling secara otomatis berdasarkan kondisi berikut:
- Jika penggunaan CPU lebih besar dari 50%, maka jumlah pod akan ditambah (scale up)
- Jika penggunaan CPU lebih kecil dari 50%, maka jumlah pod akan dikurangi (scale down)
Keterangan:
Proses ini berjalan secara otomatis tanpa perlu intervensi manual, sehingga sangat membantu dalam menjaga performa aplikasi tetap stabil saat terjadi perubahan beban.

Pengujian Horizontal Pod Autoscaler (HPA)

Menentukan Endpoint Aplikasi
Setelah konfigurasi HPA selesai, langkah pertama adalah memastikan endpoint aplikasi yang akan diuji sudah diketahui.
Cek service:
```
kubectl get svc
```
Contoh output:
```
nginx   NodePort   10.103.x.x      80:30510/TCP
```
Artinya aplikasi dapat diakses melalui:
```
http://IP_PUBLIC_SERVER:30510
```
Endpoint ini akan digunakan sebagai target saat melakukan load testing.
Melakukan Load Testing dengan Apache JMeter
Untuk mensimulasikan banyak pengguna secara bersamaan, gunakan Apache JMeter agar dapat memberikan beban ke aplikasi secara real-time.
Langkah-langkah:
- Buka aplikasi JMeter
- Tambahkan Thread Group
- Number of Threads (Users): 50–100
- Ramp-up Period: 10
- Loop Count: Forever (atau sesuai kebutuhan)
- Tambahkan HTTP Request
- Protocol: http
- Server Name / IP: IP VPS kamu
- Port: 30510
- Path: /
- Tambahkan Listener: View Results Tree dan Summary Report
- Klik tombol Start
Dengan konfigurasi ini, JMeter akan mensimulasikan puluhan hingga ratusan user yang mengakses aplikasi secara bersamaan.
Monitoring Autoscaling
Saat load testing berjalan, lakukan monitoring untuk melihat bagaimana Kubernetes merespon peningkatan beban.
Cek HPA secara real-time:
```
kubectl get hpa -w
```
Cek jumlah pod:
```
kubectl get pods -o wide
```
Cek penggunaan resource:
```
kubectl top pods
```
Monitoring ini penting untuk memastikan bahwa autoscaling berjalan sesuai dengan kondisi sistem.
Hasil yang Diharapkan (Scale Up)

Saat traffic meningkat, penggunaan CPU akan naik dan HPA akan mulai melakukan scaling.

Contoh kondisi:
```
CPU: 70% / 50%
REPLICAS: 1 → 2 → 3
```
Artinya:
- Beban aplikasi meningkat
- Kubernetes otomatis menambah jumlah pod
- Aplikasi tetap stabil meskipun traffic tinggi
Pengujian Scale Down

Setelah pengujian selesai, hentikan load testing di JMeter dan tunggu beberapa menit.

Cek kembali HPA:
```
kubectl get hpa
```
Hasil yang diharapkan:
```
REPLICAS: 3 → 2 → 1
```
Artinya:
- Beban aplikasi menurun
- Kubernetes otomatis mengurangi jumlah pod
- Resource digunakan lebih efisien

Tips dan Catatan Penting

Saat melakukan pengujian Horizontal Pod Autoscaler (HPA), ada beberapa hal penting yang perlu diperhatikan agar hasil pengujian akurat dan sesuai dengan kondisi sebenarnya. Tanpa konfigurasi yang tepat, HPA mungkin tidak bekerja secara optimal.

HPA tidak langsung menurunkan pod
Proses scale down biasanya memiliki delay sekitar 3–5 menit. Hal ini merupakan mekanisme bawaan Kubernetes untuk mencegah scaling yang terlalu agresif (flapping), sehingga sistem tetap stabil.
Pastikan resource request sudah dikonfigurasi
HPA bekerja berdasarkan perbandingan antara penggunaan resource dan nilai request. Jika resource request tidak diset, maka HPA tidak dapat menghitung persentase penggunaan CPU atau memory dengan benar.
Gunakan beban yang cukup besar
Pastikan load testing yang dilakukan cukup tinggi untuk menaikkan penggunaan CPU. Jika beban terlalu kecil, HPA tidak akan melakukan scaling karena tidak mencapai threshold yang ditentukan.
Pastikan Metrics Server berjalan dengan baik
HPA bergantung pada Metrics Server untuk membaca penggunaan CPU dan memory. Jika Metrics Server tidak aktif atau bermasalah, maka HPA tidak akan dapat bekerja sama sekali.

Dengan memperhatikan hal-hal di atas, Anda dapat memastikan bahwa proses pengujian HPA berjalan dengan optimal dan memberikan hasil yang sesuai dengan kondisi nyata di lapangan.

Kesimpulan

Horizontal Pod Autoscaler (HPA) merupakan fitur penting dalam Kubernetes yang memungkinkan sistem melakukan scaling secara otomatis berdasarkan penggunaan resource. Dengan HPA, aplikasi dapat menangani lonjakan traffic tanpa perlu intervensi manual, sekaligus tetap efisien dalam penggunaan resource saat beban rendah.

Melalui pengujian menggunakan Apache JMeter, kita dapat melihat bagaimana Kubernetes secara dinamis menyesuaikan jumlah pod sesuai kebutuhan. Hal ini menunjukkan bahwa HPA sangat berguna dalam membangun sistem yang scalable, stabil, dan siap digunakan di lingkungan production.