Зачем ставить Redis перед приложением
Redis хранит данные в оперативной памяти по модели ключ-значение. Когда его ставят между приложением и базой, повторяющиеся чтения перестают доходить до БД: приложение сначала спрашивает Redis и только при промахе отправляет запрос в базу. Ответ на чтение приходит из памяти, без сетевого round trip к СУБД, работы планировщика и чтения страниц с диска.
Механика простая. Приложение строит ключ, например product:4213, и делает GET. Значение найдено, оно сразу уходит в ответ. Ключа нет: приложение читает строку из БД, кладёт её в Redis через SET с TTL и отдаёт клиенту. Следующий такой же запрос обслуживается из памяти.
Что кэш реально разгружает:
- Базу данных: меньше SELECT, меньше одновременных соединений, меньше IOPS на диск.
- Латентность чтения: GET в Redis в пределах локальной сети укладывается в доли миллисекунды, тогда как тот же запрос к БД добавляет разбор SQL и обращение к диску при промахе буферного пула.
- Пики: короткий всплеск трафика упирается в Redis и не выедает пул соединений PostgreSQL или MySQL.
Границы применимости:
- Кэш не ускоряет запись. INSERT и UPDATE по-прежнему идут в БД. Write-through меняет момент ответа приложению, но не стоимость записи в базу.
- Кэш не заменяет индексы и разбор плана запроса. Медленный SELECT с последовательным сканом останется медленным на каждом промахе.
- Кэш не помогает при низком hit rate. Каждый промах добавляет сетевой хоп к Redis поверх обычного запроса в БД.
- Кэш не снимает блокировки строк и конкуренцию за данные внутри СУБД.
Hit rate считают по счётчикам самого Redis: keyspace_hits / (keyspace_hits + keyspace_misses). Универсального правильного значения нет: у справочника товаров и у персональной ленты эти цифры несопоставимы. Сравнивайте с baseline, снятым до включения кэша на том же профиле нагрузки.
Redis в основном однопоточный: команды обрабатываются последовательно, и пока выполняется тяжёлая операция, остальные клиенты ждут. Часть операций вынесена в побочные потоки, в том числе UNLINK и медленный ввод-вывод, но это не отменяет общего правила (документация по конфигурации Redis). Команда KEYS перебирает всё пространство ключей и на проде блокирует сервер на время прохода; для поиска по шаблону используйте SCAN с курсором, он отдаёт результат порциями и не держит сервер на весь обход. Даже SCAN может кратковременно блокировать Redis, поэтому KEYS оставляют для разработки, а SCAN применяют в production (сравнение SCAN и KEYS). Та же логика касается SMEMBERS на больших множествах и DEL на крупных ключах: DEL освобождает память синхронно и останавливает обработку команд, а UNLINK передаёт освобождение памяти другому потоку и не блокирует сервер (UNLINK).
Схема потока данных при кэшировании через Redis
Поток при cache-aside выглядит так:
- Клиент отправляет GET /api/products/4213.
- Приложение проверяет ключ: GET product:4213.
- Попадание: значение десериализуется и уходит клиенту, БД не участвует.
- Промах: приложение выполняет SELECT в БД.
- Результат сериализуется и пишется в Redis: SET product:4213 с телом JSON и EX, то есть с TTL в секундах.
- Ответ уходит клиенту, повторный запрос обслуживается из памяти.
В cache-aside приложение само управляет и чтением, и записью в кэш, поэтому вся логика ключей, TTL и инвалидации живёт в коде сервиса. Три параметра определяют устойчивость схемы: таймауты, поведение при недоступности Redis и TTL.
- Таймауты. У клиента Redis нужны таймаут установки соединения и таймаут чтения, заведомо меньшие, чем бюджет ответа API. Если Redis завис, запрос не должен ждать его дольше, чем готов ждать пользователь.
- Поведение при отказе. При ошибке Redis приложение идёт в БД и не пытается писать в кэш. Обратный вариант, ошибка 5xx, выбирают, когда кэш держит данные, которых в базе нет, но для чистого кэша чтения это редкий случай.
- TTL. Ключ без срока жизни превращается в вечные устаревшие данные. Задавайте TTL каждому ключу, который не обновляется явно.
Соединения к Redis держите в пуле: создание TCP-сессии на каждый запрос съедает весь выигрыш от кэша. Если на один HTTP-запрос нужно 20 ключей, объединяйте их в пайплайн или в один MGET, чтобы не платить 20 раз за сетевой обмен. Формат сериализации тоже влияет: JSON читаем глазами, но занимает больше памяти, чем MessagePack или CBOR.
Стратегии кэширования: cache-aside, read-through, write-through и write-behind
Паттерны различаются тем, кто управляет кэшем и в какой момент данные попадают в Redis.
| Паттерн | Кто управляет кэшем | Плюсы | Минусы | Типичный сценарий |
|---|---|---|---|---|
| Cache-aside (lazy loading) | Приложение: читает и пишет ключи само | Просто и гибко, кэшируются только запрошенные данные, при падении Redis чтение продолжается из БД | Логика размазана по коду, легко забыть инвалидацию, первый запрос всегда медленный | Карточки товаров, профили, справочники, результаты тяжёлых отчётов |
| Read-through | Промежуточный слой или библиотека | Сервис не знает про БД при промахе, код чище, ключи строятся в одном месте | Redis не умеет ходить в БД сам, нужен поддерживаемый слой, меньше контроля над ключами | Единая точка доступа к данным в сервисах, где такой слой уже есть |
| Write-through | Приложение или слой кэша | В кэше свежие данные, чтение сразу после записи не промахивается | Запись дороже: две системы синхронно, кэш забивается редко читаемыми записями | Остатки, балансы, конфигурации, права доступа, где важна свежесть |
| Write-behind (write-back) | Приложение плюс очередь или фоновый обработчик | Быстрая запись, сглаживание пиков, объединение мелких обновлений в пакет | Потеря данных при падении Redis до сброса в БД, сложная согласованность, нужна идемпотентная запись | Счётчики просмотров, метрики, агрегаты, журналы событий |
Ключевой факт: Redis сам не ходит в базу. Паттерны read-through, write-through и write-behind требуют библиотеки, прокси-слоя или собственного кода поверх Redis. Без такого слоя остаётся cache-aside: GET, при промахе SELECT, SET с TTL, а после UPDATE или DELETE в БД ключ удаляют.
Матрица выбора под профиль нагрузки:
- Чтений много, записи редкие, устаревание на секунды допустимо: cache-aside.
- Нужен минимум кода в сервисах и единая точка доступа к данным: read-through, если есть поддерживаемый слой.
- Критична свежесть сразу после записи (деньги, остатки, права): write-through плюс явное удаление ключа.
- Запись преобладает, потеря нескольких секунд агрегатов допустима: write-behind с надёжной очередью и повторными попытками.
Инвалидация кэша и устаревшие данные
Устаревшие данные появляются по трём причинам: запись в БД прошла, а ключ не удалён; TTL истёк не вовремя; чтение и запись гоняют один ключ одновременно.
Рабочие приёмы:
- TTL как страховка. Он ограничивает максимальный возраст данных сверху, даже если инвалидация сломалась. TTL выбирайте короче, чем допустимая степень устаревания: для курса валют это секунды, для описания товара - часы.
- Удаление ключа после записи в БД. Именно DEL или UNLINK, а не SET со старым значением из памяти: перезапись протухшим значением после гонки фиксирует рассинхрон надолго.
- Версионирование ключей. Ключ включает версию сущности: product:4213:v18. Новая версия получает новое имя, старое умирает по TTL, массовая инвалидация не нужна.
- Инвалидация по префиксу. Делайте её через SCAN с MATCH и последующими UNLINK пачками. Команда KEYS на работающем Redis блокирует обработку команд на всё время обхода.
Отдельная проблема, cache stampede (thundering herd): популярный ключ истёк, сотни параллельных запросов одновременно промахиваются и все идут в БД, origin получает пиковую нагрузку, растёт задержка, повторы усиливают лавину (разбор cache stampede). Смягчение строится на нескольких механизмах. Блокировка на пересчёт: SET lock:product:4213 с флагом NX и PX, один процесс пересчитывает, остальные коротко ждут и читают готовое значение или получают устаревшие данные (описание подхода с блокировкой). Вероятностное раннее обновление (XFetch): часть запросов обновляет ключ до истечения TTL, вероятность растёт по мере приближения срока (алгоритм XFetch). Jitter: к TTL добавляют случайные секунды, например base_ttl + random(0, 30s), чтобы ключи не истекали синхронной волной. Готовые конфигурации под этот сценарий мы собрали в материале про архитектуру кэширования, инвалидацию и защиту от Cache Stampede.
Когда кэш вредит: антипаттерны и лишняя сложность
Кэш добавляет вторую систему, которую нужно мониторить, защищать и обновлять. Иногда выигрыш не окупает эту цену.
- Данные меняются чаще, чем читаются. Каждая запись требует инвалидации, а промахи идут почти всегда: получается лишний сетевой хоп без выигрыша.
- Низкий hit rate. Если промахи преобладают, приложение платит и за обращение к Redis, и за запрос в БД.
- Кэш без метрик. Без hit rate, used_memory и evicted_keys вы не узнаете, что кэш деградировал, пока не начнутся ошибки в проде.
- Кэш маскирует медленный запрос. Отсутствующий индекс и раздутый JOIN остаются на месте, а после сброса кэша или при холодном старте система падает на том же месте.
- Несколько приложений делят один ключ. Разные TTL и разные моменты инвалидации дают рассинхрон, который невозможно воспроизвести.
- Чувствительные данные в Redis. Токены, персональные данные и платёжные реквизиты в кэше расширяют периметр утечки. Кэшируйте их только при необходимости и с ограничением доступа.
Правило простое: сначала индексы и план запроса, потом кэш. Общий разбор уровней кэширования и синхронизации в распределённых системах есть в полном руководстве по кэшированию для DevOps и системных администраторов.
Безопасность Redis закрывают на сетевом уровне и на уровне самого сервера. bind ограничивает адреса, на которых слушает сервер: только loopback или приватный интерфейс. protected-mode включён по умолчанию начиная с Redis 3.2 и отклоняет не-loopback подключения, если не заданы адрес привязки и пароль (разбор защиты Redis). Для Redis 5.x и более ранних версий задают сильный пароль через requirepass; начиная с Redis 6.0 вместо общего пароля используют ACL: отключают пользователя default и заводят отдельные учётные записи с минимальными правами. protected-mode - это защитный барьер, а не граница безопасности: злоумышленник с выполнением кода на хосте подключится локально и отключит его. Публичный порт 6379 в интернете без пароля - готовая точка входа для чужого скрипта (модель безопасности Redis). Отключать файрвол или проверку TLS ради отладки нельзя: используйте отдельный тестовый инстанс.
Настройка Redis как кэша: параметры и команды проверки
Базовая роль кэша описывается небольшим набором параметров redis.conf. Значения по умолчанию отличаются между ветками Redis, поэтому сверяйтесь с документацией вашей версии и меняйте конфиг сначала на тестовой среде.
maxmemory 4gb
maxmemory-policy allkeys-lru
save ""
appendonly no
timeout 0
tcp-keepalive 300
bind 127.0.0.1 10.0.0.15
protected-mode yes
- maxmemory задаёт верхнюю границу памяти. Без неё Redis растёт до исчерпания RAM и попадает под OOM killer.
- maxmemory-policy решает, что делать при достижении лимита. allkeys-lru вытесняет любые ключи по давности обращения. volatile-lru трогает только ключи с TTL. allkeys-lfu и volatile-lfu опираются на частоту обращений и подходят, когда горячий набор стабилен. noeviction просто отклоняет запись при заполнении памяти. Если политика noeviction или вытеснить ключи не удаётся, Redis начинает отвечать ошибками на команды, увеличивающие память, такие как SET и LPUSH (документация по конфигурации Redis).
- Алгоритмы LRU, LFU и minimal TTL приближённые. По умолчанию Redis проверяет пять ключей и выбирает кандидата на вытеснение; размер выборки настраивается, и значение 5 даёт приемлемый результат. Точного учёта давности или частоты здесь нет (документация по конфигурации Redis).
- save "" отключает RDB-снимки. Для чистого кэша потеря содержимого при рестарте допустима: данные восстановятся из БД. Если Redis хранит единственную копию данных, например сессии, персистентность и репликация обязательны.
- appendonly no отключает журнал AOF. Включайте его, только если содержимое кэша нельзя потерять.
- timeout 0 не закрывает простаивающие соединения. При большом числе клиентов разумно поставить ненулевое значение и не держать мёртвые сессии.
- tcp-keepalive 300 помогает замечать оборванные соединения на уровне TCP.
- bind и protected-mode ограничивают сетевой доступ. 10.0.0.15 в примере - заглушка, подставьте приватный адрес вашего интерфейса.
Просроченные ключи Redis освобождает двумя способами: при обращении, когда ключ обнаружен истёкшим, и в фоне через механизм active expire key. Поэтому expired_keys в статистике растёт не мгновенно после истечения TTL, а по мере фоновой очистки и обращений (документация по конфигурации Redis).
Разбор стратегий с настройкой maxmemory-policy и расчётом hit ratio мы давали в статье про стратегии кэширования от Redis до встроенных механизмов.
Проверка после настройки, набор команд redis-cli:
- redis-cli INFO stats - блоки keyspace_hits, keyspace_misses, evicted_keys, expired_keys.
- redis-cli INFO memory - used_memory_human, maxmemory, mem_fragmentation_ratio.
- redis-cli CONFIG GET maxmemory-policy - фактическое значение в рантайме.
- redis-cli CONFIG SET maxmemory-policy allkeys-lru - смена на лету, применяется сразу; CONFIG REWRITE переносит изменение в файл, если он доступен на запись.
- redis-cli --latency - задержка ответа сервера.
- redis-cli --bigkeys - обход через SCAN и список крупнейших ключей.
- redis-cli SLOWLOG GET 10 - медленные команды, полезно для поиска KEYS и тяжёлых операций.
Проверка конфигурации безопасности: redis-cli CONFIG GET bind, redis-cli CONFIG GET protected-mode и redis-cli CONFIG GET requirepass показывают фактические значения в рантайме (разбор защиты Redis). Затем проверьте, что порт не слушает публичный интерфейс: ss -tlnp | grep ':6379' - в выводе не должно быть внешних адресов.
Перед правкой конфигурации на проде сделайте копию файла: cp /etc/redis/redis.conf /etc/redis/redis.conf.bak. Резкое снижение maxmemory на работающем инстансе вызывает массовое вытеснение ключей, а при noeviction - ошибки записи. Проверяйте такие изменения на тестовой среде или в отдельном инстансе.
Чек-лист перед внедрением кэширования в Redis
- Какие данные кэшируем и как часто они меняются. Пункт закрыт, когда есть список сущностей с оценкой частоты записи и чтения.
- Допустимый возраст данных. Ответ должен быть в секундах или минутах; от него считают TTL.
- Значение TTL для каждого типа ключей. Пункт закрыт, когда в коде нет ни одного ключа без срока жизни.
- Инвалидация при записи. Проверьте, что после UPDATE и DELETE ключ удаляется или меняет версию, и что это покрыто тестом.
- Поведение при недоступности Redis. Таймауты короче бюджета ответа, fallback на БД описан и проверен.
- Лимит памяти и политика вытеснения. maxmemory задан, maxmemory-policy соответствует данным: все ли ключи с TTL, допустимо ли вытеснять горячие записи.
- Мониторинг. Снимаются keyspace_hits, keyspace_misses, evicted_keys, used_memory; есть алерт на рост промахов и на приближение к maxmemory.
- Защита. bind на приватный адрес, аутентификация, firewall, отсутствие публичного доступа к порту.
- План отката. Кэш можно выключить флагом конфигурации приложения, и сервис продолжит работать на БД.
- Нагрузочный тест. Прогон с включённым и выключенным кэшем на реалистичном профиле. Чек-лист этого пункта не заменяет.
Как проверить результат после настройки
Снимайте одни и те же метрики до и после включения кэша на одинаковой нагрузке: hit rate из INFO stats, задержку ответа приложения, число запросов к БД в секунду, загрузку CPU и память Redis. Прирост в процентах зависит от вашего профиля, заранее заложенных цифр не бывает.
- Проверка попаданий. Снимите keyspace_hits и keyspace_misses дважды с интервалом в несколько минут и посчитайте отношение. Рост hits при стабильной нагрузке показывает, что ключи живут достаточно долго.
- Проверка вытеснения. evicted_keys растёт - памяти не хватает, и кэш теряет горячие ключи раньше TTL. Увеличьте maxmemory или сократите объём хранимых данных.
- Проверка устаревания. Обновите запись через API, сразу прочитайте её повторно и убедитесь, что вернулось новое значение. Затем дождитесь истечения TTL и проверьте ещё раз.
- Проверка отказа. На тестовой среде остановите Redis (systemctl stop redis или docker stop с именем контейнера) и убедитесь, что приложение отвечает через БД. Остановка Redis на проде прерывает обслуживание, выполняйте это только на стенде.
- Проверка таймаутов. Заблокируйте доступ к Redis на тестовом стенде и замерьте время ответа: оно должно остаться в пределах бюджета, а не упираться в дефолтный таймаут клиента.
- Наблюдение за командами. MONITOR на проде создаёт заметную нагрузку, используйте его на стенде или ограничьтесь SLOWLOG.
Если по метрикам кэш не даёт выигрыша, ищите узкое место в другом слое: медленный запрос, нехватка пула соединений, блокировки. Методика поиска описана в материале про ускорение автоматизированных систем без замены оборудования.
Итог: ставьте Redis перед приложением, когда чтений заметно больше записей, а возраст данных в секундах или минутах допустим. Начните с cache-aside, задайте TTL каждому ключу, ограничьте maxmemory с политикой allkeys-lru и снимите baseline метрик до запуска. Если hit rate низкий или данные меняются на каждом запросе, кэш убирайте и возвращайтесь к индексам и плану запроса.