IAli
Tüm Yazılar
Write-Behind Önbellekleme ve Veritabanı Toplu Yazma Yükü Mimarisi

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.

Yüksek trafikli sistemlerde okuma yükünü önbellekle hafifletmek standart bir mühendislik refleksidir. Ancak saniyede on binlerce sayfa görüntüleme sayacı artışı, IoT telemetri sinyali veya finansal fiyat güncellemesi gibi yoğun yazma yükleri söz konusu olduğunda geleneksel veritabanları G/Ç sınırlarına takılır. Her yazma isteğini doğrudan diske commit etmek kilit çekişmesini artırır ve gecikmeleri tavan yaptırır.

Bu darboğazı aşmak için uygulanan en agresif mimari desen Write-Behind (Write-Back) önbelleklemedir. Bu modelde uygulama veriyi doğrudan belleğe yazar ve veritabanı işlemini beklemeden istemciye anında başarı döner. Veritabanına asıl yazma işlemi ise arka planda toplu (batch) ve birleştirilmiş (coalesced) paketler halinde gecikmeli olarak gerçekleştirilir.

Büyük bir yazma verimi sağlayan bu yaklaşım, sistem çöküşlerinde veri kaybı riskiyle birlikte gelir.

1. Write-Behind Çalışma Mantığı ve Birleştirme Gücü

Write-Behind mimarisinde uygulama ile veritabanı arasına bellek içi bir tampon kuyruk yerleştirilir.

İşleyiş adımları şu şekildedir:

  1. İstemci yazma isteği gönderir.
  2. Uygulama veriyi hızlı bellek katmanına (örneğin Redis) yazar ve anahtarı kirli (dirty) olarak işaretler.
  3. Uygulama istemciye anında HTTP 200 döner.
  4. Arka plan iş parçacığı (flusher) belirli aralıklarla veya tampon boyutu dolduğunda kirli anahtarları toplar.
  5. Toplanan veriler birleştirilir ve veritabanına tek bir toplu SQL sorgusuyla yazılır.
TEXT
WRITE-BEHIND AKIŞ ŞEMASI:
[İstemci] --(1. Yaz)--> [Uygulama] --(2. Hızlı Yaz)--> [Redis / RAM]
    ^                       |                              |
    +----(3. 200 OK)--------+                              | (Kirli Liste)
                                                           v
                                                  [Arka Plan Flusher]
                                                           |
                                               (Toplu SQL INSERT/UPDATE)
                                                           v
                                                    [Veritabanı (Disk)]

Bu desenin en büyük kazanımı yazma birleştirme (write coalescing) etkisidir. Örneğin bir e-ticaret sitesinde popüler bir ürünün görüntülenme sayacı 5 saniye içinde 10.000 kez artırıldığında, geleneksel sistem veritabanına 10.000 ayrı UPDATE sorgusu gönderir. Write-Behind kullanan sistem ise bellekteki sayacı 10.000 kez artırır, ancak veritabanına yalnızca tek bir sorgu atarak değeri günceller:

SQL
-- 10.000 ayri sorgu yerine tek bir toplu guncelleme
UPDATE products SET view_count = view_count + 10000 WHERE id = 42;

Bu sayede veritabanı G/Ç yükü yüzde 99 oranında azaltılabilir. Benzer mekanizmalar PostgreSQL MVCC ve Vacuum yazımızda incelediğimiz WAL tamponu ve kontrol noktası mantığında da çekirdek seviyesinde kullanılır.

2. Ölümcül Risk: Bellek Çöküşü ve Veri Kaybı

Write-Behind deseninin en zayıf karnı dayanıklılık (durability) eksikliğidir. ACID prensiplerindeki D harfi bu mimaride bilinçli olarak feda edilir.

İstemciye "veriniz kaydedildi" yanıtı verildiği anda veri henüz kalıcı depolama birimine (diske) ulaşmamıştır. Eğer arka plan temizleyici veriyi veritabanına yazmadan önce önbellek sunucusunun elektriği kesilirse veya süreç OOM (Out-Of-Memory) ile çökerse bellekte bekleyen tüm kirli veriler kaybolur.

Bu felaketi hafifletmek için üç temel savunma hattı kurulur:

  1. Bellek Katmanında Kalıcılık (AOF / WAL): Redis kullanılıyorsa appendonly yes ve appendfsync everysec yapılandırmasıyla bellek yazımları asenkron olarak yerel NVMe diske kütük olarak yazılmalıdır.
  2. Kuyruk Ayrıştırması: Kirli anahtarlar doğrudan anahtar-değer alanında değil, Redis Streams veya dayanıklı bir Kafka kuyruğunda tutulmalıdır. Önbellek Mimarisi: Cache-Aside, Write-Through ve Çift Yazma Çıkmazı yazımızda değindiğimiz gibi kuyruk mekanizmaları durum kaybını önler.
  3. Küme Çoğaltması (Replication): Bellek düğümünün birincil (primary) kopyası çöktüğünde verilerin replikaya geçmiş olması sağlanmalıdır.

3. Üretim Seviyesinde Go ile Write-Behind Flusher Tasarımı

Aşağıdaki örnekte Redis üzerinde biriken sayaç güncellemelerini toplayıp veritabanına toplu aktaran dayanıklı bir Go flusher bileşeni görülmektedir:

Go
package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"time"

	"github.com/redis/go-redis/v9"
)

type WriteBehindFlusher struct {
	rdb         *redis.Client
	db          *sql.DB
	dirtySetKey string
	batchSize   int
	interval    time.Duration
}

func (w *WriteBehindFlusher) Start(ctx context.Context) {
	ticker := time.NewTicker(w.interval)
	defer ticker.Stop()

	for {
		select {
		case <-ctx.Done():
			w.flush(context.Background())
			return
		case <-ticker.C:
			w.flush(ctx)
		}
	}
}

func (w *WriteBehindFlusher) flush(ctx context.Context) {
	// Kirli anahtar listesinden toplu eleman cek
	keys, err := w.rdb.SPopN(ctx, w.dirtySetKey, int64(w.batchSize)).Result()
	if err != nil || len(keys) == 0 {
		return
	}

	tx, err := w.db.BeginTx(ctx, nil)
	if err != nil {
		log.Printf("Transaction baslatilamadi: %v", err)
		return
	}

	stmt, err := tx.PrepareContext(ctx, "INSERT INTO metrics (key_name, val) VALUES ($1, $2) ON CONFLICT (key_name) DO UPDATE SET val = metrics.val + EXCLUDED.val")
	if err != nil {
		tx.Rollback()
		return
	}
	defer stmt.Close()

	for _, k := range keys {
		val, err := w.rdb.GetDel(ctx, "metric:"+k).Int64()
		if err != nil {
			continue
		}
		if _, err := stmt.ExecContext(ctx, k, val); err != nil {
			log.Printf("Toplu yazma hatasi: %v", err)
			tx.Rollback()
			return
		}
	}

	if err := tx.Commit(); err != nil {
		log.Printf("Commit basarisiz: %v", err)
		return
	}
}

Bu uygulamada GetDel atomik komutu kullanılarak değer okunurken Redis üzerinden silinir. Böylece aynı değerin iki kez işlenmesi önlenir.

4. Geri Basınç (Backpressure) ve Kuyruk Şişmesi

Write-Behind mimarisinde gözden kaçan bir diğer sınır durumu veritabanının yavaşlamasıdır. Veritabanında bir kilitlenme veya checkpoint duraklaması yaşandığında flusher iş parçacığı verileri diske yazamaz.

Uygulama istemcilerden hızlıca yazma almaya devam ederken arka plan kuyruğu boşaltılamazsa:

  • Redis bellek tüketimi kontrolsüzce tırmanır.
  • Bellek dolduğunda maxmemory-policy devreye girerek henüz veritabanına yazılmamış kirli verileri bellekten tahliye edebilir (eviction felaketi).

Bu felaketi önlemek için sisteme mutlaka geri basınç (backpressure) mekanizması eklenmelidir:

  • Kirli anahtar sayısı belirlenen güvenlik sınırını (örneğin 100.000 kayıt) aştığında uygulama yeni yazma isteklerini doğrudan kabul etmemeli, istemciye HTTP 429 veya 503 dönmelidir.
  • Redis üzerinde noeviction politikası seçilerek bellek dolduğunda eski kirli verilerin sessizce silinmesi engellenmelidir.

Finansal bakiye transferleri veya yasal denetim kütükleri gibi sıfır veri kaybı toleransı olan iş yüklerinde Write-Behind asla kullanılmamalıdır. Ancak analitik metrikler, oturum süreleri, izleme kütükleri ve oyun içi liderlik tabloları gibi yüksek hacimli ve kısmi kayıpları tolere edebilen senaryolarda bu desen benzersiz bir performans avantajı sağlar.

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...