Истёк один ключ — в базу побежала тысяча запросов: паттерны кеша в Redis, TTL и cache stampede
Что происходит в секунду, когда истекает горячий ключ, и как это укротить: cache-aside, write-through, jitter, блокировка, раннее обновление XFetch и инвалидация в on_commit.
20:00, только что ушёл промо-пуш, и страница телефона со скидкой получает несколько тысяч запросов в секунду. Страница быстрая, потому что карточка товара лежит в Redis с TTL пять минут. В 20:05:00 ключ истекает. Следующие несколько сотен миллисекунд каждый запрос видит пустой кеш, каждый идёт в PostgreSQL с одним и тем же запросом и каждый записывает в Redis одно и то же значение. Пул соединений к базе заканчивается, задержки растут, часть запросов падает по таймауту. При этом ничего «не сломалось»: кеш сделал ровно то, что мы ему сказали.
Это cache stampede (его ещё называют thundering herd или dog-piling). В этой статье разберём кеширование в Django по шагам: cache-aside, write-through и write-behind, как выбирать TTL, три способа укротить stampede и что в кеш класть нельзя.
Подготовка: встроенный Redis-бэкенд Django
Начиная с Django 4.0 есть встроенный бэкенд для Redis; ему нужен установленный пакет redis (redis-py). Сторонний бэкенд не нужен:
# 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,
}
}
Две детали, на которых спотыкаются: TIMEOUT задаётся в секундах, None означает «не истекает никогда», а 0 означает «истекает сразу» (фактически, не кешировать). Реальный ключ в Redis выглядит как shop:1:product:card:42, то есть KEY_PREFIX:VERSION:key. Увеличить VERSION — дешёвый способ сбросить всё разом после деплоя, который меняет формат закешированных данных.
Наивная версия и почему она ломается
Так выглядит большая часть кода в первый день:
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,
)
Это работает, и при небольшом трафике всё хорошо. Под нагрузкой проблем три:
- «Прочитать — вычислить — записать» не атомарно.
get_or_setделаетget, затем вычисляет, затем пишет. Между промахом и записью каждый параллельный запрос тоже видит промах и тоже выполняет запрос к базе. Это и есть stampede. - У всех ключей одинаковый TTL. Если вы прогрели тысячу товаров в один момент (после деплоя, после очистки), они и истекут в одну секунду. Один горячий ключ превращается в тысячу.
- Цена промаха не видна. Если запрос занимает 5 мс, stampede незаметен. Если 800 мс (агрегация, вызов внешнего API), он может положить базу.
Кеш — это не функция, которая делает всё быстрым. Это обещание, что дорогой путь будет выполняться редко. Stampede нарушает именно это обещание.
Три паттерна: cache-aside, write-through, write-behind
| Паттерн | Кто пишет в кеш | Сильная сторона | Риск |
|---|---|---|---|
| Cache-aside (lazy loading) | Читатель, при промахе | Просто, кешируется только то, что реально читают | Stampede при промахе, устаревшие данные до TTL или инвалидации |
| Write-through | Писатель, сразу после записи в БД | Чтения почти не промахиваются | Каждая запись платит цену, кешируется и то, что никто не читает |
| Write-behind (write-back) | Писатель пишет только в кеш, БД обновляется позже в фоне | Очень быстрые записи | Потеря данных, если кеш умрёт до сброса |
Cache-aside — вариант по умолчанию в Django-проектах. Вот его более аккуратная версия:
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
Что изменилось по сравнению с наивной версией:
- Sentinel вместо
None.cache.get(key)возвращаетNoneи когда ключа нет, и когда вы сохранилиNone. С_MISSэти случаи различимы, и можно закешировать «такого товара нет» (negative caching). Без этого бот, перебирающий несуществующие ID, будет ходить в базу на каждый запрос. - Jitter в TTL. ±10% размазывают истечения по времени, и ключи, прогретые вместе, не истекают вместе.
- Кешируем dict, а не экземпляр модели. Сериализованная через pickle модель привязана к коду модели; после деплоя, меняющего модель, старые значения в Redis могут перестать ей соответствовать. Простой dict только с нужными полями меньше и безопаснее.
Write-through означает обновлять кеш в том же месте, где идёт запись в БД. В Django важно делать это после коммита (подробнее ниже):
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 — когда приложение пишет только в Redis, а фоновый воркер (например, Celery) периодически сбрасывает изменения в PostgreSQL. Это подходит для счётчиков вроде просмотров или лайков, где потерять несколько инкрементов допустимо. Для денег, заказов и статусов — нет: если Redis перезапустится до сброса, данные пропадут, а PostgreSQL перестанет быть источником истины.
Как выбрать TTL
«Правильного» TTL не существует; есть вопрос: как долго пользователь может видеть устаревшие данные без реального вреда?
- Каталог, категории, публичные настройки: от минут до часов плюс явная инвалидация при изменении.
- Тяжёлые агрегаты (дашборды, отчёты): столько, сколько допускает бизнес, часто с пересчётом в фоне.
- Отрицательные результаты («не найдено»): коротко, от секунд до минуты, иначе только что созданный объект останется «невидимым».
- Всё, что с
timeout=None: только при явной инвалидации, в которой вы уверены, иначе устаревшее значение живёт вечно.
TTL — это страховочная сетка. Даже если вы инвалидируете кеш на каждой записи, оставляйте конечный TTL: если одна инвалидация потеряется (падение между коммитом и delete), данные вылечатся сами.
Как укротить stampede
1. Блокировка: пересчитывает только один процесс
Идея: при промахе один процесс берёт короткую блокировку и вычисляет значение, остальные немного ждут и читают результат из кеша. В Django для этого естественно подходит cache.add(): в Redis-бэкенде он превращается в SET ... NX, а это атомарная операция, True получит только один.
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 — хелпер из примера cache-aside выше.)
Важные детали: повторная проверка после взятия блокировки (кто-то мог заполнить кеш, пока мы ждали), TTL у самой блокировки (если процесс умрёт, блокировка исчезнет сама) и дедлайн для ожидающих (лучше один раз сходить в базу, чем повесить запрос).
У этой версии есть тонкое слабое место: если compute() работает дольше lock_ttl, блокировка истекает, её берёт другой процесс, а наш finally удаляет чужую блокировку. Для коротких вычислений это приемлемо. Для долгих нужна блокировка с токеном владельца. В redis-py она есть из коробки: при освобождении Lua-скрипт сверяет токен и удаляет ключ, только если он всё ещё наш.
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: не давать ключам истекать вместе
Мы уже добавили его в jittered(). От одного очень горячего ключа он не спасает, но убирает «синхронные» stampede после деплоя или очистки кеша. Стоит одну строку, используйте везде.
3. Раннее обновление: пересчитать до истечения
Блокировка заставляет пользователей ждать пересчёта. Для горячих ключей лучше вообще не давать им истекать под нагрузкой. Алгоритм вероятностного раннего истечения (XFetch, из статьи «Optimal Probabilistic Cache Stampede Prevention», Vattani, Chierichetti, Lowenstein) работает так: вместе со значением храним, сколько заняло вычисление (delta), и когда значение логически истекает. На каждом чтении запрос «бросает кубик», и чем ближе истечение и чем дороже пересчёт, тем выше шанс, что именно этот запрос пересчитает значение заранее, пока остальные получают старое.
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
-log(u) для равномерного u из (0, 1] — положительное случайное число, обычно маленькое, но иногда большое. Поэтому вдали от истечения почти никто не пересчитывает, а в последние несколько delta один-два запроса делают это, пока ключ ещё на месте. beta > 1 сдвигает обновления раньше, beta < 1 — позже. Другой вариант той же идеи — фоновое обновление: задача в Celery beat каждые N минут пересчитывает популярные ключи, и пользователи вообще не видят промахов.
Инвалидация и транзакции
Самый частый продакшен-баг с кешем в Django — не stampede, а инвалидация не в тот момент.
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.)
Почему первая версия неверна: до COMMIT другие транзакции видят старую строку (READ COMMITTED). Если удалить ключ внутри транзакции, параллельный читатель получит промах, прочитает из базы старую цену и положит её обратно в кеш на следующие пять минут. transaction.on_commit() вызывает колбэк только после успешного коммита, а при откате транзакции не вызывает его вовсе.
Даже с on_commit остаётся редкая гонка: читатель прочитал старую строку до нашего коммита, а записал её в кеш после нашего delete. Именно поэтому конечный TTL из предыдущего раздела не опционален.
Что нельзя кешировать
- Балансы, статусы платежей и заказов, остатки в момент решения о продаже. Такие решения должны читать источник истины внутри транзакции (при необходимости с
select_for_update). Кеш может показать бейдж «есть в наличии», но не должен решать, пройдёт ли платёж. - Результаты идемпотентности и всё, что должно пережить перезапуск. Redis с политикой вытеснения вправе удалить ключ в любой момент.
- Данные пользователя под общим ключом.
cache_pageна странице с именем пользователя или CSRF-токеном отдаст страницу одного пользователя другому. Либо не кешируйте такие view, либо включайте пользователя в ключ. - Права и роли с длинным TTL. Отозванный доступ, который работает ещё час, — это баг безопасности.
- Огромные значения. Многомегабайтное значение медленно (де)сериализуется и передаётся по сети на каждом чтении. Кешируйте узкий dict, а не весь queryset.
Подводные камни в продакшене
maxmemory-policy. Политика Redis по умолчанию —noeviction: когда память заканчивается, записи падают с ошибкой. Для чистого кеша обычно нуженallkeys-lruилиallkeys-lfu.- Один Redis для кеша и Celery.
maxmemoryи политика вытеснения действуют на весь инстанс, а не на номер базы. Сallkeys-lruRedis может вытеснить ваши очереди Celery. Держите брокер и кеш в разных инстансах. - Redis недоступен. Встроенный бэкенд Django не глотает ошибки соединения молча. Решите осознанно: сайт должен идти в базу (а выдержит ли она?) или возвращать ошибку?
KEYS *для инвалидации по шаблону. На большом keyspace он блокирует Redis. ИспользуйтеSCAN, а лучше версионирование ключей (VERSIONили номер версии в самом ключе).- Измеряйте, а не гадайте. Смотрите hit ratio и вытеснения:
# 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"
Если evicted_keys стабильно растёт, кеш слишком мал для вашего рабочего набора, и дело не в настройке TTL.
Чек-лист
- Кешируйте dict с нужными полями, а не экземпляры моделей или целые queryset.
- Используйте sentinel, чтобы отличать «нет ключа» от «закешированного
None»; отрицательные результаты кешируйте коротко. - Добавляйте jitter к каждому TTL.
- Для дорогих или горячих ключей: блокировка через
cache.add()/redis.lock()или раннее обновление. - Инвалидируйте в
transaction.on_commit(), никогда внутри транзакции. - Всегда оставляйте конечный TTL как страховку, даже при явной инвалидации.
- Не принимайте денежных решений на основе кеша.
- Разные Redis для кеша и брокера Celery;
maxmemory-policyзадавайте осознанно. - Следите за
keyspace_hits,keyspace_missesиevicted_keys.
Итог
Кеш не делает дорогой запрос дешёвым, он только делает его редким, а stampede — это момент, когда «редко» превращается в «все сразу». Cache-aside с sentinel, TTL с jitter и инвалидация в on_commit закрывают потребности большинства Django-проектов. Для горячих и дорогих ключей добавьте блокировку или раннее обновление, а всё, что решает про деньги, оставьте в PostgreSQL.
// комментарии
Загружаем комментарии...