К содержимому
Войти

Python Road Map

🟥 Redis

Redis — хранилище структур данных в памяти. Его ставят перед базой как кэш, но на нём же держат счётчики, рейтинги, очереди, сессии и лимиты запросов. На собеседовании про Redis спрашивают почти всегда, когда в резюме есть бэкенд: почему он быстрый при одном потоке, какую структуру взять под задачу, что он теряет при падении и что делает, когда кончилась память. Все цифры ниже сняты на ноутбуке: Redis 7.4 в Docker, команды через redis-cli

🧠 Один поток и почему это быстро

Все данные лежат в оперативной памяти, а команды выполняет один главный поток. Он через мультиплексирование (epoll на Linux) слушает тысячи соединений и по очереди берёт из них готовые команды. Пока выполняется одна команда, остальные ждут. Типичная команда вроде GET или INCR занимает доли микросекунды, поэтому очередь не успевает вырасти, а время ответа определяет сеть

Из однопоточности следуют два вывода, которые спрашивают чаще всего. Первый: каждая команда атомарна. INCR от тысячи клиентов одновременно даст ровно тысячу, без блокировок и гонок. Второй: одна медленная команда останавливает всех. Пример на 2 млн ключей:

Что происходитОтвет на GET от другого клиента
Сервер свободен0,39 мс
В это время кто-то выполняет KEYS *356–513 мс
В это время кто-то выполняет SCAN 0 COUNT 10000,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 хранит не только строки. Правильная структура часто заменяет кусок кода в сервисе и запрос к базе:

ТипГлавные командыДля чего берут
StringGET, SET, INCR, SET ... NX EXкэш объекта, счётчики, флаги, простая блокировка
HashHSET, HGET, HINCRBYобъект с полями: профиль, корзина, сессия. Поле меняется без перезаписи всего объекта
ListLPUSH, RPOP, BRPOP, LRANGEпростая очередь задач, последние N событий
SetSADD, SISMEMBER, SINTERуникальные значения: кто онлайн, теги, общие друзья
Sorted setZADD, ZINCRBY, ZREVRANGE, ZRANGEBYSCOREрейтинги, очереди с приоритетом, окно по времени
StreamXADD, XREADGROUP, XACKлог событий с группами потребителей, лёгкая замена брокера
HyperLogLogPFADD, PFCOUNTприблизительный подсчёт уникальных: посетители за день
BitmapSETBIT, 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 и почему кластер теряет подтверждённые записи