Premiers pas
Se connecter à Redis
redis-cli est le client en ligne de commande standard. PING teste la connectivité (retourne PONG). Utilisez toujours la commande AUTH ou le flag -a en production. Évitez de mettre les mots de passe en ligne de commande dans des environnements partagés — utilisez plutôt la variable d'environnement REDISCLI_AUTH. Redis moderne (6+) supporte des utilisateurs ACL avec permissions délimitées.
# connect to a local server (default port 6379)
redis-cli
# connect with a specific host and port
redis-cli -h host.example.com -p 6380
# connect with authentication
redis-cli -a "yourpassword"
redis-cli -h host -p 6379 -a "yourpassword"
# connect over TLS
redis-cli --tls --cert client.crt --key client.key -h host -p 6379
# test the connection
PING # returns PONG
PING "hello" # returns "hello"Sélection de base et bases
Les bases Redis sont des namespaces logiques (numérotés 0-15), pas des schémas isolés — elles partagent la même mémoire. La plupart des applications n'utilisent que la db 0. FLUSHDB vide la base courante ; FLUSHALL tout. Les bases multiples sont déconseillées au profit d'instances Redis séparées ou de préfixes de clés, puisqu'elles partagent un seul thread et ne peuvent pas être configurées individuellement.
# Redis has 16 logical databases (0-15) by default
SELECT 0 # switch to database 0
SELECT 15 # switch to database 15
# move a key to another database
MOVE mykey 1
# flush the current database (DESTRUCTIVE)
FLUSHDB
# flush ALL databases (VERY DESTRUCTIVE)
FLUSHALL
# get the number of keys in the current db
DBSIZE
# get basic server info
INFO server
INFO memory
INFO replicationClés et opérations générales
KEYS bloque le serveur pendant le scan — ne l'utilisez jamais en production sur de grands jeux ; utilisez SCAN (basé curseur, non bloquant). Structurez les clés avec des deux-points (user:1:profile) pour la lisibilité. EX fixe l'expiration en secondes ; PX en millisecondes. TYPE retourne la structure de données (string, list, hash, set, zset, stream).
# set and get a key
SET user:1 "Alice"
GET user:1
# check if a key exists
EXISTS user:1 # 1 if exists, 0 if not
# delete keys
DEL user:1
DEL key1 key2 key3 # returns number deleted
# set a key with expiration (seconds)
SET session:abc "data" EX 3600
# find keys matching a pattern (avoid in production)
KEYS user:*
SCAN 0 MATCH user:* COUNT 100 # safer iteration
# rename a key
RENAME oldkey newkey
# get the type of a value stored at a key
TYPE user:1Expiration et TTL
TTL retourne -2 pour les clés inexistantes et -1 pour les clés sans expiration. L'expiration est paresseuse — Redis ne vérifie qu'à l'accès de la clé ou lors de balayages périodiques en arrière-plan. SET avec EX est atomique (pas de course entre SET et EXPIRE). Les clés expirées ne déclenchent pas d'événements par défaut ; activez les notifications keyspace si vous en avez besoin.
# set expiration on an existing key
EXPIRE user:1 60 # 60 seconds
EXPIREAT user:1 1700000000 # Unix timestamp
# set expiration in milliseconds
PEXPIRE user:1 60000
# view remaining time to live (seconds)
TTL user:1 # -2 if no key, -1 if no expiry
# view TTL in milliseconds
PTTL user:1
# remove expiration (make key persistent)
PERSIST user:1
# set value AND expiration atomically
SET token "abc" EX 3600SCAN et itération sûre
SCAN est l'alternative sûre en production à KEYS — il retourne un curseur à suivre jusqu'à 0. COUNT est un indice, pas exact (peut retourner plus ou moins). SCAN offre des garanties faibles : il peut retourner des doublons ou rater des clés ajoutées pendant l'itération, mais ne bloque jamais. Utilisez HSCAN/SSCAN/ZSCAN pour les types de collections. Gérez toujours la boucle de curseur dans votre code.
# SCAN: cursor-based iteration (non-blocking)
SCAN 0 MATCH user:* COUNT 100
# returns: [nextCursor, [key1, key2, ...]]
SCAN <nextCursor> MATCH user:* COUNT 100
# continue until cursor returns to 0
# scan a specific type
SCAN 0 TYPE hash
# HSCAN: iterate hash fields
HSCAN myhash 0 MATCH field* COUNT 100
# SSCAN: iterate set members
SSCAN myset 0 MATCH member* COUNT 100
# ZSCAN: iterate sorted set members
ZSCAN myzset 0 MATCH member* COUNT 100Aperçu des types de données
Structures de données cœur
Choisir la bonne structure de données est la compétence Redis clé. Strings pour compteurs/caches, hashes pour objets, lists pour files, sets pour unicité/tags, sorted sets pour leaderboards/classements, streams pour logs d'événements. Chaque opération sur une structure est atomique, donc les clients concurrents ne peuvent pas corrompre l'état. Choisissez la structure qui correspond à votre pattern d'accès.
# Redis is a data structure server, not just a key-value store
# Each key holds a typed data structure:
# String: binary-safe blob (up to 512MB)
SET key "value"
SET counter 100
# List: ordered, linked-list of strings
LPUSH mylist "a" "b"
RPUSH mylist "c"
# Hash: field-value map (like a small object)
HSET user:1 name "Alice" age 30
# Set: unordered collection of unique strings
SADD tags "redis" "db"
# Sorted Set (ZSet): set scored by a float
ZADD leaderboard 100 "alice" 200 "bob"
# Stream: append-only log with IDs
XADD mystream * field value
# Bitmap, HyperLogLog, Geo: built on strings/zsetsChoisir le bon type
Choisissez le type selon le pattern d'accès : besoin d'unicité ? Set. Besoin d'un ordre par score ? Sorted set. Besoin de mettre à jour un champ d'un objet ? Hash (pas une chaîne sérialisée). Besoin de comptages uniques approximatifs à l'échelle ? HyperLogLog (12 Ko pour des milliards d'éléments). Le bon type = code plus simple, opérations atomiques et économies mémoire drastiques.
# Use case -> data type mapping:
# Cache a string -> String
SET api:response "json_blob"
# Store an object -> Hash (one key, multiple fields)
HSET user:1 name "Alice" email "[email protected]" age 30
# Queue / stack -> List
LPUSH tasks "job1" # push to head
RPOP tasks # pop from tail (FIFO queue)
# Unique tags -> Set
SADD post:1:tags "redis" "db" "cache"
# Leaderboard -> Sorted Set
ZADD scores 100 "alice" 250 "bob"
ZREVRANGE scores 0 9 # top 10
# Event log -> Stream
XADD events * type click user 1
# Count unique -> HyperLogLog (approximate, fixed memory)
PFADD visitors "user1" "user2"Encodage mémoire
Redis utilise des encodages compacts (listpack, intset) pour les petites structures — économisant 5 à 10x la mémoire — et bascule automatiquement vers tables de hachage/skiplists à mesure qu'elles croissent. OBJECT ENCODING révèle l'encodage courant. MEMORY USAGE rapporte les octets. On peut régler le seuil (ex. hash-max-listpack-entries) mais les défauts sont bien choisis. Comprendre les encodages aide à planifier la capacité.
# Redis optimizes storage based on size
# Inspect the internal encoding of a key
OBJECT ENCODING mykey
# String encodings:
# "embstr" - short strings (< 44 bytes)
# "raw" - long strings
# "int" - integer values
# Hash/List/Set/ZSet encodings:
# "listpack" / "intset" - small (compact, memory-efficient)
# "hashtable" / "list" / "skiplist" - large (faster, more memory)
# check memory usage of a key
MEMORY USAGE mykey
# sample memory usage stats
MEMORY STATS
# the encoding changes automatically as the structure growsCommandes OBJECT et mémoire
OBJECT IDLETIME sert à trouver les clés de cache froides (rarement accédées). 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 (Redis 7+) retourne de la documentation structurée. Ces outils d'introspection aident à déboguer l'enflure mémoire et à régler les politiques d'éviction.
# OBJECT subcommands for introspection
OBJECT ENCODING mykey # internal encoding
OBJECT REFCOUNT mykey # reference count
OBJECT IDLETIME mykey # seconds since last access
OBJECT FREQ mykey # access frequency (LFU mode)
# check memory usage (bytes) of a key
MEMORY USAGE mykey
MEMORY USAGE mykey SAMPLES 0 # exact count
# total memory used by the server
INFO memory | grep used_memory_human
# help understand a command
COMMAND INFO GET
COMMAND DOCS SET
# COMMAND lists all commands (huge output)
COMMANDErreurs de type et vérification
Le type d'une clé est fixe pour sa durée de vie — impossible de réutiliser la même clé pour un type différent sans la supprimer d'abord. Les erreurs WRONGTYPE protègent contre la confusion accidentelle de types. Vérifiez toujours TYPE quand vous travaillez avec des clés d'origine inconnue. Ce typage strict explique pourquoi les commandes Redis sont préfixées par type (HSET vs SET vs SADD).
# each key has ONE type; using the wrong command fails
SET mykey "hello"
LPUSH mykey "x" # WRONGTYPE error
# WRONGTYPE Operation against a key holding the wrong kind of value
# check the type before operating
TYPE mykey # "string"
if [ "$(TYPE mykey)" = "string" ]; then ...
# TYPE returns: string|list|hash|set|zset|stream|none
# rename preserves the type
RENAME mykey newkey
TYPE newkey # still "string"
# type is immutable; delete + recreate to change types
DEL mykey
LPUSH mykey "x" # now a listStrings
Opérations de chaînes de base
Les strings sont binary-safe (peuvent contenir jusqu'à 512 Mo d'octets quelconques, images ou JSON inclus). SET avec NX est la primitive de verrou Redis classique (set si non existant). GETSET est atomique et utile pour échanger des configs. SETRANGE peut agrandir une chaîne. Pour des données structurées, préférez les Hashes aux chaînes JSON sérialisées — ils permettent des mises à jour au niveau champ.
# set and get
SET mykey "hello"
GET mykey # "hello"
# set only if not exists (NX) or only if exists (XX)
SET mykey "new" NX # set only if key does NOT exist
SET mykey "new" XX # set only if key DOES exist
SET mykey "new" EX 60 NX # with expiry, only if new
# get and set atomically (returns old value)
GETSET counter 0 # returns old value, sets new
# append to a string
APPEND mykey " world" # "hello world"
# get substring
GETRANGE mykey 0 4 # "hello"
SETRANGE mykey 6 "redis"# "hello redis"
# get string length
STRLEN mykey # 11Compteurs numériques
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. Les compteurs marchent au mieux combinés à EXPIRE pour des stats par tranches temporelles.
# increment a numeric string atomically
INCR counter # counter = counter + 1
INCRBY counter 10 # counter = counter + 10
# decrement
DECR counter # counter = counter - 1
DECRBY counter 5 # counter = counter - 5
# floating point operations
SET price "10.50"
INCRBYFLOAT price 0.25 # "10.75"
INCRBYFLOAT price -1.00 # "9.75"
# all increment ops are atomic and concurrency-safe
# use for: counters, rate limiting, sequence IDs, statsOpérations multi-clés
MSET/MGET batchent les opérations en un aller-retour — essentiel pour la performance (le modèle mono-thread de Redis rend l'overhead par commande significatif). MSETNX est atomique : soit toutes les clés se règlent, soit aucune (tout ou rien). GETDEL (6.2+) retourne et supprime atomiquement — utile pour les patterns de messages à lecture unique. Batchez les commandes dès que possible pour réduire la latence réseau.
# set multiple keys at once (atomic)
MSET k1 "v1" k2 "v2" k3 "v3"
# get multiple keys at once
MGET k1 k2 k3 # ["v1", "v2", "v3"]
# set multiple only if ALL keys are new
MSETNX k1 "v1" k4 "v4" # 1 if all set, 0 if any existed
# MSET/MGET reduce round-trips — much faster than
# separate SET/GET calls in a loop
# get the length of a string value
STRLEN k1 # 2
# atomic get-and-delete (useful for queues)
GETDEL mykey # returns value AND deletes keyBitmaps (basés string)
Les bitmaps stockent des flags booléens pour jusqu'à 4 milliards d'utilisateurs en ~512 Mo — extrêmement économes pour de grandes populations. BITOP AND/OR/XOR/NOT combine les bitmaps (ex. utilisateurs actifs plusieurs jours). BITCOUNT compte les utilisateurs actifs. Cas d'usage : utilisateurs actifs quotidiens, feature flags, suivi de présence. Position = ID utilisateur.
# bitmaps are strings operated on at the bit level
# great for boolean flags on a large user base
# set bit at position (0 or 1)
SETBIT user:1:active 7 1 # user 1 active
GETBIT user:1:active 7 # 1
# count set bits
BITCOUNT user:1:active # total bits set to 1
# bitwise operations between strings
SETBIT users:daily:2025-01-01 5 1
SETBIT users:daily:2025-01-02 5 1
BITOP AND active-both users:daily:2025-01-01 users:daily:2025-01-02
BITCOUNT active-both # users active on both days
# find the first set bit
BITPOS user:1:active 1 # position of first 1-bitOpérations bitfield
BITFIELD packe plusieurs petits compteurs dans une seule chaîne — ex. 1000 compteurs quotidiens en u8 dans 1 Ko. OVERFLOW SAT sature au max (bien pour des stats), FAIL retourne nil au débordement (bien pour des plafonds), WRAP boucle (défaut, généralement non voulu). Bien plus économe en mémoire que des clés séparées pour de nombreux petits compteurs.
# BITFIELD: multiple counters in one string (compact)
# store up to 2^63 counters, each 1-64 bits, in a single key
# set a 8-bit unsigned counter at offset 0
BITFIELD mycount SET u8 0 100
# increment a counter (with overflow control)
BITFIELD mycount INCRBY u8 0 10 # returns 110
BITFIELD mycount INCRBY u8 0 10 # returns 120
# overflow control: WRAP (default), SAT, FAIL
BITFIELD mycount OVERFLOW SAT INCRBY u8 0 200 # saturates at 255
BITFIELD mycount OVERFLOW FAIL INCRBY u8 0 999 # returns nil (overflow)
# read multiple counters in one call
BITFIELD mycount GET u8 0 GET u8 8 GET u8 16Hashes
Bases des hashes
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.
# a hash maps fields to values (like a small object)
HSET user:1 name "Alice" age 30 email "[email protected]"
# get a single field
HGET user:1 name # "Alice"
# get multiple fields
HMGET user:1 name age # ["Alice", "30"]
# get all fields and values
HGETALL user:1
# name -> Alice
# age -> 30
# email -> [email protected]
# get all field names or values
HKEYS user:1 # [name, age, email]
HVALS user:1 # [Alice, 30, [email protected]]
# get the number of fields
HLEN user:1 # 3Opérations sur champs de hash
HSETNX offre le « set si non existant » au niveau champ (utile pour l'init ponctuelle). HINCRBY sur les champs de hash est atomique — parfait pour des compteurs par utilisateur (compte de connexions, de vues). Les hashes s'auto-suppriment quand le dernier champ est retiré (HDEL). HMSET est déprécié depuis que HSET accepte plusieurs champs ; utilisez toujours HSET.
# set a field only if it doesn't exist
HSETNX user:1 status "new" # 1 if set, 0 if existed
# delete a field
HDEL user:1 email # removes the email field
# check if a field exists
HEXISTS user:1 name # 1 if exists, 0 if not
# increment a numeric field atomically
HINCRBY user:1 age 1 # age = 31
HINCRBY user:1 age -5 # age = 26
HINCRBYFLOAT user:1 score 0.5
# get the string length of a field's value
HSTRLEN user:1 name # 5 (length of "Alice")
# set multiple fields (same as HSET with multiple)
HMSET user:1 a 1 b 2 # deprecated, use HSETIté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. HRANDFIELD (6.2+) sert à l'échantillonnage (ex. feature flags aléatoires). Pour des hashes à millions de champs, envisagez de les casser en plusieurs clés par sharding.
# HSCAN: cursor-based iteration (for large hashes)
HSCAN user:1 0 MATCH "na*" COUNT 10
# returns [cursor, [field, value, field, value, ...]]
# iterate all fields
cursor=0
while true:
cursor, fields = HSCAN user:1 cursor COUNT 100
process(fields)
if cursor == 0: break
# HGETALL is fine for small hashes (< 100 fields)
# HSCAN is required for large hashes to avoid blocking
# get a random field
HRANDFIELD user:1 # one random field name
HRANDFIELD user:1 3 # 3 random field names
HRANDFIELD user:1 3 WITHVALUES # fields + valuesExpiration de hash (Redis 7.4+)
Le TTL au niveau champ (7.4+) est une fonctionnalité majeure des hashes — auparavant il fallait des clés séparées ou des contournements pour expirer des champs individuels. Utile pour des objets à durées de vie mixtes (un profil utilisateur où le token de session expire mais le nom persiste). Les vieilles versions de Redis exigent de stocker les champs expirant comme clés séparées avec leur propre EXPIRE.
# before 7.4, expiration was only at the key level
EXPIRE user:1 3600 # the whole hash expires
# Redis 7.4+: field-level TTL (HEXPIRE)
HEXPIRE user:1 60 FIELDS 1 session_token
# expires only the session_token field in 60 seconds
# get TTL of a specific field
HPTTL user:1 FIELDS 1 session_token
# persist a specific field (remove its TTL)
HPERSIST user:1 FIELDS 1 session_token
# get all fields and their expiration times
HEXPIRETIME user:1 FIELDS 1 session_tokenCas 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.
# 1. Store an object (user profile, config)
HSET config:app name "MyApp" version "2.0" debug "off"
# 2. Per-user counters
HINCRBY user:1:stats logins 1
HINCRBY user:1:stats page_views 1
HGET user:1:stats logins
# 3. Shopping cart (product_id -> quantity)
HSET cart:user:1 product:100 2
HINCRBY cart:user:1 product:100 1
HDEL cart:user:1 product:100
# 4. Feature flags
HSET feature_flags user:1 new_ui 1 beta 0
HGET feature_flags user:1 new_ui # 1
# 5. Group small key-value pairs into one hash (memory savings)
# instead of SET k1 v1; SET k2 v2 -> HSET bucket k1 v1 k2 v2Lists
Bases des listes (push/pop)
Les listes sont à deux bouts, donc 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.
# lists are ordered sequences of strings (linked lists)
# push to head (left) or tail (right)
LPUSH mylist "a" "b" # list: [b, a]
RPUSH mylist "c" # list: [b, a, c]
# pop from head or tail
LPOP mylist # "b" (removes from head)
RPOP mylist # "c" (removes from tail)
# pop multiple
LPOP mylist 2 # ["a", ...]
# get length
LLEN mylist # 0
# blocking pop (waits if empty, up to timeout)
BLPOP queue:tasks 30 # blocks up to 30 seconds
BRPOP queue:tasks 0 # blocks foreverIndexation et plages de liste
LRANGE 0 -1 retourne toute la liste. 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). LINDEX est O(N) pour les éléments du milieu — les listes sont optimisées pour l'accès aux extrémités. Pour un accès aléatoire par index, utilisez une autre structure.
# get element by index (0-based, O(N) traversal)
LINDEX mylist 0 # first element
LINDEX mylist -1 # last element
# get a range of elements
LRANGE mylist 0 -1 # all elements
LRANGE mylist 0 2 # first 3 elements
LRANGE mylist -3 -1 # last 3 elements
# set an element by index
LSET mylist 1 "new"
# get length
LLEN mylist
# trim to a range (removes everything outside)
LTRIM mylist 0 99 # keep only first 100 elements
# remove elements by value
LREM mylist 2 "value" # remove first 2 occurrences of "value"
LREM mylist -2 "value" # remove last 2 occurrencesListe comme file
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.
# simple FIFO queue: LPUSH to add, RPOP to consume
LPUSH tasks "job1" "job2"
RPOP tasks # "job1" (FIFO order)
# reliable queue with BRPOP (blocking, waits for work)
BRPOP tasks 0 # blocks until a task is available
# move items between lists atomically
LPUSH source "item"
RPOPLPUSH source destination # move one item
# blocking move (reliable queue pattern)
BRPOPLPUSH source destination 30 # blocks up to 30s
# Redis 6.2+: BLMOVE replaces BRPOPLPUSH
BLMOVE source destination RIGHT LEFT 30
# capped queue (e.g., recent events)
LPUSH recent "event"
LTRIM recent 0 99 # keep latest 100Insertion et retrait de liste
LINSERT est O(N) — à utiliser avec parcimonie sur les grandes listes. LPOS trouve les positions d'éléments sans les retirer. 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 — considérez un sorted set ou un autre modèle de données.
# insert before or after a pivot element
LINSERT mylist BEFORE "pivot" "new"
LINSERT mylist AFTER "pivot" "new"
# remove elements by value
LREM mylist 1 "value" # remove first occurrence from head
LREM mylist -1 "value" # remove first occurrence from tail
LREM mylist 0 "value" # remove ALL occurrences
# pop and push in one atomic operation
RPOPLPUSH source dest
# get and remove from both ends (6.2+)
LPOP mylist 2 # pop 2 from head
LMPOP 2 mylist LEFT COUNT 3 # (7.0+) pop from one of multiple lists
# find the position of an element (6.0+)
LPOS mylist "value"
LPOS mylist "value" RANK 2 # find 2nd occurrenceCas 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.
# 1. Task queue (FIFO)
LPUSH tasks "process_order:123"
BRPOP tasks 30
# 2. Recent activity feed (capped)
LPUSH user:1:feed "post:99" "post:98"
LTRIM user:1:feed 0 49 # latest 50
# 3. Stack (LIFO)
LPUSH stack "item"
LPOP stack
# 4. Circular buffer (limited size)
LPUSH buffer "new"
LTRIM buffer 0 999 # keep 1000 items
# 5. Rate limiter (sliding window)
LPUSH rate:user:1 <timestamp>
LTRIM rate:user:1 0 99
LLEN rate:user:1 # request count in windowSets
Bases des sets
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. SRANDMEMBER ne retire pas ; SPOP si. Les sets utilisent intset (tableau trié) quand tous les membres sont entiers — très économe en mémoire.
# sets: unordered collection of unique strings
SADD tags "redis" "db" "cache"
SADD tags "redis" # ignored (already exists)
# remove a member
SREM tags "cache"
# check membership
SISMEMBER tags "redis" # 1 if member, 0 if not
# get the number of members
SCARD tags # 2
# get all members (avoid on large sets)
SMEMBERS tags # ["redis", "db"]
# get a random member
SRANDMEMBER tags # one random member
SRANDMEMBER tags 3 # 3 random (may repeat)
SRANDMEMBER tags -3 # 3 unique random
# pop a random member (removes it)
SPOP tags # removes and returns oneOpérations ensemblistes
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.
# 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 0Itération et déplacement de set
SMOVE est atomique — utile pour les transitions d'état (ex. déplacer un utilisateur du set 'pending' à 'active'). SSCAN est la façon sûre d'itérer les grands sets. SMISMEMBER (7.4+) vérifie l'appartenance en lot, réduisant les aller-retours. BSPOP (7.0+) bloque comme BLPOP mais pour les sets — utile pour les patterns événementiels où l'ordre n'importe pas.
# SSCAN: cursor-based iteration for large sets
SSCAN myset 0 MATCH "pre*" COUNT 100
# returns [cursor, [member1, member2, ...]]
# move a member from one set to another atomically
SMOVE source dest "member"
# pop multiple random members (6.2+)
SPOP myset 3 # removes and returns 3 members
# blocking set pop (7.0+) - waits until a member exists
BSPOP myset 30 # blocks up to 30 seconds
# check multiple memberships at once (7.4+)
SMISMEMBER myset "a" "b" "c"
# returns [1, 0, 1]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.
# 1. Tags / categories
SADD post:1:tags "redis" "db"
SADD post:2:tags "redis" "cache"
SINTER post:1:tags post:2:tags # posts sharing "redis"
# 2. Unique visitors per day
SADD visitors:2025-01-01 "user:1" "user:2"
SCARD visitors:2025-01-01 # visitor count
# 3. Followers / following
SADD user:1:following "user:2" "user:3"
SADD user:2:following "user:1" "user:3"
SINTER user:1:following user:2:following # mutual follows
# 4. Blacklist / whitelist
SADD blacklist "ip:1.2.3.4"
SISMEMBER blacklist "ip:1.2.3.4"
# 5. Lottery / random selection
SADD participants "u1" "u2" "u3" "u4"
SPOP participants 1 # draw a winnerSets vs autres types
Le choix de type est la décision de conception Redis cœur. Set pour unicité + appartenance rapide (sans ordre). Sorted set pour classements/ordre (coûte plus de mémoire). List pour séquences avec doublons. Hash pour objets champ-valeur. Dans le doute, esquissez vos patterns d'accès : lectures, écritures, ordre et exigences d'unicité — le bon type devient évident.
# Set: unordered, unique, O(1) membership check
SADD myset "a" "b"
SISMEMBER myset "a" # O(1)
# Sorted Set: unique + ordered by score
ZADD myzset 1 "a" 2 "b"
ZRANK myzset "a" # 0 (rank)
# List: ordered, allows duplicates, O(N) search
LPUSH mylist "a" "a"
LPOS mylist "a" # 0 (first match)
# Hash: field-value pairs, no ordering
HSET myhash a 1 b 2
# Choose:
# - need uniqueness only? -> Set
# - need uniqueness + ordering? -> Sorted Set
# - need ordering + allow dups? -> List
# - need key-value mapping? -> HashSorted sets
Bases des sorted sets
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.
# sorted set: unique members ordered by a float score
ZADD leaderboard 100 "alice" 200 "bob" 150 "carol"
# update a score (re-add with new score)
ZADD leaderboard 250 "alice" # alice's score becomes 250
# add with options (NX: only new, XX: only existing, GT/LT: conditional)
ZADD leaderboard NX 300 "new"
ZADD leaderboard GT 300 "alice" # only if new score is greater
# get a member's score
ZSCORE leaderboard "alice" # "250"
# get a member's rank (0-based, ascending)
ZRANK leaderboard "alice" # rank from lowest
ZREVRANK leaderboard "alice" # rank from highest (0 = top)
# get the number of members
ZCARD leaderboard # 3Requêtes par plages
ZRANGE retourne par rang (index) ; ZRANGEBYSCORE par score. Le préfixe '(' rend un score exclusif. Redis 6.2 a unifié ces commandes dans ZRANGE avec les options BYSCORE/BYLEX/REV. WITHSCORES inclut le score dans la sortie. Pour les leaderboards, ZREVRANGE 0 9 donne le top 10. ZRANGESTORE (6.2+) stocke le résultat dans une nouvelle clé.
# get members by index range (ascending)
ZRANGE leaderboard 0 -1 # all, ascending
ZRANGE leaderboard 0 2 # first 3 (lowest scores)
ZRANGE leaderboard -3 -1 # last 3 (highest scores)
# get members by score range
ZRANGEBYSCORE leaderboard 100 200 # scores 100-200
ZRANGEBYSCORE leaderboard 100 +inf # scores >= 100
ZRANGEBYSCORE leaderboard (100 200 # scores > 100 (exclusive)
# descending order
ZREVRANGE leaderboard 0 2 # top 3 (highest scores)
ZREVRANGEBYSCORE leaderboard 200 100 # 200 down to 100
# with scores
ZRANGE leaderboard 0 -1 WITHSCORES
# Redis 6.2+: unified ZRANGE with BYSCORE/REV options
ZRANGE leaderboard 100 200 BYSCORE
ZRANGE leaderboard 200 100 BYSCORE REVOpérations de score et rangs
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). ZCOUNT donne le compte d'une plage sans fetch des membres. ZMSCORE (6.2+) fetch les scores en lot, réduisant les aller-retours pour les lookups multi-membres.
# increment a member's score
ZINCRBY leaderboard 50 "alice" # alice += 50
# get the score
ZSCORE leaderboard "alice"
# remove a member
ZREM leaderboard "bob"
# remove members by rank range
ZREMRANGEBYRANK leaderboard 0 9 # remove lowest 10
ZREMRANGEBYSCORE leaderboard 0 100 # remove scores <= 100
# count members in a score range
ZCOUNT leaderboard 100 200
# get the rank
ZRANK leaderboard "alice" # ascending rank
ZREVRANK leaderboard "alice" # descending rank (0 = highest)
# get multiple members' scores at once
ZMSCORE leaderboard "alice" "bob" # ["250", "200"]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 que quand tous les scores sont identiques.
# 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" BYLEXAgrégations de sorted sets
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 précède les noms de sets.
# ZUNIONSTORE / ZINTERSTORE: combine multiple sorted sets
ZADD set1 1 "a" 2 "b"
ZADD set2 2 "a" 3 "c"
# union: sum scores by default (a = 1+2 = 3)
ZUNIONSTORE result 2 set1 set2
ZRANGE result 0 -1 WITHSCORES # a=3, b=2, c=3
# specify aggregation: SUM (default), MIN, MAX
ZUNIONSTORE result 2 set1 set2 AGGREGATE MAX # a=2, b=2, c=3
# apply weights to each set's scores
ZUNIONSTORE result 2 set1 set2 WEIGHTS 2 1 # set1 scores * 2
# intersection (only members in ALL sets)
ZINTERSTORE result 2 set1 set2 # only "a"
# Redis 6.2+: return without storing
ZUNION 2 set1 set2 WITHSCORES
ZINTER 2 set1 set2 WITHSCORES
ZDIFF 2 set1 set2 WITHSCORESPub/Sub
Bases du Pub/Sub
Pub/Sub est fire-and-forget : les messages sont livrés aux abonnés connectés à l'instant, sans persistance. Si aucun abonné n'écoute, le message est perdu. Le rendant impropre à la livraison fiable — utilisez Streams pour cela. Pub/Sub est idéal pour notifications temps réel, chat et fan-out où une perte occasionnelle est acceptable. Les abonnés doivent être connectés pour recevoir.
# subscribe to channels (in one client)
SUBSCRIBE news alerts
# publish a message to a channel (from another client)
PUBLISH news "Breaking: Redis 7.4 released"
# pattern subscription (glob-style)
PSUBSCRIBE news.*
# unsubscribe
UNSUBSCRIBE news
PUNSUBSCRIBE news.*
# note: published messages are NOT persisted
# if no subscriber is listening, the message is lost
# for persistent messaging, use Streams insteadPub/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é).
# 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)Patterns et cas d'usage du Pub/Sub
Pub/Sub est parfait pour le fan-out : un publisher, beaucoup d'abonnés (salons de chat, dashboards live, invalidation de cache). PSUBSCRIBE avec motifs glob (user:*:login) permet un routage flexible. La limite principale : pas de persistance — un abonné déconnecté rate les messages. Pour une livraison fiable, couplez Pub/Sub à un Stream comme backup, ou utilisez simplement Streams.
# 1. Real-time chat
# client subscribes to their room
SUBSCRIBE chat:room:42
# server publishes messages
PUBLISH chat:room:42 "Alice: hello"
# 2. Cache invalidation
# subscribe to invalidation channel
SUBSCRIBE cache:invalidate
# when data changes, publish
PUBLISH cache:invalidate "user:123"
# 3. Event notifications (with PSUBSCRIBE patterns)
PSUBSCRIBE user:*:login
# matches user:1:login, user:2:login, etc.
# 4. Live dashboards
SUBSCRIBE metrics:*
# push real-time updates to dashboards
# 5. Multiplayer game state
PUBLISH game:room:1 "player_moved:5:10"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.
# 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 endsPub/Sub vs Streams
Pub/Sub pour la messagerie temps réel éphémère ; Streams pour la messagerie durable et rejouable. Un hybride courant : Pub/Sub pour les notifications live (rapide, avec pertes) + Streams comme source de vérité (durable, rejouable). Les nouveaux abonnés lisent le Stream pour rattraper, puis s'abonnent au Pub/Sub pour les mises à jour live. Pour la plupart des systèmes de production exigeant de la fiabilité, Streams est le meilleur défaut.
# Pub/Sub: fire-and-forget, no persistence
PUBLISH channel "msg" # lost if no subscribers
# Streams: persistent, replayable, consumer groups
XADD mystream * msg "hello" # stored forever (or capped)
# Pub/Sub pros: simple, low latency, fan-out
# Pub/Sub cons: no persistence, no replay, no consumer groups
# Streams pros: persistent, replayable, consumer groups, ACK
# Streams cons: more complex, requires cleanup (XADD MAXLEN)
# when to use each:
# - real-time notifications (loss OK) -> Pub/Sub
# - chat with presence -> Pub/Sub + Streams
# - reliable task queue -> Streams
# - event sourcing / audit log -> Streams
# - fan-out to transient subscribers -> Pub/SubTransactions et pipelining
Transactions MULTI/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.
# MULTI starts a transaction; commands are queued
MULTI
SET counter 1
INCR counter
INCR counter
GET counter
EXEC
# returns: [OK, 2, 3, "3"]
# discard a transaction (cancels all queued commands)
MULTI
SET x 1
DISCARD
# errors during queuing (syntax) abort the whole transaction
# errors during EXEC (e.g., wrong type) skip only that commandWATCH (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, pas pendant la mise en file. UNWATCH annule les watches (aussi à la déconnexion).
# WATCH monitors keys; if any change before EXEC, the transaction aborts
WATCH counter
val = GET counter # read current value
MULTI
INCR counter # queue the update
EXEC # nil if counter changed -> retry
# typical pattern: read-modify-write with retry
WATCH key
current = GET key
new_value = compute(current)
MULTI
SET key new_value
EXEC
# if EXEC returns nil, the key changed — loop and retry
# UNWATCH cancels all watches
UNWATCHPipelining (aller-retours batchés)
Le pipelining batche les commandes pour réduire les aller-retours réseau — drastiquement plus rapide que des commandes individuelles sur le réseau. Contrairement à MULTI/EXEC, les commandes pipelinées ne sont PAS atomiques (d'autres clients peuvent s'intercaler). Utilisez le pipelining pour les opérations en masse où l'atomicité n'importe pas (inserts/lectures en masse) et MULTI/EXEC quand vous avez besoin d'atomicité. La plupart des clients pipelinent automatiquement dans MULTI/EXEC.
# pipelining sends multiple commands in one network round-trip
# (no atomicity guarantee, just reduced latency)
# in a client library (e.g., Node.js / redis):
const pipe = client.multi()
pipe.set("k1", "v1")
pipe.set("k2", "v2")
pipe.incr("counter")
const results = await pipe.exec()
# vs MULTI/EXEC: pipelining does NOT guarantee atomicity
# other clients can interleave between pipelined commands
# raw protocol example (RESP):
# *1\r\n$4\r\nPING\r\n*1\r\n$4\r\nPING\r\n
# (send multiple commands at once, read multiple replies)Scripts Lua (atomiques)
Les scripts Lua sont la façon Redis de faire des opérations atomiques complexes — le script tourne comme une unique unité atomique (sans intercalage). EVALSHA rejoue un script chargé par hash (évite de renvoyer le script). Gardez les scripts courts (ils bloquent le serveur). Les scripts ont des exigences de déterminisme (pas d'appels random/time) pour la réplication. Redis 7+ utilise FUNCTIONS comme alternative plus structurée.
# Lua scripts run atomically — no other command runs during execution
# EVAL: run a script
EVAL "return redis.call('GET', KEYS[1])" 1 mykey
# a check-and-set script:
EVAL "
local cur = redis.call('GET', KEYS[1])
if cur == ARGV[1] then
return redis.call('SET', KEYS[1], ARGV[2])
end
return 0
" 1 mykey "expected" "newvalue"
# load a script once, then run by SHA hash (efficient)
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# returns a SHA1 hash
EVALSHA <sha1> 1 mykey
# check if a script is loaded
SCRIPT EXISTS <sha1>Functions (Redis 7.0+)
Functions (7.0+) améliore les scripts EVAL : nommés (pas seulement hashés), organisés en bibliothèques et persistants 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.
# FUNCTIONS are named, versioned Lua scripts (better than EVAL)
# register a function library
FUNCTION LOAD '#!lua name=mylib
redis.register_function("my_set",
function(keys, args)
return redis.call("SET", keys[1], args[1])
end
)'
# call a function by name
FCALL my_set 1 mykey "hello"
# list loaded libraries
FUNCTION LIST
# get the function's code
FUNCTION DUMP mylib
# delete a library
FUNCTION DELETE mylib
# functions persist across restarts (unlike EVAL scripts)Persistance
Snapshots RDB
Les snapshots RDB sont des fichiers binaires compacts idéals pour backups et disaster recovery. BGSAVE fork le processus (copy-on-write) pour ne pas bloquer le thread principal, mais de grands jeux peuvent quand même causer des pics mémoire au fork. Les règles 'save' déclenchent des snapshots automatiques selon le taux de changement. RDB risque de perdre les données écrites après le dernier snapshot — couplez avec AOF pour la durabilité.
# RDB: point-in-time snapshot of the dataset (compact binary)
# trigger a snapshot manually:
SAVE # blocks until done (use with care)
BGSAVE # forks a background process (non-blocking)
LASTSAVE # Unix timestamp of the last successful save
# configure automatic snapshots in redis.conf:
# save 3600 1 # save if >= 1 key changed in 3600s
# save 300 100 # save if >= 100 keys changed in 300s
# save 60 10000 # save if >= 10000 keys changed in 60s
# save "" # disable RDB entirely
# RDB file location (default: dump.rdb in the working dir)
CONFIG GET dbfilename
CONFIG GET dir
# RDB pros: compact, fast restart, great for backups
# RDB cons: potential data loss between snapshotsAOF (Append-Only File)
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). Les fichiers AOF sont plus grands et plus lents à charger que RDB. Redis 7 utilise un format AOF multi-parties (base + incrémental).
# AOF: logs every write command (durable, replayable)
# enable in redis.conf:
# appendonly yes
# appendfilename "appendonly.aof"
# fsync policies:
# appendfsync always # fsync every write (safest, slowest)
# appendfsync everysec # fsync once per second (default, balanced)
# appendfsync no # let OS decide (fastest, risk of data loss)
# trigger AOF rewrite (compacts the log)
BGREWRITEAOF
# AOF auto-rewrite thresholds:
# auto-aof-rewrite-percentage 100
# auto-aof-rewrite-min-size 64mb
# AOF pros: minimal data loss (1 sec max with everysec)
# AOF cons: larger files, slower load on restartHybride RDB + AOF
Tourner RDB + AOF ensemble donne le redémarrage rapide de RDB et la durabilité d'AOF. Depuis Redis 7, l'AOF est un fichier multi-parties : un snapshot de base RDB + un log de commandes incrémental — combinant chargement rapide et perte de données minimale. aof-use-rdb-preamble (défaut yes) met un snapshot RDB au début de l'AOF pour une récupération plus rapide. C'est la configuration de production recommandée.
# use BOTH RDB and AOF for the best of both worlds
# redis.conf:
# save 900 1 # RDB snapshots
# appendonly yes # AOF enabled
# aof-use-rdb-preamble yes # RDB header in AOF (faster load)
# on restart, Redis loads AOF (more complete)
# the AOF file can start with an RDB snapshot (faster load)
# followed by incremental AOF commands
# disaster recovery: keep both RDB and AOF backups
# RDB for fast restores, AOF for minimal data loss
# check what's enabled
CONFIG GET save
CONFIG GET appendonly
# monitor persistence operations
INFO persistenceBackup 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. Testez toujours les backups avec redis-check-rdb/aof.
# backup: copy the RDB file while Redis runs
cp /var/lib/redis/dump.rdb /backup/dump-$(date +%F).rdb
# or trigger a BGSAVE first for a consistent snapshot
BGSAVE
# wait for LASTSAVE to update, then copy the file
# AOF backup: copy the AOF manifest + files
cp /var/lib/redis/appendonly.aof.* /backup/
# restore: stop Redis, replace the data files, start
redis-cli SHUTDOWN
cp /backup/dump.rdb /var/lib/redis/dump.rdb
redis-server /etc/redis/redis.conf
# for point-in-time recovery from AOF:
# edit the AOF file to remove unwanted commands, then restart
# RDB file analysis (offline)
redis-check-rdb /var/lib/redis/dump.rdb
redis-check-aof /var/lib/redis/appendonly.aofCompromis de persistance
Le choix de persistance dépend de vos besoins de durabilité. Pur cache : désactivez la persistance pour la vitesse maximale. Données critiques : RDB+AOF (recommandé). Un pattern courant : désactiver la persistance sur le primaire (pour la performance) et persister sur un réplica (décharge l'I/O disque). L'AOF everysec est le point idéal — au plus 1 seconde de perte avec impact minimal. Testez toujours la récupération.
# choosing a persistence strategy:
# 1. RDB only (cache, re-buildable data)
# save 3600 1
# appendonly no
# -> fast restart, some data loss on crash
# 2. AOF only (durability-critical, everysec)
# save ""
# appendonly yes
# appendfsync everysec
# -> up to 1s data loss, larger files
# 3. RDB + AOF (recommended production default)
# save 3600 1
# appendonly yes
# aof-use-rdb-preamble yes
# -> durability + fast restart
# 4. No persistence (pure cache, ephemeral)
# save ""
# appendonly no
# -> maximum speed, all data lost on restart
# 5. Replica-only persistence (offload from primary)
# primary: no persistence (max performance)
# replica: RDB + AOF (persist here instead)Clustering
Bases du Redis Cluster
Redis Cluster shard les données entre nœuds avec 16 384 slots de hachage. CRC16(clé) % 16384 détermine le slot. Les opérations multi-clés (MGET, transactions) exigent des clés dans le même slot — utilisez des hash tags ({user:1}) pour forcer les clés liées ensemble. Chaque primaire peut avoir des réplicas pour la HA. Le cluster gère le failover automatiquement quand un primaire échoue.
# Redis Cluster shards data across multiple nodes (16,384 slots)
# each key maps to a slot: CRC16(key) % 16384
# create a cluster (6 nodes: 3 primaries + 3 replicas)
redis-cli --cluster create \
host1:7000 host2:7000 host3:7000 \
host1:7001 host2:7001 host3:7001 \
--cluster-replicas 1
# check cluster status
redis-cli -p 7000 CLUSTER INFO
redis-cli -p 7000 CLUSTER NODES
# count slots assigned
CLUSTER COUNTKEYSINSLOT 1234
# get the slot for a key
CLUSTER KEYSLOT mykey # e.g., 1234
# multi-key operations require keys in the SAME slot
# use hash tags to force keys to the same slot:
SET {user:1}:profile "alice"
SET {user:1}:cart "items"
# both map to the same slot (the part inside {})Hash tags et ops multi-clés
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.
# hash tags: the substring inside {} determines the slot
# {user:1}:profile and {user:1}:cart share a slot
# enabling multi-key operations:
MSET {user:1}:name "Alice" {user:1}:age 30 # OK (same slot)
MSET user:1:name "Alice" user:2:age 30 # CROSSSLOT error
# transactions across keys (must be same slot)
WATCH {order:1}:items
MULTI
HINCRBY {order:1}:items product:1 1
HINCRBY {order:1}:total 10
EXEC
# Lua scripts accessing multiple keys (all keys must share a slot)
EVAL "..." 2 {user:1}:a {user:1}:b
# design hash tags carefully:
# - too broad -> hotspots (one shard overloaded)
# - too narrow -> can't do multi-key opsResharding du cluster
Le resharding déplace des slots entre nœuds sans interruption — Redis migre les clés une à une tout en servant les requêtes. Ajoutez des nœuds puis rebalancer pour répartir la charge. L'outil CLI --cluster gère l'orchestration complexe. Lancez toujours --cluster check après les changements. Le resharding est lent (migration clé par clé), donc planifiez la capacité à l'avance plutôt que de resharder sous charge.
# move slots from one node to another (resharding)
redis-cli --cluster reshard host1:7000
# prompts for: how many slots, target node, source nodes
# add a new node to the cluster
redis-cli --cluster add-node newhost:7000 host1:7000
# add a new replica to an existing primary
redis-cli --cluster add-node newhost:7001 host1:7000 \
--cluster-slave --cluster-master-id <nodeId>
# remove a node (migrates its slots first)
redis-cli --cluster del-node host1:7000 <nodeId>
# rebalance slots across all nodes
redis-cli --cluster rebalance host1:7000
# check cluster health
redis-cli --cluster check host1:7000
redis-cli --cluster fix host1:7000 # repair issuesFailover du cluster
Le failover de cluster est automatique : si un primaire est injoignable au-delà de cluster-node-timeout (défaut 15 s), son réplica est promu. Le failover manuel sert à la maintenance (mises à niveau sans interruption). TAKEOVER risque le split-brain — en urgence seulement. Sans réplicas, un primaire défaillant rend ses slots indisponibles (cluster down). Tournez toujours avec des réplicas en production. CLUSTER NODES montre la topologie.
# when a primary fails, its replica is promoted automatically
# manual failover (for maintenance):
redis-cli -p 7001 CLUSTER FAILOVER # replica -> primary
redis-cli -p 7001 CLUSTER FAILOVER FORCE # without primary agreement
redis-cli -p 7001 CLUSTER FAILOVER TAKEOVER # force, may split brain
# view the cluster topology
CLUSTER NODES
CLUSTER SHARDS # (7.0+)
# a node flagged as FAIL after timeout is removed
# cluster- node-timeout 15000 (15 seconds in redis.conf)
# if a cluster has no replica for a failing primary,
# that slot range becomes unavailable until the primary returns
# (or you manually fix it)
# CLUSTER RESET resets a node (HARD removes all data)Cluster vs Sentinel vs mono
Instance unique pour le dev. Sentinel pour la HA quand les données tiennent sur une machine (un primaire + réplicas + sentinels pour monitoring/failover). Cluster pour le scaling horizontal quand les données dépassent une machine ou que le débit d'écriture est très élevé. Le cluster ajoute de la complexité (hash tags, limites multi-clés). Les services gérés (Redis Cloud, ElastiCache, MemoryDB) absorbent la charge opérationnelle — préférez-les sauf bonnes raisons de self-host.
# Single Redis: one instance, no HA, no scaling
# simplest, fine for dev/small cache
# Sentinel: 1 primary + replicas + sentinel monitors
# HA (automatic failover), no sharding
# good when dataset fits on one machine
# sentinel.conf: sentinel monitor mymaster host 6379 2
# Cluster: sharded across N primaries + replicas
# HA + horizontal scaling
# good for large datasets / high throughput
# more complex (multi-key limitations)
# choose:
# - dev / tiny cache -> single
# - production, data fits in RAM -> sentinel (HA)
# - data > single machine RAM -> cluster (sharding)
# - very high write throughput -> cluster (shard writes)
# managed Redis (Redis Cloud, ElastiCache) handles
# sentinel/cluster ops for youSentinel (haute disponibilité)
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.
# 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 mymasterCommandes Sentinel
Les clients se connectent aux Sentinels pour découvrir le primaire courant, puis se connectent à lui. Au failover, les clients réinterrogent les Sentinels pour trouver le nouveau primaire. SENTINEL failover déclenche un failover manuel (pour les mises à niveau glissantes). 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.
# query sentinel state
redis-cli -p 26379 SENTINEL masters # all monitored primaries
redis-cli -p 26379 SENTINEL master mymaster # details of one primary
redis-cli -p 26379 SENTINEL replicas mymaster
redis-cli -p 26379 SENTINEL sentinels mymaster
# find the current primary address
SENTINEL get-master-addr-by-name mymaster
# force a failover (manual, for maintenance)
SENTINEL failover mymaster
# reset a master's state (clears replicas/sentinels discovered)
SENTINEL reset mymaster
# check the number of OK sentinels
SENTINEL ckquorum mymaster
# "OK 3 usable Sentinels" or "NOQUORUM" warning
# clients should connect to sentinels, NOT directly to the primary
# libraries: redis-py, jedis, ioredis all support sentinel modeProcessus de failover
Le failover est automatique mais cause une brève coupure d'écriture (secondes). SDOWN est l'opinion d'un sentinel ; ODOWN le consensus du quorum. 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). Abonnez-vous à +switch-master pour les alertes.
# when a primary is down longer than down-after-milliseconds:
# 1. sentinels mark it SDOWN (subjectively down)
# 2. quorum agrees -> ODOWN (objectively down)
# 3. a sentinel is elected leader
# 4. leader picks the best replica (most up-to-date)
# 5. promotes the replica: REPLICAOF NO ONE
# 6. reconfigures other replicas to follow the new primary
# 7. updates sentinel configs with the new primary address
# 8. clients reconnect via sentinel discovery
# during failover, writes fail briefly (seconds)
# reads from replicas continue (if the app uses them)
# the old primary, when it returns, is reconfigured as a replica
# of the new primary (its writes during partition are lost)
# monitor failover events:
redis-cli -p 26379 SUBSCRIBE +switch-master
redis-cli -p 26379 SUBSCRIBE +failover-*Réplicas de lecture et scaling
Les réplicas délestent les lectures du primaire — utile pour les charges à forte lecture (analytique, reporting). La réplication est asynchrone, donc les données du réplica peuvent prendre du retard (millisecondes normalement, mais peut croître sous charge). Utilisez READONLY pour lire depuis les réplicas. Les réplicas inscriptibles (4.0+) acceptent les écritures non répliquées — utile pour des données temporaires ou caches par réplica, mais les écritures se perdent au failover. Surveillez le lag des réplicas.
# replicas can serve reads (eventually consistent)
REPLICAOF 192.168.1.10 6379 # become a replica of this primary
REPLICAOF NO ONE # promote to primary (manual)
# check replication status
INFO replication
# role:slave, master_host, master_link_status:up, ...
# replica lag (bytes and seconds lagging behind primary)
# master_repl_offset vs slave_repl_offset
# clients can route reads to replicas for read scaling
# but beware: replica data may be stale (replication lag)
# Redis Sentinel + clients: configure read preference
# READONLY command enables reads on a replica
# writable replicas (Redis 4.0+): accept writes that are
# local-only (not replicated) — useful for ephemeral data
# replica-read-only no (in redis.conf)Internals de la réplication
La réplication est async et unidirectionnelle (primaire vers réplica). La sync initiale envoie un RDB complet puis le backlog de commandes ; PSYNC permet une resync partielle après de courtes déconnexions (via le backlog de réplication — réglez repl-backlog-size). Un changement d'ID de réplication (au redémarrage du primaire ou au failover) force une resync complète. La réplication en chaîne (réplica d'un réplica) réduit la charge du primaire pour les grands fan-out.
# replication is asynchronous: primary -> replica (one-way)
# initial sync: full RDB transfer + buffered commands
# subsequent: streaming command log
# trigger a full resync (force replica to reload everything)
redis-cli -p 6380 REPLICAOF NO ONE
redis-cli -p 6380 REPLICAOF 192.168.1.10 6379
# partial resync (PSYNC): if the replica disconnects briefly,
# it can resume from the replication backlog (no full resync)
# repl-backlog-size 1mb (tune for longer disconnects)
# monitor replication in real-time
redis-cli -p 6379 INFO replication
# master_repl_offset, slave_read_repl_offset, backlog_size
# chain replication: a replica of a replica (tree topology)
# reduces load on the primary for many replicas
REPLICAOF replica-host 6380 # chain off another replica
# replication ID changes on every primary restart -> full resyncStreams
Bases des streams (XADD/XREAD)
Les streams sont la structure de messagerie durable de Redis — append-only, rejouables, avec groupes de consommateurs. Les IDs sont basés timestamp (auto-générés avec *). XREAD avec $ tail le stream (nouveaux éléments seulement) ; avec 0 lit depuis le début. MAXLEN plafonne le stream (~ pour approximatif est bien plus rapide). Les streams résolvent le problème de non-persistance de Pub/Sub et sont la façon recommandée de bâtir des files fiables.
# streams are append-only logs with IDs (durable, replayable)
# XADD: add an entry (auto-generate ID with *)
XADD mystream * sensor temp 25.5
# returns an ID like "1700000000000-0" (timestamp-sequence)
# add with a specific ID (must be greater than the last)
XADD mystream 1700000001000-0 sensor temp 26.0
# read entries
XREAD COUNT 10 STREAMS mystream 0 # from the beginning
XREAD COUNT 10 STREAMS mystream $ # new entries only (tail)
# block for new entries (like BLPOP for lists)
XREAD BLOCK 30000 STREAMS mystream $ # blocks up to 30s
# get the length
XLEN mystream # number of entries
# capped stream (keep only last N entries)
XADD mystream MAXLEN 1000 * field value
XADD mystream MAXLEN ~ 1000 * field value # ~ = approx (faster)Groupes de consommateurs
Les groupes de consommateurs permettent le traitement parallèle : chaque élément est livré à exactement un consommateur du groupe. '>' lit les nouveaux éléments ; '0' les éléments en attente (non acquittés) de ce consommateur. XACK marque un élément traité. Les éléments en attente (livrés mais non acquittés) forment un log de traitement — utilisez XPENDING pour trouver les messages bloqués et XCLAIM pour les réassigner à un autre consommateur après un timeout.
# create a consumer group at a specific position
XGROUP CREATE mystream mygroup $ # only new entries
XGROUP CREATE mystream mygroup 0 # all existing entries
XGROUP CREATE mystream mygroup 0 MKSTREAM # create stream if missing
# read entries as a consumer (assigns pending entries)
XREADGROUP GROUP mygroup consumer1 COUNT 10 STREAMS mystream >
# '>' = never-delivered entries
# read pending entries (for this consumer, not yet acked)
XREADGROUP GROUP mygroup consumer1 STREAMS mystream 0
# acknowledge processing (removes from pending)
XACK mystream mygroup <id1> <id2>
# view pending entries (pending entries list)
XPENDING mystream mygroup
# returns: count, min-id, max-id, consumers
# view a consumer's pending entries
XPENDING mystream mygroup - + 10 consumer1Traitement et récupération de stream
XAUTOCLAIM est clé pour un traitement fiable : il réassigne les éléments en attente depuis trop longtemps (consommateur crashé ou suspendu) à un consommateur sain. Le min-idle-time évite de voler des éléments encore en traitement. XTRIM borne la taille du stream (essentiel pour la mémoire). XRANGE lit une plage par ID. XINFO révèle l'état stream/groupe/consommateur pour le monitoring. C'est une file de messages complète et durable.
# XCLAIM: reassign a pending entry to another consumer
# (after the original consumer died or is too slow)
XCLAIM mystream mygroup consumer2 60000 <entry-id>
# 60000 = min idle time (ms) before claiming
# XAUTOCLAIM (6.2+): auto-claim stale pending entries
XAUTOCLAIM mystream mygroup consumer2 60000 0 COUNT 10
# claims entries idle > 60s, returns them to consumer2
# view stream info
XINFO STREAM mystream FULL
XINFO GROUPS mystream
XINFO CONSUMERS mystream mygroup
# delete an entry (rarely needed)
XDEL mystream <id>
# trim the stream (free memory)
XTRIM mystream MAXLEN 10000
XTRIM mystream MINID 1700000000000 # remove older than this ID
# range queries
XRANGE mystream - + # all entries
XRANGE mystream 1700000000000 - 1700000009999 -Cas d'usage des streams
Les streams excellent aux files fiables, event sourcing et données de séries temporelles. Le motif de groupe de consommateurs (XADD + XREADGROUP + XACK) remplace complètement les files à base de listes, avec retry intégré (éléments en attente) et récupération (XAUTOCLAIM). Pour les séries temporelles, MAXLEN borne la mémoire. Les streams sont la structure Redis la plus complète — utilisez-les dès que vous avez besoin de durabilité et de traitement ordonné.
# 1. Reliable task queue (replaces lists + BRPOPLPUSH)
XADD tasks * type email payload '{"to":"[email protected]"}'
XREADGROUP GROUP workers worker1 COUNT 1 STREAMS tasks >
# process and XACK on success
# 2. Event sourcing / audit log
XADD events * user 1 action login ip 1.2.3.4
# replay with XRANGE for reconstruction
# 3. Real-time analytics (time-windowed)
XADD metrics * cpu 75 mem 60
XRANGE metrics - + # query by time range
# 4. Chat history (capped)
XADD chat:room:1 MAXLEN ~ 1000 * user alice msg "hello"
XREAD COUNT 20 STREAMS chat:room:1 0
# 5. IoT sensor data (with TTL via trimming)
XADD sensors:temp MAXLEN ~ 86400 * value 22.5 # keep last dayStreams vs autres files
Les streams sont la file native Redis — plus simples que Kafka/RabbitMQ et suffisantes pour la plupart des charges tenant en RAM. Elles manquent du parallélisme par partition de Kafka (un stream = un shard) mais les groupes de consommateurs offrent du parallélisme de workers. Pour de très hauts débits ou une durabilité sur disque, Kafka gagne. Pour du routage complexe, RabbitMQ gagne. Pour la plupart des apps utilisant déjà Redis, les streams sont le bon défaut de messagerie fiable.
# Redis Streams vs Lists (for queues):
# Lists: LPUSH/BRPOP, simple, NO retry/recovery
# Streams: consumer groups, ACK, pending, XAUTOCLAIM
# Redis Streams vs Kafka:
# Streams: in-memory (RAM-bounded), simpler, single-node or cluster
# Kafka: disk-based, partitioned, higher throughput at scale
# Redis Streams vs RabbitMQ:
# Streams: simpler, fewer features, in-memory
# RabbitMQ: rich routing, exchanges, acknowledgments, disk
# Streams capacity: limited by RAM (use MAXLEN/MINID to trim)
# Streams persistence: RDB/AOF (like any Redis data)
# choose Streams when:
# - you need a queue but already use Redis
# - dataset fits in RAM
# - you want simplicity over Kafka's scale
# - you need consumer groups with retryHyperLogLog, Bitmaps et Geo
HyperLogLog (cardinalité)
HyperLogLog (HLL) compte les éléments uniques avec ~0,81 % d'erreur en 12 Ko fixes — compter des milliards d'éléments avec mémoire constante. Parfait pour l'analytique comme les visiteurs uniques quotidiens/hebdo/mensuels. PFMERGE combine les HLL (ex. uniques mensuels depuis les quotidiens). Le compromis est l'approximation — utilisez un Set pour des comptages exacts ou des tests d'appartenance (SISMEMBER), HLL quand vous ne voulez que le compte.
# HyperLogLog: approximate unique count with fixed 12KB memory
# perfect for counting unique visitors, IPs, etc. at scale
# add elements (returns 1 if the cardinality changed)
PFADD visitors:2025-01-01 "user:1" "user:2" "user:3"
# get the approximate unique count
PFCOUNT visitors:2025-01-01 # ~3
# merge multiple HLLs (e.g., monthly uniques from daily)
PFMERGE visitors:2025-01 visitors:2025-01-01 visitors:2025-01-02
# accuracy: ~0.81% standard error
# memory: always ~12KB regardless of element count (up to 2^64)
# vs a Set for unique counting:
# SADD + SCARD: exact, but O(N) memory (grows with count)
# PFADD + PFCOUNT: approximate, fixed 12KB memory
# 1 million uniques: Set ~10MB, HLL always 12KBBitmaps en profondeur
Les bitmaps stockent un bit par utilisateur — 1 million d'utilisateurs = 125 Ko, 4 milliards = 512 Mo. BITOP AND/OR/XOR/NOT combine les bitmaps (rétention, analyse de churn). BITPOS trouve le premier bit à 1. Cas d'usage : utilisateurs actifs quotidiens, feature flags, présence, groupes A/B. Limite : exige des IDs utilisateurs entiers denses (les trous gaspillent l'espace). Pour des données sparses, préférez un Set ou HyperLogLog.
# bitmaps: boolean operations on a string's bits
# ideal for per-user flags over a large user base (user ID = bit position)
# mark user 7 as "active today"
SETBIT active:2025-01-01 7 1
# check if user 7 was active
GETBIT active:2025-01-01 7 # 1
# count active users
BITCOUNT active:2025-01-01
# users active on BOTH days (AND)
BITOP AND active:both active:2025-01-01 active:2025-01-02
BITCOUNT active:both
# users active on EITHER day (OR)
BITOP OR active:either active:2025-01-01 active:2025-01-02
# users active on day 1 but NOT day 2 (XOR or AND NOT)
BITOP XOR diff active:2025-01-01 active:2025-01-02
# find the first active user
BITPOS active:2025-01-01 1 # position of first 1-bit
# memory: 1 million users = 125KB (1 bit per user)Géospatial (GEO)
Les commandes GEO stockent des points géographiques et supportent les requêtes par rayon/boîte — bâties sur des sorted sets (score = geohash). GEOSEARCH (6.2+, remplace GEORADIUS) trouve les points proches avec options riches (WITHCOORD, WITHDIST, ASC/DESC). La distance est calculée sur une sphère. La précision est bonne pour la plupart des apps. Pour du GIS complexe (polygones, routage), utilisez une base spatiale dédiée. GEO est parfait pour les fonctionnalités « trouver à proximité ».
# GEO: built on sorted sets, stores (lng, lat, name) points
# add locations (longitude, latitude, name)
GEOADD places -73.99 40.73 "Park" -73.98 40.75 "Museum" -74.00 40.70 "Cafe"
# get coordinates of a member
GEOPOS places "Park" # [["-73.99","40.73"]]
# distance between two members (meters by default)
GEODIST places "Park" "Museum" # "1623.5"
GEODIST places "Park" "Museum" km # "1.623"
# find members within a radius (meters)
GEOSEARCH places FROMMEMBER "Park" BYRADIUS 1000 m ASC
# members within 1km of Park, sorted by distance
# find members within a bounding box
GEOSEARCH places FROMLONLAT -73.99 40.73 BYBOX 2 2 km
# GEOSEARCH also returns distance and coordinates
GEOSEARCH places FROMMEMBER "Park" BYRADIUS 500 m WITHCOORD WITHDISTOpérations géospatiales
GEO est implémenté sur sorted sets — le geohash des coordonnées est le score. On peut donc utiliser des commandes Z* pour certaines opérations (ZREM, ZRANGE). GEOSEARCH retourne des résultats riches (distance, coordonnées, geohash). COUNT limite les résultats (à utiliser avec ASC pour les N plus proches). GEOSEARCHSTORE sauve les résultats pour un traitement supplémentaire. La précision du geohash se dégrade près des pôles — acceptable pour la plupart des apps réelles.
# add multiple points at once
GEOADD cities -122.41 37.78 "San Francisco" -74.00 40.71 "New York"
# get the geohash of a member
GEOHASH places "Park" # ["dr5reg..."]
# remove a member (uses ZREM internally)
ZREM places "Cafe"
# count members in an area (using ZCOUNT on the underlying zset)
ZCOUNT places -180 180 # all members
# GEOSEARCH with a center point and limiting results
GEOSEARCH places FROMLONLAT -73.99 40.73 \
BYRADIUS 2000 m ASC COUNT 5 # nearest 5 within 2km
# GEOSEARCHSTORE: store results in a new key (6.2+)
GEOSEARCHSTORE nearby FROMLONLAT -73.99 40.73 BYRADIUS 1000 m
# the underlying structure is a sorted set, so:
ZRANGE places 0 -1 # list all members
ZSCORE places "Park" # geohash scoreChoisir les types spécialisés
Redis offre beaucoup de structures spécialisées au-delà des cinq cœur. HyperLogLog pour la cardinalité approximative, Bitmaps pour les flags booléens denses, GEO pour la proximité. Les modules ajoutent des filtres de Bloom (test d'appartenance avec faux positifs), Top-K (heavy hitters) et RedisTimeSeries (séries temporelles optimisées). Accordez la structure à la forme de vos données et vos besoins de précision — le bon choix peut économiser des ordres de grandeur de mémoire.
# Cardinality counting (unique elements):
# exact, need membership test -> Set (SADD/SISMEMBER/SCARD)
# approximate, huge scale -> HyperLogLog (PFADD/PFCOUNT)
# per-time-bucket uniques -> HLL per day, PFMERGE for ranges
# Boolean flags over a dense ID space:
# small number of flags -> Set of active IDs
# millions of users -> Bitmap (SETBIT/BITCOUNT)
# multiple counters compactly -> BITFIELD
# Geographic points:
# "find nearby" queries -> GEO (GEOADD/GEOSEARCH)
# complex GIS -> use PostGIS/external
# Time-series data:
# simple, capped -> Stream (XADD MAXLEN)
# dedicated TS module -> RedisTimeSeries (module)
# Probabilistic structures (modules):
# Bloom filter -> RedisBloom (BF.ADD/BF.EXISTS)
# Top-K -> RedisBloom (TOPK)Sécurité
Authentification et ACL
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. Sauvez les ACL dans un fichier pour la persistance. N'utilisez jamais l'utilisateur par défaut en production — désactivez-le ou réglez un mot de passe fort.
# set a password (simple, legacy)
CONFIG SET requirepass "strongpassword"
AUTH "strongpassword"
# Redis 6+: ACL system with users and permissions
# add a user with limited access
ACL SETUSER appuser on >secretpassword ~app:* +get +set +del -@dangerous
# list users
ACL LIST
ACL WHOAMI # current user
# view a user's permissions
ACL GETUSER appuser
# delete a user
ACL DELUSER appuser
# save ACLs to a file (persists across restarts)
ACL SAVE
ACL LOAD # reload from file
# aclfile in redis.conf:
# aclfile /etc/redis/users.aclChiffrement 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, vous pouvez faire tourner les deux ports temporairement.
# enable TLS in redis.conf (Redis 6+)
# generate certs first (or use a real CA):
port 0 # disable plain-text port
tls-port 6379
tls-cert-file /etc/redis/redis.crt
tls-key-file /etc/redis/redis.key
tls-ca-cert-file /etc/redis/ca.crt
# connect with TLS
redis-cli --tls --cert client.crt --key client.key \
--cacert ca.crt -h host -p 6379
# mutual TLS (mTLS) for client authentication
tls-cluster yes # TLS between cluster nodes
tls-replication yes # TLS between primary/replica
tls-auth-clients yes # require client certs
# mix TLS and plain text (transition period)
# port 6380
# tls-port 6379Sécurité réseau
Redis n'a pas de contrôle d'accès réseau natif — utilisez bind + protected-mode + un pare-feu. N'exposez JAMAIS Redis à Internet (d'innombrables breaches depuis des Redis ouverts sans auth). protected-mode bloque les connexions externes quand aucun mot de passe n'est réglé. rename-command désactive les commandes dangereuses (FLUSHALL, CONFIG, KEYS), mais les ACL (6.0+) sont l'approche moderne. Mettez Redis dans un sous-réseau privé ; accès via VPN ou bastion.
# bind to specific interfaces (never 0.0.0.0 in prod)
bind 127.0.0.1 10.0.0.5
protected-mode yes # blocks external access if no password
# require authentication
requirepass "strong-random-password"
# rename dangerous commands (or disable them)
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG "CONFIG_9f8a7b"
rename-command KEYS ""
# Redis 6+: better to use ACLs instead of rename-command
# ACL SETUSER default -flushall -config -keys
# disable debug commands
# ACL SETUSER default -@dangerous
# use a firewall / security group to restrict access
# Redis should NEVER be directly internet-accessible
# (the 2018+ ransom attacks scanned for open Redis instances)Audit et logging
SLOWLOG enregistre les commandes lentes pour l'audit de performance — réglez le seuil à votre SLO (ex. 10 ms). MONITOR logue chaque commande (énorme impact de performance — débogage seulement). LATENCY MONITOR aide à trouver les pics de latence. CLIENT LIST montre les clients connectés (surveillez les fuites). Réglez loglevel à 'notice' en production (debug trop verbeux). Expédiez les logs à un système central pour l'analyse.
# log slow commands (slowlog)
CONFIG SET slowlog-log-slower-than 10000 # 10ms in microseconds
CONFIG SET slowlog-max-len 128 # keep 128 entries
SLOWLOG GET 10 # last 10 slow commands
SLOWLOG RESET
# log to a file (redis.conf)
logfile /var/log/redis/redis.log
loglevel notice # debug|verbose|notice|warning
# monitor all commands (debugging only — huge perf impact)
MONITOR
# latency monitoring
CONFIG SET latency-monitor-threshold 100 # 100ms
LATENCY HISTORY event-name
LATENCY DOCTOR # analysis report
# client list (who's connected)
CLIENT LIST
CLIENT GETNAME
CLIENT SETNAME "my-app"Bonnes pratiques de sécurité
La sécurité Redis est en couches : réseau (bind/pare-feu), authentification (mot de passe/ACL), transport (TLS), restriction de commandes (ACL/rename) et audit (slowlog/monitor). La règle n°1 : n'exposez jamais Redis directement à Internet — il n'a pas de rate limiting ni de protection brute force intégrée. Chiffrez les fichiers RDB/AOF au niveau disque (ils contiennent vos données en clair). Gardez Redis à jour pour les correctifs de sécurité.
# 1. NEVER expose Redis to the public internet
bind 127.0.0.1
protected-mode yes
# 2. Use strong passwords or ACLs
requirepass "<64-char-random-string>"
# or ACLs with least privilege
# 3. Enable TLS for transit encryption
tls-port 6379
# 4. Restrict dangerous commands
ACL SETUSER default -@dangerous -flushall -keys
# 5. Use a firewall / security group
# allow only app servers on the Redis port
# 6. Rotate credentials regularly
ACL SETUSER appuser on >newpassword ~app:* +@read +@write
# 7. Audit access
LOGICALDB MONITOR # or use an audit module
# 8. Encrypt sensitive data at rest (disk encryption)
# RDB/AOF files can contain sensitive data
# 9. Keep Redis updated (security patches)
# 10. Isolate environments (separate dev/staging/prod)Performance et optimisation
Fondamentaux de performance
Redis est mono-threadé pour l'exécution des commandes — une commande lente bloque TOUS les clients. N'utilisez jamais KEYS, SMEMBERS ni DEL sur de grandes structures en production. Utilisez la famille SCAN, HSCAN et UNLINK (suppression async) à la place. Pipelinez les commandes pour réduire les aller-retours. Connaissez le Big-O de chaque commande : O(1) et O(log N) sûrs ; les commandes O(N) doivent être bornées (LRANGE avec petites plages).
# Redis is single-threaded (mostly) — avoid blocking commands
# DANGEROUS on large datasets (block the server):
KEYS * # use SCAN instead
SMEMBERS bigset # use SSCAN
HGETALL bighash # use HSCAN
DEL hugekey # use UNLINK (async delete)
FLUSHDB # use FLUSHDB ASYNC
# use UNLINK instead of DEL for large keys (non-blocking)
UNLINK bigkey # deletes in a background thread
# favor pipelining and batch commands
MGET k1 k2 k3 # one round-trip, not three GETs
LPUSH list a b c # one command, not three
# prefer structurally efficient commands
# O(1): GET, SET, HGET, SISMEMBER, ZSCORE
# O(log N): ZADD, ZRANGE
# O(N): LRANGE, SMEMBERS, KEYS, SORTPipelining et opérations en lot
Le pipelining est le plus grand levier de performance Redis — batcher les commandes en un seul aller-retour réseau peut donner 10 à 100x d'accélération. Chaque aller-retour coûte la latence réseau (~0,1-1 ms) ; 1000 commandes individuelles = 100-1000 ms, mais pipeliné = ~1 ms. Ne sur-pipelinez pas (les réponses en file consomment la mémoire). Benchmark avec redis-benchmark -P pour trouver votre point idéal. Les transactions pipelinent automatiquement.
# pipelining: send many commands without waiting for replies
# (reduces round-trip time — huge speedup over network)
# example (Node.js with ioredis):
const pipeline = redis.pipeline()
for (let i = 0; i < 1000; i++) {
pipeline.set(`key:${i}`, "value")
}
await pipeline.exec() # one round-trip for 1000 commands
# transactions (MULTI/EXEC) are automatically pipelined
redis.multi().set("k", "v").incr("c").exec()
# MSET/MGET batch in one command
MSET k1 v1 k2 v2 k3 v3
MGET k1 k2 k3
# benchmark pipelining
redis-benchmark -t set -n 100000 -P 16 # -P = pipeline size
# don't pipeline too many at once (memory for queued replies)
# batch in groups of 100-1000Optimisation mémoire
La mémoire est la contrainte principale de Redis. Utilisez la bonne structure : hashes pour les objets (l'encodage listpack est 5 à 10x plus petit que des clés séparées). Réglez les seuils d'encodage pour garder les structures compactes. Le « key bucketing » (grouper les petites clés dans un hash) réduit drastiquement l'overhead par clé. Réglez maxmemory + une politique d'éviction pour prévenir l'OOM. Surveillez used_memory et le ratio de fragmentation.
# use the right data structure (memory vs speed trade-offs)
# store small objects as hashes (listpack encoding is compact)
HSET user:1 name "Alice" age 30 # better than 3 string keys
# tune encoding thresholds (redis.conf)
hash-max-listpack-entries 128 # hash -> hashtable above this
hash-max-listpack-value 64 # field value size limit
list-max-listpack-size -2 # listpack max size
set-max-intset-entries 512 # intset -> hashtable above this
zset-max-listpack-entries 128
# use hashes for many small keys (key bucketing)
# instead of SET user:1:clicks 5; SET user:2:clicks 3
# use HSET clicks user:1 5 user:2 3
# monitor memory
INFO memory | grep used_memory_human
MEMORY STATS
# set maxmemory and an eviction policy
maxmemory 4gb
maxmemory-policy allkeys-lruPolitiques d'éviction
La politique d'éviction contrôle le comportement quand la mémoire est pleine. Pour un pur cache : allkeys-lru ou allkeys-lfu (LFU mieux pour des patterns d'accès biaisés). Pour une base : noeviction (les écritures échouent plutôt que de perdre des données). Pour un usage mixte : volatile-lru (évince seulement les clés avec TTL, garde les persistantes). LFU (4.0+) suit la fréquence d'accès, surpassant souvent LRU. Surveillez evicted_keys pour dimensionner maxmemory correctement.
# when maxmemory is reached, Redis evicts keys per the policy
# maxmemory-policy options:
# no eviction (writes fail with OOM error)
maxmemory-policy noeviction
# LRU (Least Recently Used) — approximate LRU
allkeys-lru # evict any key (cache use case)
volatile-lru # only evict keys with TTL set
# LFU (Least Frequently Used) — better for skewed access
allkeys-lfu
volatile-lfu
# random eviction
allkeys-random
volatile-random
# TTL-based (evict soonest-expiring)
volatile-ttl
# for a cache: allkeys-lru or allkeys-lfu (best hit rate)
# for a database: noeviction (never lose data silently)
# mixed (some persistent, some cache): volatile-lruBenchmarking
redis-benchmark mesure le débit et la latence sous charge. -c (concurrence) simule des clients ; -P (pipelining) teste la performance batchée. --latency montre le temps d'aller-retour en temps réel. Pour des résultats précis, lancez le benchmark depuis une machine proche de Redis (le réseau domine). Redis 6+ supporte --threads pour un benchmarking multi-threadé. Performance typique mono-nœud : 100K+ ops/s sur matériel ordinaire.
# redis-benchmark: built-in performance testing
redis-benchmark -t set,get -n 100000 -c 50
# -t: test commands, -n: number of requests, -c: concurrent clients
# test with pipelining
redis-benchmark -t set -n 100000 -c 50 -P 16
# test a specific command with a specific key
redis-benchmark -t get -n 100000 -r 100000 -q
# -r: random keys (INSERT random keys for testing)
# latency check (100 requests, shows distribution)
redis-cli --latency
redis-cli --latency-history # rolling update
redis-cli --latency-dist # histogram
# in-memory test (no network overhead)
redis-benchmark -t set -n 100000 -q --threads 4
# monitor while benchmarking
redis-cli INFO stats | grep instantaneous_ops_per_secAdministration
Infos serveur et monitoring
INFO est la commande de monitoring principale — vérifiez régulièrement les sections mémoire, clients, persistance et stats. MEMORY DOCTOR et LATENCY DOCTOR fournissent une analyse automatisée. SLOWLOG attrape les commandes lentes. CLIENT LIST montre toutes les connexions (surveillez les fuites — chacune consomme de la mémoire). Mettez en place un monitoring externe (Prometheus + redis_exporter, Datadog) pour des graphiques historiques et des alertes sur mémoire, connexions et lag de réplication.
# comprehensive server information
INFO # all sections
INFO server # version, uptime, config
INFO clients # connected clients
INFO memory # memory usage, fragmentation
INFO persistence # RDB/AOF status
INFO stats # ops/sec, hit rate, keyspace
INFO replication # primary/replica state
INFO keyspace # keys per database
# real-time stats
LATENCY DOCTOR # latency analysis
MEMORY DOCTOR # memory analysis
# live monitoring (subscribe to a special channel)
SUBSCRIBE __redis__:invalidate
# slow query log
SLOWLOG GET 10
SLOWLOG LEN
# client connections
CLIENT LIST
CLIENT KILL ID <id> # disconnect a clientGestion des clients
CLIENT LIST identifie les connexions par adresse, nom et commande courante — inestimable pour trouver des fuites ou clients bloqués. CLIENT SETNAME étiquette les connexions pour une identification facile (réglez-le dans votre app à la connexion). CLIENT PAUSE bloque brièvement les clients pour des migrations/snapshots sûrs. Réglez un timeout pour nettoyer les connexions inactives. maxclients prévient l'épuisement des connexions (chaque client utilise de la mémoire).
# list all connected clients
CLIENT LIST
# id, addr, name, age, idle, flags, db, cmd
# name your connections (for identification)
CLIENT SETNAME "my-app-worker-1"
# get the current client's info
CLIENT INFO
# get the current client's ID
CLIENT ID
# kill a client
CLIENT KILL ADDR 1.2.3.4:12345
CLIENT KILL ID 42
CLIENT KILL TYPE normal # kill all normal clients
# pause clients (for maintenance, 10 seconds)
CLIENT PAUSE 10000
# set a timeout for idle clients
CONFIG SET timeout 300 # 5 minutes
# max clients
CONFIG SET maxclients 10000Configuration
CONFIG SET change les réglages à l'exécution (pas de redémarrage) ; CONFIG REWRITE les persiste dans redis.conf. Testez toujours les changements de config en staging. Réglages de production clés : maxmemory + politique d'éviction (prévenir l'OOM), save + appendonly (persistance), tcp-keepalive (détecter les clients morts), timeout (nettoyer les connexions inactives). Versionnez votre redis.conf. CONFIG GET * montre tout — utile pour l'audit.
# view config (runtime changes with CONFIG SET)
CONFIG GET maxmemory
CONFIG GET maxmemory-policy
CONFIG GET save
CONFIG GET appendonly
# change config at runtime
CONFIG SET maxmemory 4gb
CONFIG SET maxmemory-policy allkeys-lru
CONFIG SET slowlog-log-slower-than 10000
# persist config changes to redis.conf
CONFIG REWRITE
# view all config (large output)
CONFIG GET *
# typical redis.conf (production):
# bind 127.0.0.1
# protected-mode yes
# port 6379
# maxmemory 4gb
# maxmemory-policy allkeys-lru
# save 3600 1
# appendonly yes
# appendfsync everysec
# tcp-keepalive 300
# timeout 0Débogage et dépannage
OBJECT ENCODING révèle la représentation interne (débogage mémoire). OBJECT IDLETIME trouve les clés froides (candidates à l'éviction). MEMORY USAGE par clé identifie les gouffres mémoire. DEBUG SLEEP teste comment votre app gère la latence. LATENCY suit les événements (expiration, éviction, clés rapides). La défragmentation active (4.0+) récupère automatiquement la mémoire fragmentée en ligne. Utilisez les commandes DEBUG avec parcimonie en production.
# check if a key exists and its type
EXISTS mykey
TYPE mykey
OBJECT ENCODING mykey
OBJECT IDLETIME mykey # seconds since last access
# memory usage per key
MEMORY USAGE mykey
# find keys blocking the server (DEBUG SLEEP for testing)
DEBUG SLEEP 2 # blocks for 2 seconds (testing only)
# check the latency
LATENCY HISTORY event
LATENCY GRAPH event
# object frequency (LFU mode)
OBJECT FREQ mykey
# inspect a key's internal structure (debugging)
DEBUG OBJECT mykey # raw internal info
# last saved RDB timestamp
LASTSAVE
# active defragmentation (4.0+)
CONFIG SET activedefrag yes
MEMORY MALLOC-STATSMises à niveau et maintenance
Pour des mises à niveau sans interruption, utilisez la réplication : mettez à niveau les réplicas d'abord, failover, puis l'ancien primaire. Pour les clusters, redémarrages glissants un nœud à la fois (primaire à failover d'abord). Backupez toujours (BGSAVE + copie RDB) avant mise à niveau. Lisez les release notes pour les changements cassants. Testez en staging. Redis maintient la compatibilité descendante entre versions mineures, mais les majeures peuvent avoir des étapes de migration.
# upgrade a standalone Redis:
# 1. save the dataset
SAVE
# 2. stop Redis
redis-cli SHUTDOWN
# 3. replace the binary
# 4. start the new version
redis-server /etc/redis/redis.conf
# upgrade a primary/replica pair (zero downtime):
# 1. upgrade the REPLICA first
SHUTDOWN
# 2. start new version on replica
# 3. promote replica to primary (SENTINEL FAILOVER)
# 4. upgrade the old primary (now a replica)
# 5. failback if desired
# upgrade a cluster:
# 1. upgrade one node at a time (rolling)
# 2. for each node: CLUSTER FAILOVER (if primary), upgrade, restart
# always back up before upgrading
# check the release notes for breaking changes
# test the upgrade in staging first
# rolling restart of a cluster (script)
for node in $nodes; do
redis-cli -h $node CLUSTER FAILOVER
redis-cli -h $node SHUTDOWN
ssh $node "systemctl start redis"
donePatterns courants
Pattern de cache (cache-aside)
Cache-aside est le pattern Redis le plus courant : lire le cache, retomber sur la DB au miss, peupler le cache. Réglez un TTL pour borner l'obsolescence. Pour les écritures, soit write-through (mettre à jour le cache à l'écriture DB), soit invalidation (supprimer la clé de cache). L'invalidation est plus sûre (pas de course au repeuplement), mais le write-through garde le cache chaud. Protection contre le stampede : utilisez un verrou ou le pattern 'dogpile' pour éviter que beaucoup de requêtes ne frappent la DB simultanément au miss.
# cache-aside: app checks cache, falls back to DB, fills cache
# pseudo-code:
function get_user(id):
# 1. check cache
data = GET("user:" + id)
if data:
return JSON.parse(data)
# 2. cache miss -> query database
data = db.query("SELECT * FROM users WHERE id = ?", id)
# 3. fill cache (with TTL to avoid stale data)
SET("user:" + id, JSON.stringify(data), "EX", 3600)
return data
# write-through: update cache when DB changes
function update_user(id, data):
db.update(id, data)
SET("user:" + id, JSON.stringify(data), "EX", 3600)
# cache invalidation:
DEL("user:" + id) # when the DB record is deletedVerrous distribués
Les verrous distribués avec SET NX EX sont simples mais demandent du soin : réglez toujours un TTL (prévenir les deadlocks si le détenteur crashe), et utilisez un token unique pour ne libérer que votre propre verrou (check-and-delete atomique via Lua). Pour plus de sûreté face aux scénarios de panne, l'algorithme Redlock utilise plusieurs instances Redis indépendantes. Les verrous ne sont pas parfaitement sûrs (dérive d'horloge, pauses GC) — pour de fortes garanties de justesse, considérez un système de consensus (etcd, ZooKeeper). Les verrous Redis suffisent pour la plupart des coordinations pratiques.
# SET NX with expiry = simple distributed lock
SET lock:resource "token-abc" NX EX 10
# returns OK if acquired, nil if already held
# release: only delete if the value matches (avoid releasing others' locks)
# (requires a Lua script for atomicity)
EVAL "
if redis.call('GET', KEYS[1]) == ARGV[1] then
return redis.call('DEL', KEYS[1])
end
return 0
" 1 lock:resource "token-abc"
# Redlock algorithm (multi-instance, higher safety):
# 1. get the time
# 2. SET NX on N (usually 5) independent Redis instances
# 3. if acquired on majority (3/5) within validity window -> locked
# 4. otherwise, release on all instances and retry
# lock options:
# EX 10 # expire after 10 seconds (safety)
# NX # only if not exists
# "token" # unique value per lock holder (for safe release)Rate limiting
La fenêtre fixe (INCR+EXPIRE) est la plus simple mais autorise un burst 2x aux frontières de fenêtre. La fenêtre glissante (sorted set de timestamps) est plus précise mais plus gourmande. Le token bucket autorise le burst jusqu'à un max. Tout peut être atomique avec des scripts Lua (important pour la justesse en concurrence). Pour le rate limiting par utilisateur à l'échelle, la fenêtre fixe suffit généralement et est très économe en mémoire.
# fixed window rate limiter (simple)
# INCR + EXPIRE on first request
count = INCR("rate:user:1")
if count == 1:
EXPIRE("rate:user:1", 60) # 60-second window
if count > 100:
return "Rate limited"
# sliding window rate limiter (sorted set)
now = current_time_millis()
ZADD("rate:user:1", now, now) # add current request
ZREMRANGEBYSCORE("rate:user:1", 0, now - 60000) # remove old
EXPIRE("rate:user:1", 60)
count = ZCARD("rate:user:1") # current count
if count > 100:
return "Rate limited"
# token bucket (Lua script for atomicity)
# maintains a bucket of tokens refilled over time
# see: https://redis.io/docs/patterns/distributed-locks/
# GCRA (Generic Cell Rate Algorithm) — elegant single-key versionLeaderboard et classement
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. Pour les rangs en percentiles, combinez ZCARD et ZREVRANK. C'est l'un des cas d'usage les plus naturels et puissants de Redis.
# sorted set = perfect for leaderboards
ZADD leaderboard 100 "alice" 250 "bob" 150 "carol"
# top 10 players (highest scores)
ZREVRANGE leaderboard 0 9 WITHSCORES
# a player's rank
ZREVRANK leaderboard "alice" # 0-indexed from top
# update a score (atomic)
ZINCRBY leaderboard 50 "alice"
# players within a score range (e.g., silver tier 100-199)
ZRANGEBYSCORE leaderboard 100 199
# percentile rank
total = ZCARD(leaderboard)
rank = ZREVRANK(leaderboard "alice"
percentile = (total - rank) / total * 100
# pagination (page 3, 10 per page)
ZREVRANGE leaderboard 20 29 WITHSCORES
# time-bucketed leaderboards (weekly)
ZADD leaderboard:2025-W01 100 "alice"
EXPIRE leaderboard:2025-W01 604800 # 1 week TTLStore de sessions
Redis est le store de sessions classique : rapide, supporte le TTL (expiration automatique) et partagé entre serveurs d'app. Utilisez un hash par session avec un TTL glissant (rafraîchi à chaque requête). Suivez les sessions d'un utilisateur dans un set pour les fonctionnalités « déconnexion partout ». En cluster, utilisez des hash tags ({user:1}) pour garder la session d'un utilisateur et son index de session dans le même shard. Rotez les IDs de session aux connexions/changements de privilèges pour la sécurité.
# Redis is ideal for web sessions (fast, expiring, shared)
# store session as a hash with TTL
HSET session:abc123 user_id 1 last_active 1700000000 data "..."
EXPIRE session:abc123 1800 # 30-minute timeout
# update session (and refresh TTL)
HSET session:abc123 last_active 1700001000
EXPIRE session:abc123 1800 # sliding expiration
# destroy a session
DEL session:abc123
# list active sessions for a user (index by user)
SADD user:1:sessions "session:abc123"
SMEMBERS user:1:sessions # all session IDs
# cluster-friendly: use a hash tag for the user's sessions
SADD {user:1}:sessions "session:abc123"
# enables multi-key operations on the user's session data
# rotate session ID on privilege change (security)
RENAME session:old session:new
EXPIRE session:new 1800Scripting 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). redis.call lève les erreurs (arrête), redis.pcall les retourne. Les scripts se cachent par leur hash SHA1, donc les appels répétés utilisent EVALSHA pour l'efficacité.
# run a Lua script inline
EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mykey "hello"
# 1 = number of keys
# mykey = KEYS[1]
# "hello" = ARGV[1]
# return types: string/integer/boolean/table (nil/true/false)
EVAL "return 42" 0
EVAL "return {1, 2, 3}" 0
EVAL "return redis.call('GET', KEYS[1])" 1 mykey
# redis.call() raises error if command fails (stops script)
# redis.pcall() returns error as a table (can handle)
EVAL "local ok, err = pcall(redis.call, 'GET', 'missing'); return err" 0EVALSHA et cache de scripts
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.
# load script once, get its SHA1
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# returns: "fa00..." (the SHA1)
# execute by hash (saves bandwidth on repeated calls)
EVALSHA "fa00..." 1 mykey
# check if a script is cached
SCRIPT EXISTS "fa00..." "abcd..."
# returns: 1) 1 2) 0
# flush the script cache
SCRIPT FLUSH
# list all running scripts (NOSCRIPT errors = cache miss -> reload)
SCRIPT DEBUG SYNC # blocking debug mode
SCRIPT DEBUG NO # disableOpérations atomiques
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 et migrations de files 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.
# atomic compare-and-set (only update if value matches)
local cur = redis.call('GET', KEYS[1])
if cur == ARGV[1] then
return redis.call('SET', KEYS[1], ARGV[2])
end
return 0
# atomic 'decrement if positive' (semaphore / rate limit)
local val = tonumber(redis.call('GET', KEYS[1]) or 0)
if val > 0 then
redis.call('DECR', KEYS[1])
return 1
end
return 0
# atomic list pop + push (move between queues)
local item = redis.call('RPOP', KEYS[1])
if item then
redis.call('LPUSH', KEYS[2], item)
end
return itemRedis Functions (7.0+)
Redis Functions (7.0+) est le remplaçant moderne des scripts EVAL ad-hoc : enregistrées, nommées et versionnées comme des procédures stockées de base de données. Une bibliothèque regroupe plusieurs fonctions ; FCALL les invoque. Les fonctions persistent dans RDB/AOF (survivent aux redémarrages), contrairement aux caches EVAL éphémères. Elles rendent le scripting plus maintenable pour une logique non triviale, et plus faciles à auditer et versionner.
# register a library of functions
FUNCTION LOAD "#!lua name=mylib
redis.register_function('myset', function(keys, args)
return redis.call('SET', keys[1], args[1])
end)
redis.register_function('double', function(keys, args)
local v = tonumber(redis.call('GET', keys[1]))
return redis.call('SET', keys[1], v * 2)
end)
"
# call a function
FCALL myset 1 mykey "hello"
FCALL double 1 counter
# list libraries
FUNCTION LIST
FUNCTION LIST WITHCODE
# delete a library
FUNCTION DELETE mylib
# dump and restore (for backup / migration)
FUNCTION DUMP
FUNCTION RESTORE <payload>Déboguer les scripts
Utilisez redis.log() pour émettre des messages dans le log Redis pour le débogage sans affecter les valeurs de retour. redis-cli --ldb est un débogueur Lua interactif : breakpoints, pas à pas, inspection des locales. SCRIPT DEBUG SYNC fait bloquer le serveur sur le script pour que le débogueur puisse steper. Testez toujours les scripts en staging — une boucle incontrôlée peut verrouiller tout le serveur Redis. Gardez les scripts déterministes (pas de random/time) pour la justesse de la réplication.
# LOG writes to the Redis log (visible in redis-cli)
EVAL "redis.log(redis.LOG_NOTICE, 'hello from lua'); return 1" 0
# levels: LOG_DEBUG, LOG_VERBOSE, LOG_NOTICE, LOG_WARNING
# return the error object on pcall failure
EVAL "local ok, err = pcall(function()
error('something broke')
end)
return {ok=tostring(ok), err=tostring(err)}" 0
# debugger (Redis 5.0+)
SCRIPT DEBUG SYNC # synchronous, blocking
TDEBUG # step / continue / print
# use redis-cli --ldb to launch debugger:
# redis-cli --ldb --eval myscript.lua key1 key2 , arg1 arg2
# print variables in the debugger
print myvar
step
continueMonitoring et dépannage
INFO et LATENCY
INFO est la commande de monitoring la plus importante — elle rapporte mémoire, clients, réplication et débit en un coup. Surveillez mem_fragmentation_ratio (idéal ~1,0–1,5) ; >1,5 gaspille la mémoire, <1 signifie que Redis swappe (catastrophique pour la latence). LATENCY DOCTOR analyse les événements lents récents et suggère des correctifs. Surveillez keyspace_misses vs keyspace_hits pour suivre votre ratio de hit de cache.
# INFO: server, clients, memory, stats, replication, cpu
INFO # everything
INFO memory # memory section only
INFO replication # replica lag, master link
INFO stats # ops/sec, keyspace hits/misses
# key metrics to watch:
# used_memory_rss # RSS from OS (real footprint)
# mem_fragmentation_ratio # >1.5 = fragmentation, <1 = swapping (bad!)
# connected_clients # client connections
# instantaneous_ops_per_sec
# keyspace_misses # cache hit ratio = hits / (hits + misses)
# LATENCY: samples slow events
LATENCY HISTORY event-name
LATENCY DOCTOR # human-readable diagnosis
LATENCY RESET
# LATENCY GRAPH event-name (ASCII art)SLOWLOG et CLIENT LIST
SLOWLOG capture les commandes plus lentes que le seuil configuré (défaut 10 ms) — inestimable pour trouver les requêtes causant les pics de latence. Les opérations keyspace comme KEYS * et SMEMBERS sur d'énormes sets sont des coupables courants. CLIENT LIST montre chaque connexion avec temps d'inactivité et commande courante ; utilisez CLIENT SETNAME pour étiqueter les connexions de votre app afin d'identifier à quel pool appartient un client bloqué.
# SLOWLOG: record slow commands (over slowlog-log-slower-than, default 10ms)
CONFIG SET slowlog-log-slower-than 10000 # 10ms in microseconds
CONFIG SET slowlog-max-len 128 # keep last 128 entries
SLOWLOG GET # last 10 slow commands
SLOWLOG GET 5 # last 5
SLOWLOG RESET # clear
# each entry: id, timestamp, duration (us), command args, client, addr
# CLIENT LIST: see all connected clients
CLIENT LIST
# fields: id, addr, fd, name, age, idle, flags, db, cmd, ...
# kill a stuck client
CLIENT KILL ADDR 10.0.0.1:12345
CLIENT KILL ID 42
# name your connections for easier debugging
CLIENT SETNAME my-app-workerMEMORY et OBJECT
MEMORY USAGE rapporte les octets précis d'une clé (avec SAMPLES 0 pour une exactitude complète sur les grandes collections). OBJECT ENCODING révèle le format interne de Redis — les petites structures utilisent des encodages compacts (listpack, ziplist) économes en CPU et mémoire, promus automatiquement en tables de hachage / skiplists à mesure qu'elles croissent. Connaître l'encodage aide à expliquer pourquoi une clé est plus grosse ou plus lente que prévu.
# MEMORY USAGE: bytes used by a single key
MEMORY USAGE key
MEMORY USAGE bigset SAMPLES 0 # scan all elements (accurate)
# MEMORY STATS: detailed allocator stats
MEMORY STATS
# MEMORY DOCTOR: diagnosis
MEMORY DOCTOR
# OBJECT ENCODING: see internal representation
OBJECT ENCODING mylist # quicklist / ziplist / listpack / hashtable
OBJECT REFCOUNT mykey
OBJECT IDLETIME mykey # seconds since last access
OBJECT FREQ mykey # LFU access frequency (only with maxmemory-policy LFU)
# why is my key so big? use DEBUG OBJECT (careful, can be slow)
DEBUG OBJECT mykeyBigkey et scan keyspace
N'utilisez jamais KEYS en production — il bloque le serveur. SCAN est l'alternative par curseur non bloquante ; itérez jusqu'à ce que le curseur revienne à 0. --bigkeys et --memkeys sont des helpers CLI bâtis sur SCAN qui font remonter les plus grandes clés sans bloquer. Les grandes clés (surtout les collections à millions d'éléments) causent des pics de latence à l'expiration/éviction — trouvez-les et scindez-les (ex. sharder un énorme sorted set par temps).
# find big keys safely (production-safe, samples)
redis-cli --bigkeys
# scans keyspace, reports largest of each type
# more accurate: --memkeys (memory usage per key)
redis-cli --memkeys
redis-cli --hotkeys # with LFU policy, finds frequently-accessed keys
# SCAN: iterate keys without blocking (never use KEYS *)
SCAN 0 MATCH user:* COUNT 100
# returns: next-cursor, [key1, key2, ...]
SCAN <next-cursor> ...
# cursor 0 = done
# scan a hash field-by-field
HSCAN myhash 0 COUNT 100
SSCAN myset 0 MATCH prefix*
ZSCAN myzset 0
# inspect a key's TTL (left to live)
TTL mykey # seconds (-1 = no expire, -2 = no key)
PTTL mykey # millisecondsSanté du cluster et failover
CLUSTER NODES et CLUSTER INFO sont les contrôles de santé principaux du cluster — cherchez cluster_state:ok et que tous les slots soient assignés (16384 au total). CLUSTER FAILOVER sur un réplica déclenche un basculement de master contrôlé ; FORCE saute la sync initiale (plus rapide mais léger risque de perte de données) et TAKEOVER contourne le consensus du cluster (urgence seulement). Lancez toujours --cluster check après des reshardings ou incidents pour attraper des slots orphelins ou des états de split-brain.
# cluster node status
CLUSTER NODES
# fields: id, addr, flags (master/slave/fail?), slots, ping/pong
# cluster-wide health
CLUSTER INFO
# cluster_state:ok / cluster_slots_assigned / cluster_slots_ok
# cluster_known_nodes
# slot ownership (which node owns a key)
CLUSTER KEYSLOT mykey # hash slot number
CLUSTER COUNTKEYSINSLOT 1234
# reshard slots (use redis-cli --cluster reshard)
redis-cli --cluster reshard 127.0.0.1:7000 \
--cluster-from <node-id> --cluster-to <node-id> \
--cluster-slots 1000 --cluster-yes
# manual failover (on a replica)
CLUSTER FAILOVER # wait for sync
CLUSTER FAILOVER FORCE # skip sync (faster, slight data loss risk)
CLUSTER FAILOVER TAKEOVER # no consensus (emergency only)
# verify cluster after changes
redis-cli --cluster check 127.0.0.1:7000
redis-cli --cluster fix 127.0.0.1:7000 # auto-repair minor issuesSnippets Redis associés
Copy-paste ready code for common tasks.
Strings & Counters
Set, get, increment, and expire string values.
Lists & Queues
Build queues and stacks with list operations.
Hashes
Store object fields and values efficiently.
Sets
Manage unique collections and compute intersections.
Sorted Sets & Leaderboards
Rank items by score for leaderboards and scheduling.
Pub/Sub
Broadcast messages to subscribed clients.
Persistence
Configure RDB snapshots and AOF append logs.
Keys & Expiration
Set TTL, scan keys, and inspect the keyspace.
Was this helpful?