Cache berlapis — dari edge sampai memori proses

Cache yang benar bukan satu lapis, melainkan empat — dan yang paling sering salah bukan cara mengisinya, melainkan apa yang terjadi tepat saat ia kedaluwarsa.

Empat lapis dan porsinya

Lapis 2: cache di memori proses

// src/lib/cache-memori.ts
type Entri<T> = { nilai: T; kedaluwarsa: number; basiSampai: number };

const peta = new Map<string, Entri<unknown>>();
const sedangJalan = new Map<string, Promise<unknown>>();

export async function cache<T>(
  kunci: string,
  ttlDetik: number,
  ambil: () => Promise<T>,
): Promise<T> {
  const now = Date.now();
  const entri = peta.get(kunci) as Entri<T> | undefined;

  if (entri && now < entri.kedaluwarsa) {
    return entri.nilai;
  }

  // Cegah thundering herd: hanya SATU pengambilan per kunci.
  const berjalan = sedangJalan.get(kunci) as Promise<T> | undefined;
  if (berjalan) {
    // Kalau ada versi basi, pakai itu daripada ikut menunggu.
    if (entri && now < entri.basiSampai) return entri.nilai;
    return berjalan;
  }

  const p = ambil()
    .then((nilai) => {
      peta.set(kunci, {
        nilai,
        kedaluwarsa: Date.now() + ttlDetik * 1000,
        basiSampai: Date.now() + ttlDetik * 10 * 1000,
      });
      return nilai;
    })
    .catch((e) => {
      // Sumber mati: sajikan yang basi kalau ada.
      if (entri && Date.now() < entri.basiSampai) return entri.nilai;
      throw e;
    })
    .finally(() => sedangJalan.delete(kunci));

  sedangJalan.set(kunci, p);
  return p;
}

Dua puluh baris ini menyelesaikan tiga masalah sekaligus: cache, thundering herd, dan penyajian basi saat sumber mati. Untuk sebagian besar kebutuhan portal berita, ini sudah cukup dan tidak butuh infrastruktur apa pun.

export const ambilKurs = () =>
  cache("kurs", 300, () => ambilJson<Kurs>(URL_KURS));

Batasi ukurannya

const MAKS = 500;

// setelah peta.set(...)
if (peta.size > MAKS) {
  // Map di JavaScript mempertahankan urutan penyisipan:
  // kunci pertama adalah yang paling lama.
  const tertua = peta.keys().next().value;
  if (tertua !== undefined) peta.delete(tertua);
}

Tanpa batas, cache dengan kunci dinamis — artikel:${slug} — akan tumbuh sampai container di-OOM-kill oleh kernel, tanpa satu pun baris log yang menjelaskan. Ini kebocoran memori yang paling umum di aplikasi Node yang memakai Map sebagai cache.

Lapis 3: Redis / ElastiCache

// src/lib/redis.ts
import { createClient } from "redis";

export const redis = createClient({
  url: process.env.REDIS_URL,
  socket: { connectTimeout: 2000, reconnectStrategy: (n) => Math.min(n * 100, 3000) },
});

redis.on("error", (e) => console.error(JSON.stringify({ level: "error", redis: String(e) })));
await redis.connect();

export async function cacheRedis<T>(
  kunci: string,
  ttlDetik: number,
  ambil: () => Promise<T>,
): Promise<T> {
  try {
    const ada = await redis.get(kunci);
    if (ada) return JSON.parse(ada) as T;
  } catch {
    // Redis mati bukan alasan halaman mati.
  }

  const nilai = await ambil();

  try {
    await redis.setEx(kunci, ttlDetik, JSON.stringify(nilai));
  } catch { /* abaikan */ }

  return nilai;
}

Kapan Redis benar-benar dibutuhkan

Perhatikan bahwa alasan Redis dibutuhkan hampir selalu state yang dibagi, bukan kecepatan. Kalau kebutuhanmu murni kecepatan, memori proses lebih cepat dan gratis.

Anti-pola yang mahal

// Sebar TTL supaya tidak kedaluwarsa serempak
const ttl = 300 + Math.floor(Math.random() * 60);

Baris satu ini menyelesaikan baris kedua di tabel. Kalau seribu entri diisi bersamaan saat deploy — dan semuanya ber-TTL 300 detik — maka lima menit kemudian seribu entri kedaluwarsa dalam detik yang sama. Menambahkan jitter 0–60 detik menyebarkannya.