Skip to content

Redis CLI Aide-mémoire

Magasin de structures de données en mémoire — commandes et usage du CLI.

01

Premiers pas

Se connecter au serveur Redis

redis-cli est le client en ligne de commande standard. Par défaut il se connecte à 127.0.0.1:6379. Utilisez -h pour l'hôte, -p pour le port, -a pour le mot de passe (ou la variable d'env REDISCLI_AUTH pour éviter de fuiter des secrets dans l'historique du shell). TLS exige --tls plus cert/key. Le schéma d'URL redis:// est supporté en Redis 6+, rediss:// pour TLS.

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

# connect to a remote host with custom port
redis-cli -h redis.example.com -p 6380

# connect with authentication
redis-cli -a "yourpassword"
redis-cli -h host -p 6379 -a "yourpassword"

# connect over TLS
redis-cli --tls --cert client.crt --key client.key -h host -p 6379

# connect using a URL (Redis 6+)
redis-cli redis://user:password@host:6379/0
redis-cli rediss://user:password@host:6379/0  # TLS

Options de connexion et modes

redis-cli supporte les modes interactif et ponctuel. Passer une commande en arguments l'exécute et quitte. Le mode pipe lit des commandes RESP/texte depuis stdin — génial pour le scripting et les chargements en masse. -n sélectionne la base logique. --stat et --latency sont des helpers de monitoring intégrés. --raw sort les valeurs sans préfixes de type, utile pour le piping.

redis-cli
# select a specific database index (0-15)
redis-cli -n 1            # use database 1

# run a single command and exit (non-interactive)
redis-cli GET mykey
redis-cli -h host PING

# pass command with arguments
redis-cli SET counter 100
redis-cli INCR counter

# read commands from stdin (pipe mode)
echo "SET k1 v1" | redis-cli
cat commands.txt | redis-cli

# repeat a command every second (watch mode)
redis-cli --stat
redis-cli --latency

# pretty-print JSON output (Redis 6+)
redis-cli --raw GET user:json

PING et test de connectivité

PING est le health check le plus simple — un Redis fonctionnel retourne PONG. --latency mesure en continu le temps d'aller-retour (utile pour diagnostiquer des problèmes réseau). --latency-dist montre un histogramme. --latency-history logue des stats glissantes. Utilisez-les pour établir une base de qualité de connexion avant tout réglage de performance.

redis-cli
# basic connectivity test
redis-cli ping
# PONG

# ping with a message (echoed back)
redis-cli PING "hello"
# "hello"

# test auth + connection in one shot
redis-cli -a password PING

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

# latency histogram
redis-cli --latency-dist

# latency history (rolling, every 15s by default)
redis-cli --latency-history -i 1

Astuces du mode interactif

Le mode interactif est un REPL des commandes Redis. HELP <commande> ou HELP @<groupe> montre la doc intégrée (sans Internet). CONNECT change de serveur dans la session. CLEAR efface l'écran. Le CLI détecte automatiquement les entrées multi-lignes pour les chaînes quotées. Préfixez ':' pour les commandes propres au CLI (comme :raw) vs les commandes Redis.

redis-cli
# start interactive mode
redis-cli

# inside the CLI:
127.0.0.1:6379> HELP SET       # command help
127.0.0.1:6379> HELP @string   # help for a command group
127.0.0.1:6379> SCAN 0         # any Redis command

# clear the screen
127.0.0.1:6379> CLEAR

# connect to a different server without restarting
127.0.0.1:6379> CONNECT host 6380

# exit
127.0.0.1:6379> EXIT
127.0.0.1:6379> QUIT

# multi-line input: end with a backslash
127.0.0.1:6379> SET mykey "this is \
a multi-line value"

# toggle raw output mode
127.0.0.1:6379> :raw

Sélection de base et bases

Les bases Redis sont des namespaces logiques (0-15) partageant la même mémoire — pas des schémas isolés. La plupart des apps n'utilisent que la db 0. FLUSHDB vide la base courante ; FLUSHALL tout (prudence !). Les bases multiples sont déconseillées au profit d'instances séparées ou de préfixes de clés, puisqu'elles partagent un seul thread.

redis-cli
# Redis has 16 logical databases (0-15) by default
SELECT 0     # switch to database 0
SELECT 15    # switch to database 15

# move a key to another database
MOVE mykey 1

# flush the current database (DESTRUCTIVE)
FLUSHDB

# flush ALL databases (VERY DESTRUCTIVE)
FLUSHALL

# get the number of keys in the current db
DBSIZE

# swap two databases (Redis 4.0+)
SWAPDB 0 1

Aide et découverte des commandes

COMMAND introspecte la table des commandes du serveur — utile pour découvrir les capacités et l'arité. COMMAND DOCS (7.0+) retourne de la documentation structurée. La commande HELP du CLI montre la doc hors ligne groupée par catégorie (@string, @hash, @server, etc.). Lancez 'redis-cli --help' pour tous les flags et options du CLI.

redis-cli
# list all commands (huge output)
COMMAND

# get details of a specific command
COMMAND INFO GET
COMMAND INFO SET HSET LPUSH

# structured documentation (Redis 7+)
COMMAND DOCS SET
COMMAND DOCS @string

# count available commands
COMMAND COUNT

# CLI help
redis-cli --help
redis-cli --version

# inside interactive mode
HELP
HELP @server
HELP @string
HELP @hash
HELP GETSET
02

Strings

SET et GET de base

SET/GET sont les opérations de chaînes fondamentales. NX = set si non existant (pour les verrous) ; XX = set si existant. EX/PX/EXAT/PXAT règlent l'expiration atomiquement (pas de course entre SET et EXPIRE). GETSET retourne la valeur précédente tout en réglant la nouvelle. Les chaînes sont binary-safe jusqu'à 512 Mo.

redis-cli
# set and get a key
SET mykey "Hello"
GET mykey               # "Hello"

# set only if not exists (NX) or only if exists (XX)
SET mykey "new" NX      # set only if key does NOT exist
SET mykey "new" XX      # set only if key DOES exist

# set with expiration (seconds / milliseconds)
SET token "abc" EX 3600    # expires in 3600s
SET token "abc" PX 60000   # expires in 60000ms

# set with expiration at a Unix timestamp
SET token "abc" EXAT 1700000000

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

# delete a key
DEL mykey

Compteurs numériques (INCR/DECR)

INCR/DECR sont atomiques — sûrs en accès concurrent sans verrous. Cela rend Redis idéal pour compteurs, rate limiting (INCR + EXPIRE) et génération d'IDs de séquence. INCRBYFLOAT supporte les décimales mais utilise la double précision (attention aux arrondis). Si la valeur n'est pas un entier, INCR retourne une erreur.

redis-cli
# increment a numeric string atomically
SET counter 100
INCR counter            # 101
INCRBY counter 10       # 111

# decrement
DECR counter            # 110
DECRBY counter 5        # 105

# floating point increment
SET price "10.50"
INCRBYFLOAT price 0.25  # "10.75"
INCRBYFLOAT price -1.00 # "9.75"

# all increment ops are atomic and concurrency-safe
# use for: counters, rate limiting, sequence IDs, stats

# INCR on a non-integer value returns an error
SET mystr "hello"
INCR mystr              # ERROR: value is not an integer

APPEND et opérations de chaînes

APPEND étend une chaîne (la crée si absente). STRLEN rapporte la longueur. GETRANGE/SETRANGE opèrent sur des sous-chaînes (binary-safe). GETDEL (6.2+) retourne et supprime atomiquement — utile pour les patterns de lecture unique. GETEX retourne atomiquement la valeur et règle un TTL — pratique pour rafraîchir l'expiration d'une session à la lecture.

redis-cli
# append to a string value
SET msg "Hello"
APPEND msg " World"     # "Hello World"

# get string length
STRLEN msg              # 11

# get substring
GETRANGE msg 0 4        # "Hello"
GETRANGE msg 6 -1       # "World"

# overwrite a substring (grows if needed)
SETRANGE msg 6 "Redis"  # "Hello Redis"

# get and delete atomically
GETDEL mykey            # returns value AND deletes key
# get and set expiration atomically (6.2+)
GETEX mykey EX 3600     # returns value, sets TTL

# append only if key exists
APPEND existing_key "more"

MSET et MGET (opérations en lot)

MSET/MGET batchent les opérations en un aller-retour — essentiel pour la performance (Redis est mono-threadé, donc l'overhead par commande compte). MSETNX est atomique : soit toutes les clés se règlent, soit aucune. Pour beaucoup de petites paires clé-valeur, envisagez de les grouper dans un hash (HSET) pour une meilleure efficacité mémoire via l'encodage listpack.

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

# get multiple keys at once
MGET k1 k2 k3           # 1) "v1" 2) "v2" 3) "v3"

# set multiple only if ALL keys are new
MSETNX k1 "v1" k4 "v4"  # 1 if all set, 0 if any existed

# MSET/MGET reduce round-trips — much faster than
# separate SET/GET calls in a loop

# get the length of a string value
STRLEN k1               # 2

# set multiple fields of different keys is not possible;
# for per-field updates use hashes (HSET)

# pipeline alternative in CLI:
printf '%s\n' "SET k1 v1" "SET k2 v2" "GET k1" | redis-cli --pipe-mode

Bitmaps (basés string)

Les bitmaps stockent des flags booléens pour jusqu'à 4 milliards d'utilisateurs en ~512 Mo — extrêmement économes. BITOP AND/OR/XOR/NOT combine les bitmaps (ex. utilisateurs actifs plusieurs jours). BITCOUNT compte les utilisateurs actifs. BITFIELD packe plusieurs petits compteurs dans une chaîne. Position = ID utilisateur. Cas d'usage : utilisateurs actifs quotidiens, feature flags.

redis-cli
# bitmaps are strings operated on at the bit level
# great for boolean flags on a large user base

# set bit at position (0 or 1)
SETBIT user:1:active 7 1    # user 1 active
GETBIT user:1:active 7      # 1

# count set bits
BITCOUNT user:1:active      # total bits set to 1

# bitwise operations between strings
SETBIT users:d1 5 1
SETBIT users:d2 5 1
BITOP AND active-both users:d1 users:d2
BITCOUNT active-both        # users active on both days

BITOP OR  active-either users:d1 users:d2
BITOP XOR diff         users:d1 users:d2

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

# bitfield: multiple counters in one string
BITFIELD mycnt SET u8 0 100
BITFIELD mycnt INCRBY u8 0 10

Expiration et TTL des chaînes

TTL retourne -2 pour les clés inexistantes et -1 pour les clés sans expiration. SET avec EX est atomique (pas de course entre SET et EXPIRE). KEEPTTL (6.0+) permet de mettre à jour une valeur en préservant son TTL — utile pour rafraîchir des valeurs cachées sans réinitialiser la fenêtre d'expiration. L'expiration est paresseuse (vérifiée à l'accès) plus des balayages périodiques en arrière-plan.

redis-cli
# set a key with expiration in one atomic command
SET session "data" EX 3600    # 1 hour
SET cache "value" PX 60000    # 60 seconds (ms)

# set expiration on an existing key
EXPIRE mykey 60               # 60 seconds
PEXPIRE mykey 60000           # 60 seconds (ms)
EXPIREAT mykey 1700000000     # Unix timestamp

# view remaining time to live
TTL mykey          # seconds (-1 = no expiry, -2 = no key)
PTTL mykey         # milliseconds

# remove expiration (make key persistent)
PERSIST mykey

# TTL with KEEPTTL option (6.0+): set value, keep existing TTL
SET mykey "newval" KEEPTTL
03

Lists

Opérations push et pop

Les listes sont à deux bouts : LPUSH+RPOP = file (FIFO), LPUSH+LPOP = pile (LIFO). BLPOP/BRPOP bloquent jusqu'à disponibilité d'un élément — le socle des files Redis (pas de polling). Réglez toujours un timeout sur BLPOP pour gérer les déconnexions. Les listes sont O(1) pour tête/queue mais O(N) pour l'accès au milieu.

redis-cli
# lists are ordered sequences of strings (linked lists)
LPUSH mylist "a" "b"      # list: [b, a]
RPUSH mylist "c"          # list: [b, a, c]

# pop from head or tail
LPOP mylist               # "b" (removes from head)
RPOP mylist               # "c" (removes from tail)

# pop multiple (6.2+)
LPOP mylist 2             # pop 2 from head

# get length
LLEN mylist               # 0

# blocking pop (waits if empty, up to timeout)
BLPOP queue:tasks 30      # blocks up to 30 seconds
BRPOP queue:tasks 0       # blocks forever

# push only if the list exists (don't create new key)
LPUSHX mylist "x"         # 0 if key doesn't exist

LRANGE et indexation

LRANGE 0 -1 retourne toute la liste. LINDEX est O(N) pour les éléments du milieu — les listes sont optimisées pour l'accès aux extrémités. LSET modifie par index. LINSERT est O(N) (avec parcimonie sur les grandes listes). LPOS trouve les positions d'éléments sans les retirer. Pour un accès aléatoire fréquent par index, une liste est un mauvais choix — considérez un sorted set.

redis-cli
# get a range of elements (0-based, negative from end)
LRANGE mylist 0 -1        # all elements
LRANGE mylist 0 2         # first 3 elements
LRANGE mylist -3 -1       # last 3 elements

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

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

# get length
LLEN mylist

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

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

Pops bloquants et files

BRPOPLPUSH/BLMOVE déplace un élément atomiquement de la source vers la destination — le consommateur peut le traiter en sécurité, et s'il crashe, l'élément reste dans la destination (motif de file fiable). Cela bat BRPOP+traitement car un crash après BRPOP perd l'élément. Après traitement, supprimez de la liste de destination.

redis-cli
# simple FIFO queue: LPUSH to add, RPOP to consume
LPUSH tasks "job1" "job2"
RPOP tasks                # "job1" (FIFO order)

# reliable queue with BRPOP (blocking, waits for work)
BRPOP tasks 0             # blocks until a task is available

# move items between lists atomically
RPOPLPUSH source destination  # move one item

# blocking move (reliable queue pattern)
BRPOPLPUSH source destination 30  # blocks up to 30s

# Redis 6.2+: BLMOVE replaces BRPOPLPUSH
BLMOVE source destination RIGHT LEFT 30

# capped queue (e.g., recent events)
LPUSH recent "event"
LTRIM recent 0 99         # keep latest 100

LREM, LSET et LTRIM

LTRIM est un motif courant pour plafonner la taille d'une liste (ex. ne garder que les 100 derniers événements). LREM retire par valeur (count : positif=tête, négatif=queue, 0=tous). LMPOP (7.0+) pop depuis plusieurs listes en un appel, utile pour les files priorisées. Pour des opérations fréquentes au milieu de liste, une liste est un mauvais choix.

redis-cli
# trim to a range (removes everything outside)
LTRIM mylist 0 99         # keep only first 100 elements
LTRIM mylist -50 -1       # keep only last 50

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

# pop and push in one atomic operation
RPOPLPUSH source dest

# pop from multiple lists (7.0+)
LMPOP 2 mylist1 mylist2 LEFT COUNT 3

# blocking pop from multiple lists (7.0+)
BLMPOP 30 2 mylist1 mylist2 LEFT COUNT 3

# remove a key only if it's a list (type-safe)
DEL mylist                # works on any type

Cas d'usage des listes

Les listes conviennent aux séquences à accès par extrémités : files, piles, feeds, tampons. LTRIM les rend idéales pour logs/feeds plafonnés. Pour le rate limiting, une liste de timestamps + LTRIM est une simple fenêtre glissante. Pour des files triées/priorisées, utilisez un sorted set. Les listes ne dédupliquent pas — utilisez un set pour cela.

redis-cli
# 1. Task queue (FIFO)
LPUSH tasks "process_order:123"
BRPOP tasks 30

# 2. Recent activity feed (capped)
LPUSH user:1:feed "post:99" "post:98"
LTRIM user:1:feed 0 49     # latest 50

# 3. Stack (LIFO)
LPUSH stack "item"
LPOP stack

# 4. Circular buffer (limited size)
LPUSH buffer "new"
LTRIM buffer 0 999         # keep 1000 items

# 5. Rate limiter (sliding window)
LPUSH rate:user:1 1700000000
LTRIM rate:user:1 0 99
LLEN rate:user:1           # request count in window

# 6. Chat history (capped)
LPUSH chat:room:1 "alice: hello"
LTRIM chat:room:1 0 999    # keep last 1000 messages
04

Sets

SADD, SMEMBERS et SISMEMBER

Les sets stockent des valeurs uniques — parfaits pour tags, catégories et déduplication. SISMEMBER est O(1) — bien plus rapide que vérifier une liste. SMEMBERS peut bloquer sur de grands sets ; utilisez SSCAN pour itérer. SMISMEMBER (7.4+) vérifie l'appartenance en lot, réduisant les aller-retours. Les sets utilisent intset (tableau trié) quand tous les membres sont entiers — très économes en mémoire.

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

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

# get all members (avoid on large sets)
SMEMBERS tags              # 1) "redis" 2) "db" 3) "cache"

# get the number of members
SCARD tags                 # 3

# remove a member
SREM tags "cache"          # 1

# check multiple memberships at once (7.4+)
SMISMEMBER tags "redis" "db" "missing"
# 1) 1  2) 1  3) 0

Opérations ensemblistes (union/inter/diff)

Les opérations ensemblistes sont le superpouvoir de Redis — union, intersection et différence en O(N) sans traitement client. Cas d'usage : amis communs (SINTER), visiteurs uniques (SUNION), filtrage par tags (SINTER d'ensembles de tags). SINTERCARD (7.0+) ne retourne que le compte, plus rapide quand on n'a pas besoin des membres. Stockez les résultats pour éviter les recalculs.

redis-cli
# set union, intersection, difference
SADD set1 "a" "b" "c"
SADD set2 "b" "c" "d"

# union (all unique members from all sets)
SUNION set1 set2           # a, b, c, d

# intersection (members in ALL sets)
SINTER set1 set2           # b, c

# difference (members in set1 but NOT in set2)
SDIFF set1 set2            # a

# store the result in a new set
SUNIONSTORE result set1 set2
SINTERSTORE result set1 set2
SDIFFSTORE result set1 set2

# count intersection without returning members (7.0+)
SINTERCARD 2 set1 set2 LIMIT 0

# operations on multiple sets at once
SUNION s1 s2 s3 s4

SREM, SMOVE et SPOP

SMOVE est atomique — utile pour les transitions d'état (ex. déplacer un utilisateur du set 'pending' à 'active'). SPOP retire des membres aléatoires (utile pour loterie/sharding). SRANDMEMBER ne retire pas. BSPOP (7.0+) bloque comme BLPOP mais pour les sets — utile pour les patterns événementiels où l'ordre n'importe pas. SREM retourne le compte réellement retiré.

redis-cli
# remove one or more members
SADD myset "a" "b" "c" "d"
SREM myset "a" "b"         # 2 (number removed)

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

# pop a random member (removes it)
SPOP myset                 # removes and returns one
SPOP myset 3               # removes and returns 3 (6.2+)

# get a random member (does NOT remove)
SRANDMEMBER myset          # one random member
SRANDMEMBER myset 3        # 3 random (may repeat)
SRANDMEMBER myset -3       # 3 unique random

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

# delete the entire set
DEL myset

Itération SSCAN

SSCAN est la façon sûre d'itérer les grands sets — SMEMBERS bloque le serveur pour des sets énormes. SSCAN est basé curseur : appelez répétitivement jusqu'à ce que le curseur revienne à 0. COUNT est un indice (peut retourner plus ou moins). SSCAN offre des garanties faibles : il peut retourner des doublons ou rater des membres ajoutés pendant l'itération, mais ne bloque jamais. Gérez toujours la boucle de curseur dans votre code.

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

# continue until cursor returns to 0
SSCAN myset <nextCursor> MATCH "pre*" COUNT 100

# iterate all members safely
cursor=0
while true:
  cursor, members = SSCAN myset cursor COUNT 100
  process(members)
  if cursor == 0: break

# scan with type filtering (7.0+ for SCAN, sets always same type)
# COUNT is a hint, not exact (may return more or fewer)

# MATCH pattern supports glob: *, ?, [abc]
SSCAN myset 0 MATCH "user:*" COUNT 1000

# for small sets, SMEMBERS is fine
# for large sets (>10k), always use SSCAN

Cas d'usage des sets

Les sets sont la référence pour l'unicité et les relations. Le motif SINTER pour followers/amis communs est un classique. Pour « visiteurs par jour » à cardinalité énorme, considérez HyperLogLog (approximatif mais 12 Ko fixes). Pour des données uniques ordonnées (leaderboards), utilisez un sorted set. Les sets sont sans ordre — si l'ordre compte, utilisez une liste ou un sorted set.

redis-cli
# 1. Tags / categories
SADD post:1:tags "redis" "db"
SADD post:2:tags "redis" "cache"
SINTER post:1:tags post:2:tags   # posts sharing "redis"

# 2. Unique visitors per day
SADD visitors:2025-01-01 "user:1" "user:2"
SCARD visitors:2025-01-01        # visitor count

# 3. Followers / following (mutual friends)
SADD user:1:following "user:2" "user:3"
SADD user:2:following "user:1" "user:3"
SINTER user:1:following user:2:following  # mutual follows

# 4. Blacklist / whitelist
SADD blacklist "ip:1.2.3.4"
SISMEMBER blacklist "ip:1.2.3.4"   # 1 = blocked

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

Sorted sets

ZADD, ZSCORE et ZRANK

Les sorted sets (zsets) sont la structure la plus puissante de Redis — membres uniques ordonnés par score, avec des opérations en O(log N). Les options ZADD (NX/XX/GT/LT) permettent des mises à jour conditionnelles : GT ne met à jour que si le nouveau score est plus grand (génial pour le suivi du « meilleur score »). Les scores sont des doubles ; les membres uniques. Les égalités se départagent lexicographiquement.

redis-cli
# sorted set: unique members ordered by a float score
ZADD leaderboard 100 "alice" 200 "bob" 150 "carol"

# update a score (re-add with new score)
ZADD leaderboard 250 "alice"   # alice's score becomes 250

# add with options (NX: only new, XX: only existing, GT/LT)
ZADD leaderboard NX 300 "new"        # only if new
ZADD leaderboard GT 300 "alice"      # only if new score > current
ZADD leaderboard LT 50 "alice"       # only if new score < current

# get a member's score
ZSCORE leaderboard "alice"      # "250"

# get a member's rank (0-based, ascending)
ZRANK leaderboard "alice"       # rank from lowest
ZREVRANK leaderboard "alice"    # rank from highest (0 = top)

# get the number of members
ZCARD leaderboard               # 3

# get multiple scores at once (6.2+)
ZMSCORE leaderboard "alice" "bob"  # ["250", "200"]

ZRANGE et ZREVRANGE

ZRANGE retourne par rang (index) ; avec BYSCORE il retourne par plage de score. Redis 6.2 a unifié ZRANGEBYSCORE/ZREVRANGE dans ZRANGE avec les options BYSCORE/BYLEX/REV. WITHSCORES inclut le score dans la sortie. Pour les leaderboards, ZRANGE 0 9 REV donne le top 10. ZRANGESTORE (6.2+) stocke le résultat dans une nouvelle clé pour un traitement ultérieur.

redis-cli
# get members by index range (ascending)
ZRANGE leaderboard 0 -1              # all, ascending
ZRANGE leaderboard 0 2               # first 3 (lowest scores)
ZRANGE leaderboard -3 -1             # last 3 (highest scores)

# descending order
ZREVRANGE leaderboard 0 2            # top 3 (highest scores)

# with scores
ZRANGE leaderboard 0 -1 WITHSCORES

# Redis 6.2+: unified ZRANGE with BYSCORE/REV options
ZRANGE leaderboard 100 200 BYSCORE
ZRANGE leaderboard 200 100 BYSCORE REV

# store a range in a new key (6.2+)
ZRANGESTORE top3 leaderboard 0 2 REV

# get by rank with scores
ZRANGE leaderboard 0 9 REV WITHSCORES  # top 10

# limit results (pagination)
ZRANGE leaderboard 0 -1 BYSCORE LIMIT 0 10

ZRANGEBYSCORE et ZCOUNT

ZRANGEBYSCORE retourne par plage de score ; le préfixe '(' rend un score exclusif. ZCOUNT donne le compte d'une plage sans fetch des membres. ZINCRBY ajuste atomiquement un score et re-trie — parfait pour les leaderboards en direct. ZREMRANGEBYRANK est excellent pour borner un zset (ex. ne garder que le top 1000).

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

# with pagination
ZRANGEBYSCORE leaderboard 100 200 LIMIT 0 10

# count members in a score range
ZCOUNT leaderboard 100 200

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

# remove a member
ZREM leaderboard "bob"

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

ZUNIONSTORE et ZINTERSTORE

ZUNIONSTORE/ZINTERSTORE combinent des zsets avec agrégation configurable (SUM/MIN/MAX) et poids — puissant pour le scoring pondéré (ex. pertinence = match_texte*2 + récence*1). Redis 6.2 a ajouté ZUNION/ZINTER/ZDIFF qui retournent les résultats sans stocker (une commande de moins). Ce sont des O(N*M) — prudence avec de nombreux grands sets. Le compte de sets doit précéder les noms de sets.

redis-cli
# combine multiple sorted sets
ZADD set1 1 "a" 2 "b"
ZADD set2 2 "a" 3 "c"

# union: sum scores by default (a = 1+2 = 3)
ZUNIONSTORE result 2 set1 set2
ZRANGE result 0 -1 WITHSCORES   # a=3, b=2, c=3

# specify aggregation: SUM (default), MIN, MAX
ZUNIONSTORE result 2 set1 set2 AGGREGATE MAX   # a=2, b=2, c=3

# apply weights to each set's scores
ZUNIONSTORE result 2 set1 set2 WEIGHTS 2 1     # set1 scores * 2

# intersection (only members in ALL sets)
ZINTERSTORE result 2 set1 set2                 # only "a"

# Redis 6.2+: return without storing
ZUNION 2 set1 set2 WITHSCORES
ZINTER 2 set1 set2 WITHSCORES
ZDIFF 2 set1 set2 WITHSCORES

# count intersection (7.0+)
ZINTERCARD 2 set1 set2 LIMIT 0

Plages lexicographiques (BYLEX)

BYLEX active les requêtes par plages sur les membres quand les scores sont égaux — transformant un sorted set en index de chaînes auto-trié. Cas d'usage : autocomplétion (stocker des mots avec score 0, interroger des plages de préfixes), dictionnaires triés. '[a' est inclusif, '(a' exclusif, '-' début, '+' fin. Ne marche de façon significative que quand tous les scores sont identiques.

redis-cli
# when all scores are equal, sorted sets act as a sorted string set
ZADD myset 0 "apple" 0 "banana" 0 "cherry" 0 "date"

# range by lexicographical order
ZRANGEBYLEX myset "[a" "[c"        # apple, banana, cherry
ZRANGEBYLEX myset "(a" "[c"        # banana, cherry (a exclusive)
ZRANGEBYLEX myset "-" "[b"         # from start to banana
ZRANGEBYLEX myset "[c" "+"         # cherry to end

# count in a lex range
ZLEXCOUNT myset "[a" "[c"          # 3

# remove by lex range
ZREMRANGEBYLEX myset "[a" "[b"

# Redis 6.2+: use ZRANGE with BYLEX
ZRANGE myset "[a" "[c" BYLEX

# limit results (pagination)
ZRANGEBYLEX myset "[a" "[c" LIMIT 0 10

Pattern de leaderboard

Les sorted sets rendent les leaderboards triviaux : ZADD pour mettre à jour les scores, ZREVRANGE pour le top N, ZREVRANK pour la position d'un joueur. ZINCRBY met à jour les scores atomiquement. Pour des leaderboards par tranches temporelles (quotidien/hebdo), utilisez une clé par période avec TTL. La pagination utilise ZREVRANGE avec offset. C'est l'un des cas d'usage les plus naturels et puissants de Redis.

redis-cli
# build a leaderboard
ZADD leaderboard 100 "alice" 250 "bob" 150 "carol"

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

# a player's rank (0 = top)
ZREVRANK leaderboard "alice"

# update a score (atomic)
ZINCRBY leaderboard 50 "alice"

# players within a score range (e.g., silver tier 100-199)
ZRANGEBYSCORE leaderboard 100 199

# percentile rank
total = ZCARD(leaderboard)
rank = ZREVRANK(leaderboard "alice")
# percentile = (total - rank) / total * 100

# pagination (page 3, 10 per page)
ZREVRANGE leaderboard 20 29 WITHSCORES

# time-bucketed leaderboards (weekly)
ZADD leaderboard:2025-W01 100 "alice"
EXPIRE leaderboard:2025-W01 604800   # 1 week TTL
06

Hashes

HSET, HGET et HGETALL

Les hashes sont idéals pour stocker des objets — une clé par objet, des champs par propriété. Cela bat la sérialisation JSON car on peut mettre à jour des champs individuels atomiquement (HSET) sans read-modify-write. HGETALL retourne tous les champs ; pour les grands hashes, préférez HSCAN. Les hashes utilisent l'encodage listpack quand petits (sous ~128 champs), les rendant économes en mémoire.

redis-cli
# a hash maps fields to values (like a small object)
HSET user:1 name "Alice" age 30 email "[email protected]"

# get a single field
HGET user:1 name            # "Alice"

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

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

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

# set a field only if it doesn't exist
HSETNX user:1 status "new"   # 1 if set, 0 if existed

# delete a field
HDEL user:1 email            # removes the email field

HMGET (get multi-champs)

HMGET fetch plusieurs champs en un aller-retour — bien plus rapide que des HGET séparés. HSET (depuis 4.0) accepte plusieurs paires champ-valeur, rendant HMSET déprécié. HKEYS/HVALS retournent tous les noms/valeurs de champs. HRANDFIELD (6.2+) sert à l'échantillonnage (ex. feature flags aléatoires). HGETALL bloque sur les grands hashes — utilisez HSCAN pour l'itération en production.

redis-cli
# get multiple fields at once
HMGET user:1 name age       # 1) "Alice" 2) "30"
HMGET user:1 name missing age  # 1) "Alice" 2) nil 3) "30"

# set multiple fields (HSET supports multiple field-value pairs)
HSET user:1 name "Bob" age 25 email "[email protected]"

# HMSET is deprecated (use HSET with multiple fields)
# HMSET still works but returns OK instead of count

# get all field names
HKEYS user:1                # 1) "name" 2) "age" 3) "email"

# get all values
HVALS user:1                # 1) "Alice" 2) "30" 3) "[email protected]"

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

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

HINCRBY (champs numériques)

HINCRBY sur les champs de hash est atomique — parfait pour des compteurs par utilisateur (compte de connexions, de vues, quantités de panier). HINCRBYFLOAT supporte les décimales. Les hashes s'auto-suppriment quand le dernier champ est retiré (HDEL). Cela rend les hashes la structure idéale pour des objets à compteurs numériques — bien plus efficace que des clés string séparées par compteur.

redis-cli
# increment a numeric field atomically
HSET user:1:stats logins 0
HINCRBY user:1:stats logins 1    # logins = 1
HINCRBY user:1:stats logins 1    # logins = 2
HINCRBY user:1:stats logins -1   # logins = 1

# increment by a specific amount
HINCRBY user:1:stats page_views 10

# floating point increment
HINCRBYFLOAT user:1:stats score 0.5

# all HINCRBY operations are atomic
# perfect for per-user/per-object counters

# use case: shopping cart (product_id -> quantity)
HSET cart:user:1 product:100 2
HINCRBY cart:user:1 product:100 1   # now 3
HINCRBY cart:user:1 product:100 -1  # now 2
HDEL cart:user:1 product:100        # remove item

HSCAN (itération de hash)

HGETALL bloque le serveur pour les grands hashes — utilisez HSCAN pour l'itération en production. HSCAN est basé curseur : appelez répétitivement jusqu'à ce que le curseur revienne à 0. COUNT est un indice. Les résultats viennent en tableau plat [champ, valeur, champ, valeur, ...] — appariez-les dans votre code. Pour des hashes à millions de champs, considérez le sharding en plusieurs clés.

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

# iterate all fields safely
cursor=0
while true:
  cursor, fields = HSCAN user:1 cursor COUNT 100
  process(fields)
  if cursor == 0: break

# HGETALL is fine for small hashes (< 100 fields)
# HSCAN is required for large hashes to avoid blocking

# match field names with glob patterns
HSCAN user:1 0 MATCH "user:*" COUNT 1000

# no VALUES-only option; results are [field, value, field, value, ...]
# pair them up in your code

# COUNT is a hint — may return more or fewer than requested

# HSCAN never blocks; safe for production use

Cas d'usage des hashes

Les hashes excellent pour les objets et compteurs groupés. Technique mémoire puissante : quand vous avez beaucoup de petites clés string, groupez-les dans un hash — l'encodage listpack a bien moins d'overhead que des milliers de clés individuelles (chacune avec ses métadonnées). Ce « key bucketing » peut réduire l'usage mémoire de 5 à 10x pour de petites valeurs. Le TTL au niveau champ (7.4+) est un ajout majeur.

redis-cli
# 1. Store an object (user profile, config)
HSET config:app name "MyApp" version "2.0" debug "off"

# 2. Per-user counters
HINCRBY user:1:stats logins 1
HINCRBY user:1:stats page_views 1
HGET user:1:stats logins

# 3. Shopping cart (product_id -> quantity)
HSET cart:user:1 product:100 2
HINCRBY cart:user:1 product:100 1
HDEL cart:user:1 product:100

# 4. Feature flags
HSET feature_flags user:1 new_ui 1 beta 0
HGET feature_flags user:1 new_ui   # 1

# 5. Session store with TTL
HSET session:abc user_id 1 data "..."
EXPIRE session:abc 1800   # 30 min

# 6. Hash field expiration (Redis 7.4+)
HEXPIRE user:1 60 FIELDS 1 session_token
HPTTL user:1 FIELDS 1 session_token
07

Gestion des clés

EXISTS, TYPE et DEL

EXISTS avec plusieurs clés retourne le compte de celles existant. TYPE retourne le type de structure de données — vérifiez toujours avant d'opérer pour éviter les erreurs WRONGTYPE (le type d'une clé est immuable pour sa durée de vie). DEL est bloquant et peut suspendre le serveur sur de grandes structures ; préférez UNLINK pour les grandes clés. TYPE retourne 'none' pour les clés inexistantes.

redis-cli
# check if a key exists
SET mykey "hello"
EXISTS mykey             # 1
EXISTS missing           # 0
EXISTS key1 key2 key3    # count of existing keys (multiple)

# get the type of a value
TYPE mykey               # "string"
TYPE mylist              # "list"
TYPE missing             # "none"

# delete one or more keys
DEL mykey                # 1 if deleted, 0 if not
DEL key1 key2 key3       # number of keys deleted

# delete is blocking for large keys — use UNLINK instead
# UNLINK deletes in a background thread

# check type before operating to avoid WRONGTYPE errors
TYPE mykey
# returns: string | list | hash | set | zset | stream | none

UNLINK (suppression async)

UNLINK (4.0+) est l'alternative non bloquante à DEL pour les grandes clés — il retire la clé du keyspace immédiatement mais libère la mémoire dans un thread d'arrière-plan, prévenant les suspensions du serveur. Pour des clés à millions d'éléments, utilisez toujours UNLINK. FLUSHDB ASYNC / FLUSHALL ASYNC font pareil pour la suppression en masse. Le pool de threads lazyfree gère la libération réelle.

redis-cli
# UNLINK: non-blocking delete (large keys)
UNLINK biglist bighash   # returns count of deleted keys

# UNLINK removes the key from the keyspace immediately
# but frees the memory in a background thread

# compare:
DEL biglist              # blocks until fully freed
UNLINK biglist           # returns immediately, frees later

# for small keys, DEL and UNLINK are equivalent
# for large keys (millions of elements), UNLINK is essential

# flush database asynchronously (non-blocking)
FLUSHDB ASYNC
FLUSHALL ASYNC

# check what's being freed in background
INFO memory | grep lazyfree

RENAME et RENAMENX

RENAME déplace atomiquement une clé vers un nouveau nom, écrasant toute clé de destination existante (et sa valeur). RENAMENX (6.2+) ne renomme que si la destination n'existe pas, prévenant les écrasements accidentels. Le TTL se préserve au renommage. RENAME est atomique — aucun autre client ne peut voir un état intermédiaire. Le renommage inter-bases n'est pas supporté ; utilisez MOVE ou DUMP/RESTORE.

redis-cli
# rename a key (overwrites destination if it exists)
SET oldkey "value"
RENAME oldkey newkey     # OK; oldkey is gone, newkey has "value"

# rename only if destination doesn't exist (6.2+)
RENAMENX oldkey newkey   # 1 if renamed, 0 if newkey already exists

# rename preserves the type and TTL
SET tempkey "data" EX 3600
RENAME tempkey permkey   # permkey now has TTL of ~3600s
TTL permkey              # ~3600

# rename across databases is not supported
# use MOVE + RENAME, or DUMP/RESTORE for cross-db moves

# type is immutable — rename keeps the type
TYPE permkey             # "string"

# renaming is atomic

KEYS vs SCAN

KEYS bloque le serveur pendant le scan de tout le keyspace — ne l'utilisez JAMAIS en production sur de grands jeux. SCAN est l'alternative sûre en production : basé curseur, non bloquant, retourne un curseur à suivre jusqu'à 0. SCAN peut retourner des doublons ou rater des clés ajoutées pendant l'itération, mais ne bloque jamais. COUNT est un indice (peut retourner plus ou moins). Gérez toujours la boucle de curseur dans votre code.

redis-cli
# KEYS: blocks the server while scanning — NEVER in production
KEYS *                   # all keys (DANGEROUS on large DBs)
KEYS user:*              # keys matching pattern
KEYS session:*

# SCAN: cursor-based iteration (non-blocking, production-safe)
SCAN 0 MATCH user:* COUNT 100
# returns: [nextCursor, [key1, key2, ...]]

# continue until cursor returns to 0
SCAN <nextCursor> MATCH user:* COUNT 100

# scan by type (7.0+)
SCAN 0 TYPE hash
SCAN 0 MATCH user:* TYPE string COUNT 100

# SCAN is weakly consistent:
# - may return duplicates
# - may miss keys added during iteration
# - but NEVER blocks the server

# COUNT is a hint, not exact

RANDOMKEY et DBSIZE

RANDOMKEY retourne une clé aléatoire sans la retirer — utile pour l'échantillonnage. DBSIZE retourne le compte exact de clés dans la base courante (O(1)). INFO keyspace montre les comptages par base avec les stats d'expiration (keys, expires, avg_ttl). Pour une clé aléatoire d'un type précis, pas de commande intégrée — utilisez SCAN + TYPE en boucle.

redis-cli
# get a random key (O(1), does not remove)
RANDOMKEY                # "user:1" or nil if db is empty

# get the number of keys in the current database
DBSIZE                   # 1234

# count keys across all databases (in a cluster)
# note: DBSIZE only counts the current db
SELECT 0; DBSIZE
SELECT 1; DBSIZE

# get keyspace info (keys per db with expiry info)
INFO keyspace
# db0:keys=1000,expires=500,avg_ttl=3600000
# db1:keys=50,expires=10,avg_ttl=60000

# scan with count for approximate size estimation
SCAN 0 COUNT 1           # get cursor + small sample

# find a random key of a specific type
# (no built-in; use SCAN + TYPE in a loop)

Commandes OBJECT

OBJECT ENCODING révèle la représentation interne (débogage mémoire). OBJECT IDLETIME trouve les clés froides (candidates à l'éviction). OBJECT FREQ ne marche qu'avec maxmemory-policy LFU. MEMORY USAGE avec SAMPLES 0 compte exactement (le défaut échantillonne pour les grandes collections). COMMAND DOCS (7.0+) retourne de la documentation structurée. Ces outils d'introspection aident à déboguer l'enflure mémoire.

redis-cli
# OBJECT subcommands for introspection
OBJECT ENCODING mykey     # internal encoding (embstr, raw, int, listpack, etc.)
OBJECT REFCOUNT mykey     # reference count
OBJECT IDLETIME mykey     # seconds since last access
OBJECT FREQ mykey         # access frequency (LFU mode only)

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

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

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

# the encoding changes automatically as the structure grows
# e.g., hash: listpack -> hashtable when fields exceed threshold

# help understand a command
COMMAND INFO GET
COMMAND DOCS SET          # structured docs (7.0+)
08

Expiration et persistance

EXPIRE et EXPIREAT

EXPIRE règle le TTL d'une clé existante ; SET avec EX/PX/EXAT/PXAT le fait atomiquement (préféré). Les options NX/GT/LT (7.0+) permettent un TTL conditionnel — utile pour « n'ajouter l'expiration que si absente » ou « seulement prolonger, jamais raccourcir ». TTL retourne -1 pour les clés sans expiration, -2 pour les inexistantes. L'expiration est paresseuse (vérifiée à l'accès) plus des balayages périodiques en arrière-plan.

redis-cli
# set expiration on an existing key (seconds)
SET mykey "value"
EXPIRE mykey 60              # expires in 60 seconds
EXPIRE mykey 60 NX           # only set TTL if none exists (7.0+)
EXPIRE mykey 60 GT           # only set if new TTL > current (7.0+)
EXPIRE mykey 60 LT           # only set if new TTL < current (7.0+)

# set expiration in milliseconds
PEXPIRE mykey 60000

# set expiration at a Unix timestamp
EXPIREAT mykey 1700000000       # seconds
PEXPIREAT mykey 1700000000000    # milliseconds

# set value AND expiration atomically (preferred)
SET token "abc" EX 3600
SET token "abc" PX 3600000
SET token "abc" EXAT 1700000000

# get remaining TTL
TTL mykey          # seconds (-1 = no expiry, -2 = no key)
PTTL mykey         # milliseconds

PERSIST (retirer le TTL)

PERSIST retire le TTL, rendant une clé persistante (la valeur demeure). GETEX (6.2+) retourne atomiquement la valeur et règle ou retire le TTL — utile pour rafraîchir l'expiration d'une session à la lecture (GETEX clé EX 3600) ou rendre permanente une clé temporaire (GETEX clé PERSIST). COPY (6.2+) copie une clé, optionnellement entre bases, sans la course du GET+SET.

redis-cli
# remove expiration (make key persistent)
SET session "data" EX 3600
TTL session               # 3600
PERSIST session           # 1 (success)
TTL session               # -1 (no expiry)

# PERSIST returns 1 if the TTL was removed, 0 if key had no TTL or doesn't exist

# copy a key with optional TTL handling (6.2+)
COPY source dest               # copy without TTL
COPY source dest REPLACE       # overwrite destination
COPY source dest DB 1          # copy to another database

# GETEX: get value and optionally set/remove TTL (6.2+)
GETEX mykey EX 3600       # returns value, sets 3600s TTL
GETEX mykey PERSIST       # returns value, removes TTL

# note: PERSIST only removes TTL; the key and value remain

SAVE et BGSAVE (RDB)

SAVE bloque le serveur jusqu'à la fin du snapshot — ne l'utilisez jamais en production. BGSAVE fork le processus (copy-on-write) pour ne pas bloquer le thread principal, mais de grands jeux peuvent causer des pics mémoire au fork. Les règles 'save' déclenchent des snapshots automatiques selon le taux de changement. RDB est compact et idéal pour les backups mais risque de perdre les données écrites après le dernier snapshot.

redis-cli
# SAVE: synchronous snapshot (BLOCKS the server until done)
SAVE                     # blocks — use only in maintenance windows

# BGSAVE: background snapshot (non-blocking, forks a child)
BGSAVE                   # returns immediately, saves in background
LASTSAVE                 # Unix timestamp of the last successful save

# check if a BGSAVE is in progress
INFO persistence | grep rdb_bgsave_in_progress

# configure automatic snapshots in redis.conf:
#   save 3600 1     # save if >= 1 key changed in 3600s
#   save 300 100    # save if >= 100 keys changed in 300s
#   save 60 10000   # save if >= 10000 keys changed in 60s
#   save ""         # disable RDB entirely

# RDB file location
CONFIG GET dbfilename    # "dump.rdb"
CONFIG GET dir           # "/var/lib/redis"

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

BGREWRITEAOF (compaction AOF)

AOF ajoute chaque commande d'écriture à un log — bien plus durable que RDB (au plus 1 seconde de perte avec everysec). 'always' fsync à chaque écriture (très lent, réservé aux données critiques). BGREWRITEAOF compacte le log (le réécrit comme l'ensemble minimal de commandes). Redis 7 utilise un format AOF multi-parties (base RDB + log incrémental) — appenddirname héberge les parties.

redis-cli
# AOF: logs every write command (durable, replayable)
# enable in redis.conf:
#   appendonly yes
#   appendfilename "appendonly.aof"

# fsync policies:
#   appendfsync always    # fsync every write (safest, slowest)
#   appendfsync everysec  # fsync once per second (default, balanced)
#   appendfsync no        # let OS decide (fastest, risk of data loss)

# trigger AOF rewrite (compacts the log)
BGREWRITEAOF             # non-blocking, rewrites in background

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

# check AOF status
INFO persistence | grep aof

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

# Redis 7: multi-part AOF (base + incremental files)
CONFIG GET appenddirname   # "appendonlydir"

Configuration de la persistance

CONFIG SET change les réglages à l'exécution (pas de redémarrage) ; CONFIG REWRITE les persiste dans redis.conf. La mise en place de production recommandée est l'hybride RDB + AOF : RDB pour un redémarrage rapide et les backups, AOF pour une perte de données minimale. Depuis Redis 7, l'AOF commence par un snapshot de base RDB suivi de commandes incrémentales — combinant chargement rapide et durabilité.

redis-cli
# view current persistence settings
CONFIG GET save
CONFIG GET appendonly
CONFIG GET appendfsync
CONFIG GET dir
CONFIG GET dbfilename
CONFIG GET appendfilename

# enable AOF at runtime
CONFIG SET appendonly yes

# change fsync policy at runtime
CONFIG SET appendfsync everysec

# disable RDB snapshots
CONFIG SET save ""

# persist config changes to redis.conf
CONFIG REWRITE

# hybrid persistence (recommended):
# RDB for fast restart + AOF for durability
# redis.conf:
#   save 3600 1
#   appendonly yes
#   aof-use-rdb-preamble yes   # RDB header in AOF (faster load)

# check persistence status
INFO persistence

Backup et restauration

Backupez régulièrement le fichier RDB (compact, rapide) — c'est un snapshot cohérent même pendant que Redis tourne (copy-on-write). Pour l'AOF, backupez tout le répertoire appendonly (multi-parties Redis 7). Restaurez en arrêtant Redis, remplaçant les fichiers et relançant. Pour récupérer d'une mauvaise commande, éditez l'AOF pour la retirer avant redémarrage. redis-cli --rdb effectue un backup en ligne sans toucher directement au filesystem.

redis-cli
# backup: copy the RDB file while Redis runs
BGSAVE
# wait for LASTSAVE to update, then copy the file
cp /var/lib/redis/dump.rdb /backup/dump-$(date +%F).rdb

# AOF backup: copy the AOF manifest + files (Redis 7)
cp -r /var/lib/redis/appendonlydir /backup/

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

# for point-in-time recovery from AOF:
# edit the AOF file to remove unwanted commands, then restart

# RDB file analysis (offline, safe)
redis-check-rdb /var/lib/redis/dump.rdb
redis-check-aof /var/lib/redis/appendonly.aof

# fix a truncated AOF
redis-check-aof --fix /var/lib/redis/appendonly.aof

# online backup with --rdb (dumps RDB to stdout/file)
redis-cli --rdb /backup/dump.rdb
09

Pub/Sub

SUBSCRIBE et UNSUBSCRIBE

SUBSCRIBE bloque le client pour recevoir des messages d'un ou plusieurs canaux. Un client abonné ne peut appeler que SUBSCRIBE/UNSUBSCRIBE/PSUBSCRIBE/PUNSUBSCRIBE/PING/QUIT — aucune autre commande. PUBSUB introspecte l'état pub/sub (canaux actifs, comptages d'abonnés). Les messages sont fire-and-forget : si aucun abonné n'écoute, le message est perdu. Pour une livraison fiable, utilisez Streams.

redis-cli
# subscribe to channels (in one client, blocks)
SUBSCRIBE news alerts

# the client now listens for messages:
# 1) "subscribe" 2) "news" 3) 1
# 1) "subscribe" 2) "alerts" 3) 2

# unsubscribe from specific channels
UNSUBSCRIBE news
UNSUBSCRIBE news alerts

# unsubscribe from ALL channels
UNSUBSCRIBE

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

# count active subscriptions (in another client)
PUBSUB CHANNELS           # list active channels
PUBSUB NUMSUB news        # subscriber count for "news"

PUBLISH

PUBLISH retourne le nombre d'abonnés ayant reçu le message (0 si aucun). Impossible de récupérer un message après publication — si aucun abonné n'écoute, il est perdu. PUBSUB CHANNELS liste les canaux actifs (avec au moins un abonné) ; PUBSUB NUMSUB retourne les comptages d'abonnés. Pour une messagerie fiable et rejouable, utilisez Streams (XADD/XREAD).

redis-cli
# publish a message to a channel (from another client)
PUBLISH news "Breaking: Redis 7.4 released"
# returns: number of subscribers that received the message

# publish to a channel with no subscribers
PUBLISH empty "hello"
# returns: 0 (message is lost)

# publish to multiple channels (separate PUBLISH calls)
PUBLISH news "msg1"
PUBLISH alerts "msg2"

# pub/sub has no persistence, no replay, no consumer groups
# subscribers must be connected to receive messages

# check how many clients are listening
PUBSUB NUMSUB news
PUBSUB NUMSUB news alerts    # multiple channels

# list active channels (with pattern)
PUBSUB CHANNELS              # all active channels
PUBSUB CHANNELS news:*       # channels matching pattern

PSUBSCRIBE (abonnement par motif)

PSUBSCRIBE s'abonne aux canaux correspondant à des motifs glob — puissant pour le routage d'événements (ex. user:*:login attrape tous les événements de connexion utilisateur). Un message correspondant à la fois à un abonnement direct et à un motif est livré deux fois. Les abonnés par motif reçoivent des événements 'pmessage' avec le motif, le canal et le message. PUNSUBSCRIBE annule les abonnements par motif.

redis-cli
# subscribe to channels matching a glob pattern
PSUBSCRIBE news.*
PSUBSCRIBE user:*:login
PSUBSCRIBE events:*

# patterns use glob syntax:
#   *    matches any sequence
#   ?    matches one character
#   [ab] matches 'a' or 'b'

# unsubscribe from patterns
PUNSUBSCRIBE news.*
PUNSUBSCRIBE               # unsubscribe from ALL patterns

# a message matching both a direct subscription and a pattern
# is delivered twice (once for each)

# pattern subscribers receive:
# 1) "pmessage" 2) "news.*" 3) "news.tech" 4) "the message"

# use case: event routing
PSUBSCRIBE user:*:login       # all user logins
PSUBSCRIBE order:*:created    # all order creations
PSUBSCRIBE cache:*:invalidate # cache invalidation events

Pub/Sub shardé (7.0+)

Le Pub/Sub shardé (7.0+) résout un problème du mode Cluster : le Pub/Sub ordinaire broadcast chaque PUBLISH à tous les nœuds du cluster, gaspillant la bande passante. Le Pub/Sub shardé route les messages seulement vers le shard possédant la clé du canal — bien plus efficace dans les grands clusters. Utilisez SSUBSCRIBE/SPUBLISH dans les déploiements Cluster. Le nom du canal détermine le shard (comme une clé).

redis-cli
# regular Pub/Sub broadcasts to ALL cluster nodes (expensive)
# sharded Pub/Sub routes messages only to the shard owning the channel

# subscribe to a shard channel
SSUBSCRIBE mychannel

# publish to a shard channel
SPUBLISH mychannel "hello"

# sharded pub/sub uses the channel name for shard routing
# so messages only travel within one shard (more efficient)

# use sharded pub/sub in a Redis Cluster to avoid
# broadcasting messages to every node

# regular SUBSCRIBE/PUBLISH still work in cluster mode
# but they broadcast to all shards (cluster-wide overhead)

# check shard channel subscribers (7.0+)
PUBSUB SHARDCHANNELS
PUBSUB SHARDNUMSUB mychannel

Notifications keyspace

Les notifications keyspace laissent les clients réagir aux événements du cycle de vie des clés (set, delete, expire, evict). Configurez avec notify-keyspace-events. Elles sont fire-and-forget (sans persistance) et non fiables — si le serveur Redis redémarre, les événements en attente sont perdus. Pour un traitement d'événements fiable, utilisez Streams. Les notifications keyspace sont parfaites pour les effets de bord comme le nettoyage ou le réchauffement de cache.

redis-cli
# enable keyspace notifications (disabled by default)
CONFIG SET notify-keyspace-events "KEA"
# K = keyspace events, E = keyevent events
# g = generic (DEL, EXPIRE, ...), $ = string, l = list
# h = hash, s = set, z = sorted set, x = expired, e = evicted
# A = all except m (m = keymiss)

# subscribe to events on a specific key
SUBSCRIBE __keyspace@0__:mykey
# publishes "set", "del", "expire", etc.

# subscribe to events of a specific type
SUBSCRIBE __keyevent@0__:del
# publishes the key name that was deleted

# example: react when a key expires
SUBSCRIBE __keyspace@0__:session:abc
# receives "expired" when the key TTL ends

# example: react to all expired keys
SUBSCRIBE __keyevent@0__:expired

# check current setting
CONFIG GET notify-keyspace-events
10

Transactions

MULTI et EXEC

MULTI/EXEC groupe les commandes en un bloc atomique et séquentiel — aucun autre client ne peut s'intercaler. Les commandes se mettent en file (retournant QUEUED) et s'exécutent ensemble à EXEC. Une erreur de mise en file (mauvais nom de commande) avorte toute la transaction. Une erreur à l'exécution (mauvais type sur une clé) ne saute que cette commande — le reste s'exécute quand même. Différent des transactions SQL.

redis-cli
# MULTI starts a transaction; commands are queued
MULTI
SET counter 1
INCR counter
INCR counter
GET counter
EXEC
# returns: 1) OK  2) 2  3) 3  4) "3"

# all queued commands execute atomically (no interleaving)
# other clients cannot run commands between MULTI and EXEC

# each queued command returns "QUEUED" until EXEC
MULTI
SET x 1
# "QUEUED"
INCR x
# "QUEUED"
EXEC
# 1) OK 2) 2

# the transaction is atomic: all or nothing (at queuing time)

DISCARD (annuler la transaction)

DISCARD annule une transaction, vidant toutes les commandes en file et libérant la connexion du mode transaction. Il efface aussi les clés WATCHées (voir WATCH). Après DISCARD, le client peut émettre des commandes normales à nouveau. DISCARD est l'équivalent du « rollback » — mais notez que Redis ne supporte pas le rollback partiel dans EXEC ; les erreurs à l'exécution sautent la commande fautive mais committent le reste.

redis-cli
# DISCARD cancels a transaction (clears all queued commands)
MULTI
SET x 1
INCR x
DISCARD
# OK — no commands are executed

# after DISCARD, the connection returns to normal mode
GET x
# (nil) or the previous value — nothing changed

# DISCARD also clears all WATCHed keys
WATCH counter
MULTI
INCR counter
DISCARD
# counter is no longer watched

# you must call MULTI before DISCARD
DISCARD
# ERR DISCARD without MULTI

WATCH (verrouillage optimiste)

WATCH implémente le verrouillage optimiste : si une clé surveillée change entre WATCH et EXEC, la transaction est avortée (EXEC retourne nil). C'est le motif Redis standard pour l'atomicité read-modify-write (puisque Redis n'a pas de verrous de lignes). Rejouez toujours sur nil. WATCH est vérifié au moment de EXEC. UNWATCH annule les watches (aussi à la déconnexion). Une clé surveillée modifiée par le même client déclenche aussi l'abandon.

redis-cli
# WATCH monitors keys; if any change before EXEC, transaction aborts
WATCH counter
val = GET counter          # read current value
MULTI
INCR counter               # queue the update
EXEC                       # nil if counter changed -> retry

# typical pattern: read-modify-write with retry
WATCH key
current = GET key
new_value = compute(current)
MULTI
SET key new_value
EXEC
# if EXEC returns nil, the key changed — loop and retry

# UNWATCH cancels all watches
UNWATCH

# WATCH is checked at EXEC time, not during queuing
# if a watched key is modified (by any client, including yourself),
# EXEC returns nil and the transaction is not executed

UNWATCH et cas limites de WATCH

Après EXEC (que la transaction ait committé ou été avortée par WATCH), tous les watches sont automatiquement effacés. Pareil pour DISCARD. Pour rejouer une boucle de verrouillage optimiste, il faut rappeler WATCH avant le prochain MULTI. WATCH dans MULTI est une erreur — WATCH doit toujours précéder MULTI. UNWATCH sert surtout à annuler des watches sans entrer en transaction.

redis-cli
# UNWATCH cancels all watches
WATCH key1 key2
UNWATCH                    # both keys are no longer watched

# WATCH inside a MULTI is not allowed (error)
MULTI
WATCH key
# ERR WATCH inside MULTI is not allowed

# after EXEC (success or abort), watches are cleared
WATCH key
MULTI
SET key "new"
EXEC
# key is no longer watched after EXEC

# after DISCARD, watches are cleared
WATCH key
MULTI
DISCARD
# key is no longer watched

# re-WATCH after EXEC to retry the optimistic lock loop
WATCH key
val = GET key
MULTI
SET key newval
EXEC
# if nil, loop: WATCH key again, GET, MULTI, SET, EXEC

Gestion des erreurs de transaction

Redis a deux types d'erreurs dans les transactions. Les erreurs de mise en file (mauvais nom/arité de commande) avortent toute la transaction au moment d'EXEC (EXECABORT) — rien ne tourne. Les erreurs à l'exécution (ex. INCR sur un non-entier) ne sautent que la commande fautive — le reste s'exécute quand même. Il n'y a PAS de rollback. C'est une différence critique avec les bases SQL. Validez vos données avant MULTI pour éviter les erreurs d'exécution.

redis-cli
# two types of errors in transactions:

# 1. Queuing errors (bad command syntax) — aborts the WHOLE transaction
MULTI
SET key "value"
INCRBY key "notanumber"   # error during queuing (wrong arity/type at parse)
GET key
EXEC
# EXECABORT Transaction discarded because of previous errors.
# NOTHING executes — not even the SET

# 2. Runtime errors (wrong type at execution) — skips ONLY that command
SET key "stringvalue"
MULTI
INCR key                  # queues fine (syntax OK)
SET otherkey "ok"
EXEC
# 1) (error) ERR value is not an integer
# 2) OK
# the INCR failed but SET otherkey succeeded — no rollback!

# lesson: Redis transactions do NOT have rollback like SQL
11

Pipelining

Bases du pipeline

Le pipelining batche les commandes pour réduire les aller-retours réseau — drastiquement plus rapide que des commandes individuelles sur le réseau. Chaque aller-retour coûte la latence réseau (~0,1-1 ms) ; 1000 commandes individuelles = 100-1000 ms, mais pipeliné = ~1 ms. La plupart des bibliothèques clientes offrent une méthode pipeline/multi. redis-cli peut pipeliner via stdin. Le pipelining NE garantit PAS l'atomicité — d'autres clients peuvent s'intercaler.

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

# using redis-cli with stdin (simple pipeline):
printf '%s\n' "SET k1 v1" "SET k2 v2" "GET k1" | redis-cli
# OK
# OK
# "v1"

# using redis-cli --pipe (raw RESP, fastest for bulk loads):
# (see the data-import-export section for details)

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

# vs individual commands:
await redis.set("k1", "v1")    # round-trip 1
await redis.set("k2", "v2")    # round-trip 2
await redis.incr("counter")    # round-trip 3

MULTI vs pipelining

MULTI/EXEC garantit l'atomicité (aucun autre client ne peut s'intercaler) ET est automatiquement pipeliné par la plupart des bibliothèques clientes (donc aller-retours réduits aussi). Le pipelining simple réduit seulement les aller-retours — d'autres clients peuvent exécuter entre vos commandes pipelinées. Utilisez MULTI/EXEC quand vous avez besoin d'atomicité (ex. read-modify-write avec WATCH) ; le pipelining simple pour les opérations en masse où ordre/atomicité n'importent pas.

redis-cli
# MULTI/EXEC: atomic (no interleaving), pipelined automatically
MULTI
SET k1 v1
SET k2 v2
INCR counter
EXEC
# all 3 commands run atomically as one block

# Pipelining: NOT atomic, just batched (other clients can interleave)
# (in client code)
pipe.set("k1", "v1")
pipe.set("k2", "v2")
pipe.incr("counter")
pipe.exec()
# commands may interleave with other clients

# when to use which:
# - need atomicity (all-or-nothing)?      -> MULTI/EXEC
# - just want speed (bulk operations)?    -> pipelining
# - both?                                  -> MULTI/EXEC (auto-pipelined)

# MULTI/EXEC is automatically pipelined by most clients
# so you get atomicity + batch round-trips in one

Protocole RESP

RESP est le protocole filaire de Redis — simple, textuel et rapide. *N dénote un tableau de N éléments ; $N une bulk string de N octets ; + une simple chaîne ; : un entier ; - une erreur. Le mode --pipe de redis-cli accepte du RESP brut pour un chargement en masse à vitesse maximale (bien plus rapide que des commandes texte via stdin). Comprendre RESP aide au débogage et à bâtir des clients custom.

redis-cli
# RESP (REdis Serialization Protocol) is the wire format
# redis-cli sends RESP; you can also send it raw with --pipe

# simple command (PING) in RESP:
# *1\r\n$4\r\nPING\r\n

# SET key value in RESP:
# *3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n

# RESP types:
#   +OK      simple string
#   -ERR     error
#   :42      integer
#   $5\r\nhello   bulk string
#   *2\r\n...     array

# raw pipeline with RESP (fastest bulk insert):
# generate a RESP file and pipe it:
cat commands.resp | redis-cli --pipe

# --pipe mode expects raw RESP; checks reply counts
# output: "Last reply received from server: ..."
# "errors: 0, replies: N"

Pipeline dans les scripts shell

Le scripting shell avec redis-cli est un moyen courant de charger des données en masse ou d'exécuter des opérations batchées. L'approche la plus simple pipe des commandes texte via stdin (echo/cat | redis-cli). Pour la vitesse maximale, générez du RESP et utilisez le mode --pipe (un ordre de grandeur plus rapide pour les gros chargements). Les exemples de boucle bash montrent les deux approches — choisissez selon votre volume et vos besoins de performance.

redis-cli
# pipeline multiple commands via stdin
echo -e "SET k1 v1\nSET k2 v2\nGET k1\nGET k2" | redis-cli

# pipeline from a file
cat commands.txt | redis-cli

# pipeline with --pipe-mode (raw RESP, fastest)
# first generate RESP, then pipe:
redis-cli --pipe < commands.resp

# bulk insert example (bash, generate RESP):
for i in $(seq 1 1000); do
  printf '*3\r\n$3\r\nSET\r\n$4\r\nkey:\r\n$1\r\n%s\r\n' "$i"
done | redis-cli --pipe

# or simpler (text mode, slightly slower):
for i in $(seq 1 1000); do
  echo "SET key:$i value$i"
done | redis-cli

# --pipe-mode reports errors and throughput

Limites et bonnes pratiques du pipeline

Le pipelining est le plus grand levier de performance Redis, mais ne sur-pipelinez pas — les réponses en file consomment de la mémoire côté client et serveur. Batchez par groupes de 100 à 1000 commandes. Benchmark avec redis-benchmark -P pour trouver votre point idéal (le débit s'aplatit, la latence augmente avec de très grands pipelines). Pour les commandes dépendant de résultats précédents, utilisez des scripts Lua (atomiques, un seul aller-retour) au lieu de plusieurs appels pipelinés.

redis-cli
# don't pipeline too many commands at once
# (queued replies consume memory on both client and server)

# bad: 1 million commands in one pipeline
# -> huge memory buffer, potential timeout

# good: batch in groups of 100-1000
for batch in chunks(data, 500):
  pipe = redis.pipeline()
  for item in batch:
    pipe.set(item.key, item.value)
  pipe.exec()

# benchmark pipelining
redis-benchmark -t set -n 100000 -P 16   # -P = pipeline size
# try -P 1, 10, 100, 1000 to find the sweet spot

# use pipelining for:
# - bulk imports
# - batch reads (MGET is better for simple multi-get)
# - pre-warming cache
# - reducing latency in high-RTT environments

# avoid pipelining for:
# - commands that depend on previous results (use Lua instead)
# - very large batches (split into chunks)
12

Scripting Lua

Bases d'EVAL

EVAL exécute des scripts Lua atomiquement — pendant qu'un script tourne, aucune autre commande ne s'exécute, idéal pour les opérations atomiques multi-étapes. KEYS et ARGV passent les données de l'appelant ; ne construisez jamais les clés par concaténation de chaînes dans le script (viole les règles du cluster — toutes les clés doivent être dans KEYS). redis.call lève les erreurs (arrête), redis.pcall les retourne. Les scripts se cachent par leur hash SHA1 pour EVALSHA.

redis-cli
# EVAL: run a Lua script inline
# EVAL "script" numkeys key1 key2 ... arg1 arg2 ...
EVAL "return redis.call('GET', KEYS[1])" 1 mykey
# 1 = number of keys
# mykey = KEYS[1]

# run a simple script (no keys)
EVAL "return 42" 0
EVAL "return {1, 2, 3}" 0
EVAL "return 'hello'" 0

# a check-and-set script:
EVAL "
  local cur = redis.call('GET', KEYS[1])
  if cur == ARGV[1] then
    return redis.call('SET', KEYS[1], ARGV[2])
  end
  return 0
" 1 mykey "expected" "newvalue"

# redis.call() raises error if command fails (stops script)
# redis.pcall() returns error as a table (can handle)
EVAL "local ok, err = pcall(redis.call, 'GET', 'missing'); return err" 0

EVALSHA et SCRIPT LOAD

EVALSHA exécute un script déjà chargé par son hash SHA1, évitant de renvoyer le corps du script à chaque appel — gain de bande passante majeur pour les apps qui rejouent le même script. Sur cache miss (après SCRIPT FLUSH ou redémarrage), Redis retourne NOSCRIPT ; les clients l'attrapent et retombent sur EVAL + SCRIPT LOAD. Utilisez toujours des bibliothèques (redis-py, ioredis) qui gèrent cela de façon transparente.

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

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

# check if a script is cached
SCRIPT EXISTS "fa00d1f0..." "abcd1234..."
# 1) 1  2) 0   (1 = exists, 0 = not cached)

# flush the script cache
SCRIPT FLUSH

# list all running scripts (during debug)
SCRIPT DEBUG SYNC   # blocking debug mode
SCRIPT DEBUG NO     # disable debugger

# typical client library pattern:
# 1. SCRIPT LOAD the script on startup
# 2. EVALSHA to run it (falls back to EVAL on NOSCRIPT error)

SCRIPT LOAD, FLUSH et EXISTS

SCRIPT LOAD cache un script et retourne son SHA1. SCRIPT EXISTS vérifie si des scripts sont cachés (utile après redémarrage). SCRIPT FLUSH efface tous les scripts cachés — les EVALSHA suivants retournent NOSCRIPT. SCRIPT KILL arrête un script longue durée, mais seulement s'il n'a encore rien écrit (pour préserver la cohérence) ; sinon il faut SHUTDOWN NOSAVE. Les scripts sont éphémères — utilisez Functions (7.0+) pour la persistance.

redis-cli
# SCRIPT LOAD: load a script without running it
SCRIPT LOAD "return redis.call('SET', KEYS[1], ARGV[1])"
# returns the SHA1 hash

# SCRIPT EXISTS: check if scripts are cached (after load or restart)
SCRIPT EXISTS "abc123..." "def456..."
# 1) 1  2) 0

# SCRIPT FLUSH: clear the script cache
SCRIPT FLUSH
# all EVALSHA calls will now return NOSCRIPT until scripts are reloaded

# SCRIPT KILL: stop a running script (only if it hasn't written yet)
SCRIPT KILL

# if the script has already executed a write command:
# SHUTDOWN NOSAVE is the only way to stop it (extreme measure)

# scripts are ephemeral — they don't survive a restart
# use Redis Functions (7.0+) for persistent scripts

# check the script cache size
INFO memory | grep script_cache

KEYS et ARGV

KEYS[] porte les noms de clés (essentiel pour le routage du cluster — le cluster s'en sert pour déterminer quel shard traite le script). ARGV[] porte valeurs et paramètres. Ne codez jamais en dur des noms de clés dans le script (ex. redis.call('GET', 'mykey')) — cela casse le routage du cluster car le cluster ne peut pas dire sur quel shard vit 'mykey'. Passez toujours les clés via KEYS[]. L'argument numkeys dit à Redis combien de KEYS attendre.

redis-cli
# KEYS[]: key names passed to the script
# ARGV[]: additional arguments (values, options)

# example: atomic increment with cap
EVAL "
  local current = tonumber(redis.call('GET', KEYS[1]) or 0)
  local max = tonumber(ARGV[1])
  if current >= max then
    return -1  -- cap reached
  end
  return redis.call('INCR', KEYS[1])
" 1 counter 100
# KEYS[1] = counter, ARGV[1] = 100

# example: move item between lists atomically
EVAL "
  local item = redis.call('RPOP', KEYS[1])
  if item then
    redis.call('LPUSH', KEYS[2], item)
  end
  return item
" 2 source_list dest_list

# NEVER hardcode key names in scripts (breaks cluster routing)
# always pass keys via KEYS[] so the cluster can route correctly

Opérations atomiques avec Lua

Les scripts Lua sont la façon canonique de faire des opérations multi-commandes atomiques dans Redis (pas de course MULTI/EXEC). Compare-and-set, acquisition de sémaphore, migrations de files et rate limiting en profitent tous. Les scripts bloquent le serveur pendant leur exécution — gardez-les courts et évitez les boucles sur beaucoup de clés (qui peuvent suspendre d'autres clients). Pour du travail très long, utilisez Redis Functions (Redis 7.0+) déclarées et versionnées comme des procédures stockées.

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

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

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

# atomic rate limiter (fixed window)
EVAL "
  local count = redis.call('INCR', KEYS[1])
  if count == 1 then
    redis.call('EXPIRE', KEYS[1], ARGV[1])
  end
  return count
" 1 rate:user:1 60

Redis Functions (7.0+)

Functions (7.0+) améliore les scripts EVAL : nommées (pas seulement hashées), organisées en bibliothèques et persistantes entre redémarrages (les scripts EVAL sont éphémères). Plus faciles à gérer et déployer. FCALL invoque une fonction par nom. Functions est la façon moderne d'ajouter de la logique serveur atomique. Comme les scripts, elles doivent être déterministes pour la réplication. FUNCTION DUMP/RESTORE permet backup et migration.

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

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

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

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

# delete a library
FUNCTION DELETE mylib

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

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

Gestion des connexions

CLIENT LIST

CLIENT LIST montre chaque client connecté avec adresse, âge, temps d'inactivité, commande courante et flags — inestimable pour trouver des fuites ou clients bloqués. Le champ 'idle' aide à repérer les connexions abandonnées. 'cmd' montre la dernière commande (utile pour trouver un client exécutant une commande lente). 'flags' indique le type de client (N=normal, M=master, S=slave/réplica, P=pubsub, b=bloqué). Filtrez par TYPE en 7.0+.

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

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

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

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

# count connected clients
CLIENT LIST | wc -l

CLIENT SETNAME et GETNAME

CLIENT SETNAME étiquette une connexion pour l'identifier dans CLIENT LIST — essentiel pour déboguer les fuites de connexions dans des environnements multi-services. Réglez le nom juste après la connexion dans votre app (ex. 'api-server:pid12345:pool1'). Les noms apparaissent dans le champ 'name' de CLIENT LIST. Cela rend trivial de trouver quel service détient une connexion bloquée ou qui fuite.

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

# get the current connection's name
CLIENT GETNAME

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

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

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

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

CLIENT KILL

CLIENT KILL déconnecte de force un client — utile pour retirer des connexions bloquées ou qui fuient. Kill par ADDR (ip:port), ID, TYPE ou USER (ACL). MAXAGE (7.0+) tue les clients inactifs depuis plus de N secondes. SKIPME yes (défaut) empêche de tuer votre propre connexion. Utilisez CLIENT LIST d'abord pour trouver la cible, puis CLIENT KILL pour la déconnecter. Les kills sont immédiats (pas d'arrêt gracieux).

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

# kill a client by ID
CLIENT KILL ID 42

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

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

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

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

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

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

CLIENT ID et INFO

CLIENT ID retourne un entier unique jamais réutilisé pour la connexion — utile pour logging et corrélation. CLIENT INFO donne des infos détaillées sur votre propre connexion. CLIENT NO-EVICT (6.0+) protège les écritures d'un client de déclencher l'éviction (utile pour les écritures critiques). CLIENT REPLY contrôle si le serveur envoie des réponses (OFF pour les chargements en masse fire-and-forget, SKIP pour une commande).

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

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

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

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

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

# CLIENT UNPAUSE: resume processing after CLIENT PAUSE
CLIENT UNPAUSE

CLIENT PAUSE

CLIENT PAUSE bloque l'exécution des commandes de tous les autres clients pendant N millisecondes — utile pour snapshots, migrations et failovers de cluster sûrs. Le mode WRITE (7.0+) ne suspend que les écritures en laissant les lectures continuer (moins perturbant). Le client qui pause n'est pas lui-même bloqué. Pendant la pause, les commandes en file consomment la mémoire, donc gardez les pauses courtes. CLIENT UNPAUSE reprend immédiatement.

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

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

# resume processing immediately
CLIENT UNPAUSE

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

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

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

Limites de connexions et timeout

maxclients plafonne les connexions concurrentes (défaut 10000) — relevez-le si vous avez beaucoup de serveurs d'app ou de pools. timeout déconnecte les clients inactifs (0 = jamais ; 300 s pour la sûreté). tcp-keepalive détecte les connexions TCP mortes (défaut 300 s). Chaque client consomme de la mémoire pour son buffer de sortie — surveillez avec INFO clients. client-output-buffer-limit empêche un client lent de consommer toute la mémoire du serveur (surtout important pour pub/sub et réplicas).

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

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

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

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

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

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

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

Gestion du serveur

Sections INFO

INFO est la commande de monitoring principale — elle rapporte mémoire, clients, réplication, persistance et stats en un coup. Filtrez les sections (INFO memory) pour réduire la sortie. Métriques clés : used_memory_rss (empreinte réelle), mem_fragmentation_ratio (idéal ~1,0-1,5), connected_clients, instantaneous_ops_per_sec, keyspace_hits/misses (ratio de hit de cache). TIME retourne l'heure serveur pour la synchronisation des horloges.

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

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

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

# get server time
TIME                    # [unix_timestamp, microseconds]

CONFIG GET et SET

CONFIG SET change les réglages à l'exécution sans redémarrer Redis — idéal pour les réglages. CONFIG GET récupère les valeurs courantes (utilisez des motifs comme CONFIG GET *memory*). Réglages d'exécution courants : maxmemory + politique d'éviction, seuil slowlog, timeout, seuils d'encodage. Tous les réglages ne sont pas changeables à l'exécution (ex. port, adresse bind exigent un redémarrage). Testez toujours les changements de config en staging d'abord.

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

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

# view all config (large output)
CONFIG GET *

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

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

CONFIG REWRITE

CONFIG REWRITE persiste les changements de CONFIG SET à l'exécution dans redis.conf — le fichier est mis à jour en place, préservant commentaires et structure. Cela comble l'écart entre changements à l'exécution et persistance entre redémarrages. Backupez toujours redis.conf avant REWRITE (rarement problématique, mais la sécurité d'abord). Versionnez votre redis.conf pour suivre et auditer les changements dans le temps.

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

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

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

# view the config file path
CONFIG GET *

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

# always back up redis.conf before CONFIG REWRITE

SLOWLOG

SLOWLOG enregistre les commandes plus lentes que le seuil configuré (défaut 10 ms = 10000us) — inestimable pour trouver les coupables de latence. Réglez le seuil à votre SLO (ex. 5 ms). Commandes lentes courantes : KEYS, SMEMBERS sur d'énormes sets, HGETALL sur d'énormes hashes, SORT sur de grandes données. slowlog-max-len plafonne le log (défaut 128). Seuil à 0 pour tout loguer (débogage seulement — overhead élevé).

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

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

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

# slowlog length
SLOWLOG LEN

# reset (clear all entries)
SLOWLOG RESET

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

MONITOR

MONITOR streame chaque commande de chaque client en temps réel — un outil de débogage puissant mais à HUGE impact de performance (divise à peu près le débit par deux). N'utilisez JAMAIS MONITOR en production sauf nécessité absolue et brièvement. Parfait en staging : connectez MONITOR, reproduisez le problème, voyez exactement quelles commandes votre app envoie. En production, préférez SLOWLOG, LATENCY MONITOR ou INFO commandstats.

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

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

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

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

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

# MONITOR is best used in a staging/dev environment

Monitoring LATENCY

LATENCY MONITOR suit les événements de latence (réglez un seuil, ex. 100 ms). LATENCY DOCTOR analyse les événements récents et suggère des correctifs — un excellent point de départ de diagnostic. Événements courants : 'command' (commandes lentes), 'fork' (délai de fork BGSAVE), 'expire-cycle' (balayage d'expiration), 'aof-write' (délai de fsync AOF). LATENCY GRAPH montre une timeline ASCII. Réglez le seuil à votre SLO et surveillez régulièrement.

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

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

# ASCII art graph of an event
LATENCY GRAPH command

# human-readable diagnosis and recommendations
LATENCY DOCTOR

# reset latency data
LATENCY RESET
LATENCY RESET event-name

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

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

Cluster

CLUSTER INFO

CLUSTER INFO donne un rapide résumé de santé : cluster_state doit être 'ok' (les 16384 slots couverts), cluster_slots_ok doit égaler 16384. cluster_known_nodes est le nombre total de nœuds ; cluster_size le nombre de primaires. Si cluster_state est 'fail', certains slots sont indisponibles (probablement un primaire et son réplica tous deux down). Vérifiez depuis n'importe quel nœud — l'info est globale au cluster.

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

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

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

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

CLUSTER NODES

CLUSTER NODES est la vue définitive de la topologie — une ligne par nœud avec ID, adresse, rôle (master/slave), le master suivi (pour les réplicas) et les plages de slots. Cherchez les flags 'fail' ou 'fail?' indiquant des nœuds malsains. Les plages de slots montrent quel primaire possède quels slots de hachage (0-16383). CLUSTER SHARDS (7.0+) groupe les nœuds par shard (primaire + ses réplicas).

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

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

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

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

# Redis 7.0+: shard view
CLUSTER SHARDS

CLUSTER KEYSLOT et COUNTKEYSINSLOT

CLUSTER KEYSLOT montre à quel slot une clé mappe (CRC16 % 16384). Les hash tags ({...}) forcent les clés liées dans le même slot — essentiel pour les opérations multi-clés (MGET, transactions, scripts Lua) en cluster. Utilisez redis-cli -c (mode cluster) pour suivre automatiquement les redirections MOVED. CLUSTER GETKEYSINSLOT récupère les clés d'un slot (utilisé pendant le resharding).

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

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

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

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

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

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

Hash tags

Les hash tags ({...}) forcent les clés dans le même slot, permettant les opérations multi-clés en cluster. Mais utilisez-les avec discernement — sur-utiliser un tag (ex. {users}:1, {users}:2) crée un hotspot sur un shard. Concevez les hash tags autour des patterns d'accès : groupez les clés accédées ensemble (les données d'un utilisateur, les articles d'une commande) mais séparez les clés sans lien. C'est le défi de modélisation de données en cluster.

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

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

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

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

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

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

CLUSTER FAILOVER

Le failover de cluster est automatique quand un primaire est injoignable au-delà de cluster-node-timeout (défaut 15 s). Le failover manuel sert à la maintenance (mises à niveau sans interruption) : FAILOVER est gracieux (attend la sync de réplication), FORCE saute la sync (plus rapide, léger risque de perte de données), TAKEOVER contourne le consensus (urgence seulement, risque de split-brain). Après failover, l'ancien primaire devient réplica à son retour. Tournez toujours avec des réplicas en production.

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

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

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

# check failover status
CLUSTER INFO | grep cluster_state

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

Outil redis-cli --cluster

L'outil redis-cli --cluster gère les opérations de cluster complexes : création, resharding, rééquilibrage, ajout/retrait de nœuds, health checks et réparations. --cluster check est votre réflexe pour vérifier la santé du cluster après changements. --cluster fix répare automatiquement les problèmes mineurs (slots orphelins, etc.). --cluster call exécute une commande sur tous les nœuds. Utilisez-les plutôt que les commandes CLUSTER manuelles pour les tâches opérationnelles.

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

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

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

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

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

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

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

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

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

Sentinel (HA)

Mise en place Sentinel

Sentinel apporte la HA sans sharding : il surveille un primaire, promeut un réplica en cas d'échec et reconfigure les clients. Le quorum (le dernier nombre) est combien de sentinels doivent s'accorder que le primaire est down — réglez (N/2)+1 pour N sentinels. Déployez 3 sentinels sur des machines séparées pour la tolérance aux pannes. down-after-milliseconds doit être > au jitter réseau ; trop bas cause de faux failovers.

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

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

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

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

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

# sentinel auto-discovers other sentinels and replicas

SENTINEL masters et réplicas

SENTINEL masters liste tous les primaires surveillés ; SENTINEL master <nom> donne les détails (y compris num-slaves et num-other-sentinels). SENTINEL replicas montre les réplicas ; SENTINEL sentinels les sentinels pairs. ckquorum vérifie que vous avez assez de sentinels pour un quorum — lancez-le en monitoring. Toutes les grandes bibliothèques clientes Redis supportent Sentinel nativement (elles interrogent les sentinels pour trouver le primaire courant).

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

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

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

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

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

SENTINEL get-master-addr-by-name

SENTINEL get-master-addr-by-name retourne l'IP et le port du primaire courant — les clients l'appellent pour découvrir le primaire, puis s'y connectent. Au failover, les sentinels retournent l'adresse du nouveau primaire. Les clients devraient s'abonner aux événements +switch-master pour apprendre les failovers immédiatement. Ce pattern de découverte est intégré au mode Sentinel de toutes les grandes bibliothèques clientes Redis.

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

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

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

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

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

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

SENTINEL failover

SENTINEL failover déclenche un failover manuel (pour les mises à niveau glissantes/maintenance). Le failover automatique survient quand un primaire est down plus longtemps que down-after-milliseconds. Le failover est automatique mais cause une brève coupure d'écriture (secondes). Le leader élu choisit le réplica le plus à jour à promouvoir. Quand l'ancien primaire revient, il devient réplica — les écritures qu'il a acceptées pendant la partition réseau sont PERDUES (risque de split-brain).

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

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

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

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

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

Quorum et monitoring Sentinel

Le quorum est le nombre de sentinels qui doivent s'accorder que le primaire est down avant de déclencher le failover — réglez à la majorité (N/2+1) pour N sentinels. ckquorum vérifie que vous en avez assez. down-after-milliseconds doit être > au jitter réseau (30 s est sûr). failover-timeout plafonne la durée du failover. parallel-syncs contrôle combien de réplicas se resync simultanément (1 = sûr mais lent). Les sentinels mettent à jour leur config seuls aux changements de topologie.

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

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

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

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

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

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

# view sentinel configuration
SENTINEL masters
SENTINEL master mymaster

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

# Sentinel automatically updates its config file when topology changes
17

Monitoring

Commande MONITOR

MONITOR streame chaque commande de chaque client en temps réel. Le format de sortie est : timestamp [db addr_client] "commande" "args". Inestimable pour déboguer quelles commandes une app envoie réellement. Mais il divise à peu près le débit par deux — à réserver au staging/dev ou à un débogage production bref. Filtrez avec grep pour des patterns précis. Pour le monitoring de production, préférez SLOWLOG, INFO commandstats ou LATENCY MONITOR.

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

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

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

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

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

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

Monitoring LATENCY

LATENCY MONITOR suit les pics de latence par type d'événement. Réglez un seuil (ex. 100 ms) et Redis enregistre les événements le dépassant. LATENCY DOCTOR analyse les événements récents et suggère des correctifs — un excellent point de départ de diagnostic. LATENCY GRAPH montre une timeline ASCII. Coupables courants : 'fork' (BGSAVE sur grands jeux), 'expire-cycle' (expiration massive), 'aof-fsync-always' (fsync AOF). Réglez le seuil à votre SLO et surveillez régulièrement.

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

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

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

# ASCII art graph
LATENCY GRAPH command

# human-readable diagnosis and recommendations
LATENCY DOCTOR

# reset latency data
LATENCY RESET
LATENCY RESET command

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

# check threshold
CONFIG GET latency-monitor-threshold

MEMORY DOCTOR et STATS

MEMORY USAGE rapporte les octets d'une clé (SAMPLES 0 pour l'exactitude complète). MEMORY STATS donne des stats d'allocateur détaillées. MEMORY DOCTOR fournit un diagnostic automatisé (fragmentation, grandes clés, etc.). Surveillez mem_fragmentation_ratio : >1,5 gaspille la mémoire (fragmentation), <1 signifie que Redis swappe (catastrophique pour la latence). MEMORY PURGE tente de rendre la mémoire à l'OS. La défragmentation active (4.0+) récupère automatiquement la mémoire fragmentée.

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

# MEMORY STATS: detailed allocator stats
MEMORY STATS

# MEMORY DOCTOR: automated memory diagnosis
MEMORY DOCTOR

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

# check total memory used
INFO memory | grep used_memory_human

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

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

# active defragmentation (4.0+)
CONFIG SET activedefrag yes

Commandes DEBUG

Les commandes DEBUG servent au diagnostic et aux tests — avec prudence. DEBUG SLEEP teste comment votre app gère la latence (bloque le serveur). DEBUG OBJECT révèle l'encodage interne et le refcount d'une clé. DEBUG RELOAD sauve, vide et recharge le dataset (utile pour tester la persistance). Puissantes mais dangereuses — restreignez-les par ACL en production (catégorie -@admin ou -@dangerous). Ne lancez jamais DEBUG sur un primaire de production sans comprendre l'impact.

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

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

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

# DEBUG JMAP: memory map (jemalloc)
DEBUG JMAP

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

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

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

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

redis-cli --latency

redis-cli --latency mesure en continu le temps d'aller-retour — essentiel pour établir une base de performance réseau. --latency-history logue des stats glissantes toutes les 15 s (utilisez -i pour changer). --latency-dist montre un histogramme (visualise le jitter et la latence de queue). En mode cluster, vérifiez la latence de chaque nœud séparément. Établissez une base, puis surveillez les pics. Une latence >1 ms en localhost indique un problème (CPU, pression mémoire ou commandes lentes).

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

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

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

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

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

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

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

redis-cli --stat

redis-cli --stat est le 'top' de Redis — il montre un résumé rafraîchi des clés, mémoire, clients, clients bloqués, requêtes/s et connexions. Le (+N) à côté de requests montre le delta depuis le dernier échantillon. Utilisez-le pour des health checks rapides et repérer les anomalies (mémoire croissante, clients qui fuient, taux de requêtes en pic). La colonne 'child' montre si un enfant BGSAVE/BGREWRITEAOF tourne.

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

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

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

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

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

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

Sécurité

AUTH (mot de passe legacy)

AUTH est l'authentification à mot de passe unique legacy (avant Redis 6). En Redis 6+, utilisez les utilisateurs ACL (AUTH utilisateur motdepasse). Le flag -a expose le mot de passe dans l'historique du shell — préférez la variable d'environnement REDISCLI_AUTH. Utilisez toujours des mots de passe forts (64+ caractères aléatoires). En production, combinez AUTH à TLS, restrictions réseau (bind/pare-feu) et moindre privilège par ACL pour une défense en profondeur.

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

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

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

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

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

# remove password
CONFIG SET requirepass ""

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

ACL SETUSER

Les ACL de Redis 6+ remplacent le modèle de mot de passe unique — créez des utilisateurs avec permissions délimitées. La syntaxe : on (activé), >motdepasse, ~motif (motifs de clés), +commande/-commande, +@catégorie/-@catégorie (ex. +@read, -@dangerous). Créez toujours un utilisateur au moindre privilège pour chaque app. L'utilisateur par défaut existe toujours — réglez un mot de passe fort ou restreignez-le. Sauvez les ACL dans un fichier (ACL SAVE) pour la persistance.

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

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

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

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

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

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

ACL LIST et GETUSER

ACL LIST montre tous les utilisateurs en format de règles compact. ACL GETUSER donne les permissions détaillées d'un utilisateur (y compris mots de passe hachés, commandes autorisées/refusées, motifs de clés). ACL WHOAMI retourne l'utilisateur courant. ACL LOG (7.0+) enregistre les commandes refusées et échecs d'auth — utile pour l'audit de sécurité. ACL SAVE/LOAD gèrent le fichier ACL pour la persistance entre redémarrages.

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

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

# view current user
ACL WHOAMI
# "appuser"

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

# delete a user
ACL DELUSER appuser

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

# reload ACLs from file
ACL LOAD

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

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

ACL WHOAMI et DELUSER

ACL WHOAMI identifie l'utilisateur courant. ACL DELUSER retire un utilisateur (et déconnecte ses connexions actives). Mettre un utilisateur 'off' le désactive temporairement sans supprimer ses règles — utile pour suspendre un accès. ACL LOG enregistre les événements de sécurité (commandes refusées, auth échouée) — surveillez-le pour toute activité suspecte. Rotez régulièrement les mots de passe avec ACL SETUSER >nouveaumdp.

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

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

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

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

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

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

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

rename-command (désactiver des commandes)

rename-command (dans redis.conf) désactive ou renomme des commandes dangereuses — réglez à "" pour désactiver, ou une chaîne pour renommer. Il exige un redémarrage (non modifiable à l'exécution). En Redis 6+, préférez les ACL (-flushall, -@dangerous), modifiables à l'exécution et par utilisateur. Commandes à restreindre : FLUSHALL/FLUSHDB (perte de données), KEYS (bloque le serveur), CONFIG (sécurité), DEBUG (peut crasher), SHUTDOWN (arrête le serveur).

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

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

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

# view available commands (after rename/restrictions)
COMMAND

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

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

Chiffrement TLS/SSL

TLS chiffre les données en transit — essentiel en production, surtout sur réseaux non fiables. Redis 6+ supporte TLS nativement. mTLS (tls-auth-clients yes) exige que les clients présentent un certificat, fournissant l'authentification mutuelle sans mots de passe. Pour cluster/sentinel, activez TLS aussi sur la communication inter-nœuds. Port 0 désactive le texte en clair ; pendant la migration, faites tourner les deux ports temporairement. Utilisez toujours des certs signés par une CA appropriée en production.

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

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

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

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

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

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

Import et export de données

redis-cli --rdb (backup)

redis-cli --rdb effectue un backup en ligne — il streame le RDB vers un fichier sans toucher directement au filesystem du serveur. Non bloquant (utilise le fork en arrière-plan de BGSAVE) et sûr en production. Combiné à SSH, vous pouvez backuper un Redis distant vers un fichier local. Vérifiez les backups avec redis-check-rdb. Planifiez des backups réguliers via cron. Testez toujours les procédures de restauration — un backup non testé n'est pas un backup.

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

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

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

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

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

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

redis-cli --pipe (insertion en masse)

redis-cli --pipe est le moyen le plus rapide de charger des données en masse dans Redis — il streame du RESP brut et n'attend pas les réponses jusqu'à la fin. Générez le RESP avec printf ou un script. --pipe rapporte les erreurs et le total de réponses. Pour des chargements plus simples/petits, piper des commandes texte (echo | redis-cli) marche mais est plus lent. Benchmark toujours : --pipe peut charger des millions de clés en minutes. Surveillez la mémoire pendant les gros chargements.

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

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

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

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

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

DUMP et RESTORE

DUMP sérialise la valeur d'une clé en blob binaire (inclut type et valeur, mais pas le TTL — spécifiez le TTL dans RESTORE en millisecondes). RESTORE le désérialise dans une clé, marchant entre instances Redis différentes (génial pour les migrations). Le format sérialisé dépend de la version — un blob de Redis 4.x peut ne pas se charger en 7.x ; vérifiez toujours la compatibilité. Pour des copies intra-instance, préférez la commande native COPY (6.2+) à DUMP+RESTORE.

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

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

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

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

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

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

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

MIGRATE (déplacer entre serveurs)

MIGRATE déplace (ou copie) atomiquement une clé entre instances Redis — la clé n'est jamais aux deux endroits en même temps (atomique). C'est la brique du resharding de cluster. COPY garde la clé source ; par défaut elle est supprimée. REPLACE écrase une clé de destination existante. Pour plusieurs clés, passez une chaîne vide comme clé et listez-les avec KEYS. Réglez le timeout assez haut pour les grandes valeurs. MIGRATE est bloquant aux deux bouts pendant le transfert.

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

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

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

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

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

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

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

COPY (copie intra-instance)

COPY (6.2+) duplique une clé au sein de la même instance atomiquement — bien plus simple que DUMP+RESTORE. Il ne copie PAS le TTL par défaut (utilisez EXPIRE ensuite). COPY marche entre bases avec l'option DB. REPLACE écrase une destination existante. Pour les copies inter-instances, utilisez MIGRATE (atomique à travers le réseau). COPY est le remplaçant moderne du motif DUMP+RESTORE pour la duplication intra-instance.

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

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

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

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

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

redis-check-rdb et redis-check-aof

redis-check-rdb et redis-check-aof vérifient l'intégrité des fichiers de persistance — lancez-les toujours sur les backups avant restauration. redis-check-aof --fix récupère d'un AOF tronqué en retirant la queue incomplète (il demande confirmation). Redis 7 utilise un AOF multi-parties (base + incrémentaux) — vérifiez le fichier manifest. Ces outils sont en lecture seule sauf --fix, donc sûrs à exécuter à tout moment. Validez les backups religieusement — un backup non vérifié n'est pas un backup.

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

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

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

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

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

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

# always run these checks BEFORE replacing production data files
20

Tests de performance

Bases de redis-benchmark

redis-benchmark est l'outil de test de charge intégré de Redis — il simule des clients concurrents et rapporte le débit (requêtes/s) et les percentiles de latence. -t sélectionne les tests (PING, SET, GET, INCR, etc.) ; -n fixe le nombre de requêtes ; -d la taille du payload. Benchmark toujours sur du matériel équivalent à la production pour établir une base de performance. Les 50 clients parallèles par défaut sont un point de départ — réglez -c pour matcher votre vraie charge. Lancez les benchmarks avant et après les changements de config pour mesurer l'impact.

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

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

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

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

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

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

Réglages de pipeline et concurrence

Les deux plus grands leviers de débit sont -c (concurrence) et -P (taille du pipeline). -c augmente les clients parallèles (plus de requêtes en vol) ; -P batche les commandes par aller-retour (moins d'overhead réseau). Combinés, ils peuvent pousser le débit 10 à 20x. Le benchmark mono-client (-c 1) mesure la latence pure ; le multi-client mesure le débit. Des payloads plus grands (-d) déplacent le goulot vers la bande passante. Réglez toujours -c/-P pour matcher le comportement réel de votre bibliothèque cliente.

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

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

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

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

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

Percentiles de latence et sortie CSV

Regardez toujours les percentiles de latence (P50, P99, P99.9), pas seulement les moyennes — les moyennes cachent les pics de latence de queue qui nuisent à l'expérience utilisateur. Un P99 5x pire que le P50 indique du jitter (GC, réseau ou commandes lentes). --csv sort des résultats lisibles par machine pour suivre les tendances dans le temps. Sauvez les benchmarks avant et après les changements de config pour mesurer l'impact objectivement. Suivez P99 et requêtes/s ensemble — optimiser l'un au détriment de l'autre est un piège courant.

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

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

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

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

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

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

Benchmarking cluster et Lua

Le mode --cluster distribue les clés entre les slots du cluster — essentiel pour des benchmarks de cluster réalistes (les benchmarks mono-nœud ratent l'overhead de routage inter-slots). -r fixe la taille du keyspace aléatoire (utilisez une grande valeur pour éviter que toutes les ops ne frappent une seule clé, ce qui gonfle les chiffres via le cache mémoire). --eval benchmark des scripts Lua. --threads (Redis 6+) utilise plusieurs threads de benchmark — utile quand un seul thread ne peut pas générer assez de charge pour saturer le serveur. Utilisez toujours -r pour des chiffres réalistes.

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

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

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

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

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

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

--idle et warmup

--idle mesure l'overhead pur de connexion/réseau avec des PINGs seulement — la base que vous ne pouvez pas battre. Warm up toujours le serveur avant de mesurer (les caches froids sous-estiment la performance) : lancez d'abord un benchmark jetable, puis le mesuré. --loop tourne en continu (utile pour les tests de charge soutenue). --seed rend le keyspace aléatoire reproductible — essentiel pour les comparaisons A/B. --dbnum sélectionne la base (utilisez une base séparée pour ne pas polluer les données de production pendant les benchmarks).

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

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

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

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

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

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

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

Interprétation et pièges du benchmark

Les pièges du benchmark gonflent les chiffres de façon irréaliste : (1) les benchmarks localhost-only ratent la latence réseau ; (2) sans -r, toutes les ops frappent une seule clé (gonflées par le cache) ; (3) des payloads minuscules ne sollicitent pas mémoire/réseau ; (4) ignorer l'overhead de persistance (le fsync AOF peut couper le débit de 2 à 5x) ; (5) un seul thread de benchmark ne peut pas saturer un serveur multi-cœur. Un benchmark réaliste utilise -r (clés aléatoires), -d (payload réaliste), --threads (client multi-threadé) et teste avec persistance et réseau équivalents à la production. Divulguez toujours les paramètres du benchmark en partageant des chiffres.

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

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

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

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

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

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

Was this helpful?