На Ubuntu 24.04 пакет redis-server читает настройки из /etc/redis/redis.conf, а службой управляет systemd-юнит redis-server. Ниже — готовый набор директив для одного инстанса Redis 7.x в роли кэша и логика выбора значений под конкретный сервер.
Сценарий простой: Redis стоит между приложением и базой, хранит результаты тяжёлых запросов, сессии или фрагменты страниц, и потерю любого ключа можно пережить ценой повторного обращения к источнику. Конфиг рассчитан на один инстанс, без кластера, Sentinel и репликации. Отказоустойчивый кэш с автоматическим переключением — отдельная схема с репликой и Sentinel или с Redis Cluster, здесь её не разбираем.
Разбираем директивы, которые определяют поведение кэша под нагрузкой: maxmemory, maxmemory-policy, timeout, tcp-keepalive, save, appendonly. Плюс обязательный минимум по доступу: bind, protected-mode, requirepass. Все команды проверки приведены с ожидаемым форматом вывода.
Перед правкой файла убедитесь в версии:
redis-server --version
Команда вернёт строку вида Redis server v=7.0.x. Ветка важна: в Redis 7.0 команда CONFIG GET принимает несколько шаблонов за один вызов и возвращает пары ключ-значение, а в 6.x её вызывают по одной директиве. Если версия ниже 7.0, примеры ниже выполняйте построчно. Поведение CONFIG GET с шаблонами описано в документации Redis.
| Директива | Роль в кэш-инстансе | Значение в примере |
|---|---|---|
| maxmemory | потолок памяти под данные | 2gb, подставьте своё |
| maxmemory-policy | что удалять при заполнении | allkeys-lru |
| timeout | закрытие простаивающих клиентов | 0 |
| tcp-keepalive | обнаружение оборванных TCP-соединений | 300 |
| save | снапшоты RDB на диск | "" (выключены) |
| appendonly | журнал операций AOF | no |
| bind, protected-mode | кто может подключиться | 127.0.0.1, yes |
| requirepass | пароль на подключение | заглушка CHANGE_ME_STRONG_PASSWORD |
Готовый redis.conf для кэш-инстанса
Сначала резервная копия. Правка рабочего конфига без бэкапа — самый частый способ получить незапускающийся Redis в три часа ночи:
sudo cp /etc/redis/redis.conf /etc/redis/redis.conf.bak
Дальше блок директив, который можно вставить в /etc/redis/redis.conf. Значение maxmemory — заглушка, его считаем в следующем подразделе. Пароль в requirepass тоже заглушка, реальный храните в менеджере секретов, а не в репозитории.
# /etc/redis/redis.conf, фрагмент для кэш-инстанса # Redis 7.x, Ubuntu 24.04 bind 127.0.0.1 -::1 protected-mode yes port 6379 requirepass CHANGE_ME_STRONG_PASSWORD maxmemory 2gb maxmemory-policy allkeys-lru timeout 0 tcp-keepalive 300 save "" appendonly no
Что здесь важно по мелочам. Префикс «-» перед ::1 в bind означает, что адрес опционален: если на сервере отключён IPv6, Redis не откажется стартовать. Директива save с пустой строкой отключает точки снапшотов RDB, appendonly no выключает журнал AOF. Обе строки нужны вместе: одной мало, если раньше AOF был включён и файл уже создан.
Перед рестартом проверьте конфиг на тестовой среде. Синтаксической проверки отдельных флагов у redis-server нет, поэтому безопасный путь — применить файл на копии инстанса, поднять его и посмотреть, что процесс стартовал и отвечает на PING.
Как посчитать maxmemory под свой сервер
maxmemory задаёт объём, после которого Redis начинает вытеснять ключи или возвращать ошибки записи. Значение указывают в байтах или с суффиксом: 2gb, 512mb. Ставить лимит равным всей RAM нельзя, процессу нужна память сверх него.
Вне maxmemory живут: сам процесс, буферы клиентских соединений, фрагментация аллокатора и копия страниц при fork, если включены RDB-снапшоты. Поэтому RSS процесса бывает выше лимита, а при нехватке памяти ядро выбирает жертву через OOM killer. Худший сценарий для fork оценивают как удвоение занятой памяти, если в момент снапшота в данные активно пишут.
Логика расчёта для сервера 8 ГБ, где Redis — единственный тяжёлый сервис:
- 1–1,5 ГБ оставить ОС, systemd, агенту мониторинга и логам;
- 0,5–1 ГБ заложить на фрагментацию и буферы соединений;
- остаток, примерно 5–6 ГБ, отдать под maxmemory.
Если на той же машине работают PostgreSQL, Nginx и приложение, вычитайте их потребление первым. Для чистого кэша без персистентности запас на fork не нужен, но запас на фрагментацию остаётся.
Фактическое потребление смотрят так:
redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning INFO memory
В выводе четыре поля: used_memory (данные в понимании Redis), used_memory_rss (сколько памяти видит ядро), maxmemory (действующий лимит) и mem_fragmentation_ratio (отношение RSS к used_memory). Показатель выше 1,5 держится долго — запас стоит увеличить или перезапустить инстанс в окно обслуживания.
Почему allkeys-lru для чистого кэша
Политика вытеснения решает, что удалять, когда used_memory упирается в maxmemory. Для чистого кэша базовая настройка — allkeys-lru: Redis удаляет ключи, к которым дольше всего не обращались, независимо от наличия TTL. Все ключи равнозначны, любой можно пересобрать из источника.
| Политика | Поведение | Когда выбирать |
|---|---|---|
| allkeys-lru | вытесняет любые ключи по давности обращения | чистый кэш, все ключи восстанавливаемы |
| allkeys-lfu | вытесняет по частоте обращений | кэш с устойчиво горячим меньшинством ключей |
| allkeys-random | удаляет случайные ключи | редкий случай, когда давность и частота не информативны |
| volatile-lru | вытесняет только ключи с TTL | в инстансе есть данные без TTL, которые нельзя терять |
| volatile-ttl | удаляет ключи с наименьшим остатком TTL | важен срок жизни, а не популярность |
| noeviction | не вытесняет ничего, ошибки на запись | Redis как хранилище, а не кэш |
Политика volatile-lru вытесняет по приблизительному LRU только среди ключей с установленным expire — это описано в самодокументированном redis.conf. Ловушка политик volatile-*: если ключей с TTL не осталось, вытеснять нечего, и Redis вернёт ошибку на запись даже при заполненной памяти. noeviction ведёт себя так же: при достижении maxmemory команда записи получит отказ, а read-only команды вроде GET продолжат отвечать. Для кэша это обычно не то поведение, которое нужно.
Два необязательных параметра сглаживают побочные эффекты вытеснения. lazyfree-lazy-eviction yes освобождает память удаляемых крупных значений в фоновом потоке вместо синхронного освобождения. maxmemory-samples регулирует точность приближённого LRU, по умолчанию 5; больше выборка — точнее выбор жертвы и чуть выше нагрузка на CPU.
Персистентность: отключать или нет
RDB (директива save) делает снапшот всей базы в dump.rdb через заданные интервалы. AOF (appendonly) пишет журнал операций и восстанавливает состояние при старте. Обе механики страхуют от потери данных при рестарте и обе стоят ресурсов.
Цена RDB: fork процесса и копирование страниц при записи, всплеск дискового I/O, память под COW. Цена AOF: постоянная запись на диск, объём журнала и время восстановления при большом файле. Для кэша эти издержки часто лишние: данные не уникальны и восстанавливаются из источника.
Отключаем обе директивы:
save "" appendonly no
Чтобы отключить RDB, нужно закомментировать все директивы save (по умолчанию их три) и явно указать save "", после чего перезапустить Redis — так этот шаг описан в обсуждении отключения персистентности.
Риски, которые вы принимаете вместе с этим решением:
- после рестарта кэш пустой, и вся нагрузка разом идёт в базу или приложение — вероятен шторм запросов и рост времени ответа;
- при аварийном завершении процесса теряются все данные, включая те, что приложение считало уже сохранёнными;
- если инстанс делит память с очередями, распределёнными локами, счётчиками или сессиями, отключать персистентность нельзя: это уже не кэш.
Шторм после холодного старта разбираем отдельно в материале про кэширование в высоконагруженных системах и защиту от cache stampede: там есть и про прогрев кэша, и про то, как не уронить базу в момент потери кэша. Практический приём — прогревать кэш по расписанию после деплоя и ограничивать число одновременных запросов к источнику на один ключ.
Развилка по сценариям:
| Сценарий | save | appendonly | Что учесть |
|---|---|---|---|
| чистый кэш перед БД | "" | no | холодный старт и шторм запросов |
| кэш, который должен пережить рестарт | оставить точки снапшотов | no | память под fork, всплески I/O |
| смешанное использование | по необходимости | yes | fsync-политика AOF и объём журнала |
Если Redis нужен и как кэш, и как хранилище, разнесите роли по разным инстансам. Один процесс с allkeys-lru однажды вытеснит данные, которые вы считали постоянными. Подробнее про память, персистентность и репликацию — в полном руководстве по настройке Redis для продакшена.
Сеть и таймауты: timeout и tcp-keepalive
timeout закрывает клиентское соединение после N секунд простоя. Значение 0 означает «не закрывать». Настройка по умолчанию — 0, и для кэша с пулом соединений от приложения это разумный выбор.
Когда timeout полезен: если клиенты подключаются напрямую, без пула, и оставляют «мёртвые» соединения, которые занимают файловые дескрипторы и память под буферы. Тогда значение вроде 300 освобождает ресурсы. Условие одно: timeout должен быть больше времени простоя соединения в пуле приложения. Иначе пул будет получать разорванные соединения и отдавать ошибки в ответ на запросы из середины своего пула, а это худший вид дебага.
tcp-keepalive задаёт период TCP-проб для обнаружения оборванной связи. Значение по умолчанию — 300 секунд, 0 отключает механизм. Для кэша 300 оставляют почти всегда: это дешёвый способ узнать, что клиент исчез, не дожидаясь таймаута приложения.
Проверка значений на работающем инстансе:
redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning CONFIG GET timeout tcp-keepalive
Ожидаемый формат ответа — пары имя/значение:
1) "timeout" 2) "0" 3) "tcp-keepalive" 4) "300"
Безопасность кэш-инстанса: минимум, который нельзя пропустить
Redis, доступный из интернета без пароля, — классический способ отдать злоумышленнику выполнение команд и содержимое кэша. Три директивы закрывают базовый сценарий для локального кэша:
bind 127.0.0.1 -::1 protected-mode yes requirepass CHANGE_ME_STRONG_PASSWORD
bind ограничивает интерфейсы, на которых Redis слушает. protected-mode yes не даёт принять соединение с внешнего адреса, если bind не задан и пароль не установлен. requirepass требует пароль на AUTH. Пароль берите длинный и случайный, храните в менеджере секретов, а строку CHANGE_ME_STRONG_PASSWORD из примера замените целиком.
Если приложение живёт на другом хосте, схема другая: bind на приватный IP, доступ только из подсети приложений через файрвол и никакой публикации наружу. Правило про файрвол и права доступа работает без исключений: отключать файрвол или выдавать 777 на файлы конфигурации — не решение проблемы, а её источник.
Проверка доступа с локального хоста:
redis-cli -h 127.0.0.1 -p 6379 -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning PING
Ожидаемый ответ — PONG. Проверка снаружи: с другой машины запрос на публичный адрес и порт 6379 должен завершиться отказом или таймаутом, а не ответом PONG.
Пароль в командной строке попадает в историю shell и в список процессов. Чище передать его через переменную окружения REDISCLI_AUTH, которую redis-cli читает сам — этот способ рекомендован в документации по redis-cli:
read -rs REDISCLI_AUTH export REDISCLI_AUTH redis-cli PING
Для разграничения прав в Redis 6.0 и выше есть ACL: отдельный пользователь с ограниченным набором команд и префиксов ключей вместо одного общего пароля. Для кэша одного приложения это хорошая практика, если к инстансу обращаются несколько сервисов.
Как применить конфиг и проверить результат
Порядок без сюрпризов: резервная копия файла, правка, рестарт службы, проверка статуса и логов.
sudo systemctl restart redis-server sudo systemctl status redis-server sudo journalctl -u redis-server -n 50 --no-pager
Статус должен показывать active (running), а в журнале не должно быть строк о невозможности загрузить конфигурацию. Рестарт обрывает соединения и, при отключённой персистентности, обнуляет кэш. Планируйте его на окно низкой нагрузки.
Часть директив меняют без перезапуска: maxmemory, maxmemory-policy, timeout, tcp-keepalive применяются через CONFIG SET сразу. Команда CONFIG REWRITE записывает текущие значения в файл, но переформатирует его, поэтому держите бэкап под рукой.
redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning CONFIG SET maxmemory-policy allkeys-lru redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning CONFIG SET maxmemory 2gb redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning CONFIG REWRITE
С save и appendonly осторожнее: CONFIG SET save "" отключает снапшоты, CONFIG SET appendonly no останавливает AOF, но уже созданный файл на диске остаётся и будет прочитан при следующем старте, если не отключить AOF в самом файле конфигурации. Правка /etc/redis/redis.conf с последующим рестартом предсказуемее.
Проверка через redis-cli CONFIG GET
CONFIG GET показывает действующие значения, а не то, что вы намеревались написать. В Redis 7.0 несколько директив запрашивают одной командой:
redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning CONFIG GET maxmemory maxmemory-policy timeout tcp-keepalive save appendonly
Ожидаемый вывод в общем виде (цифры условные):
1) "maxmemory" 2) "2147483648" 3) "maxmemory-policy" 4) "allkeys-lru" 5) "timeout" 6) "0" 7) "tcp-keepalive" 8) "300" 9) "save" 10) "" 11) "appendonly" 12) "no"
Что считать правильным: maxmemory в байтах соответствует заданному лимиту, maxmemory-policy равна allkeys-lru, timeout и tcp-keepalive совпадают с файлом, save возвращает пустую строку при отключённых снапшотах, appendonly возвращает no.
Проверка через redis-cli INFO
CONFIG GET подтверждает настройки, INFO показывает поведение. Начните с памяти:
redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning INFO memory
Ожидаемые поля в выводе: used_memory, used_memory_rss, maxmemory, maxmemory_policy, mem_fragmentation_ratio. Сравните used_memory с maxmemory: устойчивое приближение к лимиту означает, что вытеснение работает постоянно, и либо кэш мал для рабочего набора, либо TTL выставлены слишком долго.
Дальше статистика вытеснения и попаданий:
redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning INFO stats redis-cli -a 'CHANGE_ME_STRONG_PASSWORD' --no-auth-warning INFO keyspace
В секции stats важны три счётчика. evicted_keys растёт, когда память заполнена и Redis удаляет ключи: при заполненном maxmemory это нормальная работа политики, а не ошибка. keyspace_hits и keyspace_misses показывают попадания и промахи. Промахов стало заметно больше, чем раньше, — проверяйте TTL, размер maxmemory и то, не меняется ли формат ключей после деплоя. Универсального порога hit rate нет, он зависит от приложения.
Секция keyspace показывает, что реально лежит в базе:
db0:keys=142350,expires=138900
Если expires почти равен keys, почти все ключи имеют TTL, и это нормально для кэша. Ноль в expires при работающем кэше означает, что TTL не выставляются, и память будет расти до вытеснения по LRU. Методику разбора таких ситуаций смотрите в материале про диагностику ошибок кэширования, а влияние размера кэша на нагрузку базы разобрано в статье про кэширование базы данных.
Чек-лист перед выводом в прод
- Резервная копия /etc/redis/redis.conf сделана, путь к ней записан.
- maxmemory выставлен с запасом под ОС, буферы и фрагментацию, а не равным всей RAM.
- maxmemory-policy соответствует роли инстанса: allkeys-lru для чистого кэша.
- Решение по save и appendonly принято осознанно, риск холодного старта и шторма запросов в базу понятен.
- timeout и tcp-keepalive проверены на тестовой среде вместе с пулом соединений приложения.
- bind ограничен локальным или приватным интерфейсом, protected-mode включён, порт 6379 недоступен из интернета.
- requirepass задан, пароль хранится в секретах и не попал в репозиторий и историю shell.
- После рестарта CONFIG GET и INFO memory подтверждают значения, служба в статусе active (running).
- Метрики evicted_keys, keyspace_hits, keyspace_misses и used_memory выводятся в мониторинг.
- План прогрева кэша после деплоя и рестарта есть, ограничение параллельных запросов к источнику на один ключ предусмотрено.
Кластер, Sentinel и тюнинг под конкретный профиль нагрузки требуют отдельного разбора и знания вашей архитектуры: такие решения принимают по метрикам продакшена, а не по шаблону. Базовый конфиг выше закрывает роль кэша на одном инстансе и даёт проверяемый результат в виде CONFIG GET и INFO.