IAli
Tüm Yazılar
Redis Pub/Sub ile L1/L2 Çok Katmanlı Önbellek Geçersizleştirme Ağı

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:

TEXT
Ç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üş]
  1. L1 (Yerel Bellek): Go içinde sync.Map veya 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.
  2. 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:

TEXT
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:

Go
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:

  1. 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.
  2. 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 tepki

Fikirlerinizi tek tıkla paylaşarak geri bildirim bırakın.

Bu teknik notu çevrenizle paylaşın

Ali Purtaş

@alipurtas • Hey, This is Ali!

İletişime Geç

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

İç Bağlantılı Mimari
Yorumlar yükleniyor...