Начало работы
Подключение к серверу Redis
redis-cli — стандартный клиент командной строки. По умолчанию подключается к 127.0.0.1:6379. Используйте -h для хоста, -p для порта, -a для пароля (или задайте переменную окружения REDISCLI_AUTH, чтобы не светить секреты в истории shell). Для TLS нужны --tls и сертификаты/ключи. Схема URL redis:// поддерживается в Redis 6+, rediss:// — для TLS.
# connect to local server (default port 6379)
redis-cli
# connect to a remote host with custom port
redis-cli -h redis.example.com -p 6380
# connect with authentication
redis-cli -a "yourpassword"
redis-cli -h host -p 6379 -a "yourpassword"
# connect over TLS
redis-cli --tls --cert client.crt --key client.key -h host -p 6379
# connect using a URL (Redis 6+)
redis-cli redis://user:password@host:6379/0
redis-cli rediss://user:password@host:6379/0 # TLSОпции подключения и режимы
redis-cli поддерживает интерактивный и одноразовый режимы. Если передать команду аргументами, она выполнится и клиент завершится. Режим pipe читает команды RESP или текст из stdin — отлично для скриптов и массовой загрузки. -n выбирает логическую базу. --stat и --latency — встроенные помощники мониторинга. --raw выводит значения без префиксов типов, удобно для конвейеров.
# select a specific database index (0-15)
redis-cli -n 1 # use database 1
# run a single command and exit (non-interactive)
redis-cli GET mykey
redis-cli -h host PING
# pass command with arguments
redis-cli SET counter 100
redis-cli INCR counter
# read commands from stdin (pipe mode)
echo "SET k1 v1" | redis-cli
cat commands.txt | redis-cli
# repeat a command every second (watch mode)
redis-cli --stat
redis-cli --latency
# pretty-print JSON output (Redis 6+)
redis-cli --raw GET user:jsonPING и проверка соединения
PING — простейшая проверка работоспособности: живой Redis отвечает PONG. --latency непрерывно измеряет round-trip (полезно для диагностики сетевых проблем). --latency-dist показывает гистограмму. --latency-history ведёт скользящую статистику. Используйте это, чтобы зафиксировать базовое качество соединения перед настройкой производительности.
# basic connectivity test
redis-cli ping
# PONG
# ping with a message (echoed back)
redis-cli PING "hello"
# "hello"
# test auth + connection in one shot
redis-cli -a password PING
# check round-trip latency (continuous)
redis-cli --latency
# output: min: 0, max: 1, avg: 0.27 (3421 samples)
# latency histogram
redis-cli --latency-dist
# latency history (rolling, every 15s by default)
redis-cli --latency-history -i 1Советы по интерактивному режиму
Интерактивный режим — это REPL для команд Redis. HELP <command> или HELP @<group> показывает встроенную документацию (интернет не нужен). CONNECT переключает серверы в рамках сессии. CLEAR очищает экран. CLI автоматически распознаёт многострочный ввод для строк в кавычках. Префикс ':' запускает специфичные для CLI команды (например, :raw) вместо команд Redis.
# start interactive mode
redis-cli
# inside the CLI:
127.0.0.1:6379> HELP SET # command help
127.0.0.1:6379> HELP @string # help for a command group
127.0.0.1:6379> SCAN 0 # any Redis command
# clear the screen
127.0.0.1:6379> CLEAR
# connect to a different server without restarting
127.0.0.1:6379> CONNECT host 6380
# exit
127.0.0.1:6379> EXIT
127.0.0.1:6379> QUIT
# multi-line input: end with a backslash
127.0.0.1:6379> SET mykey "this is \
a multi-line value"
# toggle raw output mode
127.0.0.1:6379> :rawВыбор базы и основы
Базы Redis — логические пространства имён (0–15), делящие одну память, а не изолированные схемы. Большинство приложений используют только db 0. FLUSHDB очищает текущую базу; FLUSHALL очищает всё (осторожно!). От нескольких баз лучше отказаться в пользу отдельных инстансов или префиксов ключей, так как они делят один поток.
# Redis has 16 logical databases (0-15) by default
SELECT 0 # switch to database 0
SELECT 15 # switch to database 15
# move a key to another database
MOVE mykey 1
# flush the current database (DESTRUCTIVE)
FLUSHDB
# flush ALL databases (VERY DESTRUCTIVE)
FLUSHALL
# get the number of keys in the current db
DBSIZE
# swap two databases (Redis 4.0+)
SWAPDB 0 1Справка и поиск команд
COMMAND исследует таблицу команд сервера — полезно для изучения возможностей и арности. COMMAND DOCS (7.0+) возвращает структурированную документацию. Команда HELP в CLI показывает офлайн-документацию по категориям (@string, @hash, @server и т. д.). Запустите 'redis-cli --help', чтобы увидеть все флаги и опции CLI.
# list all commands (huge output)
COMMAND
# get details of a specific command
COMMAND INFO GET
COMMAND INFO SET HSET LPUSH
# structured documentation (Redis 7+)
COMMAND DOCS SET
COMMAND DOCS @string
# count available commands
COMMAND COUNT
# CLI help
redis-cli --help
redis-cli --version
# inside interactive mode
HELP
HELP @server
HELP @string
HELP @hash
HELP GETSETСтроки
Базовые SET и GET
SET/GET — фундаментальные операции со строками. NX = установить, если не существует (используется для блокировок); XX = установить, если существует. EX/PX/EXAT/PXAT задают срок жизни атомарно (нет гонки между SET и EXPIRE). GETSET возвращает предыдущее значение, устанавливая новое. Строки бинарно-безопасны до 512 МБ.
# set and get a key
SET mykey "Hello"
GET mykey # "Hello"
# set only if not exists (NX) or only if exists (XX)
SET mykey "new" NX # set only if key does NOT exist
SET mykey "new" XX # set only if key DOES exist
# set with expiration (seconds / milliseconds)
SET token "abc" EX 3600 # expires in 3600s
SET token "abc" PX 60000 # expires in 60000ms
# set with expiration at a Unix timestamp
SET token "abc" EXAT 1700000000
# get and set atomically (returns old value)
GETSET counter 0 # returns old value, sets new
# delete a key
DEL mykeyЧисловые счётчики (INCR/DECR)
INCR/DECR атомарны — безопасны при конкурентном доступе без блокировок. Поэтому Redis идеален для счётчиков, rate limiting (INCR + EXPIRE) и генерации последовательных ID. INCRBYFLOAT поддерживает дроби, но использует double (следите за округлением). Если значение не целое, INCR вернёт ошибку.
# increment a numeric string atomically
SET counter 100
INCR counter # 101
INCRBY counter 10 # 111
# decrement
DECR counter # 110
DECRBY counter 5 # 105
# floating point increment
SET price "10.50"
INCRBYFLOAT price 0.25 # "10.75"
INCRBYFLOAT price -1.00 # "9.75"
# all increment ops are atomic and concurrency-safe
# use for: counters, rate limiting, sequence IDs, stats
# INCR on a non-integer value returns an error
SET mystr "hello"
INCR mystr # ERROR: value is not an integerAPPEND и операции со строками
APPEND удлиняет строку (создаёт её, если нет). STRLEN сообщает длину. GETRANGE/SETRANGE работают с подстроками (бинарно-безопасно). GETDEL (6.2+) атомарно возвращает и удаляет — удобно для одноразового чтения. GETEX атомарно возвращает значение и задаёт TTL — удобно для продления срока сессии при чтении.
# append to a string value
SET msg "Hello"
APPEND msg " World" # "Hello World"
# get string length
STRLEN msg # 11
# get substring
GETRANGE msg 0 4 # "Hello"
GETRANGE msg 6 -1 # "World"
# overwrite a substring (grows if needed)
SETRANGE msg 6 "Redis" # "Hello Redis"
# get and delete atomically
GETDEL mykey # returns value AND deletes key
# get and set expiration atomically (6.2+)
GETEX mykey EX 3600 # returns value, sets TTL
# append only if key exists
APPEND existing_key "more"MSET и MGET (батчи)
MSET/MGET объединяют операции в один round-trip — критично для производительности (Redis однопоточный, поэтому накладные расходы на команду заметны). MSETNX атомарна: либо все ключи установлены, либо ни один. Для множества небольших пар ключ-значение рассмотрите группировку в хеш (HSET) ради экономии памяти за счёт кодировки listpack.
# set multiple keys at once (atomic)
MSET k1 "v1" k2 "v2" k3 "v3"
# get multiple keys at once
MGET k1 k2 k3 # 1) "v1" 2) "v2" 3) "v3"
# set multiple only if ALL keys are new
MSETNX k1 "v1" k4 "v4" # 1 if all set, 0 if any existed
# MSET/MGET reduce round-trips — much faster than
# separate SET/GET calls in a loop
# get the length of a string value
STRLEN k1 # 2
# set multiple fields of different keys is not possible;
# for per-field updates use hashes (HSET)
# pipeline alternative in CLI:
printf '%s\n' "SET k1 v1" "SET k2 v2" "GET k1" | redis-cli --pipe-modeБитмапы (на строках)
Битмапы хранят булевы флаги для 4 миллиардов пользователей примерно в 512 МБ — крайне экономно. BITOP AND/OR/XOR/NOT комбинируют битмапы (например, пользователи, активные в несколько дней). BITCOUNT считает активных пользователей. BITFIELD упаковывает несколько небольших счётчиков в одну строку. Позиция = ID пользователя. Сценарии: daily active users, фича-флаги.
# bitmaps are strings operated on at the bit level
# great for boolean flags on a large user base
# set bit at position (0 or 1)
SETBIT user:1:active 7 1 # user 1 active
GETBIT user:1:active 7 # 1
# count set bits
BITCOUNT user:1:active # total bits set to 1
# bitwise operations between strings
SETBIT users:d1 5 1
SETBIT users:d2 5 1
BITOP AND active-both users:d1 users:d2
BITCOUNT active-both # users active on both days
BITOP OR active-either users:d1 users:d2
BITOP XOR diff users:d1 users:d2
# find the first set bit
BITPOS user:1:active 1 # position of first 1-bit
# bitfield: multiple counters in one string
BITFIELD mycnt SET u8 0 100
BITFIELD mycnt INCRBY u8 0 10Срок жизни строк и TTL
TTL возвращает -2 для несуществующих ключей и -1 для ключей без срока жизни. SET с EX атомарен (нет гонки между SET и EXPIRE). KEEPTTL (6.0+) позволяет обновить значение, сохранив TTL, — удобно для обновления кэшированных значений без сброса окна истечения. Истечение ленивое (проверяется при обращении) плюс периодические фоновые обходы.
# set a key with expiration in one atomic command
SET session "data" EX 3600 # 1 hour
SET cache "value" PX 60000 # 60 seconds (ms)
# set expiration on an existing key
EXPIRE mykey 60 # 60 seconds
PEXPIRE mykey 60000 # 60 seconds (ms)
EXPIREAT mykey 1700000000 # Unix timestamp
# view remaining time to live
TTL mykey # seconds (-1 = no expiry, -2 = no key)
PTTL mykey # milliseconds
# remove expiration (make key persistent)
PERSIST mykey
# TTL with KEEPTTL option (6.0+): set value, keep existing TTL
SET mykey "newval" KEEPTTLСписки
Операции push и pop
Списки двусторонние: LPUSH+RPOP = очередь (FIFO), LPUSH+LPOP = стек (LIFO). BLPOP/BRPOP блокируются до появления элемента — это основа очередей на Redis (без опроса). Всегда задавайте таймаут для BLPOP, чтобы обрабатывать обрыв ы соединения. Для головы и хвоста списки дают O(1), а доступ к середине — O(N).
# lists are ordered sequences of strings (linked lists)
LPUSH mylist "a" "b" # list: [b, a]
RPUSH mylist "c" # list: [b, a, c]
# pop from head or tail
LPOP mylist # "b" (removes from head)
RPOP mylist # "c" (removes from tail)
# pop multiple (6.2+)
LPOP mylist 2 # pop 2 from head
# get length
LLEN mylist # 0
# blocking pop (waits if empty, up to timeout)
BLPOP queue:tasks 30 # blocks up to 30 seconds
BRPOP queue:tasks 0 # blocks forever
# push only if the list exists (don't create new key)
LPUSHX mylist "x" # 0 if key doesn't existLRANGE и индексация
LRANGE 0 -1 возвращает весь список. LINDEX для середины работает за O(N) — списки оптимизированы под доступ с краёв. LSET изменяет по индексу. LINSERT работает за O(N) (используйте умеренно на больших списках). LPOS находит позиции элемента, не удаляя его. Для частого случайного доступа по индексу список — неподходящий выбор: рассмотрите sorted set.
# get a range of elements (0-based, negative from end)
LRANGE mylist 0 -1 # all elements
LRANGE mylist 0 2 # first 3 elements
LRANGE mylist -3 -1 # last 3 elements
# get element by index (O(N) traversal)
LINDEX mylist 0 # first element
LINDEX mylist -1 # last element
# set an element by index
LSET mylist 1 "newval"
# get length
LLEN mylist
# insert before or after a pivot element
LINSERT mylist BEFORE "pivot" "new"
LINSERT mylist AFTER "pivot" "new"
# find the position of an element (6.0+)
LPOS mylist "value"
LPOS mylist "value" RANK 2 # find 2nd occurrenceБлокирующие pop и очереди
BRPOPLPUSH/BLMOVE атомарно перемещают элемент из источника в приёмник — потребитель может обрабатывать его безопасно, и если он упадёт, элемент останется в приёмнике (паттерн надёжной очереди). Это лучше BRPOP + обработка, потому что падение после BRPOP теряет элемент. После обработки удалите элемент из списка-приёмн ика.
# simple FIFO queue: LPUSH to add, RPOP to consume
LPUSH tasks "job1" "job2"
RPOP tasks # "job1" (FIFO order)
# reliable queue with BRPOP (blocking, waits for work)
BRPOP tasks 0 # blocks until a task is available
# move items between lists atomically
RPOPLPUSH source destination # move one item
# blocking move (reliable queue pattern)
BRPOPLPUSH source destination 30 # blocks up to 30s
# Redis 6.2+: BLMOVE replaces BRPOPLPUSH
BLMOVE source destination RIGHT LEFT 30
# capped queue (e.g., recent events)
LPUSH recent "event"
LTRIM recent 0 99 # keep latest 100LREM, LSET и LTRIM
LTRIM — частый приём для ограничения размера списка (например, хранить только последние 100 событий). LREM удаляет по значению (count: положительный — с головы, отрицательный — с хвоста, 0 — все). LMPOP (7.0+) извлекает из нескольких списков за один вызов — удобно для приоритетных очередей. При частых операциях в середине списка список — неподходящий выбор.
# trim to a range (removes everything outside)
LTRIM mylist 0 99 # keep only first 100 elements
LTRIM mylist -50 -1 # keep only last 50
# remove elements by value
LREM mylist 2 "value" # remove first 2 occurrences of "value"
LREM mylist -2 "value" # remove last 2 occurrences
LREM mylist 0 "value" # remove ALL occurrences
# pop and push in one atomic operation
RPOPLPUSH source dest
# pop from multiple lists (7.0+)
LMPOP 2 mylist1 mylist2 LEFT COUNT 3
# blocking pop from multiple lists (7.0+)
BLMPOP 30 2 mylist1 mylist2 LEFT COUNT 3
# remove a key only if it's a list (type-safe)
DEL mylist # works on any typeСценарии использования списков
Списки лучше всего подходят для последовательностей с доступом с краёв: очереди, стеки, ленты, буферы. LTRIM делает их идеальными для ограниченных журналов и лент. Для rate limiting простым скользящим окном служит список временных меток + LTRIM. Для сортированных и приоритетных очередей используйте sorted set. Списки не поддерживают дедупликацию — для этого нужен set.
# 1. Task queue (FIFO)
LPUSH tasks "process_order:123"
BRPOP tasks 30
# 2. Recent activity feed (capped)
LPUSH user:1:feed "post:99" "post:98"
LTRIM user:1:feed 0 49 # latest 50
# 3. Stack (LIFO)
LPUSH stack "item"
LPOP stack
# 4. Circular buffer (limited size)
LPUSH buffer "new"
LTRIM buffer 0 999 # keep 1000 items
# 5. Rate limiter (sliding window)
LPUSH rate:user:1 1700000000
LTRIM rate:user:1 0 99
LLEN rate:user:1 # request count in window
# 6. Chat history (capped)
LPUSH chat:room:1 "alice: hello"
LTRIM chat:room:1 0 999 # keep last 1000 messagesМножества
SADD, SMEMBERS и SISMEMBER
Множества хранят уникальные значения — идеальны для тегов, категорий и дедупликации. SISMEMBER работает за O(1) — намного быстрее проверки по списку. SMEMBERS может блокировать на больших множествах; для перебора используйте SSCAN. SMISMEMBER (7.4+) пакетно проверяет принадлежность, сокращая round-trip'ы. Если все элементы — целые числа, используется intset (отсортированный массив), что очень экономит память.
# sets: unordered collection of unique strings
SADD tags "redis" "db" "cache"
SADD tags "redis" # ignored (already exists)
# check membership (O(1))
SISMEMBER tags "redis" # 1 if member, 0 if not
# get all members (avoid on large sets)
SMEMBERS tags # 1) "redis" 2) "db" 3) "cache"
# get the number of members
SCARD tags # 3
# remove a member
SREM tags "cache" # 1
# check multiple memberships at once (7.4+)
SMISMEMBER tags "redis" "db" "missing"
# 1) 1 2) 1 3) 0Операции над множествами (union/inter/diff)
Операции над множествами — суперсила Redis: объединение, пересечение и разность за O(N) без обработки на клиенте. Сценарии: общие друзья (SINTER), уникальные посетители (SUNION), фильтрация по тегам (SINTER множеств тегов). SINTERCARD (7.0+) возвращает только количество — быстрее, когда сами элементы не нужны. Сохраняйте результаты, чтобы не пересчитывать.
# set union, intersection, difference
SADD set1 "a" "b" "c"
SADD set2 "b" "c" "d"
# union (all unique members from all sets)
SUNION set1 set2 # a, b, c, d
# intersection (members in ALL sets)
SINTER set1 set2 # b, c
# difference (members in set1 but NOT in set2)
SDIFF set1 set2 # a
# store the result in a new set
SUNIONSTORE result set1 set2
SINTERSTORE result set1 set2
SDIFFSTORE result set1 set2
# count intersection without returning members (7.0+)
SINTERCARD 2 set1 set2 LIMIT 0
# operations on multiple sets at once
SUNION s1 s2 s3 s4SREM, SMOVE и SPOP
SMOVE атомарна — удобна для смены состояний (например, перевод пользователя из множества 'pending' в 'active'). SPOP удаляет случайные элементы (полезно для лотерей и шардирования). SRANDMEMBER не удаляет. BSPOP (7.0+) блокируется как BLPOP, но для множеств — полезно в событийных паттернах, где порядок не важен. SREM возвращает число фактически удалённых элементов.
# remove one or more members
SADD myset "a" "b" "c" "d"
SREM myset "a" "b" # 2 (number removed)
# move a member from one set to another atomically
SMOVE source dest "member"
# pop a random member (removes it)
SPOP myset # removes and returns one
SPOP myset 3 # removes and returns 3 (6.2+)
# get a random member (does NOT remove)
SRANDMEMBER myset # one random member
SRANDMEMBER myset 3 # 3 random (may repeat)
SRANDMEMBER myset -3 # 3 unique random
# blocking set pop (7.0+) - waits until a member exists
BSPOP myset 30 # blocks up to 30 seconds
# delete the entire set
DEL mysetПеребор через SSCAN
SSCAN — безопасный способ перебрать большое множество: SMEMBERS блокирует сервер на огромных множествах. SSCAN работает по курсору: вызывайте повторно, пока курсор не вернётся к 0. COUNT — это подсказка (может вернуть больше или меньше). SSCAN даёт слабые гарантии: возможны дубликаты или пропуск добавленных элементов, но она никогда не блокирует. Всегда обрабатывайте цикл по курсору в своём коде.
# SSCAN: cursor-based iteration for large sets
SSCAN myset 0 MATCH "pre*" COUNT 100
# returns: [nextCursor, [member1, member2, ...]]
# continue until cursor returns to 0
SSCAN myset <nextCursor> MATCH "pre*" COUNT 100
# iterate all members safely
cursor=0
while true:
cursor, members = SSCAN myset cursor COUNT 100
process(members)
if cursor == 0: break
# scan with type filtering (7.0+ for SCAN, sets always same type)
# COUNT is a hint, not exact (may return more or fewer)
# MATCH pattern supports glob: *, ?, [abc]
SSCAN myset 0 MATCH "user:*" COUNT 1000
# for small sets, SMEMBERS is fine
# for large sets (>10k), always use SSCANСценарии использования множеств
Множества — основной инструмент для уникальности и связей. Паттерн SINTER для взаимных подписчиков и друзей — классика. Для «посетителей за день» с огромной кардинальностью рассмотрите HyperLogLog (приблизительно, но фиксированные 12 КБ). Для упорядоченных уникальных данных (рейтинги) используйте sorted set. Множества неупорядочены — если порядок важен, берите список или sorted set.
# 1. Tags / categories
SADD post:1:tags "redis" "db"
SADD post:2:tags "redis" "cache"
SINTER post:1:tags post:2:tags # posts sharing "redis"
# 2. Unique visitors per day
SADD visitors:2025-01-01 "user:1" "user:2"
SCARD visitors:2025-01-01 # visitor count
# 3. Followers / following (mutual friends)
SADD user:1:following "user:2" "user:3"
SADD user:2:following "user:1" "user:3"
SINTER user:1:following user:2:following # mutual follows
# 4. Blacklist / whitelist
SADD blacklist "ip:1.2.3.4"
SISMEMBER blacklist "ip:1.2.3.4" # 1 = blocked
# 5. Lottery / random selection
SADD participants "u1" "u2" "u3" "u4"
SPOP participants 1 # draw a winnerСортированные множества
ZADD, ZSCORE и ZRANK
Сортированные множества (zsets) — самая мощная структура Redis: уникальные элементы, упорядоченные по score, с операциями за O(log N). Опции ZADD (NX/XX/GT/LT) дают условные обновления: GT обновляет, только если новый score больше (отлично для отслеживания лучшего результата). Score — это double; элементы уникальны. При равенстве score порядок лексикографический.
# sorted set: unique members ordered by a float score
ZADD leaderboard 100 "alice" 200 "bob" 150 "carol"
# update a score (re-add with new score)
ZADD leaderboard 250 "alice" # alice's score becomes 250
# add with options (NX: only new, XX: only existing, GT/LT)
ZADD leaderboard NX 300 "new" # only if new
ZADD leaderboard GT 300 "alice" # only if new score > current
ZADD leaderboard LT 50 "alice" # only if new score < current
# get a member's score
ZSCORE leaderboard "alice" # "250"
# get a member's rank (0-based, ascending)
ZRANK leaderboard "alice" # rank from lowest
ZREVRANK leaderboard "alice" # rank from highest (0 = top)
# get the number of members
ZCARD leaderboard # 3
# get multiple scores at once (6.2+)
ZMSCORE leaderboard "alice" "bob" # ["250", "200"]ZRANGE и ZREVRANGE
ZRANGE возвращает по рангу (индексу); с BYSCORE — по диапазону score. В Redis 6.2 ZRANGEBYSCORE/ZREVRANGE объединены в ZRANGE с опциями BYSCORE/BYLEX/REV. WITHSCORES включает score в вывод. Для рейтингов ZRANGE 0 9 REV даёт топ-10. ZRANGESTORE (6.2+) сохраняет результат в новый ключ для дальнейшей обработки.
# get members by index range (ascending)
ZRANGE leaderboard 0 -1 # all, ascending
ZRANGE leaderboard 0 2 # first 3 (lowest scores)
ZRANGE leaderboard -3 -1 # last 3 (highest scores)
# descending order
ZREVRANGE leaderboard 0 2 # top 3 (highest scores)
# with scores
ZRANGE leaderboard 0 -1 WITHSCORES
# Redis 6.2+: unified ZRANGE with BYSCORE/REV options
ZRANGE leaderboard 100 200 BYSCORE
ZRANGE leaderboard 200 100 BYSCORE REV
# store a range in a new key (6.2+)
ZRANGESTORE top3 leaderboard 0 2 REV
# get by rank with scores
ZRANGE leaderboard 0 9 REV WITHSCORES # top 10
# limit results (pagination)
ZRANGE leaderboard 0 -1 BYSCORE LIMIT 0 10ZRANGEBYSCORE и ZCOUNT
ZRANGEBYSCORE возвращает по диапазону score; префикс '(' делает score эксклюзивным. ZCOUNT даёт количество в диапазоне, не выбирая элементы. ZINCRBY атомарно меняет score и пересортировывает — идеально для живых рейтингов. ZREMRANGEBYRANK хорош для ограничения размера zset (например, хранить только топ-1000).
# get members by score range
ZRANGEBYSCORE leaderboard 100 200 # scores 100-200
ZRANGEBYSCORE leaderboard 100 +inf # scores >= 100
ZRANGEBYSCORE leaderboard -inf 200 # scores <= 200
ZRANGEBYSCORE leaderboard (100 200 # scores > 100 (exclusive)
# with pagination
ZRANGEBYSCORE leaderboard 100 200 LIMIT 0 10
# count members in a score range
ZCOUNT leaderboard 100 200
# increment a member's score atomically
ZINCRBY leaderboard 50 "alice" # alice += 50
# remove a member
ZREM leaderboard "bob"
# remove by rank range
ZREMRANGEBYRANK leaderboard 0 9 # remove lowest 10
ZREMRANGEBYSCORE leaderboard 0 100 # remove scores <= 100ZUNIONSTORE и ZINTERSTORE
ZUNIONSTORE/ZINTERSTORE объединяют zsets с настраиваемой агрегацией (SUM/MIN/MAX) и весами — мощно для взвешенного скоринга (например, релевантность = text_match*2 + recency*1). В Redis 6.2 добавлены ZUNION/ZINTER/ZDIFF, возвращающие результат без сохранения (на одну команду меньше). Это O(N*M) — будьте осторожны с большими множествами. Число множеств указывается перед их именами.
# combine multiple sorted sets
ZADD set1 1 "a" 2 "b"
ZADD set2 2 "a" 3 "c"
# union: sum scores by default (a = 1+2 = 3)
ZUNIONSTORE result 2 set1 set2
ZRANGE result 0 -1 WITHSCORES # a=3, b=2, c=3
# specify aggregation: SUM (default), MIN, MAX
ZUNIONSTORE result 2 set1 set2 AGGREGATE MAX # a=2, b=2, c=3
# apply weights to each set's scores
ZUNIONSTORE result 2 set1 set2 WEIGHTS 2 1 # set1 scores * 2
# intersection (only members in ALL sets)
ZINTERSTORE result 2 set1 set2 # only "a"
# Redis 6.2+: return without storing
ZUNION 2 set1 set2 WITHSCORES
ZINTER 2 set1 set2 WITHSCORES
ZDIFF 2 set1 set2 WITHSCORES
# count intersection (7.0+)
ZINTERCARD 2 set1 set2 LIMIT 0Лексикографические диапазоны (BYLEX)
BYLEX позволяет делать запросы по диапазону элементов при равных score — превращая sorted set в автоматически сортируемый строковый индекс. Сценарии: автодополнение (слова со score 0, запрос по префиксу), сортированные словари. '[a' означает включительно, '(a' — исключительно, '-' — начало, '+' — конец. Осмысленно работает только когда все score одинаковы.
# when all scores are equal, sorted sets act as a sorted string set
ZADD myset 0 "apple" 0 "banana" 0 "cherry" 0 "date"
# range by lexicographical order
ZRANGEBYLEX myset "[a" "[c" # apple, banana, cherry
ZRANGEBYLEX myset "(a" "[c" # banana, cherry (a exclusive)
ZRANGEBYLEX myset "-" "[b" # from start to banana
ZRANGEBYLEX myset "[c" "+" # cherry to end
# count in a lex range
ZLEXCOUNT myset "[a" "[c" # 3
# remove by lex range
ZREMRANGEBYLEX myset "[a" "[b"
# Redis 6.2+: use ZRANGE with BYLEX
ZRANGE myset "[a" "[c" BYLEX
# limit results (pagination)
ZRANGEBYLEX myset "[a" "[c" LIMIT 0 10Паттерн рейтинга
Sorted sets делают рейтинги тривиальными: ZADD обновляет счёт, ZREVRANGE даёт топ-N, ZREVRANK — позицию игрока. ZINCRBY атомарно меняет счёт. Для рейтингов по периодам (день/неделя) используйте отдельный ключ на период с TTL. Пагинация — ZREVRANGE со смещением. Это один из самых естественных и мощных сценариев Redis.
# build a leaderboard
ZADD leaderboard 100 "alice" 250 "bob" 150 "carol"
# top 10 players (highest scores)
ZREVRANGE leaderboard 0 9 WITHSCORES
# a player's rank (0 = top)
ZREVRANK leaderboard "alice"
# update a score (atomic)
ZINCRBY leaderboard 50 "alice"
# players within a score range (e.g., silver tier 100-199)
ZRANGEBYSCORE leaderboard 100 199
# percentile rank
total = ZCARD(leaderboard)
rank = ZREVRANK(leaderboard "alice")
# percentile = (total - rank) / total * 100
# pagination (page 3, 10 per page)
ZREVRANGE leaderboard 20 29 WITHSCORES
# time-bucketed leaderboards (weekly)
ZADD leaderboard:2025-W01 100 "alice"
EXPIRE leaderboard:2025-W01 604800 # 1 week TTLХеши
HSET, HGET и HGETALL
Хеши идеальны для хранения объектов: один ключ на объект, поля на свойства. Это лучше сериализации JSON, потому что можно атомарно обновлять отдельные поля (HSET) без чтения-изменения-записи. HGETALL возвращает все поля; для больших хешей предпочитайте HSCAN. Небольшие хеши используют кодировку listpack (примерно до 128 полей), что экономит память.
# a hash maps fields to values (like a small object)
HSET user:1 name "Alice" age 30 email "[email protected]"
# get a single field
HGET user:1 name # "Alice"
# get all fields and values
HGETALL user:1
# 1) "name" -> "Alice"
# 2) "age" -> "30"
# 3) "email" -> "[email protected]"
# get the number of fields
HLEN user:1 # 3
# get the string length of a field's value
HSTRLEN user:1 name # 5 (length of "Alice")
# set a field only if it doesn't exist
HSETNX user:1 status "new" # 1 if set, 0 if existed
# delete a field
HDEL user:1 email # removes the email fieldHMGET (получение нескольких полей)
HMGET пакетно получает несколько полей за один round-trip — намного быстрее отдельных вызовов HGET. HSET (с 4.0) принимает несколько пар поле-значение, поэтому HMSET устарел. HKEYS/HVALS возвращают все имена полей и значения. HRANDFIELD (6.2+) удобна для сэмплирования (например, случайные фича-флаги). HGETALL блокирует на больших хешах — для продакшена используйте HSCAN.
# get multiple fields at once
HMGET user:1 name age # 1) "Alice" 2) "30"
HMGET user:1 name missing age # 1) "Alice" 2) nil 3) "30"
# set multiple fields (HSET supports multiple field-value pairs)
HSET user:1 name "Bob" age 25 email "[email protected]"
# HMSET is deprecated (use HSET with multiple fields)
# HMSET still works but returns OK instead of count
# get all field names
HKEYS user:1 # 1) "name" 2) "age" 3) "email"
# get all values
HVALS user:1 # 1) "Alice" 2) "30" 3) "[email protected]"
# check if a field exists
HEXISTS user:1 name # 1 if exists, 0 if not
# get a random field (6.2+)
HRANDFIELD user:1 # one random field name
HRANDFIELD user:1 3 WITHVALUES # 3 random fields + valuesHINCRBY (числовые поля)
HINCRBY по полям хеша атомарен — идеален для счётчиков по пользователям (число входов, просмотров, количество товаров в корзине). HINCRBYFLOAT поддерживает дроби. Хеш автоматически удаляется, когда удалено последнее поле (HDEL). Поэтому хеши — идеальная структура для объектов с числовыми счётчиками: куда эффективнее отдельных строковых ключей на каждый счётчик.
# increment a numeric field atomically
HSET user:1:stats logins 0
HINCRBY user:1:stats logins 1 # logins = 1
HINCRBY user:1:stats logins 1 # logins = 2
HINCRBY user:1:stats logins -1 # logins = 1
# increment by a specific amount
HINCRBY user:1:stats page_views 10
# floating point increment
HINCRBYFLOAT user:1:stats score 0.5
# all HINCRBY operations are atomic
# perfect for per-user/per-object counters
# use case: shopping cart (product_id -> quantity)
HSET cart:user:1 product:100 2
HINCRBY cart:user:1 product:100 1 # now 3
HINCRBY cart:user:1 product:100 -1 # now 2
HDEL cart:user:1 product:100 # remove itemHSCAN (перебор хеша)
HGETALL блокирует сервер на больших хешах — для продакшена используйте HSCAN. HSCAN работает по курсору: вызывайте повторно, пока курсор не вернётся к 0. COUNT — это подсказка. Результат приходит плоским массивом [поле, значение, поле, значение, ...] — сопоставляйте пары в коде. Для хешей с миллионами полей рассмотрите шардирование на несколько ключей.
# HSCAN: cursor-based iteration (for large hashes)
HSCAN user:1 0 MATCH "na*" COUNT 10
# returns [cursor, [field, value, field, value, ...]]
# iterate all fields safely
cursor=0
while true:
cursor, fields = HSCAN user:1 cursor COUNT 100
process(fields)
if cursor == 0: break
# HGETALL is fine for small hashes (< 100 fields)
# HSCAN is required for large hashes to avoid blocking
# match field names with glob patterns
HSCAN user:1 0 MATCH "user:*" COUNT 1000
# no VALUES-only option; results are [field, value, field, value, ...]
# pair them up in your code
# COUNT is a hint — may return more or fewer than requested
# HSCAN never blocks; safe for production useСценарии использования хешей
Хеши особенно хороши для объектов и сгруппированных счётчиков. Мощный приём экономии памяти: когда у вас много мелких строковых ключей, сгруппируйте их в один хеш — кодировка listpack требует куда меньше накладных расходов, чем тысячи отдельных ключей (у каждого свои метаданные). Такое «объединение в корзины» может сократить память в 5–10 раз для небольших значений. TTL на уровне поля (7.4+) — важное дополнение.
# 1. Store an object (user profile, config)
HSET config:app name "MyApp" version "2.0" debug "off"
# 2. Per-user counters
HINCRBY user:1:stats logins 1
HINCRBY user:1:stats page_views 1
HGET user:1:stats logins
# 3. Shopping cart (product_id -> quantity)
HSET cart:user:1 product:100 2
HINCRBY cart:user:1 product:100 1
HDEL cart:user:1 product:100
# 4. Feature flags
HSET feature_flags user:1 new_ui 1 beta 0
HGET feature_flags user:1 new_ui # 1
# 5. Session store with TTL
HSET session:abc user_id 1 data "..."
EXPIRE session:abc 1800 # 30 min
# 6. Hash field expiration (Redis 7.4+)
HEXPIRE user:1 60 FIELDS 1 session_token
HPTTL user:1 FIELDS 1 session_tokenУправление ключами
EXISTS, TYPE и DEL
EXISTS с несколькими ключами возвращает число существующих. TYPE возвращает тип структуры данных — всегда проверяйте перед операцией, чтобы избежать ошибок WRONGTYPE (тип ключа неизменен на всё время жизни). DEL блокирующая и может застопорить сервер на больших структурах; для больших ключей предпочитайте UNLINK. Для несуществующих ключей TYPE возвращает 'none'.
# check if a key exists
SET mykey "hello"
EXISTS mykey # 1
EXISTS missing # 0
EXISTS key1 key2 key3 # count of existing keys (multiple)
# get the type of a value
TYPE mykey # "string"
TYPE mylist # "list"
TYPE missing # "none"
# delete one or more keys
DEL mykey # 1 if deleted, 0 if not
DEL key1 key2 key3 # number of keys deleted
# delete is blocking for large keys — use UNLINK instead
# UNLINK deletes in a background thread
# check type before operating to avoid WRONGTYPE errors
TYPE mykey
# returns: string | list | hash | set | zset | stream | noneUNLINK (асинхронное удаление)
UNLINK (4.0+) — неблокирующая альтернатива DEL для больших ключей: она сразу убирает ключ из пространства ключей, а память освобождает в фоновом потоке, предотвращая зависание сервера. Для ключей с миллионами элементов всегда используйте UNLINK. FLUSHDB ASYNC / FLUSHALL ASYNC делают то же для массового удаления. Фактическое освобождение выполняет пул потоков lazyfree.
# UNLINK: non-blocking delete (large keys)
UNLINK biglist bighash # returns count of deleted keys
# UNLINK removes the key from the keyspace immediately
# but frees the memory in a background thread
# compare:
DEL biglist # blocks until fully freed
UNLINK biglist # returns immediately, frees later
# for small keys, DEL and UNLINK are equivalent
# for large keys (millions of elements), UNLINK is essential
# flush database asynchronously (non-blocking)
FLUSHDB ASYNC
FLUSHALL ASYNC
# check what's being freed in background
INFO memory | grep lazyfreeRENAME и RENAMENX
RENAME атомарно переименовывает ключ, перезаписывая существующий целевой ключ (и его значение). RENAMENX (6.2+) переименовывает, только если целевого ключа нет, предотвращая случайную перезапись. TTL при переименовании сохраняется. RENAME атомарна — другие клиенты не видят промежуточное состояние. Переименование между базами не поддерживается; исполь зуйте MOVE или DUMP/RESTORE.
# rename a key (overwrites destination if it exists)
SET oldkey "value"
RENAME oldkey newkey # OK; oldkey is gone, newkey has "value"
# rename only if destination doesn't exist (6.2+)
RENAMENX oldkey newkey # 1 if renamed, 0 if newkey already exists
# rename preserves the type and TTL
SET tempkey "data" EX 3600
RENAME tempkey permkey # permkey now has TTL of ~3600s
TTL permkey # ~3600
# rename across databases is not supported
# use MOVE + RENAME, or DUMP/RESTORE for cross-db moves
# type is immutable — rename keeps the type
TYPE permkey # "string"
# renaming is atomicKEYS и SCAN
KEYS блокирует сервер, пока сканирует всё пространство ключей, — НИКОГДА не используйте её в продакшене на больших наборах. SCAN — безопасная для продакшена альтернатива: на курсоре, без блокировки, возвращает курсор, по которому идёте до 0. SCAN может вернуть дубликаты или пропустить добавленные ключи, но никогда не блокирует. COUNT — подсказка (может вернуть больше или меньше). Всегда обрабатывайте цикл по курсору в коде.
# KEYS: blocks the server while scanning — NEVER in production
KEYS * # all keys (DANGEROUS on large DBs)
KEYS user:* # keys matching pattern
KEYS session:*
# SCAN: cursor-based iteration (non-blocking, production-safe)
SCAN 0 MATCH user:* COUNT 100
# returns: [nextCursor, [key1, key2, ...]]
# continue until cursor returns to 0
SCAN <nextCursor> MATCH user:* COUNT 100
# scan by type (7.0+)
SCAN 0 TYPE hash
SCAN 0 MATCH user:* TYPE string COUNT 100
# SCAN is weakly consistent:
# - may return duplicates
# - may miss keys added during iteration
# - but NEVER blocks the server
# COUNT is a hint, not exactRANDOMKEY и DBSIZE
RANDOMKEY возвращает случайный ключ, не удаляя его, — полезно для сэмплирования. DBSIZE возвращает точное число ключей в текущей базе (O(1)). INFO keyspace показывае т счётчики по базам со статистикой истечения (keys, expires, avg_ttl). Для случайного ключа конкретного типа встроенной команды нет — используйте SCAN + TYPE в цикле.
# get a random key (O(1), does not remove)
RANDOMKEY # "user:1" or nil if db is empty
# get the number of keys in the current database
DBSIZE # 1234
# count keys across all databases (in a cluster)
# note: DBSIZE only counts the current db
SELECT 0; DBSIZE
SELECT 1; DBSIZE
# get keyspace info (keys per db with expiry info)
INFO keyspace
# db0:keys=1000,expires=500,avg_ttl=3600000
# db1:keys=50,expires=10,avg_ttl=60000
# scan with count for approximate size estimation
SCAN 0 COUNT 1 # get cursor + small sample
# find a random key of a specific type
# (no built-in; use SCAN + TYPE in a loop)Команды OBJECT
OBJECT ENCODING показывает внутреннее представление (отладка памяти). OBJECT IDLETIME ищет холодные ключи (кандидаты на вытеснение). OBJECT FREQ работает только с maxmemory-policy LFU. MEMORY USAGE с SAMPLES 0 считает точно (по умолчанию для больших коллекций берутся сэмплы). COMMAND DOCS (7.0+) возвращает структурированную документацию. Эти инструменты помогают отлаживать раздувание памяти.
# OBJECT subcommands for introspection
OBJECT ENCODING mykey # internal encoding (embstr, raw, int, listpack, etc.)
OBJECT REFCOUNT mykey # reference count
OBJECT IDLETIME mykey # seconds since last access
OBJECT FREQ mykey # access frequency (LFU mode only)
# check memory usage of a key (bytes)
MEMORY USAGE mykey
MEMORY USAGE mykey SAMPLES 0 # exact count (slower for large keys)
# total memory used by the server
INFO memory | grep used_memory_human
# inspect a key's internal structure (debugging, can be slow)
DEBUG OBJECT mykey # raw internal info
# the encoding changes automatically as the structure grows
# e.g., hash: listpack -> hashtable when fields exceed threshold
# help understand a command
COMMAND INFO GET
COMMAND DOCS SET # structured docs (7.0+)Срок жизни и сохранение
EXPIRE и EXPIREAT
EXPIRE задаёт TTL существующему ключу; SET с EX/PX/EXAT/PXAT делает это атомарно (предпочтительно). Опции NX/GT/LT (7.0+) задают TTL условно — удобно для «добавить срок, только если его нет» или «только продлить, не сокращая». TTL возвращает -1 для ключей без срока и -2 для несуществующих. Истечение ленивое (проверяется при обращении) плюс периодические фоновые обходы.
# set expiration on an existing key (seconds)
SET mykey "value"
EXPIRE mykey 60 # expires in 60 seconds
EXPIRE mykey 60 NX # only set TTL if none exists (7.0+)
EXPIRE mykey 60 GT # only set if new TTL > current (7.0+)
EXPIRE mykey 60 LT # only set if new TTL < current (7.0+)
# set expiration in milliseconds
PEXPIRE mykey 60000
# set expiration at a Unix timestamp
EXPIREAT mykey 1700000000 # seconds
PEXPIREAT mykey 1700000000000 # milliseconds
# set value AND expiration atomically (preferred)
SET token "abc" EX 3600
SET token "abc" PX 3600000
SET token "abc" EXAT 1700000000
# get remaining TTL
TTL mykey # seconds (-1 = no expiry, -2 = no key)
PTTL mykey # millisecondsPERSIST (снятие TTL)
PERSIST снимает TTL, делая ключ постоянным (значение остаётся). GETEX (6.2+) атомарно возвращает значение и задаёт или снимает TTL — удобно для продления сессии при чтении (GETEX key EX 3600) или превращения временного ключа в постоянный (GETEX key PERSIST). COPY (6.2+) копирует ключ, в том числе между базами, без гонки GET+SET.
# remove expiration (make key persistent)
SET session "data" EX 3600
TTL session # 3600
PERSIST session # 1 (success)
TTL session # -1 (no expiry)
# PERSIST returns 1 if the TTL was removed, 0 if key had no TTL or doesn't exist
# copy a key with optional TTL handling (6.2+)
COPY source dest # copy without TTL
COPY source dest REPLACE # overwrite destination
COPY source dest DB 1 # copy to another database
# GETEX: get value and optionally set/remove TTL (6.2+)
GETEX mykey EX 3600 # returns value, sets 3600s TTL
GETEX mykey PERSIST # returns value, removes TTL
# note: PERSIST only removes TTL; the key and value remainSAVE и BGSAVE (RDB)
SAVE блокирует сервер до завершения снимка — никогда не используйте в продакшене. BGSAVE форкает процесс (copy-on-write), поэтому основной поток не блокируется, но большие наборы данных могут вызвать скачок памяти при форке. Правила 'save' запускают автоматические снимки по частоте изменений. RDB компактен и идеален для резервных копий, но рискует потерять данные, записанные после последнего снимка.
# SAVE: synchronous snapshot (BLOCKS the server until done)
SAVE # blocks — use only in maintenance windows
# BGSAVE: background snapshot (non-blocking, forks a child)
BGSAVE # returns immediately, saves in background
LASTSAVE # Unix timestamp of the last successful save
# check if a BGSAVE is in progress
INFO persistence | grep rdb_bgsave_in_progress
# configure automatic snapshots in redis.conf:
# save 3600 1 # save if >= 1 key changed in 3600s
# save 300 100 # save if >= 100 keys changed in 300s
# save 60 10000 # save if >= 10000 keys changed in 60s
# save "" # disable RDB entirely
# RDB file location
CONFIG GET dbfilename # "dump.rdb"
CONFIG GET dir # "/var/lib/redis"
# RDB pros: compact, fast restart, great for backups
# RDB cons: potential data loss between snapshotsBGREWRITEAOF (сжатие AOF)
AOF дописывает каждую команду записи в лог — намного надёжнее RDB (при everysec теряется максимум 1 секунда данных). 'always' делает fsync при каждой записи (очень медленно, только для критичных данных). BGREWRITEAOF сжимает лог, переписывая его минимальным набором команд. В Redis 7 используется многочастный формат AOF (базовый RDB + инкрементальный лог) — части лежат в appenddirname.
# AOF: logs every write command (durable, replayable)
# enable in redis.conf:
# appendonly yes
# appendfilename "appendonly.aof"
# fsync policies:
# appendfsync always # fsync every write (safest, slowest)
# appendfsync everysec # fsync once per second (default, balanced)
# appendfsync no # let OS decide (fastest, risk of data loss)
# trigger AOF rewrite (compacts the log)
BGREWRITEAOF # non-blocking, rewrites in background
# AOF auto-rewrite thresholds:
# auto-aof-rewrite-percentage 100
# auto-aof-rewrite-min-size 64mb
# check AOF status
INFO persistence | grep aof
# AOF pros: minimal data loss (1 sec max with everysec)
# AOF cons: larger files, slower load on restart
# Redis 7: multi-part AOF (base + incremental files)
CONFIG GET appenddirname # "appendonlydir"Конфигурация сохранения
CONFIG SET меняет настройки на лету (без перезапуска); CONFIG REWRITE сохраняет их в redis.conf. Рекомендуемая продакшен-конфигурация — гибрид RDB + AOF: RDB для быстрого рестарта и резервных копий, AOF для минимальных потерь. Начиная с Redis 7 AOF начинается со снимка RDB, за которым идут инкрементальные команды, — это сочетает быструю загрузку с надёжностью.
# view current persistence settings
CONFIG GET save
CONFIG GET appendonly
CONFIG GET appendfsync
CONFIG GET dir
CONFIG GET dbfilename
CONFIG GET appendfilename
# enable AOF at runtime
CONFIG SET appendonly yes
# change fsync policy at runtime
CONFIG SET appendfsync everysec
# disable RDB snapshots
CONFIG SET save ""
# persist config changes to redis.conf
CONFIG REWRITE
# hybrid persistence (recommended):
# RDB for fast restart + AOF for durability
# redis.conf:
# save 3600 1
# appendonly yes
# aof-use-rdb-preamble yes # RDB header in AOF (faster load)
# check persistence status
INFO persistenceРезервное копирование и восстановление
Регулярно делайте резервные копии RDB-файла (компактно и быстро) — это согласованный снимок даже во время работы Redis (copy-on-write). Для AOF копируйте весь каталог appendonly (многочастный в Redis 7). Восстановление: остановите Redis, замените файлы и запустите снова. Чтобы исправить ошибочную команду, отредактируйте AOF и удалите её перед перезапуском. redis-cli --rdb делает онлайн-бэкап, не трогая файловую систему напрямую.
# backup: copy the RDB file while Redis runs
BGSAVE
# wait for LASTSAVE to update, then copy the file
cp /var/lib/redis/dump.rdb /backup/dump-$(date +%F).rdb
# AOF backup: copy the AOF manifest + files (Redis 7)
cp -r /var/lib/redis/appendonlydir /backup/
# restore: stop Redis, replace data files, restart
redis-cli SHUTDOWN
cp /backup/dump.rdb /var/lib/redis/dump.rdb
redis-server /etc/redis/redis.conf
# for point-in-time recovery from AOF:
# edit the AOF file to remove unwanted commands, then restart
# RDB file analysis (offline, safe)
redis-check-rdb /var/lib/redis/dump.rdb
redis-check-aof /var/lib/redis/appendonly.aof
# fix a truncated AOF
redis-check-aof --fix /var/lib/redis/appendonly.aof
# online backup with --rdb (dumps RDB to stdout/file)
redis-cli --rdb /backup/dump.rdbPub/Sub
SUBSCRIBE и UNSUBSCRIBE
SUBSCRIBE блокирует клиента, чтобы получать сообщения из одного или нескольких каналов. Подписанный клиент может вызывать только SUBSCRIBE/UNSUBSCRIBE/PSUBSCRIBE/PUNSUBSCRIBE/PING/QUIT — никаких других команд. PUBSUB исследует состояние pub/sub (активные каналы, число подписчиков). Сообщения работают по принципу «отправил и забыл»: если подписчиков нет, сообщение теряется. Для надёжной доставки используйте Streams.
# subscribe to channels (in one client, blocks)
SUBSCRIBE news alerts
# the client now listens for messages:
# 1) "subscribe" 2) "news" 3) 1
# 1) "subscribe" 2) "alerts" 3) 2
# unsubscribe from specific channels
UNSUBSCRIBE news
UNSUBSCRIBE news alerts
# unsubscribe from ALL channels
UNSUBSCRIBE
# note: published messages are NOT persisted
# if no subscriber is listening, the message is lost
# for persistent messaging, use Streams instead
# count active subscriptions (in another client)
PUBSUB CHANNELS # list active channels
PUBSUB NUMSUB news # subscriber count for "news"PUBLISH
PUBLISH возвращает число подписчиков, получивших сообщение (0, если никого). Получить сообщение после публикации невозможно — если подписчиков не было, оно потеряно. PUBSUB CHANNELS перечисляет активные каналы (с хотя бы одним подписчиком); PUBSUB NUMSUB возвращает число подписчиков. Для надёжного обмена с переигрыванием используйте Streams (XADD/XREAD).
# publish a message to a channel (from another client)
PUBLISH news "Breaking: Redis 7.4 released"
# returns: number of subscribers that received the message
# publish to a channel with no subscribers
PUBLISH empty "hello"
# returns: 0 (message is lost)
# publish to multiple channels (separate PUBLISH calls)
PUBLISH news "msg1"
PUBLISH alerts "msg2"
# pub/sub has no persistence, no replay, no consumer groups
# subscribers must be connected to receive messages
# check how many clients are listening
PUBSUB NUMSUB news
PUBSUB NUMSUB news alerts # multiple channels
# list active channels (with pattern)
PUBSUB CHANNELS # all active channels
PUBSUB CHANNELS news:* # channels matching patternPSUBSCRIBE (подписка по шаблону)
PSUBSCRIBE подписывается на каналы, совпадающие с glob-шаблонами, — мощно для маршрутизации событий (например, user:*:login ловит все события входа пользователей). Сообщение, подходящее и под прямую подписку, и под шаблон, доставляется дважды. Подписчики по шаблону получают события 'pmessage' с шаблоном, каналом и сообщением. PUNSUBSCRIBE отменяет подписки по шаблону.
# subscribe to channels matching a glob pattern
PSUBSCRIBE news.*
PSUBSCRIBE user:*:login
PSUBSCRIBE events:*
# patterns use glob syntax:
# * matches any sequence
# ? matches one character
# [ab] matches 'a' or 'b'
# unsubscribe from patterns
PUNSUBSCRIBE news.*
PUNSUBSCRIBE # unsubscribe from ALL patterns
# a message matching both a direct subscription and a pattern
# is delivered twice (once for each)
# pattern subscribers receive:
# 1) "pmessage" 2) "news.*" 3) "news.tech" 4) "the message"
# use case: event routing
PSUBSCRIBE user:*:login # all user logins
PSUBSCRIBE order:*:created # all order creations
PSUBSCRIBE cache:*:invalidate # cache invalidation eventsШардированный Pub/Sub (7.0+)
Шардированный Pub/Sub (7.0+) решает проблему кластерного режима: обычный Pub/Sub рассылает каждый PUBLISH на все узлы кластера, тратя пропускную способность. Шардированный Pub/Sub направляет сообщения только в шард, которому принадлежит ключ канала, — гораздо эффективнее в больших кластерах. В кластерах используйте SSUBSCRIBE/SPUBLISH. Имя канала определяет шард (как ключ).
# regular Pub/Sub broadcasts to ALL cluster nodes (expensive)
# sharded Pub/Sub routes messages only to the shard owning the channel
# subscribe to a shard channel
SSUBSCRIBE mychannel
# publish to a shard channel
SPUBLISH mychannel "hello"
# sharded pub/sub uses the channel name for shard routing
# so messages only travel within one shard (more efficient)
# use sharded pub/sub in a Redis Cluster to avoid
# broadcasting messages to every node
# regular SUBSCRIBE/PUBLISH still work in cluster mode
# but they broadcast to all shards (cluster-wide overhead)
# check shard channel subscribers (7.0+)
PUBSUB SHARDCHANNELS
PUBSUB SHARDNUMSUB mychannelKeyspace-уведомления
Keyspace-уведомления позволяют клиентам реагировать на события жизненного цикла ключей (set, delete, expire, evict). Настраиваются через notify-keyspace-events. Они работают по принципу «отправил и забыл» (без сохранения) и ненадёжны: при перезапуске сервера Redis ожидающие события теряются. Для надёжной обработк и событий используйте Streams. Keyspace-уведомления хороши для побочных эффектов вроде очистки или прогрева кэша.
# enable keyspace notifications (disabled by default)
CONFIG SET notify-keyspace-events "KEA"
# K = keyspace events, E = keyevent events
# g = generic (DEL, EXPIRE, ...), $ = string, l = list
# h = hash, s = set, z = sorted set, x = expired, e = evicted
# A = all except m (m = keymiss)
# subscribe to events on a specific key
SUBSCRIBE __keyspace@0__:mykey
# publishes "set", "del", "expire", etc.
# subscribe to events of a specific type
SUBSCRIBE __keyevent@0__:del
# publishes the key name that was deleted
# example: react when a key expires
SUBSCRIBE __keyspace@0__:session:abc
# receives "expired" when the key TTL ends
# example: react to all expired keys
SUBSCRIBE __keyevent@0__:expired
# check current setting
CONFIG GET notify-keyspace-eventsТранзакции
MULTI и EXEC
MULTI/EXEC группирует команды в атомарный последовательный блок — другой клиент не может вклиниться. Команды ставятся в очередь (возвращая QUEUED) и выполняются вместе при EXEC. Ошибка постановки в очередь (неверное имя команды) отменяет всю транзакцию. Ошибка выполнения (неверный тип ключа) пропускает только эту команду, остальные выполняются. Это отличается от транзакций SQL.
# MULTI starts a transaction; commands are queued
MULTI
SET counter 1
INCR counter
INCR counter
GET counter
EXEC
# returns: 1) OK 2) 2 3) 3 4) "3"
# all queued commands execute atomically (no interleaving)
# other clients cannot run commands between MULTI and EXEC
# each queued command returns "QUEUED" until EXEC
MULTI
SET x 1
# "QUEUED"
INCR x
# "QUEUED"
EXEC
# 1) OK 2) 2
# the transaction is atomic: all or nothing (at queuing time)DISCARD (отмена транзакции)
DISCARD отменяет транзакцию, очищая все команды в очереди и выводя соединение из режима транзакции. Она также снимает все WATCH-наблюдения (см. WATCH). После DISCARD клиент снова может выполнять обычные команды. DISCARD — аналог 'rollback', но учтите: Redis не поддерживает частичный откат внутри EXEC; ошибки выполнения пропускают сбойную команду, а остальные фиксируются.
# DISCARD cancels a transaction (clears all queued commands)
MULTI
SET x 1
INCR x
DISCARD
# OK — no commands are executed
# after DISCARD, the connection returns to normal mode
GET x
# (nil) or the previous value — nothing changed
# DISCARD also clears all WATCHed keys
WATCH counter
MULTI
INCR counter
DISCARD
# counter is no longer watched
# you must call MULTI before DISCARD
DISCARD
# ERR DISCARD without MULTIWATCH (оптимистичные блокировки)
WATCH реализует оптимистичную блокировку: если отслеживаемый ключ изменился между WATCH и EXEC, транзакция отменяется (EXEC возвращает nil). Это стандартный паттерн Redis для атомарности «чтение-изменение-запись» (в Redis нет блокировок строк). Всегда повторяйте попытку при nil. WATCH проверяется во время EXEC. UNWATCH снимает наблюдение (это же происходит при DISCONNECT). Изменение отслеживаемого ключа самим клиентом тоже вызывает отмену.
# WATCH monitors keys; if any change before EXEC, transaction aborts
WATCH counter
val = GET counter # read current value
MULTI
INCR counter # queue the update
EXEC # nil if counter changed -> retry
# typical pattern: read-modify-write with retry
WATCH key
current = GET key
new_value = compute(current)
MULTI
SET key new_value
EXEC
# if EXEC returns nil, the key changed — loop and retry
# UNWATCH cancels all watches
UNWATCH
# WATCH is checked at EXEC time, not during queuing
# if a watched key is modified (by any client, including yourself),
# EXEC returns nil and the transaction is not executedUNWATCH и крайние случаи WATCH
После EXEC (зафиксирована транзакция или отменена из-за WATCH) все наблюдения автоматически снимаются. То же при DISCARD. Чтобы повторить цикл оптимистичной блокировки, нужно снова вызвать WATCH перед следующим MULTI. WATCH внутри MULTI — ошибка; WATCH всегда должен идти перед MULTI. UNWATCH нужен в основном для отмены наблюдений без входа в транзакцию.
# UNWATCH cancels all watches
WATCH key1 key2
UNWATCH # both keys are no longer watched
# WATCH inside a MULTI is not allowed (error)
MULTI
WATCH key
# ERR WATCH inside MULTI is not allowed
# after EXEC (success or abort), watches are cleared
WATCH key
MULTI
SET key "new"
EXEC
# key is no longer watched after EXEC
# after DISCARD, watches are cleared
WATCH key
MULTI
DISCARD
# key is no longer watched
# re-WATCH after EXEC to retry the optimistic lock loop
WATCH key
val = GET key
MULTI
SET key newval
EXEC
# if nil, loop: WATCH key again, GET, MULTI, SET, EXECОбработка ошибок транзакций
В транзакциях Redis есть два типа ошибок. Ошибки постановки в очередь (неверное имя команды или арность) отменяют всю транзакцию при EXEC (EXECABORT) — ничего не выполняется. Ошибки выполнения (например, INCR по нечислу) пропускают только сбойную команду, остальные выполняются. Откатов НЕТ. Это критическое отличие от баз SQL. Проверяйте данные перед MULTI, чтобы избежать ошибок выполнения.
# two types of errors in transactions:
# 1. Queuing errors (bad command syntax) — aborts the WHOLE transaction
MULTI
SET key "value"
INCRBY key "notanumber" # error during queuing (wrong arity/type at parse)
GET key
EXEC
# EXECABORT Transaction discarded because of previous errors.
# NOTHING executes — not even the SET
# 2. Runtime errors (wrong type at execution) — skips ONLY that command
SET key "stringvalue"
MULTI
INCR key # queues fine (syntax OK)
SET otherkey "ok"
EXEC
# 1) (error) ERR value is not an integer
# 2) OK
# the INCR failed but SET otherkey succeeded — no rollback!
# lesson: Redis transactions do NOT have rollback like SQLПайплайнинг
Основы пайплайна
Пайплайнинг объединяет команды в батчи, сокращая сетевые round-trip'ы, — это кардинально быстрее отдельных команд по сети. Каждый round-trip стоит сетевой задержки (~0.1–1 мс); 1000 отдельных команд = 100–1000 мс, а в пайплайне — около 1 мс. Большинство клиентских библиотек предоставляют метод pipeline/multi. redis-cli может использовать пайплайн через stdin. Пайплайнинг НЕ гарантирует атомарность — другие клиенты могут вклиниться.
# pipelining sends multiple commands in one network round-trip
# (no atomicity guarantee, just reduced latency)
# using redis-cli with stdin (simple pipeline):
printf '%s\n' "SET k1 v1" "SET k2 v2" "GET k1" | redis-cli
# OK
# OK
# "v1"
# using redis-cli --pipe (raw RESP, fastest for bulk loads):
# (see the data-import-export section for details)
# in a client library (e.g., Node.js with ioredis):
const pipe = redis.pipeline()
pipe.set("k1", "v1")
pipe.set("k2", "v2")
pipe.incr("counter")
const results = await pipe.exec()
# vs individual commands:
await redis.set("k1", "v1") # round-trip 1
await redis.set("k2", "v2") # round-trip 2
await redis.incr("counter") # round-trip 3MULTI и пайплайнинг
MULTI/EXEC гарантирует атомарность (другой клиент не вклинится) И автоматически использует пайплайнинг в большинстве клиентских библиотек (то есть сокращает и round-trip'ы). Простой пайплайнинг только сокращает round-trip'ы — другие клиенты могут выполнять команды между вашими. Используйте MULTI/EXEC, когда нужна атомарность (например, чтение-изменение-запись с WATCH); простой пайплайнинг — для массовых операций, где порядок и атомарность не важны.
# MULTI/EXEC: atomic (no interleaving), pipelined automatically
MULTI
SET k1 v1
SET k2 v2
INCR counter
EXEC
# all 3 commands run atomically as one block
# Pipelining: NOT atomic, just batched (other clients can interleave)
# (in client code)
pipe.set("k1", "v1")
pipe.set("k2", "v2")
pipe.incr("counter")
pipe.exec()
# commands may interleave with other clients
# when to use which:
# - need atomicity (all-or-nothing)? -> MULTI/EXEC
# - just want speed (bulk operations)? -> pipelining
# - both? -> MULTI/EXEC (auto-pipelined)
# MULTI/EXEC is automatically pipelined by most clients
# so you get atomicity + batch round-trips in oneПротокол RESP
RESP — сетевой протокол Redis: простой, текстовый и быстрый. *N обозначает массив из N элементов; $N — bulk-строку из N байт; + — простую строку; : — целое число; - — ошибку. Режим redis-cli --pipe принимает сырой RESP для максимально быстрой массовой загрузки (гораздо быстрее текстовых команд через stdin). Понимание RESP помогает при отладке и создании собственных клиентов.
# RESP (REdis Serialization Protocol) is the wire format
# redis-cli sends RESP; you can also send it raw with --pipe
# simple command (PING) in RESP:
# *1\r\n$4\r\nPING\r\n
# SET key value in RESP:
# *3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n
# RESP types:
# +OK simple string
# -ERR error
# :42 integer
# $5\r\nhello bulk string
# *2\r\n... array
# raw pipeline with RESP (fastest bulk insert):
# generate a RESP file and pipe it:
cat commands.resp | redis-cli --pipe
# --pipe mode expects raw RESP; checks reply counts
# output: "Last reply received from server: ..."
# "errors: 0, replies: N"Пайплайн в shell-скриптах
Скрипты на shell с redis-cli — частый способ массовой загрузки данных и пакетных операций. Простейший подход — передать текстовые команды через stdin (echo/cat | redis-cli). Для максимальной скорости генерируйте RESP и используйте режим --pipe (на порядок быстрее на больших загрузках). Примеры циклов на bash показывают оба подхода — выбирайте по объёму и требованиям к производительности.
# pipeline multiple commands via stdin
echo -e "SET k1 v1\nSET k2 v2\nGET k1\nGET k2" | redis-cli
# pipeline from a file
cat commands.txt | redis-cli
# pipeline with --pipe-mode (raw RESP, fastest)
# first generate RESP, then pipe:
redis-cli --pipe < commands.resp
# bulk insert example (bash, generate RESP):
for i in $(seq 1 1000); do
printf '*3\r\n$3\r\nSET\r\n$4\r\nkey:\r\n$1\r\n%s\r\n' "$i"
done | redis-cli --pipe
# or simpler (text mode, slightly slower):
for i in $(seq 1 1000); do
echo "SET key:$i value$i"
done | redis-cli
# --pipe-mode reports errors and throughputОграничения и лучшие практики пайплайна
Пайплайнинг — главный рычаг производительности Redis, но не переусердствуйте: очередь ответов занимает память и на клиенте, и на сервере. Объединяйте в группы по 100–1000 команд. Замеряйте redis-benchmark -P, чтобы найти оптимум (пропускная способность выходит на плато, а задержка растёт при очень больших пайплайнах). Для команд, зависящих от предыдущих результатов, используйте Lua-скрипты (атомарно, один round-trip) вместо нескольких вызовов в пайплайне.
# don't pipeline too many commands at once
# (queued replies consume memory on both client and server)
# bad: 1 million commands in one pipeline
# -> huge memory buffer, potential timeout
# good: batch in groups of 100-1000
for batch in chunks(data, 500):
pipe = redis.pipeline()
for item in batch:
pipe.set(item.key, item.value)
pipe.exec()
# benchmark pipelining
redis-benchmark -t set -n 100000 -P 16 # -P = pipeline size
# try -P 1, 10, 100, 1000 to find the sweet spot
# use pipelining for:
# - bulk imports
# - batch reads (MGET is better for simple multi-get)
# - pre-warming cache
# - reducing latency in high-RTT environments
# avoid pipelining for:
# - commands that depend on previous results (use Lua instead)
# - very large batches (split into chunks)Lua-скрипты
Основы EVAL
EVAL выполняет Lua-скрипты атомарно: пока скрипт работает, другие команды не выполняются, что идеально для многошаговых атомарных операций. KEYS и ARGV передают данные от вызывающей стороны; никогда не собирайте ключи конкатенацией строк в скрипте (это нарушает правила кластера — все ключи должны быть в KEYS). redis.call пробрасывает ошибки (останавливает выполнение), redis.pcall возвращает их. Скрипты кэшируются по SHA1-хешу для EVALSHA.
# EVAL: run a Lua script inline
# EVAL "script" numkeys key1 key2 ... arg1 arg2 ...
EVAL "return redis.call('GET', KEYS[1])" 1 mykey
# 1 = number of keys
# mykey = KEYS[1]
# run a simple script (no keys)
EVAL "return 42" 0
EVAL "return {1, 2, 3}" 0
EVAL "return 'hello'" 0
# a check-and-set script:
EVAL "
local cur = redis.call('GET', KEYS[1])
if cur == ARGV[1] then
return redis.call('SET', KEYS[1], ARGV[2])
end
return 0
" 1 mykey "expected" "newvalue"
# redis.call() raises error if command fails (stops script)
# redis.pcall() returns error as a table (can handle)
EVAL "local ok, err = pcall(redis.call, 'GET', 'missing'); return err" 0EVALSHA и SCRIPT LOAD
EVALSHA запускает ранее загруженный скрипт по его SHA1-хешу, не отправляя тело скрипта при каждом вызове, — большая экономия трафика для приложений, выполняющих один и тот же скрипт многократно. При промахе кэша (после SCRIPT FLUSH или перезапуска) Redis возвращает NOSCRIPT; клиенты перехватывают это и откатываются к EVAL + SCRIPT LOAD. Всегда используйте библиотеки (redis-py, ioredis), которые делают это прозрачно.
# load a script once, get its SHA1
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# returns: "fa00d1f0..." (the SHA1 hash)
# execute by hash (saves bandwidth on repeated calls)
EVALSHA "fa00d1f0..." 1 mykey
# check if a script is cached
SCRIPT EXISTS "fa00d1f0..." "abcd1234..."
# 1) 1 2) 0 (1 = exists, 0 = not cached)
# flush the script cache
SCRIPT FLUSH
# list all running scripts (during debug)
SCRIPT DEBUG SYNC # blocking debug mode
SCRIPT DEBUG NO # disable debugger
# typical client library pattern:
# 1. SCRIPT LOAD the script on startup
# 2. EVALSHA to run it (falls back to EVAL on NOSCRIPT error)SCRIPT LOAD, FLUSH и EXISTS
SCRIPT LOAD кэширует скрипт и возвращает его SHA1. SCRIPT EXISTS проверяет, закэшированы ли скрипты (полезно после перезапуска). SCRIPT FLUSH очищает весь кэш скриптов — последующие EVALSHA вернут NOSCRIPT. SCRIPT KILL останавливает долго работающий скрипт, но только если он ещё ничего не записал (ради консистентности); если записал, нужен SHUTDOWN NOSAVE. Скрипты эфемерны — для сохранности используйте Functions (7.0+).
# SCRIPT LOAD: load a script without running it
SCRIPT LOAD "return redis.call('SET', KEYS[1], ARGV[1])"
# returns the SHA1 hash
# SCRIPT EXISTS: check if scripts are cached (after load or restart)
SCRIPT EXISTS "abc123..." "def456..."
# 1) 1 2) 0
# SCRIPT FLUSH: clear the script cache
SCRIPT FLUSH
# all EVALSHA calls will now return NOSCRIPT until scripts are reloaded
# SCRIPT KILL: stop a running script (only if it hasn't written yet)
SCRIPT KILL
# if the script has already executed a write command:
# SHUTDOWN NOSAVE is the only way to stop it (extreme measure)
# scripts are ephemeral — they don't survive a restart
# use Redis Functions (7.0+) for persistent scripts
# check the script cache size
INFO memory | grep script_cacheKEYS и ARGV
KEYS[] содержит имена ключей (важно для маршрутизации в кластере — по ним кластер определяет, какой шард выполняет скрипт). ARGV[] содержит значения и параметры. Никогда не хардкодьте имена ключей внутри скрипта (например, redis.call('GET', 'mykey')) — это ломает маршрутизацию, потому что кластер не знает, на каком шарде живёт 'mykey'. Всегда передавайте ключи через KEYS[]. Аргумент numkeys говорит Redis, сколько ключей ожидать.
# KEYS[]: key names passed to the script
# ARGV[]: additional arguments (values, options)
# example: atomic increment with cap
EVAL "
local current = tonumber(redis.call('GET', KEYS[1]) or 0)
local max = tonumber(ARGV[1])
if current >= max then
return -1 -- cap reached
end
return redis.call('INCR', KEYS[1])
" 1 counter 100
# KEYS[1] = counter, ARGV[1] = 100
# example: move item between lists atomically
EVAL "
local item = redis.call('RPOP', KEYS[1])
if item then
redis.call('LPUSH', KEYS[2], item)
end
return item
" 2 source_list dest_list
# NEVER hardcode key names in scripts (breaks cluster routing)
# always pass keys via KEYS[] so the cluster can route correctlyАтомарные операции на Lua
Lua-скрипты — канонический способ делать атомарные многошаговые операции в Redis (без гонок MULTI/EXEC). Compare-and-set, захват семафора, миграция очередей и rate limiting выигрывают от этого. Скрипты блокируют сервер на время работы — держите их короткими и избегайте циклов по множеству ключей (они могут застопорить других клиентов). Для очень долгой работы используйте Redis Functions (Redis 7.0+), которые объявляются и версионируются как хранимые процедуры.
# atomic compare-and-set (only update if value matches)
EVAL "
local cur = redis.call('GET', KEYS[1])
if cur == ARGV[1] then
return redis.call('SET', KEYS[1], ARGV[2])
end
return 0
" 1 mykey "expected" "newvalue"
# atomic 'decrement if positive' (semaphore / rate limit)
EVAL "
local val = tonumber(redis.call('GET', KEYS[1]) or 0)
if val > 0 then
redis.call('DECR', KEYS[1])
return 1
end
return 0
" 1 semaphore
# atomic list pop + push (move between queues)
EVAL "
local item = redis.call('RPOP', KEYS[1])
if item then
redis.call('LPUSH', KEYS[2], item)
end
return item
" 2 source_queue dest_queue
# atomic rate limiter (fixed window)
EVAL "
local count = redis.call('INCR', KEYS[1])
if count == 1 then
redis.call('EXPIRE', KEYS[1], ARGV[1])
end
return count
" 1 rate:user:1 60Redis Functions (7.0+)
Functions (7.0+) улучшают EVAL-скрипты: у них есть имена (а не только хеши), они организованы в библиотеки и сохраняются между перезапусками (EVAL-скрипты эфемерны). Это упрощает управление и деплой. FCALL вызывает функцию по имени. Functions — современный способ добавлять атомарную серверную логику. Как и скрипты, они должны быть детерминированными для репликации. FUNCTION DUMP/RESTORE позволяет делать бэкап и миграцию.