Redis vs Memcached — Which Cache Should You Use in 2026?

# Redis — store a hash (object) directly
redis-cli HSET user:123 name "Shubham" email "shubham@example.com" role "admin"
redis-cli HGET user:123 name
# "Shubham"
 
# Redis — sorted set for leaderboard
redis-cli ZADD leaderboard 1500 "user:alice"
redis-cli ZADD leaderboard 2300 "user:bob"
redis-cli ZREVRANGE leaderboard 0 9 WITHSCORES
# Top 10 users with scores
 
# Redis — list for a queue
redis-cli LPUSH tasks "send-email:123"
redis-cli RPOP tasks   # Worker consumes task
 
# Redis — set operations
redis-cli SADD online_users user:123 user:456
redis-cli SCARD online_users   # Count online users
 
# Memcached — only string values
memcache_client.set("user:123", json.dumps({"name": "Shubham", "email": "..."}))
# You serialize to JSON yourself — less flexible, more CPU

# RDB — periodic snapshots (default)
# redis.conf
save 900 1      # Save if 1 key changed in 900 seconds
save 300 10     # Save if 10 keys changed in 300 seconds
save 60 10000   # Save if 10000 keys changed in 60 seconds
 
# AOF — append-only log (more durable)
appendonly yes
appendfsync everysec  # Sync every second (good balance)

# Python pymemcache — client-side sharding
from pymemcache.client.hash import HashClient
client = HashClient([
    ('memcache1', 11211),
    ('memcache2', 11211),
    ('memcache3', 11211),
])
client.set('key', 'value')  # Client decides which node gets this key

apiVersion: redis.redis.opstreelabs.in/v1beta2
kind: Redis
metadata:
  name: redis-standalone
spec:
  kubernetesConfig:
    image: redis:7.2-alpine
  storage:
    volumeClaimTemplate:
      spec:
        accessModes: [ReadWriteOnce]
        resources:
          requests:
            storage: 5Gi
  redisConfig:
    additionalRedisConfig: secretName

apiVersion: redis.redis.opstreelabs.in/v1beta2
kind: RedisCluster
metadata:
  name: redis-cluster
spec:
  clusterSize: 3   # 3 masters + 3 replicas = 6 pods
  kubernetesConfig:
    image: redis:7.2-alpine
  storage:
    volumeClaimTemplate:
      spec:
        resources:
          requests:
            storage: 10Gi

helm repo add bitnami https://charts.bitnami.com/bitnami
 
# Standalone
helm install redis bitnami/redis \
  --set auth.password=secretpassword \
  --set master.persistence.size=5Gi
 
# Cluster
helm install redis bitnami/redis-cluster \
  --set password=secretpassword \
  --set cluster.nodes=6

apiVersion: apps/v1
kind: Deployment
metadata:
  name: memcached
spec:
  replicas: 3
  selector:
    matchLabels:
      app: memcached
  template:
    metadata:
      labels:
        app: memcached
    spec:
      containers:
      - name: memcached
        image: memcached:1.6-alpine
        args: ["-m", "512"]  # 512MB memory
        ports:
        - containerPort: 11211
        resources:
          requests:
            memory: "600Mi"
            cpu: "100m"
          limits:
            memory: "700Mi"

# Redis — Python
import redis
 
r = redis.Redis(host='redis', port=6379, decode_responses=True)
 
# Cache with TTL
r.setex("user:123:profile", 3600, json.dumps(user_data))
 
# Rate limiter
count = r.incr("rate:ip:1.2.3.4")
r.expire("rate:ip:1.2.3.4", 60)
if count > 100:
    raise RateLimitError()
 
# Pub/sub
r.publish("deploys", json.dumps({"service": "api", "version": "v2.1"}))

# Memcached — Python
from pymemcache.client.base import Client
 
mc = Client(('memcached', 11211))
 
# Cache with TTL
mc.set("user:123:profile", json.dumps(user_data), expire=3600)
 
# Get
data = mc.get("user:123:profile")