🟥 Redis
Redis — хранилище структур данных в памяти. Его ставят перед базой как кэш, но на нём же держат счётчики, рейтинги, очереди, сессии и лимиты запросов. На собеседовании про Redis спрашивают почти всегда, когда в резюме есть бэкенд: почему он быстрый при одном потоке, какую структуру взять под задачу, что он теряет при падении и что делает, когда кончилась память. Все цифры ниже сняты на ноутбуке: Redis 7.4 в Docker, команды через redis-cli
🧠 Один поток и почему это быстро
Все данные лежат в оперативной памяти, а команды выполняет один главный поток. Он через мультиплексирование (epoll на Linux) слушает тысячи соединений и по очереди берёт из них готовые команды. Пока выполняется одна команда, остальные ждут. Типичная команда вроде GET или INCR занимает доли микросекунды, поэтому очередь не успевает вырасти, а время ответа определяет сеть
Из однопоточности следуют два вывода, которые спрашивают чаще всего. Первый: каждая команда атомарна. INCR от тысячи клиентов одновременно даст ровно тысячу, без блокировок и гонок. Второй: одна медленная команда останавливает всех. Пример на 2 млн ключей:
| Что происходит | Ответ на GET от другого клиента |
|---|---|
| Сервер свободен | 0,39 мс |
В это время кто-то выполняет KEYS * | 356–513 мс |
В это время кто-то выполняет SCAN 0 COUNT 1000 | 0,7–3 мс |
KEYS * обходит всё пространство ключей одной командой, и полсекунды сервер не отвечает никому. SCAN отдаёт ключи порциями по курсору, и между порциями сервер обслуживает остальных. То же с удалением большого ключа: DEL множества из 3 млн элементов (162 МБ) занял 248 мс, UNLINK того же размера — 13 мкс. UNLINK убирает ключ из словаря сразу, а память освобождает фоновым потоком
«Однопоточный» — упрощение. Фоновые потоки есть давно: они делают fsync, освобождают память после UNLINK, закрывают файлы. Есть и I/O-потоки (io-threads, по умолчанию 1, то есть выключены): они читают и пишут сокеты и разбирают протокол. Сами команды по-прежнему выполняет главный поток, поэтому атомарность не меняется
Сеть дороже команды
Раз команда выполняется за микросекунды, основное время уходит на путь туда и обратно. Pipelining отправляет пачку команд без ожидания ответа на каждую. redis-benchmark на одном соединении:
redis-benchmark -t set -n 200000 -q -P 1 -c 1
SET: 20114.65 requests per second
redis-benchmark -t set -n 200000 -q -P 16 -c 1
SET: 282485.88 requests per secondПачка по 16 команд дала в 14 раз больше записей в секунду, и это внутри одного контейнера. Между машинами в дата-центре сетевой путь длиннее, и разница ещё больше. Пачка не атомарна: между командами одного пайплайна могут выполниться чужие. Если нужна атомарность нескольких команд, берут MULTI/EXEC или Lua-скрипт, который сервер выполняет целиком, не прерываясь
🧰 Структуры данных под задачи
Redis хранит не только строки. Правильная структура часто заменяет кусок кода в сервисе и запрос к базе:
| Тип | Главные команды | Для чего берут |
|---|---|---|
| String | GET, SET, INCR, SET ... NX EX | кэш объекта, счётчики, флаги, простая блокировка |
| Hash | HSET, HGET, HINCRBY | объект с полями: профиль, корзина, сессия. Поле меняется без перезаписи всего объекта |
| List | LPUSH, RPOP, BRPOP, LRANGE | простая очередь задач, последние N событий |
| Set | SADD, SISMEMBER, SINTER | уникальные значения: кто онлайн, теги, общие друзья |
| Sorted set | ZADD, ZINCRBY, ZREVRANGE, ZRANGEBYSCORE | рейтинги, очереди с приоритетом, окно по времени |
| Stream | XADD, XREADGROUP, XACK | лог событий с группами потребителей, лёгкая замена брокера |
| HyperLogLog | PFADD, PFCOUNT | приблизительный подсчёт уникальных: посетители за день |
| Bitmap | SETBIT, BITCOUNT | флаг на пользователя по числовому id: заходил ли сегодня |
Sorted set спрашивают отдельно, потому что на нём решается классическая задача про таблицу лидеров. Каждый элемент хранит число (score), набор всегда отсортирован, вставка и поиск ранга идут за O(log N):
> ZADD leaderboard 1500 anna 1720 boris 1610 vera
> ZINCRBY leaderboard 300 anna
"1800"
> ZREVRANGE leaderboard 0 2 WITHSCORES
1) "anna"
2) "1800"
3) "boris"
4) "1720"
5) "vera"
6) "1610"
> ZREVRANK leaderboard vera
(integer) 2В Postgres то же самое — order by score desc с индексом и пересчёт ранга на каждый запрос. В Redis ранг игрока из миллиона приходит одной командой
HyperLogLog показывает, как Redis меняет точность на память. 100 тысяч уникальных id в обычном множестве заняли 5,5 МБ. В HyperLogLog те же id заняли 14 КБ, а PFCOUNT вернул 100 254, ошибка 0,25%. Для счётчика посетителей на дашборде этого хватает, для биллинга нет
Маленькие хеши, списки и множества Redis хранит компактно, одним блоком памяти (OBJECT ENCODING показывает listpack). Когда элементов больше порога, в Redis 7.4 это 512 полей для хеша, структура переходит в обычную хеш-таблицу. Хеш на 512 коротких полей занял 6 КБ, на 513 — уже 28 КБ. Отсюда практический приём: 100 тысяч объектов по 10 полей в хешах заняли 17 МБ, а те же данные в миллионе отдельных строковых ключей — 74 МБ
💾 Персистентность
Redis в памяти, но умеет сохранять данные на диск двумя способами. Их часто путают на собеседовании
RDB — снимок всех данных в файл dump.rdb по расписанию. Redis делает fork, и дочерний процесс пишет снимок, а родитель продолжает обслуживать клиентов. Память общая благодаря copy-on-write: копируются только страницы, которые меняются во время записи. Сам fork выполняется в главном потоке и копирует таблицу страниц: на 337 МБ данных он занял 2,7 мс, а на старых виртуалках Xen документация приводит 1,5 секунды для 6 ГБ. По умолчанию Redis пишет снимок через час, если было хотя бы одно изменение, через 5 минут при 100 изменениях и через минуту при 10 тысячах
AOF — журнал всех команд записи. При старте Redis проигрывает его и восстанавливает данные. Насколько часто журнал сбрасывается на диск, задаёт appendfsync:
appendfsync | Что теряется при падении | Цена |
|---|---|---|
always | ничего из подтверждённого | fsync на каждую пачку команд, медленно |
everysec (по умолчанию) | до секунды записей | почти так же быстро, как без журнала |
no | то, что ОС не успела сбросить, на Linux обычно до 30 секунд | быстрее всего |
Журнал растёт, поэтому Redis периодически переписывает его в фоне в минимальный набор команд: сто INCR одного ключа превращаются в один SET
Проверка, что это значит на практике: 500 записей, затем docker kill -s KILL, то есть kill -9 без корректной остановки, и рестарт:
RDB с настройками по умолчанию: DBSIZE до 500, после рестарта 0
AOF (appendonly yes, everysec): DBSIZE до 500, после рестарта 500Снимок не успел сработать, 500 изменений меньше порогов, и всё пропало. По умолчанию в Redis включён только RDB, AOF надо включать явно. Документация советует для сохранности уровня Postgres включать оба: AOF для свежих записей, RDB для бэкапов и быстрого рестарта. Чистому кэшу персистентность часто не нужна вовсе: он прогреется из базы
🧹 Когда кончается память
Лимит памяти задаёт maxmemory. На 64-битной системе по умолчанию он равен нулю, то есть лимита нет, и Redis растёт, пока его не убьёт OOM killer. Что делать при достижении лимита, решает maxmemory-policy:
| Политика | Что вытесняет |
|---|---|
noeviction (по умолчанию) | ничего, команды записи получают ошибку, чтение работает |
allkeys-lru | давно не читанные ключи среди всех |
allkeys-lfu | редко читаемые ключи среди всех |
allkeys-random | случайные ключи |
volatile-lru, volatile-lfu, volatile-random | то же, но только среди ключей с TTL |
volatile-ttl | ключи с самым коротким оставшимся TTL |
С лимитом 20 МБ и noeviction запись по одному ключу на 100 байт остановилась на 110 324-м ключе с ошибкой OOM command not allowed when used memory > 'maxmemory', а GET продолжал отвечать. После переключения на allkeys-lru ещё 100 тысяч записей прошли, число ключей осталось около 110 тысяч, а самые старые ключи исчезли
LRU в Redis приближённый: сервер не ведёт список всех ключей по времени доступа, а берёт случайную выборку (maxmemory-samples, по умолчанию 5) и вытесняет худший ключ из неё и из пула прошлых кандидатов. Так он экономит память, а точность на реальной нагрузке почти не страдает
Для кэша обычно ставят allkeys-lru или allkeys-lfu. volatile-* нужны, когда в одном Redis лежат и кэш с TTL, и данные без TTL, которые терять нельзя. Если ключей с TTL нет, volatile-* ведут себя как noeviction, и это частый сюрприз. Документация в таком случае советует развести кэш и данные по двум инстансам
🔁 Репликация, Sentinel и Cluster
Репликация в Redis асинхронная. Мастер отвечает клиенту «OK» и потом отправляет команду репликам. Если мастер упал между ответом и отправкой, а репликой назначили нового мастера, подтверждённая запись потеряна. Команда WAIT 1 100 ждёт, пока запись подтвердит хотя бы одна реплика, и снижает вероятность потери, но строгой согласованности не даёт: документация прямо говорит, что при сложных отказах подтверждённые записи всё равно могут пропасть. Реплики по умолчанию только читают, после короткого разрыва догоняют мастер по журналу изменений (PSYNC), а при долгом получают полный снимок
Sentinel решает задачу автоматического переключения для одного мастера с репликами. Несколько процессов Sentinel следят за мастером. Когда достаточно из них (quorum) считают его недоступным, большинство выбирает лидера, и он назначает реплику новым мастером. Адрес мастера клиент узнаёт у Sentinel, поэтому после переключения конфиг сервиса менять не нужно. Sentinel ставят минимум три, на разных машинах. При двух падение машины с одним из них оставляет второго без большинства, и переключения не будет
Cluster нужен, когда данные или нагрузка на запись не помещаются в один мастер. Пространство ключей разбито на 16 384 слота, слот ключа — CRC16 от имени по модулю 16384, каждый мастер владеет диапазоном слотов. Минимальный рабочий кластер — три мастера, рекомендуют шесть узлов, по реплике на мастер. Кластер из трёх мастеров в Docker:
$ redis-cli -p 7000 CLUSTER KEYSLOT user:42
(integer) 15880
$ redis-cli -p 7000 SET user:42 a
(error) MOVED 15880 127.0.0.1:7002
$ redis-cli -p 7000 MSET user:42 a user:43 b
(error) CROSSSLOT Keys in request don't hash to the same slot
$ redis-cli -c -p 7000 MSET {user:42}:cart x {user:42}:profile y
OKУзел сам запрос не пересылает: он отвечает MOVED с адресом владельца слота. Клиентская библиотека в кластерном режиме запоминает карту слотов и сразу ходит куда надо. Команды над несколькими ключами, транзакции и Lua-скрипты работают, только если все ключи в одном слоте. Для этого есть hash tag: если в имени есть {...}, хешируется только часть в скобках, и {user:42}:cart с {user:42}:profile гарантированно лежат вместе. Цена — горячий тег собирает всю нагрузку на один узел
Redis или Valkey
В марте 2024 Redis объявил, что с версии 7.4 уходит с открытой лицензии BSD на RSALv2 или SSPLv1, которые не входят в число открытых. В том же месяце Linux Foundation запустил форк Valkey от Redis 7.2.4 на BSD. С Redis 8 к лицензиям добавилась открытая AGPLv3. Для кода сервиса разницы почти нет: Valkey совместим с Redis 7.2 по протоколу и командам, и клиентские библиотеки работают с обоими
⚠️ Где ошибаются
Запускают KEYS в проде. На миллионах ключей это сотни миллисекунд, в течение которых сервер не отвечает никому, и у сервисов срабатывают таймауты. Для обхода ключей есть SCAN, для поиска медленных команд — SLOWLOG GET
Удаляют большие ключи через DEL. Множество на миллионы элементов освобождается в главном потоке. Для больших ключей берут UNLINK, а лучше не создают ключи на сотни мегабайт: такие ключи ещё и мешают разносить нагрузку по кластеру
Не ставят maxmemory. Redis съедает память машины, и его убивает ядро. Если на нём есть персистентность и реплика, maxmemory ставят с запасом: буферы репликации и AOF в лимит не входят
Ставят volatile-lru на кэш без TTL. Вытеснять нечего, политика ведёт себя как noeviction, и сервис получает ошибки записи вместо вытеснения
Считают подтверждённую запись сохранённой. Без AOF данные живут до следующего снимка, а асинхронная репликация теряет записи при переключении мастера. Деньги, заказы и всё, что нельзя потерять, пишут в базу, Redis держит копию или временное состояние
Выключают персистентность на мастере с автоперезапуском. Мастер падает, перезапускается пустым, и реплики послушно синхронизируются с пустым мастером. Документация описывает этот сценарий отдельно: либо персистентность на мастере, либо без автоматического рестарта
🎯 Вопросы с собеседований
Почему Redis быстрый, если он однопоточный?
Данные в памяти, а команды простые, поэтому одна команда выполняется за доли микросекунды. Один поток обслуживает тысячи соединений через мультиплексирование и не тратит время на блокировки и переключение контекста. Узкое место обычно сеть, поэтому команды отправляют пачками через pipelining. Сокеты могут читать и писать отдельные I/O-потоки, но команды по-прежнему выполняет один поток
Какие структуры данных есть в Redis и где ты их применял бы?
Строки для кэша и счётчиков, хеши для объектов с полями, списки для простой очереди, множества для уникальных значений, sorted set для рейтингов и окон по времени, streams для лога событий с группами потребителей. Ещё HyperLogLog для приблизительного подсчёта уникальных и битовые карты для флагов по id. Хорошо привести пример: таблица лидеров на ZINCRBY и ZREVRANK вместо сортировки в базе на каждый запрос
Чем RDB отличается от AOF?
RDB — периодический снимок всех данных через fork, компактный файл для бэкапа и быстрого рестарта, но при падении теряется всё после последнего снимка. AOF — журнал команд записи, при appendfsync everysec теряется до секунды. AOF больше по размеру и медленнее восстанавливается. Для важных данных включают оба, для чистого кэша часто ни один
Что будет, когда Redis упрётся в maxmemory?
Зависит от maxmemory-policy. По умолчанию noeviction: запись получает ошибку OOM, чтение работает. Для кэша ставят allkeys-lru или allkeys-lfu, и Redis вытесняет давно или редко читаемые ключи. Политики volatile-* трогают только ключи с TTL. LRU приближённый, по случайной выборке из 5 ключей
Почему нельзя вызывать KEYS в проде и чем его заменить?
KEYS обходит все ключи одной командой, а пока она выполняется, однопоточный сервер не отвечает остальным клиентам. На миллионах ключей это сотни миллисекунд простоя. SCAN возвращает ключи порциями по курсору, и между порциями сервер обслуживает других. Он может вернуть ключ дважды, поэтому код должен быть к этому готов
Может ли Redis потерять подтверждённую запись?
Да. Репликация асинхронная: мастер отвечает клиенту до отправки команды репликам, и при его падении новый мастер записи может не иметь. Без AOF запись теряется и при обычном рестарте до снимка. WAIT уменьшает вероятность потери, но строгой согласованности не даёт
Как работает Redis Cluster и что такое hash tag?
Ключи распределены по 16 384 слотам через CRC16 по модулю, каждый мастер владеет диапазоном слотов. Если запрос пришёл не на тот узел, он отвечает MOVED, и клиент идёт к владельцу слота. Команды над несколькими ключами работают только в пределах одного слота. Hash tag в фигурных скобках заставляет хешировать только часть имени, и связанные ключи пользователя оказываются на одном узле
Чем Sentinel отличается от Cluster?
Sentinel даёт автоматическое переключение для одного мастера с репликами: все данные на одном мастере, шардирования нет. Cluster делит данные между несколькими мастерами и сам переключает реплики при отказе. Sentinel проще и подходит, пока данные и запись помещаются в одну машину. Cluster нужен, когда не помещаются, и за это платят ограничениями на команды с несколькими ключами
📚 Что почитать
- Diagnosing latency issues — как устроен один поток, почему медленные команды и
forkтормозят всех, чемKEYSопасен в проде - Redis persistence — RDB и AOF, политики
fsync, что выбрать и как бэкапить - Key eviction — все политики вытеснения, как работает приближённый LRU и LFU, какие метрики смотреть
- Scale with Redis Cluster — слоты, hash tags и почему кластер теряет подтверждённые записи