# Connect to local instance (default: 127.0.0.1:6379)
redis-cli

# Connect to a remote host with authentication
redis-cli -h <host> -p <port> -a <password>

# Test the connection
PING
# Response: PONG

# Select a database (0–15, default is 0)
SELECT 1

# Show server info and stats
INFO
INFO memory
INFO replication

SET counter 0
INCR counter        # => 1
INCRBY counter 5    # => 6

SET session:abc "token"
EXPIRE session:abc 3600   # expires in 1 hour
TTL session:abc           # => 3598 (or similar)

SET key value EX 60       # expire in 60 seconds
SET key value PX 5000     # expire in 5000 milliseconds
SET key value EXAT 1800000000   # expire at Unix timestamp
SET key value NX EX 60    # set only if not exists, then expire

# Queue (FIFO): push right, pop left
RPUSH jobs "task1" "task2"
BLPOP jobs 0              # blocks until an item is available

# Stack (LIFO): push and pop from the same end
LPUSH stack "a" "b"
LPOP stack                # => "b"

HSET user:1 name "Alice" email "alice@example.com" age 30
HGET user:1 name          # => "Alice"
HGETALL user:1
HINCRBY user:1 age 1      # age becomes 31

SADD page:visitors "user:1" "user:2" "user:3"
SADD vip:users "user:2" "user:4"
SINTER page:visitors vip:users   # => "user:2"

ZADD leaderboard 1500 "alice" 2200 "bob" 1800 "carol"
ZREVRANGE leaderboard 0 2 WITHSCORES   # top 3 players
ZINCRBY leaderboard 100 "alice"        # alice's score becomes 1600
ZRANGEBYSCORE leaderboard 1500 2000    # players in score range

# Terminal 1 — subscriber
SUBSCRIBE notifications

# Terminal 2 — publisher
PUBLISH notifications "Deploy completed successfully"

# RDB
save 900 1       # save if 1 key changed in 900 seconds
save 60 10000    # save if 10000 keys changed in 60 seconds

# AOF
appendonly yes
appendfsync everysec

WATCH account:balance

MULTI
DECRBY account:balance 100
INCRBY account:target 100
EXEC
# If account:balance was modified by another client between WATCH and EXEC,
# EXEC returns nil and the transaction is aborted.

# Atomic get-and-increment pattern
EVAL "
  local val = redis.call('GET', KEYS[1])
  if val then
    return redis.call('INCR', KEYS[1])
  else
    return redis.call('SET', KEYS[1], 1)
  end
" 1 mycounter

# Producer
XADD events * type "order.placed" order_id "42"

# Consumer group setup
XGROUP CREATE events processors $ MKSTREAM

# Consumer reads and acknowledges
XREADGROUP GROUP processors worker1 COUNT 10 STREAMS events >
XACK events processors <entry-id>

PFADD unique:visitors "user:1" "user:2" "user:1"
PFCOUNT unique:visitors   # => 2 (approximate)

GEOADD locations 13.361389 38.115556 "Palermo"
GEOADD locations 15.087269 37.502669 "Catania"
GEODIST locations Palermo Catania km   # => 166.27
GEOSEARCH locations FROMMEMBER Palermo BYRADIUS 200 km ASC

# Monitor all commands in real time (use only in development)
MONITOR

# Get configuration values
CONFIG GET maxmemory
CONFIG GET save

# Set configuration at runtime
CONFIG SET maxmemory 2gb
CONFIG SET maxmemory-policy allkeys-lru

# Rewrite redis.conf with current runtime config
CONFIG REWRITE

# Slow query log
SLOWLOG GET 10
SLOWLOG RESET
SLOWLOG LEN

# Client management
CLIENT LIST
CLIENT SETNAME my-service
CLIENT KILL ID <id>

# Debug and diagnostics
DEBUG SLEEP 0
OBJECT ENCODING key     # internal encoding (ziplist, hashtable, etc.)
OBJECT IDLETIME key     # seconds since key was last accessed
OBJECT FREQ key         # access frequency (LFU policy)
OBJECT REFCOUNT key
MEMORY USAGE key        # memory in bytes for a key
MEMORY DOCTOR           # recommendations for memory issues

CONFIG SET maxmemory 1gb
CONFIG SET maxmemory-policy allkeys-lru

# On a replica, point to the primary
REPLICAOF <host> <port>

# Remove replication (promote to primary)
REPLICAOF NO ONE

# Check replication status
INFO replication

# Node info
CLUSTER INFO
CLUSTER NODES
CLUSTER MYID

# Slot management
CLUSTER SLOTS
CLUSTER KEYSLOT key        # which slot a key belongs to
CLUSTER COUNTKEYSINSLOT n  # number of keys in a slot

# Manual failover
CLUSTER FAILOVER

r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)

# String
r.set("key", "value", ex=60)
val = r.get("key")

# Hash
r.hset("user:1", mapping={"name": "Alice", "age": "30"})
user = r.hgetall("user:1")

# Pipeline (batches commands in one round trip)
pipe = r.pipeline()
pipe.incr("counter")
pipe.expire("counter", 3600)
pipe.execute()

# Connection pool (recommended for production)
pool = redis.ConnectionPool(host="localhost", port=6379, max_connections=20)
r = redis.Redis(connection_pool=pool)
```

const redis = new Redis({ host: "localhost", port: 6379 });

// String
await redis.set("key", "value", "EX", 60);
const val = await redis.get("key");

// Hash
await redis.hset("user:1", "name", "Alice", "age", "30");
const user = await redis.hgetall("user:1");

// Pipeline
const pipeline = redis.pipeline();
pipeline.incr("counter");
pipeline.expire("counter", 3600);
await pipeline.exec();
```

rdb := redis.NewClient(&redis.Options{
    Addr: "localhost:6379",
})

ctx := context.Background()

// String
err := rdb.Set(ctx, "key", "value", time.Hour).Err()
val, err := rdb.Get(ctx, "key").Result()

// Pipeline
pipe := rdb.Pipeline()
pipe.Incr(ctx, "counter")
pipe.Expire(ctx, "counter", time.Hour)
_, err = pipe.Exec(ctx)
```

# Acquire lock: SET with NX (not exists) and PX (millisecond expiry)
SET lock:resource <unique-token> NX PX 30000

# Release lock (Lua script ensures atomicity)
EVAL "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end" 1 lock:resource <unique-token>

# Fixed window counter
INCR rate:user:42:2024010112
EXPIRE rate:user:42:2024010112 3600

SET cache:product:99 "<json>" EX 300   # cache for 5 minutes
SET cache:product:99 "<json>" EX 300 XX  # only update if key exists

HSET session:<token> user_id 42 created_at 1700000000
EXPIRE session:<token> 86400   # 24-hour session