Kesh invalidatsiyasi: kesh o'chirildi, sahifada esa hamon eski narx
post_save'da keshni o'chirish nega eski narxni qaytarib qo'yadi, on_commit buni qanday tuzatadi, guruh uchun versiyalangan kalitlar va 12 ta worker'dagi lokal kesh bilan nima qilish kerak.
Tasavvur qiling: internet-do'kon sahifasi. Operator admin panelda mahsulot narxini 12 000 so'mdan 15 000 so'mga o'zgartirib, "Saqlash"ni bosdi. Kod to'g'ri yozilgan: saqlangandan keyin post_save signali mahsulot kalitini Redis'dan o'chiradi. Lekin o'n daqiqadan keyin ham mijoz sahifada 12 000 ni ko'ryapti. Kesh o'chirildi, unga hech kim qo'lda yozmadi, eski narx esa joyida turibdi.
Mashhur hazil bor: dasturlashda faqat ikkita qiyin narsa bor, kesh invalidatsiyasi va nom berish. Bu hazil yashab kelayotganining sababi, u haqiqat. Biror narsani keshga qo'yish oson. Qiyini shu nusxa qachon eskirganini aniq bilish va uni aynan o'z vaqtida o'chirish. O'tgan maqolada kesh naqshlari, TTL va cache stampede haqida gaplashgandik. Bu yerda bitta savolga e'tibor qaratamiz: keshni eski ma'lumotni to'g'ri "unutishga" qanday majburlash mumkin.
Nega invalidatsiya qiyin
Kesh ma'lumotning ikkinchi nusxasi. Ikkita nusxa paydo bo'lishi bilan ular bir-biriga zid bo'lishi mumkin. Baza haqiqatni saqlaydi, kesh esa o'tmishdagi bir lahzaning surati. Invalidatsiya (invalidation) bu "shu surat endi yaroqsiz" deyish degani.
Uni qiyinlashtiradigan uchta narsa bor:
- Parallellik. Yozuvchilar va o'quvchilar bir vaqtda, turli process'larda, ko'pincha turli serverlarda ishlaydi. "Bazani yangilash, keyin keshni o'chirish" ketma-ketligi atomar emas: ikki qadam orasida har narsa sodir bo'lishi mumkin.
- Tranzaksiyalar. Kodingiz ma'lumotni o'zgartirdim deb o'ylaydi, baza esa hali commit qilmagan. Boshqa ulanishlar hamon eski qatorni ko'radi.
- Hosila ma'lumotlar. Bitta mahsulot o'z kalitida, kategoriya ro'yxatida, bosh sahifada, qidiruv natijalarida, keshlangan shablon bo'lagida turadi.
product:42ni o'chirish ularning hech biriga tegmaydi.
Boshlang'ich nuqta, klassik cache-aside o'qish:
# catalog/cache.py
from django.core.cache import cache
from catalog.models import Product
PRODUCT_TTL = 60 * 10 # 10 minutes
def product_key(product_id: int) -> str:
return f"product:{product_id}"
def get_product_data(product_id: int) -> dict:
key = product_key(product_id)
data = cache.get(key)
if data is None:
product = Product.objects.get(pk=product_id)
data = {
"id": product.pk,
"name": product.name,
"price": str(product.price),
}
cache.set(key, data, PRODUCT_TTL)
return data
1-yondashuv: faqat TTL ga tayanish
Eng oddiy invalidatsiya umuman invalidatsiya qilmaslik: har bir kalitning TTL'i bor va ma'lumot ko'pi bilan shuncha vaqt eskirgan bo'lishiga ruxsat beriladi. Bu halol yondashuv va ko'pincha yetarli. Mahsulot tavsifi 10 daqiqa kechikib yangilansa, hech kim zarar ko'rmaydi.
Muammo biznes "narx darhol o'zgarishi kerak" deganda boshlanadi. TTL'ni 5 soniyagacha qisqartirsangiz, hit ratio tushib ketadi va yana bazaga yugurasiz. TTL eskirishning yuqori chegarasi, invalidatsiya strategiyasi emas. Lekin buni yodda tuting: har bir kalitda baribir TTL bo'lishi shart, chunki quyidagi har qanday usul ishdan chiqishi mumkin, TTL esa zararni cheklaydigan xavfsizlik to'ri.
2-yondashuv: signalda o'chirish va nega u buziladi
Keyingi tabiiy qadam, model saqlanganda kalitni o'chirish:
# catalog/signals.py -- WRONG
from django.core.cache import cache
from django.db.models.signals import post_save
from django.dispatch import receiver
from catalog.cache import product_key
from catalog.models import Product
@receiver(post_save, sender=Product)
def drop_product_cache(sender, instance, **kwargs):
# Runs inside the transaction, BEFORE commit
cache.delete(product_key(instance.pk))
# catalog/services.py
from django.db import transaction
from catalog.models import PriceHistory, Product
def change_price(product_id: int, new_price) -> None:
with transaction.atomic():
product = Product.objects.select_for_update().get(pk=product_id)
product.price = new_price
product.save(update_fields=["price"]) # post_save -> cache.delete()
PriceHistory.objects.create(product=product, price=new_price)
# COMMIT happens only here
post_save qayerda ishlashiga qarang: UPDATE so'rovidan keyin darhol, lekin hali transaction.atomic() ichida. Commit faqat with bloki tugaganda bo'ladi. PostgreSQL'ning standart izolyatsiya darajasi READ COMMITTED da boshqa ulanishlar commit qilinmagan o'zgarishlarni ko'rmaydi. Natijada quyidagi vaqt chizig'i hosil bo'ladi:
| Qadam | A so'rov (admin, yozuvchi) | B so'rov (mijoz, o'quvchi) |
|---|---|---|
| 1 | UPDATE price = 15000 (commit qilinmagan) |
|
| 2 | post_save → cache.delete("product:42") |
|
| 3 | INSERT INTO pricehistory ... |
product:42 keshda yo'q |
| 4 | SELECT → eski qatorni ko'radi, 12000 |
|
| 5 | cache.set("product:42", 12000) |
|
| 6 | COMMIT |
6-qadamdan keyin bazada 15 000, keshda 12 000, va TTL tugamaguncha buni hech narsa tuzatmaydi. 2- va 6-qadamlar orasidagi oyna tranzaksiyaning qolgan qismi qancha davom etsa, shuncha uzun: bitta qo'shimcha INSERT, tashqi API'ga murojaat, sekin query. ATOMIC_REQUESTS = True bo'lsa, butun view bitta tranzaksiya, demak oyna so'rov oxirigacha ochiq turadi. Mashhur mahsulotda bu oynaga kimdir albatta tushadi.
Ikkinchi, sezilmas xato ham bor: tranzaksiya rollback bo'lsa, biz mutlaqo to'g'ri kesh yozuvini bekorga o'chirib yuborgan bo'lamiz. To'g'rilikka zarari yo'q, lekin signal noto'g'ri paytda ishlayotganini ko'rsatadi.
Yechim: transaction.on_commit
Django'da aynan "ma'lumot bazaga haqiqatan yozilgandan keyin buni bajar" uchun hook bor: transaction.on_commit(). Callback saqlab qo'yiladi va faqat eng tashqi tranzaksiya muvaffaqiyatli commit bo'lgandan keyin chaqiriladi. Tranzaksiya rollback bo'lsa, callback tashlab yuboriladi. Faol tranzaksiya bo'lmasa (autocommit rejimi), u darhol ishlaydi.
# catalog/signals.py
from functools import partial
from django.core.cache import cache
from django.db import transaction
from django.db.models.signals import post_delete, post_save
from django.dispatch import receiver
from catalog.cache import product_key
from catalog.models import Product
@receiver(post_save, sender=Product)
@receiver(post_delete, sender=Product)
def drop_product_cache(sender, instance, using, **kwargs):
transaction.on_commit(
partial(cache.delete, product_key(instance.pk)),
using=using,
robust=True,
)
# catalog/apps.py
from django.apps import AppConfig
class CatalogConfig(AppConfig):
name = "catalog"
def ready(self):
from catalog import signals # noqa: F401
Muhim tafsilotlar:
using=using. Signal baza alias'ini beradi. Bir nechta baza bo'lsa, callback to'g'ri ulanishning tranzaksiyasiga bog'lanishi kerak.robust=True(Django 4.2+). Redis ishlamay qolsa, xato log'ga yoziladi va boshqaon_commitcallback'lari baribir ishlaydi. Ma'lumot allaqachon commit bo'lgan; shu nuqtada so'rovni xato bilan tugatish foydalanuvchini faqat chalg'itadi.lambdaemas,partial.partialproduct_key(instance.pk)ni hozirning o'zida hisoblaydi.lambdaesainstance.pkni keyinroq, commit paytida o'qiydi. Tashqi tranzaksiya ichidagipost_deleteda Django o'chirgandan keyininstance.pkniNonega aylantiradi, shuning uchun lambda bemalolproduct:Nonekalitini o'chiradi.
Ichma-ich atomic() bloklari kutilgandek ishlaydi: savepoint ichida ro'yxatga olingan callback eng tashqi commit'dan keyin ishlaydi, savepoint rollback bo'lsa esa uning callback'lari tashlanadi.
Keshni commit'dan keyin o'chiring, hech qachon oldin emas. Commit'gacha boshqa ulanishlar eski ma'lumotni ko'radi va uni bemalol keshga qaytarib qo'yadi.
Qolgan poyga holati va "kechiktirilgan ikki marta o'chirish"
on_commit katta oynani yopadi, lekin har qanday oynani emas. O'quvchi hali ham shunday qilishi mumkin: keshda topolmaydi, commit'dan oldin eski qatorni o'qiydi, bir lahza qotib qoladi (GC pauza, sekin tarmoq) va eski qiymatni keshga bizning delete'imiz ishlab bo'lgandan keyin yozadi. Oyna kichik, odatda millisekundlar, lekin u bor.
Ma'lumotingiz buni ko'tara olsa, TTL uni qoplaydi. Ko'tara olmasa, keng tarqalgan usul ikki marta o'chirish: commit'dan keyin darhol va biroz vaqt o'tib yana bir marta, sekin o'quvchi aniq ishini tugatganda.
# catalog/tasks.py
from celery import shared_task
from django.core.cache import cache
@shared_task
def delete_cache_keys(keys: list[str]) -> None:
cache.delete_many(keys)
# catalog/signals.py (fragment)
from catalog.tasks import delete_cache_keys
def invalidate_product(product_id: int, category_id: int) -> None:
key = product_key(product_id)
cache.delete(key)
bump_generation(f"category:{category_id}")
# Second delete catches a reader that filled the cache with old data
delete_cache_keys.apply_async(args=[[key]], countdown=2)
Bu ham kafolat emas, faqat oynani ancha toraytiradi. Aytgancha, yozishda set emas, delete ni afzal ko'ring. Ikki yozuvchi keshga yangi qiymat qo'ysa, ular noto'g'ri tartibda tugab, eskiroq qiymatni qoldirishi mumkin. Delete'da bunday tartib muammosi yo'q: keyingi o'quvchi doim bazaga boradi.
Signallar hamma narsani ko'rmaydi
Signallar faqat Model.save() va Model.delete() orqali ishlaydi. Real kodning katta qismi ma'lumotni ularsiz o'zgartiradi:
# None of these send post_save:
Product.objects.filter(category_id=7).update(is_active=False)
Product.objects.bulk_update(products, ["price"])
Product.objects.bulk_create(new_products)
# catalog/services.py
from functools import partial
from django.core.cache import cache
from django.db import transaction
from catalog.cache import product_key
from catalog.models import Product
def deactivate_category(category_id: int) -> None:
with transaction.atomic():
ids = list(
Product.objects.select_for_update()
.filter(category_id=category_id)
.values_list("pk", flat=True)
)
Product.objects.filter(pk__in=ids).update(is_active=False)
keys = [product_key(pk) for pk in ids]
transaction.on_commit(partial(cache.delete_many, keys), robust=True)
QuerySet.update(), bulk_update(), bulk_create(), raw SQL, migratsiya, o'sha bazaga yozadigan boshqa servis: ularning hech biri post_save yubormaydi. (QuerySet.delete() esa har bir obyekt uchun pre_delete/post_delete yuboradi, shuning uchun Django ularni avval yuklab oladi.) Ommaviy operatsiyalarda keshni o'sha servis funksiyasining o'zida, yana on_commit orqali, aniq o'chiring.
Agar boshqa tizimlar bazaga to'g'ridan-to'g'ri yozsa, signallar umuman yordam bermaydi. Unda yoki barcha yozuvlarni bitta servis orqali o'tkazasiz, yoki bazaning o'zini tinglaysiz (masalan, trigger va LISTEN/NOTIFY, yoki logical replication). Bu kattaroq loyiha; ko'p jamoalar uchun bunday holatda halol TTL to'g'ri javob.
Versiyalangan kalitlar: guruhni invalidatsiya qilish
product:42 ni o'chirish oson. Kategoriya ro'yxatining barcha sahifalari, har qanday sahifa raqami va filtr bilan-chi? Bu kalitlarni sanab chiqa olmaysiz, KEYS bilan urinib ko'rmang ham:
# Never in production: KEYS blocks Redis while it walks every key
redis-cli KEYS 'product:*'
# If you really must iterate, SCAN walks the keyspace in small steps
redis-cli --scan --pattern ':1:product:*' --count 1000
Tozaroq usul, kalitga avlod raqamini (generation) qo'shish. Har bir nomlar fazosi (namespace, masalan kategoriya) uchun hisoblagich bor. Shu namespace'ning har bir kesh kaliti hisoblagichning joriy qiymatini o'z ichiga oladi. Butun guruhni invalidatsiya qilish uchun hisoblagichni oshirasiz: yangi o'qishlar yangi kalit yasaydi, eski kalitlarga esa endi hech kim murojaat qilmaydi va ular TTL bilan o'lib ketadi.
# catalog/generations.py
import time
from django.core.cache import cache
def _gen_key(namespace: str) -> str:
return f"gen:{namespace}"
def get_generation(namespace: str) -> int:
key = _gen_key(namespace)
gen = cache.get(key)
if gen is None:
# Never restart from 1: if this key was evicted, old data keys
# may still live under small generation numbers.
cache.add(key, time.time_ns(), timeout=None)
gen = cache.get(key)
return gen
def bump_generation(namespace: str) -> int:
key = _gen_key(namespace)
try:
return cache.incr(key)
except ValueError: # key does not exist
cache.add(key, time.time_ns(), timeout=None)
return cache.incr(key)
# catalog/listing.py
from django.core.cache import cache
from catalog.generations import get_generation
from catalog.models import Product
LIST_TTL = 60 * 5
PAGE_SIZE = 20
def category_page(category_id: int, page: int) -> list[dict]:
gen = get_generation(f"category:{category_id}")
key = f"category:{category_id}:g{gen}:page:{page}"
data = cache.get(key)
if data is None:
start = (page - 1) * PAGE_SIZE
rows = (
Product.objects.filter(category_id=category_id, is_active=True)
.order_by("name", "pk")
.values("pk", "name", "price")[start:start + PAGE_SIZE]
)
data = [{**row, "price": str(row["price"])} for row in rows]
cache.set(key, data, LIST_TTL)
return data
# catalog/signals.py
from functools import partial
from django.core.cache import cache
from django.db import transaction
from django.db.models.signals import post_delete, post_save
from django.dispatch import receiver
from catalog.cache import product_key
from catalog.generations import bump_generation
from catalog.models import Product
def invalidate_product(product_id: int, category_id: int) -> None:
cache.delete(product_key(product_id))
bump_generation(f"category:{category_id}")
@receiver(post_save, sender=Product)
@receiver(post_delete, sender=Product)
def drop_product_cache(sender, instance, using, **kwargs):
transaction.on_commit(
partial(invalidate_product, instance.pk, instance.category_id),
using=using,
robust=True,
)
Nega boshlang'ich qiymat 1 emas, time.time_ns()? Agar xotira yetishmaganda Redis hisoblagichni chiqarib tashlasa (eviction), g1, g2, g3 ma'lumot kalitlari esa hali tirik bo'lsa, 1 dan qayta boshlash eski ma'lumotni qayta tiriltiradi. Soatga asoslangan boshlang'ich qiymat amalda doim avvalgisidan katta bo'ladi. Imkoni bo'lsa, Redis'da volatile-* eviction siyosatini sozlang: unda TTL'siz kalitlar, masalan shu hisoblagichlar, chiqarib tashlanmaydi.
Narxi har o'qishda Redis'ga bitta qo'shimcha murojaat (generation'ni olish uchun). Bir nechta namespace'li sahifa uchun generation'larni cache.get_many() bilan bitta chaqiruvda oling. Chekka holatni ham unutmang: mahsulot bir kategoriyadan boshqasiga o'tsa, eski va yangi kategoriyaning ikkalasini ham oshirish kerak, demak eski category_id kerak bo'ladi (masalan pre_save dan yoki obyekt yuklanganda saqlab qo'yilgan qiymatdan).
Django'da o'rnatilgan version argumenti va cache.incr_version() ham bor, lekin ular bir vaqtda bitta kalit bilan ishlaydi. "Butun guruhni unut" uchun aniq generation hisoblagichi tushunishga osonroq.
Bir nechta server va lokal kesh
Process ichida kesh bo'lsa, ish yanada qiyinlashadi. LocMemCache, functools.lru_cache, modul darajasidagi lug'at: hammasi bitta worker process ichida yashaydi. 3 ta serverda 4 tadan gunicorn worker bo'lsa, bu 12 ta mustaqil nusxa. Redis'dagi kalitni o'chirish ularning hech biriga tegmaydi, bitta serverdagi on_commit esa boshqa serverning xotirasi haqida hech narsa bilmaydi.
Amaliy variantlar:
| Variant | Yangilik | Murakkablik |
|---|---|---|
| Lokal qatlamda qisqa TTL (soniyalar) | TTL davomida eskirgan bo'lishi mumkin | minimal |
| Har o'qishda Redis'dagi generation'ni tekshirish | yangi, har o'qishda bitta Redis chaqiruvi | o'rtacha |
| Redis Pub/Sub orqali invalidatsiyani tarqatish | odatda yangi, xabar yo'qolishi mumkin | yuqori |
Ko'p hollarda juda qisqa lokal TTL'li ikki qatlamli kesh yetarli:
# settings.py
CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.redis.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/1",
"TIMEOUT": 600,
},
"local": {
"BACKEND": "django.core.cache.backends.locmem.LocMemCache",
"LOCATION": "l1",
"TIMEOUT": 5,
},
}
# config/flags.py
from django.core.cache import caches
from config.models import FeatureFlag
def get_flags() -> dict:
local = caches["local"]
flags = local.get("flags")
if flags is None:
shared = caches["default"]
flags = shared.get("flags")
if flags is None:
flags = dict(FeatureFlag.objects.values_list("name", "enabled"))
shared.set("flags", flags, 600)
local.set("flags", flags) # lives 5 s (TIMEOUT of "local")
return flags
Redis Pub/Sub jozibali ko'rinadi, lekin u "yubordim va unutdim" tamoyilida ishlaydi: xabar yuborilgan paytda qayta ulanayotgan worker uni hech qachon olmaydi. Shuning uchun tarqatish bo'lsa ham, qisqa TTL'ni zaxira sifatida qoldirasiz. Read replica'larga ham xuddi shu mantiq tegishli: agar kesh primary'dan orqada qolayotgan replica'dan to'ldirilsa, yozuvdan darhol keyingi cache miss eski ma'lumotni qaytarib qo'yishi mumkin. Muhim kalitlarni primary'dan to'ldiring.
Eventual consistency'ni ongli ravishda qabul qilish
Oxirgi qadam texnik emas. Hamma ma'lumotga bir xil yangilik kerak emas, aksincha deb o'ylash esa yo foydasiz keshga, yo noto'g'ri ma'lumotga olib keladi. Har bir ma'lumot turi uchun alohida qaror qiling:
- Pulga oid qarorlar (to'lov paytidagi balans, checkout'dagi yakuniy narx, limitlar): hech qachon keshga qarab qaror qilmang. Bazadan, tranzaksiya ichida, kerak bo'lsa
select_for_update()bilan o'qing. Kesh dashboard'da balansni ko'rsatishi mumkin, lekin to'lovni tasdiqlamasligi kerak. - Katalog ma'lumotlari (nomlar, tavsiflar, ro'yxatlar):
on_commitinvalidatsiyasi va bir necha daqiqalik TTL. - Konfiguratsiya va flag'lar: generation yoki qisqa lokal TTL; bir necha soniya eskirish muammo emas.
Ruxsat etilgan eskirishni kesh kaliti yoniga yozib qo'ying. "Bu 5 daqiqagacha eski bo'lishi mumkin" biznes rozi bo'la oladigan talab; "kesh doim yangi" esa hech kim bajara olmaydigan va'da.
Invalidatsiyani test qilish
Django'ning TestCase har bir testni hech qachon commit bo'lmaydigan tranzaksiyaga o'raydi, shuning uchun on_commit callback'lari odatda umuman ishlamaydi. captureOnCommitCallbacks(execute=True) dan foydalaning:
# catalog/tests.py
from decimal import Decimal
from django.test import TestCase
from catalog.cache import get_product_data
from catalog.models import Category, Product
from catalog.services import change_price
class PriceChangeTests(TestCase):
@classmethod
def setUpTestData(cls):
cls.category = Category.objects.create(name="Drinks")
def test_cache_dropped_after_commit(self):
product = Product.objects.create(
name="Tea", price=Decimal("12000.00"), category=self.category
)
get_product_data(product.pk) # warm the cache
with self.captureOnCommitCallbacks(execute=True):
change_price(product.pk, Decimal("15000.00"))
self.assertEqual(get_product_data(product.pk)["price"], "15000.00")
Test sozlamalarida LocMemCache ishlating, shunda testlar haqiqiy Redis'ni bir-biri bilan ham, development muhiti bilan ham bo'lishmaydi.
Checklist
- Har bir kesh kalitida TTL bor, hatto aniq invalidatsiya qilsangiz ham.
- Invalidatsiya to'g'ridan-to'g'ri
post_saveda emas,transaction.on_commit()ichida ishlaydi. partialishlating yoki qiymatlarni darhol oling; dangasa lambda ichidainstance.pkni o'qimang.update(),bulk_*, raw SQL: keshni servis funksiyasida aniq o'chiring.- Yozishda yangi qiymat qo'ymang, kalitni o'chiring.
- Kalitlar guruhi uchun
KEYS/pattern bo'yicha o'chirish emas, generation hisoblagichlari. - Generation hisoblagichi hech qachon 1 dan qayta boshlanmaydi;
volatile-*eviction siyosatini afzal ko'ring. - Process ichidagi keshda qisqa TTL; nechta nusxa borligini bilasiz.
- Pulga oid qarorlar keshdan emas, bazadan o'qiydi.
- Testlarda
captureOnCommitCallbacks(execute=True).
Xulosa
Kesh invalidatsiyasi ko'pincha vaqt masalasida buziladi: commit'dan oldin o'chirish, signallarni chetlab o'tadigan yozuvlarni unutish, boshqa process'lardagi nusxalarni hisobga olmaslik. Commit'dan keyin o'chiring, TTL'ni xavfsizlik to'ri sifatida saqlang, guruhlar uchun generation hisoblagichidan foydalaning va har bir ma'lumot qanchalik eskirishi mumkinligini yozib qo'ying. Shunda kesh sirli xatolar manbai emas, tushunarli kelishuvga aylanadi.
// izohlar
Izohlar yuklanmoqda...