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

Blog / Performance, Caching & Scalability / Merancang Arsitektur Laravel y...
Performance, Caching & Scalability

Merancang Arsitektur Laravel yang Siap Menangani Pertumbuhan Traffic dan Pengguna

AD

Admin HijrahKreativa

Penulis

19 Oct 2026
15 min read
53 views

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.

Overview

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:

  1. sederhana untuk skala sekarang,
  2. tidak menutup jalan ke skala berikutnya, dan
  3. memberi tahu kapan skala berikutnya dibutuhkan (lewat metrik).

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:

  • peta tahapan pertumbuhan dengan sinyal yang memicu tiap tahap,
  • prinsip pondasi yang diterapkan sejak tahap 0,
  • konfigurasi read replica dan aturan pemakaiannya,
  • strategi data yang terus tumbuh (indeks ber-tenant, arsip, pruning),
  • pola degradasi anggun, feature flag, dan pembatasan beban,
  • kerangka observabilitas dan perencanaan kapasitas,
  • daftar periksa arsitektur dan templat catatan keputusan (ADR).

Prerequisites

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.

Step-by-step Tutorial

Langkah 1: Tahapan Pertumbuhan

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.

Langkah 2: Pondasi Sejak Tahap 0

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

Langkah 3: Data Ber-tenant yang Tetap Cepat

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.

Langkah 4: Read Replica

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".
  • Replication lag: replika bisa tertinggal beberapa ratus milidetik atau lebih. Pada request berikutnya (redirect setelah simpan), pembacaan kembali ke replika dan data terbaru mungkin belum ada. Untuk halaman yang langsung menampilkan hasil simpan, paksa baca dari primary:
$iuran = Iuran::useWritePdo()->findOrFail($id);
  • Keputusan transaksional (cek saldo, cek status pembayaran sebelum memperbarui) selalu dari primary, idealnya di dalam transaksi dengan lockForUpdate().
  • Laporan berat memakai koneksi 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)->...;
  • Pengguna database untuk replika laporan cukup punya hak SELECT.
  • Pantau Seconds_Behind_Source/Replica lag; beri peringatan bila melebihi ambang.

Langkah 5: Data yang Terus Tumbuh

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.

Langkah 6: Degradasi yang Anggun

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.

Langkah 7: Melindungi Sistem dari Beban Berlebih

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
]);
  • Endpoint mahal (ekspor, laporan) punya batas tersendiri, termasuk batas global.
  • Pekerjaan berat dijalankan lewat queue dengan jumlah worker terbatas, sehingga beban database dari laporan tetap terkendali berapa pun permintaannya.
  • Di load balancer, batasi koneksi per server (maxconn HAProxy) agar kelebihan diantrekan atau ditolak dengan cepat, bukan menumpuk sampai timeout.

Langkah 8: Rilis Bertahap dengan Feature Flag

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').

Langkah 9: Observabilitas

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

Langkah 10: Perencanaan Kapasitas

Lakukan secara berkala (misalnya tiap kuartal) dan sebelum periode puncak:

  1. Ukur beban saat ini pada jam tersibuk: rps puncak, p95, pemakaian CPU/memori, koneksi DB, ukuran data.
  2. Proyeksikan pertumbuhan: jumlah RW/pengguna yang diharapkan 6–12 bulan ke depan.
  3. Ketahui titik jenuh dari stress test (misalnya ±110 rps per server web).
  4. Hitung kebutuhan:
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)
  1. Periksa komponen bersama: apakah database sanggup dengan beban ×2,5? Biasanya inilah yang lebih dulu jenuh.
  2. Catat asumsi dan hasilnya agar bisa dibandingkan dengan kenyataan.

Langkah 11: Catat Keputusan Arsitektur (ADR)

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

Langkah 12: Daftar Periksa Arsitektur

Pondasi (semua tahap)

  • ☐ Session, cache, queue di Redis; file di storage abstrak (siap S3).
  • ☐ Pekerjaan lambat di queue, job idempoten.
  • ☐ Timeout di semua panggilan keluar; circuit breaker untuk layanan penting.
  • ☐ Kolom tenant + index komposit diawali tenant.
  • ☐ php artisan optimize, OPcache, reload saat deploy.
  • ☐ Log terstruktur dengan request ID dan tenant.

Sebelum banyak server (tahap 2)

  • ☐ APP_KEY dan konfigurasi identik di semua server.
  • ☐ trustProxies terkonfigurasi.
  • ☐ Scheduler hanya di satu server atau onOneServer().
  • ☐ Health check bermakna.
  • ☐ Migrasi kompatibel mundur untuk deploy bergilir.

Sebelum skala data (tahap 3)

  • ☐ Query lambat sudah dioptimasi dan diukur.
  • ☐ Pra-agregasi untuk laporan yang sering diakses.
  • ☐ Kebijakan masa simpan dan pruning.
  • ☐ Aturan baca primary vs replika didokumentasikan.

Operasional

  • ☐ SLO ditetapkan dan dipantau.
  • ☐ Load test sebelum periode puncak.
  • ☐ Perencanaan kapasitas berkala.
  • ☐ ADR untuk keputusan besar.

Langkah 13: Test Arsitektur

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();
});

Troubleshooting

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

Best Practices

Keamanan

  • Isolasi tenant ditegakkan di level data (global scope, index, test isolasi), bukan hanya di UI.
  • Pengguna replika laporan hanya punya hak SELECT.
  • Rate limiter melindungi dari penyalahgunaan sekaligus beban berlebih.
  • Feature flag tidak dipakai untuk menyembunyikan fitur yang belum aman; otorisasi tetap diterapkan.

Performa

  • Optimasi di tahap sekarang sebelum naik tahap.
  • Pra-agregasi dan replika laporan untuk memisahkan beban baca berat dari transaksi.
  • Pekerjaan berat lewat queue dengan kapasitas terbatas sebagai pengaman beban.
  • Kapasitas direncanakan dari titik jenuh hasil pengujian, dengan margin.

Maintainability

  • Monolit modular dengan batas jelas sebelum mempertimbangkan layanan terpisah.
  • Keputusan besar dicatat sebagai ADR.
  • Prinsip arsitektur dijaga oleh test arsitektur dan test isolasi tenant.
  • SLO menjadi bahasa bersama antara tim teknis dan pemilik produk.

Related Articles

Last Tested

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

Bagikan artikel:

Artikel lainnya