Cloud & IT Cert Prep · Ders

Önbellekleme Stratejileri: Tembel Yükleme ve Yazma Üzerinden Geçirme

Önbellek kaçırmalarında önbelleği doldurmak için tembel yüklemeyi, her veritabanı yazma işleminde önbelleği tutarlı tutmak için yazma üzerinden geçirmeyi uygulayın.

Önbellekleme Stratejileri: Tembel Yükleme ve Yazma Üzerinden Geçirme, CoddyKit'te ücretsiz bir Cloud & IT Cert Prep dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Cloud & IT Cert Prep öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Cloud & IT Cert Prep kursu toplamda 4 dersten oluşur.

Önbelleğe Alma Stratejileri Neden Önemlidir

Uygulamanız ile veritabanınız arasına bir önbellek eklemek, verilerin ne zaman önbelleğe alınacağını, ne zaman önbellekten okunacağını ve ne zaman çıkarılacağını belirleyen bir dizi kuraldan, yani bir önbelleğe alma stratejisinden yararlanmanızı gerektirir. Yanlış stratejiyi seçmek; güncel olmayan verilere (önbelleğin eski değerler döndürmesi), soğuk önbellek isabet kayıplarına (önbelleğin boş olması ve her isteğin veritabanına gitmesi) veya önbellek yığılmasına (aynı eksik anahtar için çok sayıda eşzamanlı isteğin veritabanına aynı anda gitmesi) yol açar. Temel iki strateji lazy loading ve write-through'tur.

Lazy Loading (Önbellek Yanı): Nasıl Çalışır

Lazy loading (önbellek yanı olarak da adlandırılır), en yaygın önbelleğe alma modelidir. Uygulama önce önbelleği kontrol eder. Önbellek isabetinde veriler doğrudan önbellekten döndürülür; bu hızlı yoldur. Önbellek isabet kaybında uygulama verileri veritabanından alır, sonucu bir TTL ile önbelleğe yazar ve çağırana döndürür. Önbelleğe yalnızca gerçekten istenen veriler alınır; bu nedenle yönteme lazy adı verilir. Aynı anahtara yönelik sonraki istekte veri önbellekte bulunur.

# Lazy loading pattern (Python with redis-py)
def get_user(user_id, redis_client, db):
    cache_key = f'user:{user_id}'

    # 1. Check cache
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)   # Cache HIT

    # 2. Cache MISS: fetch from DB
    user = db.query('SELECT * FROM users WHERE id = %s', user_id)

    # 3. Populate cache with TTL of 300 seconds
    redis_client.setex(cache_key, 300, json.dumps(user))

    return user

Lazy Loading: Avantajları

Lazy loading'in üç temel avantajı vardır: yalnızca istenen veriler önbelleğe alınır; kimsenin okumadığı verilerle önbellek doldurulmaz, böylece bellek verimli kullanılır. Soğuk önbellek uygulamayı bozmaz; önbellek isabet kayıplarında uygulama veritabanına geri döner. Bu nedenle ElastiCache yeniden başlatılsa veya bir düğüm başarısız olsa bile uygulama daha yüksek gecikmeyle çalışmaya devam eder. Önbellek veritabanıyla her zaman nihai olarak tutarlıdır; güncellemeler atlanmış olsa bile güncel olmayan verilerin süresi TTL aracılığıyla dolar.

Lazy Loading: Dezavantajları

Lazy loading'in üç temel dezavantajı vardır: önbellek isabet kayıpları maliyetlidir; isabet durumundaki tek işleme karşılık üç işlem (önbellek kontrolü, veritabanı okuması ve önbellek yazması) gerektiğinden soğuk isteklerde gecikme artar. Güncel olmayan veriler; veritabanı güncellendikten sonra TTL dolana veya anahtar açıkça geçersiz kılınana kadar önbellek eski değeri sunmaya devam eder (önbellek tutarsızlığı aralığı). Önbellek yığılması; popüler bir anahtarın süresi dolarsa çok sayıda eşzamanlı istek önbellek isabet kaybı yaşar ve veritabanına eşzamanlı olarak gider; bu da veritabanını aşırı yükleyebilir.

# Mitigating cache stampede with a probabilistic early expiration
# (Refresh the key before it expires to avoid simultaneous misses)
def get_with_stampede_protection(key, redis_client, db_fetch_fn, ttl=300):
    value = redis_client.get(key)
    ttl_remaining = redis_client.ttl(key)

    # Probabilistically refresh before expiry
    if value is None or (ttl_remaining < 30 and random.random() < 0.1):
        value = db_fetch_fn()
        redis_client.setex(key, ttl, json.dumps(value))
    return json.loads(value)

Write-Through: Nasıl Çalışır

Write-through stratejisinde veritabanına yapılan her yazma işlemi aynı anda önbelleğe de yazılır. Uygulama, aynı işlemin parçası olarak hem önbelleğe hem veritabanına yazar (veya veritabanı bir önbellek güncellemesini tetikler). Böylece önbellek her zaman veritabanıyla senkronize olur; güncel olmayan veri aralığı oluşmaz. Write-through, önbellekteki verilerin her zaman güncel olmasını garanti eder ve yakın zamanda yazılan veriler için sonraki okumaların her zaman önbellek isabeti olmasını sağlar.

# Write-through pattern (Python)
def update_user(user_id, user_data, redis_client, db):
    # 1. Write to database FIRST
    db.execute('UPDATE users SET name=%s WHERE id=%s',
                (user_data['name'], user_id))

    # 2. Update cache immediately (write-through)
    cache_key = f'user:{user_id}'
    redis_client.setex(cache_key, 3600, json.dumps(user_data))

    return user_data

# Every read is now a cache hit for recently updated data

Write-Through: Avantajları

Write-through avantajları: önbellek verileri her zaman günceldir; her yazma işleminde önbellek güncellendiği için güncel olmayan veri oluşmaz. Okumalar her zaman hızlıdır; sık yazılan popüler veriler her zaman önbellektedir. Okumalarda önbellek yığılması oluşmaz; veriler okunmadan önce önceden doldurulduğu için yakın zamanda yazılan verilerde soğuk isabet kayıpları yaşanmaz. Bu strateji, ürün katalogları, fiyatlandırma sistemleri veya kullanıcı profili önbellekleri gibi sık güncellenen ve okuma ağırlıklı iş yükleri için idealdir.

Write-Through: Dezavantajları

Write-through dezavantajları: yazma cezası; her yazma işlemi iki işlem (veritabanı ve önbellek) gerektirdiğinden yazma gecikmesini artırır. Önbellek kirliliği; veriler bir daha hiç okunmayacak olsa bile önbelleğe alınır (bir kez yazılır, bir daha istenmez) ve önbellek belleği boşa harcanır. Önbelleğin yeniden başlatılması soğuk önbelleğe neden olur; önbellek kümesi yeniden başlatılırsa önceden yazılmış tüm veriler kaybolur ve önbelleğin yazma işlemleri veya bir önbellek ısıtma süreci aracılığıyla yeniden doldurulması gerekir. Nadiren okunan önbellek verilerinin sınırsız büyümesini önlemek için write-through yöntemini bir TTL ile birleştirin.

Lazy Loading ve Write-Through'u Birleştirme

Uygulamada birçok üretim sistemi her iki stratejiyi birleştirir: sık güncellenen ve sık okunan veriler (kullanıcı oturumları veya güncel fiyatlar gibi) için write-through, nadiren güncellenen ve sık okunan veriler (ürün açıklamaları veya makale içerikleri gibi) için lazy loading kullanın. Her ikisinde de uygun TTL değerleri belirleyin: write-through anahtarlarına veriler her zaman güncel olduğundan uzun bir TTL, lazy loading anahtarlarına ise güncel olmayan veri aralığını sınırlamak için daha kısa bir TTL verin. Bu hibrit yaklaşım, güncelliğini yitirmeyi en aza indirirken önbellek isabet oranını en üst düzeye çıkarır.

# Hybrid: write-through for sessions, lazy loading for product data

# Write-through for session data (always fresh, critical)
def save_session(session_id, data, redis_client, db):
    db.upsert('sessions', session_id, data)
    redis_client.setex(f'session:{session_id}', 3600, json.dumps(data))

# Lazy loading for product catalog (infrequent updates OK)
def get_product(product_id, redis_client, db):
    cached = redis_client.get(f'product:{product_id}')
    if cached:
        return json.loads(cached)
    product = db.query('SELECT * FROM products WHERE id=%s', product_id)
    redis_client.setex(f'product:{product_id}', 86400, json.dumps(product))
    return product

TTL Tasarım İlkeleri

Önbelleğe alınan verilerdeki Time-To-Live (TTL) değeri, güncel olmayan veri aralığının maksimum süresini ve önbelleğin bellek kullanımını belirler. TTL değerlerini şunlara göre tasarlayın: veri güncelleme sıklığı (oturum verileri sık değişir → kısa TTL; statik içerik nadiren değişir → uzun TTL), güncelliğini yitirmeye tolerans (finansal fiyatlar → çok kısa; blog yazısı metni → saatler veya günler) ve önbellek bellek kapasitesi (düşük bellek → güncel olmayan verileri daha hızlı çıkarmak için daha kısa TTL). Her zaman TTL belirleyin; süresi dolmadan verileri asla önbelleğe almayın, aksi hâlde önbellek zamanla güncel olmayan verilerle dolar.

# TTL examples by data type

# API rate limit counter: 60 seconds
redis_client.setex(f'ratelimit:{ip}', 60, count)

# User session: 30 minutes
redis_client.setex(f'session:{id}', 1800, json.dumps(session))

# Product catalog: 24 hours
redis_client.setex(f'product:{id}', 86400, json.dumps(product))

# Stock price: 10 seconds
redis_client.setex(f'price:{symbol}', 10, price)

# Static site content: 7 days
redis_client.setex(f'page:{slug}', 604800, html_content)

Güncelleme Sırasında Önbelleği Geçersiz Kılma

Yalnızca TTL süresinin dolmasına güvenmek yerine, temel veriler değiştiğinde önbellek anahtarlarını açıkça geçersiz kılabilirsiniz (silebilirsiniz). Böylece güncel olmayan veri aralığı tamamen ortadan kalkar. Yaygın modeller: yazma sırasında silme (her veritabanı güncellemesinden sonra önbellek anahtarını silmek; sonraki okuma anahtarı lazy loading aracılığıyla yeniden doldurur), olay güdümlü geçersiz kılma (DynamoDB Streams veya RDS değişiklik yakalama, etkilenen anahtarları silen bir Lambda'yı tetikler). Önbelleği geçersiz kılma, dağıtık sistemlerdeki en zor sorunlardan biridir; geçersiz kılma mantığınız ne kadar basitse önbelleğiniz de o kadar güvenilir olur.

# Delete-on-write invalidation pattern
def update_product(product_id, new_data, redis_client, db):
    # Update the database
    db.execute('UPDATE products SET ... WHERE id=%s', (product_id,))

    # Invalidate the cache key
    redis_client.delete(f'product:{product_id}')

    # Also invalidate any list/search caches that may include this product
    redis_client.delete('products:list:page:1')
    redis_client.delete(f'products:category:{new_data["category_id"]}')

    # Next read will trigger lazy loading with fresh data

Write-Behind (Write-Back) Önbelleğe Alma

Daha az yaygın ancak güçlü bir model olan write-behind (write-back) yönteminde uygulama yalnızca önbelleğe yazar ve önbellek verileri arka planda eşzamansız olarak veritabanına aktarır. Bu yöntem, önbellek verileri aktaramadan önce başarısız olursa veri kaybı olabilmesi karşılığında son derece hızlı yazma işlemleri (yalnızca bellekte) sağlar. Write-behind; verilerin yeniden oluşturulabildiği veya küçük kayıpların kabul edilebilir olduğu yüksek sıklıklı ve yüksek hacimli yazma işlemleri için uygundur; örneğin isabet sayaçları, analiz olayları veya oyun skorlarının güncellenmesi. ElastiCache write-behind özelliğini yerel olarak desteklemez; bunun uygulama katmanında uygulanması gerekir.

# Write-behind pattern: write to cache, flush to DB asynchronously
# Application writes:
# redis_client.incr('post:42:views')      # fast, in-memory only

# Background job (runs every 60 seconds):
def flush_view_counts(redis_client, db):
    for key in redis_client.scan_iter('post:*:views'):
        count = redis_client.getdel(key)  # atomic get-and-delete
        post_id = key.split(':')[1]
        db.execute('UPDATE posts SET views = views + %s WHERE id = %s',
                   (int(count), post_id))

Hızlı Kontrol

Bu dersteki AWS Solutions Architect (SAA-C03) kavramlarını anlayıp anlamadığınızı test edin.

Ders Özeti

Bu derste şunları öğrendiniz: lazy loading, okuma isabet kayıplarında önbelleği doldurur ve belleği verimli kullanır, ancak TTL süresi dolana kadar güncel olmayan veriler sunabilir; write-through, her yazma işleminde önbelleği günceller ve güncel olmayan veri oluşmasını engeller, ancak okunmayan veriler için bellek harcar; açık geçersiz kılma ise güncel olmayan veri aralıklarını ortadan kaldırmak için veritabanı güncellemelerinde önbellek anahtarlarını siler. Sırada ElastiCache ile oturum depolama ve liderlik tablosu modellerini inceleyeceğiz.

Sıkça Sorulan Sorular

“Önbellekleme Stratejileri: Tembel Yükleme ve Yazma Üzerinden Geçirme” dersi ücretsiz mi?

Evet — “Önbellekleme Stratejileri: Tembel Yükleme ve Yazma Üzerinden Geçirme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Cloud & IT Cert Prep kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Cloud & IT Cert Prep kursu toplamda 4 dersten oluşur.

“Önbellekleme Stratejileri: Tembel Yükleme ve Yazma Üzerinden Geçirme” dersinde ne öğreneceğim?

Önbellek kaçırmalarında önbelleği doldurmak için tembel yüklemeyi, her veritabanı yazma işleminde önbelleği tutarlı tutmak için yazma üzerinden geçirmeyi uygulayın. Cloud & IT Cert Prep ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Cloud & IT Cert Prep öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Cloud & IT Cert Prep, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Önbellekleme Stratejileri: Tembel Yükleme ve Yazma Üzerinden Geçirme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Cloud & IT Cert Prep dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Cloud & IT Cert Prep dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

Redis ve Memcached: Doğru Motoru Seçme
ElastiCache Redis Çoğaltma Grupları ve Küme Kipi
Önbellekleme Stratejileri: Tembel Yükleme ve Yazma Üzerinden Geçirme
Oturum Depolama ve Liderlik Tablosu Örüntüleri

← Cloud & IT Cert Prep Sayfasına Dön