Redis 7 Cluster Operations and Memory Optimization Handbook 2026

#!lua name=mylib

-- Function that atomically increments view count and records view history
redis.register_function('increment_view', function(keys, args)
  local current = redis.call('HINCRBY', keys[1], 'views', 1)
  redis.call('ZADD', keys[1] .. ':history', redis.call('TIME')[1], args[1])
  return current
end)

# Load the library
cat mylib.lua | redis-cli -x FUNCTION LOAD REPLACE

# Call the function
redis-cli FCALL increment_view 1 article:1001 "user:42"

# List registered functions
redis-cli FUNCTION LIST

# Cache-only user: read/write on cache:* keys, read-only on session:* keys
redis-cli ACL SETUSER cache_worker on >StrongP@ss123 \
  ~cache:* +@all \
  (~session:* %R~session:* +@read)

# Verify ACL rules
redis-cli ACL GETUSER cache_worker

# Save current ACL list to file
redis-cli ACL SAVE

# Configure 6 Redis instances (ports 7000-7005)
for port in 7000 7001 7002 7003 7004 7005; do
  mkdir -p /opt/redis-cluster/${port}
  cat > /opt/redis-cluster/${port}/redis.conf << CONF
port ${port}
cluster-enabled yes
cluster-config-file nodes-${port}.conf
cluster-node-timeout 5000
appendonly yes
appendfilename "appendonly.aof"
dir /opt/redis-cluster/${port}
maxmemory 4gb
maxmemory-policy allkeys-lfu
bind 0.0.0.0
protected-mode no
save 3600 1 300 100 60 10000
aof-use-rdb-preamble yes
CONF
  redis-server /opt/redis-cluster/${port}/redis.conf &
done

# Create cluster (3 masters + 3 replicas)
redis-cli --cluster create \
  192.168.1.10:7000 192.168.1.10:7001 192.168.1.10:7002 \
  192.168.1.10:7003 192.168.1.10:7004 192.168.1.10:7005 \
  --cluster-replicas 1

# Place in the same slot: only the {user:1000} part is used for hash calculation
redis-cli SET "{user:1000}.profile" '{"name":"Kim"}'
redis-cli SET "{user:1000}.settings" '{"theme":"dark"}'
redis-cli SET "{user:1000}.cart" '["item1","item2"]'

# Verify they are in the same slot
redis-cli CLUSTER KEYSLOT "{user:1000}.profile"
redis-cli CLUSTER KEYSLOT "{user:1000}.settings"

# Add a new node to the cluster
redis-cli --cluster add-node 192.168.1.10:7006 192.168.1.10:7000

# Auto rebalancing: distribute slots evenly across all masters
redis-cli --cluster rebalance 192.168.1.10:7000

# Manually move slots from one node to another
redis-cli --cluster reshard 192.168.1.10:7000 \
  --cluster-from <source-node-id> \
  --cluster-to <target-node-id> \
  --cluster-slots 1000 \
  --cluster-yes

# Check cluster status
redis-cli --cluster check 192.168.1.10:7000
redis-cli --cluster info 192.168.1.10:7000

# Check memory usage of a specific key (in bytes)
redis-cli MEMORY USAGE user:profile:10001
# (integer) 256

# For nested structures, specify sample count (0 for full traversal)
redis-cli MEMORY USAGE myhash SAMPLES 0

# Memory diagnostic report
redis-cli MEMORY DOCTOR
# "Sam, I have no memory problems"

# Memory statistics summary
redis-cli MEMORY STATS

# Full server memory information
redis-cli INFO memory

# Maximum memory and eviction policy
maxmemory 4gb
maxmemory-policy allkeys-lfu

# LFU algorithm tuning
# lfu-log-factor: higher values slow counter increments (default 10)
# lfu-decay-time: counter decay period in minutes (default 1)
lfu-log-factor 10
lfu-decay-time 1

# Enable memory defragmentation (jemalloc-based)
activedefrag yes
active-defrag-enabled yes
active-defrag-ignore-bytes 100mb
active-defrag-threshold-lower 10
active-defrag-threshold-upper 100
active-defrag-cycle-min 1
active-defrag-cycle-max 25

# Lazy Free settings: background processing for large key deletions
lazyfree-lazy-eviction yes
lazyfree-lazy-expire yes
lazyfree-lazy-server-del yes
replica-lazy-flush yes

# I/O thread settings (Redis 7+)
io-threads 4
io-threads-do-reads yes

# redis.conf: encoding threshold adjustment examples
# Workloads with many small hashes: increase thresholds to maintain listpack
hash-max-listpack-entries 256
hash-max-listpack-value 128

# Ranking service with many small sorted sets
zset-max-listpack-entries 256
zset-max-listpack-value 64

# Tag system with many small sets
set-max-listpack-entries 256
set-max-intset-entries 1024

# Maximum size per list node (-2 = 8KB, -1 = 4KB)
list-max-listpack-size -2
list-compress-depth 1

# Check current encoding
redis-cli OBJECT ENCODING mykey

# Small hash (listpack)
redis-cli HSET small:hash f1 v1 f2 v2 f3 v3
redis-cli OBJECT ENCODING small:hash
# "listpack"

# Automatic transition to hashtable when threshold is exceeded
# Create a hash with 129 fields (exceeding default hash-max-listpack-entries=128)
for i in $(seq 1 129); do
  redis-cli HSET big:hash "field_${i}" "value_${i}"
done
redis-cli OBJECT ENCODING big:hash
# "hashtable"

# Set composed of only integers: intset encoding
redis-cli SADD int:set 1 2 3 4 5
redis-cli OBJECT ENCODING int:set
# "intset"

# redis.conf: Hybrid mode (production recommended)

# RDB snapshot intervals: 3600s (1 hour) with 1 change, 300s with 100 changes, 60s with 10000 changes
save 3600 1 300 100 60 10000

# Enable AOF
appendonly yes
appendfilename "appendonly.aof"

# AOF fsync policy: everysec (balance between performance and durability)
appendfsync everysec

# Enable hybrid mode: use RDB format as preamble during AOF rewrite
aof-use-rdb-preamble yes

# Multi-Part AOF directory (Redis 7 default)
appenddirname "appendonlydir"

# AOF rewrite trigger conditions
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

# RDB compression and checksum
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb

# Stop writes on background save failure
stop-writes-on-bgsave-error yes

# Check memory usage
redis-cli INFO memory | grep -E "used_memory_human|used_memory_rss_human|mem_fragmentation_ratio"
# used_memory_human:2.85G
# used_memory_rss_human:3.12G
# mem_fragmentation_ratio:1.09

# Check cluster status
redis-cli CLUSTER INFO
# cluster_state:ok
# cluster_slots_assigned:16384
# cluster_slots_ok:16384
# cluster_known_nodes:6
# cluster_size:3

# Commands processed per second
redis-cli INFO stats | grep instantaneous_ops_per_sec

# Check connection count
redis-cli INFO clients | grep connected_clients

# Keyspace hit rate (cache efficiency)
redis-cli INFO stats | grep -E "keyspace_hits|keyspace_misses"

# Check Slow Log (commands taking over 10ms)
redis-cli SLOWLOG GET 10
redis-cli SLOWLOG LEN

import redis
from redis.cluster import RedisCluster

# Redis Cluster connection
startup_nodes = [
    {"host": "192.168.1.10", "port": 7000},
    {"host": "192.168.1.10", "port": 7001},
    {"host": "192.168.1.10", "port": 7002},
]

rc = RedisCluster(
    startup_nodes=startup_nodes,
    decode_responses=True,
    password="your_secure_password",
    socket_timeout=5,
    retry_on_timeout=True,
)

def check_cluster_health():
    """Checks overall cluster status and sends alerts on anomalies."""
    alerts = []

    # Check cluster state
    cluster_info = rc.cluster_info()
    if cluster_info.get("cluster_state") != "ok":
        alerts.append(f"[CRITICAL] Cluster state abnormal: {cluster_info.get('cluster_state')}")

    # Check memory usage per node
    for node in rc.get_nodes():
        try:
            info = rc.get_redis_connection(node).info("memory")
            used = info["used_memory"]
            maxmem = info.get("maxmemory", 0)
            if maxmem > 0:
                usage_pct = (used / maxmem) * 100
                if usage_pct > 85:
                    alerts.append(
                        f"[WARNING] Node {node.host}:{node.port} "
                        f"memory usage {usage_pct:.1f}%"
                    )

            # Check memory fragmentation ratio
            frag_ratio = info.get("mem_fragmentation_ratio", 1.0)
            if frag_ratio > 1.5:
                alerts.append(
                    f"[WARNING] Node {node.host}:{node.port} "
                    f"memory fragmentation ratio {frag_ratio:.2f}"
                )
        except Exception as e:
            alerts.append(f"[ERROR] Node {node.host}:{node.port} connection failed: {e}")

    return alerts


def get_memory_report():
    """Generates a per-node memory usage report."""
    report = []
    for node in rc.get_nodes():
        try:
            info = rc.get_redis_connection(node).info("memory")
            report.append({
                "node": f"{node.host}:{node.port}",
                "role": node.server_type,
                "used_memory_human": info["used_memory_human"],
                "used_memory_rss_human": info["used_memory_rss_human"],
                "fragmentation_ratio": info["mem_fragmentation_ratio"],
                "used_memory_peak_human": info["used_memory_peak_human"],
            })
        except Exception as e:
            report.append({"node": f"{node.host}:{node.port}", "error": str(e)})
    return report


if __name__ == "__main__":
    # Cluster health check
    alerts = check_cluster_health()
    if alerts:
        for alert in alerts:
            print(alert)
        # send_to_slack(alerts) or send_to_pagerduty(alerts)
    else:
        print("All nodes healthy")

    # Memory report output
    for item in get_memory_report():
        print(item)

# Check current fragmentation ratio
redis-cli INFO memory | grep mem_fragmentation_ratio

# Enable Active Defrag at runtime
redis-cli CONFIG SET activedefrag yes
redis-cli CONFIG SET active-defrag-threshold-lower 10

# Check defragmentation progress
redis-cli INFO memory | grep -E "active_defrag"

# Big key scan (SCAN-based, safe for production)
redis-cli --bigkeys

# Exact memory usage of a specific key
redis-cli MEMORY USAGE large:hash SAMPLES 0

# Asynchronous deletion of big keys (UNLINK = non-blocking DEL)
redis-cli UNLINK large:hash

# redis.conf
repl-backlog-size 256mb
repl-backlog-ttl 3600

# Check current cluster node status
redis-cli CLUSTER NODES

# Check if a specific node is in FAIL state
redis-cli CLUSTER INFO | grep cluster_state

# Manual failover (executed from a replica)
redis-cli -p 7003 CLUSTER FAILOVER

# Force failover (when master is unresponsive)
redis-cli -p 7003 CLUSTER FAILOVER FORCE

# Verify AOF file integrity
redis-check-aof --fix /opt/redis-cluster/7000/appendonlydir/appendonly.aof.1.incr.aof

# Verify RDB file integrity
redis-check-rdb /opt/redis-cluster/7000/dump.rdb

# Restore from backup: stop instance then replace RDB/AOF files
redis-cli -p 7000 SHUTDOWN NOSAVE
cp /backup/dump.rdb /opt/redis-cluster/7000/dump.rdb
redis-server /opt/redis-cluster/7000/redis.conf