
Redis Pub/Sub ile L1/L2 Çok Katmanlı Önbellek Geçersizleştirme Ağı
Süreç içi yerel RAM (L1) ile merkezi Redis (L2) katmanlarını senkron tutan Pub/Sub tabanlı geçersizleştirme ve istemci önbellekleme mimarisi.
Merkezi bir Redis kümesi mikroservis mimarilerinde veritabanı yükünü düşürmek için harika bir çözümdür. Ancak saniyede yüz binlerce isteğin aktığı uç noktalarda ağ kartı sınırları, TCP paketleme maliyeti ve serileştirme yükü devreye girer. Redis sunucusuna yapılan her çağrı yerel ağda 1 ile 2 milisaniye arasında gecikme ekler.
Bu gecikmeyi mikrosaniye seviyesine indirmek isteyen ekipler çok katmanlı önbellek mimarisine (Multi-tier Caching) geçer. Uygulamanın kendi bellek alanında çalışan yerel bir RAM önbelleği (L1) ve arkasında paylaşımlı merkezi Redis (L2).
L1 katmanı ağ çağrısını tamamen ortadan kaldırır. Ancak beraberinde dağıtık sistemlerin en zor problemini getirir. Bir sunucu veriyi güncellediğinde diğer sunucuların yerel L1 belleklerindeki bayat kopyalar nasıl geçersiz kılınacaktır?
1. İki Katmanlı Önbellek Mimarisi: L1 ve L2 Ayrımı
İki katmanlı bir önbellek modelinde veri okuma hiyerarşisi şu şekilde işler:
ÇOK KATMANLI ÖNBELLEK AKIŞI:
[İstek] ---> [L1: Yerel RAM] --(Hit: ~50ns)-----> [Dönüş]
|
(Miss)
v
[L2: Redis] --(Hit: ~1.5ms)----> [L1 e Yaz] -> [Dönüş]
|
(Miss)
v
[Veritabanı] --(Hit: ~15ms)-----> [L2 ve L1 e Yaz] -> [Dönüş]
- L1 (Yerel Bellek): Go içinde
sync.Mapveya Ristretto, Java içinde Caffeine kütüphanesi kullanılır. Veriye erişim doğrudan CPU bellek veri yolundan (RAM) gerçekleşir ve yaklaşık 50 nanosaniye sürer. Ağ G/Ç maliyeti sıfırdır. - L2 (Merkezi Önbellek): Redis kümesidir. Kümedeki tüm sunucular tarafından paylaşılır. Erişim süresi 1-2 milisaniyedir.
Bu yapı Önbellek İzdihamı ve XFetch Probabilistik Erken Yenileme Algoritması yazımızda bahsettiğimiz izdiham baskısını L2 katmanında dahi hissetmeden yerel RAM seviyesinde karşılar.
Ancak kümede 10 adet API podu çalıştığını düşünelim. Pod A bir kullanıcının profilini güncelleyip veritabanına ve L2 Redis katmanına yazdığında, Pod B ve Pod C kendi L1 belleklerinde tuttuğu eski kullanıcı profilini kullanmaya devam eder. Bu tutarsızlık dakikalarca sürebilir.
2. Redis Pub/Sub ile Geçersizleştirme Yayınları
L1 önbelleklerini senkronize etmenin en yaygın çözümü olay tabanlı geçersizleştirmedir (event-driven invalidation).
Her uygulama örneği başladığında Redis üzerinde ortak bir kanala (örneğin cache:invalidations) abone olur. Bir düğüm bir anahtarı güncellediğinde veya sildiğinde bu kanala bir geçersizleştirme mesajı basar:
PUB/SUB İLE GEÇERSİZLEŞTİRME YAYINI:
[Pod A (Yazıcı)] ---> [Redis L2 Güncelle]
|
+--(PUBLISH "cache:invalidations" "user:42")
|
v
+-------------------+
| Redis Pub/Sub |
+-------------------+
|
+------------------+------------------+
| |
v v
[Pod B Abonesi] [Pod C Abonesi]
(L1 den "user:42" sil) (L1 den "user:42" sil)
Tüm podlar bu mesajı aldıkları anda yerel L1 belleklerindeki user:42 anahtarını siler. Bir sonraki okuma isteğinde podlar yerel L1 bellekte veriyi bulamaz, L2 Redis katmanına giderek güncel veriyi çeker ve L1 belleğini tazeler.
Bu iletişim modeli RabbitMQ AMQP Değişim Tipleri yazımızdaki Fanout yayın deseniyle birebir aynı amaca hizmet eder.
3. Go ile L1/L2 Senkronizasyon Uygulaması
Aşağıda Redis Pub/Sub dinleyicisi ile yerel Go önbelleğini senkron tutan bir mimari bileşen örneği yer almaktadır:
package cache
import (
"context"
"log"
"sync"
"time"
"github.com/redis/go-redis/v9"
)
type MultiTierCache struct {
rdb *redis.Client
l1 sync.Map
channel string
}
func NewMultiTierCache(rdb *redis.Client, channel string) *MultiTierCache {
m := &MultiTierCache{
rdb: rdb,
channel: channel,
}
go m.listenInvalidations(context.Background())
return m
}
func (m *MultiTierCache) Get(ctx context.Context, key string) (string, bool) {
// 1. L1 yerel bellek kontrolu
if val, ok := m.l1.Load(key); ok {
return val.(string), true
}
// 2. L2 Redis kontrolu
val, err := m.rdb.Get(ctx, key).Result()
if err != nil {
return "", false
}
// L1 bellege yaz (Kisa bir yerel guvenlik TTL i ile)
m.l1.Store(key, val)
return val, true
}
func (m *MultiTierCache) SetAndInvalidate(ctx context.Context, key string, val string, ttl time.Duration) error {
// Once L2 Redis guncelle
if err := m.rdb.Set(ctx, key, val, ttl).Err(); err != nil {
return err
}
// Kendi L1 bellegini guncelle
m.l1.Store(key, val)
// Diger dugumlere gecersizlestirme sinyali yayinla
return m.rdb.Publish(ctx, m.channel, key).Err()
}
func (m *MultiTierCache) listenInvalidations(ctx context.Context) {
pubsub := m.rdb.Subscribe(ctx, m.channel)
defer pubsub.Close()
ch := pubsub.Channel()
for msg := range ch {
// Mesajda gelen anahtari yerel L1 bellekten tahliye et
m.l1.Delete(msg.Payload)
}
}
4. Redis 6 İstemci Taraflı Önbellekleme (Tracking Mode)
Redis 6 ile birlikte motor seviyesinde İstemci Taraflı Önbellekleme (Client-Side Caching) desteği eklenmiştir. Bu modelde uygulama kendi Pub/Sub altyapısını kurmak zorunda kalmaz.
RESP3 protokolü üzerinden çalışan bu sistemde iki ana mod bulunur:
- Normal Mod: Sunucu istemcinin hangi anahtarları okuduğunu bağlantı bazında hafızasında tutar. Anahtar değiştiğinde ilgili istemciye geçersizleştirme mesajı yollar. Ancak bu mod Redis üzerinde bağlantı başına yüksek bellek tüketebilir.
- Yayın Modu (BCAST - Broadcast Mode): Redis sunucusu istemcinin okuduğu anahtarları tek tek tutmaz. Bunun yerine istemciler belirli anahtar öneklerine (örneğin
user:) abone olur. Bu önek altındaki herhangi bir anahtar değiştiğinde Redis tüm abonelere geçersizleştirme sinyali basar.
BCAST modu sunucu tarafında bellek harcamadığı için büyük ölçekli mikroservis kümelerinde tercih edilen standarttır.
5. Ağ Kesintileri ve TTL Güvenlik Ağı
Pub/Sub mekanizması "ateşle ve unut" (fire-and-forget) prensibiyle çalışır. Eğer bir uygulama podu ağ dalgalanması sebebiyle 2 saniyeliğine Redis bağlantısını kaybederse, o 2 saniye içinde yapılan geçersizleştirme mesajlarını asla alamaz.
Bu kritik sınır durumunu yönetmek için iki katı kural uygulanmalıdır:
- Zorunlu Kısa L1 TTL: L1 belleğindeki anahtarlar hiçbir zaman sonsuz yaşam süresiyle saklanmamalıdır. L1 için 5 ile 30 saniye arasında agresif bir TTL tanımlanmalıdır. Böylece bir geçersizleştirme mesajı ağda kaybolsa bile pod en fazla 30 saniye içinde bayat veriyi kendiliğinden temizler.
- Yeniden Bağlantıda L1 Tahliyesi: Redis bağlantısı koptuğunda ve tekrar kurulduğunda (reconnect), uygulama podu geçmişteki kayıp mesajları bilemeyeceği için yerel L1 belleğindeki tüm verileri toptan temizlemelidir (flush).
Bu iki önlem alındığında L1/L2 önbellek mimarisi, ağ gecikmelerini sıfıra yaklaştırırken veri tutarlılığı risklerini kontrol edilebilir bir sınırda tutmayı başarır.
Yazıyı Değerlendir
0 tepkiFikirlerinizi tek tıkla paylaşarak geri bildirim bırakın.
Ali Purtaş
@alipurtas • Hey, This is Ali!
Kendi halinde yazılım geliştiren bir öğrenci. Sistemler kuruyor, deniyor, bozuyor ve öğrendiği gerçek çözümleri burada belgeliyor.
Konu Kümesi & Önerilen Yazılar
Önbellek İzdihamı ve XFetch Probabilistik Erken Yenileme Algoritması
Önbellek izdihamı (cache stampede) krizlerini önleyen XFetch olasılıksal erken yenileme algoritması ve tekil uçuş (singleflight) desen analizi.
Write-Behind Önbellekleme ve Veritabanı Toplu Yazma Yükü Mimarisi
Write-behind önbellekleme ile yazma gecikmesini düşürme, toplu veritabanı yazımları, veri kaybı riskleri ve çöküş kurtarma mimari rehberi.
Önbellek Mimarisi: Cache-Aside, Write-Through ve Çift Yazma Çıkmazı
Cache-aside ve write-through önbellek stratejileri, çift yazma problemi, yarış durumları ve CDC outbox tabanlı veri tutarlılığı mimari analizi.
Tartışma & Yorumlar
0Tartışmaya katılmak ve soru sormak için oturum açmalısınız.
Giriş Yap