Все заметки
Программирование

Инвалидация кеша: кеш удалили, а на странице всё ещё старая цена

Почему удаление кеша в 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 как страховку, используйте счётчики поколений для групп и запишите, насколько может устаревать каждый вид данных. Тогда кеш станет понятным компромиссом, а не источником загадочных багов.

// комментарии

Загружаем комментарии...

    // следующий шаг

    Давайте построим что-нибудь вместе.

    Написать в Telegram
    aslbek@asldev: ~
    ❯