Laravel Cache: Strategi Cache Data, Query, dan Halaman Tanpa Menyebabkan Data Kedaluwarsa
Admin HijrahKreativa
Penulis
Source code aplikasi, template web, dan ebook. Unduh dari akun setelah bayar. Lihat produk
Admin HijrahKreativa
Penulis
Memilih apa yang layak di-cache, merancang kunci cache yang aman, dan yang terpenting: kapan dan bagaimana cache dibuang saat data berubah. Membahas TTL, invalidasi berbasis event setelah commit, kunci berversi, cache tags, stale-while-revalidate dengan Cache::flexible, pencegahan stampede, cache fragmen dan halaman penuh, serta HTTP cache untuk browser dan CDN.
Ada pepatah lama di dunia pemrograman: hanya ada dua hal sulit, yaitu menamai sesuatu dan invalidasi cache. Menambahkan cache itu mudah:
$ringkasan = Cache::remember('dasbor:ringkasan', 3600, fn () => $this->hitungRingkasan());
Dasbor jadi cepat. Lalu bendahara mencatat pemasukan Rp500.000, membuka dasbor, dan saldo kas belum berubah. Ia mencatat ulang, dan sekarang ada transaksi ganda. Masalah performa selesai, berganti menjadi masalah kepercayaan terhadap data.
Kasus lain yang lebih berbahaya: halaman profil di-cache dengan kunci profil, lalu warga A melihat data milik warga B karena kunci cache tidak menyertakan ID pengguna.
Artikel ini membahas cache yang cepat dan tetap benar.
Hasil akhir:
Cache::flexible (stale-while-revalidate) dan pencegahan stampede,| Komponen | Versi |
|---|---|
| PHP | 8.3+ (disarankan 8.4) |
| Laravel | 13.x |
| Cache store | Redis 7.x (dibutuhkan untuk cache tags) |
| Testing | Pest 4 |
| Kandidat | Contoh | Layak? |
|---|---|---|
| Perhitungan berat yang sering dibaca, jarang berubah | Ringkasan kas bulanan, statistik dasbor | Sangat layak |
| Data referensi | Daftar RT, jenis iuran, pengaturan aplikasi | Sangat layak |
| Respons API eksternal | Data wilayah, kurs | Layak; sesuaikan TTL dengan sumbernya |
| Halaman publik | Daftar pengumuman, halaman profil RW | Layak; HTTP cache/CDN |
| Daftar dengan filter dan pagination bebas | Pencarian iuran dengan 8 filter | Biasanya tidak: kombinasi kunci terlalu banyak, hit rate rendah; perbaiki query/index |
| Data yang harus akurat saat itu juga | Saldo saat memproses pembayaran, stok, status pembayaran | Jangan dibaca dari cache untuk keputusan |
| Query yang sudah cepat (< 5 ms) | Mencari pengguna berdasarkan ID | Tidak perlu; menambah kerumitan |
Prinsip: cache dipakai untuk membaca dan menampilkan. Keputusan yang mengubah data (validasi saldo, pengecekan status) selalu membaca dari sumber aslinya.
Kunci cache yang tidak konsisten membuat invalidasi mustahil. Pusatkan pembuatan kunci:
// app/Support/Cache/KunciCache.php
namespace App\Support\Cache;
final class KunciCache
{
public static function ringkasanKas(int $rwId, string $periode): string
{
return "rw:{$rwId}:kas:ringkasan:{$periode}";
}
public static function daftarRt(int $rwId): string
{
return "rw:{$rwId}:rt:daftar";
}
public static function tagihanKeluarga(int $keluargaId): string
{
return "keluarga:{$keluargaId}:tagihan:aktif";
}
public static function pengaturan(): string
{
return 'app:pengaturan';
}
}
Aturan kunci:
rw:{id}:kas:...) agar mudah dibaca dan dikelompokkan.'cari:'.md5(json_encode($filterTervalidasi)).Kebocoran data antar-pengguna lewat cache adalah bug keamanan, bukan sekadar bug tampilan. Bila ragu, sertakan ID pengguna di kunci.
Setiap entri cache sebaiknya punya TTL, bahkan bila sudah ada invalidasi berbasis event. Bila suatu saat invalidasi terlewat (bug, perubahan langsung di database, job gagal), TTL membatasi berapa lama data salah bertahan.
| Data | TTL | Alasan |
|---|---|---|
| Pengaturan aplikasi | 1 jam + invalidasi saat disimpan | Jarang berubah |
| Daftar RT | 1 hari + invalidasi | Sangat jarang berubah |
| Ringkasan kas | 10 menit + invalidasi | Berubah setiap ada transaksi |
| Data wilayah dari API | 7 hari | Hampir tidak pernah berubah |
| Statistik publik | 5 menit, tanpa invalidasi | Selisih beberapa menit dapat diterima |
Hindari Cache::forever() kecuali benar-benar ada invalidasi yang andal.
Letakkan cache di service/query object, bukan tersebar di controller dan view:
// app/Modules/Kas/Queries/RingkasanKas.php
namespace App\Modules\Kas\Queries;
use App\Modules\Kas\Models\TransaksiKas;
use App\Support\Cache\KunciCache;
use Illuminate\Support\Facades\Cache;
final class RingkasanKas
{
public function untuk(int $rwId, string $periode): array
{
return Cache::flexible(
KunciCache::ringkasanKas($rwId, $periode),
[600, 1800], // segar 10 menit, boleh basi sampai 30 menit
fn () => $this->hitung($rwId, $periode),
);
}
public function hitungLangsung(int $rwId, string $periode): array
{
return $this->hitung($rwId, $periode); // untuk keputusan yang butuh angka akurat
}
private function hitung(int $rwId, string $periode): array
{
$baris = TransaksiKas::where('rw_id', $rwId)
->where('periode', $periode)
->selectRaw("SUM(CASE WHEN jenis = 'masuk' THEN nominal ELSE 0 END) AS masuk")
->selectRaw("SUM(CASE WHEN jenis = 'keluar' THEN nominal ELSE 0 END) AS keluar")
->first();
return [
'masuk' => (int) $baris->masuk,
'keluar' => (int) $baris->keluar,
'saldo' => (int) $baris->masuk - (int) $baris->keluar,
'dihitung_pada' => now()->toIso8601String(),
];
}
}
Hal-hal penting:
dihitung_pada ditampilkan kecil di dasbor ("diperbarui 3 menit lalu"). Pengguna jadi paham bahwa angka itu ringkasan, bukan nilai real time.Cache::flexible (Stale-While-Revalidate)Cache::flexible($kunci, [$segar, $basi], $callback) bekerja dalam tiga fase:
| Umur data | Perilaku |
|---|---|
< $segar (10 menit) |
Kembalikan dari cache |
antara $segar dan $basi (10–30 menit) |
Kembalikan data lama segera, lalu hitung ulang di belakang layar setelah respons dikirim |
> $basi atau belum ada |
Hitung sekarang (pengguna menunggu) |
Dengan ini, pengguna hampir tidak pernah menunggu perhitungan ulang, dan hanya satu proses yang menghitung ulang (Laravel memakai lock). Cocok untuk dasbor dan statistik.
TTL saja berarti bendahara bisa melihat saldo lama selama 10 menit. Untuk data yang ia ubah sendiri, buang cache segera saat data berubah.
// app/Modules/Kas/Observers/TransaksiKasObserver.php
namespace App\Modules\Kas\Observers;
use App\Modules\Kas\Models\TransaksiKas;
use App\Support\Cache\KunciCache;
use Illuminate\Contracts\Events\ShouldHandleEventsAfterCommit;
use Illuminate\Support\Facades\Cache;
final class TransaksiKasObserver implements ShouldHandleEventsAfterCommit
{
public function saved(TransaksiKas $trx): void
{
$this->buang($trx);
// Bila periode berubah, cache periode lama juga harus dibuang
// getPrevious(): nilai sebelum save terakhir. getOriginal() sudah berisi nilai baru
// karena observer ini baru berjalan setelah commit (setelah syncOriginal).
if ($trx->wasChanged('periode')) {
Cache::forget(KunciCache::ringkasanKas($trx->rw_id, $trx->getPrevious()['periode']));
}
}
public function deleted(TransaksiKas $trx): void
{
$this->buang($trx);
}
private function buang(TransaksiKas $trx): void
{
Cache::forget(KunciCache::ringkasanKas($trx->rw_id, $trx->periode));
}
}
// app/Modules/Kas/Models/TransaksiKas.php
use Illuminate\Database\Eloquent\Attributes\ObservedBy;
#[ObservedBy(TransaksiKasObserver::class)]
class TransaksiKas extends Model { /* ... */ }
Mengapa setelah commit? Bila cache dibuang di dalam transaksi, ada jeda sebelum commit. Request lain yang masuk pada jeda itu membaca data lama dari database (karena belum commit), lalu menyimpannya kembali ke cache. Setelah commit, cache berisi data lama dan bertahan sampai TTL habis. ShouldHandleEventsAfterCommit membuat observer baru berjalan setelah transaksi selesai.
Keterbatasan observer: query massal seperti TransaksiKas::where(...)->update([...]) tidak memicu event model. Untuk operasi massal, buang cache secara eksplisit setelahnya, atau gunakan kunci berversi (Langkah 7).
Bila invalidasi dipicu dari modul lain, lebih baik lewat event domain (misalnya IuranDilunasi) yang didengar listener di modul pemilik cache.
Bagaimana membuang semua cache milik satu RW (ringkasan semua periode, daftar, statistik) tanpa tahu satu per satu kuncinya? Gunakan nomor versi di dalam kunci:
// app/Support/Cache/VersiCache.php
namespace App\Support\Cache;
use Illuminate\Support\Facades\Cache;
final class VersiCache
{
public static function ambil(string $ruang): int
{
return (int) Cache::rememberForever("versi:{$ruang}", fn () => 1);
}
public static function naikkan(string $ruang): void
{
Cache::add("versi:{$ruang}", 1);
Cache::increment("versi:{$ruang}");
}
}
$versi = VersiCache::ambil("rw:{$rwId}");
$kunci = "rw:{$rwId}:v{$versi}:kas:ringkasan:{$periode}";
VersiCache::naikkan("rw:{$rwId}") membuat semua kunci lama tidak pernah dibaca lagi (versinya sudah berbeda) dan dibiarkan kedaluwarsa oleh TTL atau dibuang LRU Redis. Cara ini bekerja di semua driver cache dan aman untuk operasi massal.
Kunci versi disimpan dengan rememberForever, jadi pastikan instance cache memakai kebijakan eviction yang tepat: bila kunci versi ter-evict, versi kembali ke 1 dan data dengan v1 yang mungkin masih tersisa bisa terbaca lagi. Untuk menghindarinya, simpan kunci versi di store redis dengan koneksi data (noeviction), atau di database.
Driver Redis dan Memcached mendukung tags untuk mengelompokkan entri:
Cache::tags(["rw:{$rwId}", 'kas'])->remember(KunciCache::ringkasanKas($rwId, $periode), 600, fn () => ...);
// Buang semua cache kas milik RW ini
Cache::tags(["rw:{$rwId}", 'kas'])->flush();
Catatan:
file, database, dan dynamodb.Ketika entri populer kedaluwarsa dan banyak request datang bersamaan, semuanya menghitung ulang dan membebani database. Cara mencegahnya:
Cache::flexible (Langkah 5): sudah memakai lock untuk perhitungan ulang.remember biasa:public function rememberDenganLock(string $kunci, int $ttl, \Closure $hitung): mixed
{
if (($nilai = Cache::get($kunci)) !== null) {
return $nilai;
}
return Cache::lock("lock:{$kunci}", 15)->block(10, function () use ($kunci, $ttl, $hitung) {
return Cache::get($kunci) ?? tap($hitung(), fn ($v) => Cache::put($kunci, $v, $ttl));
});
}
600 + random_int(0, 120).memo dan onceBila data yang sama dibaca berkali-kali dalam satu request (pengaturan dibaca di layout, sidebar, dan 10 komponen), bahkan Redis pun dipanggil berkali-kali.
// Memo di atas store mana pun: panggilan berikutnya dalam request yang sama tidak menyentuh Redis
$pengaturan = Cache::memo()->remember(KunciCache::pengaturan(), 3600, fn () => Pengaturan::pluck('nilai', 'kunci')->all());
// once(): hasil method disimpan per instance objek selama request
public function peranAktif(): array
{
return once(fn () => $this->roles()->pluck('name')->all());
}
Untuk bagian halaman yang mahal dibuat (misalnya widget statistik dengan banyak query dan perulangan), cache HTML hasil render sekaligus data di dalamnya. Kuncinya: data diambil di dalam closure cache, sehingga saat cache masih berlaku tidak ada query yang berjalan sama sekali.
// app/Modules/Laporan/Fragmen/StatistikRw.php
namespace App\Modules\Laporan\Fragmen;
use App\Support\Cache\VersiCache;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\HtmlString;
final class StatistikRw
{
public function __construct(private StatistikQuery $statistik) {}
public function html(int $rwId): HtmlString
{
$versi = VersiCache::ambil("rw:{$rwId}");
$html = Cache::remember("fragmen:rw:{$rwId}:v{$versi}:statistik", 600, function () use ($rwId) {
return view('dasbor.partials.statistik', [
'statistik' => $this->statistik->untuk($rwId), // query berat hanya saat cache kosong
])->render();
});
return new HtmlString($html);
}
}
// Controller
return view('dasbor.index', [
'statistikHtml' => app(StatistikRw::class)->html($rw->id),
]);
{{-- resources/views/dasbor/index.blade.php --}}
<section aria-label="Statistik RW">
{{ $statistikHtml }} {{-- HtmlString tidak di-escape ulang --}}
</section>
Partial yang di-cache harus bersifat sama untuk semua yang berbagi kunci tersebut. Jangan meng-cache fragmen yang berisi token CSRF, nama pengguna yang login, atau tombol yang tergantung izin, kecuali kunci menyertakan pengguna atau peran yang bersangkutan.
Halaman publik (daftar pengumuman, profil RW) sama untuk semua pengunjung tamu. Cara paling efisien adalah membiarkan browser dan CDN meng-cache-nya, sehingga request bahkan tidak sampai ke PHP.
Laravel menyediakan middleware cache.headers:
// routes/web.php
Route::middleware('cache.headers:public;max_age=300;s_maxage=600;etag')->group(function () {
Route::get('/pengumuman', [PengumumanPublikController::class, 'index'])->name('publik.pengumuman');
Route::get('/pengumuman/{pengumuman:slug}', [PengumumanPublikController::class, 'show']);
});
| Direktif | Arti |
|---|---|
public |
Boleh disimpan cache bersama (CDN, proxy) |
max_age=300 |
Browser memakai salinan 5 menit |
s_maxage=600 |
CDN memakai salinan 10 menit |
etag |
Laravel menghitung ETag dari isi respons; browser mengirim If-None-Match dan menerima 304 Not Modified bila tidak berubah |
Syarat aman untuk cache publik:
web memulai session dan mengirim cookie, sehingga banyak CDN menolak meng-cache-nya. Untuk halaman publik murni, pertimbangkan grup middleware tanpa session (withoutMiddleware([StartSession::class, ...])) atau atur CDN agar mengabaikan cookie hanya pada path publik.Cache-Control: private, no-store.Saat pengumuman diterbitkan atau diubah, minta CDN membuang cache path tersebut (purge) lewat API CDN di observer/listener, atau terima jeda sesuai s_maxage.
Cache halaman penuh di aplikasi (tanpa CDN) bisa dibuat dengan middleware yang menyimpan respons untuk tamu:
// app/Http/Middleware/CacheHalamanTamu.php
public function handle(Request $request, Closure $next, int $ttl = 300)
{
if ($request->user() || ! $request->isMethod('GET') || $request->query()) {
return $next($request);
}
$kunci = 'halaman:'.sha1($request->getHost().$request->getPathInfo());
if ($html = Cache::get($kunci)) {
return response($html)->header('X-Cache', 'HIT');
}
$respons = $next($request);
if ($respons->isSuccessful() && ! $respons->headers->has('Set-Cookie')) {
Cache::put($kunci, $respons->getContent(), $ttl);
}
return $respons->header('X-Cache', 'MISS');
}
Set-Cookie dicek di objek respons, tetapi cookie session baru ditambahkan oleh middleware StartSession setelah middleware ini selesai bila urutannya di dalam grup web. Pasang middleware ini di grup tanpa session agar pengecekannya benar.
// tests/Feature/Cache/RingkasanKasCacheTest.php
use Illuminate\Support\Facades\Cache;
beforeEach(fn () => config(['cache.default' => 'array']));
it('ringkasan kas diperbarui setelah transaksi baru disimpan', function () {
$rw = RukunWarga::factory()->create();
TransaksiKas::factory()->for($rw, 'rukunWarga')->create(['jenis' => 'masuk', 'nominal' => 100_000, 'periode' => '2026-10']);
$query = app(RingkasanKas::class);
expect($query->untuk($rw->id, '2026-10')['saldo'])->toBe(100_000);
TransaksiKas::factory()->for($rw, 'rukunWarga')->create(['jenis' => 'masuk', 'nominal' => 50_000, 'periode' => '2026-10']);
expect($query->untuk($rw->id, '2026-10')['saldo'])->toBe(150_000);
});
it('kunci cache berbeda per RW (tidak bocor antar-tenant)', function () {
expect(KunciCache::ringkasanKas(1, '2026-10'))->not->toBe(KunciCache::ringkasanKas(2, '2026-10'));
});
it('halaman publik mengirim header cache', function () {
$this->get('/pengumuman')
->assertOk()
->assertHeader('Cache-Control')
->assertHeader('ETag');
});
it('halaman pribadi tidak boleh di-cache publik', function () {
$warga = User::factory()->create()->assignRole('warga');
$res = $this->actingAs($warga)->get('/tagihan-saya')->assertOk();
expect($res->headers->get('Cache-Control'))->not->toContain('public');
});
Test pertama berjalan karena di dalam test, transaksi RefreshDatabase dianggap level dasar, sehingga observer ShouldHandleEventsAfterCommit tetap dijalankan setelah operasi simpan.
| Error / Gejala | Penyebab | Solusi |
|---|---|---|
| Data di dasbor tidak berubah setelah disimpan | Tidak ada invalidasi | Observer/listener yang membuang kunci |
| Kadang masih data lama walau sudah di-invalidate | Invalidasi di dalam transaksi | ShouldHandleEventsAfterCommit |
| Update massal tidak membuang cache | Query massal tidak memicu event model | Invalidasi eksplisit atau kunci berversi |
| Pengguna melihat data pengguna lain | Kunci cache tanpa ID pengguna/tenant | Sertakan ID di kunci; tinjau semua remember |
This cache store does not support tagging |
Driver file/database | Redis/Memcached atau kunci berversi |
| Database melonjak saat cache kedaluwarsa | Stampede | Cache::flexible, lock, jitter |
| Error setelah deploy saat membaca cache | Model/kelas yang diserialisasi berubah | Simpan array primitif; naikkan versi kunci saat deploy |
| Halaman publik tidak di-cache CDN | Respons membawa Set-Cookie |
Route publik tanpa session |
| Token CSRF salah (419) di halaman ter-cache | Fragmen/halaman berisi token pengguna lain | Jangan cache bagian berisi CSRF; ambil token lewat JS/meta terpisah |
| Hit rate rendah | Kunci terlalu spesifik (filter bebas) | Cache hanya kombinasi umum atau perbaiki query |
Keamanan
Cache-Control: private, no-store.Performa
Cache::flexible untuk dasbor dan statistik.memo/once untuk data yang dibaca berulang dalam satu request.Maintainability
KunciCache).| Komponen | Versi |
|---|---|
| Laravel | 13.x |
| PHP | 8.4 |
| Redis | 7.x |
| Pest | 4.x |
| Tanggal | 19 Oktober 2026 |
Sebelumnya
Cara Mengoptimalkan Query MySQL Laravel Menggunakan Index dan EXPLAIN
Berikutnya
PHP-FPM Tuning untuk Laravel: Memahami Worker, Memory Limit, dan Kapasitas Request
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...
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,...
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