🧠 Стратегии кэширования
Кэш — копия данных там, откуда их достать быстрее, чем из источника: в памяти процесса или в Redis вместо запроса к базе. Он снимает нагрузку с базы и срезает задержку, но приносит вопрос, на котором сыплются и на собеседовании, и на проде: что делать, когда данные в базе поменялись. На этой странице разобраны стратегии чтения и записи, TTL и инвалидация, выбор между локальным и общим кэшем. Цифры сняты на ноутбуке: PostgreSQL 16 и Redis 7.4 в Docker, клиент на Go
🧠 Сколько даёт кэш
Возьмём карточку товара: строка из products и средняя оценка по 20 тысячам отзывов. Медиана из 200 запросов:
| Что читаем | Время |
|---|---|
| Карточка из Postgres с агрегатом по отзывам | 74 мс |
| Строка из Postgres по первичному ключу | 0,21 мс |
| Готовая карточка из Redis | 0,18 мс |
Карточка из map в памяти процесса | 41 нс |
Первая строка объясняет, зачем кэш: тяжёлый запрос превращается в чтение по ключу, в 400 раз быстрее. Вторая показывает, когда он почти бесполезен. Чтение по первичному ключу из Postgres стоит столько же, сколько поход в Redis, потому что оба упираются в сеть. Кэшируют дорогое: агрегаты, джойны, ответы внешних API, собранные из нескольких запросов объекты
Среднее время ответа зависит от доли попаданий (hit ratio). Промах стоит 74 мс плюс два похода в Redis, попадание — 0,18 мс:
- 90% попаданий: в среднем 7,6 мс, и на тысячу запросов в секунду база выполняет 100 тяжёлых запросов
- 99% попаданий: в среднем 0,9 мс и 10 тяжёлых запросов в секунду
Разница между 90 и 99 процентами — восьмикратная по задержке и десятикратная по нагрузке на базу. Поэтому hit ratio выводят на дашборд первым, а падение доли попаданий ловят алертом раньше, чем жалобы пользователей
📖 Стратегии чтения и записи
Стратегия отвечает на два вопроса: кто кладёт данные в кэш и что происходит с кэшем при записи
| Стратегия | Чтение | Запись | Чем платят |
|---|---|---|---|
| Cache-aside (lazy loading) | приложение смотрит в кэш, при промахе читает базу и кладёт результат в кэш | приложение пишет в базу и удаляет ключ | первый запрос после промаха медленный, между записью и удалением ключа возможны устаревшие данные |
| Read-through | приложение спрашивает только кэш, при промахе кэш сам вызывает загрузчик | как в cache-aside | нужна библиотека или кэш, который умеет загружать данные |
| Write-through | как в cache-aside | приложение пишет в базу и сразу кладёт новое значение в кэш | каждая запись дважды, в кэше оседает то, что никто не читает |
| Write-behind (write-back) | из кэша | запись идёт в кэш, в базу уходит позже пачкой | при падении кэша теряются записи, которые не доехали до базы |
Cache-aside
Самая частая стратегия в бэкенде, и на собеседовании под «как ты кэшируешь» обычно ждут её. Кэш ничего не знает о базе, всю логику держит приложение:
func getCard(ctx context.Context, id int) (Card, error) {
key := fmt.Sprintf("card:v1:%d", id)
b, err := rdb.Get(ctx, key).Bytes()
if err == nil {
var c Card
if json.Unmarshal(b, &c) == nil {
return c, nil
}
} else if !errors.Is(err, redis.Nil) {
log.Printf("redis: %v", err) // кэш недоступен, идём в базу
}
c, err := loadCard(ctx, id) // тот самый запрос на 74 мс
if err != nil {
return Card{}, err
}
b, _ = json.Marshal(c)
rdb.Set(ctx, key, b, ttlWithJitter(10*time.Minute))
return c, nil
}Три детали в этом коде спрашивают отдельно. Ошибка Redis не роняет запрос: кэш ускоряет, но не должен становиться точкой отказа. Ключ содержит версию формата v1: если в новом релизе поменяется структура Card, новый код начнёт с пустых ключей v2, а старый, который ещё работает во время выкатки, не споткнётся о новый JSON. У каждого ключа есть TTL, о нём ниже
Плюс cache-aside в том, что в кэш попадает только то, что читают, а пустой кэш после рестарта не ломает сервис, только замедляет его. Минус — каждый промах стоит три похода: в кэш, в базу и снова в кэш
Write-through и write-behind
Write-through обновляет кэш при каждой записи, поэтому сразу после записи читатели видят новое значение. Его берут, когда важно читать свежее сразу после изменения, а данные читают чаще, чем пишут. Цена — лишняя запись в кэш на каждое изменение, в том числе для объектов, которые потом никто не откроет. Обычно его комбинируют с cache-aside и TTL: промах всё равно загружается из базы, а TTL вычищает невостребованное
Write-behind переворачивает порядок: приложение пишет в кэш, а в базу данные уходят позже, пачками. Так считают просмотры и лайки: INCR в Redis на каждый просмотр, а раз в несколько секунд воркер переносит накопленные счётчики в Postgres одним запросом. Вместо записи на каждый просмотр база получает один запрос раз в несколько секунд. Для денег и заказов это не подходит: Redis упал между записью и сбросом — изменения пропали, а клиент уже получил «успешно»
🔄 TTL и инвалидация
Кэш — копия, и копия устаревает. Способов держать её свежей два: ограничить срок жизни и удалять ключ при изменении. На практике используют оба
TTL — страховка от всего, что пошло не так: забытая инвалидация, запись в базу в обход сервиса, баг в коде. Ключ без TTL при любой такой ошибке хранит неправду вечно. Длину TTL выбирают от вопроса «сколько секунд устаревших данных бизнес готов терпеть». Курс валют для витрины держат минуту, название товара час, справочник городов сутки. Слишком короткий TTL превращает кэш в источник промахов, слишком длинный — в источник жалоб
У TTL в Redis есть особенность, на которой ловят и на код-ревью. SET без срока снимает TTL с существующего ключа, а INCR, HSET и LPUSH его сохраняют:
> SET card:42 a EX 600
> SET card:42 b
> TTL card:42
(integer) -1 # ключ стал вечным
> SET card:42 c EX 600
> SET card:42 d KEEPTTL
> TTL card:42
(integer) 600Если ключи создаются одновременно, например прогрев после деплоя, с одинаковым TTL они и истекут одновременно, и все промахи придут в базу в одну секунду. Поэтому к TTL добавляют случайную добавку:
func ttlWithJitter(base time.Duration) time.Duration {
return base + rand.N(base/10) // от 10 до 11 минут
}Что происходит, когда в истёкший ключ разом приходят сотни запросов, и как это лечат, разобрано на странице про проблемы кэша
Почему ключ удаляют, а не обновляют
При изменении данных есть два варианта: положить в кэш новое значение или удалить ключ, чтобы следующий читатель загрузил его из базы. Удаление выглядит расточительным, но обновление ломается на конкурентной записи. Два запроса меняют цену товара почти одновременно:
- Писатель A записывает в базу цену 200
- Писатель B записывает в базу цену 300 и кладёт 300 в кэш
- Писатель A, задержавшийся на паузе GC или в сети, кладёт в кэш 200
Этот сценарий запущен на Postgres и Redis с принудительным порядком через каналы, вывод программы:
set: база 300 кэш 200
del: база 300 кэш 300В базе 300, в кэше 200, и так будет до конца TTL. С удалением порядок писателей не важен: оба удаляют один ключ, следующий читатель берёт из базы последнее значение
Порядок тоже важен: сначала база, потом удаление ключа. Если удалить ключ первым, в промежутке до записи в базу читатель успеет загрузить старое значение и вернуть его в кэш. У cache-aside остаётся и более редкая гонка, когда читатель загрузил старое значение до записи, а положил в кэш после удаления. Её разбирает страница про проблемы кэша, там же способы её закрыть
🏠 Локальный кэш или общий
Локальный кэш живёт в памяти процесса: map с мьютексом или библиотека с вытеснением по LRU и лимитом размера. Чтение за десятки наносекунд, без сети и сериализации. Но у каждой реплики сервиса своя копия. Пять подов в Kubernetes — пять копий, и после изменения в базе пользователь видит то старую цену, то новую, в зависимости от того, в какой под попал запрос. Удалить ключ в одном поде мало, остальные о записи не знают
Общий кэш — отдельный сервис, чаще всего Redis. Копия одна на все реплики, инвалидация одним DEL, кэш переживает рестарт сервиса. Платят сетью: 0,18 мс вместо 41 нс, плюс сериализация и ещё одна система в эксплуатации
| Локальный | Общий (Redis) | |
|---|---|---|
| Задержка чтения | десятки наносекунд | доли миллисекунды |
| Консистентность между репликами | у каждой своя копия | одна копия |
| Инвалидация | только TTL или рассылка событий всем репликам | DEL по ключу |
| После рестарта сервиса | пустой | на месте |
| Объём | ограничен памятью пода | отдельная машина или кластер |
Локальный берут для того, что меняется редко и одинаково для всех: конфиги, фича-флаги, справочники, курсы валют. Ему ставят короткий TTL, секунды или минуты, и ограничивают размер: map без лимита растёт, пока под не убьёт OOM killer
Часто их ставят друг за другом: локальный кэш на несколько секунд перед Redis, Redis перед базой. Горячие ключи читаются из памяти, а Redis прикрывает базу от промахов локального. Чтобы локальные копии не жили устаревшими весь TTL, при записи рассылают событие через Redis Pub/Sub или брокер. С Redis 6 есть и встроенный механизм, client-side caching: сервер запоминает, какие ключи читал клиент, и присылает ему сообщение об инвалидации, когда ключ меняется
⚠️ Где ошибаются
Кэшируют дешёвое. Чтение по первичному ключу из Postgres идёт за 0,2 мс, столько же, сколько чтение из Redis. Кэш тут добавляет ещё одну систему и устаревшие данные, а выигрыша не даёт. Сначала профилируют и находят дорогой запрос, потом кэшируют его
Ставят ключ без TTL. Любая ошибка инвалидации становится вечной. Отдельная ловушка Redis — обновление значения обычным SET без EX или KEEPTTL: TTL пропадает молча
Обновляют кэш при записи вместо удаления. Два конкурентных писателя оставляют в кэше значение проигравшего, и оно живёт до конца TTL. Удаляют ключ, и только после успешной записи в базу
Держат в кэше то, чего нет в базе. Корзина или черновик заказа, которые живут только в Redis без персистентности и реплики, пропадут при первом рестарте. Кэш хранит копию, источником правды остаётся база
Кладут в общий кэш персональное по общему ключу. Ответ /me, закэшированный по пути запроса без идентификатора пользователя, получит следующий пользователь. Ключ обязан содержать всё, от чего зависит ответ: пользователя, язык, права
🎯 Вопросы с собеседований
Какие стратегии кэширования ты знаешь?
Cache-aside: приложение читает из кэша, при промахе идёт в базу и кладёт результат в кэш, при записи удаляет ключ. Read-through: то же, но загрузку делает сам кэш. Write-through: при записи новое значение кладут и в базу, и в кэш. Write-behind: пишут в кэш, а в базу сбрасывают позже пачками, это быстро, но при падении кэша записи теряются. В бэкенде чаще всего cache-aside с TTL
Почему при изменении данных ключ удаляют, а не обновляют?
Из-за конкурентных записей. Если два запроса меняют одно значение, они могут положить его в кэш в другом порядке, чем записали в базу, и в кэше останется старое значение до конца TTL. Удаление не зависит от порядка: следующий читатель загрузит из базы последнюю версию. Цена — один лишний промах после записи
Что делать сначала: писать в базу или удалять ключ из кэша?
Сначала база, потом удаление. Если удалить ключ первым, до записи в базу кто-нибудь прочитает старое значение и снова положит его в кэш. Если удаление после записи не прошло, например Redis недоступен, спасает TTL. Поэтому TTL ставят даже там, где инвалидация есть
Как выбрать TTL?
От того, сколько устаревших данных терпит бизнес, и от частоты изменений. Цену в корзине и остатки кэшируют на секунды или не кэшируют вовсе, название товара держат часами, справочники сутками. К TTL добавляют случайный разброс, чтобы ключи, созданные одновременно, не истекали одновременно. Короткий TTL снижает долю попаданий, поэтому его проверяют по метрике hit ratio
Локальный кэш или Redis?
Локальный быстрее на порядки, но у каждой реплики своя копия, и после изменения реплики отвечают по-разному. Redis общий для всех реплик и инвалидируется одним удалением, но стоит сетевого похода. Локальный берут для редко меняющихся данных с коротким TTL и лимитом размера, Redis — для остального. Часто ставят оба уровня друг за другом
Что будет с сервисом, если Redis упадёт?
При cache-aside сервис продолжит работать, если код считает ошибку кэша промахом и идёт в базу. Но вся нагрузка, которую закрывал кэш, придёт в базу разом, и при 99% попаданий это в сто раз больше тяжёлых запросов. Поэтому заранее проверяют, выдержит ли база, и ставят ограничение на число одновременных запросов к ней
Что не стоит кэшировать?
Дешёвые запросы, которые база отдаёт так же быстро, как кэш. Данные, которые меняются чаще, чем их читают: кэш будет почти всегда пустым. Данные, где устаревание недопустимо, например баланс перед списанием. Чувствительные данные в общем кэше без продуманного ключа и прав доступа
📚 Что почитать
- Cache-Aside pattern — паттерн в Azure Architecture Center: порядок записи и удаления, проблемы локального кэша, когда паттерн не подходит
- Caching strategies — документация ElastiCache о lazy loading, write-through и о том, как TTL сглаживает недостатки обоих
- EXPIRE — какие команды снимают TTL, а какие нет, и как Redis удаляет истёкшие ключи
- Client-side caching reference — как Redis сообщает клиенту, что его локальная копия устарела, и какие там гонки