Skip to content

Redis CLI Шпаргалка

Хранилище данных в памяти: команды CLI и работа с ними.

01

Начало работы

Подключение к серверу Redis

redis-cli — стандартный клиент командной строки. По умолчанию подключается к 127.0.0.1:6379. Используйте -h для хоста, -p для порта, -a для пароля (или задайте переменную окружения REDISCLI_AUTH, чтобы не светить секреты в истории shell). Для TLS нужны --tls и сертификаты/ключи. Схема URL redis:// поддерживается в Redis 6+, rediss:// — для TLS.

redis-cli
# 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 выводит значения без префиксов типов, удобно для конвейеров.

redis-cli
# 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:json

PING и проверка соединения

PING — простейшая проверка работоспособности: живой Redis отвечает PONG. --latency непрерывно измеряет round-trip (полезно для диагностики сетевых проблем). --latency-dist показывает гистограмму. --latency-history ведёт скользящую статистику. Используйте это, чтобы зафиксировать базовое качество соединения перед настройкой производительности.

redis-cli
# 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.

redis-cli
# 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-cli
# 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.

redis-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
02

Строки

Базовые SET и GET

SET/GET — фундаментальные операции со строками. NX = установить, если не существует (используется для блокировок); XX = установить, если существует. EX/PX/EXAT/PXAT задают срок жизни атомарно (нет гонки между SET и EXPIRE). GETSET возвращает предыдущее значение, устанавливая новое. Строки бинарно-безопасны до 512 МБ.

redis-cli
# 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 вернёт ошибку.

redis-cli
# 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 integer

APPEND и операции со строками

APPEND удлиняет строку (создаёт её, если нет). STRLEN сообщает длину. GETRANGE/SETRANGE работают с подстроками (бинарно-безопасно). GETDEL (6.2+) атомарно возвращает и удаляет — удобно для одноразового чтения. GETEX атомарно возвращает значение и задаёт TTL — удобно для продления срока сессии при чтении.

redis-cli
# 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.

redis-cli
# 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, фича-флаги.

redis-cli
# 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, — удобно для обновления кэшированных значений без сброса окна истечения. Истечение ленивое (проверяется при обращении) плюс периодические фоновые обходы.

redis-cli
# 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
03

Списки

Операции push и pop

Списки двусторонние: LPUSH+RPOP = очередь (FIFO), LPUSH+LPOP = стек (LIFO). BLPOP/BRPOP блокируются до появления элемента — это основа очередей на Redis (без опроса). Всегда задавайте таймаут для BLPOP, чтобы обрабатывать обрывы соединения. Для головы и хвоста списки дают O(1), а доступ к середине — O(N).

redis-cli
# 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 exist

LRANGE и индексация

LRANGE 0 -1 возвращает весь список. LINDEX для середины работает за O(N) — списки оптимизированы под доступ с краёв. LSET изменяет по индексу. LINSERT работает за O(N) (используйте умеренно на больших списках). LPOS находит позиции элемента, не удаляя его. Для частого случайного доступа по индексу список — неподходящий выбор: рассмотрите sorted set.

redis-cli
# 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 теряет элемент. После обработки удалите элемент из списка-приёмника.

redis-cli
# 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 100

LREM, LSET и LTRIM

LTRIM — частый приём для ограничения размера списка (например, хранить только последние 100 событий). LREM удаляет по значению (count: положительный — с головы, отрицательный — с хвоста, 0 — все). LMPOP (7.0+) извлекает из нескольких списков за один вызов — удобно для приоритетных очередей. При частых операциях в середине списка список — неподходящий выбор.

redis-cli
# 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.

redis-cli
# 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
04

Множества

SADD, SMEMBERS и SISMEMBER

Множества хранят уникальные значения — идеальны для тегов, категорий и дедупликации. SISMEMBER работает за O(1) — намного быстрее проверки по списку. SMEMBERS может блокировать на больших множествах; для перебора используйте SSCAN. SMISMEMBER (7.4+) пакетно проверяет принадлежность, сокращая round-trip'ы. Если все элементы — целые числа, используется intset (отсортированный массив), что очень экономит память.

redis-cli
# 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+) возвращает только количество — быстрее, когда сами элементы не нужны. Сохраняйте результаты, чтобы не пересчитывать.

redis-cli
# 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 s4

SREM, SMOVE и SPOP

SMOVE атомарна — удобна для смены состояний (например, перевод пользователя из множества 'pending' в 'active'). SPOP удаляет случайные элементы (полезно для лотерей и шардирования). SRANDMEMBER не удаляет. BSPOP (7.0+) блокируется как BLPOP, но для множеств — полезно в событийных паттернах, где порядок не важен. SREM возвращает число фактически удалённых элементов.

redis-cli
# 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 даёт слабые гарантии: возможны дубликаты или пропуск добавленных элементов, но она никогда не блокирует. Всегда обрабатывайте цикл по курсору в своём коде.

redis-cli
# 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.

redis-cli
# 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
05

Сортированные множества

ZADD, ZSCORE и ZRANK

Сортированные множества (zsets) — самая мощная структура Redis: уникальные элементы, упорядоченные по score, с операциями за O(log N). Опции ZADD (NX/XX/GT/LT) дают условные обновления: GT обновляет, только если новый score больше (отлично для отслеживания лучшего результата). Score — это double; элементы уникальны. При равенстве score порядок лексикографический.

redis-cli
# 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+) сохраняет результат в новый ключ для дальнейшей обработки.

redis-cli
# 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 10

ZRANGEBYSCORE и ZCOUNT

ZRANGEBYSCORE возвращает по диапазону score; префикс '(' делает score эксклюзивным. ZCOUNT даёт количество в диапазоне, не выбирая элементы. ZINCRBY атомарно меняет score и пересортировывает — идеально для живых рейтингов. ZREMRANGEBYRANK хорош для ограничения размера zset (например, хранить только топ-1000).

redis-cli
# 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 <= 100

ZUNIONSTORE и ZINTERSTORE

ZUNIONSTORE/ZINTERSTORE объединяют zsets с настраиваемой агрегацией (SUM/MIN/MAX) и весами — мощно для взвешенного скоринга (например, релевантность = text_match*2 + recency*1). В Redis 6.2 добавлены ZUNION/ZINTER/ZDIFF, возвращающие результат без сохранения (на одну команду меньше). Это O(N*M) — будьте осторожны с большими множествами. Число множеств указывается перед их именами.

redis-cli
# 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 одинаковы.

redis-cli
# 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.

redis-cli
# 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
06

Хеши

HSET, HGET и HGETALL

Хеши идеальны для хранения объектов: один ключ на объект, поля на свойства. Это лучше сериализации JSON, потому что можно атомарно обновлять отдельные поля (HSET) без чтения-изменения-записи. HGETALL возвращает все поля; для больших хешей предпочитайте HSCAN. Небольшие хеши используют кодировку listpack (примерно до 128 полей), что экономит память.

redis-cli
# 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 field

HMGET (получение нескольких полей)

HMGET пакетно получает несколько полей за один round-trip — намного быстрее отдельных вызовов HGET. HSET (с 4.0) принимает несколько пар поле-значение, поэтому HMSET устарел. HKEYS/HVALS возвращают все имена полей и значения. HRANDFIELD (6.2+) удобна для сэмплирования (например, случайные фича-флаги). HGETALL блокирует на больших хешах — для продакшена используйте HSCAN.

redis-cli
# 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 + values

HINCRBY (числовые поля)

HINCRBY по полям хеша атомарен — идеален для счётчиков по пользователям (число входов, просмотров, количество товаров в корзине). HINCRBYFLOAT поддерживает дроби. Хеш автоматически удаляется, когда удалено последнее поле (HDEL). Поэтому хеши — идеальная структура для объектов с числовыми счётчиками: куда эффективнее отдельных строковых ключей на каждый счётчик.

redis-cli
# 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 item

HSCAN (перебор хеша)

HGETALL блокирует сервер на больших хешах — для продакшена используйте HSCAN. HSCAN работает по курсору: вызывайте повторно, пока курсор не вернётся к 0. COUNT — это подсказка. Результат приходит плоским массивом [поле, значение, поле, значение, ...] — сопоставляйте пары в коде. Для хешей с миллионами полей рассмотрите шардирование на несколько ключей.

redis-cli
# 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+) — важное дополнение.

redis-cli
# 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
07

Управление ключами

EXISTS, TYPE и DEL

EXISTS с несколькими ключами возвращает число существующих. TYPE возвращает тип структуры данных — всегда проверяйте перед операцией, чтобы избежать ошибок WRONGTYPE (тип ключа неизменен на всё время жизни). DEL блокирующая и может застопорить сервер на больших структурах; для больших ключей предпочитайте UNLINK. Для несуществующих ключей TYPE возвращает 'none'.

redis-cli
# 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 | none

UNLINK (асинхронное удаление)

UNLINK (4.0+) — неблокирующая альтернатива DEL для больших ключей: она сразу убирает ключ из пространства ключей, а память освобождает в фоновом потоке, предотвращая зависание сервера. Для ключей с миллионами элементов всегда используйте UNLINK. FLUSHDB ASYNC / FLUSHALL ASYNC делают то же для массового удаления. Фактическое освобождение выполняет пул потоков lazyfree.

redis-cli
# 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 lazyfree

RENAME и RENAMENX

RENAME атомарно переименовывает ключ, перезаписывая существующий целевой ключ (и его значение). RENAMENX (6.2+) переименовывает, только если целевого ключа нет, предотвращая случайную перезапись. TTL при переименовании сохраняется. RENAME атомарна — другие клиенты не видят промежуточное состояние. Переименование между базами не поддерживается; используйте MOVE или DUMP/RESTORE.

redis-cli
# 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 atomic

KEYS и SCAN

KEYS блокирует сервер, пока сканирует всё пространство ключей, — НИКОГДА не используйте её в продакшене на больших наборах. SCAN — безопасная для продакшена альтернатива: на курсоре, без блокировки, возвращает курсор, по которому идёте до 0. SCAN может вернуть дубликаты или пропустить добавленные ключи, но никогда не блокирует. COUNT — подсказка (может вернуть больше или меньше). Всегда обрабатывайте цикл по курсору в коде.

redis-cli
# 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 exact

RANDOMKEY и DBSIZE

RANDOMKEY возвращает случайный ключ, не удаляя его, — полезно для сэмплирования. DBSIZE возвращает точное число ключей в текущей базе (O(1)). INFO keyspace показывает счётчики по базам со статистикой истечения (keys, expires, avg_ttl). Для случайного ключа конкретного типа встроенной команды нет — используйте SCAN + TYPE в цикле.

redis-cli
# 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+) возвращает структурированную документацию. Эти инструменты помогают отлаживать раздувание памяти.

redis-cli
# 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+)
08

Срок жизни и сохранение

EXPIRE и EXPIREAT

EXPIRE задаёт TTL существующему ключу; SET с EX/PX/EXAT/PXAT делает это атомарно (предпочтительно). Опции NX/GT/LT (7.0+) задают TTL условно — удобно для «добавить срок, только если его нет» или «только продлить, не сокращая». TTL возвращает -1 для ключей без срока и -2 для несуществующих. Истечение ленивое (проверяется при обращении) плюс периодические фоновые обходы.

redis-cli
# 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         # milliseconds

PERSIST (снятие TTL)

PERSIST снимает TTL, делая ключ постоянным (значение остаётся). GETEX (6.2+) атомарно возвращает значение и задаёт или снимает TTL — удобно для продления сессии при чтении (GETEX key EX 3600) или превращения временного ключа в постоянный (GETEX key PERSIST). COPY (6.2+) копирует ключ, в том числе между базами, без гонки GET+SET.

redis-cli
# 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 remain

SAVE и BGSAVE (RDB)

SAVE блокирует сервер до завершения снимка — никогда не используйте в продакшене. BGSAVE форкает процесс (copy-on-write), поэтому основной поток не блокируется, но большие наборы данных могут вызвать скачок памяти при форке. Правила 'save' запускают автоматические снимки по частоте изменений. RDB компактен и идеален для резервных копий, но рискует потерять данные, записанные после последнего снимка.

redis-cli
# 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 snapshots

BGREWRITEAOF (сжатие AOF)

AOF дописывает каждую команду записи в лог — намного надёжнее RDB (при everysec теряется максимум 1 секунда данных). 'always' делает fsync при каждой записи (очень медленно, только для критичных данных). BGREWRITEAOF сжимает лог, переписывая его минимальным набором команд. В Redis 7 используется многочастный формат AOF (базовый RDB + инкрементальный лог) — части лежат в appenddirname.

redis-cli
# 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, за которым идут инкрементальные команды, — это сочетает быструю загрузку с надёжностью.

redis-cli
# 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 делает онлайн-бэкап, не трогая файловую систему напрямую.

redis-cli
# 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.rdb
09

Pub/Sub

SUBSCRIBE и UNSUBSCRIBE

SUBSCRIBE блокирует клиента, чтобы получать сообщения из одного или нескольких каналов. Подписанный клиент может вызывать только SUBSCRIBE/UNSUBSCRIBE/PSUBSCRIBE/PUNSUBSCRIBE/PING/QUIT — никаких других команд. PUBSUB исследует состояние pub/sub (активные каналы, число подписчиков). Сообщения работают по принципу «отправил и забыл»: если подписчиков нет, сообщение теряется. Для надёжной доставки используйте Streams.

redis-cli
# 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).

redis-cli
# 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 pattern

PSUBSCRIBE (подписка по шаблону)

PSUBSCRIBE подписывается на каналы, совпадающие с glob-шаблонами, — мощно для маршрутизации событий (например, user:*:login ловит все события входа пользователей). Сообщение, подходящее и под прямую подписку, и под шаблон, доставляется дважды. Подписчики по шаблону получают события 'pmessage' с шаблоном, каналом и сообщением. PUNSUBSCRIBE отменяет подписки по шаблону.

redis-cli
# 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. Имя канала определяет шард (как ключ).

redis-cli
# 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 mychannel

Keyspace-уведомления

Keyspace-уведомления позволяют клиентам реагировать на события жизненного цикла ключей (set, delete, expire, evict). Настраиваются через notify-keyspace-events. Они работают по принципу «отправил и забыл» (без сохранения) и ненадёжны: при перезапуске сервера Redis ожидающие события теряются. Для надёжной обработки событий используйте Streams. Keyspace-уведомления хороши для побочных эффектов вроде очистки или прогрева кэша.

redis-cli
# 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
10

Транзакции

MULTI и EXEC

MULTI/EXEC группирует команды в атомарный последовательный блок — другой клиент не может вклиниться. Команды ставятся в очередь (возвращая QUEUED) и выполняются вместе при EXEC. Ошибка постановки в очередь (неверное имя команды) отменяет всю транзакцию. Ошибка выполнения (неверный тип ключа) пропускает только эту команду, остальные выполняются. Это отличается от транзакций SQL.

redis-cli
# 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; ошибки выполнения пропускают сбойную команду, а остальные фиксируются.

redis-cli
# 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 MULTI

WATCH (оптимистичные блокировки)

WATCH реализует оптимистичную блокировку: если отслеживаемый ключ изменился между WATCH и EXEC, транзакция отменяется (EXEC возвращает nil). Это стандартный паттерн Redis для атомарности «чтение-изменение-запись» (в Redis нет блокировок строк). Всегда повторяйте попытку при nil. WATCH проверяется во время EXEC. UNWATCH снимает наблюдение (это же происходит при DISCONNECT). Изменение отслеживаемого ключа самим клиентом тоже вызывает отмену.

redis-cli
# 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 executed

UNWATCH и крайние случаи WATCH

После EXEC (зафиксирована транзакция или отменена из-за WATCH) все наблюдения автоматически снимаются. То же при DISCARD. Чтобы повторить цикл оптимистичной блокировки, нужно снова вызвать WATCH перед следующим MULTI. WATCH внутри MULTI — ошибка; WATCH всегда должен идти перед MULTI. UNWATCH нужен в основном для отмены наблюдений без входа в транзакцию.

redis-cli
# 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, чтобы избежать ошибок выполнения.

redis-cli
# 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
11

Пайплайнинг

Основы пайплайна

Пайплайнинг объединяет команды в батчи, сокращая сетевые round-trip'ы, — это кардинально быстрее отдельных команд по сети. Каждый round-trip стоит сетевой задержки (~0.1–1 мс); 1000 отдельных команд = 100–1000 мс, а в пайплайне — около 1 мс. Большинство клиентских библиотек предоставляют метод pipeline/multi. redis-cli может использовать пайплайн через stdin. Пайплайнинг НЕ гарантирует атомарность — другие клиенты могут вклиниться.

redis-cli
# 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 3

MULTI и пайплайнинг

MULTI/EXEC гарантирует атомарность (другой клиент не вклинится) И автоматически использует пайплайнинг в большинстве клиентских библиотек (то есть сокращает и round-trip'ы). Простой пайплайнинг только сокращает round-trip'ы — другие клиенты могут выполнять команды между вашими. Используйте MULTI/EXEC, когда нужна атомарность (например, чтение-изменение-запись с WATCH); простой пайплайнинг — для массовых операций, где порядок и атомарность не важны.

redis-cli
# 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 помогает при отладке и создании собственных клиентов.

redis-cli
# 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 показывают оба подхода — выбирайте по объёму и требованиям к производительности.

redis-cli
# 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) вместо нескольких вызовов в пайплайне.

redis-cli
# 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)
12

Lua-скрипты

Основы EVAL

EVAL выполняет Lua-скрипты атомарно: пока скрипт работает, другие команды не выполняются, что идеально для многошаговых атомарных операций. KEYS и ARGV передают данные от вызывающей стороны; никогда не собирайте ключи конкатенацией строк в скрипте (это нарушает правила кластера — все ключи должны быть в KEYS). redis.call пробрасывает ошибки (останавливает выполнение), redis.pcall возвращает их. Скрипты кэшируются по SHA1-хешу для EVALSHA.

redis-cli
# 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" 0

EVALSHA и SCRIPT LOAD

EVALSHA запускает ранее загруженный скрипт по его SHA1-хешу, не отправляя тело скрипта при каждом вызове, — большая экономия трафика для приложений, выполняющих один и тот же скрипт многократно. При промахе кэша (после SCRIPT FLUSH или перезапуска) Redis возвращает NOSCRIPT; клиенты перехватывают это и откатываются к EVAL + SCRIPT LOAD. Всегда используйте библиотеки (redis-py, ioredis), которые делают это прозрачно.

redis-cli
# 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+).

redis-cli
# 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_cache

KEYS и ARGV

KEYS[] содержит имена ключей (важно для маршрутизации в кластере — по ним кластер определяет, какой шард выполняет скрипт). ARGV[] содержит значения и параметры. Никогда не хардкодьте имена ключей внутри скрипта (например, redis.call('GET', 'mykey')) — это ломает маршрутизацию, потому что кластер не знает, на каком шарде живёт 'mykey'. Всегда передавайте ключи через KEYS[]. Аргумент numkeys говорит Redis, сколько ключей ожидать.

redis-cli
# 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+), которые объявляются и версионируются как хранимые процедуры.

redis-cli
# 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 60

Redis Functions (7.0+)

Functions (7.0+) улучшают EVAL-скрипты: у них есть имена (а не только хеши), они организованы в библиотеки и сохраняются между перезапусками (EVAL-скрипты эфемерны). Это упрощает управление и деплой. FCALL вызывает функцию по имени. Functions — современный способ добавлять атомарную серверную логику. Как и скрипты, они должны быть детерминированными для репликации. FUNCTION DUMP/RESTORE позволяет делать бэкап и миграцию.

redis-cli
# FUNCTIONS are named, versioned Lua scripts (better than EVAL)
# register a function library
FUNCTION LOAD '#!lua name=mylib
redis.register_function("my_set",
  function(keys, args)
    return redis.call("SET", keys[1], args[1])
  end
)'

# call a function by name
FCALL my_set 1 mykey "hello"

# list loaded libraries
FUNCTION LIST
FUNCTION LIST WITHCODE   # include source

# get the function's code (for backup)
FUNCTION DUMP

# delete a library
FUNCTION DELETE mylib

# restore from a dump (for migration)
FUNCTION RESTORE <payload>

# functions persist across restarts (unlike EVAL scripts)
# they're saved in RDB/AOF
13

Управление соединениями

CLIENT LIST

CLIENT LIST показывает каждое подключённое клиентское соединение с адресом, возрастом, временем простоя, текущей командой и флагами — бесценно для поиска утечек и зависших клиентов. Поле 'idle' помогает заметить заброшенные соединения. 'cmd' показывает последнюю команду (удобно, чтобы найти клиента с медленной командой). 'flags' указывает тип клиента (N=обычный, M=master, S=slave/replica, P=pubsub, b=заблокирован). В 7.0+ можно фильтровать по TYPE.

redis-cli
# list all connected clients
CLIENT LIST
# fields: id, addr, laddr, fd, name, age, idle, flags, db, cmd, ...

# filter by type (7.0+)
CLIENT LIST TYPE normal    # normal clients only
CLIENT LIST TYPE replica   # replicas
CLIENT LIST TYPE pubsub    # pub/sub subscribers

# filter by ID (7.0+)
CLIENT LIST ID 1 2 3

# output includes useful fields:
#   addr=10.0.0.1:12345   remote address
#   age=3600              seconds since connected
#   idle=0                seconds since last command
#   cmd=get               last command executed
#   db=0                  current database
#   flags=N               N=normal, M=master, S=slave, P=pubsub

# count connected clients
CLIENT LIST | wc -l

CLIENT SETNAME и GETNAME

CLIENT SETNAME помечает соединение, чтобы его можно было опознать в CLIENT LIST, — необходимо для отладки утечек соединений в средах с множеством сервисов. Задавайте имя сразу после подключения в приложении (например, 'api-server:pid12345:pool1'). Имена видны в поле 'name' в CLIENT LIST. Это позволяет мгновенно понять, какой сервис владеет зависшим или утёкшим соединением.

redis-cli
# name your connection (for identification in CLIENT LIST)
CLIENT SETNAME "my-app-worker-1"

# get the current connection's name
CLIENT GETNAME

# in application code, set the name immediately after connecting:
# redis-cli example:
redis-cli CLIENT SETNAME "debug-session"

# names appear in CLIENT LIST output:
CLIENT LIST
# ... name=my-app-worker-1 ...

# names are useful for:
# - identifying which app/pool a connection belongs to
# - finding leaks (connections that should have been closed)
# - debugging stuck clients
# - naming conventions: app:hostname:pid or pool:name

# names are limited to a reasonable length and cannot contain spaces

CLIENT KILL

CLIENT KILL принудительно отключает клиента — полезно для удаления зависших или утёкших соединений. Убивать можно по ADDR (ip:port), ID, TYPE или USER (ACL). MAXAGE (7.0+) убивает клиентов, простаивающих дольше N секунд. SKIPME yes (по умолчанию) не даёт убить собственное соединение. Сначала найдите цель через CLIENT LIST, затем отключите её через CLIENT KILL. Убийство мгновенное (без корректного завершения).

redis-cli
# kill a client by address
CLIENT KILL ADDR 10.0.0.1:12345

# kill a client by ID
CLIENT KILL ID 42

# kill by type (7.0+)
CLIENT KILL TYPE normal    # kill all normal clients
CLIENT KILL TYPE pubsub    # kill all pub/sub clients

# kill by user (ACL, 6.0+)
CLIENT KILL USER appuser

# kill by address with skip-me
CLIENT KILL ADDR 10.0.0.1:0 SKIPME yes   # don't kill myself

# kill all clients matching filters (7.0+)
CLIENT KILL TYPE normal MAXAGE 3600      # kill idle > 1h

# kill returns the number of clients killed
# use with caution — kills are immediate, no graceful shutdown

# common use: disconnect a stuck client consuming resources
CLIENT LIST
CLIENT KILL ID <id>

CLIENT ID и INFO

CLIENT ID возвращает уникальное, никогда не повторяющееся целое для соединения — удобно для логирования и корреляции. CLIENT INFO даёт подробную информацию о вашем соединении. CLIENT NO-EVICT (6.0+) защищает записи клиента от вытеснения (полезно для критичных записей). CLIENT REPLY управляет отправкой ответов (OFF для массовых загрузок по принципу «отправил и забыл», SKIP — для одной команды).

redis-cli
# get the current client's unique ID (never reused)
CLIENT ID

# get the current client's info (detailed)
CLIENT INFO
# id=42 addr=127.0.0.1:12345 laddr=127.0.0.1:6379 name= db=0 ...

# the ID is a monotonically increasing integer
# it's unique per connection and never reused
# useful for logging and tracking

# CLIENT NO-EVICT (6.0+): this client's writes won't trigger eviction
CLIENT NO-EVICT ON    # protect this client from eviction
CLIENT NO-EVICT OFF   # normal behavior

# CLIENT REPLY (6.0+): control reply mode
CLIENT REPLY ON       # normal replies
CLIENT REPLY OFF      # no replies
CLIENT REPLY SKIP     # skip reply for next command only

# CLIENT UNPAUSE: resume processing after CLIENT PAUSE
CLIENT UNPAUSE

CLIENT PAUSE

CLIENT PAUSE блокирует выполнение команд для всех остальных клиентов на N миллисекунд — полезно для безопасных снимков, миграций и failover кластера. Режим WRITE (7.0+) приостанавливает только записи, оставляя чтения (менее разрушительно). Сам приостанавливающий клиент не блокируется. Во время паузы команды в очереди занимают память, поэтому паузы должны быть короткими. CLIENT UNPAUSE возобновляет немедленно.

redis-cli
# pause all client processing for N milliseconds
CLIENT PAUSE 10000         # pause for 10 seconds
# all other clients' commands are queued, not executed

# pause modes (7.0+):
CLIENT PAUSE 10000 ALL        # pause all commands (default)
CLIENT PAUSE 10000 WRITE      # pause only writes (reads continue)

# resume processing immediately
CLIENT UNPAUSE

# use cases:
# - safe snapshot/migration (pause writes, take consistent backup)
# - cluster failover (pause to ensure clean handoff)
# - debugging (pause to inspect state)

# during pause:
# - commands from OTHER clients are queued (memory grows)
# - the pausing client can still run commands
# - paused commands execute when the pause ends

# check if a pause is active
CLIENT INFO | grep flags
# 'P' flag = paused

Лимиты соединений и таймауты

maxclients ограничивает число одновременных соединений (по умолчанию 10000) — увеличивайте, если у вас много серверов приложений или пулов соединений. timeout отключает простаивающих клиентов (0 = никогда; для безопасности ставьте 300 с). tcp-keepalive обнаруживает мёртвые TCP-соединения (по умолчанию 300 с). Каждый клиент занимает память под выходной буфер — следите через INFO clients. client-output-buffer-limit не даёт одному медленному клиенту съесть всю память сервера (особенно важно для pub/sub и реплик).

redis-cli
# max concurrent clients
CONFIG GET maxclients        # default 10000
CONFIG SET maxclients 50000  # increase limit

# timeout: disconnect idle clients after N seconds
CONFIG GET timeout           # default 0 (never)
CONFIG SET timeout 300       # 5 minutes

# TCP keepalive (detect dead connections)
CONFIG GET tcp-keepalive     # default 300
CONFIG SET tcp-keepalive 60

# when maxclients is reached, new connections are rejected
# error: "ERR max number of clients reached"

# check current client count vs limit
INFO clients
# connected_clients:150
# blocked_clients:5
# maxclients:10000

# each connection uses memory (~a few KB for the output buffer)
# monitor for output buffer growth:
INFO clients | grep client_recent_max_output_buffer

# set output buffer limits (prevent one client from using all memory)
CONFIG GET client-output-buffer-limit
14

Управление сервером

Разделы INFO

INFO — основная команда мониторинга: она сообщает память, клиентов, репликацию, сохранение и статистику за один вызов. Фильтруйте разделы (INFO memory), чтобы сократить вывод. Ключевые метрики: used_memory_rss (реальный объём), mem_fragmentation_ratio (идеально ~1.0–1.5), connected_clients, instantaneous_ops_per_sec, keyspace_hits/misses (доля попаданий в кэш). TIME возвращает время сервера для синхронизации часов.

redis-cli
# comprehensive server information
INFO                  # all sections
INFO server           # version, uptime, config
INFO clients          # connected clients
INFO memory           # memory usage, fragmentation
INFO persistence      # RDB/AOF status
INFO stats            # ops/sec, hit rate, keyspace
INFO replication      # primary/replica state
INFO cpu              # CPU usage
INFO keyspace         # keys per database
INFO commandstats     # command frequency
INFO errorstats       # error frequency

# get a specific metric
INFO memory | grep used_memory_human
INFO stats | grep instantaneous_ops_per_sec
INFO replication | grep role

# check Redis version and mode
INFO server | grep redis_version
INFO server | grep redis_mode        # standalone, cluster, sentinel

# get server time
TIME                    # [unix_timestamp, microseconds]

CONFIG GET и SET

CONFIG SET меняет настройки на лету без перезапуска Redis — идеально для тюнинга. CONFIG GET возвращает текущие значения (используйте шаблоны вроде CONFIG GET *memory*). Частые правки на лету: maxmemory + политика вытеснения, порог slowlog, timeout, пороги кодировок. Не все настройки меняются на лету (например, port и bind требуют перезапуска). Всегда сначала проверяйте изменения конфигурации на стейджинге.

redis-cli
# view config (runtime changes with CONFIG SET)
CONFIG GET maxmemory
CONFIG GET maxmemory-policy
CONFIG GET save
CONFIG GET appendonly
CONFIG GET requirepass

# change config at runtime (no restart needed)
CONFIG SET maxmemory 4gb
CONFIG SET maxmemory-policy allkeys-lru
CONFIG SET slowlog-log-slower-than 10000   # 10ms in microseconds
CONFIG SET timeout 300

# view all config (large output)
CONFIG GET *

# get a specific pattern
CONFIG GET *max*
CONFIG GET *timeout*

# common runtime tweaks:
CONFIG SET maxclients 20000
CONFIG SET hash-max-listpack-entries 256
CONFIG SET appendfsync everysec

CONFIG REWRITE

CONFIG REWRITE сохраняет изменения CONFIG SET обратно в redis.conf — файл обновляется на месте с сохранением комментариев и структуры. Это связывает изменения на лету с сохранностью между перезапусками. Всегда делайте резервную копию redis.conf перед REWRITE (проблемы редки, но безопасность прежде всего). Держите redis.conf в системе контроля версий, чтобы отслеживать и проверять изменения.

redis-cli
# persist config changes to redis.conf
CONFIG REWRITE

# after CONFIG SET maxmemory 4gb
# CONFIG REWRITE updates redis.conf to include:
#   maxmemory 4gb

# the original redis.conf is updated in-place
# comments and structure are preserved

# view the config file path
CONFIG GET *

# typical redis.conf (production):
# bind 127.0.0.1
# protected-mode yes
# port 6379
# maxmemory 4gb
# maxmemory-policy allkeys-lru
# save 3600 1
# appendonly yes
# appendfsync everysec
# tcp-keepalive 300
# timeout 0

# always back up redis.conf before CONFIG REWRITE

SLOWLOG

SLOWLOG записывает команды медленнее заданного порога (по умолчанию 10 мс = 10000 мкс) — бесценно для поиска виновников задержек. Задайте порог под свой SLO (например, 5 мс). Частые медленные команды: KEYS, SMEMBERS на огромных множествах, HGETALL на огромных хешах, SORT на больших данных. slowlog-max-len ограничивает длину журнала (по умолчанию 128). Порог 0 логирует всё (только для отладки — большие накладные расходы).

redis-cli
# configure slow log (threshold in microseconds)
CONFIG SET slowlog-log-slower-than 10000   # 10ms (10000 us)
CONFIG SET slowlog-max-len 128             # keep last 128 entries

# view slow commands
SLOWLOG GET          # last 10 (default)
SLOWLOG GET 5        # last 5
SLOWLOG GET 0        # all entries

# each entry:
# 1) id              unique ID
# 2) timestamp       Unix time
# 3) duration        microseconds
# 4) command         the command and args
# 5) client          address:port
# 6) client name     if set

# slowlog length
SLOWLOG LEN

# reset (clear all entries)
SLOWLOG RESET

# set threshold to 0 to log ALL commands (debugging)
# set to -1 to disable
CONFIG SET slowlog-log-slower-than 0

MONITOR

MONITOR в реальном времени транслирует каждую команду каждого клиента — мощный инструмент отладки, но с ОГРОМНЫМ влиянием на производительность (примерно вдвое снижает пропускную способность). НИКОГДА не используйте MONITOR в продакшене без крайней необходимости и только кратко. Он идеален для стейджинга: подключите MONITOR, воспроизведите проблему и увидьте, какие именно команды шлёт приложение. В продакшене лучше SLOWLOG, LATENCY MONITOR или INFO commandstats.

redis-cli
# MONITOR: real-time log of ALL commands (debugging only!)
MONITOR
# every command from every client is printed:
# 1700000000.123456 [0 10.0.0.1:12345] "SET" "key" "value"
# 1700000000.123567 [0 10.0.0.1:12345] "GET" "key"

# to stop monitoring, send any non-MONITOR command or disconnect
# press Ctrl+C in redis-cli

# WARNING: MONITOR has a HUGE performance impact
# it roughly halves throughput — use only for debugging

# use cases:
# - debugging what commands an app is sending
# - auditing command patterns
# - finding the source of unexpected writes

# safer alternatives for production:
# - SLOWLOG (only slow commands)
# - LATENCY MONITOR (specific events)
# - COMMANDSTATS in INFO (command frequency)

# MONITOR is best used in a staging/dev environment

Мониторинг LATENCY

LATENCY MONITOR отслеживает события задержек (задайте порог, например 100 мс). LATENCY DOCTOR анализирует недавние события и предлагает исправления — отличная отправная точка для диагностики. Частые события: 'command' (медленные команды), 'fork' (задержка форка BGSAVE), 'expire-cycle' (обход истечения), 'aof-write' (задержка fsync AOF). LATENCY GRAPH показывает ASCII-таймлайн. Задайте порог под свой SLO и следите регулярно.

redis-cli
# enable latency monitoring (threshold in ms)
CONFIG SET latency-monitor-threshold 100   # 100ms

# view latency events
LATENCY HISTORY event-name
LATENCY LATEST                            # most recent events
LATENCY HISTORY command
LATENCY HISTORY expire-cycle

# ASCII art graph of an event
LATENCY GRAPH command

# human-readable diagnosis and recommendations
LATENCY DOCTOR

# reset latency data
LATENCY RESET
LATENCY RESET event-name

# common events to monitor:
#   command         slow commands
#   fast-command    slow O(1) commands
#   expire-cycle    expiration cycle taking too long
#   fork            BGSAVE/BGREWRITEAOF fork taking too long
#   aof-write       AOF write delays
#   unlink          async delete delays

# check current threshold
CONFIG GET latency-monitor-threshold
15

Кластер

CLUSTER INFO

CLUSTER INFO даёт краткую сводку здоровья: cluster_state должен быть 'ok' (все 16 384 слота покрыты), cluster_slots_ok должен равняться 16384. cluster_known_nodes — общее число узлов; cluster_size — число мастеров. Если cluster_state 'fail', часть слотов недоступна (вероятно, мастер и его реплика оба упали). Проверяйте с любого узла — информация общая для кластера.

redis-cli
# cluster-wide health
CLUSTER INFO
# key fields:
#   cluster_state:ok              # ok or fail
#   cluster_slots_assigned:16384  # total slots
#   cluster_slots_ok:16384        # slots covered
#   cluster_known_nodes:6         # total nodes
#   cluster_size:3                # number of primaries
#   cluster_current_epoch:7
#   cluster_my_epoch:1

# cluster_state:ok means all slots are covered
# cluster_state:fail means some slots are unavailable

# check from any node in the cluster
redis-cli -p 7000 CLUSTER INFO

# other cluster commands require being in cluster mode
# (redis-server --cluster-enabled yes)

CLUSTER NODES

CLUSTER NODES — определяющий вид топологии: по строке на узел с ID, адресом, ролью (master/slave), мастером, за которым следует реплика, и диапазонами слотов. Ищите флаги 'fail' или 'fail?', указывающие на нездоровые узлы. Диапазоны слотов показывают, какой мастер владеет какими хеш-слотами (0–16383). CLUSTER SHARDS (7.0+) группирует узлы по шардам (мастер + его реплики).

redis-cli
# view the full cluster topology
CLUSTER NODES
# each line is a node:
# <id> <addr:port@cport> <flags> <master> <ping-sent> <pong-recv> <epoch> <link> <slots>

# flags include:
#   M  = master (primary)
#   S  = slave (replica)
#   mymaster = the node this replica follows
#   fail? = suspected down
#   fail  = confirmed down
#   handshake = new node joining
#   nofailover = failover disabled

# example output:
# 1a2b... 127.0.0.1:7000@17000 myself,master - 0 0 1 connected 0-5460
# 3c4d... 127.0.0.1:7001@17001 master - 0 0 2 connected 5461-10922
# 5e6f... 127.0.0.1:7002@17002 master - 0 0 3 connected 10923-16383
# 7g8h... 127.0.0.1:7003@17003 slave 1a2b... 0 0 4 connected

# count nodes by type
CLUSTER NODES | grep -c master
CLUSTER NODES | grep -c slave

# Redis 7.0+: shard view
CLUSTER SHARDS

CLUSTER KEYSLOT и COUNTKEYSINSLOT

CLUSTER KEYSLOT показывает, в какой слот попадает ключ (CRC16 % 16384). Хеш-теги ({...}) направляют связанные ключи в один слот — это необходимо для мульти-ключевых операций (MGET, транзакции, Lua-скрипты) в кластере. Используйте redis-cli -c (режим кластера), чтобы автоматически следовать редиректам MOVED. CLUSTER GETKEYSINSLOT получает ключи слота (используется при решардинге).

redis-cli
# get the hash slot for a key
CLUSTER KEYSLOT mykey       # e.g., 1234
# CRC16(key) % 16384

# count keys in a specific slot (on the owning node)
CLUSTER COUNTKEYSINSLOT 1234

# get keys in a slot (must be run on the slot's owning node)
CLUSTER GETKEYSINSLOT 1234 10   # up to 10 keys

# in a cluster, keys must be on the same slot for multi-key ops
# use hash tags to force keys to the same slot:
SET {user:1}:profile "alice"
SET {user:1}:cart "items"
# both map to the same slot (the part inside {})

# CLUSTER KEYSLOT {user:1}:profile
# CLUSTER KEYSLOT {user:1}:cart
# same result -> same slot -> same shard

# if you access a key on the wrong node, you get a MOVED redirect:
# (error) MOVED 1234 127.0.0.1:7000
# redis-cli -c follows redirects automatically

Хеш-теги

Хеш-теги ({...}) направляют ключи в один слот, что позволяет мульти-ключевые операции в кластере. Но используйте их разумно: чрезмерное применение одного тега (например, {users}:1, {users}:2) создаёт горячую точку на одном шарде. Проектируйте хеш-теги под паттерны доступа: группируйте ключи, читаемые вместе (данные пользователя, позиции заказа), но держите несвязанные ключи отдельно. Это главная задача моделирования данных в кластере.

redis-cli
# hash tags: the substring inside {} determines the slot
# {user:1}:profile and {user:1}:cart share a slot

# enabling multi-key operations in a cluster:
MSET {user:1}:name "Alice" {user:1}:age 30   # OK (same slot)
MSET user:1:name "Alice" user:2:age 30       # CROSSSLOT error

# transactions across keys (must be same slot)
WATCH {order:1}:items
MULTI
HINCRBY {order:1}:items product:1 1
HINCRBY {order:1}:total 10
EXEC

# Lua scripts accessing multiple keys (all keys must share a slot)
EVAL "..." 2 {user:1}:a {user:1}:b

# design hash tags carefully:
# - too broad -> hotspots (one shard overloaded)
#   e.g., {users}:1, {users}:2 -> all on one shard (bad!)
# - too narrow -> can't do multi-key ops
#   e.g., user:1:a, user:1:b -> different slots (can't MGET)

# good: {user:1}:* groups one user's data on one shard
# bad:  {all-users}:* puts everyone on one shard

CLUSTER FAILOVER

Failover в кластере автоматический, если мастер недоступен дольше cluster-node-timeout (по умолчанию 15 с). Ручной failover нужен для обслуживания (обновления без простоя): FAILOVER корректный (ждёт синхронизации репликации), FORCE пропускает синхронизацию (быстрее, но есть риск потери данных), TAKEOVER обходит консенсус (только в аварийных ситуациях, риск split-brain). После failover старый мастер при возвращении становится репликой. В продакшене всегда работайте с репликами.

redis-cli
# when a primary fails, its replica is promoted automatically
# manual failover (for maintenance), run on the REPLICA:
redis-cli -p 7001 CLUSTER FAILOVER         # graceful (waits for sync)
redis-cli -p 7001 CLUSTER FAILOVER FORCE   # without primary agreement (faster)
redis-cli -p 7001 CLUSTER FAILOVER TAKEOVER # force, may split brain (emergency)

# graceful failover steps:
# 1. replica stops syncing from master
# 2. master stops accepting writes
# 3. replica catches up on replication offset
# 4. replica is promoted to master
# 5. cluster is updated with new master info
# 6. old master becomes a replica when it returns

# CLUSTER RESET resets a node (HARD removes all data)
CLUSTER RESET HARD
CLUSTER RESET SOFT

# check failover status
CLUSTER INFO | grep cluster_state

# rolling upgrade pattern:
# for each replica: CLUSTER FAILOVER (becomes master), upgrade old master

Инструмент redis-cli --cluster

Инструмент redis-cli --cluster выполняет сложные операции с кластером: создание, решардинг, ребалансировку, добавление и удаление узлов, проверки здоровья и исправления. --cluster check — ваш основной инструмент проверки здоровья кластера после изменений. --cluster fix автоматически исправляет мелкие проблемы (осиротевшие слоты и т. п.). --cluster call выполняет команду на всех узлах. Используйте это вместо ручных команд CLUSTER для операционных задач.

redis-cli
# create a cluster (6 nodes: 3 primaries + 3 replicas)
redis-cli --cluster create \
  host1:7000 host2:7000 host3:7000 \
  host1:7001 host2:7001 host3:7001 \
  --cluster-replicas 1

# check cluster health
redis-cli --cluster check host1:7000

# repair issues
redis-cli --cluster fix host1:7000

# reshard (move slots between nodes)
redis-cli --cluster reshard host1:7000
# prompts for: how many slots, target node, source nodes

# rebalance slots across all nodes
redis-cli --cluster rebalance host1:7000

# add a new node
redis-cli --cluster add-node newhost:7000 host1:7000

# add a replica
redis-cli --cluster add-node newhost:7001 host1:7000 \
  --cluster-slave --cluster-master-id <nodeId>

# remove a node (migrates its slots first)
redis-cli --cluster del-node host1:7000 <nodeId>

# call a command on all nodes
redis-cli --cluster call host1:7000 INFO server
16

Sentinel (высокая доступность)

Настройка Sentinel

Sentinel обеспечивает высокую доступность без шардирования: он следит за мастером, повышает реплику при отказе и перенастраивает клиентов. Quorum (последнее число) — сколько sentinel'ов должны согласиться, что мастер недоступен; задавайте (N/2)+1 для N sentinel'ов. Размещайте 3 sentinel'а на разных машинах для отказоустойчивости. down-after-milliseconds должен быть больше сетевого джиттера; слишком малое значение вызывает ложные failover'ы.

redis-cli
# Sentinel monitors a primary + replicas, handles failover
# sentinel.conf (port 26379):
sentinel monitor mymaster 192.168.1.10 6379 2
# name, host, port, quorum (number of sentinels to agree on failure)

sentinel down-after-milliseconds mymaster 30000   # 30s to declare down
sentinel failover-timeout mymaster 180000         # 3min failover timeout
sentinel parallel-syncs mymaster 1                # replicas to resync in parallel

# start a sentinel:
redis-sentinel /etc/redis/sentinel.conf
# or:
redis-server /etc/redis/sentinel.conf --sentinel

# deploy at least 3 sentinels (odd number) for quorum
# sentinels communicate with each other and the Redis nodes

# connect to a sentinel to find the current primary:
redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster

# sentinel auto-discovers other sentinels and replicas

SENTINEL masters и replicas

SENTINEL masters перечисляет все отслеживаемые мастера; SENTINEL master <name> даёт детали (включая num-slaves и num-other-sentinels). SENTINEL replicas показывает реплики; SENTINEL sentinels — других sentinel'ов. ckquorum проверяет, хватает ли sentinel'ов для кворума, — запускайте в мониторинге. Все крупные клиентские библиотеки Redis поддерживают Sentinel нативно (они спрашивают sentinel'ов, чтобы найти текущего мастера).

redis-cli
# query sentinel state
redis-cli -p 26379 SENTINEL masters          # all monitored primaries
redis-cli -p 26379 SENTINEL master mymaster  # details of one primary
# fields: name, ip, port, runid, role, ...
#   num-slaves, num-other-sentinels
#   quorum, down-after-milliseconds
#   failover-timeout, parallel-syncs

# list replicas of a master
redis-cli -p 26379 SENTINEL replicas mymaster

# list other sentinels monitoring the same master
redis-cli -p 26379 SENTINEL sentinels mymaster

# count monitoring sentinels (should be >= quorum)
redis-cli -p 26379 SENTINEL sentinels mymaster | grep -c name

# check the number of OK sentinels
SENTINEL ckquorum mymaster
# "OK 3 usable Sentinels. Quorum and failover authorization can be reached"
# or "NOQUORUM" warning (not enough sentinels)

SENTINEL get-master-addr-by-name

SENTINEL get-master-addr-by-name возвращает IP и порт текущего мастера — клиенты вызывают это, чтобы найти мастера, и затем подключаются к нему. При failover sentinel'ы возвращают адрес нового мастера. Клиентам стоит подписаться на события +switch-master, чтобы сразу узнавать о failover'ах. Этот паттерн обнаружения встроен в режим Sentinel всех крупных клиентских библиотек Redis.

redis-cli
# find the current primary address
redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster
# 1) "192.168.1.10"
# 2) "6379"

# clients use this to discover the current primary
# on failover, the sentinel returns the new primary's address

# clients should connect to sentinels, NOT directly to the primary
# libraries: redis-py, jedis, ioredis all support sentinel mode

# example client connection (pseudo-code):
# 1. connect to a sentinel
# 2. SENTINEL get-master-addr-by-name mymaster
# 3. connect to the returned primary
# 4. on connection error, repeat from step 1

# monitor for failover events
redis-cli -p 26379 SUBSCRIBE +switch-master
# publishes: mymaster 192.168.1.10 6379 192.168.1.11 6379

# other events:
redis-cli -p 26379 SUBSCRIBE +failover-state
redis-cli -p 26379 SUBSCRIBE +sdown
redis-cli -p 26379 SUBSCRIBE +odown

SENTINEL failover

SENTINEL failover запускает ручной failover (для плановых обновлений и обслуживания). Автоматический failover происходит, когда мастер недоступен дольше down-after-milliseconds. Failover автоматический, но вызывает короткий простой записи (секунды). Избранный лидер sentinel'ов выбирает самую актуальную реплику для повышения. Когда старый мастер возвращается, он становится репликой — записи, принятые им во время сетевого разделения, ТЕРЯЮТСЯ (риск split-brain).

redis-cli
# force a manual failover (for maintenance)
SENTINEL failover mymaster
# triggers failover: promotes a replica to primary

# the failover process:
# 1. sentinels mark primary SDOWN (subjectively down)
# 2. quorum agrees -> ODOWN (objectively down)
# 3. a sentinel is elected leader
# 4. leader picks the best replica (most up-to-date)
# 5. promotes the replica: REPLICAOF NO ONE
# 6. reconfigures other replicas to follow the new primary
# 7. updates sentinel configs with the new primary address
# 8. clients reconnect via sentinel discovery

# during failover, writes fail briefly (seconds)
# reads from replicas continue (if the app uses them)

# the old primary, when it returns, is reconfigured as a replica
# of the new primary (its writes during partition are lost)

# monitor failover events:
redis-cli -p 26379 SUBSCRIBE +switch-master
redis-cli -p 26379 SUBSCRIBE +failover-*

Кворум Sentinel и мониторинг

Quorum — число sentinel'ов, которые должны согласиться, что мастер недоступен, прежде чем запустить failover; задавайте большинство (N/2+1) для N sentinel'ов. ckquorum проверяет, что их достаточно. down-after-milliseconds должен быть больше сетевого джиттера (30 с — безопасно). failover-timeout ограничивает длительность failover. parallel-syncs задаёт, сколько реплик ресинхронизируются одновременно (1 — безопасно, но медленно). Sentinel'ы автоматически обновляют конфигурацию при изменениях топологии.

redis-cli
# quorum: number of sentinels that must agree a master is down
# set in sentinel monitor command:
sentinel monitor mymaster 192.168.1.10 6379 2
#                                          ^ quorum = 2

# for 3 sentinels: quorum = 2 (majority)
# for 5 sentinels: quorum = 3 (majority)

# check quorum status
SENTINEL ckquorum mymaster
# "OK 3 usable Sentinels" or "NOQUORUM"

# tune down-after-milliseconds (time before declaring down)
sentinel down-after-milliseconds mymaster 30000   # 30s default

# tune failover-timeout (max time for failover to complete)
sentinel failover-timeout mymaster 180000   # 3min default

# parallel-syncs: how many replicas resync simultaneously
sentinel parallel-syncs mymaster 1   # 1 at a time (safe, slow)

# view sentinel configuration
SENTINEL masters
SENTINEL master mymaster

# reset a master's state (clears discovered replicas/sentinels)
SENTINEL reset mymaster

# Sentinel automatically updates its config file when topology changes
17

Мониторинг

Команда MONITOR

MONITOR в реальном времени транслирует каждую команду каждого клиента. Формат вывода: timestamp [db client_addr] "command" "args". Незаменим, чтобы понять, какие команды реально шлёт приложение. Но он примерно вдвое снижает пропускную способность — используйте только на стейджинге/в разработке или кратко в продакшене. Фильтруйте через grep по нужным шаблонам. Для продакшен-мониторинга лучше SLOWLOG, INFO commandstats или LATENCY MONITOR.

redis-cli
# MONITOR: real-time log of ALL commands (debugging only!)
MONITOR
# every command from every client is printed:
# 1700000000.123456 [0 10.0.0.1:12345] "SET" "key" "value"
# 1700000000.123567 [0 10.0.0.1:12345] "GET" "key"

# format: <unix_time> [<db> <addr>] "<cmd>" "<arg>" ...
# the [0 ...] shows which database and client

# to stop monitoring: Ctrl+C or send any command

# filter for specific patterns (in another terminal):
redis-cli MONITOR | grep "SET"
redis-cli MONITOR | grep "10.0.0.1"
redis-cli MONITOR | grep -E "(SET|DEL)"

# WARNING: MONITOR roughly halves throughput
# use only for debugging, never in production

# safer alternatives:
# - SLOWLOG (only slow commands)
# - INFO commandstats (command frequency)
# - LATENCY MONITOR (latency events)

Мониторинг LATENCY

LATENCY MONITOR отслеживает всплески задержек по типам событий. Задайте порог (например, 100 мс), и Redis будет записывать события, его превысившие. LATENCY DOCTOR анализирует недавние события и предлагает исправления — отличная отправная точка для диагностики. LATENCY GRAPH показывает ASCII-таймлайн. Частые виновники: 'fork' (BGSAVE на больших данных), 'expire-cycle' (массовое истечение), 'aof-fsync-always' (fsync AOF). Задайте порог под свой SLO и следите регулярно.

redis-cli
# enable latency monitoring (threshold in ms)
CONFIG SET latency-monitor-threshold 100   # 100ms

# view recent latency events
LATENCY LATEST
# event, timestamp, last latency, max latency

# history of an event
LATENCY HISTORY command
LATENCY HISTORY expire-cycle
LATENCY HISTORY fork

# ASCII art graph
LATENCY GRAPH command

# human-readable diagnosis and recommendations
LATENCY DOCTOR

# reset latency data
LATENCY RESET
LATENCY RESET command

# common events:
#   command         slow commands (over threshold)
#   fast-command    slow O(1)/O(log N) commands
#   expire-cycle    key expiration sweep too slow
#   fork            BGSAVE/BGREWRITEAOF fork delay
#   aof-fsync-always  AOF fsync delay
#   unlink          async delete delay

# check threshold
CONFIG GET latency-monitor-threshold

MEMORY DOCTOR и STATS

MEMORY USAGE сообщает байты для одного ключа (SAMPLES 0 для полной точности). MEMORY STATS даёт подробную статистику аллокатора. MEMORY DOCTOR выполняет автоматическую диагностику (ищет фрагментацию, большие ключи и т. п.). Следите за mem_fragmentation_ratio: >1.5 — потери памяти из-за фрагментации, <1 — Redis свопится (катастрофа для задержек). MEMORY PURGE пытается вернуть память ОС. Активная дефрагментация (4.0+) автоматически возвращает фрагментированную память.

redis-cli
# MEMORY USAGE: bytes used by a single key
MEMORY USAGE mykey
MEMORY USAGE bigset SAMPLES 0   # exact (default samples for large keys)

# MEMORY STATS: detailed allocator stats
MEMORY STATS

# MEMORY DOCTOR: automated memory diagnosis
MEMORY DOCTOR

# MEMORY MALLOC-STATS: low-level allocator stats (jememalloc)
MEMORY MALLOC-STATS

# check total memory used
INFO memory | grep used_memory_human

# key metrics to watch:
#   used_memory             logical bytes used
#   used_memory_rss         RSS from OS (real footprint)
#   used_memory_peak        peak usage
#   mem_fragmentation_ratio >1.5 = fragmentation, <1 = swapping (bad!)

# MEMORY PURGE: attempt to free memory back to OS
MEMORY PURGE

# active defragmentation (4.0+)
CONFIG SET activedefrag yes

Команды DEBUG

Команды DEBUG — для диагностики и тестирования, используйте осторожно. DEBUG SLEEP проверяет, как приложение переживает задержки (блокирует сервер). DEBUG OBJECT показывает внутреннюю кодировку ключа и refcount. DEBUG RELOAD сохраняет, очищает и перезагружает набор данных (полезно для проверки сохранения). Они мощные, но опасные — ограничьте их через ACL в продакшене (категории -@admin или -@dangerous). Никогда не запускайте DEBUG на продакшен-мастере, не понимая последствий.

redis-cli
# DEBUG SLEEP: block the server for N seconds (testing only!)
DEBUG SLEEP 2             # blocks for 2 seconds (testing latency)

# DEBUG OBJECT: raw internal info about a key
DEBUG OBJECT mykey
# Value at:0x7f... refcount:1 encoding:embstr serializedlength:12 ...

# DEBUG SET-ACTIVE-EXPIRE: toggle expiration sweeps
DEBUG SET-ACTIVE-EXPIRE 0  # disable expiration sweeps (debugging)
DEBUG SET-ACTIVE-EXPIRE 1  # re-enable

# DEBUG JMAP: memory map (jemalloc)
DEBUG JMAP

# DEBUG CHANGE-REPL-ID: change replication ID (advanced)
DEBUG CHANGE-REPL-ID

# DEBUG RELOAD: save RDB, flush, reload from RDB (testing)
DEBUG RELOAD

# DEBUG LOADAOF: reload from AOF (testing)
DEBUG LOADAOF

# WARNING: DEBUG commands can be dangerous
# use ACL to restrict them in production:
# ACL SETUSER default -@admin

redis-cli --latency

redis-cli --latency непрерывно измеряет round-trip — необходимо для базовой оценки сети. --latency-history ведёт скользящую статистику каждые 15 с (меняется через -i). --latency-dist показывает гистограмму (визуализирует джиттер и хвостовую задержку). В режиме кластера проверяйте задержку до каждого узла отдельно. Зафиксируйте базовую линию, затем следите за всплесками. Задержка >1 мс на localhost указывает на проблему (CPU, давление на память или медленные команды).

redis-cli
# continuous latency measurement (round-trip time)
redis-cli --latency
# output: min: 0, max: 1, avg: 0.27 (3421 samples)

# latency history (rolling, every N seconds)
redis-cli --latency-history
# default interval: 15 seconds
# output: min: 0, max: 2, avg: 0.31 (1500 samples) -- 15.01 seconds

# custom interval (1 second)
redis-cli --latency-history -i 1

# latency distribution (histogram)
redis-cli --latency-dist
# shows a visual histogram of latency distribution

# latency to a remote host
redis-cli -h remote-host --latency

# use cases:
# - baseline your network latency
# - detect network issues (jitter, spikes)
# - compare latency before/after config changes
# - monitor latency over time with --latency-history

# for cluster mode, check latency to each node:
redis-cli -h node1 -p 7000 --latency &
redis-cli -h node2 -p 7000 --latency &

redis-cli --stat

redis-cli --stat — это как 'top' для Redis: он обновляет сводку по ключам, памяти, клиентам, заблокированным клиентам, запросам в секунду и соединениям. Прибавка (+N) рядом с запросами показывает изменение с прошлого сэмпла. Используйте для быстрых проверок здоровья и поиска аномалий (рост памяти, утечка клиентов, всплеск запросов). Колонка 'child' показывает, запущен ли дочерний процесс BGSAVE/BGREWRITEAOF.

redis-cli
# --stat: continuous server stats (like top for Redis)
redis-cli --stat
# output (refreshes every second):
# ------- data ------ --------------------- load -------------------- - child -
# keys       mem      clients blocked requests            connections
# 1000       1.50M    50      0       12345 (+12)         1000

# --stat shows:
#   keys       total keys in the db
#   mem        memory usage
#   clients    connected clients
#   blocked    blocked clients (BLPOP, etc.)
#   requests   total requests (+N since last sample)
#   connections total connections since start
#   child      child process info (BGSAVE/BGREWRITEAOF)

# custom interval (every 5 seconds)
redis-cli --stat -i 5

# monitor a remote server
redis-cli -h host --stat

# use cases:
# - quick health check (are clients/memory/keys growing?)
# - spot traffic spikes (requests/second)
# - monitor during load tests
# - detect connection leaks (clients increasing steadily)

# combine with --no-raw for machine-readable output
18

Безопасность

AUTH (устаревший пароль)

AUTH — устаревшая аутентификация одним паролем (до Redis 6). В Redis 6+ используйте пользователей ACL (AUTH username password). Флаг -a раскрывает пароль в истории shell — предпочитайте переменную окружения REDISCLI_AUTH. Всегда используйте надёжные пароли (64+ случайных символов). В продакшене сочетайте AUTH с TLS, сетевыми ограничениями (bind/файрвол) и минимальными правами на основе ACL для эшелонированной защиты.

redis-cli
# set a password (simple, legacy)
CONFIG SET requirepass "strongpassword"

# authenticate (legacy, before Redis 6)
AUTH "strongpassword"
# OK

# authenticate as a specific user (Redis 6+ ACL)
AUTH appuser "secretpassword"
# OK

# connect with password via CLI
redis-cli -a "strongpassword"
redis-cli -a "strongpassword" --no-auth-warning  # suppress warning

# safer: use environment variable
export REDISCLI_AUTH="strongpassword"
redis-cli   # reads REDISCLI_AUTH automatically

# remove password
CONFIG SET requirepass ""

# AUTH returns ERR if the password is wrong
# after AUTH, all commands work normally

ACL SETUSER

ACL в Redis 6+ заменяют модель с одним паролем — создавайте пользователей с ограниченными правами. Синтаксис: on (включён), >password, ~pattern (шаблоны ключей), +command/-command, +@category/-@category (например, +@read, -@dangerous). Всегда создавайте пользователя с минимальными правами для каждого приложения. Пользователь default существует всегда — задайте ему надёжный пароль или ограничьте его. Сохраняйте ACL в файл (ACL SAVE) для персистентности.

redis-cli
# Redis 6+: ACL system with users and permissions
# create a user with limited access
ACL SETUSER appuser on >secretpassword ~app:* +get +set +del -@dangerous
# on = enabled
# >password = set password
# ~pattern = key patterns this user can access
# +command = allowed commands
# -command = denied commands
# +@category / -@category = allow/deny command categories

# categories: @read, @write, @admin, @dangerous, @keyspace, @connection, etc.

# create a read-only user
ACL SETUSER readonly on >pass ~* +@read -@dangerous

# create an admin user
ACL SETUSER admin on >adminpass ~* +@all

# create a user for a specific app (restricted keys)
ACL SETUSER app1 on >pass ~app1:* +@read +@write +@connection -@dangerous

# the default user (always exists)
ACL SETUSER default on >defaultpass ~* +@all -@dangerous

ACL LIST и GETUSER

ACL LIST показывает всех пользователей в компактном формате правил. ACL GETUSER даёт подробные права одного пользователя (включая хеши паролей, разрешённые и запрещённые команды, шаблоны ключей). ACL WHOAMI возвращает текущего пользователя. ACL LOG (7.0+) записывает отклонённые команды и неудачные аутентификации — полезно для аудита безопасности. ACL SAVE/LOAD управляют файлом ACL для сохранности между перезапусками.

redis-cli
# list all users (compact rules)
ACL LIST
# 1) "user default on nopass ~* +@all"
# 2) "user appuser on #abc123... ~app:* +get +set +del -@dangerous"

# view a user's detailed permissions
ACL GETUSER appuser
# flags, passwords, commands, keys, channels, selectors

# view current user
ACL WHOAMI
# "appuser"

# view all users (just names, 7.0+)
ACL USERS

# delete a user
ACL DELUSER appuser

# save ACLs to a file (persists across restarts)
ACL SAVE

# reload ACLs from file
ACL LOAD

# aclfile in redis.conf:
#   aclfile /etc/redis/users.acl

# view current user's rules
ACL LOG        # security audit log (7.0+)
ACL LOG RESET  # clear the audit log

ACL WHOAMI и DELUSER

ACL WHOAMI определяет текущего пользователя. ACL DELUSER удаляет пользователя (и отключает его активные соединения). Перевод пользователя в 'off' временно отключает его, не удаляя правила, — удобно для приостановки доступа. ACL LOG записывает события безопасности (отклонённые команды, неудачную аутентификацию) — следите за подозрительной активностью. Регулярно меняйте пароли через ACL SETUSER >newpass.

redis-cli
# get the current authenticated user
ACL WHOAMI
# "appuser"

# switch user (re-authenticate)
AUTH adminuser "adminpass"
ACL WHOAMI
# "adminuser"

# delete a user (disconnects their clients)
ACL DELUSER tempuser

# temporarily disable a user (keeps the rules, blocks login)
ACL SETUSER appuser off
# the user cannot authenticate, but their rules are preserved
# re-enable:
ACL SETUSER appuser on

# rotate a user's password
ACL SETUSER appuser >newpassword

# remove a user's password
ACL SETUSER appuser <secretpassword  # remove this password
# or remove all passwords:
ACL SETUSER appuser resetpass

# view the audit log (denied commands, auth failures)
ACL LOG
ACL LOG COUNT 5  # last 5 entries
ACL LOG RESET    # clear the log

rename-command (отключение команд)

rename-command (в redis.conf) отключает или переименовывает опасные команды: пустая строка "" отключает, строка задаёт новое имя. Требует перезапуска (не меняется на лету). В Redis 6+ предпочитайте ACL (-flushall, -@dangerous), которые меняются на лету и работают по пользователям. Команды, которые стоит ограничить: FLUSHALL/FLUSHDB (потеря данных), KEYS (блокирует сервер), CONFIG (безопасность), DEBUG (может уронить), SHUTDOWN (останавливает сервер).

redis-cli
# rename or disable dangerous commands (in redis.conf)
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG "CONFIG_9f8a7b"
rename-command KEYS ""
rename-command DEBUG ""
rename-command SHUTDOWN "SHUTDOWN_7x9y"

# "" completely disables the command (returns error)
# a string renames it (must use the new name)

# Redis 6+: prefer ACLs instead of rename-command
# ACL SETUSER default -flushall -config -keys -@dangerous

# view available commands (after rename/restrictions)
COMMAND

# note: rename-command requires a restart (not changeable at runtime)
# ACLs are runtime-changeable and more flexible

# dangerous commands to restrict:
#   FLUSHALL, FLUSHDB  - delete all data
#   KEYS               - blocks server
#   CONFIG             - can change security settings
#   DEBUG              - can crash the server
#   SHUTDOWN           - stops the server
#   MONITOR            - performance impact

Шифрование TLS/SSL

TLS шифрует данные в пути — обязательно для продакшена, особенно в недоверенных сетях. Redis 6+ поддерживает TLS нативно. mTLS (tls-auth-clients yes) требует от клиентов сертификат, давая взаимную аутентификацию без паролей. Для кластера и sentinel включите TLS и на межунтовом обмене. Порт 0 отключает открытый текст; при миграции временно держите оба порта. В продакшене всегда используйте сертификаты, подписанные надёжным CA.

redis-cli
# enable TLS in redis.conf (Redis 6+)
port 0                       # disable plain-text port
tls-port 6379
tls-cert-file /etc/redis/redis.crt
tls-key-file /etc/redis/redis.key
tls-ca-cert-file /etc/redis/ca.crt

# connect with TLS
redis-cli --tls --cert client.crt --key client.key \
  --cacert ca.crt -h host -p 6379

# mutual TLS (mTLS) for client authentication
tls-auth-clients yes         # require client certs
tls-auth-clients no          # don't require (default)
tls-auth-clients optional    # verify if provided

# TLS for cluster and replication
tls-cluster yes              # TLS between cluster nodes
tls-replication yes          # TLS between primary/replica

# mix TLS and plain text (transition period)
# port 6380
# tls-port 6379

# generate self-signed certs for testing:
# openssl req -x509 -newkey rsa:4096 -keyout redis.key \
#   -out redis.crt -days 365 -nodes
19

Импорт и экспорт данных

redis-cli --rdb (резервная копия)

redis-cli --rdb делает онлайн-бэкап: он передаёт RDB в файл, не трогая файловую систему сервера напрямую. Это неблокирующе (использует фоновый форк BGSAVE) и безопасно для продакшена. В связке с SSH можно сделать бэкап удалённого Redis в локальный файл. Проверяйте копии через redis-check-rdb. Планируйте регулярные бэкапы через cron. Всегда проверяйте процедуру восстановления — непроверенный бэкап не является бэкапом.

redis-cli
# dump the RDB snapshot to a file (online backup)
redis-cli --rdb /backup/dump.rdb
# Output: RDB file written to /backup/dump.rdb

# dump RDB to a remote host's file (via SSH):
ssh remote-host "redis-cli --rdb /tmp/dump.rdb"

# the --rdb flag:
# - connects to Redis and requests a BGSAVE
# - streams the RDB to the specified file
# - non-blocking (uses the background fork)
# - safe to run on a production server

# verify the RDB file
redis-check-rdb /backup/dump.rdb

# restore: stop Redis, replace dump.rdb, restart
redis-cli SHUTDOWN
cp /backup/dump.rdb /var/lib/redis/dump.rdb
redis-server /etc/redis/redis.conf

# schedule regular backups:
# 0 2 * * * redis-cli --rdb /backup/dump-$(date +\%F).rdb

redis-cli --pipe (массовая вставка)

redis-cli --pipe — самый быстрый способ массовой загрузки данных в Redis: он передаёт сырой RESP и не ждёт ответов до конца. Генерируйте RESP через printf или скрипт. --pipe сообщает об ошибках и общем числе ответов. Для простых и небольших загрузок подойдёт передача текстовых команд (echo | redis-cli), но это медленнее. Всегда замеряйте: --pipe загружает миллионы ключей за минуты. Следите за памятью при больших загрузках.

redis-cli
# --pipe: bulk load raw RESP data (fastest method)
# generate RESP and pipe it:

# example: bulk SET commands (bash)
for i in $(seq 1 100000); do
  printf '*3\r\n$3\r\nSET\r\n$%d\r\nkey:%d\r\n$%d\r\nvalue%d\r\n' \
    $((4 + ${#i})) $i $((5 + ${#i})) $i
done | redis-cli --pipe

# simpler text mode (slower but easier):
for i in $(seq 1 100000); do
  echo "SET key:$i value$i"
done | redis-cli

# --pipe mode output:
# All data transferred. Waiting for the last reply...
# Last reply received from server.
# errors: 0, replies: 100000

# prepare RESP from a CSV/data file:
# (each line: key,value)
while IFS=, read -r key value; do
  printf '*3\r\n$3\r\nSET\r\n$%d\r\n%s\r\n$%d\r\n%s\r\n' \
    ${#key} "$key" ${#value} "$value"
done < data.csv | redis-cli --pipe

DUMP и RESTORE

DUMP сериализует значение ключа в бинарный блоб (с типом и значением, но без TTL — TTL указывайте в RESTORE в миллисекундах). RESTORE десериализует его в ключ и работает между разными инстансами Redis (отлично для миграций). Формат сериализации зависит от версии — блоб из Redis 4.x может не загрузиться в 7.x; всегда проверяйте совместимость. Для копий внутри инстанса предпочитайте нативную команду COPY (6.2+) вместо DUMP+RESTORE.

redis-cli
# DUMP: serialize a key's value (binary blob)
DUMP mykey
# returns a serialized blob (binary, includes type + value + TTL info)

# RESTORE: deserialize into a key
RESTORE newkey 0 <serialized_blob>
# 0 = no TTL (milliseconds); set a TTL otherwise
RESTORE newkey 3600000 <blob>   # 1 hour TTL
RESTORE newkey 0 <blob> REPLACE  # overwrite if exists

# copy a key (6.2+ does this natively with COPY)
# manual copy via DUMP + RESTORE:
SET source "value"
blob = DUMP source
RESTORE dest 0 blob

# DUMP/RESTORE preserve the type but NOT the TTL
# (TTL must be specified in RESTORE)

# DUMP/RESTORE work across different Redis instances
# (migrate data between servers)

# note: serialized format is version-specific
# a blob from Redis 4.x may not load in 7.x — verify compatibility

# use COPY (6.2+) instead for in-instance copies:
COPY source dest                # copy without TTL
COPY source dest REPLACE        # overwrite destination
COPY source dest DB 1           # copy to another database
COPY source dest REPLACE DB 1   # both

MIGRATE (перенос между серверами)

MIGRATE атомарно переносит (или копирует) ключ между инстансами Redis — ключ никогда не находится в обоих местах одновременно (атомарно). Это строительный блок решардинга кластера. COPY сохраняет исходный ключ; по умолчанию он удаляется. REPLACE перезаписывает существующий целевой ключ. Для нескольких ключей передайте пустую строку как ключ и перечислите их через KEYS. Задавайте таймаут с запасом для больших значений. MIGRATE блокирует обе стороны на время передачи.

redis-cli
# MIGRATE: atomically move a key from one Redis to another
# syntax: MIGRATE host port key|"" dest-db timeout [COPY] [REPLACE]
#         [AUTH password] [KEYS key1 key2 ...]

# move a single key (default: deletes from source after copy)
MIGRATE 192.168.1.20 6379 mykey 0 5000
# host, port, key, dest-db, timeout-ms

# copy without deleting from source
MIGRATE 192.168.1.20 6379 mykey 0 5000 COPY

# overwrite if the key exists on destination
MIGRATE 192.168.1.20 6379 mykey 0 5000 REPLACE

# migrate multiple keys (pass "" as the key, then KEYS ...)
MIGRATE 192.168.1.20 6379 "" 0 5000 KEYS key1 key2 key3

# authenticate with the destination
MIGRATE 192.168.1.20 6379 mykey 0 5000 AUTH destpassword

# MIGRATE is atomic: the key appears on exactly one instance at any moment
# timeout is in milliseconds — large keys need longer timeouts
# returns NOKEY if the key doesn't exist on source

COPY (копия внутри инстанса)

COPY (6.2+) атомарно дублирует ключ внутри одного инстанса — гораздо проще, чем DUMP+RESTORE. По умолчанию TTL НЕ копируется (примените EXPIRE после этого). COPY работает между базами с опцией DB. REPLACE перезаписывает существующий целевой ключ. Для копирования между инстансами используйте MIGRATE (он атомарен по сети). COPY — современная замена паттерну DUMP+RESTORE для дублирования внутри инстанса.

redis-cli
# COPY: duplicate a key within the same instance (6.2+)
COPY source dest               # copy value (no TTL by default)
COPY source dest REPLACE       # overwrite destination if it exists
COPY source dest DB 1          # copy to another database
COPY source dest REPLACE DB 1  # both options

# before COPY existed, you needed DUMP + RESTORE:
SET src "hello"
blob = DUMP src
RESTORE dst 0 blob

# COPY preserves the type (string, list, hash, ...)
SET mystr "hello"
COPY mystr mystr_copy
TYPE mystr_copy               # "string"

# COPY does NOT copy TTL by default — use after EXPIRE if needed
SET temp "data" EX 3600
COPY temp temp_copy
TTL temp_copy                 # -1 (no TTL)
EXPIRE temp_copy 3600         # set TTL manually

# COPY is atomic and never blocks (unlike DUMP on huge keys)

redis-check-rdb и redis-check-aof

redis-check-rdb и redis-check-aof проверяют целостность файлов сохранения — всегда запускайте их на резервных копиях перед восстановлением. redis-check-aof --fix восстанавливает усечённый AOF, удаляя неполный хвост (спрашивает подтверждение). Redis 7 использует многочастный AOF (база + инкременты) — проверяйте файл манифеста. Эти инструменты только читают, кроме --fix, поэтому их безопасно запускать в любое время. Проверяйте резервные копии скрупулёзно — непроверенная копия не является бэкапом.

redis-cli
# verify the integrity of an RDB file (offline, safe)
redis-check-rdb /var/lib/redis/dump.rdb
# outputs: [offset] Checksum OK | CRC error | file truncated

# verify an AOF file
redis-check-aof /var/lib/redis/appendonly.aof
# outputs: AOF analyzed: size=... ok_up_to=... ok_up_to_line=...

# fix a truncated AOF (interactive prompt)
redis-check-aof --fix /var/lib/redis/appendonly.aof

# Redis 7 multi-part AOF: check the manifest
redis-check-aof --manifest /var/lib/redis/appendonlydir/appendonly.aof.manifest

# truncate an RDB to a specific offset (recovery)
redis-check-rdb --fix /var/lib/redis/dump.rdb

# use cases:
# - verify a backup before restore
# - diagnose corruption after a crash
# - recover from a truncated AOF (removes the incomplete tail)
# - validate files copied across servers

# always run these checks BEFORE replacing production data files
20

Тестирование производительности

Основы redis-benchmark

redis-benchmark — встроенный инструмент нагрузочного тестирования Redis: он имитирует параллельных клиентов и сообщает пропускную способность (запросов/с) и перцентили задержки. -t выбирает тесты (PING, SET, GET, INCR и т. д.); -n задаёт число запросов; -d — размер полезной нагрузки. Всегда замеряйте на железе, эквивалентном продакшену, чтобы зафиксировать базовую производительность. 50 параллельных клиентов по умолчанию — лишь отправная точка; подберите -c под реальную нагрузку. Запускайте бенчмарки до и после изменений конфигурации, чтобы измерить эффект.

redis-cli
# redis-benchmark: built-in performance benchmarking tool
# runs commands against a Redis server and reports throughput/latency

# default benchmark (50 parallel clients, 100000 requests)
redis-benchmark
# default commands: PING, SET, GET, INCR, LPUSH, RPUSH, LPOP, RPOP,
#   SADD, HSET, SPOP, ZADD, ZPOPMIN, LRANGE_100, LRANGE_300, ...

# run a specific command only
redis-benchmark -t set,get -n 100000
# -t = test (comma-separated commands)
# -n = number of requests

# test a specific command with custom data
redis-benchmark -t set -n 100000 -d 100
# -d = data size in bytes (default 3)

# output example:
# ====== SET ======
#   100000 requests completed in 0.85 seconds
#   50 parallel clients
#   3 bytes payload
#   keep alive: 1
#   98.90% <= 1 milliseconds
#   100.00% <= 1 milliseconds
#   117647.05 requests per second

# run against a remote server with auth
redis-benchmark -h host -p 6379 -a password -t set,get -n 100000

Настройка пайплайна и конкурентности

Два главных рычага пропускной способности — -c (конкурентность) и -P (размер пайплайна). -c увеличивает число параллельных клиентов (больше запросов в полёте); -P объединяет команды в один round-trip (меньше сетевых накладных расходов). Вместе они могут поднять пропускную способность в 10–20 раз. Бенчмарк с одним клиентом (-c 1) измеряет чистую задержку; многоклиентский — пропускную способность. Большие нагрузки (-d) смещают узкое место в сетевую полосу. Подбирайте -c/-P под поведение вашей клиентской библиотеки.

redis-cli
# -c = number of parallel connections (clients)
redis-benchmark -t set -n 100000 -c 50     # default: 50 clients
redis-benchmark -t set -n 100000 -c 200    # 200 concurrent clients
redis-benchmark -t set -n 100000 -c 1      # single client (latency focus)

# -P = pipeline size (commands per round-trip)
redis-benchmark -t set -n 100000 -P 1      # no pipelining (baseline)
redis-benchmark -t set -n 100000 -P 16     # pipeline 16 commands
redis-benchmark -t set -n 100000 -P 100    # pipeline 100 commands

# combine -c and -P for max throughput
redis-benchmark -t set -n 100000 -c 50 -P 16

# typical results (localhost, small values):
#   -c 1  -P 1   -> ~100k req/s  (latency-bound)
#   -c 50 -P 1   -> ~600k req/s  (concurrency)
#   -c 50 -P 16  -> ~2M req/s    (pipelining)

# test with a larger payload (network-bound)
redis-benchmark -t set -n 100000 -d 1024   # 1KB values
redis-benchmark -t set -n 100000 -d 65536  # 64KB values

Перцентили задержки и вывод CSV

Всегда смотрите на перцентили задержки (P50, P99, P99.9), а не только на средние: средние скрывают хвостовые всплески, которые портят опыт пользователей. P99 в 5 раз хуже P50 указывает на джиттер (GC, сеть или медленные команды). --csv выдаёт машиночитаемые результаты для отслеживания трендов. Сохраняйте бенчмарки до и после изменений конфигурации, чтобы объективно измерять эффект. Следите за P99 и запросами/с вместе — оптимизация одного за счёт другого — частая ловушка.

redis-cli
# --csv: CSV output (easy to parse / log)
redis-benchmark -t set,get -n 100000 --csv
# output: "test","rps","avg_latency_ms","min_latency_ms",...
# "SET","117647.05","0.284","0.144"
# "GET","125000.00","0.272","0.136"

# --precision: set decimal places for latency
redis-benchmark -t set -n 100000 --precision 4

# latency percentiles (Redis 6+):
# the default output shows "X% <= Y milliseconds" lines
# ====== SET ======
#   50.00% <= 0.239 milliseconds
#   99.00% <= 0.511 milliseconds
#   99.90% <= 1.023 milliseconds
#   100.00% <= 1.519 milliseconds

# focus on tail latency (P99, P99.9) — average hides outliers
# P99 > 5x P50 indicates jitter or GC pauses

# save results to a file for comparison
redis-benchmark -t set,get -n 100000 --csv > bench-$(date +%F).csv

# compare two runs (before/after a config change)
diff bench-2025-01-01.csv bench-2025-01-02.csv

Бенчмарк кластера и Lua

Режим --cluster распределяет ключи по слотам кластера — необходим для реалистичного бенчмарка кластера (одноузловые тесты не учитывают накладные расходы маршрутизации между слотами). -r задаёт размер случайного пространства ключей (берите большое значение, иначе все операции бьют в один ключ, завышая цифры за счёт кэширования в памяти). --eval замеряет Lua-скрипты. --threads (Redis 6+) использует несколько потоков бенчмарка — полезно, когда один поток не создаёт достаточной нагрузки для насыщения сервера. Всегда используйте -r для реалистичных цифр.

redis-cli
# benchmark a Redis Cluster (redis-benchmark supports cluster mode)
redis-benchmark --cluster -h node1 -p 7000 -t set,get -n 100000
# automatically distributes keys across cluster slots

# cluster mode with multiple nodes
redis-benchmark --cluster -h node1 -p 7000 -h node2 -p 7000 \
  -t set,get -n 100000 -c 50

# benchmark a Lua script (--eval)
redis-benchmark -n 100000 eval "return redis.call('SET', KEYS[1], ARGV[1])" 0 mykey hello
# note: key and args are positional after the script

# benchmark with random keys (--random-data + keyspace length)
redis-benchmark -t set -n 100000 -r 1000000
# -r 1000000 = random keys from a 1M keyspace (SET key:RAND_INT value)
# avoids hitting the same key (tests real-world distribution)

# use a random payload (not the same bytes each time)
redis-benchmark -t set -n 100000 -r 1000000 -d 100 --random-data

# only run the benchmark for a fixed time (seconds)
redis-benchmark -t set --threads 4 -n 100000
# --threads (6+) uses multiple threads (default 1, doesn't help single-core)

--idle и прогрев

--idle измеряет чистые накладные расходы соединения и сети только на PING — базовая линия, которую не побить. Всегда прогревайте сервер перед измерением (холодные кэши занижают производительность): сначала прогоните пробный бенчмарк, затем измеряемый. --loop работает непрерывно (полезно для длительной нагрузки). --seed делает случайное пространство ключей воспроизводимым — необходимо для A/B-сравнений. --dbnum выбирает базу (используйте отдельную базу, чтобы не засорять продакшен-данные во время бенчмарка).

redis-cli
# --idle: only send PINGs (no commands) — measure pure connection overhead
redis-benchmark -t ping -n 100000 --idle
# useful for measuring connection / network baseline latency

# --dbnum: select a specific database
redis-benchmark -t set -n 100000 --dbnum 1

# --clients: same as -c (alias)
redis-benchmark -t set -n 100000 --clients 100

# warm up the server before measuring (avoid cold-start bias)
redis-benchmark -t set -n 10000   # warmup run (discard results)
redis-benchmark -t set -n 100000  # measured run

# --loop: run the benchmark forever (Ctrl+C to stop)
redis-benchmark -t set -n 100000 --loop

# --seed: reproducible random keys (same -r sequence every run)
redis-benchmark -t set -n 100000 -r 1000000 --seed 42

# benchmark with a specific client socket buffer
redis-benchmark -t set -n 100000 --numdatadb 1

Интерпретация бенчмарков и ловушки

Ловушки бенчмарков завышают цифры нереалистично: (1) тесты только на localhost не учитывают сетевую задержку; (2) без -r все операции бьют в один ключ (завышение за счёт кэширования); (3) крошечные нагрузки не нагружают память и сеть; (4) игнорирование накладных расходов сохранения (fsync AOF может снизить пропускную способность в 2–5 раз); (5) один поток бенчмарка не насыщает многоядерный сервер. Реалистичный бенчмарк использует -r (случайные ключи), -d (реалистичная нагрузка), --threads (многопоточный клиент) и тестирует с продакшен-эквивалентными настройками сохранения и сети. Всегда указывайте параметры бенчмарка, когда делитесь цифрами.

redis-cli
# COMMON PITFALL #1: benchmarking localhost only
# localhost numbers don't reflect real network latency
# always test over your production network path

# COMMON PITFALL #2: all keys the same (no -r)
# redis-benchmark -t set -n 100000
#   -> all SETs hit "key:0" — inflated by in-memory caching
# FIX: use -r to randomize keys
redis-benchmark -t set -n 100000 -r 1000000

# COMMON PITFALL #3: tiny payloads only
# 3-byte values don't reflect real memory/network pressure
# test with realistic sizes
redis-benchmark -t set -n 100000 -d 256 -r 1000000

# COMMON PITFALL #4: ignoring persistence overhead
# benchmark with AOF on vs off to see the durability cost:
redis-benchmark -t set -n 100000   # with current persistence settings
# (then) CONFIG SET appendonly no
redis-benchmark -t set -n 100000   # without AOF — compare

# COMMON PITFALL #5: single-threaded benchmark client
# one benchmark thread may not generate enough load
redis-benchmark -t set -n 100000 --threads 4 -c 100

# GOOD BENCHMARK (realistic):
redis-benchmark -t set,get -n 1000000 -c 50 -P 16 -r 1000000 -d 100 --threads 4 --csv

Связанные сниппеты Redis CLI

Copy-paste ready code for common tasks.

Подключение: URL, TLS, AUTH и SELECT

Подключение к автономному экземпляру, TLS, с аутентификацией или к нестандартному индексу DB.

Интерактивный режим, HELP и интроспекция

Навигация в REPL, поиск команд и интроспекция сервера.

MULTI / EXEC / WATCH (Транзакции)

Атомарная постановка команд в очередь и оптимистичная блокировка через WATCH.

Pub/Sub: SUBSCRIBE, PUBLISH и PSUBSCRIBE

Фан-аут обмен сообщениями через каналы и подписки по шаблону.

MONITOR, SLOWLOG и отладка задержек

Наблюдение за каждой командой в реальном времени и поиск медленных запросов.

EVAL, Lua и статистика Function (Серверный скриптинг)

Запуск атомарных серверных Lua-скриптов; загрузка и вызов функций.

Персистентность RDB / AOF и резервное копирование

Запуск снимков, управление перезаписью AOF и создание безопасного бэкапа.

Пользователи ACL и операции с кластером

Управление пользователями ACL, инструментами redis-check и resharding кластера.

Was this helpful?