🌩️ Проблемы кэша
Кэш чаще всего подводит в моменты перехода: истёк популярный ключ, перезапустился Redis, запись в базу разошлась с записью в кэш. В такие секунды база получает всю нагрузку, от которой её прятали, и сервис падает из-за того, что должно было его ускорять. На собеседовании мидла про это спрашивают почти всегда после вопроса о стратегиях: «что будет, если ключ истечёт под нагрузкой». Цифры ниже сняты на ноутбуке: PostgreSQL 16 и Redis 7.4 в Docker, клиент на Go, «тяжёлый запрос» в базу длится 50 мс, в пуле 20 соединений
🧠 Пять сбоев и их названия
В статьях и на собеседованиях одни и те же сбои зовут по-разному, ниже все частые названия
| Сбой | Что происходит | Другие названия |
|---|---|---|
| Стампид | истёк один популярный ключ, и сотни запросов разом идут в базу за одним и тем же | cache stampede, thundering herd, dog-piling, пробой кэша |
| Лавина | одновременно пропало много ключей: истекли разом или упал сам Redis | cache avalanche |
| Запросы мимо кэша | спрашивают то, чего нет в базе, и кэшировать нечего | cache penetration, проникновение |
| Расхождение с базой | в кэше осталось старое значение после записи | stale set, inconsistency |
| Горячий ключ | один ключ читают так часто, что упираются в один узел Redis | hot key |
🐂 Стампид: тысяча промахов в один ключ
Обычный cache-aside из страницы про стратегии кэширования при промахе идёт в базу. Пока первый запрос ждёт свои 50 мс, ключ всё ещё пуст, и каждый следующий запрос тоже уходит в базу. Тысяча одновременных запросов к истёкшему ключу:
| Как загружаем | Запросов в базу | p50 | p99 |
|---|---|---|---|
| Без защиты | 937–1000 | 1,4 с | 2,8 с |
| singleflight, один процесс | 1 | 58–67 мс | 63–69 мс |
| singleflight, 5 реплик | 5 | 55–60 мс | 56–62 мс |
Без защиты запросы выстроились в очередь за 20 соединениями пула, и последний ждал почти три секунды. На проде всё хуже: запрос тяжелее, база в это время обслуживает и других, и очередь растёт быстрее, чем рассасывается
singleflight
singleflight склеивает одновременные вызовы с одним ключом: функция выполняется один раз, остальные ждут её результата. Пакет лежит в golang.org/x/sync/singleflight:
var group singleflight.Group
func getCard(ctx context.Context, id int) (Card, error) {
key := fmt.Sprintf("card:v1:%d", id)
if c, ok := fromCache(ctx, key); ok {
return c, nil
}
v, err, _ := group.Do(key, func() (any, error) {
c, err := loadCard(ctx, id) // в базу пойдёт только первый
if err == nil {
toCache(ctx, key, c)
}
return c, err
})
if err != nil {
return Card{}, err
}
return v.(Card), nil
}Три свойства, о которых спрашивают. Группа живёт в памяти процесса, поэтому пять реплик сделают пять запросов в базу: этого обычно хватает, ведь беда была в тысяче. Ошибку получат все ждущие разом, и если база ответила таймаутом, тысяча запросов вернёт тысячу ошибок. И Do не знает про context вызывающего: функция работает с ctx первого вызова, и если его отменили, ошибку отмены увидят все. Поэтому загрузку внутри Do запускают со своим таймаутом через context.WithoutCancel(ctx) и context.WithTimeout, а ждать с отменой позволяет DoChan
Если реплик сотни
Когда реплик много, склейку переносят в Redis: первый, кто промахнулся, берёт короткую блокировку SET lock:card:42 <token> NX PX 3000, остальные ждут несколько миллисекунд и перечитывают ключ или сразу отдают старую копию. Подводные камни распределённых блокировок разобраны на следующей странице модуля
Так же устроены lease в memcache у Facebook: сервер выдаёт право загрузить ключ одному клиенту раз в 10 секунд, остальным велит подождать. По их статье на ключах, склонных к стампиду, пиковая нагрузка на базу упала с 17 тысяч запросов в секунду до 1,3 тысячи
Обновить до того, как ключ истечёт
Ещё лучше, если ключ вообще не истекает под нагрузкой. Два приёма:
- Отдавать старое и обновлять в фоне (stale-while-revalidate). В кэше лежат значение и момент, когда его пора обновить. TTL ключа длиннее этого момента. Читатель, увидевший просроченное, отдаёт его сразу и запускает обновление, одно на ключ через тот же singleflight. Пользователь ждёт только при холодном старте
- Вероятностное раннее обновление (XFetch, статья Vattani и соавторов, VLDB 2015). Каждый читатель с небольшой вероятностью сам обновляет ключ до истечения, и вероятность растёт к концу TTL. Для запроса, который строится 50 мс, за 50 мс до истечения обновит каждый третий читатель, за 250 мс — меньше одного из ста
Go · XFetch: раннее обновление без блокировок
type entry struct {
Val Card
Delta time.Duration // сколько строилось значение
Expiry time.Time
}
// beta = 1 по умолчанию, больше единицы — обновлять раньше
func shouldRecompute(e entry, beta float64) bool {
// -ln(U) для U из (0, 1] — экспоненциальная случайная величина
gap := time.Duration(float64(e.Delta) * beta * -math.Log(1-rand.Float64()))
return time.Now().Add(gap).After(e.Expiry)
}Вероятность обновления за g до истечения равна exp(-g / (beta * Delta)). Чем дороже значение, тем раньше его начинают обновлять. Хранить приходится и время построения, поэтому в кэше лежит структура, а не голое значение
❄️ Лавина и холодный кэш
Стампид бьёт по одному ключу, лавина по тысячам сразу. Причин три:
- Ключи создали одновременно с одинаковым TTL, например прогрели после деплоя, и они так же одновременно истекли. Лечится разбросом TTL, он показан на странице про стратегии
- Упал или перезапустился Redis без персистентности. При 99% попаданий база получает в сто раз больше тяжёлых запросов
- Сменили формат ключа: новый релиз читает
card:v2:*, а там пусто. Это та же лавина, только устроенная своими руками
От второго и третьего защищаются одним способом: не пускают в базу больше запросов, чем она выдержит. Перед загрузкой из базы ставят ограничитель одновременных запросов, семафор на N слотов. Кто не уместился, получает ошибку или заглушку сразу, а не через три секунды очереди. Сверху ставят circuit breaker на Redis, чтобы при недоступном кэше не тратить таймаут на каждое обращение к нему
Холодный кэш прогревают до того, как на него придёт трафик: скриптом загружают самые читаемые ключи, список берут из логов запросов или из redis-cli --hotkeys. Новую версию ключей выкатывают постепенно, по одной реплике или по проценту трафика, а не на все поды разом
🕳️ Запросы мимо кэша
Cache-aside кэширует найденное. Если спрашивают card:999999999, которого нет в базе, промах повторяется на каждом запросе. Обычно это парсер, перебирающий id, или баг клиента, который ходит с удалённым id. Сто таких запросов в секунду — сто запросов в базу, и кэш их не видит
Защита в порядке простоты:
- Проверить вход. Отрицательный id, id больше последнего выданного, кривой UUID отсекаются до кэша и базы
- Кэшировать отсутствие. Кладут в кэш метку «не найдено» с коротким TTL, секунды или минуту. Если объект потом создадут, метку удаляют при создании, а TTL страхует
- Фильтр Блума. Множество всех существующих id в компактной вероятностной структуре: на ответ «нет» можно полагаться, «да» иногда ошибается. При 1% ложных срабатываний это около 10 бит на элемент. В Redis 8 он встроен (
BF.ADD,BF.EXISTS), в 7.x это модуль. Фильтр нужно наполнять при каждой вставке, а удалять из него нельзя, поэтому его берут, когда id много и ими реально перебирают
const notFound = "\x00nf" // метка, которой не бывает в настоящих данных
func getCard(ctx context.Context, id int) (Card, error) {
key := fmt.Sprintf("card:v1:%d", id)
if s, err := rdb.Get(ctx, key).Result(); err == nil {
if s == notFound {
return Card{}, ErrNotFound
}
return decode(s)
}
c, err := loadCard(ctx, id)
if errors.Is(err, ErrNotFound) {
rdb.Set(ctx, key, notFound, 30*time.Second)
return Card{}, ErrNotFound
}
if err != nil {
return Card{}, err
}
rdb.Set(ctx, key, encode(c), 10*time.Minute)
return c, nil
}В замере 100 запросов к несуществующему id дали одну загрузку из базы вместо ста
🔀 Кэш и база разошлись
Правило «сначала база, потом удаление ключа» закрывает гонку двух писателей, но оставляет гонку читателя и писателя:
- Читатель промахивается и читает из базы цену 100
- Писатель записывает в базу 200 и удаляет ключ
- Читатель, задержавшийся на паузе GC или в сети, кладёт в кэш 100
Удаление писателя уже прошло, и старое значение легло в пустой ключ. Сценарий запущен на Postgres и Redis с порядком через каналы:
del: база 200 кэш "100"Окно узкое: читатель должен застрять между чтением базы и записью в кэш. Под нагрузкой в тысячи запросов в секунду оно всё равно срабатывает, а старое значение живёт до конца TTL
Варианты, от простого к надёжному:
| Приём | Как работает | Чем платят |
|---|---|---|
| Короткий TTL | расхождение живёт не дольше TTL | меньше попаданий |
| Двойное удаление | удалить ключ сразу и ещё раз через секунду | не гарантия, читатель может застрять дольше |
| Версия в кэше | в строке базы счётчик версий, кэш принимает значение только не старше того, что уже знает | нужна атомарная проверка в Redis и «надгробие» при удалении |
| Инвалидация из лога базы | отдельный процесс читает WAL через Debezium или логическую репликацию и удаляет ключи | ещё один компонент, задержка в доли секунды |
Версии требуют одной хитрости: если писатель удалит ключ, проверять читателю будет не с чем. Поэтому вместо удаления писатель оставляет надгробие — запись с новой версией без данных. Читатели считают её промахом, а положить в кэш значение старой версии не могут. С этим приёмом тот же сценарий:
читатель со старой версией записал в кэш: false
version: база 200 кэш ""Redis · запись в кэш только для новой версии
-- KEYS[1] ключ, ARGV[1] версия, ARGV[2] данные, ARGV[3] TTL в секундах
local cur = redis.call('HGET', KEYS[1], 'v')
if cur and tonumber(cur) > tonumber(ARGV[1]) then return 0 end
redis.call('HSET', KEYS[1], 'v', ARGV[1], 'd', ARGV[2])
redis.call('EXPIRE', KEYS[1], ARGV[3])
return 1Писатель выполняет UPDATE ... SET version = version + 1 ... RETURNING version и кладёт в ключ v = новая версия, d = "". Скрипт выполняется в Redis атомарно, поэтому проверка и запись не разъезжаются
Инвалидация из лога базы нравится тем, что ловит все записи: из миграций, админки, другого сервиса, ручного UPDATE в консоли. Удаление ключа в коде сервиса про них не знает
Ещё одна частая причина расхождения — удаление ключа внутри транзакции. Ключ удалили, транзакция ещё не закоммичена, читатель взял из базы старое и вернул его в кэш. Удаляют после коммита
🔥 Горячие ключи
Redis выполняет команды в одном потоке, а в кластере ключ лежит на одном узле. Баннер на главной или карточка товара из рассылки читаются сотни тысяч раз в секунду и упираются в один узел, пока остальные простаивают. Добавление узлов в кластер не помогает: ключ всё равно в одном слоте
Найти горячие ключи помогает redis-cli --hotkeys. Он работает только при политике вытеснения LFU, потому что берёт счётчик частоты обращений. Счётчик логарифмический: в замере 3000 чтений ключа дали значение 30, 300 чтений — 15:
hot key found with counter: 30 keyname: "promo:banner"
hot key found with counter: 15 keyname: "user:7"На кластере, где LFU не включён, горячие ключи ищут по метрикам клиента: счётчик обращений по префиксу ключа или сэмплирование в коде. MONITOR в проде не включают, он сам нагружает сервер
Лечат так:
- Локальный кэш на секунды перед Redis. Сто подов читают баннер из своей памяти, в Redis идёт один запрос в секунду от каждого
- Копии ключа. Пишут значение в
promo:banner#0…promo:banner#7, читают случайную копию. Ключи попадают в разные слоты и узлы. Цена — запись и инвалидация восьми ключей вместо одного - Чтение с реплик. В кластере клиент может читать с реплик после команды
READONLY, ценой данных с небольшой задержкой репликации
⚠️ Где ошибаются
Считают, что TTL с разбросом решает стампид. Разброс разводит во времени разные ключи. Один популярный ключ он не спасает: когда истечёт именно он, все читатели придут в базу
Делают singleflight с общим ctx запроса. Первый пользователь закрыл вкладку, его контекст отменился, и загрузку для тысячи остальных тоже отменило. Загрузка внутри Do живёт со своим таймаутом
Не кэшируют «не найдено». Парсер перебирает id, а каждый промах доходит до базы. Метка отсутствия с TTL в 30 секунд снимает почти всю эту нагрузку
Меняют формат ключей на все поды разом. Новый релиз начинает с пустого кэша, и выкатка превращается в лавину. Выкатывают постепенно или прогревают новые ключи заранее
Удаляют ключ внутри транзакции. До коммита читатель успевает вернуть в кэш старое значение. Удаляют после коммита, а лучше вешают инвалидацию на события из лога базы
🎯 Вопросы с собеседований
Что такое cache stampede и как с ним бороться?
Это когда популярный ключ истёк, и все одновременные запросы промахиваются и идут в базу за одним и тем же. Внутри процесса склеивают одинаковые загрузки через singleflight, между репликами — короткой блокировкой в Redis, пока один загружает, остальные ждут или отдают старую копию. Ещё лучше не давать ключу истечь под нагрузкой: обновлять его в фоне заранее или вероятностно, как в XFetch
Как работает singleflight и какие у него ограничения?
Группа хранит текущие вызовы по ключу. Первый вызов Do выполняет функцию, остальные с тем же ключом ждут и получают тот же результат и ту же ошибку. Работает только внутри одного процесса, поэтому запросов в базу будет столько, сколько реплик. Не учитывает контекст ждущих, поэтому загрузку запускают со своим таймаутом, а для отмены ожидания используют DoChan
Чем лавина отличается от стампида?
Стампид бьёт по одному горячему ключу. Лавина задевает множество ключей одновременно: они истекли в одну секунду или упал сам кэш. От одновременного истечения помогает разброс TTL. От падения кэша — ограничение одновременных запросов к базе, circuit breaker и прогрев перед тем, как вернуть трафик
Что делать с запросами к несуществующим данным?
Каждый такой запрос промахивается и идёт в базу, потому что кэшировать нечего. Сначала проверяют вход и отсекают заведомо невалидные id. Потом кэшируют сам факт отсутствия с коротким TTL. Если id перебирают в больших объёмах, ставят фильтр Блума: он точно говорит «такого нет» и занимает около 10 бит на элемент при 1% ошибок
Как кэш может разойтись с базой при cache-aside, даже если ключ удаляют после записи?
Читатель промахнулся и прочитал из базы старое значение, затем писатель обновил базу и удалил ключ, и только потом читатель положил старое значение в кэш. Оно проживёт до конца TTL. Закрывают это коротким TTL, повторным удалением через секунду, версиями с атомарной проверкой при записи в кэш или инвалидацией по логу базы
Что такое горячий ключ и как его разгрузить?
Ключ, который читают так часто, что один узел Redis не справляется, а масштабирование кластера не помогает, потому что ключ живёт в одном слоте. Ищут через redis-cli --hotkeys при LFU или метриками клиента. Разгружают локальным кэшем на несколько секунд, копиями ключа с суффиксом на разных узлах или чтением с реплик
Redis перезапустился с пустой памятью. Что будет с сервисом и как подготовиться заранее?
Все запросы станут промахами, и база получит нагрузку, которую раньше снимал кэш, при 99% попаданий это в сто раз больше. Заранее ставят ограничение одновременных запросов к базе, чтобы лишние получали быстрый отказ, а не очередь на секунды. Включают персистентность или реплику для Redis, прогревают популярные ключи до того, как вернуть трафик, и проверяют такой сценарий на нагрузочном тесте
📚 Что почитать
- Пакет singleflight — документация
Do,DoChanиForgetс точной семантикой - Scaling Memcache at Facebook — статья NSDI 2013: lease против стампида и устаревших записей, инвалидация по логу базы на масштабе Facebook
- Optimal Probabilistic Cache Stampede Prevention — статья про XFetch с доказательством и псевдокодом на полстраницы
- Bloom filter — фильтр Блума в Redis: как выбрать долю ошибок и размер, сколько он занимает по сравнению с set