Barcha yozuvlar
Dasturlash

Bitta kalit tugadi, ming so'rov bazaga yugurdi: Redis kesh naqshlari, TTL va cache stampede

Kesh kalitining muddati tugagan sekundda nima bo'ladi va uni qanday jilovlash mumkin: cache-aside, write-through, jitter, lock, XFetch bilan erta yangilash va on_commit ichidagi invalidatsiya.

Soat 20:00, aksiya haqidagi push-xabar hozirgina jo'natildi va chegirmadagi telefon sahifasiga sekundiga bir necha ming so'rov kelyapti. Sahifa tez ochiladi, chunki mahsulot kartochkasi Redis'da besh daqiqalik TTL bilan saqlanadi. Keyin 20:05:00 da kalitning muddati tugaydi. Keyingi bir necha yuz millisekund davomida har bir so'rov bo'sh keshni ko'radi, har biri PostgreSQL'ga bir xil query bilan boradi va har biri Redis'ga bir xil qiymatni qayta yozadi. Bazaga ulanishlar pool'i tugaydi, kechikish oshadi, so'rovlarning bir qismi timeout bilan yiqiladi. Vaholanki hech narsa "buzilmagan": kesh aynan biz aytgan ishni qildi.

Bu cache stampede (uni thundering herd yoki dog-piling deb ham atashadi). Bu maqolada Django'da keshlashni bosqichma-bosqich quramiz: cache-aside, write-through va write-behind, TTL qanday tanlanadi, stampede'ni jilovlashning uchta usuli va keshga nimani umuman qo'ymaslik kerak.

Tayyorgarlik: Django'ning o'rnatilgan Redis backend'i

Django 4.0 dan beri Redis uchun o'rnatilgan backend bor; unga faqat redis paketi (redis-py) kerak. Uchinchi tomon backend'i shart emas:

# settings.py
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "TIMEOUT": 300,          # default: 5 minutes
        "KEY_PREFIX": "shop",
        "VERSION": 1,
    }
}

Ko'pchilik qoqiladigan ikki tafsilot: TIMEOUT sekundlarda beriladi, None "hech qachon tugamaydi" degani, 0 esa "darhol tugaydi" degani (amalda keshlamaslik). Redis'dagi haqiqiy kalit shop:1:product:card:42 ko'rinishida bo'ladi, ya'ni KEY_PREFIX:VERSION:key. Keshdagi ma'lumot shakli o'zgaradigan deploy'dan keyin VERSIONni bittaga oshirish hammasini birdaniga bekor qilishning arzon usuli.

Sodda versiya va u nega buziladi

Birinchi kuni ko'p kod mana shunday ko'rinadi:

from django.core.cache import cache

from .models import Product


def get_product_card(product_id: int) -> dict | None:
    return cache.get_or_set(
        f"product:card:{product_id}",
        lambda: Product.objects.filter(pk=product_id)
        .values("id", "name", "price", "stock")
        .first(),
        timeout=300,
    )

Bu ishlaydi va trafik kam bo'lganda hammasi joyida. Yuklama ostida esa uchta muammo chiqadi:

  1. "O'qi, hisobla, yoz" atomar emas. get_or_set avval get qiladi, keyin hisoblaydi, keyin yozadi. Kesh bo'sh chiqqan payt bilan yozish orasida parallel kelgan har bir so'rov ham bo'sh keshni ko'radi va u ham bazaga query yuboradi. Stampede aynan shu.
  2. Hamma kalitlarning TTL'i bir xil. Agar mingta mahsulotni bir paytda keshga yuklagan bo'lsangiz (deploy'dan keyin, keshni tozalagandan keyin), ularning muddati ham bir sekundda tugaydi. Bitta "issiq" kalit mingta issiq kalitga aylanadi.
  3. Miss narxi ko'rinmaydi. Query 5 ms olsa, stampede deyarli sezilmaydi. 800 ms olsa (agregatsiya, tashqi API chaqiruvi), u bazani yiqitishi mumkin.

Kesh hamma narsani tezlashtiradigan funksiya emas. U qimmat yo'l kamdan-kam ishlashi haqidagi va'da. Stampede aynan shu va'dani buzadi.

Uchta naqsh: cache-aside, write-through, write-behind

Naqsh Keshga kim yozadi Kuchli tomoni Xavfi
Cache-aside (lazy loading) O'quvchi, kesh bo'sh chiqqanda Oddiy, faqat haqiqatan o'qiladigan narsa keshlanadi Miss paytida stampede, TTL yoki invalidatsiyagacha eskirgan ma'lumot
Write-through Yozuvchi, bazaga yozgandan so'ng darhol O'qishlar deyarli miss bo'lmaydi Har bir yozish qimmatlashadi, hech kim o'qimaydigan narsa ham keshlanadi
Write-behind (write-back) Yozuvchi faqat keshga yozadi, baza keyinroq fonda yangilanadi Juda tez yozish Kesh flush'dan oldin o'chib qolsa, ma'lumot yo'qoladi

Cache-aside Django loyihalarida standart tanlov. Mana uning ehtiyotkorroq versiyasi:

import random

from django.core.cache import cache

from .models import Product

_MISS = object()


def jittered(base: int, spread: float = 0.1) -> int:
    """300 -> a random value between 270 and 330."""
    delta = int(base * spread)
    return base + random.randint(-delta, delta)


def card_key(product_id: int) -> str:
    return f"product:card:{product_id}"


def get_product_card(product_id: int) -> dict | None:
    key = card_key(product_id)
    cached = cache.get(key, _MISS)
    if cached is not _MISS:
        return cached  # may be None: "this product does not exist"

    card = (
        Product.objects.filter(pk=product_id)
        .values("id", "name", "price", "stock")
        .first()
    )
    # negative caching: remember "not found" too, but briefly
    ttl = 30 if card is None else jittered(300)
    cache.set(key, card, timeout=ttl)
    return card

Sodda versiyaga nisbatan nima o'zgardi:

  • None o'rniga sentinel. cache.get(key) kalit yo'q bo'lganda ham, siz None saqlagan bo'lsangiz ham None qaytaradi. _MISS bilan bu ikki holatni ajrata olamiz va "bunday mahsulot yo'q" degan javobni ham keshlay olamiz (negative caching). Busiz mavjud bo'lmagan ID'larni terib chiqayotgan bot har bir so'rovda bazaga boradi.
  • TTL'ga jitter. ±10% muddatlar tugashini vaqt bo'yicha yoyib yuboradi, birga yuklangan kalitlar birga tugamaydi.
  • Model obyekti emas, dict keshlanadi. pickle qilingan model obyekti model kodiga bog'langan; modelni o'zgartiradigan deploy'dan keyin Redis'dagi eski qiymatlar unga mos kelmay qolishi mumkin. Faqat kerakli maydonlardan iborat oddiy dict kichikroq va xavfsizroq.

Write-through keshni bazaga yozayotgan joyning o'zida yangilash degani. Django'da buni commit'dan keyin qilish muhim (bu haqda quyida batafsil):

def set_price_write_through(product_id: int, price) -> None:
    def refresh() -> None:
        card = (
            Product.objects.filter(pk=product_id)
            .values("id", "name", "price", "stock")
            .first()
        )
        cache.set(card_key(product_id), card, timeout=jittered(300))

    with transaction.atomic():
        Product.objects.filter(pk=product_id).update(price=price)
        transaction.on_commit(refresh)

Write-behind ilova faqat Redis'ga yozadi, fon worker'i (masalan, Celery) esa vaqti-vaqti bilan o'zgarishlarni PostgreSQL'ga tushiradi. Bu ko'rishlar yoki layk'lar kabi hisoblagichlar uchun to'g'ri keladi, u yerda bir nechta increment yo'qolsa, katta gap emas. Pul, buyurtmalar va statuslar uchun esa yo'q: Redis flush'dan oldin qayta ishga tushsa, ma'lumot yo'qoladi va PostgreSQL haqiqat manbai bo'lishdan to'xtaydi.

TTL'ni qanday tanlash kerak

"To'g'ri" TTL degan narsa yo'q, bitta savol bor: foydalanuvchi eskirgan ma'lumotni real zararsiz qancha vaqt ko'rishi mumkin?

  • Katalog, kategoriyalar, ommaviy sozlamalar: daqiqalardan soatlargacha, o'zgarganda esa aniq invalidatsiya.
  • Og'ir agregatlar (dashboard'lar, hisobotlar): biznes qancha ruxsat bersa, shuncha; ko'pincha fonda qayta hisoblanadi.
  • Salbiy natijalar ("topilmadi"): qisqa, bir necha sekunddan bir daqiqagacha, aks holda yangi yaratilgan obyekt "ko'rinmas" bo'lib qoladi.
  • timeout=None bilan saqlanadigan hamma narsa: faqat ishonchli aniq invalidatsiya bo'lsa, aks holda eskirgan qiymat abadiy yashaydi.

TTL bu sug'urta to'ri. Har bir yozishda invalidatsiya qilsangiz ham, cheklangan TTL qoldiring: bitta invalidatsiya yo'qolsa (commit bilan delete orasida jarayon yiqilsa), ma'lumot o'z-o'zidan tuzaladi.

Stampede'ni jilovlash

1. Lock: faqat bitta jarayon qayta hisoblaydi

G'oya shunday: kesh bo'sh chiqqanda bitta jarayon qisqa lock oladi va qiymatni hisoblaydi, qolganlar biroz kutib, natijani keshdan o'qiydi. Django'da buning uchun cache.add() juda mos keladi: Redis backend'ida u SET ... NXga aylanadi, bu esa atomar amal, Trueni faqat bittasi oladi.

import time
from collections.abc import Callable
from typing import Any

from django.core.cache import cache

_MISS = object()


def get_or_compute_locked(
    key: str,
    compute: Callable[[], Any],
    ttl: int = 300,
    lock_ttl: int = 10,
    wait: float = 3.0,
) -> Any:
    value = cache.get(key, _MISS)
    if value is not _MISS:
        return value

    lock_key = f"lock:{key}"
    deadline = time.monotonic() + wait
    while True:
        # add() == SET NX: only one process gets True
        if cache.add(lock_key, "1", timeout=lock_ttl):
            try:
                value = cache.get(key, _MISS)  # double-check
                if value is _MISS:
                    value = compute()
                    cache.set(key, value, timeout=jittered(ttl))
                return value
            finally:
                cache.delete(lock_key)

        time.sleep(0.05)
        value = cache.get(key, _MISS)
        if value is not _MISS:
            return value
        if time.monotonic() >= deadline:
            return compute()  # do not hang forever; fall back to the DB

(jittered yuqoridagi cache-aside misolidagi yordamchi funksiya.)

Muhim tafsilotlar: lock olingandan keyin qayta tekshirish (biz kutayotganimizda kimdir keshni to'ldirgan bo'lishi mumkin), lock'ning o'zida TTL (jarayon o'lib qolsa, lock o'zi yo'qoladi) va kutayotganlar uchun deadline (so'rovni osib qo'ygandan ko'ra bir marta bazaga borgan yaxshi).

Bu versiyaning nozik zaif joyi bor: compute() lock_ttldan uzoqroq ishlasa, lock muddati tugaydi, uni boshqa jarayon oladi, bizning finally esa birovning lock'ini o'chiradi. Qisqa hisob-kitoblar uchun bu maqbul. Uzoqlari uchun egasining tokeni bor lock kerak. redis-py'da u tayyor holda bor: bo'shatishda Lua skript tokenni solishtiradi va kalit hali bizniki bo'lsagina uni o'chiradi.

import redis

r = redis.Redis.from_url("redis://127.0.0.1:6379/1")


def rebuild_report(report_id: int) -> None:
    lock = r.lock(f"lock:report:{report_id}", timeout=30, blocking_timeout=5)
    if not lock.acquire():
        return  # someone else is already rebuilding it
    try:
        ...  # heavy computation + cache.set(...)
    finally:
        # deletes the key only if our token is still there (Lua script)
        lock.release()

2. Jitter: kalitlarni birga tugashiga yo'l qo'ymaslik

Biz uni allaqachon jittered()ga qo'shdik. Bitta juda issiq kalitdan u qutqarmaydi, lekin deploy yoki keshni tozalashdan keyingi "sinxron" stampede'larni yo'qotadi. Bir qator kod turadi, hamma joyda ishlating.

3. Erta yangilash: muddat tugashidan oldin qayta hisoblash

Lock foydalanuvchilarni qayta hisoblashni kutishga majbur qiladi. Issiq kalitlar uchun yaxshiroq yo'l ularning muddatini yuklama ostida umuman tugatmaslik. Ehtimoliy erta tugash algoritmi (XFetch, Vattani, Chierichetti va Lowenstein'ning "Optimal Probabilistic Cache Stampede Prevention" maqolasidan) shunday ishlaydi: qiymat bilan birga uni hisoblash qancha vaqt olganini (delta) va qiymat mantiqan qachon tugashini saqlaymiz. Har bir o'qishda so'rov "zar tashlaydi": muddat tugashiga qancha yaqin bo'lsak va qayta hisoblash qancha qimmat bo'lsa, aynan shu so'rov qiymatni oldindan qayta hisoblash ehtimoli shuncha yuqori, qolganlar esa hali eski qiymatni oladi.

import math
import random
import time
from collections.abc import Callable
from typing import Any

from django.core.cache import cache


def get_xfetch(
    key: str,
    compute: Callable[[], Any],
    ttl: int = 300,
    beta: float = 1.0,
) -> Any:
    entry = cache.get(key)
    if entry is not None:
        value, delta, expires_at = entry
        # 1 - random() is in (0, 1], so log() never sees zero
        jitter = -delta * beta * math.log(1.0 - random.random())
        if time.time() + jitter < expires_at:
            return value  # still fresh enough

    started = time.time()
    value = compute()
    delta = time.time() - started  # how long the recompute took
    cache.set(key, (value, delta, time.time() + ttl), timeout=ttl)
    return value

(0, 1] oralig'idagi tekis taqsimlangan u uchun -log(u) musbat tasodifiy son: odatda kichik, lekin ba'zan katta. Shuning uchun muddat tugashidan uzoqda deyarli hech kim qayta hisoblamaydi, oxirgi bir necha delta ichida esa bir-ikkita so'rov buni kalit hali joyida turganda qiladi. beta > 1 yangilashni ertaroqqa, beta < 1 kechroqqa suradi. Shu g'oyaning boshqa varianti fonda yangilash: Celery beat vazifasi har N daqiqada mashhur kalitlarni qayta hisoblaydi va foydalanuvchilar miss'ni umuman ko'rmaydi.

Invalidatsiya va transaction'lar

Django'da kesh bilan bog'liq eng ko'p uchraydigan production xatosi stampede emas, balki noto'g'ri paytda qilingan invalidatsiya.

from django.core.cache import cache
from django.db import transaction

from .models import Product


# WRONG: the cache changes before the transaction is committed
def set_price_wrong(product_id: int, price) -> None:
    with transaction.atomic():
        Product.objects.filter(pk=product_id).update(price=price)
        cache.delete(card_key(product_id))
        # ...more work here; if it raises, the DB rolls back,
        # but a concurrent reader may already have re-cached the old row


# RIGHT: invalidate only after COMMIT
def set_price(product_id: int, price) -> None:
    with transaction.atomic():
        Product.objects.filter(pk=product_id).update(price=price)
        transaction.on_commit(lambda: cache.delete(card_key(product_id)))

(card_key cache-aside misolidan.)

Birinchi versiya nega noto'g'ri: COMMIT'gacha boshqa transaction'lar eski qatorni ko'radi (READ COMMITTED). Kalitni transaction ichida o'chirsangiz, parallel o'quvchi miss oladi, bazadan eski narxni o'qiydi va uni keyingi besh daqiqaga keshga qaytarib qo'yadi. transaction.on_commit() callback'ni faqat muvaffaqiyatli commit'dan keyin chaqiradi, transaction rollback bo'lsa esa umuman chaqirmaydi.

on_commit bilan ham kamdan-kam uchraydigan poyga holati qoladi: o'quvchi eski qatorni bizning commit'dan oldin o'qigan, lekin keshga bizning deletedan keyin yozgan. Oldingi bo'limdagi cheklangan TTL ixtiyoriy emasligining sababi ham shu.

Nimani keshlamaslik kerak

  • Balanslar, to'lov va buyurtma statuslari, sotish haqida qaror qabul qilinayotgan paytdagi qoldiqlar. Bunday qarorlar haqiqat manbaini transaction ichida o'qishi kerak (kerak bo'lsa select_for_update bilan). Kesh "omborda bor" belgisini ko'rsatishi mumkin, lekin to'lov o'tadimi yoki yo'qmi, buni hal qilmasligi kerak.
  • Idempotentlik natijalari va qayta ishga tushishdan keyin ham saqlanib qolishi kerak bo'lgan hamma narsa. Eviction siyosati yoqilgan Redis istalgan paytda kalitni o'chirishga haqli.
  • Umumiy kalit ostidagi foydalanuvchi ma'lumotlari. Foydalanuvchi ismi yoki CSRF token ko'rsatiladigan sahifaga cache_page qo'ysangiz, bir foydalanuvchining sahifasi boshqasiga ketadi. Bunday view'larni yo keshlamang, yo foydalanuvchini kalitga qo'shing.
  • Uzun TTL bilan huquqlar va rollar. Bekor qilingan ruxsat yana bir soat ishlab tursa, bu xavfsizlik xatosi.
  • Juda katta qiymatlar. Bir necha megabaytlik qiymat har bir o'qishda sekin (de)serializatsiya qilinadi va tarmoq orqali sekin uzatiladi. Butun queryset'ni emas, ixcham dict'ni keshlang.

Production'dagi tuzoqlar

  • maxmemory-policy. Redis'ning standart siyosati noeviction: xotira to'lganda yozish amallari xato bilan qaytadi. Sof kesh uchun odatda allkeys-lru yoki allkeys-lfu kerak.
  • Kesh va Celery uchun bitta Redis. maxmemory va eviction siyosati baza raqamiga emas, butun instance'ga ta'sir qiladi. allkeys-lru bilan Redis Celery navbatlaringizni ham chiqarib tashlashi mumkin. Broker va keshni alohida instance'larda saqlang.
  • Redis ishlamay qolsa. Django'ning o'rnatilgan backend'i ulanish xatolarini jimgina yutib yubormaydi. Ongli qaror qiling: sayt bazaga borishi kerakmi (baza bu yuklamani ko'tara oladimi?) yoki xato qaytarishi kerakmi?
  • Shablon bo'yicha invalidatsiya uchun KEYS *. Katta keyspace'da u Redis'ni bloklab qo'yadi. SCAN ishlating, undan ham yaxshisi kalitlarni versiyalash (VERSION yoki kalitning o'zidagi versiya raqami).
  • Taxmin qilmang, o'lchang. Hit ratio va eviction'larni kuzating:
# hit/miss counters since the last restart
redis-cli INFO stats | grep -E "keyspace_(hits|misses)|evicted_keys"

# what happens when memory runs out?
redis-cli CONFIG GET maxmemory
redis-cli CONFIG GET maxmemory-policy

# remaining TTL of a specific key (Django key = prefix:version:key)
redis-cli TTL "shop:1:product:card:42"

Agar evicted_keys muntazam o'sib borsa, kesh ishchi to'plamingiz uchun kichiklik qilyapti va muammo TTL sozlamasida emas.

Checklist

  • Model obyektlari yoki butun queryset'larni emas, kerakli maydonlardan iborat dict'larni keshlang.
  • "Kalit yo'q" bilan "keshlangan None"ni ajratish uchun sentinel ishlating; salbiy natijalarni qisqa muddatga keshlang.
  • Har bir TTL'ga jitter qo'shing.
  • Qimmat yoki issiq kalitlar uchun: cache.add() / redis.lock() orqali lock yoki erta yangilash.
  • Invalidatsiyani transaction.on_commit() ichida qiling, hech qachon transaction ichida emas.
  • Aniq invalidatsiya bo'lsa ham, sug'urta sifatida doim cheklangan TTL qoldiring.
  • Pulga oid qarorlarni keshga tayanib qabul qilmang.
  • Kesh va Celery broker'i uchun alohida Redis; maxmemory-policyni ongli ravishda belgilang.
  • keyspace_hits, keyspace_misses va evicted_keysni kuzatib boring.

Xulosa

Kesh qimmat query'ni arzon qilmaydi, u faqat uni kamdan-kam ishlatadi, stampede esa "kamdan-kam" "hammasi birdaniga"ga aylanadigan lahza. Sentinel bilan cache-aside, jitter'li TTL va on_commit ichidagi invalidatsiya ko'pchilik Django loyihalari ehtiyojini qoplaydi. Issiq va qimmat kalitlar uchun lock yoki erta yangilash qo'shing, pul haqida qaror qiladigan hamma narsani esa PostgreSQL'da qoldiring.

// izohlar

Izohlar yuklanmoqda...

    // keyingi qadam

    Keling, birga nimadir quramiz.

    Telegramda yozish
    aslbek@asldev: ~
    ❯