Strategi Modern Caching Multi-Tier: L1 In-Memory, L2 Distributed Redis, dan L3 Edge CDN

Membangun arsitektur caching 3-tier tangguh: mitigasi cache stampede dengan algoritma probabilistik XFetch, koordinasi invalidasi via Surrogate-Keys, dan eliminasi bottleneck pembacaan database SQL.

PuluhLabs Engineering Team, Principal Systems Architect · 13 November 2026 · 7 min baca

Strategi Modern Caching Multi-Tier: L1 In-Memory, L2 Distributed Redis, dan L3 Edge CDN
Pengembangan Web
DECOUPLED

Isi artikel ini

  • Karakteristik dan Peran Masing-Masing Lapisan
  • Mitigasi Cache Stampede dengan Algoritma XFetch
  • Konfigurasi L3 Edge CDN Melalui Header Standar
  • Strategi Invalidasi Lintas Lapisan

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.

text
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:

  1. 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 header Surrogate-Key atau Cache-Tag.
  2. 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.
  3. 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:

typescript
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
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 ada max-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 (atau Cache-Tag pada 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:

  1. Database SQL di-update.
  2. L2 Redis dihapus melalui perintah DEL atau diperbarui nilainya.
  3. Notifikasi dikirimkan melalui Redis Pub/Sub ke semua pod aplikasi aktif untuk membersihkan kunci terkait dari memori L1 lokal (l1Cache.delete(key)).
  4. 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.

Bagikan Artikel Ini:
Topik Terkait:Semua artikel: Performa web dan Core Web VitalsCachingRedisEdge CDNXFetchPerforma Web
Istilah Teknis Terkait (Knowledge Graph Glossary)
Jejaring Entitas & Solusi Teknis Terkait
3 Solusi Terintegrasi
Architecture Matrix

Perbandingan Headless CMS vs Monolitik

Kajian komparatif performa, keamanan OWASP, dan total biaya kepemilikan (TCO).

Buka Solusi
Planning Tool

Kalkulator Investasi & Jadwal Website

Estimasi biaya pembuatan website company profile, portal B2B, atau web app kustom.

Buka Solusi
Partnership Hub

Kemitraan White-Label untuk Agensi

Dukungan rekayasa teknis rahasia di balik layar agensi Anda dengan NDA resmi.

Buka Solusi

PuluhLabs Engineering Team

Principal Systems Architect

Terakhir diperbarui: 13 November 2026

Ingin Menerapkan Standar Performa Ini pada Proyek Agensi Anda?

Tim PuluhLabs siap menjadi mitra rekayasa digital rahasia (white-label) untuk agensi Anda. Garansi performa skor Lighthouse 90+, Core Web Vitals hijau, dan 100% hak milik kode.

Konsultasi Proyek Bersama Tim PuluhLabs

Artikel Rekomendasi Selanjutnya

Lihat Semua
  1. Performa Web

    Optimasi Core Web Vitals: Membedah dan Memperbaiki Cumulative Layout Shift (CLS) hingga Skor Nol

  2. SEO & Performa

    Optimasi Latensi Jaringan: Implementasi HTTP/3 QUIC dan Brotli Compression pada Edge NGINX

  3. SEO & Performa

    Audit Kinerja Frontend: Mengukur dan Mengoptimalkan Total Blocking Time (TBT) dan Long Tasks