Cara Menguji Performa Load Testing Aplikasi di Kubernetes Cluster dengan k6 dan monitoring di Prometheus
Pengantar
Ketika sebuah aplikasi sudah berjalan di Kubernetes Cluster, pekerjaan belum selesai karena salah satu langkah penting sebelum aplikasi digunakan oleh banyak pengguna adalah melakukan load testing atau pengujian beban untuk mengetahui seberapa kuat aplikasi menangani banyak request secara bersamaan sekaligus mengidentifikasi bottleneck yang mungkin muncul pada pod, service, maupun node Kubernetes. Dalam lingkungan Kubernetes, load testing menjadi semakin penting karena sistem biasanya memanfaatkan fitur autoscaling seperti Horizontal Pod Autoscaler (HPA), sehingga tanpa pengujian yang memadai kita tidak akan mengetahui apakah autoscaling berjalan dengan baik atau justru menimbulkan masalah baru ketika trafik meningkat. Salah satu kombinasi yang populer digunakan adalah k6 sebagai tool load testing dan Prometheus sebagai sistem monitoring, di mana k6 mampu menghasilkan ribuan request dengan konfigurasi yang fleksibel sedangkan Prometheus dapat mengumpulkan metrik dari cluster Kubernetes secara real-time. Dengan melakukan load testing Kubernetes menggunakan k6 dan Prometheus, kita dapat mengetahui kapasitas maksimum aplikasi, mengukur waktu respons aplikasi, memastikan HPA bekerja dengan baik, mendeteksi bottleneck CPU dan memory, mengidentifikasi error ketika trafik meningkat, serta membantu perencanaan kapasitas infrastruktur. Pada artikel ini kita akan membahas cara melakukan load testing aplikasi di Kubernetes menggunakan k6 serta memantau performanya melalui Prometheus.
Apa Itu k6?
k6 adalah tool open-source yang digunakan untuk melakukan load testing, stress testing, dan performance testing terhadap aplikasi web, API, maupun layanan yang berjalan di Kubernetes.
Tool ini dikembangkan menggunakan bahasa Go (Golang) dan menggunakan JavaScript sebagai bahasa scripting untuk membuat skenario pengujian.
Karena ringan dan mudah diotomatisasi, k6 banyak digunakan oleh tim DevOps, Site Reliability Engineering (SRE), dan developer untuk menguji performa aplikasi sebelum digunakan di lingkungan production.
Beberapa keunggulan k6:
- Ringan dan mudah digunakan
Tidak membutuhkan resource besar dan dapat dijalankan langsung dari terminal Linux maupun container. - Konfigurasi menggunakan JavaScript
Skenario pengujian ditulis menggunakan JavaScript sehingga lebih fleksibel dan mudah dipahami. - Mendukung berbagai jenis load test
Dapat digunakan untuk load testing, stress testing, spike testing, soak testing, dan performance benchmarking. - Integrasi dengan Grafana dan Prometheus
Metrik hasil benchmark dapat dikirim langsung ke sistem monitoring untuk visualisasi realtime. - Cocok untuk CI/CD pipeline
Dapat diintegrasikan dengan GitLab CI, GitHub Actions, Jenkins, maupun platform automation lainnya.
Contoh penggunaan k6:
- Menguji performa aplikasi Laravel
- Menguji API REST dan GraphQL
- Menguji Kubernetes Ingress
- Menguji Load Balancer
- Menguji autoscaling Kubernetes (HPA)
Contoh metrik yang dihasilkan k6:
- Request Per Second (RPS)
Jumlah request yang berhasil diproses setiap detik. - Response Time
Waktu yang dibutuhkan aplikasi untuk merespon request. - Error Rate
Persentase request yang gagal selama pengujian. - Throughput
Jumlah data atau request yang berhasil diproses dalam periode tertentu. - Virtual Users (VUs)
Jumlah pengguna virtual yang disimulasikan selama benchmark.
Mengapa k6 Populer untuk Kubernetes?
- Dapat menghasilkan ribuan request dengan resource yang relatif kecil
- Mudah diintegrasikan dengan Prometheus dan Grafana
- Cocok untuk menguji Horizontal Pod Autoscaler (HPA)
- Dapat dijalankan dari container maupun pod Kubernetes
- Mendukung monitoring performa secara realtime
Keterangan:
k6 menjadi salah satu tool load testing modern yang banyak digunakan pada lingkungan cloud-native dan Kubernetes karena ringan, mudah diotomasi, serta memiliki integrasi yang sangat baik dengan ekosistem observability seperti Prometheus dan Grafana.
Apa Itu Prometheus?
Prometheus adalah sistem monitoring dan alerting open-source yang sangat populer pada lingkungan Kubernetes dan cloud-native.
Prometheus digunakan untuk mengumpulkan, menyimpan, serta menganalisis metrik dari berbagai komponen infrastruktur dan aplikasi secara realtime.
Pada Kubernetes, Prometheus sering digunakan untuk memantau kesehatan cluster, penggunaan resource, performa aplikasi, hingga mendeteksi potensi masalah sebelum berdampak pada pengguna.
Prometheus bekerja dengan cara melakukan scraping metrik dari berbagai target seperti:
- Kubernetes Node
Mengumpulkan informasi penggunaan CPU, memory, disk, dan network pada setiap node cluster. - Pod
Memantau resource yang digunakan oleh pod seperti CPU, memory, restart count, dan status container. - Deployment
Memantau jumlah replica, status rollout, dan kondisi deployment aplikasi. - Service
Mengumpulkan metrik yang berkaitan dengan service dan komunikasi antar aplikasi. - Application Exporter
Mengambil metrik khusus aplikasi seperti request, response time, error rate, dan informasi bisnis lainnya. - Ingress Controller
Memantau jumlah request, latency, status code HTTP, serta performa trafik masuk ke cluster.
Beberapa metrik yang umum dikumpulkan Prometheus:
- CPU Usage
- Memory Usage
- Disk Usage
- Network Traffic
- Request Per Second (RPS)
- Response Time
- Error Rate
- Container Restart Count
- Pod Status
Keunggulan Prometheus:
- Mendukung monitoring Kubernetes secara native
- Menggunakan query language yang kuat (PromQL)
- Mudah diintegrasikan dengan Grafana
- Mendukung alert otomatis menggunakan Alertmanager
- Mampu mengumpulkan ribuan metrik secara realtime
Metrik yang berhasil dikumpulkan kemudian dapat divisualisasikan menggunakan Grafana sehingga lebih mudah dianalisis melalui dashboard interaktif dan grafik realtime.
Dengan kombinasi Prometheus dan Grafana, administrator dapat memantau kondisi Kubernetes Cluster secara menyeluruh mulai dari node, pod, service, hingga performa aplikasi yang sedang berjalan.
Keterangan:
Prometheus merupakan salah satu komponen utama dalam observability Kubernetes karena mampu menyediakan data monitoring yang akurat untuk analisa performa, troubleshooting, capacity planning, dan konfigurasi autoscaling seperti Horizontal Pod Autoscaler (HPA).
Persiapan Environment
Sebelum melakukan pengujian, pastikan tersedia:
- Kubernetes Cluster
- Aplikasi yang sudah berjalan
- kubectl
- Prometheus
- Grafana
- k6
Instalasi k6
Sebelum melakukan load testing menggunakan k6, terlebih dahulu install aplikasi k6 pada server yang akan digunakan sebagai mesin benchmark.
- Install k6 pada Ubuntu / Debian
Tambahkan repository resmi k6:
sudo gpg -k curl -fsSL https://dl.k6.io/key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/k6-archive-keyring.gpg echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.listUpdate repository dan install k6:
sudo apt update sudo apt install k6 -yFungsi:
- Menambahkan repository resmi k6
- Menginstall package k6 terbaru
- Memastikan update versi lebih mudah dilakukan di kemudian hari
- Install k6 pada RHEL / AlmaLinux / Rocky Linux 8 dan 9
Buat repository k6:
sudo tee /etc/yum.repos.d/k6.repo <Install k6:
sudo dnf install k6 -yJika menggunakan Rocky Linux atau AlmaLinux versi lama yang masih menggunakan yum:
sudo yum install k6 -yFungsi:
- Menambahkan repository resmi k6 untuk RPM-based Linux
- Menginstall k6 melalui package manager
- Memudahkan proses upgrade versi k6
Keterangan:
Metode repository resmi lebih direkomendasikan dibanding instalasi manual karena memudahkan update keamanan dan perbaikan bug.
Verifikasi Instalasi
Setelah proses instalasi selesai, cek versi k6:
k6 version
Contoh output:
k6 v1.1.0
Fungsi:
Memastikan binary k6 berhasil terinstall
Memastikan PATH sistem mengenali executable k6
Menampilkan versi yang sedang digunakan
Alternatif verifikasi:
which k6
Contoh output:
/usr/bin/k6
Jika perintah berhasil menampilkan versi atau lokasi binary, maka instalasi k6 telah berhasil dan siap digunakan untuk melakukan load testing Kubernetes Cluster maupun aplikasi web.
Keterangan:
Sebelum menjalankan benchmark skala besar, pastikan server benchmark memiliki CPU dan memory yang cukup agar hasil pengujian mencerminkan performa aplikasi, bukan keterbatasan mesin penguji.
Memastikan Prometheus Berjalan
Sebelum melakukan load testing dan monitoring performa Kubernetes, pastikan seluruh komponen monitoring telah berjalan dengan normal pada cluster.
- Login ke Node Master Kubernetes
Jalankan seluruh perintah monitoring dari node control-plane atau master Kubernetes yang memiliki akses ke cluster.
Fungsi:
- Mengelola resource Kubernetes
- Mengakses kubectl secara langsung
- Memverifikasi status komponen monitoring
Keterangan:
Pastikan kubectl sudah terkonfigurasi dan dapat mengakses cluster Kubernetes sebelum melanjutkan ke tahap berikutnya. - Cek Pod Monitoring
Pada node master jalankan perintah berikut:
kubectl get pods -n monitoringFungsi:
- Menampilkan seluruh pod pada namespace monitoring
- Memastikan Prometheus dan Grafana berjalan normal
- Memverifikasi komponen observability siap digunakan
Contoh output:
NAME READY prometheus-server 1/1 grafana 1/1 node-exporter-xxxxx 1/1 kube-state-metrics-xxxxx 1/1Penjelasan Komponen:
- prometheus-server
Mengumpulkan dan menyimpan metrik dari cluster Kubernetes. - grafana
Menampilkan dashboard monitoring dalam bentuk grafik dan visualisasi. - node-exporter
Mengirim metrik sistem seperti CPU, memory, disk, dan network dari setiap node. - kube-state-metrics
Menyediakan informasi status resource Kubernetes seperti deployment, pod, service, dan HPA.
Pastikan seluruh pod menunjukkan status:
READY 1/1 STATUS RunningUntuk melihat status lebih lengkap:
kubectl get pods -n monitoring -o wideKeterangan:
Jika seluruh pod monitoring berstatus Running dan READY 1/1, maka Prometheus, Grafana, dan komponen monitoring lainnya siap digunakan untuk memantau performa cluster selama proses load testing berlangsung.
Membuat Script Load Testing k6
Setelah k6 berhasil terinstall, langkah berikutnya adalah membuat script load testing yang akan digunakan untuk mengirim request ke aplikasi yang berjalan di Kubernetes.
- Membuat File Script k6
Buat file baru menggunakan editor Nano:
nano loadtest.jsFungsi:
- Membuat file script load testing
- Menyimpan skenario benchmark k6
- Menentukan jumlah user dan target aplikasi yang akan diuji
- Isi Script Load Testing
Masukkan konfigurasi berikut:
import http from "k6/http"; import { sleep } from "k6"; export let options = { vus: 50, duration: "2m", }; export default function () { http.get("http://103.151.140.105:30081/"); sleep(1); }Penjelasan Script:
- import http from "k6/http"
Mengimpor modul HTTP untuk mengirim request ke aplikasi. - import { sleep } from "k6"
Mengimpor fungsi sleep untuk memberikan jeda antar request. - options
Berisi konfigurasi utama load testing. - vus: 50
Menjalankan 50 virtual user secara bersamaan. - duration: "2m"
Pengujian berlangsung selama 2 menit. - http.get()
Mengirim request HTTP GET ke aplikasi target. - sleep(1)
Memberikan jeda 1 detik sebelum virtual user mengirim request berikutnya.
Keterangan:
Semakin besar nilai vus, semakin tinggi beban yang diberikan ke aplikasi dan Kubernetes Cluster. - import http from "k6/http"
- Estimasi Beban Pengujian
Pada konfigurasi di atas:
- 50 virtual user aktif secara bersamaan
- Pengujian berjalan selama 2 menit
- Setiap user mengirim request berulang selama durasi benchmark
Skenario ini cukup baik untuk melakukan pengujian awal terhadap:
- Deployment Kubernetes
- Service NodePort
- Ingress Controller
- Horizontal Pod Autoscaler (HPA)
- Monitoring Prometheus dan Grafana
- Simpan File Script
Setelah selesai:
- Tekan CTRL + O untuk menyimpan file
- Tekan Enter untuk konfirmasi nama file
- Tekan CTRL + X untuk keluar dari Nano
Verifikasi file berhasil dibuat:
ls -lh loadtest.jsContoh output:
-rw-r--r-- 1 root root 280 May 22 14:30 loadtest.jsKeterangan:
Jika file loadtest.js berhasil muncul pada output ls, maka script k6 siap dijalankan untuk melakukan load testing terhadap aplikasi Kubernetes.
Menjalankan Load Testing
Setelah script k6 selesai dibuat, langkah berikutnya adalah menjalankan load testing dan menganalisa hasil benchmark yang dihasilkan.
- Menjalankan Load Test
Eksekusi script menggunakan perintah berikut:
k6 run loadtest.jsFungsi:
- Menjalankan skenario benchmark yang terdapat pada file loadtest.js
- Mengirim request ke aplikasi secara otomatis
- Mengumpulkan metrik performa selama pengujian berlangsung
Selama benchmark berjalan biasanya akan muncul informasi seperti:
running (2m00s) 50 VUs 120000 complete requests http_req_duration....: avg=120ms http_req_failed......: 0.00% http_reqs............: 1000/s - Memahami Hasil Benchmark
Output k6 menampilkan berbagai metrik penting yang digunakan untuk mengevaluasi performa aplikasi dan Kubernetes Cluster.
Informasi penting yang perlu diperhatikan:
- Response time rata-rata
- Jumlah request berhasil
- Error rate
- Throughput
- Average Response Time
Metrik ini menunjukkan waktu rata-rata yang dibutuhkan aplikasi untuk merespon request.
Contoh:
http_req_duration....: avg=120msInterpretasi:
- Setiap request rata-rata selesai dalam 120 milidetik
- Semakin kecil nilainya semakin baik
- Menunjukkan aplikasi masih responsif saat menerima beban
Keterangan:
Response time yang rendah menunjukkan aplikasi mampu memproses request dengan cepat tanpa bottleneck yang signifikan. - Jumlah Request Berhasil
k6 menampilkan jumlah request yang berhasil diproses selama benchmark.
Contoh:
120000 complete requestsInterpretasi:
- Total 120.000 request berhasil dikirim dan diproses
- Menunjukkan volume trafik yang berhasil ditangani aplikasi
- Dapat digunakan untuk mengukur kapasitas sistem
- Error Rate
Metrik ini menunjukkan persentase request yang gagal.
Contoh:
http_req_failed......: 0.00%Interpretasi:
- 0% berarti seluruh request berhasil diproses
- Tidak ada timeout maupun error aplikasi
- Menunjukkan kestabilan sistem selama benchmark
Penyebab Error Rate Tinggi:
- Pod crash
- Database overload
- Ingress timeout
- CPU atau memory habis
- Load balancer tidak mampu menangani trafik
Keterangan:
Idealnya error rate berada pada angka 0% selama load testing normal. - Throughput dan Request Per Second
Metrik throughput menunjukkan jumlah request yang berhasil diproses setiap detik.
Contoh:
http_reqs............: 1000/sInterpretasi:
- Aplikasi mampu memproses sekitar 1000 request per detik
- Menunjukkan kapasitas aktual sistem saat benchmark berlangsung
- Dapat digunakan untuk menentukan batas kemampuan cluster
Contoh Analisa Keseluruhan:
50 VUs 120000 complete requests avg response time = 120 ms error rate = 0% throughput = 1000 req/sPada hasil tersebut dapat disimpulkan bahwa:
- Aplikasi merespon dengan cepat
- Tidak ada request gagal
- Throughput cukup tinggi
- Kubernetes Cluster masih mampu menangani beban dengan baik
Keterangan:
Kombinasi response time rendah, throughput tinggi, dan error rate 0% merupakan indikator bahwa aplikasi dan Kubernetes Cluster memiliki performa yang baik pada skenario load testing yang dijalankan.
Memantau Kubernetes Saat Pengujian
Selama proses load testing berlangsung, sangat disarankan untuk melakukan monitoring Kubernetes secara realtime agar dapat melihat dampak beban terhadap pod dan node cluster.
- Membuka Terminal Monitoring
Saat k6 sedang berjalan, buka terminal atau session SSH lain.
Tujuan:
- Memisahkan proses benchmark dan monitoring
- Melihat kondisi cluster secara realtime
- Mengidentifikasi bottleneck saat beban meningkat
Keterangan:
Monitoring secara realtime membantu mengetahui bagaimana Kubernetes merespon lonjakan trafik yang dihasilkan oleh k6. - Monitoring Pod
Jalankan perintah berikut:
kubectl get pods -wFungsi:
- Menampilkan status pod secara realtime
- Memantau proses scaling pod
- Melihat pod yang restart atau mengalami error
- Memastikan deployment tetap stabil selama benchmark
Penjelasan Parameter:
- -w
Watch mode, menampilkan perubahan resource secara langsung tanpa perlu menjalankan perintah berulang kali.
Contoh perubahan saat HPA aktif:
web-abcde Running web-fghij Running web-abcde Running web-fghij Running web-klmno Running web-pqrst RunningKeterangan:
Jika jumlah pod bertambah saat CPU meningkat, berarti Horizontal Pod Autoscaler bekerja dengan normal. - Monitoring Resource Pod
Gunakan perintah:
kubectl top podsFungsi:
- Melihat penggunaan CPU pod
- Melihat penggunaan memory pod
- Mengidentifikasi pod yang menggunakan resource paling tinggi
Contoh output:
NAME CPU(cores) MEMORY(bytes) web-abcde 450m 320Mi web-fghij 430m 300MiPenjelasan:
- 450m CPU
Setara dengan 0.45 CPU core yang sedang digunakan. - 320Mi
Pod menggunakan sekitar 320 MiB memory.
Informasi ini membantu mengetahui penggunaan resource selama load test berlangsung.
Untuk melihat seluruh namespace:
kubectl top pods -AKeterangan:
Lonjakan penggunaan CPU pada pod biasanya menjadi pemicu utama Horizontal Pod Autoscaler menambah replica baru. - Monitoring Node
Jalankan:
kubectl top nodesFungsi:
- Memantau penggunaan CPU node
- Memantau penggunaan memory node
- Mengetahui kapasitas cluster selama benchmark
- Mendeteksi bottleneck pada level infrastruktur
Contoh output:
NAME CPU% MEMORY% worker01 55% 60% worker02 52% 57%Interpretasi:
- CPU 55%
Node masih memiliki kapasitas yang cukup untuk menerima workload tambahan. - Memory 60%
Penggunaan memory masih dalam batas aman.
Jika CPU mendekati 100%, kemungkinan node menjadi bottleneck.
Tanda-tanda Bottleneck Node:
- CPU terus berada di atas 90%
- Response time aplikasi meningkat
- Pod gagal dijadwalkan (Pending)
- Autoscaling tidak memberikan peningkatan performa signifikan
Keterangan:
Monitoring pod dan node secara bersamaan membantu menentukan apakah bottleneck berasal dari aplikasi, pod, atau keterbatasan resource pada node Kubernetes.
Monitoring Menggunakan Prometheus
Prometheus menyediakan berbagai metrik Kubernetes yang dapat digunakan untuk melakukan analisis performa aplikasi, pod, node, maupun infrastruktur selama proses load testing berlangsung.
Dengan menggunakan PromQL (Prometheus Query Language), administrator dapat memantau penggunaan resource dan perilaku aplikasi secara realtime melalui dashboard Grafana maupun antarmuka Prometheus.
- CPU Usage Pod
Query:
rate(container_cpu_usage_seconds_total[5m])Fungsi:
- Menampilkan penggunaan CPU setiap container
- Memantau peningkatan beban aplikasi
- Membantu analisa autoscaling HPA
Penjelasan Query:
- container_cpu_usage_seconds_total
Counter total penggunaan CPU container. - rate()
Menghitung rata-rata perubahan nilai per detik. - [5m]
Menggunakan data selama 5 menit terakhir.
Untuk menampilkan CPU berdasarkan pod:
sum(rate(container_cpu_usage_seconds_total[5m])) by (pod)Keterangan:
CPU yang terus meningkat selama load testing menunjukkan aplikasi menerima beban yang lebih besar dan berpotensi memicu autoscaling. - Memory Usage Pod
Query:
container_memory_working_set_bytesFungsi:
- Melihat konsumsi memory aktual container
- Mendeteksi memory leak
- Memastikan container tidak mendekati batas memory
Penjelasan:
- working_set
Memory aktif yang benar-benar digunakan aplikasi. - Tidak termasuk cache yang dapat dilepaskan oleh kernel.
Untuk melihat penggunaan memory berdasarkan pod:
sum(container_memory_working_set_bytes) by (pod)Keterangan:
Memory yang terus meningkat tanpa turun kembali dapat menjadi indikasi adanya memory leak pada aplikasi. - Request Rate (Requests Per Second)
Jika aplikasi menggunakan HTTP exporter atau instrumentation metrics, gunakan query berikut:
rate(http_requests_total[1m])Fungsi:
- Menghitung jumlah request per detik
- Melihat trafik aplikasi secara realtime
- Membandingkan hasil benchmark dengan throughput k6
Penjelasan Query:
- http_requests_total
Counter total request HTTP. - rate()
Menghitung rata-rata pertambahan request per detik. - [1m]
Menggunakan data 1 menit terakhir.
Untuk menampilkan total request seluruh instance:
sum(rate(http_requests_total[1m]))Keterangan:
Metrik ini sangat berguna untuk memvalidasi jumlah request yang dikirim oleh k6 selama load testing. - Error Rate
Query:
rate(http_requests_total{status=~"5.."}[1m])Fungsi:
- Menghitung jumlah HTTP error 5xx
- Mendeteksi kegagalan aplikasi selama benchmark
- Membantu analisa kestabilan sistem
Penjelasan:
- status=~"5.."
Memilih seluruh status HTTP 500 sampai 599. - rate()
Menghitung jumlah error per detik.
Untuk melihat total error seluruh aplikasi:
sum(rate(http_requests_total{status=~"5.."}[1m]))Keterangan:
Lonjakan error 5xx saat load testing biasanya menunjukkan bottleneck pada aplikasi, database, atau resource Kubernetes. - Response Time (P95 Latency)
Query:
histogram_quantile( 0.95, rate(http_request_duration_seconds_bucket[5m]) )Fungsi:
- Mengukur response time percentile 95%
- Mengetahui pengalaman mayoritas pengguna
- Menganalisa peningkatan latency saat trafik tinggi
Penjelasan Query:
- histogram_quantile(0.95)
Menghitung latency pada persentil ke-95. - http_request_duration_seconds_bucket
Histogram waktu respon aplikasi. - rate(...[5m])
Menggunakan data selama 5 menit terakhir.
Interpretasi:
- P95 = 200 ms berarti 95% request selesai kurang dari 200 ms.
- Semakin rendah nilai P95 semakin baik performa aplikasi.
Keterangan:
P95 merupakan salah satu metrik performa terpenting karena lebih mencerminkan pengalaman pengguna dibanding rata-rata response time (average latency).
Menguji Horizontal Pod Autoscaler (HPA)
Salah satu fitur unggulan Kubernetes adalah kemampuan Horizontal Pod Autoscaler (HPA) yang dapat menambah atau mengurangi jumlah pod secara otomatis berdasarkan penggunaan resource atau metrik tertentu.
Dengan autoscaling, aplikasi dapat menyesuaikan kapasitas secara dinamis ketika terjadi lonjakan trafik tanpa perlu melakukan intervensi manual.
- Contoh Konfigurasi Horizontal Pod Autoscaler
Misalnya terdapat deployment aplikasi web dengan konfigurasi HPA berikut:
apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler metadata: name: web-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: 70Fungsi Konfigurasi:
- Menjaga performa aplikasi saat trafik meningkat
- Menambah replica pod secara otomatis ketika CPU tinggi
- Mengurangi replica saat beban menurun
- Mengoptimalkan penggunaan resource cluster
- Penjelasan Parameter HPA
- scaleTargetRef
Deployment yang akan dikontrol oleh HPA. - name: web-app
Deployment target yang akan di-scale. - minReplicas: 2
Jumlah pod minimum yang selalu dipertahankan. - maxReplicas: 10
Jumlah pod maksimum yang dapat dibuat oleh Kubernetes. - averageUtilization: 70
Target penggunaan CPU rata-rata sebesar 70%.
Pada contoh ini:
- Minimal tersedia 2 pod
- Maksimal dapat bertambah hingga 10 pod
- Scaling aktif ketika rata-rata CPU mendekati atau melebihi 70%
Keterangan:
Agar HPA dapat bekerja dengan baik, deployment harus memiliki konfigurasi resources.requests.cpu dan biasanya juga resources.limits.cpu. - scaleTargetRef
- Monitoring Status HPA
Selama load testing menggunakan k6, pantau status autoscaling menggunakan:
kubectl get hpa -wFungsi:
- Melihat penggunaan CPU target secara realtime
- Memantau perubahan jumlah replica pod
- Memastikan autoscaling berjalan sesuai konfigurasi
Penjelasan Parameter:
- -w
Watch mode untuk menampilkan perubahan secara realtime.
- Contoh Output HPA
NAME TARGETS MINPODS MAXPODS REPLICAS web-hpa 82%/70% 2 10 4Interpretasi:
- 82%
Penggunaan CPU saat ini. - 70%
Target CPU yang ditentukan pada HPA. - MINPODS 2
Minimal dua pod selalu tersedia. - MAXPODS 10
Kubernetes dapat menambah hingga sepuluh pod. - REPLICAS 4
Saat ini terdapat empat pod yang aktif.
Karena penggunaan CPU mencapai 82% dan melebihi target 70%, Kubernetes secara otomatis menambah jumlah pod dari dua menjadi empat replica.
Keterangan:
Proses scaling tidak terjadi secara instan. Kubernetes membutuhkan waktu untuk mengumpulkan metrik dari Metrics Server, menghitung kebutuhan resource, kemudian membuat pod baru sesuai kebijakan HPA. - 82%
- Verifikasi Penambahan Pod
Untuk melihat pod baru yang dibuat oleh HPA:
kubectl get pods -wContoh:
web-app-abcde Running web-app-fghij Running web-app-abcde Running web-app-fghij Running web-app-klmno Running web-app-pqrst RunningAnalisa:
- Jumlah pod bertambah secara otomatis
- Load mulai didistribusikan ke pod baru
- CPU rata-rata deployment akan turun kembali mendekati target
- Aplikasi tetap mampu melayani trafik yang meningkat
Keterangan:
Kombinasi k6, Prometheus, dan HPA memungkinkan administrator menguji sekaligus memverifikasi kemampuan autoscaling Kubernetes dalam menangani lonjakan trafik secara otomatis.
Kesimpulan
Secara keseluruhan, penggunaan k6 sebagai alat load testing yang dikombinasikan dengan Prometheus sebagai sistem monitoring merupakan solusi yang efektif untuk menguji performa aplikasi di Kubernetes Cluster. Melalui pengujian ini, administrator dapat mengetahui kemampuan aplikasi dalam menangani lonjakan trafik, memantau penggunaan resource seperti CPU dan memori, serta memastikan mekanisme autoscaling berjalan sesuai harapan. Untuk mendapatkan hasil yang lebih akurat, load testing sebaiknya dijalankan dari server atau VPS terpisah di luar cluster sehingga beban dari k6 tidak memengaruhi metrik Kubernetes yang sedang dianalisis. Dengan melakukan pengujian dan monitoring secara berkala, stabilitas, skalabilitas, dan keandalan aplikasi dapat ditingkatkan sebelum digunakan pada lingkungan produksi.
