Anatomi Cascading Failure Akibat Cache Stampede

Ketika sebuah key cache yang memiliki tingkat konkurensi pembacaan tinggi (hot key) kedaluwarsa secara mendadak, ribuan request masuk secara serentak menemukan kondisi cache miss. Situasi ini disebut cache stampede atau thundering herd problem.

Ketika ribuan goroutine atau worker secara simultan mencoba menghitung ulang data dan mengeksekusi query berat ke database relational (misalnya PostgreSQL atau MySQL), latensi database melonjak drastis, pool koneksi habis, resource CPU database mencapai 100%, dan server database berhenti merespons (deadlock/timeout). Dampak ini merambat ke upstream services yang mengantre koneksi, menciptakan efek domino atau cascading failure ke seluruh sistem backend.

Dua mekanisme pertahanan utama untuk mengatasi masalah ini adalah Request Deduplication (Singleflight) pada level in-process node, dan Distributed Mutex Locking pada level cluster.

Implementasi Mandiri In-Process Singleflight di Go

Pola Singleflight memastikan bahwa untuk key identik yang dipanggil bersamaan dalam satu instance aplikasi, fungsi fetch ke upstream (DB/Redis) hanya dijalankan satu kali. Pemanggil lain akan menunggu eksekusi pertama selesai dan menggunakan hasil yang sama secara bersamaan.

Berikut implementasi native Singleflight tanpa library eksternal, memanfaatkan sync.Mutex dan sync.WaitGroup standar library Go:

package main

import (
	"sync"
)

type call struct {
	wg  sync.WaitGroup
	val any
	err error
}

type Group struct {
	mu sync.Mutex
	m  map[string]*call
}

func (g *Group) Do(key string, fn func() (any, error)) (any, error) {
	g.mu.Lock()
	if g.m == nil {
		g.m = make(map[string]*call)
	}

	// Jika pemanggilan untuk key ini sedang berlangsung, tunggu
	if c, ok := g.m[key]; ok {
		g.mu.Unlock()
		c.wg.Wait()
		return c.val, c.err
	}

	// Buat state call baru untuk key ini
	c := new(call)
	c.wg.Add(1)
	g.m[key] = c
	g.mu.Unlock()

	// Eksekusi fungsi pengambil data (hanya dijalankan satu worker per node)
	c.val, c.err = fn()
	c.wg.Done()

	// Bersihkan registry setelah selesai
	g.mu.Lock()
	delete(g.m, key)
	g.mu.Unlock()

	return c.val, c.err
}

Kapan Singleflight Kurang Cukup?

Singleflight bersifat in-process. Jika backend Anda terdiri dari 50 instance container di balik Load Balancer, satu hot key yang expired masih memicu 50 query konkuren ke database secara simultan. Jika query tersebut sangat berat, 50 koneksi aktif yang mengeksekusi query lambat masih berisiko melumpuhkan database. Di sinilah distributed locking diperlukan.

Distributed Locking dengan Redis Mutex

Distributed lock memastikan bahwa di seluruh cluster aplikasi, hanya satu instance yang diizinkan mengambil alih proses regenerasi cache. Perintah Redis standar untuk akuisisi lock atomik adalah:

SET lock:item:123 <random_unique_token> NX PX 5000

Aturan penting implementasi Redis lock:

  • NX (Not Exists): Lock hanya berhasil diset jika key belum ada di Redis.
  • PX <milliseconds>: TTL wajib disertakan agar lock lepas otomatis jika worker mengalami crash (mencegah deadlock permanen).
  • Random Token: Nilai unik (seperti UUID) mencegah instance A menghapus lock milik instance B jika eksekusi instance A memakan waktu lebih lama dari nilai TTL.

Pelepasan lock harus dilakukan menggunakan Lua Script atomik untuk memvalidasi token:

if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

Alur Integrasi Komprehensif: Singleflight + Redis Lock

Strategi paling optimal menggabungkan Singleflight dan Redis Distributed Lock untuk meminimalkan beban jaringan ke Redis maupun database:

  1. Cek Redis cache. Jika HIT, langsung return data.
  2. Jika MISS, bungkus alur fetch di dalam Singleflight group.Do(key, ...) agar request identik di node lokal diredam.
  3. Di dalam fungsi Singleflight: coba akuisisi Redis Distributed Lock via SETNX.
  4. Jika Lock Berhasil Didapat: query data ke database, set Redis cache dengan TTL, lepas lock via Lua script, lalu return data.
  5. Jika Lock Gagal Didapat (diambil oleh node lain): sleep sejenak (misal 50-100ms dengan exponential backoff dan jitter), lalu coba baca ulang Redis cache. Jika tetap gagal setelah retries habis, fallback ke mitigasi degradasi.

Trade-off Stale-While-Revalidate

Daripada membiarkan cache kedaluwarsa sepenuhnya, pola Stale-While-Revalidate (SWR) menyajikan data yang sedikit usang (stale) kepada klien secara instan, sembari memperbarui data di background secara asinkron.

Kelebihan

  • Latensi pembacaan (p99) tetap sangat rendah dan konstan.
  • Menghilangkan lonjakan beban sinkron ke database secara total.

Kekurangan

  • Eventual Consistency: Pengguna dapat melihat data yang tidak sinkron beberapa detik setelah update terjadi.
  • Tidak cocok untuk transaksi finansial, inventory checkout stok terbatas, atau sistem auth/permissions kritis.

Mitigasi Cache Outage via Circuit Breaker Fallback

Ketika Redis mengalami hard failure (OOM crash, network partition, atau proses hang), fallback default yang langsung melemparkan semua query ke database akan membunuh seluruh cluster aplikasi seketika. Solusi untuk kondisi ini adalah memutus sirkuit (Circuit Breaker):

  • Deteksi Kegagalan Cepat: Set Redis command timeout sangat rendah (maksimal 100ms - 200ms). Jangan biarkan timeout Redis default (detik) memblokir worker pool aplikasi.
  • Open Circuit State: Jika tingkat kegagalan koneksi Redis melebihi ambang batas (misal 30% dalam 10 detik), circuit breaker beralih ke status Open.
  • Degradasi Terkontrol: Alih-alih meneruskan jutaan request ke database saat circuit open, return response fallback yang aman (misalnya: data kosong, static placeholder, atau in-memory LRU cache lokal berukuran kecil) dan batasi traffic ke database menggunakan rate limiter berbasis token bucket.