Инвалидация кеша: кеш удалили, а на странице всё ещё старая цена
Почему удаление кеша в post_save возвращает старую цену, как это чинит on_commit, версионированные ключи для групп и что делать с локальным кешем в 12 воркерах.
Представьте страницу интернет-магазина. Оператор в админке меняет цену товара с 12 000 на 15 000 сумов и нажимает «Сохранить». Код написан правильно: сразу после сохранения сигнал post_save удаляет ключ товара из Redis. Но и через десять минут покупатель видит на странице 12 000. Кеш удалили, вручную в него никто не писал, а старая цена на месте.
Есть известная шутка: в программировании только две сложные вещи, инвалидация кеша и придумывание имён. Шутка живёт, потому что это правда. Положить данные в кеш легко. Сложно точно знать, когда эта копия перестала быть верной, и удалить её ровно в нужный момент. В прошлой статье мы говорили о паттернах кеширования, TTL и cache stampede. Здесь сосредоточимся на одном вопросе: как правильно заставить кеш забыть старые данные.
Почему инвалидация сложна
Кеш — это вторая копия данных. Как только копий две, они могут разойтись. База хранит истину, кеш — снимок из какого-то момента в прошлом. Инвалидация — это способ сказать «этот снимок больше не действителен».
Сложность создают три вещи:
- Конкурентность. Писатели и читатели работают одновременно, в разных процессах, часто на разных серверах. Последовательность «обновить базу, потом удалить кеш» не атомарна: между двумя шагами может произойти что угодно.
- Транзакции. Ваш код считает, что данные уже изменены, а база их ещё не закоммитила. Другие соединения по-прежнему видят старую строку.
- Производные данные. Один товар лежит в своём ключе, в списке категории, на главной, в результатах поиска, в закешированном фрагменте шаблона. Удаление
product:42не трогает ничего из этого.
Отправная точка — классическое чтение по схеме cache-aside:
# 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: полагаться только на TTL
Самая простая инвалидация — её отсутствие: у каждого ключа есть TTL, и данным разрешено устаревать не дольше этого срока. Это честно и на удивление часто достаточно. Если описание товара обновится с опозданием в 10 минут, никто не пострадает.
Проблемы начинаются, когда бизнес говорит: «цена должна меняться сразу». Сократите TTL до 5 секунд — и hit ratio падает, вы снова нагружаете базу. TTL — это верхняя граница устаревания, а не стратегия инвалидации. Но запомните: у каждого ключа всё равно должен быть TTL, потому что любой из способов ниже может отказать, а TTL — страховочная сетка, которая ограничивает ущерб.
Подход 2: удалять в сигнале, и почему это ломается
Естественный следующий шаг — удалять ключ при сохранении модели:
# 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: сразу после UPDATE, но ещё внутри transaction.atomic(). Коммит происходит только при выходе из блока with. На уровне изоляции PostgreSQL по умолчанию, READ COMMITTED, другие соединения не видят незакоммиченных изменений. Получается такая временная шкала:
| Шаг | Запрос A (админ, писатель) | Запрос B (покупатель, читатель) |
|---|---|---|
| 1 | UPDATE price = 15000 (не закоммичено) |
|
| 2 | post_save → cache.delete("product:42") |
|
| 3 | INSERT INTO pricehistory ... |
промах кеша по product:42 |
| 4 | SELECT → видит старую строку, 12000 |
|
| 5 | cache.set("product:42", 12000) |
|
| 6 | COMMIT |
После шага 6 в базе 15 000, в кеше 12 000, и до истечения TTL это ничто не исправит. Окно между шагами 2 и 6 длится столько, сколько остаток транзакции: лишний INSERT, вызов внешнего API, медленный запрос. При ATOMIC_REQUESTS = True вся view — одна транзакция, и окно открыто до конца запроса. На популярном товаре в это окно кто-нибудь обязательно попадёт.
Есть и вторая, тихая ошибка: если транзакция откатится, мы зря удалим совершенно корректную запись кеша. На корректность это не влияет, но показывает, что сигнал срабатывает не в тот момент.
Решение: transaction.on_commit
В Django есть хук ровно для «сделай это, когда данные действительно в базе»: transaction.on_commit(). Колбэк сохраняется и вызывается только после успешного коммита самой внешней транзакции. При откате он отбрасывается. Если активной транзакции нет (режим autocommit), он выполняется сразу.
# 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
Важные детали:
using=using. Сигнал передаёт алиас базы. При нескольких базах колбэк нужно привязать к транзакции правильного соединения.robust=True(Django 4.2+). Если Redis недоступен, исключение логируется, а остальные колбэкиon_commitвсё равно выполняются. Данные уже закоммичены; ронять запрос в этот момент — только путать пользователя.partialвместоlambda.partialвычисляетproduct_key(instance.pk)прямо сейчас.lambdaпрочитаетinstance.pkпозже, в момент коммита. Вpost_deleteвнутри внешней транзакции Django после удаления выставляетinstance.pk = None, и lambda спокойно удалит ключproduct:None.
Вложенные блоки atomic() ведут себя ожидаемо: колбэк, зарегистрированный внутри savepoint, выполнится после внешнего коммита, а при откате savepoint его колбэки отбрасываются.
Инвалидируйте после коммита, никогда до. До коммита другие соединения видят старые данные и охотно положат их обратно в кеш.
Оставшаяся гонка и «отложенное двойное удаление»
on_commit закрывает большое окно, но не все. Читатель всё ещё может: промахнуться мимо кеша, прочитать старую строку до коммита, на мгновение зависнуть (пауза GC, медленная сеть) и записать старое значение в кеш уже после нашего удаления. Окно маленькое, обычно миллисекунды, но оно есть.
Если данные это переживут, его закроет TTL. Если нет — распространённый приём: удалить дважды, сразу после коммита и ещё раз чуть позже, когда медленный читатель точно закончил.
# 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)
Это тоже не гарантия, а лишь сильное сужение окна. Кстати, при записи предпочитайте delete, а не set. Если два писателя кладут в кеш новые значения, они могут закончить в неправильном порядке и оставить более старое. У удаления такой проблемы с порядком нет: следующий читатель всегда идёт в базу.
Сигналы видят не всё
Сигналы срабатывают только через Model.save() и Model.delete(). Много реального кода меняет данные в обход них:
# 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(), сырой SQL, миграция, другой сервис, пишущий в ту же базу, — никто из них не отправляет post_save. (QuerySet.delete() как раз отправляет pre_delete/post_delete для каждого объекта, поэтому Django сначала их загружает.) Для массовых операций инвалидируйте явно, в той же сервисной функции и тоже через on_commit.
Если в базу напрямую пишут другие системы, сигналы не помогут вовсе. Тогда либо все записи идут через один сервис, либо вы слушаете саму базу (например, триггеры с LISTEN/NOTIFY или логическая репликация). Это отдельный проект; для многих команд честный TTL здесь правильный ответ.
Версионированные ключи: инвалидация группы
Удалить product:42 легко. А как быть со всеми страницами списка категории, с любыми номерами страниц и фильтрами? Перечислить эти ключи нельзя, и не пытайтесь делать это через KEYS:
# 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
Аккуратнее приём с номером поколения (generation) в ключе. У каждого пространства имён (например, категории) есть счётчик. Каждый ключ кеша этого пространства содержит текущее значение счётчика. Чтобы инвалидировать всю группу, счётчик увеличивают: новые чтения строят новые ключи, а старые становятся недостижимыми и умирают по TTL.
# 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,
)
Почему стартовое значение time.time_ns(), а не 1? Если Redis при нехватке памяти вытеснит счётчик, а ключи данных g1, g2, g3 ещё живы, старт с 1 воскресит старые данные. Значение на основе часов практически всегда больше любого предыдущего. Если можете, настройте в Redis политику вытеснения volatile-*: тогда ключи без TTL, как эти счётчики, не вытесняются.
Цена — один лишний поход в Redis на каждое чтение (за поколением). Для страницы с несколькими пространствами берите поколения одним вызовом cache.get_many(). И помните про крайний случай: если товар переехал из одной категории в другую, увеличить нужно обе, а значит, нужен старый category_id (например, из pre_save или из значения, сохранённого при загрузке объекта).
В Django есть и встроенный аргумент version с cache.incr_version(), но они работают с одним ключом за раз. Для «забудь всю группу» явный счётчик поколений проще понять.
Несколько серверов и локальный кеш
Всё усложняется, когда кеш живёт внутри процесса. LocMemCache, functools.lru_cache, словарь на уровне модуля — все они живут в одном worker-процессе. 4 воркера gunicorn на 3 серверах — это 12 независимых копий. Удаление ключа в Redis не трогает ни одну из них, а on_commit на одном сервере ничего не знает о памяти другого.
Практические варианты:
| Вариант | Свежесть | Сложность |
|---|---|---|
| Короткий TTL на локальном слое (секунды) | устаревание до TTL | минимальная |
| Проверка поколения в Redis на каждом чтении | свежо, один вызов Redis на чтение | средняя |
| Рассылка инвалидации через Redis Pub/Sub | обычно свежо, сообщения могут теряться | высокая |
В большинстве случаев хватает двухуровневого кеша с очень коротким локальным TTL:
# 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 выглядит заманчиво, но работает по принципу «отправил и забыл»: воркер, который в момент публикации переподключался, сообщение не получит никогда. Поэтому даже с рассылкой короткий TTL остаётся страховкой. Та же логика с read-репликами: если кеш заполняется с реплики, отстающей от primary, промах сразу после записи может вернуть старые данные. Критичные ключи заполняйте с primary.
Принять eventual consistency осознанно
Последний шаг не технический. Не всем данным нужна одинаковая свежесть, а притворство, что нужна, ведёт либо к бесполезному кешу, либо к неверным данным. Решайте по типу данных:
- Денежные решения (баланс в момент платежа, итоговая цена на checkout, лимиты): никогда не решайте по кешу. Читайте из базы, внутри транзакции, при необходимости с
select_for_update(). Кеш может показать баланс на дашборде, но не одобрить платёж. - Данные каталога (названия, описания, списки): инвалидация через
on_commitплюс TTL в минутах. - Конфигурация и флаги: поколения или короткий локальный TTL; несколько секунд устаревания допустимы.
Запишите допустимое устаревание рядом с ключом кеша. «Это может быть старше на 5 минут» — требование, с которым бизнес может согласиться; «кеш всегда свежий» — обещание, которое никто не выполнит.
Тестирование инвалидации
TestCase в Django оборачивает каждый тест в транзакцию, которая никогда не коммитится, поэтому колбэки on_commit по умолчанию не выполняются. Используйте captureOnCommitCallbacks(execute=True):
# 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")
В тестовых настройках используйте LocMemCache, чтобы тесты не делили настоящий Redis друг с другом и с разработкой.
Чеклист
- У каждого ключа кеша есть TTL, даже при явной инвалидации.
- Инвалидация выполняется в
transaction.on_commit(), а не прямо вpost_save. - Используйте
partialили захватывайте значения сразу; не читайтеinstance.pkв ленивой lambda. update(),bulk_*, сырой SQL: инвалидируйте явно в сервисной функции.- При записи удаляйте ключи, а не кладите новые значения.
- Группы ключей: счётчики поколений, а не
KEYS/удаление по шаблону. - Счётчик поколения никогда не стартует заново с 1; предпочитайте политику
volatile-*. - У кеша внутри процесса короткий TTL; вы знаете, сколько существует копий.
- Денежные решения читают из базы, никогда из кеша.
- В тестах —
captureOnCommitCallbacks(execute=True).
Итог
Инвалидация кеша чаще всего ломается на тайминге: удаление до коммита, записи в обход сигналов, забытые копии в других процессах. Удаляйте после коммита, держите TTL как страховку, используйте счётчики поколений для групп и запишите, насколько может устаревать каждый вид данных. Тогда кеш станет понятным компромиссом, а не источником загадочных багов.
// комментарии
Загружаем комментарии...