Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk

Blog / Performance, Caching & Scalability / Cara Mengukur Performa Laravel...
Performance, Caching & Scalability

Cara Mengukur Performa Laravel Menggunakan ApacheBench, k6, dan Laravel Telescope

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
13 min read
52 views

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.

Overview

"Aplikasinya sudah cepat kok, di laptop saya cuma 200 ms." Kalimat ini tidak menjawab pertanyaan yang penting:

  • Berapa waktu respons saat 200 warga membuka aplikasi bersamaan pada tanggal 10?
  • Pada beban berapa server mulai mengembalikan error?
  • Setelah optimasi kemarin, apakah benar lebih cepat, dan seberapa?
  • Request mana yang lambat, dan lambat di bagian mana?

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:

  • lingkungan uji yang hasilnya bisa dipercaya,
  • benchmark cepat dengan ab dan cara membaca hasilnya,
  • skrip k6 untuk alur warga (login token, lihat tagihan, lihat pengumuman) dengan skenario load, stress, dan spike,
  • Telescope untuk diagnosis, plus Pulse untuk agregat di bawah beban,
  • daftar metrik server yang dipantau selama pengujian,
  • templat laporan dan threshold k6 sebagai anggaran performa di CI.

Prerequisites

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)

Step-by-step Tutorial

Langkah 1: Siapkan Lingkungan Uji yang Jujur

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.

Langkah 2: ApacheBench untuk Pengukuran Cepat

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:

  • Requests per second: throughput pada tingkat konkurensi ini.
  • Time per request (mean): latensi rata-rata yang dialami satu klien.
  • Persentil: lebih penting dari rata-rata. Di contoh, 95% request selesai ≤ 318 ms, tetapi 1% pengguna menunggu lebih dari 600 ms.
  • Failed requests: 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.
  • Non-2xx responses: 4xx/5xx. Bila banyak 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.

Langkah 3: Pasang k6

# 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.

Langkah 4: Skrip k6 Alur Warga

// 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.

Langkah 5: Jenis Pengujian dengan Skenario k6

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.

Langkah 6: Pantau Server Selama Pengujian

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

Langkah 7: Telescope untuk Diagnosis per Request

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:

  1. Buka halaman yang lambat sekali.
  2. Di /telescope/requests, buka request tersebut: durasi total, memori, dan tab Queries.
  3. Cari pola: query yang sama berulang puluhan kali (N+1), query bertanda slow, banyak cache miss.
  4. Salin query lambat dan jalankan 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();.

Langkah 8: Pulse untuk Agregat di Bawah Beban

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.

Langkah 9: Tulis Laporan Hasil

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.

Langkah 10: Anggaran Performa di CI

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.

Troubleshooting

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

Best Practices

Keamanan

  • Jangan load test production tanpa rencana dan persetujuan.
  • Token uji memiliki ability terbatas (hanya baca) dan dicabut setelah pengujian.
  • Telescope tidak aktif bebas di production; bila dipakai, dengan gate dan filter.
  • Token dan URL disimpan sebagai secret CI, bukan di repository.

Performa

  • Ukur persentil (p95, p99), bukan hanya rata-rata.
  • Skenario arrival-rate untuk menemukan kapasitas sebenarnya.
  • Selalu pantau server selama pengujian untuk menemukan penyebab, bukan hanya gejala.
  • Data uji dengan volume realistis.

Maintainability

  • Skrip k6 disimpan di repository (tests/beban/) dan diperlakukan seperti kode.
  • Laporan dengan format tetap per pengujian, menyebut commit dan lingkungan.
  • Smoke test performa di CI sebagai anggaran performa.
  • Ulangi pengujian setelah perubahan besar dan sebelum periode puncak.

Related Articles

Last Tested

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

Bagikan artikel:

Artikel lainnya