Proven Redis Tuning Techniques for Production Environments

1. Memory Optimization (most important, 90% of Redis issues stem from here)

1.1 Strictly control memory limit maxmemory 10G Without a limit Redis may be OOM‑killed, cause swap spikes, or hang.

Reserve a 20%‑30% safety margin and avoid filling memory completely.

1.2 Choose the right eviction policy maxmemory-policy allkeys-lfu For ordinary cache use allkeys-lru or allkeys-lfu.

For keys with expiration use volatile-lru.

Never use noeviction because it aborts writes when memory is full.

1.3 Prohibit BigKey

BigKey is the top performance killer.

String > 10KB

Hash/List/Set/ZSet element count > 5000 or total size > 10MB

Consequences: main‑thread blocking, slow master‑slave sync, migration/scale‑out failures.

Detection command: redis-cli --bigkeys Mitigation:

Split into smaller keys.

Use hash partitioning (bucketed hashes).

Compress values (gzip/protobuf).

1.4 Avoid HotKey

Hot keys saturate a single node’s network or CPU.

Use a local cache (e.g., Caffeine) as a fallback.

Duplicate hot keys (e.g., hotkey:1, hotkey:2) and access them randomly.

Enable multithreaded I/O in Redis 6.0+.

2. Core Configuration File Tuning

2.1 Disable Transparent Huge Pages (THP)

echo never > /sys/kernel/mm/transparent_hugepage/enabled

Enabling THP dramatically increases fork time, causing RDB saves to stall.

2.2 Set reasonable timeouts

timeout 300
tcp-keepalive 300

Prevents many idle connections from consuming file descriptors.

2.3 Rename dangerous commands

rename-command KEYS ""
rename-command FLUSHDB ""
rename-command FLUSHALL ""

This guards against accidental misuse and scan‑induced blocking.

2.4 Client configuration

Use a connection pool; avoid frequent connect/disconnect cycles.

Set appropriate max connections, timeouts, and retries.

Prevent a flood of short connections that cause high CPU usage on accept.

3. Persistence Tuning (RDB + AOF)

3.1 Avoid RDB during peak hours

RDB forks the process; larger memory means longer pauses.

save 3600 1
save 300 100
save 60 10000

In highly available clusters you can disable RDB and rely solely on AOF.

3.2 AOF optimization

appendfsync everysec
aof-load-truncated yes
aof-use-rdb-preamble yes   # hybrid persistence, must enable

everysec

balances performance and durability.

Never use always under high concurrency (performance drops ~90%).

3.3 Control AOF rewrite

auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

Prevents the AOF file from growing excessively and triggering frequent rewrites.

4. CPU and Concurrency Tuning

4.1 Enable multithreaded I/O (Redis 6.0+)

io-threads 4
io-threads-do-reads yes

Recommended thread count = number of CPU cores / 2.

Only network read/write is parallelized; command execution remains single‑threaded.

4.2 Eliminate slow commands

Avoid commands such as:

KEYS *

HGETALL

LRANGE key 0 -1

SINTER

/ SUNION on large sets ZINTERSTORE Monitor slow queries:

slowlog-log-slower-than 10000
slowlog-max-len 128

4.3 Use Pipeline / Lua for batch operations

Pipeline sends multiple commands in a single network round‑trip.

Lua scripts guarantee atomicity and reduce round‑trip latency; ideal for flash sales, rate limiting, bulk delete/get.

5. Network and Connection Optimization

5.1 Prefer Unix socket

unixsocket /tmp/redis.sock
unixsocketperm 777

Provides noticeable performance gains on internal networks.

5.2 Tune kernel TCP settings

net.core.somaxconn = 65535
net.ipv4.tcp_max_syn_backlog = 65535

Corresponding Redis setting: tcp-backlog 65535 5.3 Limit max connections maxclients 10000 Prevents file‑descriptor exhaustion.

6. Cluster and High‑Availability Tuning

6.1 Even slot distribution in Redis Cluster

Avoids traffic hotspots on individual nodes.

Schedule slot migrations outside peak periods.

6.2 Master‑slave latency optimization

Place master and replica in the same data center for low network latency.

Keep master memory moderate to reduce full‑sync time.

Disable persistence on replicas to lower load.

6.3 Sentinel optimization

Deploy at least three Sentinels.

Configure a correct quorum.

Avoid frequent master failovers.

7. Practical Troubleshooting Checklist

Check memory: INFO memory Check connections: INFO clients Check blocking: INFO stats Check slow queries: SLOWLOG GET 10 Check hit rate: keyspace_hits / (keyspace_hits + keyspace_misses) (below 90% is unacceptable)

8. One‑Sentence Redis Tuning Mantras

Control memory and eliminate BigKey.

Avoid fork during peak; use AOF with everysec .

Prohibit slow commands; disperse HotKey.

Leverage connection pools and enable multithreaded I/O.

Monitor hit rate, memory usage, and slow queries.