Skip to content

Redis Шпаргалка

Хранилище данных в памяти, используемое как база данных, кэш и брокер сообщений.

01

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

Подключение к Redis

redis-cli — стандартный клиент командной строки. PING проверяет соединение (возвращает PONG). В продакшене всегда используйте команду AUTH или флаг -a. Не передавайте пароли в командной строке в общих средах — вместо этого используйте переменную окружения REDISCLI_AUTH. Современный Redis (6+) поддерживает пользователей на основе ACL с ограниченными правами.

redis
# connect to a local server (default port 6379)
redis-cli

# connect with a specific host and port
redis-cli -h host.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

# test the connection
PING          # returns PONG
PING "hello"  # returns "hello"

Выбор базы и основы

Базы Redis — это логические пространства имён (с номерами 0–15), а не изолированные схемы: они делят одну память. Большинство приложений используют только db 0. FLUSHDB очищает текущую базу; FLUSHALL очищает всё. От нескольких баз лучше отказаться в пользу отдельных инстансов Redis или префиксов ключей, так как они делят один поток и не настраиваются по отдельности.

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

# get basic server info
INFO server
INFO memory
INFO replication

Ключи и общие операции

KEYS блокирует сервер на время сканирования — никогда не используйте её в продакшене на больших наборах данных; применяйте SCAN (на основе курсора, без блокировки). Ключи стоит структурировать через двоеточия (user:1:profile) для читаемости. EX задаёт время жизни в секундах, PX — в миллисекундах. TYPE возвращает структуру данных (string, list, hash, set, zset, stream).

redis
# set and get a key
SET user:1 "Alice"
GET user:1

# check if a key exists
EXISTS user:1          # 1 if exists, 0 if not

# delete keys
DEL user:1
DEL key1 key2 key3     # returns number deleted

# set a key with expiration (seconds)
SET session:abc "data" EX 3600

# find keys matching a pattern (avoid in production)
KEYS user:*
SCAN 0 MATCH user:* COUNT 100   # safer iteration

# rename a key
RENAME oldkey newkey

# get the type of a value stored at a key
TYPE user:1

Срок жизни и TTL

TTL возвращает -2 для несуществующих ключей и -1 для ключей без срока жизни. Истечение ленивое: Redis проверяет его при обращении к ключу или во время периодических фоновых обходов. SET с EX атомарен (нет гонки между SET и EXPIRE). Просроченные ключи по умолчанию не порождают событий; включите keyspace-уведомления, если они нужны.

redis
# set expiration on an existing key
EXPIRE user:1 60        # 60 seconds
EXPIREAT user:1 1700000000  # Unix timestamp

# set expiration in milliseconds
PEXPIRE user:1 60000

# view remaining time to live (seconds)
TTL user:1              # -2 if no key, -1 if no expiry

# view TTL in milliseconds
PTTL user:1

# remove expiration (make key persistent)
PERSIST user:1

# set value AND expiration atomically
SET token "abc" EX 3600

SCAN и безопасный перебор

SCAN — безопасная для продакшена альтернатива KEYS: она возвращает курсор, по которому вы идёте до 0. COUNT — это подсказка, а не точное значение (может вернуть больше или меньше). SCAN даёт слабые гарантии: возможны дубликаты или пропуск ключей, добавленных во время перебора, но она никогда не блокирует. Для коллекций используйте HSCAN/SSCAN/ZSCAN. Всегда обрабатывайте цикл по курсору в своём коде.

redis
# SCAN: cursor-based iteration (non-blocking)
SCAN 0 MATCH user:* COUNT 100
# returns: [nextCursor, [key1, key2, ...]]
SCAN <nextCursor> MATCH user:* COUNT 100
# continue until cursor returns to 0

# scan a specific type
SCAN 0 TYPE hash

# HSCAN: iterate hash fields
HSCAN myhash 0 MATCH field* COUNT 100

# SSCAN: iterate set members
SSCAN myset 0 MATCH member* COUNT 100

# ZSCAN: iterate sorted set members
ZSCAN myzset 0 MATCH member* COUNT 100
02

Обзор типов данных

Основные структуры данных

Выбор правильной структуры данных — ключевой навык в Redis. Строки для счётчиков и кэшей, хеши для объектов, списки для очередей, множества для уникальности и тегов, сортированные множества для рейтингов, потоки для журналов событий. Каждая операция над структурой атомарна, поэтому параллельные клиенты не могут испортить состояние. Выбирайте структуру под свой паттерн доступа.

redis
# Redis is a data structure server, not just a key-value store
# Each key holds a typed data structure:

# String: binary-safe blob (up to 512MB)
SET key "value"
SET counter 100

# List: ordered, linked-list of strings
LPUSH mylist "a" "b"
RPUSH mylist "c"

# Hash: field-value map (like a small object)
HSET user:1 name "Alice" age 30

# Set: unordered collection of unique strings
SADD tags "redis" "db"

# Sorted Set (ZSet): set scored by a float
ZADD leaderboard 100 "alice" 200 "bob"

# Stream: append-only log with IDs
XADD mystream * field value

# Bitmap, HyperLogLog, Geo: built on strings/zsets

Как выбрать тип

Выбирайте тип по паттерну доступа: нужна уникальность — Set. Нужен порядок по score — Sorted set. Нужно обновить одно поле объекта — Hash (а не сериализованная строка). Нужно приблизительное число уникальных элементов в масштабе — HyperLogLog (12 КБ на миллиарды элементов). Верный выбор типа = проще код, атомарные операции и огромная экономия памяти.

redis
# Use case -> data type mapping:
# Cache a string  -> String
SET api:response "json_blob"

# Store an object -> Hash (one key, multiple fields)
HSET user:1 name "Alice" email "[email protected]" age 30

# Queue / stack   -> List
LPUSH tasks "job1"   # push to head
RPOP tasks           # pop from tail (FIFO queue)

# Unique tags      -> Set
SADD post:1:tags "redis" "db" "cache"

# Leaderboard      -> Sorted Set
ZADD scores 100 "alice" 250 "bob"
ZREVRANGE scores 0 9     # top 10

# Event log        -> Stream
XADD events * type click user 1

# Count unique     -> HyperLogLog (approximate, fixed memory)
PFADD visitors "user1" "user2"

Кодировки памяти

Redis использует компактные кодировки (listpack, intset) для небольших структур, экономя 5–10x памяти, и автоматически переключается на хеш-таблицы и skiplist по мере роста. OBJECT ENCODING показывает текущую кодировку. MEMORY USAGE сообщает размер в байтах. Порог можно настроить (например, hash-max-listpack-entries), но значения по умолчанию хорошо подобраны. Понимание кодировок помогает планировать ёмкость.

redis
# Redis optimizes storage based on size
# Inspect the internal encoding of a key
OBJECT ENCODING mykey

# String encodings:
#   "embstr"  - short strings (< 44 bytes)
#   "raw"     - long strings
#   "int"     - integer values

# Hash/List/Set/ZSet encodings:
#   "listpack" / "intset" - small (compact, memory-efficient)
#   "hashtable" / "list" / "skiplist" - large (faster, more memory)

# check memory usage of a key
MEMORY USAGE mykey

# sample memory usage stats
MEMORY STATS

# the encoding changes automatically as the structure grows

Команды OBJECT и MEMORY

OBJECT IDLETIME полезна для поиска холодных ключей кэша (к которым редко обращаются). OBJECT FREQ работает только с политикой maxmemory-policy LFU. MEMORY USAGE с SAMPLES 0 считает точно (по умолчанию для больших коллекций берутся сэмплы). COMMAND DOCS (Redis 7+) возвращает структурированную документацию. Эти инструменты интроспекции помогают отлаживать раздувание памяти и настраивать политики вытеснения.

redis
# OBJECT subcommands for introspection
OBJECT ENCODING mykey     # internal encoding
OBJECT REFCOUNT mykey     # reference count
OBJECT IDLETIME mykey     # seconds since last access
OBJECT FREQ mykey         # access frequency (LFU mode)

# check memory usage (bytes) of a key
MEMORY USAGE mykey
MEMORY USAGE mykey SAMPLES 0   # exact count

# total memory used by the server
INFO memory | grep used_memory_human

# help understand a command
COMMAND INFO GET
COMMAND DOCS SET

# COMMAND lists all commands (huge output)
COMMAND

Ошибки и проверка типов

Тип ключа фиксирован на всё время его жизни — нельзя переиспользовать один ключ под другой тип, не удалив его сначала. Ошибки WRONGTYPE защищают от случайной путаницы типов. Всегда проверяйте TYPE при работе с ключами неизвестного происхождения. Именно из-за строгой типизации команды Redis имеют префиксы по типу (HSET vs SET vs SADD).

redis
# each key has ONE type; using the wrong command fails
SET mykey "hello"
LPUSH mykey "x"        # WRONGTYPE error

# WRONGTYPE Operation against a key holding the wrong kind of value

# check the type before operating
TYPE mykey             # "string"
if [ "$(TYPE mykey)" = "string" ]; then ...

# TYPE returns: string|list|hash|set|zset|stream|none

# rename preserves the type
RENAME mykey newkey
TYPE newkey            # still "string"

# type is immutable; delete + recreate to change types
DEL mykey
LPUSH mykey "x"        # now a list
03

Строки

Базовые операции со строками

Строки бинарно-безопасны (хранят любые байты до 512 МБ, включая изображения и JSON). SET с NX — класситивный примитив блокировки в Redis (установить, если не существует). GETSET атомарен и удобен для подмены конфигов. SETRANGE может удлинять строку. Для структурированных данных предпочитайте хеши сериализованным JSON-строкам — они позволяют обновлять отдельные поля.

redis
# set and get
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 mykey "new" EX 60 NX  # with expiry, only if new

# get and set atomically (returns old value)
GETSET counter 0        # returns old value, sets new

# append to a string
APPEND mykey " world"   # "hello world"

# get substring
GETRANGE mykey 0 4      # "hello"
SETRANGE mykey 6 "redis"# "hello redis"

# get string length
STRLEN mykey            # 11

Числовые счётчики

INCR/DECR атомарны — безопасны при конкурентном доступе без блокировок. Поэтому Redis идеален для счётчиков, rate limiting (INCR + EXPIRE) и генерации последовательных ID. INCRBYFLOAT поддерживает десятичные дроби, но использует double (следите за округлением). Если значение не целое, INCR вернёт ошибку. Счётчики лучше всего работают в связке с EXPIRE для статистики по временным окнам.

redis
# increment a numeric string atomically
INCR counter            # counter = counter + 1
INCRBY counter 10       # counter = counter + 10

# decrement
DECR counter            # counter = counter - 1
DECRBY counter 5        # counter = counter - 5

# floating point operations
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

Операции с несколькими ключами

MSET/MGET объединяют операции в один round-trip — это критично для производительности (в однопоточной модели Redis накладные расходы на команду заметны). MSETNX атомарна: либо все ключи установлены, либо ни один (всё или ничего). GETDEL (6.2+) атомарно возвращает и удаляет значение — удобно для одноразового чтения сообщений. По возможности объединяйте команды в батчи, чтобы снизить сетевую задержку.

redis
# set multiple keys at once (atomic)
MSET k1 "v1" k2 "v2" k3 "v3"

# get multiple keys at once
MGET k1 k2 k3           # ["v1", "v2", "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

# atomic get-and-delete (useful for queues)
GETDEL mykey            # returns value AND deletes key

Битмапы (на строках)

Битмапы хранят булевы флаги для 4 миллиардов пользователей примерно в 512 МБ — крайне экономно для больших аудиторий. BITOP AND/OR/XOR/NOT комбинируют битмапы (например, пользователи, активные в несколько дней). BITCOUNT считает активных пользователей. Сценарии: daily active users, фича-флаги, учёт посещаемости. Позиция бита = ID пользователя.

redis
# 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:daily:2025-01-01 5 1
SETBIT users:daily:2025-01-02 5 1
BITOP AND active-both users:daily:2025-01-01 users:daily:2025-01-02
BITCOUNT active-both        # users active on both days

# find the first set bit
BITPOS user:1:active 1      # position of first 1-bit

Операции с битовыми полями

BITFIELD упаковывает несколько небольших счётчиков в одну строку — например, 1000 дневных счётчиков как u8 в 1 КБ. OVERFLOW SAT насыщает на максимуме (удобно для статистики), FAIL возвращает nil при переполнении (удобно для ограничений), WRAP зацикливается (по умолчанию, обычно не нужно). Это гораздо экономнее отдельных ключей для многих мелких счётчиков.

redis
# BITFIELD: multiple counters in one string (compact)
# store up to 2^63 counters, each 1-64 bits, in a single key

# set a 8-bit unsigned counter at offset 0
BITFIELD mycount SET u8 0 100

# increment a counter (with overflow control)
BITFIELD mycount INCRBY u8 0 10   # returns 110
BITFIELD mycount INCRBY u8 0 10   # returns 120

# overflow control: WRAP (default), SAT, FAIL
BITFIELD mycount OVERFLOW SAT INCRBY u8 0 200  # saturates at 255
BITFIELD mycount OVERFLOW FAIL INCRBY u8 0 999 # returns nil (overflow)

# read multiple counters in one call
BITFIELD mycount GET u8 0 GET u8 8 GET u8 16
04

Хеши

Основы хешей

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

redis
# 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 multiple fields
HMGET user:1 name age       # ["Alice", "30"]

# get all fields and values
HGETALL user:1
# name  -> Alice
# age   -> 30
# email -> [email protected]

# get all field names or values
HKEYS user:1                # [name, age, email]
HVALS user:1                # [Alice, 30, [email protected]]

# get the number of fields
HLEN user:1                 # 3

Операции с полями хеша

HSETNX даёт «установить, если не существует» на уровне поля (удобно для одноразовой инициализации). HINCRBY по полям хеша атомарен — идеален для счётчиков по пользователям (число входов, просмотров). Хеш автоматически удаляется, когда удалено последнее поле (HDEL). HMSET устарел, так как HSET теперь принимает несколько полей; всегда используйте HSET.

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

# check if a field exists
HEXISTS user:1 name          # 1 if exists, 0 if not

# increment a numeric field atomically
HINCRBY user:1 age 1         # age = 31
HINCRBY user:1 age -5        # age = 26
HINCRBYFLOAT user:1 score 0.5

# get the string length of a field's value
HSTRLEN user:1 name          # 5 (length of "Alice")

# set multiple fields (same as HSET with multiple)
HMSET user:1 a 1 b 2         # deprecated, use HSET

Перебор хешей

HGETALL блокирует сервер на больших хешах — для продакшена используйте HSCAN. HSCAN работает по курсору: вызывайте повторно, пока курсор не вернётся к 0. COUNT — это подсказка. HRANDFIELD (6.2+) удобна для сэмплирования (например, случайные фича-флаги). Для хешей с миллионами полей рассмотрите разбиение на несколько ключей через шардирование.

redis
# HSCAN: cursor-based iteration (for large hashes)
HSCAN user:1 0 MATCH "na*" COUNT 10
# returns [cursor, [field, value, field, value, ...]]

# iterate all fields
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

# get a random field
HRANDFIELD user:1            # one random field name
HRANDFIELD user:1 3          # 3 random field names
HRANDFIELD user:1 3 WITHVALUES  # fields + values

Срок жизни полей хеша (Redis 7.4+)

TTL на уровне поля (7.4+) — важная возможность для хешей: раньше для истечения отдельных полей нужны были отдельные ключи или обходные пути. Удобно для объектов с разным временем жизни (профиль пользователя, где токен сессии истекает, а имя остаётся). В старых версиях Redis поля с истечением приходится хранить отдельными ключами со своим EXPIRE.

redis
# before 7.4, expiration was only at the key level
EXPIRE user:1 3600    # the whole hash expires

# Redis 7.4+: field-level TTL (HEXPIRE)
HEXPIRE user:1 60 FIELDS 1 session_token
# expires only the session_token field in 60 seconds

# get TTL of a specific field
HPTTL user:1 FIELDS 1 session_token

# persist a specific field (remove its TTL)
HPERSIST user:1 FIELDS 1 session_token

# get all fields and their expiration times
HEXPIRETIME user:1 FIELDS 1 session_token

Сценарии использования хешей

Хеши особенно хороши для объектов и сгруппированных счётчиков. Мощный приём экономии памяти: когда у вас много мелких строковых ключей, сгруппируйте их в один хеш — кодировка listpack требует куда меньше накладных расходов, чем тысячи отдельных ключей (у каждого свои метаданные). Такое «объединение в корзины» может сократить память в 5–10 раз для небольших значений.

redis
# 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. Group small key-value pairs into one hash (memory savings)
# instead of SET k1 v1; SET k2 v2 -> HSET bucket k1 v1 k2 v2
05

Списки

Основы списков (push/pop)

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

redis
# lists are ordered sequences of strings (linked lists)
# push to head (left) or tail (right)
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
LPOP mylist 2             # ["a", ...]

# 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

Индексы и диапазоны в списках

LRANGE 0 -1 возвращает весь список. LTRIM — частый приём для ограничения размера списка (например, хранить только последние 100 событий). LREM удаляет по значению (count: положительный — с головы, отрицательный — с хвоста, 0 — все). LINDEX для середины работает за O(N) — списки оптимизированы под доступ с краёв. Для произвольного доступа по индексу используйте другую структуру.

redis
# get element by index (0-based, O(N) traversal)
LINDEX mylist 0           # first element
LINDEX mylist -1          # last element

# get a range of elements
LRANGE mylist 0 -1        # all elements
LRANGE mylist 0 2         # first 3 elements
LRANGE mylist -3 -1       # last 3 elements

# set an element by index
LSET mylist 1 "new"

# get length
LLEN mylist

# trim to a range (removes everything outside)
LTRIM mylist 0 99         # keep only first 100 elements

# remove elements by value
LREM mylist 2 "value"     # remove first 2 occurrences of "value"
LREM mylist -2 "value"    # remove last 2 occurrences

Список как очередь

BRPOPLPUSH/BLMOVE атомарно перемещают элемент из источника в приёмник — потребитель может обрабатывать его безопасно, и если он упадёт, элемент останется в приёмнике (паттерн надёжной очереди). Это лучше, чем BRPOP + обработка, потому что падение после BRPOP теряет элемент. После обработки удалите элемент из списка-приёмника.

redis
# 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
LPUSH source "item"
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

Вставка и удаление в списках

LINSERT работает за O(N) — используйте умеренно на больших списках. LPOS находит позиции элемента, не удаляя его. LMPOP (7.0+) извлекает из нескольких списков за один вызов — удобно для приоритетных очередей. При частых операциях в середине списка список — неподходящий выбор: рассмотрите sorted set или другую модель данных.

redis
# insert before or after a pivot element
LINSERT mylist BEFORE "pivot" "new"
LINSERT mylist AFTER "pivot" "new"

# remove elements by value
LREM mylist 1 "value"     # remove first occurrence from head
LREM mylist -1 "value"    # remove first occurrence from tail
LREM mylist 0 "value"     # remove ALL occurrences

# pop and push in one atomic operation
RPOPLPUSH source dest

# get and remove from both ends (6.2+)
LPOP mylist 2             # pop 2 from head
LMPOP 2 mylist LEFT COUNT 3  # (7.0+) pop from one of multiple lists

# find the position of an element (6.0+)
LPOS mylist "value"
LPOS mylist "value" RANK 2   # find 2nd occurrence

Сценарии использования списков

Списки лучше всего подходят для последовательностей с доступом с краёв: очереди, стеки, ленты, буферы. LTRIM делает их идеальными для ограниченных журналов и лент. Для rate limiting простым скользящим окном служит список временных меток + LTRIM. Для сортированных и приоритетных очередей используйте sorted set. Списки не поддерживают дедупликацию — для этого нужен set.

redis
# 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 <timestamp>
LTRIM rate:user:1 0 99
LLEN rate:user:1           # request count in window
06

Множества

Основы множеств

Множества хранят уникальные значения — идеальны для тегов, категорий и дедупликации. SISMEMBER работает за O(1) — намного быстрее проверки по списку. SMEMBERS может блокировать на больших множествах; для перебора используйте SSCAN. SRANDMEMBER не удаляет элемент, SPOP удаляет. Если все элементы — целые числа, множества используют intset (отсортированный массив), что очень экономит память.

redis
# sets: unordered collection of unique strings
SADD tags "redis" "db" "cache"
SADD tags "redis"          # ignored (already exists)

# remove a member
SREM tags "cache"

# check membership
SISMEMBER tags "redis"     # 1 if member, 0 if not

# get the number of members
SCARD tags                 # 2

# get all members (avoid on large sets)
SMEMBERS tags              # ["redis", "db"]

# get a random member
SRANDMEMBER tags           # one random member
SRANDMEMBER tags 3         # 3 random (may repeat)
SRANDMEMBER tags -3        # 3 unique random

# pop a random member (removes it)
SPOP tags                  # removes and returns one

Операции над множествами

Операции над множествами — суперсила Redis: объединение, пересечение и разность за O(N) без обработки на клиенте. Сценарии: общие друзья (SINTER), уникальные посетители (SUNION), фильтрация по тегам (SINTER множеств тегов). SINTERCARD (7.0+) возвращает только количество — быстрее, когда сами элементы не нужны. Сохраняйте результаты, чтобы не пересчитывать.

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

Перебор и перемещение элементов

SMOVE атомарна — удобна для смены состояний (например, перевод пользователя из множества 'pending' в 'active'). SSCAN — безопасный способ перебрать большое множество. SMISMEMBER (7.4+) пакетно проверяет принадлежность, сокращая число round-trip'ов. BSPOP (7.0+) блокируется как BLPOP, но для множеств — полезно в событийных паттернах, где порядок не важен.

redis
# SSCAN: cursor-based iteration for large sets
SSCAN myset 0 MATCH "pre*" COUNT 100
# returns [cursor, [member1, member2, ...]]

# move a member from one set to another atomically
SMOVE source dest "member"

# pop multiple random members (6.2+)
SPOP myset 3               # removes and returns 3 members

# blocking set pop (7.0+) - waits until a member exists
BSPOP myset 30             # blocks up to 30 seconds

# check multiple memberships at once (7.4+)
SMISMEMBER myset "a" "b" "c"
# returns [1, 0, 1]

Сценарии использования множеств

Множества — основной инструмент для уникальности и связей. Паттерн SINTER для взаимных подписчиков и друзей — классика. Для «посетителей за день» с огромной кардинальностью рассмотрите HyperLogLog (приблизительно, но фиксированные 12 КБ). Для упорядоченных уникальных данных (рейтинги) используйте sorted set. Множества неупорядочены — если порядок важен, берите список или sorted set.

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

# 5. Lottery / random selection
SADD participants "u1" "u2" "u3" "u4"
SPOP participants 1        # draw a winner

Множества и другие типы

Выбор типа — ключевое решение при проектировании на Redis. Set для уникальности и быстрой проверки принадлежности (без порядка). Sorted set для рейтингов и упорядочивания (дороже по памяти). List для последовательностей с дубликатами. Hash для объектов «поле-значение». Если сомневаетесь, набросайте паттерны доступа: чтение, запись, порядок и требования к уникальности — правильный тип станет очевиден.

redis
# Set: unordered, unique, O(1) membership check
SADD myset "a" "b"
SISMEMBER myset "a"       # O(1)

# Sorted Set: unique + ordered by score
ZADD myzset 1 "a" 2 "b"
ZRANK myzset "a"          # 0 (rank)

# List: ordered, allows duplicates, O(N) search
LPUSH mylist "a" "a"
LPOS mylist "a"           # 0 (first match)

# Hash: field-value pairs, no ordering
HSET myhash a 1 b 2

# Choose:
# - need uniqueness only?           -> Set
# - need uniqueness + ordering?     -> Sorted Set
# - need ordering + allow dups?     -> List
# - need key-value mapping?         -> Hash
07

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

Основы sorted sets

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

redis
# 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: conditional)
ZADD leaderboard NX 300 "new"
ZADD leaderboard GT 300 "alice"  # only if new score is greater

# 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

Запросы по диапазону

ZRANGE возвращает по рангу (индексу), ZRANGEBYSCORE — по score. Префикс '(' делает score эксклюзивным. В Redis 6.2 они объединены в ZRANGE с опциями BYSCORE/BYLEX/REV. WITHSCORES включает score в вывод. Для рейтингов ZREVRANGE 0 9 даёт топ-10. ZRANGESTORE (6.2+) сохраняет результат в новый ключ.

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

# get members by score range
ZRANGEBYSCORE leaderboard 100 200    # scores 100-200
ZRANGEBYSCORE leaderboard 100 +inf   # scores >= 100
ZRANGEBYSCORE leaderboard (100 200   # scores > 100 (exclusive)

# descending order
ZREVRANGE leaderboard 0 2            # top 3 (highest scores)
ZREVRANGEBYSCORE leaderboard 200 100 # 200 down to 100

# 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

Операции со score и ранги

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

redis
# increment a member's score
ZINCRBY leaderboard 50 "alice"     # alice += 50

# get the score
ZSCORE leaderboard "alice"

# remove a member
ZREM leaderboard "bob"

# remove members by rank range
ZREMRANGEBYRANK leaderboard 0 9    # remove lowest 10
ZREMRANGEBYSCORE leaderboard 0 100 # remove scores <= 100

# count members in a score range
ZCOUNT leaderboard 100 200

# get the rank
ZRANK leaderboard "alice"          # ascending rank
ZREVRANK leaderboard "alice"       # descending rank (0 = highest)

# get multiple members' scores at once
ZMSCORE leaderboard "alice" "bob"  # ["250", "200"]

Лексикографические диапазоны (BYLEX)

BYLEX позволяет делать запросы по диапазону элементов при равных score — превращая sorted set в автоматически сортируемый строковый индекс. Сценарии: автодополнение (слова со score 0, запрос по префиксу), сортированные словари. '[a' означает включительно, '(a' — исключительно, '-' — начало, '+' — конец. Работает только когда все score одинаковы.

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

Агрегации sorted sets

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

redis
# ZUNIONSTORE / ZINTERSTORE: 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
08

Pub/Sub

Основы Pub/Sub

Pub/Sub работает по принципу «отправил и забыл»: сообщения доставляются подключённым в данный момент подписчикам без сохранения. Если подписчиков нет, сообщение теряется. Поэтому Pub/Sub не подходит для надёжной доставки — для этого используйте Streams. Pub/Sub идеален для уведомлений в реальном времени, чатов и вещания, где допустимы потери. Подписчик должен быть подключён, чтобы получать сообщения.

redis
# subscribe to channels (in one client)
SUBSCRIBE news alerts

# publish a message to a channel (from another client)
PUBLISH news "Breaking: Redis 7.4 released"

# pattern subscription (glob-style)
PSUBSCRIBE news.*

# unsubscribe
UNSUBSCRIBE news
PUNSUBSCRIBE news.*

# note: published messages are NOT persisted
# if no subscriber is listening, the message is lost
# for persistent messaging, use Streams instead

Шардированный Pub/Sub (7.0+)

Шардированный Pub/Sub (7.0+) решает проблему кластерного режима: обычный Pub/Sub рассылает каждый PUBLISH на все узлы кластера, тратя пропускную способность. Шардированный Pub/Sub направляет сообщения только в шард, которому принадлежит ключ канала, — гораздо эффективнее в больших кластерах. В кластерах используйте SSUBSCRIBE/SPUBLISH. Имя канала определяет шард (как ключ).

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

Паттерны и сценарии Pub/Sub

Pub/Sub отлично подходит для вещания: один издатель, много подписчиков (чаты, живые дашборды, инвалидация кэша). PSUBSCRIBE с glob-шаблонами (user:*:login) даёт гибкую маршрутизацию. Главное ограничение — отсутствие сохранности: отключившийся подписчик пропускает сообщения. Для надёжной доставки комбинируйте Pub/Sub со Stream как резервом или просто используйте Streams.

redis
# 1. Real-time chat
# client subscribes to their room
SUBSCRIBE chat:room:42
# server publishes messages
PUBLISH chat:room:42 "Alice: hello"

# 2. Cache invalidation
# subscribe to invalidation channel
SUBSCRIBE cache:invalidate
# when data changes, publish
PUBLISH cache:invalidate "user:123"

# 3. Event notifications (with PSUBSCRIBE patterns)
PSUBSCRIBE user:*:login
# matches user:1:login, user:2:login, etc.

# 4. Live dashboards
SUBSCRIBE metrics:*
# push real-time updates to dashboards

# 5. Multiplayer game state
PUBLISH game:room:1 "player_moved:5:10"

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

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

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

Pub/Sub и Streams

Pub/Sub — для эфемерного обмена в реальном времени; Streams — для долговечного обмена с возможностью переигрывания. Частый гибрид: Pub/Sub для живых уведомлений (быстро, с потерями) + Streams как источник истины (надёжно, с переигрыванием). Новые подписчики читают Stream, чтобы догнать, а затем подписываются на Pub/Sub для живых обновлений. Для большинства продакшен-систем, где нужна надёжность, Streams — лучший выбор по умолчанию.

redis
# Pub/Sub: fire-and-forget, no persistence
PUBLISH channel "msg"   # lost if no subscribers

# Streams: persistent, replayable, consumer groups
XADD mystream * msg "hello"   # stored forever (or capped)

# Pub/Sub pros: simple, low latency, fan-out
# Pub/Sub cons: no persistence, no replay, no consumer groups

# Streams pros: persistent, replayable, consumer groups, ACK
# Streams cons: more complex, requires cleanup (XADD MAXLEN)

# when to use each:
# - real-time notifications (loss OK)     -> Pub/Sub
# - chat with presence                    -> Pub/Sub + Streams
# - reliable task queue                   -> Streams
# - event sourcing / audit log            -> Streams
# - fan-out to transient subscribers      -> Pub/Sub
09

Транзакции и пайплайнинг

Транзакции MULTI/EXEC

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

redis
# MULTI starts a transaction; commands are queued
MULTI
SET counter 1
INCR counter
INCR counter
GET counter
EXEC
# returns: [OK, 2, 3, "3"]

# discard a transaction (cancels all queued commands)
MULTI
SET x 1
DISCARD

# errors during queuing (syntax) abort the whole transaction
# errors during EXEC (e.g., wrong type) skip only that command

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

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

redis
# WATCH monitors keys; if any change before EXEC, the 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

Пайплайнинг (батчи round-trip)

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

redis
# pipelining sends multiple commands in one network round-trip
# (no atomicity guarantee, just reduced latency)

# in a client library (e.g., Node.js / redis):
const pipe = client.multi()
pipe.set("k1", "v1")
pipe.set("k2", "v2")
pipe.incr("counter")
const results = await pipe.exec()

# vs MULTI/EXEC: pipelining does NOT guarantee atomicity
# other clients can interleave between pipelined commands

# raw protocol example (RESP):
# *1\r\n$4\r\nPING\r\n*1\r\n$4\r\nPING\r\n
# (send multiple commands at once, read multiple replies)

Lua-скрипты (атомарность)

Lua-скрипты — способ Redis выполнять сложные атомарные операции: скрипт выполняется как единое атомарное целое (без вклинивания). EVALSHA перезапускает загруженный скрипт по хешу (не отправляя тело заново). Держите скрипты короткими (они блокируют сервер). Скрипты должны быть детерминированными (без random/времени) для репликации. Redis 7+ предлагает FUNCTIONS как более структурированную альтернативу.

redis
# Lua scripts run atomically — no other command runs during execution
# EVAL: run a script
EVAL "return redis.call('GET', KEYS[1])" 1 mykey

# 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"

# load a script once, then run by SHA hash (efficient)
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# returns a SHA1 hash
EVALSHA <sha1> 1 mykey

# check if a script is loaded
SCRIPT EXISTS <sha1>

Functions (Redis 7.0+)

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

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

# get the function's code
FUNCTION DUMP mylib

# delete a library
FUNCTION DELETE mylib

# functions persist across restarts (unlike EVAL scripts)
10

Сохранение данных

Снимки RDB

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

redis
# RDB: point-in-time snapshot of the dataset (compact binary)
# trigger a snapshot manually:
SAVE              # blocks until done (use with care)
BGSAVE            # forks a background process (non-blocking)
LASTSAVE          # Unix timestamp of the last successful save

# 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 (default: dump.rdb in the working dir)
CONFIG GET dbfilename
CONFIG GET dir

# RDB pros: compact, fast restart, great for backups
# RDB cons: potential data loss between snapshots

AOF (Append-Only File)

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

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

# AOF auto-rewrite thresholds:
#   auto-aof-rewrite-percentage 100
#   auto-aof-rewrite-min-size 64mb

# AOF pros: minimal data loss (1 sec max with everysec)
# AOF cons: larger files, slower load on restart

Гибрид RDB + AOF

Совместное использование RDB и AOF даёт быстрый рестарт RDB и надёжность AOF. Начиная с Redis 7, AOF — это многочастный файл: снимок RDB как база + инкрементальный лог команд, что сочетает быструю загрузку с минимальными потерями. aof-use-rdb-preamble (по умолчанию yes) ставит снимок RDB в начало AOF для ускорения восстановления. Это рекомендуемая конфигурация для продакшена.

redis
# use BOTH RDB and AOF for the best of both worlds
# redis.conf:
#   save 900 1          # RDB snapshots
#   appendonly yes      # AOF enabled
#   aof-use-rdb-preamble yes  # RDB header in AOF (faster load)

# on restart, Redis loads AOF (more complete)
# the AOF file can start with an RDB snapshot (faster load)
# followed by incremental AOF commands

# disaster recovery: keep both RDB and AOF backups
# RDB for fast restores, AOF for minimal data loss

# check what's enabled
CONFIG GET save
CONFIG GET appendonly

# monitor persistence operations
INFO persistence

Резервное копирование и восстановление

Регулярно делайте резервные копии RDB-файла (компактно и быстро) — это согласованный снимок даже во время работы Redis (copy-on-write). Для AOF копируйте весь каталог appendonly (многочастный в Redis 7). Восстановление: остановите Redis, замените файлы и запустите снова. Чтобы исправить ошибочную команду, отредактируйте AOF и удалите её перед перезапуском. Всегда проверяйте резервные копии через redis-check-rdb/aof.

redis
# backup: copy the RDB file while Redis runs
cp /var/lib/redis/dump.rdb /backup/dump-$(date +%F).rdb

# or trigger a BGSAVE first for a consistent snapshot
BGSAVE
# wait for LASTSAVE to update, then copy the file

# AOF backup: copy the AOF manifest + files
cp /var/lib/redis/appendonly.aof.* /backup/

# restore: stop Redis, replace the data files, start
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)
redis-check-rdb /var/lib/redis/dump.rdb
redis-check-aof /var/lib/redis/appendonly.aof

Компромиссы сохранения

Выбор сохранения зависит от требований к надёжности. Чистый кэш: отключите сохранение ради максимальной скорости. Критичные данные: RDB+AOF (рекомендуется). Частый паттерн: отключить сохранение на основном узле (ради производительности) и включить на реплике (снимая нагрузку с диска). AOF с everysec — золотая середина: максимум 1 секунда потерь при минимальном влиянии на производительность. Всегда проверяйте восстановление.

redis
# choosing a persistence strategy:

# 1. RDB only (cache, re-buildable data)
#    save 3600 1
#    appendonly no
#    -> fast restart, some data loss on crash

# 2. AOF only (durability-critical, everysec)
#    save ""
#    appendonly yes
#    appendfsync everysec
#    -> up to 1s data loss, larger files

# 3. RDB + AOF (recommended production default)
#    save 3600 1
#    appendonly yes
#    aof-use-rdb-preamble yes
#    -> durability + fast restart

# 4. No persistence (pure cache, ephemeral)
#    save ""
#    appendonly no
#    -> maximum speed, all data lost on restart

# 5. Replica-only persistence (offload from primary)
#    primary: no persistence (max performance)
#    replica: RDB + AOF (persist here instead)
11

Кластеризация

Основы Redis Cluster

Redis Cluster шардит данные по узлам с помощью 16 384 хеш-слотов. Слот определяется как CRC16(key) % 16384. Мульти-ключевые операции (MGET, транзакции) требуют ключей в одном слоте — используйте хеш-теги ({user:1}), чтобы принудительно объединить связанные ключи. У каждого мастера могут быть реплики для отказоустойчивости. Кластер автоматически выполняет failover при отказе мастера.

redis
# Redis Cluster shards data across multiple nodes (16,384 slots)
# each key maps to a slot: CRC16(key) % 16384

# 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 status
redis-cli -p 7000 CLUSTER INFO
redis-cli -p 7000 CLUSTER NODES

# count slots assigned
CLUSTER COUNTKEYSINSLOT 1234

# get the slot for a key
CLUSTER KEYSLOT mykey   # e.g., 1234

# multi-key operations require keys in the SAME slot
# 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 {})

Хеш-теги и мульти-ключевые операции

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

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

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)
# - too narrow -> can't do multi-key ops

Решардинг кластера

Решардинг переносит слоты между узлами без простоя — Redis мигрирует ключи по одному, продолжая обслуживать запросы. Добавьте узлы, затем выполните ребалансировку, чтобы распределить нагрузку. CLI-инструмент --cluster берёт на себя сложную оркестрацию. Всегда запускайте --cluster check после изменений. Решардинг медленный (миграция по ключам), поэтому планируйте ёмкость заранее, а не делайте решардинг под нагрузкой.

redis
# move slots from one node to another (resharding)
redis-cli --cluster reshard host1:7000
# prompts for: how many slots, target node, source nodes

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

# add a new replica to an existing primary
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>

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

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

Failover в кластере

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

redis
# when a primary fails, its replica is promoted automatically
# manual failover (for maintenance):
redis-cli -p 7001 CLUSTER FAILOVER         # replica -> primary
redis-cli -p 7001 CLUSTER FAILOVER FORCE   # without primary agreement
redis-cli -p 7001 CLUSTER FAILOVER TAKEOVER # force, may split brain

# view the cluster topology
CLUSTER NODES
CLUSTER SHARDS    # (7.0+)

# a node flagged as FAIL after timeout is removed
# cluster- node-timeout 15000   (15 seconds in redis.conf)

# if a cluster has no replica for a failing primary,
# that slot range becomes unavailable until the primary returns
# (or you manually fix it)

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

Cluster, Sentinel или один узел

Один инстанс — для разработки. Sentinel — для отказоустойчивости, когда данные помещаются на одну машину (один мастер + реплики + sentinels для мониторинга и failover). Cluster — для горизонтального масштабирования, когда данные превышают одну машину или очень высока пропускная способность записи. Кластер добавляет сложность (хеш-теги, ограничения мульти-ключевых операций). Управляемые сервисы (Redis Cloud, ElastiCache, MemoryDB) снимают операционную нагрузку — предпочитайте их, если нет веских причин хостить самим.

redis
# Single Redis: one instance, no HA, no scaling
#    simplest, fine for dev/small cache

# Sentinel: 1 primary + replicas + sentinel monitors
#    HA (automatic failover), no sharding
#    good when dataset fits on one machine
#    sentinel.conf: sentinel monitor mymaster host 6379 2

# Cluster: sharded across N primaries + replicas
#    HA + horizontal scaling
#    good for large datasets / high throughput
#    more complex (multi-key limitations)

# choose:
# - dev / tiny cache              -> single
# - production, data fits in RAM  -> sentinel (HA)
# - data > single machine RAM     -> cluster (sharding)
# - very high write throughput    -> cluster (shard writes)

# managed Redis (Redis Cloud, ElastiCache) handles
# sentinel/cluster ops for you
12

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

Настройка Sentinel

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

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

Клиенты подключаются к Sentinel'ам, чтобы узнать текущего мастера, а затем работают с ним. При failover клиенты снова спрашивают Sentinel'ов о новом мастере. SENTINEL failover запускает ручной failover (для плановых обновлений). ckquorum проверяет, хватает ли sentinel'ов для кворума, — запускайте в мониторинге. Все крупные клиентские библиотеки Redis поддерживают Sentinel нативно.

redis
# query sentinel state
redis-cli -p 26379 SENTINEL masters          # all monitored primaries
redis-cli -p 26379 SENTINEL master mymaster  # details of one primary
redis-cli -p 26379 SENTINEL replicas mymaster
redis-cli -p 26379 SENTINEL sentinels mymaster

# find the current primary address
SENTINEL get-master-addr-by-name mymaster

# force a failover (manual, for maintenance)
SENTINEL failover mymaster

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

# check the number of OK sentinels
SENTINEL ckquorum mymaster
# "OK 3 usable Sentinels" or "NOQUORUM" warning

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

Процесс failover

Failover автоматический, но вызывает короткий простой записи (секунды). SDOWN — мнение одного sentinel'а; ODOWN — консенсус кворума. Избранный лидер sentinel'ов выбирает самую актуальную реплику для повышения. Когда старый мастер возвращается, он становится репликой — записи, принятые им во время сетевого разделения, ТЕРЯЮТСЯ (риск split-brain). Подпишитесь на +switch-master для оповещений.

redis
# when a primary is down longer than down-after-milliseconds:
# 1. sentinels mark it 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-*

Реплики для чтения и масштабирование

Реплики снимают нагрузку чтения с мастера — полезно для read-heavy нагрузок (аналитика, отчёты). Репликация асинхронная, поэтому данные на реплике могут отставать (обычно миллисекунды, но под нагрузкой растёт). Для чтения с реплик используйте READONLY. Записываемые реплики (4.0+) принимают нереплицируемые записи — удобно для временных данных или кэшей на реплике, но эти записи теряются при failover. Следите за лагом репликации.

redis
# replicas can serve reads (eventually consistent)
REPLICAOF 192.168.1.10 6379    # become a replica of this primary
REPLICAOF NO ONE               # promote to primary (manual)

# check replication status
INFO replication
# role:slave, master_host, master_link_status:up, ...

# replica lag (bytes and seconds lagging behind primary)
# master_repl_offset vs slave_repl_offset

# clients can route reads to replicas for read scaling
# but beware: replica data may be stale (replication lag)

# Redis Sentinel + clients: configure read preference
#   READONLY command enables reads on a replica

# writable replicas (Redis 4.0+): accept writes that are
# local-only (not replicated) — useful for ephemeral data
#   replica-read-only no   (in redis.conf)

Как устроена репликация

Репликация асинхронная и однонаправленная (от мастера к реплике). Первичная синхронизация отправляет полный RDB, затем поток команд; PSYNC включает частичную ресинхронизацию после коротких обрывов (используя replication backlog — настройте repl-backlog-size). Смена replication ID (при перезапуске мастера или failover) требует полной ресинхронизации. Цепочная репликация (реплика реплики) снижает нагрузку на мастера при большом веерном распространении.

redis
# replication is asynchronous: primary -> replica (one-way)
# initial sync: full RDB transfer + buffered commands
# subsequent: streaming command log

# trigger a full resync (force replica to reload everything)
redis-cli -p 6380 REPLICAOF NO ONE
redis-cli -p 6380 REPLICAOF 192.168.1.10 6379

# partial resync (PSYNC): if the replica disconnects briefly,
# it can resume from the replication backlog (no full resync)
#   repl-backlog-size 1mb    (tune for longer disconnects)

# monitor replication in real-time
redis-cli -p 6379 INFO replication
# master_repl_offset, slave_read_repl_offset, backlog_size

# chain replication: a replica of a replica (tree topology)
# reduces load on the primary for many replicas
REPLICAOF replica-host 6380   # chain off another replica

# replication ID changes on every primary restart -> full resync
13

Streams

Основы Streams (XADD/XREAD)

Streams — долговечная структура обмена сообщениями в Redis: append-only, с возможностью переигрывания и группами потребителей. ID основаны на времени (генерируются автоматически через *). XREAD с $ читает только новые записи; с 0 — с начала. MAXLEN ограничивает размер потока (~ для приблизительного ограничения работает гораздо быстрее). Streams решают проблему отсутствия сохранности у Pub/Sub и рекомендуются для надёжных очередей.

redis
# streams are append-only logs with IDs (durable, replayable)
# XADD: add an entry (auto-generate ID with *)
XADD mystream * sensor temp 25.5
# returns an ID like "1700000000000-0" (timestamp-sequence)

# add with a specific ID (must be greater than the last)
XADD mystream 1700000001000-0 sensor temp 26.0

# read entries
XREAD COUNT 10 STREAMS mystream 0        # from the beginning
XREAD COUNT 10 STREAMS mystream $        # new entries only (tail)

# block for new entries (like BLPOP for lists)
XREAD BLOCK 30000 STREAMS mystream $     # blocks up to 30s

# get the length
XLEN mystream                            # number of entries

# capped stream (keep only last N entries)
XADD mystream MAXLEN 1000 * field value
XADD mystream MAXLEN ~ 1000 * field value  # ~ = approx (faster)

Группы потребителей

Группы потребителей позволяют обрабатывать параллельно: каждая запись доставляется ровно одному потребителю в группе. '>' читает новые записи; '0' — ожидающие (неподтверждённые) записи этого потребителя. XACK отмечает запись обработанной. Ожидающие записи (доставленные, но не подтверждённые) образуют журнал обработки — через XPENDING ищите зависшие сообщения, а через XCLAIM переназначайте их другому потребителю после таймаута.

redis
# create a consumer group at a specific position
XGROUP CREATE mystream mygroup $        # only new entries
XGROUP CREATE mystream mygroup 0        # all existing entries
XGROUP CREATE mystream mygroup 0 MKSTREAM  # create stream if missing

# read entries as a consumer (assigns pending entries)
XREADGROUP GROUP mygroup consumer1 COUNT 10 STREAMS mystream >
# '>' = never-delivered entries

# read pending entries (for this consumer, not yet acked)
XREADGROUP GROUP mygroup consumer1 STREAMS mystream 0

# acknowledge processing (removes from pending)
XACK mystream mygroup <id1> <id2>

# view pending entries (pending entries list)
XPENDING mystream mygroup
# returns: count, min-id, max-id, consumers

# view a consumer's pending entries
XPENDING mystream mygroup - + 10 consumer1

Обработка и восстановление

XAUTOCLAIM критична для надёжной обработки: она переназначает записи, слишком долго висящие в ожидании (потребитель упал или завис), здоровому потребителю. min-idle-time не даёт забрать записи, которые ещё обрабатываются. XTRIM ограничивает размер потока (важно для памяти). XRANGE читает диапазон по ID. XINFO показывает состояние потоков, групп и потребителей для мониторинга. Это полноценная надёжная очередь сообщений.

redis
# XCLAIM: reassign a pending entry to another consumer
# (after the original consumer died or is too slow)
XCLAIM mystream mygroup consumer2 60000 <entry-id>
# 60000 = min idle time (ms) before claiming

# XAUTOCLAIM (6.2+): auto-claim stale pending entries
XAUTOCLAIM mystream mygroup consumer2 60000 0 COUNT 10
# claims entries idle > 60s, returns them to consumer2

# view stream info
XINFO STREAM mystream FULL
XINFO GROUPS mystream
XINFO CONSUMERS mystream mygroup

# delete an entry (rarely needed)
XDEL mystream <id>

# trim the stream (free memory)
XTRIM mystream MAXLEN 10000
XTRIM mystream MINID 1700000000000   # remove older than this ID

# range queries
XRANGE mystream - +                   # all entries
XRANGE mystream 1700000000000 - 1700000009999 -

Сценарии использования Streams

Streams отлично подходят для надёжных очередей, event sourcing и временных рядов. Паттерн групп потребителей (XADD + XREADGROUP + XACK) полностью заменяет очереди на списках, добавляя встроенные повторы (ожидающие записи) и восстановление (XAUTOCLAIM). Для временных рядов MAXLEN держит память под контролем. Streams — самая функциональная структура Redis; используйте её, когда нужны долговечность и упорядоченная обработка.

redis
# 1. Reliable task queue (replaces lists + BRPOPLPUSH)
XADD tasks * type email payload '{"to":"[email protected]"}'
XREADGROUP GROUP workers worker1 COUNT 1 STREAMS tasks >
# process and XACK on success

# 2. Event sourcing / audit log
XADD events * user 1 action login ip 1.2.3.4
# replay with XRANGE for reconstruction

# 3. Real-time analytics (time-windowed)
XADD metrics * cpu 75 mem 60
XRANGE metrics - +           # query by time range

# 4. Chat history (capped)
XADD chat:room:1 MAXLEN ~ 1000 * user alice msg "hello"
XREAD COUNT 20 STREAMS chat:room:1 0

# 5. IoT sensor data (with TTL via trimming)
XADD sensors:temp MAXLEN ~ 86400 * value 22.5  # keep last day

Streams и другие очереди

Streams — родная для Redis очередь: проще Kafka/RabbitMQ и достаточно для большинства нагрузок, помещающихся в RAM. У них нет партиционного параллелизма Kafka (один поток = один шард), но группы потребителей дают параллелизм воркеров. При очень высокой пропускной способности или диска-ориентированной надёжности выигрывает Kafka. При сложной маршрутизации — RabbitMQ. Для большинства приложений, уже использующих Redis, Streams — правильный выбор по умолчанию для надёжного обмена сообщениями.

redis
# Redis Streams vs Lists (for queues):
# Lists: LPUSH/BRPOP, simple, NO retry/recovery
# Streams: consumer groups, ACK, pending, XAUTOCLAIM

# Redis Streams vs Kafka:
# Streams: in-memory (RAM-bounded), simpler, single-node or cluster
# Kafka: disk-based, partitioned, higher throughput at scale

# Redis Streams vs RabbitMQ:
# Streams: simpler, fewer features, in-memory
# RabbitMQ: rich routing, exchanges, acknowledgments, disk

# Streams capacity: limited by RAM (use MAXLEN/MINID to trim)
# Streams persistence: RDB/AOF (like any Redis data)

# choose Streams when:
# - you need a queue but already use Redis
# - dataset fits in RAM
# - you want simplicity over Kafka's scale
# - you need consumer groups with retry
14

HyperLogLog, битмапы и гео

HyperLogLog (кардинальность)

HyperLogLog (HLL) считает уникальные элементы с ошибкой около 0.81%, используя фиксированные 12 КБ, — миллиарды элементов при постоянной памяти. Идеален для аналитики вроде DAU/WAU/MAU. PFMERGE объединяет HLL (например, месячные уникальные из дневных). Компромисс — приблизительность: используйте Set, когда нужны точные подсчёты или проверка принадлежности (SISMEMBER), и HLL, когда нужно только количество.

redis
# HyperLogLog: approximate unique count with fixed 12KB memory
# perfect for counting unique visitors, IPs, etc. at scale

# add elements (returns 1 if the cardinality changed)
PFADD visitors:2025-01-01 "user:1" "user:2" "user:3"

# get the approximate unique count
PFCOUNT visitors:2025-01-01        # ~3

# merge multiple HLLs (e.g., monthly uniques from daily)
PFMERGE visitors:2025-01 visitors:2025-01-01 visitors:2025-01-02

# accuracy: ~0.81% standard error
# memory: always ~12KB regardless of element count (up to 2^64)

# vs a Set for unique counting:
# SADD + SCARD: exact, but O(N) memory (grows with count)
# PFADD + PFCOUNT: approximate, fixed 12KB memory
# 1 million uniques: Set ~10MB, HLL always 12KB

Битмапы подробнее

Битмапы хранят один бит на пользователя — 1 миллион пользователей = 125 КБ, 4 миллиарда = 512 МБ. BITOP AND/OR/XOR/NOT комбинируют битмапы (удержание, анализ оттока). BITPOS находит первый установленный бит. Сценарии: daily active users, фича-флаги, посещаемость, группы A/B-тестов. Ограничение: нужны плотные целочисленные ID пользователей (пропуски тратят место). Для разреженных данных лучше Set или HyperLogLog.

redis
# bitmaps: boolean operations on a string's bits
# ideal for per-user flags over a large user base (user ID = bit position)

# mark user 7 as "active today"
SETBIT active:2025-01-01 7 1

# check if user 7 was active
GETBIT active:2025-01-01 7          # 1

# count active users
BITCOUNT active:2025-01-01

# users active on BOTH days (AND)
BITOP AND active:both active:2025-01-01 active:2025-01-02
BITCOUNT active:both

# users active on EITHER day (OR)
BITOP OR active:either active:2025-01-01 active:2025-01-02

# users active on day 1 but NOT day 2 (XOR or AND NOT)
BITOP XOR diff active:2025-01-01 active:2025-01-02

# find the first active user
BITPOS active:2025-01-01 1         # position of first 1-bit

# memory: 1 million users = 125KB (1 bit per user)

Геоданные (GEO)

Команды GEO хранят географические точки и поддерживают запросы по радиусу и прямоугольнику — построены на sorted sets (score = geohash). GEOSEARCH (6.2+, заменяет GEORADIUS) находит ближайшие точки с богатыми опциями (WITHCOORD, WITHDIST, ASC/DESC). Расстояние считается по сфере. Точности хватает большинству приложений. Для сложного GIS (полигоны, маршрутизация) используйте специализированную пространственную БД. GEO идеальна для функций «найти рядом».

redis
# GEO: built on sorted sets, stores (lng, lat, name) points
# add locations (longitude, latitude, name)
GEOADD places -73.99 40.73 "Park" -73.98 40.75 "Museum" -74.00 40.70 "Cafe"

# get coordinates of a member
GEOPOS places "Park"               # [["-73.99","40.73"]]

# distance between two members (meters by default)
GEODIST places "Park" "Museum"     # "1623.5"
GEODIST places "Park" "Museum" km  # "1.623"

# find members within a radius (meters)
GEOSEARCH places FROMMEMBER "Park" BYRADIUS 1000 m ASC
# members within 1km of Park, sorted by distance

# find members within a bounding box
GEOSEARCH places FROMLONLAT -73.99 40.73 BYBOX 2 2 km

# GEOSEARCH also returns distance and coordinates
GEOSEARCH places FROMMEMBER "Park" BYRADIUS 500 m WITHCOORD WITHDIST

Геооперации

GEO реализована на sorted sets — score это geohash координат. Поэтому часть операций можно делать командами Z* (ZREM, ZRANGE). GEOSEARCH возвращает подробные результаты (расстояние, координаты, geohash). COUNT ограничивает число результатов (используйте с ASC для ближайших N). GEOSEARCHSTORE сохраняет результаты для дальнейшей обработки. Точность geohash падает у полюсов — для большинства реальных приложений это не проблема.

redis
# add multiple points at once
GEOADD cities -122.41 37.78 "San Francisco" -74.00 40.71 "New York"

# get the geohash of a member
GEOHASH places "Park"              # ["dr5reg..."]

# remove a member (uses ZREM internally)
ZREM places "Cafe"

# count members in an area (using ZCOUNT on the underlying zset)
ZCOUNT places -180 180             # all members

# GEOSEARCH with a center point and limiting results
GEOSEARCH places FROMLONLAT -73.99 40.73 \
  BYRADIUS 2000 m ASC COUNT 5      # nearest 5 within 2km

# GEOSEARCHSTORE: store results in a new key (6.2+)
GEOSEARCHSTORE nearby FROMLONLAT -73.99 40.73 BYRADIUS 1000 m

# the underlying structure is a sorted set, so:
ZRANGE places 0 -1                 # list all members
ZSCORE places "Park"               # geohash score

Выбор специализированных типов

Redis предлагает много специализированных структур помимо основных пяти. HyperLogLog для приблизительной кардинальности, битмапы для плотных булевых флагов, GEO для близости. Модули добавляют Bloom-фильтры (проверка принадлежности с ложными срабатываниями), Top-K (самые частые элементы) и RedisTimeSeries (оптимизированные временные ряды). Подбирайте структуру под форму данных и требуемую точность — правильный выбор экономит на порядки больше памяти.

redis
# Cardinality counting (unique elements):
#   exact, need membership test  -> Set (SADD/SISMEMBER/SCARD)
#   approximate, huge scale      -> HyperLogLog (PFADD/PFCOUNT)
#   per-time-bucket uniques      -> HLL per day, PFMERGE for ranges

# Boolean flags over a dense ID space:
#   small number of flags        -> Set of active IDs
#   millions of users            -> Bitmap (SETBIT/BITCOUNT)
#   multiple counters compactly  -> BITFIELD

# Geographic points:
#   "find nearby" queries        -> GEO (GEOADD/GEOSEARCH)
#   complex GIS                  -> use PostGIS/external

# Time-series data:
#   simple, capped               -> Stream (XADD MAXLEN)
#   dedicated TS module          -> RedisTimeSeries (module)

# Probabilistic structures (modules):
#   Bloom filter                 -> RedisBloom (BF.ADD/BF.EXISTS)
#   Top-K                        -> RedisBloom (TOPK)
15

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

Аутентификация и ACL

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

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

# Redis 6+: ACL system with users and permissions
# add a user with limited access
ACL SETUSER appuser on >secretpassword ~app:* +get +set +del -@dangerous

# list users
ACL LIST
ACL WHOAMI                # current user

# view a user's permissions
ACL GETUSER appuser

# delete a user
ACL DELUSER appuser

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

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

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

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

redis
# enable TLS in redis.conf (Redis 6+)
# generate certs first (or use a real CA):
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-cluster yes              # TLS between cluster nodes
tls-replication yes          # TLS between primary/replica
tls-auth-clients yes         # require client certs

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

Сетевая безопасность

У Redis нет встроенного сетевого контроля доступа — используйте bind + protected-mode + файрвол. НИКОГДА не выставляйте Redis в интернет (бесчисленные утечки из-за открытого Redis без аутентификации). protected-mode блокирует внешние подключения, когда пароль не задан. rename-command отключает опасные команды (FLUSHALL, CONFIG, KEYS), но ACL (6.0+) — современный подход. Размещайте Redis в приватной подсети; доступ через VPN или бастион.

redis
# bind to specific interfaces (never 0.0.0.0 in prod)
bind 127.0.0.1 10.0.0.5
protected-mode yes            # blocks external access if no password

# require authentication
requirepass "strong-random-password"

# rename dangerous commands (or disable them)
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG "CONFIG_9f8a7b"
rename-command KEYS ""

# Redis 6+: better to use ACLs instead of rename-command
# ACL SETUSER default -flushall -config -keys

# disable debug commands
# ACL SETUSER default -@dangerous

# use a firewall / security group to restrict access
# Redis should NEVER be directly internet-accessible
# (the 2018+ ransom attacks scanned for open Redis instances)

Аудит и логирование

SLOWLOG записывает медленные команды для аудита производительности — задайте порог под свой SLO (например, 10 мс). MONITOR логирует каждую команду (огромное влияние на производительность — только для отладки). LATENCY MONITOR помогает искать всплески задержек. CLIENT LIST показывает подключённых клиентов (следите за утечками). В продакшене ставьте loglevel 'notice' (debug слишком подробен). Отправляйте логи в централизованную систему для анализа.

redis
# log slow commands (slowlog)
CONFIG SET slowlog-log-slower-than 10000   # 10ms in microseconds
CONFIG SET slowlog-max-len 128             # keep 128 entries
SLOWLOG GET 10                             # last 10 slow commands
SLOWLOG RESET

# log to a file (redis.conf)
logfile /var/log/redis/redis.log
loglevel notice    # debug|verbose|notice|warning

# monitor all commands (debugging only — huge perf impact)
MONITOR

# latency monitoring
CONFIG SET latency-monitor-threshold 100   # 100ms
LATENCY HISTORY event-name
LATENCY DOCTOR                              # analysis report

# client list (who's connected)
CLIENT LIST
CLIENT GETNAME
CLIENT SETNAME "my-app"

Лучшие практики безопасности

Безопасность Redis строится слоями: сеть (bind/файрвол), аутентификация (пароль/ACL), транспорт (TLS), ограничение команд (ACL/rename), аудит (slowlog/monitor). Правило №1: никогда не выставляйте Redis напрямую в интернет — у него нет встроенного rate limiting и защиты от перебора. Шифруйте RDB/AOF-файлы на уровне диска (в них ваши данные открытым текстом). Обновляйте Redis ради патчей безопасности.

redis
# 1. NEVER expose Redis to the public internet
bind 127.0.0.1
protected-mode yes

# 2. Use strong passwords or ACLs
requirepass "<64-char-random-string>"
# or ACLs with least privilege

# 3. Enable TLS for transit encryption
tls-port 6379

# 4. Restrict dangerous commands
ACL SETUSER default -@dangerous -flushall -keys

# 5. Use a firewall / security group
# allow only app servers on the Redis port

# 6. Rotate credentials regularly
ACL SETUSER appuser on >newpassword ~app:* +@read +@write

# 7. Audit access
LOGICALDB MONITOR  # or use an audit module

# 8. Encrypt sensitive data at rest (disk encryption)
# RDB/AOF files can contain sensitive data

# 9. Keep Redis updated (security patches)
# 10. Isolate environments (separate dev/staging/prod)
16

Производительность и оптимизация

Основы производительности

Redis выполняет команды в одном потоке — одна медленная команда блокирует ВСЕХ клиентов. Никогда не используйте KEYS, SMEMBERS или DEL на больших структурах в продакшене. Вместо них применяйте семейство SCAN, HSCAN и UNLINK (асинхронное удаление). Объединяйте команды в пайплайны, чтобы сократить round-trip'ы. Знайте Big-O каждой команды: O(1) и O(log N) безопасны; O(N) команды должны быть ограничены (LRANGE с небольшими диапазонами).

redis
# Redis is single-threaded (mostly) — avoid blocking commands
# DANGEROUS on large datasets (block the server):
KEYS *              # use SCAN instead
SMEMBERS bigset     # use SSCAN
HGETALL bighash     # use HSCAN
DEL hugekey         # use UNLINK (async delete)
FLUSHDB             # use FLUSHDB ASYNC

# use UNLINK instead of DEL for large keys (non-blocking)
UNLINK bigkey       # deletes in a background thread

# favor pipelining and batch commands
MGET k1 k2 k3       # one round-trip, not three GETs
LPUSH list a b c    # one command, not three

# prefer structurally efficient commands
# O(1): GET, SET, HGET, SISMEMBER, ZSCORE
# O(log N): ZADD, ZRANGE
# O(N): LRANGE, SMEMBERS, KEYS, SORT

Пайплайнинг и батчи

Пайплайнинг — главный рычаг производительности Redis: объединение команд в один сетевой round-trip может дать ускорение в 10–100 раз. Каждый round-trip стоит сетевой задержки (~0.1–1 мс); 1000 отдельных команд = 100–1000 мс, а в пайплайне — около 1 мс. Не переусердствуйте (очередь ответов занимает память). Замеряйте redis-benchmark -P, чтобы найти оптимум. Транзакции используют пайплайнинг автоматически.

redis
# pipelining: send many commands without waiting for replies
# (reduces round-trip time — huge speedup over network)

# example (Node.js with ioredis):
const pipeline = redis.pipeline()
for (let i = 0; i < 1000; i++) {
  pipeline.set(`key:${i}`, "value")
}
await pipeline.exec()        # one round-trip for 1000 commands

# transactions (MULTI/EXEC) are automatically pipelined
redis.multi().set("k", "v").incr("c").exec()

# MSET/MGET batch in one command
MSET k1 v1 k2 v2 k3 v3
MGET k1 k2 k3

# benchmark pipelining
redis-benchmark -t set -n 100000 -P 16   # -P = pipeline size

# don't pipeline too many at once (memory for queued replies)
# batch in groups of 100-1000

Оптимизация памяти

Память — главное ограничение Redis. Используйте правильную структуру: хеши для объектов (кодировка listpack в 5–10 раз компактнее отдельных ключей). Настраивайте пороги кодировок, чтобы структуры оставались в компактной форме. «Объединение ключей в корзины» (группировка мелких ключей в один хеш) резко снижает накладные расходы на ключ. Задайте maxmemory и политику вытеснения, чтобы избежать OOM. Следите за used_memory и коэффициентом фрагментации.

redis
# use the right data structure (memory vs speed trade-offs)
# store small objects as hashes (listpack encoding is compact)
HSET user:1 name "Alice" age 30   # better than 3 string keys

# tune encoding thresholds (redis.conf)
hash-max-listpack-entries 128     # hash -> hashtable above this
hash-max-listpack-value 64        # field value size limit
list-max-listpack-size -2         # listpack max size
set-max-intset-entries 512        # intset -> hashtable above this
zset-max-listpack-entries 128

# use hashes for many small keys (key bucketing)
# instead of SET user:1:clicks 5; SET user:2:clicks 3
# use HSET clicks user:1 5 user:2 3

# monitor memory
INFO memory | grep used_memory_human
MEMORY STATS

# set maxmemory and an eviction policy
maxmemory 4gb
maxmemory-policy allkeys-lru

Политики вытеснения

Политика вытеснения определяет поведение при заполнении памяти. Для чистого кэша: allkeys-lru или allkeys-lfu (LFU лучше при скошенных паттернах доступа). Для базы данных: noeviction (записи падают, а не теряются данные). Для смешанного использования: volatile-lru (вытеснять только ключи с TTL, сохраняя постоянные). LFU (4.0+) отслеживает частоту доступа и часто обходит LRU. Следите за evicted_keys, чтобы правильно подобрать maxmemory.

redis
# when maxmemory is reached, Redis evicts keys per the policy
# maxmemory-policy options:

# no eviction (writes fail with OOM error)
maxmemory-policy noeviction

# LRU (Least Recently Used) — approximate LRU
allkeys-lru         # evict any key (cache use case)
volatile-lru        # only evict keys with TTL set

# LFU (Least Frequently Used) — better for skewed access
allkeys-lfu
volatile-lfu

# random eviction
allkeys-random
volatile-random

# TTL-based (evict soonest-expiring)
volatile-ttl

# for a cache: allkeys-lru or allkeys-lfu (best hit rate)
# for a database: noeviction (never lose data silently)
# mixed (some persistent, some cache): volatile-lru

Бенчмарки

redis-benchmark измеряет пропускную способность и задержку под нагрузкой. -c (конкурентность) имитирует клиентов; -P (пайплайнинг) проверяет производительность батчей. --latency показывает round-trip в реальном времени. Для точных результатов запускайте бенчмарк с машины рядом с Redis (сеть доминирует). Redis 6+ поддерживает --threads для многопоточного бенчмарка. Типичная производительность одного узла: 100K+ операций в секунду на обычном железе.

redis
# redis-benchmark: built-in performance testing
redis-benchmark -t set,get -n 100000 -c 50
# -t: test commands, -n: number of requests, -c: concurrent clients

# test with pipelining
redis-benchmark -t set -n 100000 -c 50 -P 16

# test a specific command with a specific key
redis-benchmark -t get -n 100000 -r 100000 -q
# -r: random keys (INSERT random keys for testing)

# latency check (100 requests, shows distribution)
redis-cli --latency
redis-cli --latency-history    # rolling update
redis-cli --latency-dist       # histogram

# in-memory test (no network overhead)
redis-benchmark -t set -n 100000 -q --threads 4

# monitor while benchmarking
redis-cli INFO stats | grep instantaneous_ops_per_sec
17

Администрирование

Информация о сервере и мониторинг

INFO — основная команда мониторинга: регулярно проверяйте разделы memory, clients, persistence и stats. MEMORY DOCTOR и LATENCY DOCTOR дают автоматический анализ. SLOWLOG ловит медленные команды. CLIENT LIST показывает все соединения (следите за утечками — каждое занимает память). Настройте внешний мониторинг (Prometheus + redis_exporter, Datadog) для исторических графиков и алертов по памяти, соединениям и лагу репликации.

redis
# 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 keyspace         # keys per database

# real-time stats
LATENCY DOCTOR        # latency analysis
MEMORY DOCTOR         # memory analysis

# live monitoring (subscribe to a special channel)
SUBSCRIBE __redis__:invalidate

# slow query log
SLOWLOG GET 10
SLOWLOG LEN

# client connections
CLIENT LIST
CLIENT KILL ID <id>   # disconnect a client

Управление клиентами

CLIENT LIST идентифицирует соединения по адресу, имени и текущей команде — бесценно для поиска утечек и зависших клиентов. CLIENT SETNAME помечает соединения для удобной идентификации (задавайте при подключении в приложении). CLIENT PAUSE ненадолго блокирует клиентов для безопасных миграций и снимков. Задайте timeout для очистки простаивающих соединений. maxclients предотвращает исчерпание соединений (каждый клиент занимает память).

redis
# list all connected clients
CLIENT LIST
# id, addr, name, age, idle, flags, db, cmd

# name your connections (for identification)
CLIENT SETNAME "my-app-worker-1"

# get the current client's info
CLIENT INFO

# get the current client's ID
CLIENT ID

# kill a client
CLIENT KILL ADDR 1.2.3.4:12345
CLIENT KILL ID 42
CLIENT KILL TYPE normal    # kill all normal clients

# pause clients (for maintenance, 10 seconds)
CLIENT PAUSE 10000

# set a timeout for idle clients
CONFIG SET timeout 300    # 5 minutes

# max clients
CONFIG SET maxclients 10000

Конфигурация

CONFIG SET меняет настройки на лету (без перезапуска); CONFIG REWRITE сохраняет их в redis.conf. Всегда проверяйте изменения конфигурации на стейджинге. Ключевые настройки продакшена: maxmemory + политика вытеснения (защита от OOM), save + appendonly (персистентность), tcp-keepalive (обнаружение мёртвых клиентов), timeout (очистка простаивающих соединений). Держите redis.conf в системе контроля версий. CONFIG GET * показывает всё — полезно для аудита.

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

# change config at runtime
CONFIG SET maxmemory 4gb
CONFIG SET maxmemory-policy allkeys-lru
CONFIG SET slowlog-log-slower-than 10000

# persist config changes to redis.conf
CONFIG REWRITE

# view all config (large output)
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

Отладка и поиск проблем

OBJECT ENCODING показывает внутреннее представление (отладка памяти). OBJECT IDLETIME ищет холодные ключи (кандидаты на вытеснение). MEMORY USAGE по ключу выявляет пожирателей памяти. DEBUG SLEEP проверяет, как приложение переживает задержки. LATENCY отслеживает события (expired, eviction, fast keys). Активная дефрагментация (4.0+) автоматически возвращает фрагментированную память на лету. Используйте DEBUG-команды в продакшене умеренно.

redis
# check if a key exists and its type
EXISTS mykey
TYPE mykey
OBJECT ENCODING mykey
OBJECT IDLETIME mykey     # seconds since last access

# memory usage per key
MEMORY USAGE mykey

# find keys blocking the server (DEBUG SLEEP for testing)
DEBUG SLEEP 2             # blocks for 2 seconds (testing only)

# check the latency
LATENCY HISTORY event
LATENCY GRAPH event

# object frequency (LFU mode)
OBJECT FREQ mykey

# inspect a key's internal structure (debugging)
DEBUG OBJECT mykey        # raw internal info

# last saved RDB timestamp
LASTSAVE

# active defragmentation (4.0+)
CONFIG SET activedefrag yes
MEMORY MALLOC-STATS

Обновления и обслуживание

Для обновлений без простоя используйте репликацию: сначала обновите реплики, выполните failover, затем обновите старый мастер. В кластерах делайте rolling restart по одному узлу (сначала failover мастеров). Всегда делайте резервную копию (BGSAVE + копирование RDB) перед обновлением. Читайте release notes про breaking changes. Тестируйте на стейджинге. Redis сохраняет обратную совместимость между минорными версиями, но мажорные могут требовать шагов миграции.

redis
# upgrade a standalone Redis:
# 1. save the dataset
SAVE
# 2. stop Redis
redis-cli SHUTDOWN
# 3. replace the binary
# 4. start the new version
redis-server /etc/redis/redis.conf

# upgrade a primary/replica pair (zero downtime):
# 1. upgrade the REPLICA first
SHUTDOWN
# 2. start new version on replica
# 3. promote replica to primary (SENTINEL FAILOVER)
# 4. upgrade the old primary (now a replica)
# 5. failback if desired

# upgrade a cluster:
# 1. upgrade one node at a time (rolling)
# 2. for each node: CLUSTER FAILOVER (if primary), upgrade, restart

# always back up before upgrading
# check the release notes for breaking changes
# test the upgrade in staging first

# rolling restart of a cluster (script)
for node in $nodes; do
  redis-cli -h $node CLUSTER FAILOVER
  redis-cli -h $node SHUTDOWN
  ssh $node "systemctl start redis"
done
18

Частые паттерны

Кэширование (cache-aside)

Cache-aside — самый частый паттерн Redis: читаем из кэша, при промахе идём в БД и заполняем кэш. Задайте TTL, чтобы ограничить устаревание. При записи либо write-through (обновлять кэш при записи в БД), либо инвалидация (удалить ключ кэша). Инвалидация безопаснее (нет гонки при перезаполнении), но write-through держит кэш тёплым. Защита от cache stampede: используйте блокировку или паттерн «dogpile», чтобы множество запросов не били в БД одновременно при промахе.

redis
# cache-aside: app checks cache, falls back to DB, fills cache
# pseudo-code:
function get_user(id):
  # 1. check cache
  data = GET("user:" + id)
  if data:
    return JSON.parse(data)

  # 2. cache miss -> query database
  data = db.query("SELECT * FROM users WHERE id = ?", id)

  # 3. fill cache (with TTL to avoid stale data)
  SET("user:" + id, JSON.stringify(data), "EX", 3600)

  return data

# write-through: update cache when DB changes
function update_user(id, data):
  db.update(id, data)
  SET("user:" + id, JSON.stringify(data), "EX", 3600)

# cache invalidation:
DEL("user:" + id)   # when the DB record is deleted

Распределённые блокировки

Распределённые блокировки через SET NX EX просты, но требуют аккуратности: всегда задавайте TTL (иначе при падении держателя будет дедлок) и используйте уникальный токен, чтобы снимать только свою блокировку (атомарная проверка и удаление через Lua). Для большей надёжности при сбоях алгоритм Redlock использует несколько независимых инстансов Redis. Блокировки не абсолютно безопасны (дрейф часов, паузы GC) — для строгих гарантий корректности рассмотрите консенсусную систему (etcd, ZooKeeper). Для большинства практических задач блокировок Redis достаточно.

redis
# SET NX with expiry = simple distributed lock
SET lock:resource "token-abc" NX EX 10
# returns OK if acquired, nil if already held

# release: only delete if the value matches (avoid releasing others' locks)
# (requires a Lua script for atomicity)
EVAL "
  if redis.call('GET', KEYS[1]) == ARGV[1] then
    return redis.call('DEL', KEYS[1])
  end
  return 0
" 1 lock:resource "token-abc"

# Redlock algorithm (multi-instance, higher safety):
# 1. get the time
# 2. SET NX on N (usually 5) independent Redis instances
# 3. if acquired on majority (3/5) within validity window -> locked
# 4. otherwise, release on all instances and retry

# lock options:
#   EX 10        # expire after 10 seconds (safety)
#   NX           # only if not exists
#   "token"      # unique value per lock holder (for safe release)

Ограничение частоты (rate limiting)

Фиксированное окно (INCR+EXPIRE) проще всего, но допускает двойной всплеск на границах окна. Скользящее окно (sorted set временных меток) точнее, но требует больше памяти. Token bucket позволяет всплески до максимума. Всё это можно сделать атомарным через Lua-скрипты (важно для корректности при конкурентности). Для rate limiting по пользователям в масштабе обычно достаточно фиксированного окна — оно очень экономно по памяти.

redis
# fixed window rate limiter (simple)
# INCR + EXPIRE on first request
count = INCR("rate:user:1")
if count == 1:
  EXPIRE("rate:user:1", 60)   # 60-second window
if count > 100:
  return "Rate limited"

# sliding window rate limiter (sorted set)
now = current_time_millis()
ZADD("rate:user:1", now, now)         # add current request
ZREMRANGEBYSCORE("rate:user:1", 0, now - 60000)  # remove old
EXPIRE("rate:user:1", 60)
count = ZCARD("rate:user:1")          # current count
if count > 100:
  return "Rate limited"

# token bucket (Lua script for atomicity)
# maintains a bucket of tokens refilled over time
# see: https://redis.io/docs/patterns/distributed-locks/

# GCRA (Generic Cell Rate Algorithm) — elegant single-key version

Рейтинги и ранжирование

Sorted sets делают рейтинги тривиальными: ZADD обновляет счёт, ZREVRANGE даёт топ-N, ZREVRANK — позицию игрока. ZINCRBY атомарно меняет счёт. Для рейтингов по периодам (день/неделя) используйте отдельный ключ на период с TTL. Пагинация — ZREVRANGE со смещением. Для процентилей комбинируйте ZCARD и ZREVRANK. Это один из самых естественных и мощных сценариев Redis.

redis
# sorted set = perfect for leaderboards
ZADD leaderboard 100 "alice" 250 "bob" 150 "carol"

# top 10 players (highest scores)
ZREVRANGE leaderboard 0 9 WITHSCORES

# a player's rank
ZREVRANK leaderboard "alice"     # 0-indexed from top

# 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

Хранилище сессий

Redis — классическое хранилище сессий: быстрое, поддерживает TTL (автоматическое истечение) и общее для всех серверов приложения. Храните сессию в хеше со скользящим TTL (обновляйте при каждом запросе). Ведите множество сессий пользователя для функции «выйти везде». В кластере используйте хеш-теги ({user:1}), чтобы сессия и индекс сессий пользователя попадали в один шард. Меняйте ID сессии при входе и изменении прав ради безопасности.

redis
# Redis is ideal for web sessions (fast, expiring, shared)
# store session as a hash with TTL
HSET session:abc123 user_id 1 last_active 1700000000 data "..."
EXPIRE session:abc123 1800     # 30-minute timeout

# update session (and refresh TTL)
HSET session:abc123 last_active 1700001000
EXPIRE session:abc123 1800     # sliding expiration

# destroy a session
DEL session:abc123

# list active sessions for a user (index by user)
SADD user:1:sessions "session:abc123"
SMEMBERS user:1:sessions       # all session IDs

# cluster-friendly: use a hash tag for the user's sessions
SADD {user:1}:sessions "session:abc123"
# enables multi-key operations on the user's session data

# rotate session ID on privilege change (security)
RENAME session:old session:new
EXPIRE session:new 1800
19

Lua-скрипты

Основы EVAL

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

redis
# run a Lua script inline
EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mykey "hello"
# 1 = number of keys
# mykey = KEYS[1]
# "hello" = ARGV[1]

# return types: string/integer/boolean/table (nil/true/false)
EVAL "return 42" 0
EVAL "return {1, 2, 3}" 0
EVAL "return redis.call('GET', KEYS[1])" 1 mykey

# 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 и кэш скриптов

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

redis
# load script once, get its SHA1
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# returns: "fa00..." (the SHA1)

# execute by hash (saves bandwidth on repeated calls)
EVALSHA "fa00..." 1 mykey

# check if a script is cached
SCRIPT EXISTS "fa00..." "abcd..."
# returns: 1) 1  2) 0

# flush the script cache
SCRIPT FLUSH

# list all running scripts (NOSCRIPT errors = cache miss -> reload)
SCRIPT DEBUG SYNC   # blocking debug mode
SCRIPT DEBUG NO     # disable

Атомарные операции

Lua-скрипты — канонический способ делать атомарные многошаговые операции в Redis (без гонок MULTI/EXEC). Compare-and-set, захват семафора и миграция очередей выигрывают от этого. Скрипты блокируют сервер на время выполнения — держите их короткими и избегайте циклов по множеству ключей (они могут застопорить других клиентов). Для очень долгой работы используйте Redis Functions (Redis 7.0+), которые объявляются и версионируются как хранимые процедуры.

redis
# atomic compare-and-set (only update if value matches)
local cur = redis.call('GET', KEYS[1])
if cur == ARGV[1] then
  return redis.call('SET', KEYS[1], ARGV[2])
end
return 0

# atomic 'decrement if positive' (semaphore / rate limit)
local val = tonumber(redis.call('GET', KEYS[1]) or 0)
if val > 0 then
  redis.call('DECR', KEYS[1])
  return 1
end
return 0

# atomic list pop + push (move between queues)
local item = redis.call('RPOP', KEYS[1])
if item then
  redis.call('LPUSH', KEYS[2], item)
end
return item

Redis Functions (7.0+)

Redis Functions (7.0+) — современная замена ad-hoc EVAL-скриптам: они регистрируются, имеют имена и версии, как хранимые процедуры в базах данных. Библиотека объединяет несколько функций; FCALL вызывает их. Functions сохраняются в RDB/AOF (переживают перезапуски), в отличие от эфемерного кэша EVAL. Они делают скриптинг поддерживаемым для нетривиальной логики и проще поддаются аудиту и версионированию.

redis
# register a library of functions
FUNCTION LOAD "#!lua name=mylib
redis.register_function('myset', function(keys, args)
  return redis.call('SET', keys[1], args[1])
end)

redis.register_function('double', function(keys, args)
  local v = tonumber(redis.call('GET', keys[1]))
  return redis.call('SET', keys[1], v * 2)
end)
"

# call a function
FCALL myset 1 mykey "hello"
FCALL double 1 counter

# list libraries
FUNCTION LIST
FUNCTION LIST WITHCODE

# delete a library
FUNCTION DELETE mylib

# dump and restore (for backup / migration)
FUNCTION DUMP
FUNCTION RESTORE <payload>

Отладка скриптов

Используйте redis.log() для вывода сообщений в лог Redis без влияния на возвращаемые значения. redis-cli --ldb — интерактивный Lua-отладчик: ставьте точки останова, выполняйте по шагам, смотрите локальные переменные. SCRIPT DEBUG SYNC заставляет сервер блокироваться на скрипте, чтобы отладчик мог идти по шагам. Всегда тестируйте скрипты на стейджинге — зацикленный скрипт может заблокировать весь сервер Redis. Держите скрипты детерминированными (без random/времени) для корректной репликации.

redis
# LOG writes to the Redis log (visible in redis-cli)
EVAL "redis.log(redis.LOG_NOTICE, 'hello from lua'); return 1" 0
# levels: LOG_DEBUG, LOG_VERBOSE, LOG_NOTICE, LOG_WARNING

# return the error object on pcall failure
EVAL "local ok, err = pcall(function()
  error('something broke')
end)
return {ok=tostring(ok), err=tostring(err)}" 0

# debugger (Redis 5.0+)
SCRIPT DEBUG SYNC   # synchronous, blocking
TDEBUG              # step / continue / print
# use redis-cli --ldb to launch debugger:
#   redis-cli --ldb --eval myscript.lua key1 key2 , arg1 arg2

# print variables in the debugger
print myvar
step
continue
20

Мониторинг и поиск проблем

INFO и LATENCY

INFO — самая важная команда мониторинга: она сообщает память, клиентов, репликацию и пропускную способность за один вызов. Следите за mem_fragmentation_ratio (идеально ~1.0–1.5); >1.5 означает потери памяти, <1 — что Redis свопится (катастрофа для задержек). LATENCY DOCTOR анализирует недавние медленные события и предлагает исправления. Сравнивайте keyspace_misses и keyspace_hits, чтобы отслеживать долю попаданий в кэш.

redis
# INFO: server, clients, memory, stats, replication, cpu
INFO                # everything
INFO memory         # memory section only
INFO replication    # replica lag, master link
INFO stats          # ops/sec, keyspace hits/misses

# key metrics to watch:
#   used_memory_rss        # RSS from OS (real footprint)
#   mem_fragmentation_ratio # >1.5 = fragmentation, <1 = swapping (bad!)
#   connected_clients       # client connections
#   instantaneous_ops_per_sec
#   keyspace_misses         # cache hit ratio = hits / (hits + misses)

# LATENCY: samples slow events
LATENCY HISTORY event-name
LATENCY DOCTOR      # human-readable diagnosis
LATENCY RESET

# LATENCY GRAPH event-name (ASCII art)

SLOWLOG и CLIENT LIST

SLOWLOG фиксирует команды медленнее заданного порога (по умолчанию 10 мс) — бесценно для поиска запросов, вызывающих всплески задержек. Операции вроде KEYS * и SMEMBERS на огромных множествах — частые виновники. CLIENT LIST показывает каждое соединение с временем простоя и текущей командой; используйте CLIENT SETNAME, чтобы помечать соединения приложения и понимать, какому пулу принадлежит зависший клиент.

redis
# SLOWLOG: record slow commands (over slowlog-log-slower-than, default 10ms)
CONFIG SET slowlog-log-slower-than 10000   # 10ms in microseconds
CONFIG SET slowlog-max-len 128             # keep last 128 entries

SLOWLOG GET          # last 10 slow commands
SLOWLOG GET 5        # last 5
SLOWLOG RESET        # clear

# each entry: id, timestamp, duration (us), command args, client, addr

# CLIENT LIST: see all connected clients
CLIENT LIST
# fields: id, addr, fd, name, age, idle, flags, db, cmd, ...

# kill a stuck client
CLIENT KILL ADDR 10.0.0.1:12345
CLIENT KILL ID 42

# name your connections for easier debugging
CLIENT SETNAME my-app-worker

MEMORY и OBJECT

MEMORY USAGE сообщает точное число байт для ключа (с SAMPLES 0 для полной точности на больших коллекциях). OBJECT ENCODING раскрывает внутренний формат Redis: небольшие структуры используют компактные кодировки (listpack, ziplist), эффективные по CPU и памяти, и автоматически переходят в хеш-таблицы и skiplist по мере роста. Понимание кодировки помогает объяснить, почему ключ больше или медленнее, чем ожидалось.

redis
# MEMORY USAGE: bytes used by a single key
MEMORY USAGE key
MEMORY USAGE bigset SAMPLES 0   # scan all elements (accurate)

# MEMORY STATS: detailed allocator stats
MEMORY STATS

# MEMORY DOCTOR: diagnosis
MEMORY DOCTOR

# OBJECT ENCODING: see internal representation
OBJECT ENCODING mylist      # quicklist / ziplist / listpack / hashtable
OBJECT REFCOUNT mykey
OBJECT IDLETIME mykey       # seconds since last access
OBJECT FREQ mykey           # LFU access frequency (only with maxmemory-policy LFU)

# why is my key so big? use DEBUG OBJECT (careful, can be slow)
DEBUG OBJECT mykey

Большие ключи и сканирование keyspace

Никогда не используйте KEYS в продакшене — она блокирует сервер. SCAN — неблокирующая альтернатива на курсоре; итерируйтесь, пока курсор не вернётся к 0. --bigkeys и --memkeys — CLI-помощники на базе SCAN, которые показывают самые большие ключи без блокировки. Большие ключи (особенно коллекции с миллионами элементов) вызывают всплески задержек при истечении и вытеснении — находите и делите их (например, шардируйте огромный sorted set по времени).

redis
# find big keys safely (production-safe, samples)
redis-cli --bigkeys
# scans keyspace, reports largest of each type

# more accurate: --memkeys (memory usage per key)
redis-cli --memkeys
redis-cli --hotkeys      # with LFU policy, finds frequently-accessed keys

# SCAN: iterate keys without blocking (never use KEYS *)
SCAN 0 MATCH user:* COUNT 100
# returns: next-cursor, [key1, key2, ...]
SCAN <next-cursor> ...
# cursor 0 = done

# scan a hash field-by-field
HSCAN myhash 0 COUNT 100
SSCAN myset 0 MATCH prefix*
ZSCAN myzset 0

# inspect a key's TTL (left to live)
TTL mykey           # seconds (-1 = no expire, -2 = no key)
PTTL mykey          # milliseconds

Здоровье кластера и failover

CLUSTER NODES и CLUSTER INFO — основные проверки здоровья кластера: ищите cluster_state:ok и что все слоты назначены (всего 16 384). CLUSTER FAILOVER на реплике запускает контролируемое переключение мастера; FORCE пропускает первичную синхронизацию (быстрее, но есть риск потери данных), а TAKEOVER обходит консенсус кластера (только в аварийных ситуациях). Всегда запускайте --cluster check после решардинга или инцидентов, чтобы поймать осиротевшие слоты и состояния split-brain.

redis
# cluster node status
CLUSTER NODES
# fields: id, addr, flags (master/slave/fail?), slots, ping/pong

# cluster-wide health
CLUSTER INFO
# cluster_state:ok / cluster_slots_assigned / cluster_slots_ok
# cluster_known_nodes

# slot ownership (which node owns a key)
CLUSTER KEYSLOT mykey    # hash slot number
CLUSTER COUNTKEYSINSLOT 1234

# reshard slots (use redis-cli --cluster reshard)
redis-cli --cluster reshard 127.0.0.1:7000 \
  --cluster-from <node-id> --cluster-to <node-id> \
  --cluster-slots 1000 --cluster-yes

# manual failover (on a replica)
CLUSTER FAILOVER          # wait for sync
CLUSTER FAILOVER FORCE    # skip sync (faster, slight data loss risk)
CLUSTER FAILOVER TAKEOVER # no consensus (emergency only)

# verify cluster after changes
redis-cli --cluster check 127.0.0.1:7000
redis-cli --cluster fix 127.0.0.1:7000    # auto-repair minor issues

Was this helpful?