Go'da in-memory cache: otter/v2 ve stampede koruması
Bir API endpoint'i saniyede binlerce kez aynı veritabanı sorgusunu çalıştırıyor. Redis var ama network round-trip bile fazla; veri zaten tek bir pod'un belleğinde tutulabilecek boyutta. Go'da in-memory cache'e ihtiyaç duyduğunuzda karşınıza onlarca kütüphane çıkıyor, ama eviction politikası ve eşzamanlılık konusunda hepsi aynı değil. Bu yazıda otter/v2 kütüphanesinin W-TinyLFU admission politikasını, Loader deseniyle cache stampede korumasını ve ristretto ile farklılıklarını somut kodlarla inceliyorum.
W-TinyLFU neden LRU'dan iyi
Klasik LRU cache'in derdi basit: bir kerelik tarama sorguları (scan attack) sıcak verileri dışarı iter. Diyelim 10.000 öğelik bir cache var ve bir batch job 50.000 farklı anahtar okudu. LRU tüm sıcak anahtarları çıkarır, hit rate çöker.
W-TinyLFU (Window Tiny Least Frequently Used) bu sorunu iki katmanlı bir yapıyla çözer. Yeni gelen öğeler küçük bir "window" alanına girer, oradan ana alana kabul edilmeleri için frekans tahminine (count-min sketch) dayalı bir filtreye takılır. Frekansı düşük öğeler ana cache'e alınmaz. Caffeine (Java) bu politikayı popülerleştirdi; otter Go ekosistemindeki W-TinyLFU uygulaması.
otter/v2 kurulumu
otter'ın v2 API'si Go 1.21+ jeneriklerini kullanıyor. Kurulum:
go get github.com/maypok86/otter/v2@latestTemel bir cache oluşturmak:
package main
import (
"fmt"
"time"
"github.com/maypok86/otter/v2"
)
func main() {
cache, err := otter.NewBuilder[string, []byte](
10_000, // maximum capacity
).WithTTL(5 * time.Minute).Build()
if err != nil {
panic(err)
}
defer cache.Close()
cache.Set("user:42", []byte(`{"name":"Arda"}`))
val, ok := cache.Get("user:42")
if ok {
fmt.Println(string(val))
}
}Capacity burada öğe sayısını ifade ediyor. Bellek tabanlı sınırlama istiyorsanız Cost fonksiyonu tanımlayıp WithCost kullanabilirsiniz; bu durumda capacity toplam cost bütçesini temsil eder.
Loader deseni: stampede'den kurtulmak
Cache miss olduğunda N goroutine aynı anda veritabanına giderse "cache stampede" (thundering herd) oluşur. Klasik çözüm singleflight paketi, ama otter/v2 bunu doğrudan Loader API'siyle çözüyor.
package main
import (
"context"
"database/sql"
"time"
"github.com/maypok86/otter/v2"
)
type UserProfile struct {
ID int64
Name string
}
func buildCache(db *sql.DB) (*otter.Cache[int64, UserProfile], error) {
return otter.NewBuilder[int64, UserProfile](50_000).
WithTTL(10 * time.Minute).
WithLoader(func(ctx context.Context, key int64) (UserProfile, error) {
var p UserProfile
err := db.QueryRowContext(ctx,
"SELECT id, name FROM users WHERE id = $1", key,
).Scan(&p.ID, &p.Name)
return p, err
}).
Build()
}Loader tanımlandığında cache.Get yerine cache.GetOrLoad kullanıyorsunuz:
profile, err := cache.GetOrLoad(ctx, 42)Aynı key için eşzamanlı 500 goroutine GetOrLoad çağırsa bile Loader fonksiyonu tek bir kez çalışır, diğerleri sonucu bekler. singleflight.Group ile aynı mantık, ama cache katmanına gömülü olduğu için ayrıca yönetmeniz gereken bir şey yok.
Loader'da hata yönetimi
Loader bir hata döndürürse otter değeri cache'lemez. Bu genellikle doğru davranıştır, ama dikkat edilmesi gereken bir nokta var: veritabanı geçici olarak erişilemezken her istek Loader'ı tetikler ve singleflight koruması sadece eşzamanlı istekleri birleştirir, ardışık olanları değil. Bu durumda negatif cache (kısa TTL ile hata sonucunu cache'leme) eklemek mantıklı olabilir. Bunu Loader içinde kendiniz yapmanız gerekir:
var errNotFound = errors.New("user not found")
// Loader içinde:
if errors.Is(err, sql.ErrNoRows) {
// Boş bir sentinel değer döndürüp cache'e alınmasına izin ver
return UserProfile{ID: -1}, nil
}
// Gerçek hatada cache'leme
return UserProfile{}, errJenerasyonlu invalidation
Bireysel key silmek kolay: cache.Delete(key). Peki "tüm kullanıcı cache'ini geçersiz kıl" gibi toplu invalidation nasıl yapılır? cache.Clear() herşeyi temizler ama çoğu zaman sadece belirli bir veri kategorisini geçersiz kılmak istersiniz.
Benim tercih ettiğim desen: key'e bir "generation" sayacı gömmek.
package main
import (
"fmt"
"sync/atomic"
)
var userGeneration atomic.Int64
func userKey(id int64) string {
gen := userGeneration.Load()
return fmt.Sprintf("user:%d:gen:%d", id, gen)
}
func invalidateAllUsers() {
userGeneration.Add(1)
}Jenerasyon artırıldığında eski key'ler artık sorgulanmaz, TTL dolunca evict edilir. Bu yaklaşım cache.Clear() gibi tüm cache'i boşaltmaz, sadece ilgili kategoriyi etkiler. Otter'ın DeleteByFunc gibi bir API'si de var ama O(n) tarama gerektirdiği için büyük cache'lerde generation yaklaşımı daha düşük maliyetli.
Cost tabanlı bellek sınırlaması
Öğe sayısı yerine bellek bütçesiyle çalışmak istediğinizde:
cache, _ := otter.NewBuilder[string, []byte](100 * 1024 * 1024). // 100 MB bütçe
WithCost(func(key string, value []byte) uint32 {
return uint32(len(key) + len(value))
}).
WithTTL(15 * time.Minute).
Build()Burada capacity 100 MB'ı temsil ediyor, her öğenin cost'u key + value byte uzunluğu. Go struct'ları cache'liyorsanız unsafe.Sizeof yerine gerçekçi bir tahmin fonksiyonu yazmak daha doğru; struct içindeki slice ve string header'ları gerçek heap allocation'ı yansıtmaz.
Ristretto ile karşılaştırma
Dgraph'ın ristretto kütüphanesi de bir admission politikası (TinyLFU benzeri) kullanıyor. İkisi arasındaki farklar pratikte önemli:
ristretto, Set çağrısında değeri hemen kabul etmez; arka plandaki bir ring buffer'a yazar ve asenkron olarak cache'e alır ya da reddeder. Bu, Set çağrısından hemen sonra Get yaparsanız değeri bulamayabileceğiniz anlamına gelir. otter'da Set senkron, Get hemen sonuç verir.
ristretto'nun jenerik desteği yok. Key ve value interface{} tipinde; assertion maliyeti ve tip güvenliği kaybı var. otter/v2 Go jenerikleriyle çalışıyor.
Loader desteği ristretto'da yok. Stampede koruması için üzerine singleflight sarmanız gerekiyor.
Benchmark tarafında, otter'ın kendi benchmark'ları (GitHub'daki benchmarks/ dizini) Zipf dağılımlı iş yüklerinde hit rate'in ristretto'dan tutarlı olarak yüksek olduğunu gösteriyor. Bunun sebebi W-TinyLFU'nun window + main ayrımı; ristretto'nun admission filtresi benzer ama eviction tarafında farklı davranıyor. Kendi iş yükünüzle test etmek her zaman en doğrusu.
ristretto'nun bir avantajı: daha uzun süredir production'da, daha fazla projede kullanılmış. Bilinen edge case'leri daha fazla kişi tarafından test edilmiş durumda.
Metrikler ve gözlemlenebilirlik
otter, Stats() metoduyla hit, miss, eviction sayılarını veriyor:
stats := cache.Stats()
fmt.Printf("hits=%d misses=%d ratio=%.2f\n",
stats.Hits(), stats.Misses(), stats.Ratio())Bu değerleri bir Prometheus exporter'a bağlamak iyi bir pratik. Hit rate %80'in altına düşüyorsa ya capacity yetersizdir ya da erişim deseni cache'e uygun değildir.
import "github.com/prometheus/client_golang/prometheus"
var (
cacheHits = prometheus.NewCounter(prometheus.CounterOpts{
Name: "app_cache_hits_total",
})
cacheMisses = prometheus.NewCounter(prometheus.CounterOpts{
Name: "app_cache_misses_total",
})
)
// Periyodik olarak (örn. 10 saniyede bir):
func reportCacheMetrics(c *otter.Cache[string, []byte]) {
s := c.Stats()
cacheHits.Add(float64(s.Hits()))
cacheMisses.Add(float64(s.Misses()))
}HTTP handler'da tam örnek
Bir Go web servisi içinde otter cache'i nasıl kullanılır:
package main
import (
"context"
"database/sql"
"encoding/json"
"log"
"net/http"
"strconv"
"time"
"github.com/maypok86/otter/v2"
)
type Product struct {
ID int64 `json:"id"`
Name string `json:"name"`
Price float64 `json:"price"`
}
func main() {
db := connectDB() // kendi bağlantınız
cache, err := otter.NewBuilder[int64, Product](20_000).
WithTTL(5 * time.Minute).
WithLoader(func(ctx context.Context, id int64) (Product, error) {
var p Product
err := db.QueryRowContext(ctx,
"SELECT id, name, price FROM products WHERE id = $1", id,
).Scan(&p.ID, &p.Name, &p.Price)
return p, err
}).
Build()
if err != nil {
log.Fatal(err)
}
defer cache.Close()
mux := http.NewServeMux()
mux.HandleFunc("GET /products/{id}", func(w http.ResponseWriter, r *http.Request) {
idStr := r.PathValue("id")
id, err := strconv.ParseInt(idStr, 10, 64)
if err != nil {
http.Error(w, "invalid id", http.StatusBadRequest)
return
}
product, err := cache.GetOrLoad(r.Context(), id)
if err != nil {
http.Error(w, "not found", http.StatusNotFound)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(product)
})
log.Fatal(http.ListenAndServe(":8080", mux))
}Bu handler'da her request için veritabanı sorgusu yapılmaz. Aynı product ID'ye eşzamanlı gelen istekler tek bir SQL sorgusuyla çözülür. TTL dolduğunda ilk gelen istek Loader'ı tetikler, diğerleri bekler.
Ne zaman Redis, ne zaman in-memory
In-memory cache her zaman doğru seçim değil. Birden fazla pod aynı veriyi serve ediyorsa ve veri sık güncelleniyorsa, her pod'un kendi cache'i farklı versiyonlar gösterebilir. Bu durumda Redis gibi paylaşımlı bir cache katmanı tutarlılık sağlar. Ama veri dakikalar mertebesinde stale kalabiliyorsa (ürün listesi, konfigürasyon, profil bilgisi), in-memory cache network hop'u ortadan kaldırır. İkisi birlikte de kullanılabilir: in-memory L1, Redis L2 olarak çalışır, Loader fonksiyonu önce Redis'e bakar, orada da yoksa veritabanına gider.
Rate limiting gibi sayaç tabanlı yapılarda in-memory cache pod-local limitlere yol açacağı için genellikle uygun değil; orada dağıtık bir store gerekir.
otter/v2, Go'da in-memory cache ihtiyacı için şu an en dengeli seçenek. W-TinyLFU ile yüksek hit rate, Loader ile stampede koruması, jeneriklerle tip güvenliği. ristretto hala çalışan bir alternatif ama asenkron Set davranışı ve jenerik eksikliği onu yeni projelerde daha az cazip kılıyor. Cache capacity'nizi iş yükünüze göre ayarlayın, hit rate metriğini izleyin, stale veri toleransınıza göre TTL belirleyin.