Pada aplikasi web skala enterprise dengan jutaan permintaan per detik, beban pembacaan data (read-heavy workload) dapat melumpuhkan database utama jika setiap request diarahkan langsung ke query SQL. Arsitektur caching satu lapis (hanya mengandalkan Redis terpusat) sering kali menjadi bottleneck baru ketika bandwidth jaringan internal atau throughput koneksi TCP ke kluster Redis mulai jenuh.
Solusi industri modern adalah menerapkan arsitektur caching multi-tier (berlapis). Pendekatan ini membagi penyimpanan sementara menjadi tiga lapis independen: L1 In-Memory lokal pada instance aplikasi, L2 Distributed Cache terpusat, dan L3 Edge CDN di jaringan tepi terdistribusi global.
Alur Permintaan Klien Melalui 3 Tingkat Cache:
Pengguna (Browser)
│
▼
┌────────────────────────────────────────────────────────┐
│ L3: Edge CDN (Cloudflare / Fastly) │
│ Latensi: 5 - 20 ms | Cache-Tags / Surrogate-Keys │
└────────────────────────────────────────────────────────┘
│ (Cache Miss di Edge)
▼
┌────────────────────────────────────────────────────────┐
│ L1: In-Process Local Memory (LRU Cache di Node.js Pod) │
│ Latensi: < 0.1 ms | Akses RAM Lokal Tanpa Jaringan │
└────────────────────────────────────────────────────────┘
│ (Cache Miss di L1)
▼
┌────────────────────────────────────────────────────────┐
│ L2: Distributed Cache Cluster (Redis Sentinel / Cluster)│
│ Latensi: 1 - 3 ms | Berbagi State Antar-Pod │
└────────────────────────────────────────────────────────┘
│ (Cache Miss di L2)
▼
┌────────────────────────────────────────────────────────┐
│ Database Utama (PostgreSQL / Read Replicas) │
│ Latensi: 10 - 50 ms | Sumber Kebenaran Data │
└────────────────────────────────────────────────────────┘
Karakteristik dan Peran Masing-Masing Lapisan #
Setiap lapisan dalam hierarki caching memiliki karakteristik fisik dan kompromi arsitektural yang berbeda:
- L3 Edge CDN (Edge Tier):
Beroperasi paling dekat dengan pengguna akhir di ratusan lokasi POP (Point of Presence). Sangat efektif untuk halaman katalog publik, aset statis, dan respons API yang dapat dibagikan (public data). Invalidasi diatur melalui headerSurrogate-KeyatauCache-Tag. - L1 In-Memory Cache (App Instance Tier):
Tersimpan langsung di alokasi heap memory proses aplikasi (misalnya container Node.js atau Go). Mengakses L1 tidak memerlukan panggilan jaringan TCP maupun serialisasi JSON. Latensinya di bawah 0,1 milidetik, cocok untuk data yang dibaca ratusan kali per detik seperti konfigurasi rute, kamus translasi, dan data pengguna aktif. - L2 Distributed Cache (Cluster Tier):
Kluster Redis atau Dragonfly yang digunakan bersama oleh seluruh container pod. Berfungsi sebagai penengah ketika data tidak ditemukan di memori lokal L1, sehingga request tidak langsung menghantam database SQL.
Mitigasi Cache Stampede dengan Algoritma XFetch #
Tantangan terbesar saat data di cache kedaluwarsa di bawah lonjakan trafik tinggi adalah fenomena Cache Stampede (atau Dogpiling). Ketika sebuah kunci populer kedaluwarsa pada pukul 12:00:00, ratusan permintaan concurrent yang datang secara bersamaan mendapati cache kosong dan semuanya mengeksekusi query berat ke database secara serentak.
Alih-alih menunggu kunci benar-benar kedaluwarsa, arsitektur modern menggunakan algoritma Probabilistic Early Expiration (XFetch). Algoritma ini menghitung probabilitas acak untuk memperbarui cache di latar belakang sebelum masa berlakunya habis, di mana probabilitas meningkat seiring mendekatnya waktu kedaluwarsa dan semakin tingginya durasi komputasi query.
Rumus evaluasi XFetch:
$$\Delta - \beta \times \delta \times \ln(\text{rand}()) > \text{TTL}$$
Di mana:
- $\Delta$: Waktu komputasi untuk menghasilkan data (milidetik).
- $\beta$: Faktor agresivitas pembaruan (nilai standar: 1.0).
- $\delta$: Waktu tersisa hingga kedaluwarsa (milidetik).
- $\text{rand}()$: Nilai acak antara 0 dan 1.
Berikut adalah implementasi TypeScript untuk lapisan L1 + L2 terintegrasi dengan XFetch:
import { LRUCache } from 'lru-cache';
import Redis from 'ioredis';
const redis = new Redis(process.env.REDIS_URL || 'redis://localhost:6379');
// L1: Maksimal 10.000 entri dalam memori heap pod
const l1Cache = new LRUCache<string, any>({
max: 10000,
ttl: 1000 * 30, // 30 detik TTL di L1 lokal
});
interface CacheRecord<T> {
value: T;
delta: number; // Durasi eksekusi query dalam milidetik
expiry: number; // Timestamp kedaluwarsa unix epoch
}
export async function fetchWithMultiTier<T>(
key: string,
fetchFn: () => Promise<T>,
ttlSeconds: number,
beta = 1.0
): Promise<T> {
// 1. Cek L1 In-Memory
const cachedL1 = l1Cache.get(key) as CacheRecord<T> | undefined;
if (cachedL1) {
return cachedL1.value;
}
// 2. Cek L2 Distributed Redis
const rawL2 = await redis.get(key);
if (rawL2) {
const record: CacheRecord<T> = JSON.parse(rawL2);
l1Cache.set(key, record);
const now = Date.now();
const remainingTtl = record.expiry - now;
const isEarlyExpired =
record.delta * beta * -Math.log(Math.random()) > remainingTtl;
if (!isEarlyExpired) {
return record.value;
}
// Pembaruan asinkron di background tanpa memblokir pembaca saat ini
refreshCacheInBackground(key, fetchFn, ttlSeconds).catch(() => {});
return record.value;
}
// 3. Cache Miss di L1 & L2: Eksekusi query langsung ke database
return refreshCacheSync(key, fetchFn, ttlSeconds);
}
async function refreshCacheSync<T>(
key: string,
fetchFn: () => Promise<T>,
ttlSeconds: number
): Promise<T> {
const start = Date.now();
const value = await fetchFn();
const delta = Date.now() - start;
const expiry = Date.now() + ttlSeconds * 1000;
const record: CacheRecord<T> = { value, delta, expiry };
l1Cache.set(key, record);
await redis.set(key, JSON.stringify(record), 'EX', ttlSeconds);
return value;
}
async function refreshCacheInBackground<T>(
key: string,
fetchFn: () => Promise<T>,
ttlSeconds: number
): Promise<void> {
// Gunakan distributed lock Redis untuk memastikan hanya 1 pod yang menjalankan refresh
const lockKey = `lock:${key}`;
const acquired = await redis.set(lockKey, '1', 'NX', 'EX', 10);
if (!acquired) return;
try {
await refreshCacheSync(key, fetchFn, ttlSeconds);
} finally {
await redis.del(lockKey);
}
}
Konfigurasi L3 Edge CDN Melalui Header Standar #
Untuk mengontrol lapisan terluar (Edge CDN), aplikasi backend harus menyertakan header HTTP yang mendefinisikan batas waktu caching publik dan tag invalidasi:
HTTP/1.1 200 OK
Content-Type: application/json
Cache-Control: public, s-maxage=3600, stale-while-revalidate=86400
Surrogate-Key: tenant_42 catalog_products category_electronics
Keterangan header:
s-maxage=3600: Menginstruksikan Edge CDN untuk menyimpan respons selama 1 jam. Browser pengguna tidak terikat durasi ini jika tidak adamax-age.stale-while-revalidate=86400: Apabila masa 1 jam berakhir, Edge CDN diizinkan menyajikan data kedaluwarsa kepada pengunjung secara instan sembari mengambil versi baru dari server asal di latar belakang.Surrogate-Key(atauCache-Tagpada Cloudflare): Memberikan label pada cache entry. Ketika produk diperbarui di sistem admin, aplikasi backend hanya perlu mengirim panggilan API purge ke Cloudflare dengan payload{"tags": ["catalog_products"]}, sehingga seluruh halaman terkait langsung terhapus dari CDN global tanpa merusak cache halaman lain.
Strategi Invalidasi Lintas Lapisan #
Tantangan utama sistem multi-tier adalah konsistensi data (cache coherence). Jika produk mengalami perubahan harga:
- Database SQL di-update.
- L2 Redis dihapus melalui perintah
DELatau diperbarui nilainya. - Notifikasi dikirimkan melalui Redis Pub/Sub ke semua pod aplikasi aktif untuk membersihkan kunci terkait dari memori L1 lokal (
l1Cache.delete(key)). - Webhook invalidasi dikirimkan ke provider CDN (L3) menggunakan API Purge berbasis Tag.
Dengan mengombinasikan ketiga lapisan ini secara disiplin, beban database dapat dipangkas secara substansial, latensi respons terjaga di level minimal, dan sistem terhindar dari pemadaman mendadak saat lonjakan pengunjung terjadi.
