Cara Mengukur Performa Laravel Menggunakan ApacheBench, k6, dan Laravel Telescope
Admin HijrahKreativa
Penulis
Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk
Admin HijrahKreativa
Penulis
Menyiapkan lingkungan uji yang jujur, mengukur satu endpoint dengan ApacheBench, mensimulasikan perilaku pengguna sungguhan dengan k6 (skenario, threshold, autentikasi token), menelusuri penyebab request lambat dengan Telescope, memantau server selama pengujian, serta menulis laporan hasil dan anggaran performa di CI.
"Aplikasinya sudah cepat kok, di laptop saya cuma 200 ms." Kalimat ini tidak menjawab pertanyaan yang penting:
Ketiga alat di artikel ini menjawab pertanyaan yang berbeda:
| Alat | Pertanyaan yang dijawab | Kekuatan | Keterbatasan |
|---|---|---|---|
ApacheBench (ab) |
"Berapa rps dan latensi satu URL pada N koneksi bersamaan?" | Terpasang di banyak server, satu baris perintah | Satu URL, HTTP/1.0, tanpa skenario |
| k6 | "Bagaimana sistem berperilaku saat pengguna melakukan alur nyata dengan pola beban tertentu?" | Skrip JavaScript, skenario, threshold, cocok untuk CI | Perlu menulis skrip |
| Telescope | "Request ini lambat karena apa? Query mana, berapa kali?" | Detail per request: query, cache, job, log | Tidak untuk mengukur beban; overhead tinggi |
Hasil akhir:
ab dan cara membaca hasilnya,| Komponen | Versi |
|---|---|
| PHP | 8.3+ (disarankan 8.4) |
| Laravel | 13.x |
| ApacheBench | 2.3 (paket apache2-utils) |
| k6 | 2.x (rilis terbaru saat penulisan: 2.3) |
| Laravel Telescope | 5.x |
| Laravel Pulse | 1.x (opsional) |
| Laravel Sanctum | 4.x (token API untuk pengujian) |
Hasil load test hanya berguna bila lingkungannya mendekati production:
| Aspek | Wajib |
|---|---|
| Server | Spesifikasi dan konfigurasi sama (PHP-FPM, OPcache, Nginx) dengan production, atau perbandingannya diketahui |
| Konfigurasi Laravel | APP_ENV=production, APP_DEBUG=false, php artisan optimize |
| Data | Volume realistis (ratusan ribu baris iuran, ribuan keluarga), bukan database kosong |
| Paket debug | Debugbar mati; Telescope mati saat load test (lihat Langkah 7) |
| Layanan eksternal | Payment gateway, WhatsApp, email diarahkan ke sandbox/fake agar tidak mengirim pesan sungguhan |
| Mesin penguji | Terpisah dari server yang diuji, di jaringan yang dekat |
Isi data uji dengan seeder khusus:
// database/seeders/DataBebanSeeder.php
public function run(): void
{
$rw = RukunWarga::factory()->count(30)->create();
$rw->each(function ($rw) {
$rts = RukunTetangga::factory()->count(8)->for($rw)->create();
$rts->each(fn ($rt) => Keluarga::factory()->count(60)->for($rt)
->has(Iuran::factory()->count(24)->sequence(fn ($s) => [
'periode' => now()->subMonths($s->index)->format('Y-m'),
]))
->create());
});
// Pengguna uji dengan token Sanctum yang bisa dipakai k6
User::factory()->count(200)->create()->each(function ($u, $i) {
$u->assignRole('warga');
Storage::append('beban/token.csv', $u->createToken('k6', ['iuran:read', 'pengumuman:read'])->plainTextToken);
});
}
Sekitar 30 × 8 × 60 = 14.400 keluarga dan 345.600 baris iuran. Seeder sebesar ini memakan waktu; jalankan sekali dan simpan snapshot database staging.
Jangan menjalankan load test terhadap production kecuali terencana, di luar jam sibuk, dengan persetujuan, dan dengan rencana menghentikan pengujian.
sudo apt install apache2-utils
# 1.000 request, 20 bersamaan, endpoint publik
ab -n 1000 -c 20 -k https://staging.rw.example.id/pengumuman
# Endpoint API dengan token
ab -n 1000 -c 20 -k \
-H "Authorization: Bearer 12|abcdef..." \
-H "Accept: application/json" \
https://staging.rw.example.id/api/v1/tagihan-saya
Hasil (diringkas):
Concurrency Level: 20
Time taken for tests: 9.812 seconds
Complete requests: 1000
Failed requests: 0
Non-2xx responses: 0
Requests per second: 101.92 [#/sec] (mean)
Time per request: 196.240 [ms] (mean)
Time per request: 9.812 [ms] (mean, across all concurrent requests)
Percentage of the requests served within a certain time (ms)
50% 171
66% 188
75% 203
90% 262
95% 318
98% 455
99% 602
100% 1210 (longest request)
Cara membaca:
ab menganggap respons dengan panjang berbeda sebagai "gagal" (Length). Untuk halaman dinamis yang panjangnya bervariasi (misalnya ada timestamp), angka ini bisa menyesatkan; perhatikan Non-2xx responses untuk error sebenarnya.429, Anda sedang menguji rate limiter, bukan aplikasi.Naikkan konkurensi bertahap (-c 10, 20, 50, 100) dan catat kapan p95 melonjak atau error muncul. Itulah titik jenuh.
Keterbatasan ab: hanya satu URL, tidak ada alur, dan HTTP/1.0. Untuk perbandingan sebelum/sesudah optimasi pada satu endpoint, ab sudah cukup.
# Debian/Ubuntu
sudo gpg --no-default-keyring --keyring /usr/share/keyrings/k6-archive-keyring.gpg \
--keyserver hkp://keyserver.ubuntu.com:80 --recv-keys C5AD17C747E3415A3642D57D77C6C491D6AC1D69
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.list
sudo apt update && sudo apt install k6
# atau Docker
docker run --rm -i grafana/k6 run - < skrip.js
k6 version
Kunci GPG dan URL repositori bisa berubah; ikuti petunjuk instalasi di dokumentasi resmi k6 bila perintah di atas gagal.
// tests/beban/alur-warga.js
import http from 'k6/http';
import { check, group, sleep } from 'k6';
import { SharedArray } from 'k6/data';
import { Trend } from 'k6/metrics';
const BASE = __ENV.BASE_URL || 'https://staging.rw.example.id';
// Token dibaca sekali dan dibagi ke semua VU
const tokens = new SharedArray('token', () => open('./token.csv').split('\n').filter(Boolean));
const waktuTagihan = new Trend('waktu_tagihan', true);
export const options = {
scenarios: {
beban_normal: {
executor: 'ramping-vus',
startVUs: 0,
stages: [
{ duration: '2m', target: 50 }, // naik
{ duration: '5m', target: 50 }, // stabil
{ duration: '1m', target: 0 }, // turun
],
gracefulRampDown: '30s',
},
},
thresholds: {
http_req_failed: ['rate<0.01'], // < 1% error
http_req_duration: ['p(95)<500', 'p(99)<1200'], // ms
'http_req_duration{halaman:tagihan}': ['p(95)<400'],
checks: ['rate>0.99'],
},
};
export default function () {
const token = tokens[(__VU - 1) % tokens.length];
const params = {
headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
};
group('lihat tagihan', () => {
const res = http.get(`${BASE}/api/v1/tagihan-saya`, { ...params, tags: { halaman: 'tagihan' } });
check(res, {
'status 200': (r) => r.status === 200,
'ada data': (r) => Array.isArray(r.json('data')),
});
waktuTagihan.add(res.timings.duration);
});
sleep(Math.random() * 3 + 2); // jeda berpikir 2–5 detik, seperti pengguna sungguhan
group('lihat pengumuman', () => {
const res = http.get(`${BASE}/api/v1/pengumuman?per_page=10`, { ...params, tags: { halaman: 'pengumuman' } });
check(res, { 'status 200': (r) => r.status === 200 });
});
sleep(Math.random() * 3 + 2);
}
cp storage/app/private/beban/token.csv tests/beban/token.csv # disk 'local' Laravel 11+ berakar di storage/app/private
k6 run -e BASE_URL=https://staging.rw.example.id tests/beban/alur-warga.js
Ringkasan hasil k6 menampilkan http_req_duration (avg, p90, p95), http_reqs (rps), http_req_failed, hasil checks, dan apakah setiap threshold lolos (✓) atau gagal (✗). Bila ada threshold gagal, k6 run keluar dengan kode bukan nol, sehingga cocok untuk CI.
Mengapa token Sanctum, bukan login form? Login form berbasis session membutuhkan alur cookie dan CSRF yang lebih rumit, dan endpoint login biasanya dibatasi rate limiter. Untuk mengukur halaman setelah login, token API yang dibuat oleh seeder lebih sederhana. Bila yang diuji adalah halaman Blade berbasis session, k6 menyimpan cookie per VU secara otomatis; ambil token CSRF dari halaman login terlebih dahulu.
| Jenis | Tujuan | Pola |
|---|---|---|
| Smoke | Skrip dan sistem berfungsi | 1–2 VU, 1 menit |
| Load | Perilaku pada beban normal/puncak yang diharapkan | Naik ke target, tahan 5–30 menit |
| Stress | Menemukan titik jenuh | Naik bertahap melewati target sampai error |
| Spike | Lonjakan mendadak (pengumuman disebar di grup WhatsApp) | Dari rendah ke sangat tinggi dalam detik |
| Soak | Kebocoran memori, degradasi jangka panjang | Beban sedang selama berjam-jam |
Skenario berbasis laju kedatangan lebih realistis untuk menguji kapasitas: k6 menjaga jumlah request per detik tetap, berapa pun lambatnya server.
export const options = {
scenarios: {
stress: {
executor: 'ramping-arrival-rate',
startRate: 10,
timeUnit: '1s',
preAllocatedVUs: 100,
maxVUs: 500,
stages: [
{ duration: '2m', target: 50 },
{ duration: '2m', target: 100 },
{ duration: '2m', target: 150 },
{ duration: '2m', target: 200 },
{ duration: '1m', target: 0 },
],
},
lonjakan: {
executor: 'constant-arrival-rate',
rate: 300,
timeUnit: '1s',
duration: '30s',
preAllocatedVUs: 300,
startTime: '10m', // setelah skenario stress selesai
},
},
};
Dengan skenario *-vus, bila server melambat, setiap VU juga mengirim lebih jarang sehingga beban otomatis "mengalah". Skenario *-arrival-rate tidak mengalah, sehingga lebih jujur memperlihatkan kapan sistem kewalahan.
Load test tanpa melihat sisi server hanya memberi tahu bahwa sistem lambat, bukan mengapa.
# Server aplikasi
htop
vmstat 2 # CPU, swap (si/so), antrean run (r)
watch -n 2 "curl -s 127.0.0.1/fpm-status | grep -E 'listen queue|active|max children'"
# Database
mysql -e "SHOW GLOBAL STATUS LIKE 'Threads_running';"
mysql -e "SHOW PROCESSLIST;" | grep -v Sleep | head -30
sudo tail -f /var/log/mysql/slow.log
# Redis
redis-cli --latency
redis-cli INFO stats | grep instantaneous_ops_per_sec
| Gejala saat beban naik | Kemungkinan bottleneck |
|---|---|
| CPU server aplikasi ~100% | Kode PHP berat, bootstrap, rendering; pertimbangkan cache, Octane, atau tambah server |
CPU rendah, listen queue FPM tinggi |
Worker menunggu I/O (DB, API eksternal) |
Threads_running MySQL tinggi, slow log ramai |
Query/index |
Swap aktif (si/so > 0) |
Memori kurang; max_children terlalu besar |
| Error 429 | Rate limiter aplikasi (pastikan disesuaikan atau dikecualikan untuk pengujian) |
| Error 502/504 | PHP-FPM penuh, timeout |
Telescope merekam setiap request beserta query, cache hit/miss, job, event, log, dan exception di dalamnya. Ini alat untuk menjawab "mengapa request ini lambat".
composer require laravel/telescope --dev
php artisan telescope:install
php artisan migrate
Bila dipasang sebagai dependensi --dev, daftarkan hanya di lingkungan lokal dan cegah auto-discovery:
// composer.json
"extra": {
"laravel": {
"dont-discover": ["laravel/telescope"]
}
}
// app/Providers/AppServiceProvider.php
public function register(): void
{
if ($this->app->environment('local') && class_exists(\Laravel\Telescope\TelescopeServiceProvider::class)) {
$this->app->register(\Laravel\Telescope\TelescopeServiceProvider::class);
$this->app->register(TelescopeServiceProvider::class);
}
}
Hapus juga App\Providers\TelescopeServiceProvider::class dari bootstrap/providers.php (ditambahkan otomatis oleh telescope:install), karena sekarang didaftarkan secara kondisional.
Atur ambang query lambat agar mudah terlihat:
// config/telescope.php
'watchers' => [
Watchers\QueryWatcher::class => [
'enabled' => env('TELESCOPE_QUERY_WATCHER', true),
'ignore_packages' => true,
'ignore_paths' => [],
'slow' => 100, // ms; query di atas ini ditandai "slow"
],
// ...
],
Cara memakai saat investigasi:
/telescope/requests, buka request tersebut: durasi total, memori, dan tab Queries.EXPLAIN di MySQL.Matikan Telescope saat load test. Telescope menulis beberapa baris ke database untuk setiap request; di bawah beban, overhead-nya merusak hasil pengukuran dan bisa membebani database. Gunakan Telescope untuk menganalisis beberapa request contoh, bukan ribuan.
Bila Telescope dipakai di staging bersama, lindungi dengan gate dan batasi yang direkam:
// app/Providers/TelescopeServiceProvider.php
Telescope::filter(function (IncomingEntry $entry) {
return $this->app->environment('local')
|| $entry->isReportableException()
|| $entry->isFailedJob()
|| $entry->isSlowQuery()
|| $entry->hasMonitoredTag();
});
Gate::define('viewTelescope', fn ($user) => $user->hasRole('super-admin'));
Dan jadwalkan pembersihan: Schedule::command('telescope:prune --hours=48')->daily();.
Laravel Pulse merekam data agregat secara ringan (dengan sampling): endpoint paling lambat, query paling lambat, job paling lambat, pemakaian server, dan pengguna paling aktif. Pulse dirancang untuk production dan cocok dinyalakan selama load test di staging untuk melihat gambaran besarnya.
composer require laravel/pulse
php artisan vendor:publish --provider="Laravel\Pulse\PulseServiceProvider"
php artisan migrate
php artisan pulse:check # jalankan sebagai proses (Supervisor) untuk kartu server
PULSE_SLOW_REQUESTS_THRESHOLD=500
PULSE_SLOW_QUERIES_THRESHOLD=100
PULSE_SLOW_JOBS_THRESHOLD=1000
Setelah load test, dasbor /pulse langsung menunjukkan endpoint dan query mana yang paling banyak menyumbang waktu.
Laporan yang konsisten memudahkan perbandingan antar-rilis:
## Load Test: Alur Warga — 19 Oktober 2026
**Lingkungan:** staging (2 vCPU / 4 GB, PHP 8.4-FPM max_children=25, MySQL 8.4 terpisah)
**Data:** 14.400 keluarga, 345.600 iuran
**Skenario:** ramping-vus 0 → 50 VU (2 m), tahan 5 m; jeda berpikir 2–5 s
**Commit:** a1b2c3d
| Metrik | Target | Hasil | Status |
|---|---|---|---|
| p95 semua request | < 500 ms | 342 ms | ✓ |
| p95 /tagihan-saya | < 400 ms | 288 ms | ✓ |
| Error rate | < 1% | 0,2% | ✓ |
| Throughput | — | 14,6 rps | — |
**Titik jenuh (stress):** p95 > 1 s mulai pada ±110 rps; FPM `listen queue` naik, CPU 95%.
**Temuan:** query `whereHas('iuran')` di /tagihan-saya 120 ms → tambah index (keluarga_id, status).
**Tindak lanjut:** ulangi setelah index; target titik jenuh > 150 rps.
Jalankan skrip k6 ringan (smoke) di pipeline terhadap lingkungan staging setelah deploy. Threshold yang gagal membuat pipeline gagal:
# .github/workflows/performa.yml
name: Performa
on:
workflow_run:
workflows: ["Deploy Staging"]
types: [completed]
jobs:
k6-smoke:
if: ${{ github.event.workflow_run.conclusion == 'success' }}
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: grafana/setup-k6-action@v1
- name: Tulis token uji
run: echo "${{ secrets.K6_TOKENS }}" > tests/beban/token.csv
- name: Smoke test performa
uses: grafana/run-k6-action@v1
env:
BASE_URL: https://staging.rw.example.id
with:
path: tests/beban/smoke.js
// tests/beban/smoke.js
export const options = {
vus: 5,
duration: '1m',
thresholds: {
http_req_failed: ['rate<0.01'],
http_req_duration: ['p(95)<600'],
},
};
// ... alur yang sama, versi ringkas
Periksa versi action k6 terbaru di GitHub Marketplace sebelum memakai. Anggaran ini tidak menggantikan load test penuh, tetapi menangkap regresi besar (misalnya N+1 baru yang membuat p95 dua kali lipat) sebelum sampai ke production.
| Error / Gejala | Penyebab | Solusi |
|---|---|---|
ab melaporkan banyak Failed requests (Length) |
Panjang respons dinamis berbeda-beda | Abaikan Length; lihat Non-2xx responses |
Banyak 429 saat pengujian |
Rate limiter aplikasi | Naikkan batas untuk token uji di staging, atau uji dengan banyak pengguna |
Banyak 419 |
CSRF/session pada form | Uji API dengan token, atau ambil token CSRF di skrip |
| Hasil jauh lebih baik dari production | Data staging sedikit, cache panas | Data realistis; uji juga kondisi cache dingin |
| Hasil berubah-ubah antar-run | Mesin penguji lemah, jaringan, proses lain | Mesin penguji terpisah; ulangi 3 kali dan ambil median |
k6 kehabisan VU (Insufficient VUs) |
preAllocatedVUs/maxVUs terlalu kecil untuk laju tersebut |
Naikkan VU; artinya server melambat |
| Database staging membengkak setelah uji | Telescope aktif | Matikan Telescope saat load test; telescope:prune |
| Pesan WhatsApp/email terkirim saat pengujian | Layanan eksternal tidak di-fake | Driver log/sandbox di staging |
| k6 menyerang production tanpa sengaja | BASE_URL salah |
Default ke staging; tolak domain production di skrip |
k6 cloud script.js tidak dikenali |
Perintah berubah di k6 2.x | Gunakan k6 cloud run script.js |
Keamanan
Performa
Maintainability
tests/beban/) dan diperlakukan seperti kode.| Komponen | Versi |
|---|---|
| Laravel | 13.x |
| PHP | 8.4 |
| ApacheBench | 2.3 |
| k6 | 2.3 |
| Laravel Telescope | 5.x |
| Laravel Pulse | 1.x |
| Tanggal | 19 Oktober 2026 |
Sebelumnya
Laravel Octane vs PHP-FPM: Perbedaan, Kelebihan, Risiko, dan Skenario Penggunaan
Berikutnya
Merancang Arsitektur Laravel yang Siap Menangani Pertumbuhan Traffic dan Pengguna
Dokumen ini menjelaskan prosedur konfigurasi autentikasi SSH Key antara server Ubuntu dan GitHub untuk memungkinkan server melakukan operasi Git, seperti clone, pull, dan fetch tanpa menggunakan username dan password akun GitHub.
Peta jalan arsitektur dari satu server hingga banyak server: tahapan pertumbuhan dan sinyal kapan naik tahap, prinsip yang sebaiknya diterapkan sejak awal (stateless, asinkron, data ber-tenant), read replica, pengelolaan data yang terus tumbuh, degradasi yang anggun saat layanan bermasalah, feature...
Bagaimana Octane membuat Laravel lebih cepat dengan mem-boot aplikasi sekali dan menyimpannya di memori, apa yang sebenarnya dipercepat (dan yang tidak), risiko kebocoran state antar-request yang wajib dipahami, cara memeriksa kode agar aman untuk Octane, pemasangan dengan FrankenPHP di production,...
Dari "worker sudah jalan" menjadi "puluhan ribu job per jam tetap terkendali": mengukur throughput dan waktu tunggu, menghitung jumlah worker, auto-balancing Horizon, merancang job yang kecil dan ringan, fan-out bertahap, pembatasan laju ke API eksternal tanpa menghabiskan percobaan, mencegah antrea...
03 Nov 2026
19 Oct 2026
19 Oct 2026
19 Oct 2026
19 Oct 2026
19 Oct 2026
19 Oct 2026
19 Oct 2026
19 Oct 2026
19 Oct 2026
HijrahKreativa
Kami balas secepatnya
Masuk dulu untuk chat dengan tim kami. Riwayat chat Anda tersimpan di akun.
Masuk