Cache aplikasi dengan Redis

Cache mengubah kueri 50 ms jadi pencarian 0,5 ms. Yang menentukan apakah ia membantu atau merugikan adalah dua hal: kunci yang benar, dan strategi invalidasi yang bisa dijelaskan.

Cache-aside

func (l *Layanan) Ambil(ctx context.Context, id int64) (Produk, error) {
	kunci := fmt.Sprintf("produk:v2:%d", id)

	// 1. Coba cache
	if b, err := l.rdb.Get(ctx, kunci).Bytes(); err == nil {
		var p Produk
		if json.Unmarshal(b, &p) == nil {
			l.metrik.Inc("cache.hit")
			return p, nil
		}
	} else if !errors.Is(err, redis.Nil) {
		// Redis bermasalah: CATAT, lalu LANJUT ke database.
		l.log.WarnContext(ctx, "cache tidak tersedia", "err", err)
	}
	l.metrik.Inc("cache.miss")

	// 2. singleflight: seribu permintaan bersamaan untuk id yang sama
	//    menghasilkan SATU kueri database.
	v, err, _ := l.grup.Do(kunci, func() (any, error) {
		return l.simpan.Ambil(ctx, id)
	})
	if err != nil {
		return Produk{}, err
	}
	p := v.(Produk)

	// 3. Isi cache — kegagalan di sini tidak boleh menggagalkan permintaan.
	if b, err := json.Marshal(p); err == nil {
		if err := l.rdb.Set(ctx, kunci, b, ttlAcak(5*time.Minute)).Err(); err != nil {
			l.log.WarnContext(ctx, "gagal mengisi cache", "err", err)
		}
	}
	return p, nil
}

// TTL diberi variasi ±20% supaya ribuan kunci yang diisi bersamaan
// tidak kedaluwarsa bersamaan juga.
func ttlAcak(d time.Duration) time.Duration {
	return d + time.Duration(rand.Int64N(int64(d/5))) - d/10
}

Merancang kunci

Invalidasi

// 1. TTL — paling sederhana, dan sering sudah cukup.
//    Cocok untuk data yang boleh basi beberapa menit.

// 2. Hapus saat tulis — cocok untuk data yang harus segera benar.
func (l *Layanan) Ubah(ctx context.Context, p Produk) error {
	if err := l.simpan.Simpan(ctx, p); err != nil {
		return err
	}
	// HAPUS, jangan perbarui: memperbarui menciptakan balapan antara
	// dua penulis yang bisa meninggalkan nilai lama di cache.
	_ = l.rdb.Del(ctx, fmt.Sprintf("produk:v2:%d", p.ID)).Err()
	return nil
}

// 3. Tag lewat set — untuk daftar yang terpengaruh banyak perubahan.
func (l *Layanan) invalidasiKategori(ctx context.Context, katID int64) error {
	tag := fmt.Sprintf("tag:kategori:%d", katID)
	kunci, err := l.rdb.SMembers(ctx, tag).Result()
	if err != nil {
		return err
	}
	if len(kunci) > 0 {
		_ = l.rdb.Del(ctx, kunci...).Err()
	}
	return l.rdb.Del(ctx, tag).Err()
}

Apa yang layak di-cache

Yang harus dipantau

// Rasio hit adalah metrik nomor satu.
// Di bawah 80% untuk data katalog berarti ada yang salah:
// TTL terlalu pendek, kunci terlalu spesifik, atau invalidasi terlalu agresif.
metrik.Inc("cache.hit")   // di jalur hit
metrik.Inc("cache.miss")  // di jalur miss

Cache dalam proses versus Redis

Pola berlapis yang umum: cache dalam proses berumur sangat pendek (5–10 detik) di depan Redis, untuk data yang dibaca berkali-kali dalam satu permintaan. Tapi ingat konsekuensinya — selama beberapa detik itu, tiap task bisa punya jawaban yang berbeda.