Merancang Arsitektur Laravel yang Siap Menangani Pertumbuhan Traffic dan Pengguna
Admin HijrahKreativa
Penulis
Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk
Admin HijrahKreativa
Penulis
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 flag untuk rilis bertahap, observabilitas, serta perencanaan kapasitas. Artikel ini merangkum dan menghubungkan seluruh seri Performance, Caching & Scalability.
Arsitektur yang "siap tumbuh" bukan berarti memasang Kubernetes, microservices, dan lima jenis database sejak hari pertama. Untuk aplikasi RW yang baru dipakai 3 RW, itu pemborosan biaya dan tenaga, dan justru memperlambat pengembangan fitur.
Arsitektur yang siap tumbuh adalah arsitektur yang:
Sebagian besar keputusan yang membuat aplikasi sulit diskalakan dibuat di awal dan murah untuk dihindari: menyimpan file di disk lokal, session di file, pekerjaan berat di request, tabel tanpa kolom tenant, query tanpa index, tidak ada pemantauan. Sebaliknya, keputusan "besar" seperti read replica atau memisahkan layanan bisa ditunda sampai benar-benar dibutuhkan, asalkan pondasinya tidak menghalangi.
Hasil akhir:
| Komponen | Versi |
|---|---|
| PHP | 8.3+ (disarankan 8.4) |
| Laravel | 13.x |
| MySQL | 8.4 |
| Redis | 7.x |
| Laravel Pennant | 1.x (feature flag) |
| Laravel Pulse / layanan APM | Untuk observabilitas |
Artikel ini mengasumsikan pembaca sudah mengikuti artikel lain di seri ini; bagian-bagian di bawah merujuk ke detailnya.
Tahap 0 Tahap 1 Tahap 2 Tahap 3
Satu server Data dipisah Banyak server web Skala data
┌──────────┐ ┌──────────┐ ┌────┐ ┌────┐ ┌─────┐
│Nginx+FPM │ │Nginx+FPM │ │ LB │ │ LB │ │ CDN │
│MySQL │ ──▶ │+ worker │ ──▶ └┬──┬┘ ──▶ └┬──┬┘ └─────┘
│Redis │ └────┬─────┘ web web worker web… worker…
│worker │ ┌────┴────┐ └──┬──┘ │
│cron │ │MySQL │ MySQL Redis S3 MySQL primary ─▶ replica(s)
└──────────┘ │Redis │ Redis (cache | data)
└─────────┘ S3, search engine
| Tahap | Kapan pindah ke tahap ini (sinyal) | Perubahan utama |
|---|---|---|
| 0: Satu server | Awal | Pondasi stateless sudah diterapkan (Langkah 2) |
| 1: Data dipisah | MySQL dan PHP berebut memori/CPU; backup memperlambat aplikasi; butuh ukuran server yang berbeda | MySQL & Redis di server/layanan terkelola sendiri |
| 2: Banyak server web | CPU web jenuh setelah optimasi; butuh ketersediaan tinggi/deploy tanpa downtime | Load balancer, ≥ 2 server web, server worker terpisah, S3 |
| 3: Skala data | Database menjadi bottleneck setelah query & index dioptimasi; laporan berat mengganggu transaksi | Read replica, pemisahan cache/data Redis, CDN, mesin pencari |
| 4: Pemisahan layanan | Tim dan domain tumbuh; bagian tertentu punya pola beban/rilis yang sangat berbeda | Modul tertentu menjadi layanan, berkomunikasi via event/API |
Hal terpenting dari tabel ini: setiap perpindahan tahap dipicu oleh sinyal dari metrik, bukan oleh perasaan "sudah waktunya". Dan sebelum naik tahap, pastikan optimasi di tahap sekarang sudah dilakukan (pemeriksaan performa, index, cache, queue). Naik tahap terlalu dini menambah biaya dan kerumitan operasional.
Daftar ini murah diterapkan di awal dan mahal diperbaiki belakangan.
| Pondasi | Implementasi | Mengapa dari awal |
|---|---|---|
| File di storage abstrak | Storage::disk(config('filesystems.default')); jangan public_path() untuk unggahan |
Pindah ke S3 cukup ganti konfigurasi |
| Session & cache di Redis | SESSION_DRIVER=redis, CACHE_STORE=redis |
Multi-server tanpa perubahan kode |
| Pekerjaan lambat di queue | Email, notifikasi, PDF, panggilan API luar | Request tetap cepat; worker bisa diskalakan terpisah |
Jadwal di routes/console.php + onOneServer() |
— | Aman saat server bertambah |
| Kolom tenant di setiap tabel milik tenant | rw_id + index komposit diawali rw_id |
Query per tenant tetap cepat saat data tenant lain bertambah |
| Index sesuai pola query | Ditinjau di setiap fitur baru | Tabel besar tidak tiba-tiba lambat |
| Timeout di semua panggilan keluar | Http::timeout() |
Satu layanan lambat tidak menjatuhkan semuanya |
| Job idempoten | Constraint unik, pengecekan status | Retry dan multi-worker aman |
| Konfigurasi lewat env | Tidak ada nilai lingkungan yang di-hardcode | Server baru = salin konfigurasi |
| Log terstruktur + request ID | Konteks JSON, korelasi | Penelusuran lintas server |
| Batas modul yang jelas | Kontrak & event antar-modul | Memisahkan layanan nanti tidak berarti menulis ulang |
Aplikasi RW adalah aplikasi multi-tenant: satu instalasi melayani banyak RW. Dengan 10 RW, tabel iuran berisi 100 ribu baris; dengan 500 RW, 5 juta baris. Query milik satu RW tidak boleh ikut melambat karena data RW lain.
Scope tenant otomatis:
// app/Models/Concerns/MilikRw.php
namespace App\Models\Concerns;
use App\Support\Tenancy\RwAktif;
use Illuminate\Database\Eloquent\Builder;
trait MilikRw
{
public static function bootMilikRw(): void
{
static::addGlobalScope('rw', function (Builder $query) {
if ($rwId = app(RwAktif::class)->id()) {
$query->where($query->getModel()->qualifyColumn('rw_id'), $rwId);
}
});
static::creating(function ($model) {
$model->rw_id ??= app(RwAktif::class)->id();
});
}
}
// app/Support/Tenancy/RwAktif.php — scoped binding, aman untuk Octane
final class RwAktif
{
private ?int $id = null;
public function set(int $id): void { $this->id = $id; }
public function id(): ?int { return $this->id; }
}
// AppServiceProvider::register()
$this->app->scoped(RwAktif::class);
// Middleware: tentukan RW aktif dari pengguna yang login
app(RwAktif::class)->set($request->user()->rw_id);
Index diawali kolom tenant: semua index komposit untuk query per tenant dimulai dengan rw_id, misalnya (rw_id, periode, status). Dengan begitu MySQL langsung "melompat" ke bagian data milik RW tersebut, dan ukuran tabel total hampir tidak berpengaruh.
Job dan command berjalan tanpa pengguna login, sehingga scope tidak aktif. Set RW aktif secara eksplisit di job yang memproses data tenant, atau query dengan where('rw_id', ...) secara eksplisit.
Bila suatu saat satu atau beberapa tenant sangat besar, pola ini juga memudahkan langkah lanjutan: memindahkan tenant tertentu ke database tersendiri.
Ketika database menjadi bottleneck setelah optimasi, dan sebagian besar beban adalah baca (dasbor, laporan, daftar), tambahkan replika baca.
// config/database.php
'mysql' => [
'driver' => 'mysql',
'read' => [
'host' => array_filter(explode(',', env('DB_READ_HOSTS', env('DB_HOST')))),
],
'write' => [
'host' => [env('DB_HOST', '127.0.0.1')],
],
'sticky' => true,
'port' => env('DB_PORT', '3306'),
'database' => env('DB_DATABASE'),
'username' => env('DB_USERNAME'),
'password' => env('DB_PASSWORD'),
// ...
],
// Koneksi khusus laporan: selalu ke replika
'mysql_laporan' => [
'driver' => 'mysql',
'host' => env('DB_REPORT_HOST', env('DB_HOST')),
'database' => env('DB_DATABASE'),
'username' => env('DB_REPORT_USERNAME', env('DB_USERNAME')),
'password' => env('DB_REPORT_PASSWORD', env('DB_PASSWORD')),
// ...
],
Aturan pemakaian:
sticky => true: setelah request menulis data, pembacaan berikutnya dalam request yang sama diarahkan ke primary. Ini mencegah kasus "saya baru menyimpan, tetapi datanya tidak muncul".$iuran = Iuran::useWritePdo()->findOrFail($id);
lockForUpdate().mysql_laporan yang menunjuk ke replika khusus, sehingga query agregat besar tidak mengganggu transaksi warga:$rekap = DB::connection('mysql_laporan')->table('transaksi_kas')->where('rw_id', $rwId)->...;
SELECT.Seconds_Behind_Source/Replica lag; beri peringatan bila melebihi ambang.Data transaksi bertambah setiap bulan dan tidak pernah berkurang dengan sendirinya. Rencanakan siklus hidupnya:
| Data | Strategi |
|---|---|
| Iuran & transaksi kas | Simpan permanen (catatan keuangan); index ber-tenant; ringkasan bulanan dipra-agregasi |
Log webhook, pesan WhatsApp, failed_jobs |
Prunable dengan masa simpan (misalnya 90 hari / 6 bulan) |
| Activity log | Pindahkan entri > 2 tahun ke tabel/arsip terpisah atau storage dingin |
| Notifikasi database | Hapus yang sudah dibaca > 90 hari |
| Token, session, cache | TTL otomatis |
Pra-agregasi: daripada menghitung ringkasan kas dari jutaan transaksi setiap kali dasbor dibuka, simpan ringkasan per RW per bulan di tabel tersendiri, diperbarui oleh listener saat transaksi dicatat dan dikoreksi ulang oleh job terjadwal:
Schema::create('ringkasan_kas_bulanan', function (Blueprint $table) {
$table->id();
$table->foreignId('rw_id');
$table->char('periode', 7);
$table->bigInteger('masuk')->default(0);
$table->bigInteger('keluar')->default(0);
$table->timestamp('dihitung_ulang_pada')->nullable();
$table->unique(['rw_id', 'periode']);
});
// Listener (queue, after commit): pembaruan inkremental yang atomik
DB::table('ringkasan_kas_bulanan')->upsert(
[['rw_id' => $e->rwId, 'periode' => $e->periode, 'masuk' => $e->nominal, 'keluar' => 0]],
['rw_id', 'periode'],
['masuk' => DB::raw('masuk + VALUES(masuk)')],
);
Sintaks VALUES() di klausa ON DUPLICATE KEY UPDATE sudah deprecated di MySQL 8 tetapi masih berfungsi, dan itulah yang dihasilkan grammar MySQL Laravel untuk upsert secara default. Bila koneksi diset 'use_upsert_alias' => true, Laravel memakai sintaks alias baru; sesuaikan ekspresinya (masuk + laravel_upsert_alias.masuk). Job rekonsiliasi malam menghitung ulang dari tabel transaksi untuk mengoreksi selisih.
Partisi tabel MySQL bisa membantu tabel yang sangat besar (misalnya partisi per tahun), tetapi tabel berpartisi di InnoDB tidak mendukung foreign key dan setiap unique key harus memuat kolom partisi. Untuk sebagian besar aplikasi Laravel, index ber-tenant, pra-agregasi, dan arsip memberi hasil yang cukup dengan kerumitan jauh lebih kecil.
Saat sebagian sistem bermasalah, aplikasi sebaiknya tetap berfungsi dengan kemampuan terbatas, bukan mati seluruhnya.
| Komponen bermasalah | Perilaku yang diinginkan |
|---|---|
| Redis cache mati | Aplikasi tetap jalan, membaca langsung dari database (lebih lambat) |
| Provider WhatsApp mati | Job menumpuk dan dicoba ulang nanti; fitur lain tidak terpengaruh |
| Payment gateway lambat | Halaman pembayaran menampilkan pesan, transaksi lain berjalan |
| Layanan laporan berat | Dasbor menampilkan data cache terakhir dengan label waktu |
| Database replika laporan mati | Menu laporan dinonaktifkan sementara; transaksi tetap jalan |
Contoh fallback cache:
// app/Support/Cache/CacheAman.php
final class CacheAman
{
public static function remember(string $kunci, int $ttl, \Closure $hitung): mixed
{
try {
return Cache::remember($kunci, $ttl, $hitung);
} catch (\Throwable $e) {
report($e); // Redis bermasalah: catat, lalu tetap layani
return $hitung();
}
}
}
Gunakan pola ini secara selektif: untuk data yang mahal dihitung, fallback ke database saat Redis mati bisa memindahkan seluruh beban ke database sekaligus. Dalam kasus itu, lebih baik tampilkan "data sedang tidak tersedia" untuk widget tersebut.
Untuk layanan eksternal, terapkan circuit breaker (lihat artikel HTTP Client) dan tampilkan status yang jujur kepada pengguna.
Lonjakan traffic (pengumuman disebar ke seluruh grup WhatsApp, bot, atau klien yang salah konfigurasi) bisa menghabiskan kapasitas. Batasi sebelum sistem tumbang:
// app/Providers/AppServiceProvider.php
RateLimiter::for('api', function (Request $request) {
return $request->user()
? Limit::perMinute(120)->by('user:'.$request->user()->id)
: Limit::perMinute(30)->by('ip:'.$request->ip());
});
RateLimiter::for('laporan', fn (Request $request) => [
Limit::perMinute(5)->by('user:'.$request->user()?->id),
Limit::perMinute(30), // batas global semua pengguna
]);
maxconn HAProxy) agar kelebihan diantrekan atau ditolak dengan cepat, bukan menumpuk sampai timeout.Fitur baru yang berat (misalnya dasbor statistik real-time) sebaiknya tidak langsung diaktifkan untuk 500 RW. Laravel Pennant memungkinkan rilis bertahap:
composer require laravel/pennant
php artisan vendor:publish --provider="Laravel\Pennant\PennantServiceProvider"
php artisan migrate
// app/Providers/AppServiceProvider.php
use Laravel\Pennant\Feature;
use Illuminate\Support\Lottery;
Feature::define('dasbor-real-time', fn (User $user) => match (true) {
$user->hasRole('super-admin') => true,
in_array($user->rw_id, config('fitur.rw_uji_coba'), true) => true,
default => Lottery::odds(1, 10), // 10% pengguna lain, ditentukan sekali lalu disimpan
});
@feature('dasbor-real-time')
<x-dasbor.real-time />
@else
<x-dasbor.statis />
@endfeature
Bila metrik memburuk setelah fitur diaktifkan, matikan tanpa deploy ulang:
php artisan pennant:purge dasbor-real-time # hapus nilai tersimpan, lalu ubah definisi/konfigurasi
Atau Feature::deactivateForEveryone('dasbor-real-time').
Tanpa data, setiap keputusan arsitektur adalah tebakan. Tiga pilar yang dibutuhkan:
| Pilar | Isi | Alat |
|---|---|---|
| Metrik | Waktu respons p95 per route, rps, error rate, antrean, CPU/memori, koneksi DB, replication lag | Laravel Pulse, Prometheus + Grafana, layanan APM |
| Log | Log terstruktur dengan request ID, pengguna, tenant | Log terpusat (Loki, ELK, layanan terkelola) |
| Tracing | Rincian satu request: query, cache, HTTP keluar, job | Telescope (non-production), APM/OpenTelemetry, Laravel Nightwatch, Sentry |
Tambahkan konteks ke semua log dan job dengan facade Context, yang otomatis ikut terbawa ke job yang di-dispatch:
// Middleware
use Illuminate\Support\Facades\Context;
Context::add('request_id', $request->header('X-Request-Id') ?? (string) Str::uuid());
Context::add('rw_id', $request->user()?->rw_id);
Tetapkan SLO (service level objective) yang menjadi acuan keputusan:
| SLO | Target |
|---|---|
| Ketersediaan halaman warga | 99,5% per bulan |
| p95 halaman warga | < 500 ms |
| p95 API mobile | < 300 ms |
Waktu tunggu antrean kritis |
< 10 detik |
| Pengingat iuran terkirim | 100% dalam 6 jam setelah dijadwalkan |
Ketika SLO mulai terlewati secara konsisten, itulah sinyal untuk optimasi atau naik tahap (Langkah 1).
Lakukan secara berkala (misalnya tiap kuartal) dan sebelum periode puncak:
rps puncak saat ini : 45 rps (tanggal 10, 09:00–10:00)
pertumbuhan pengguna : ×2,5 dalam 12 bulan
rps puncak proyeksi : ≈ 113 rps
kapasitas per server web : ≈ 110 rps sebelum p95 > 1 s → pakai 70% = 77 rps aman
server web dibutuhkan : 113 / 77 ≈ 1,5 → 2 server (+1 untuk redundansi = 3)
Keputusan besar (menambah replika, memakai Octane, memisahkan modul) sebaiknya didokumentasikan singkat agar alasannya tidak hilang ketika tim berganti.
# ADR-007: Read replica untuk laporan kas
- Status: Diterima — 19 Oktober 2026
- Konteks: Laporan tahunan (query agregat 2–4 s) dijalankan bersamaan oleh banyak bendahara
di awal bulan; p95 halaman warga naik dari 280 ms ke 1,6 s pada jam itu.
Index dan pra-agregasi sudah diterapkan (ADR-004).
- Keputusan: Tambah satu replika MySQL; koneksi `mysql_laporan` untuk semua query laporan.
- Konsekuensi:
+ Laporan tidak lagi membebani primary.
− Laporan bisa tertinggal beberapa detik (replication lag) → ditampilkan label "data per jam ...".
− Biaya server bertambah; pemantauan lag wajib.
- Alternatif yang ditolak: memperbesar server DB (hanya menunda; laporan tetap bersaing dengan transaksi).
Pondasi (semua tahap)
php artisan optimize, OPcache, reload saat deploy.Sebelum banyak server (tahap 2)
APP_KEY dan konfigurasi identik di semua server.trustProxies terkonfigurasi.onOneServer().Sebelum skala data (tahap 3)
Operasional
Beberapa prinsip bisa dijaga oleh test otomatis:
// tests/Arch/ArsitekturTest.php
arch('controller tidak memanggil Mail/HTTP secara langsung')
->expect('App\Http\Controllers')
->not->toUse(['Illuminate\Support\Facades\Mail', 'Illuminate\Support\Facades\Http']);
arch('model tenant memakai trait MilikRw')
->expect(['App\Modules\Iuran\Models\Iuran', 'App\Modules\Kas\Models\TransaksiKas'])
->toUseTrait('App\Models\Concerns\MilikRw');
arch('tidak ada env() di luar config')
->expect('env')
->not->toBeUsedIn('App');
// tests/Feature/Tenancy/IsolasiTest.php
it('pengurus RW A tidak bisa melihat iuran RW B', function () {
$rwA = RukunWarga::factory()->create();
$rwB = RukunWarga::factory()->create();
$iuranB = Iuran::factory()->for($rwB, 'rukunWarga')->create();
$pengurusA = User::factory()->for($rwA, 'rukunWarga')->create()->assignRole('pengurus');
$this->actingAs($pengurusA)->getJson("/api/v1/iuran/{$iuranB->id}")->assertNotFound();
});
| Error / Gejala | Penyebab | Solusi |
|---|---|---|
| Menambah server web tidak menambah kapasitas | Bottleneck di database | Optimasi query/index, pra-agregasi, read replica |
| Data baru tidak muncul setelah simpan | Replication lag | sticky, useWritePdo() untuk halaman setelah simpan |
| Query satu RW makin lambat seiring RW bertambah | Index tidak diawali rw_id |
Index komposit ber-tenant |
| Data RW lain bocor di job/command | Global scope tidak aktif tanpa login | Set tenant di job atau filter eksplisit |
| Aplikasi mati total saat Redis mati | Tidak ada fallback, session/queue tergantung Redis | Fallback cache selektif; Redis data dengan ketersediaan tinggi |
| Fitur baru membuat server jenuh | Rilis ke semua pengguna sekaligus | Feature flag, rilis bertahap |
| Tidak tahu kapan harus menambah server | Tidak ada metrik/SLO | Pulse/APM, SLO, perencanaan kapasitas |
| Lonjakan bot menjatuhkan aplikasi | Tidak ada pembatasan | Rate limiter per pengguna/IP dan global |
| Keputusan arsitektur lama tidak dipahami | Tidak terdokumentasi | ADR |
| Biaya infrastruktur naik tanpa peningkatan | Skala sebelum optimasi | Ukur dulu; ikuti sinyal tahapan |
Keamanan
SELECT.Performa
Maintainability
| Komponen | Versi |
|---|---|
| Laravel | 13.x |
| PHP | 8.4 |
| MySQL | 8.4 |
| Redis | 7.x |
| Laravel Pennant | 1.x |
| Pest | 4.x |
| Tanggal | 19 Oktober 2026 |
Sebelumnya
Cara Mengukur Performa Laravel Menggunakan ApacheBench, k6, dan Laravel Telescope
Berikutnya
PROSEDUR KONFIGURASI SSH KEY GITHUB PADA SERVER UBUNTU
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.
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 angga...
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