Redis vs Valkey What Changed After the Fork (Complete Guide)

new_features:
  - Multi-threaded I/O (6× throughput on 8-core instances)
  - Tiered storage (NVMe for warm data, memory for hot)
  - Built-in observability (OpenTelemetry export)
  - Enhanced cluster rebalancing (zero-downtime slot migration)
  - Native S3 backup integration

# Redis 7.4.1 (single-threaded)
redis-benchmark -h redis-7.4 -p 6379 -c 50 -n 1000000 -t get,set -q

SET: 89,324 requests per second
GET: 94,118 requests per second

# Valkey 8.0.2 (multi-threaded I/O, 4 threads)
valkey-benchmark -h valkey-8.0 -p 6379 -c 50 -n 1000000 -t get,set -q

SET: 487,802 requests per second (+446%)
GET: 521,447 requests per second (+454%)

# Same dataset: 10M keys, 1KB average value
# Redis 7.4.1
INFO memory
used_memory_human: 11.8G
used_memory_rss_human: 13.2G

# Valkey 8.0.2 (tiered storage, 30% warm data on NVMe)
INFO memory
used_memory_human: 8.4G  (-29%)
used_memory_rss_human: 9.1G  (-31%)
used_memory_tiered_nvme: 3.6G

import valkey

client = valkey.Valkey(host='localhost', port=6379, decode_responses=True)

# Set JSON document
client.json_set('user:1001', '$', {
    'name': 'Sarah Chen',
    'email': 'sarah@example.com',
    'preferences': {'theme': 'dark', 'notifications': True}
})

# Query nested field
theme = client.json_get('user:1001', '$.preferences.theme')
# Returns: 'dark'

# Atomic update
client.json_set('user:1001', '$.preferences.notifications', False)

# 1. Check Redis version
redis-cli INFO server | grep redis_version
# Requires 7.0+ for smooth migration

# 2. Check for Redis Stack module usage
redis-cli MODULE LIST
# If JSON, BLOOM, GRAPH, SEARCH present → plan alternative

# 3. Check replication lag (if replica exists)
redis-cli INFO replication | grep master_repl_offset

# migration-strategy.yml
phases:
  - phase: 1-setup-valkey-replica
    steps:
      - Deploy Valkey 8.0 instance
      - Configure as Redis replica
      - Wait for full sync (monitor MASTER_LINK_STATUS)
    downtime: 0 seconds

  - phase: 2-verify-replication
    steps:
      - Compare key counts (DBSIZE on both)
      - Spot-check random keys (DUMP comparison)
      - Monitor replication lag (<100ms)
    downtime: 0 seconds

  - phase: 3-cutover
    steps:
      - Stop writes to Redis (maintenance mode or read-only)
      - Wait for Valkey to catch up (lag = 0)
      - Update application config to Valkey endpoint
      - Resume writes
    downtime: 30-90 seconds

  - phase: 4-validation
    steps:
      - Monitor error rates in application
      - Check Valkey command stats (INFO commandstats)
      - Keep Redis running as fallback for 24h
    downtime: 0 seconds

# migration.py — Redis to Valkey zero-downtime cutover
import redis
import valkey
import time

redis_client = redis.Redis(host='redis-primary.local', port=6379)
valkey_client = valkey.Valkey(host='valkey-replica.local', port=6379)

def verify_replication_lag():
    """Ensure Valkey replica is caught up"""
    redis_offset = int(redis_client.info('replication')['master_repl_offset'])
    valkey_offset = int(valkey_client.info('replication')['master_repl_offset'])
    lag = redis_offset - valkey_offset
    print(f"Replication lag: {lag} bytes")
    return lag < 1000  # <1KB lag acceptable

def verify_key_parity(sample_size=1000):
    """Spot-check random keys"""
    keys = redis_client.randomkey() for _ in range(sample_size)]
    mismatches = []
    
    for key in keys:
        redis_value = redis_client.dump(key)
        valkey_value = valkey_client.dump(key)
        if redis_value != valkey_value:
            mismatches.append(key)
    
    print(f"Mismatches: {len(mismatches)}/{sample_size}")
    return len(mismatches) == 0

# Pre-cutover validation
assert verify_replication_lag(), "Replication lag too high"
assert verify_key_parity(), "Key parity check failed"

# Cutover
print("Stopping writes to Redis...")
redis_client.config_set('replica-read-only', 'yes')  # Make Redis read-only

time.sleep(2)  # Wait for in-flight commands

print("Verifying final sync...")
assert verify_replication_lag(), "Final sync failed"

print("Promoting Valkey to primary...")
valkey_client.replicaof()  # Promote replica to primary

print("Migration complete. Update application config to Valkey endpoint.")

# Before (RedisJSON)
redis_client.json().set('user:1001', Path.root_path(), {'name': 'Sarah'})
value = redis_client.json().get('user:1001', Path('.name'))

# After (Valkey native JSON)
valkey_client.json_set('user:1001', '$', {'name': 'Sarah'})
value = valkey_client.json_get('user:1001', '$.name')

# PostgreSQL JSONB (recommended for complex queries)
import psycopg2

conn = psycopg2.connect("postgresql://localhost/mydb")
cur = conn.cursor()

cur.execute("""
    CREATE TABLE users (
        id INT PRIMARY KEY,
        data JSONB NOT NULL
    );
    CREATE INDEX idx_users_data_gin ON users USING GIN (data);
""")

# Insert
cur.execute(
    "INSERT INTO users (id, data) VALUES (%s, %s)",
    (1001, psycopg2.extras.Json({'name': 'Sarah', 'email': 'sarah@example.com'}))
)

# Query nested field
cur.execute("SELECT data->>'name' FROM users WHERE id = %s", (1001,))

# kubernetes/valkey-cluster.yaml
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: valkey-cluster
spec:
  serviceName: valkey
  replicas: 6  # 3 primaries + 3 replicas
  selector:
    matchLabels:
      app: valkey
  template:
    metadata:
      labels:
        app: valkey
    spec:
      containers:
      - name: valkey
        image: valkey/valkey:8.0.2
        ports:
        - containerPort: 6379
          name: client
        - containerPort: 16379
          name: gossip
        command:
          - valkey-server
          - /conf/valkey.conf
          - --cluster-enabled yes
          - --cluster-config-file /data/nodes.conf
          - --cluster-node-timeout 5000
          - --appendonly yes
          - --io-threads 4  # Multi-threaded I/O
          - --io-threads-do-reads yes
        volumeMounts:
        - name: conf
          mountPath: /conf
        - name: data
          mountPath: /data
        resources:
          requests:
            memory: "8Gi"
            cpu: "2000m"
          limits:
            memory: "16Gi"
            cpu: "4000m"
      volumes:
      - name: conf
        configMap:
          name: valkey-config
  volumeClaimTemplates:
  - metadata:
      name: data
    spec:
      accessModes: ["ReadWriteOnce"]
      resources:
        requests:
          storage: 100Gi
      storageClassName: fast-ssd

// cache/client.go — Redis-compatible client for Valkey
package cache

import (
    "context"
    "github.com/redis/go-redis/v9"
    "time"
)

type Client struct {
    rdb *redis.Client
}

func NewClient(addr string) *Client {
    return &Client{
        rdb: redis.NewClient(&redis.Options{
            Addr:         addr,  // Works with Redis OR Valkey
            Password:     "",
            DB:           0,
            PoolSize:     100,
            MinIdleConns: 20,
            MaxRetries:   3,
        }),
    }
}

func (c *Client) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error {
    return c.rdb.Set(ctx, key, value, ttl).Err()
}

func (c *Client) Get(ctx context.Context, key string) (string, error) {
    return c.rdb.Get(ctx, key).Result()
}

// Circuit breaker pattern for cache failures
func (c *Client) GetWithFallback(ctx context.Context, key string, fallback func() (string, error)) (string, error) {
    val, err := c.Get(ctx, key)
    if err == redis.Nil {
        // Cache miss — fetch from source
        return fallback()
    }
    if err != nil {
        // Cache failure — fallback to source, don't block request
        log.Warn("Cache error, falling back", "error", err)
        return fallback()
    }
    return val, nil
}

# Valkey on EKS (3-node cluster, HA)
# Instance: r7g.xlarge (4 vCPU, 32GB RAM)

# Monthly costs:
EC2 instances (3× r7g.xlarge): $329 × 3 = $987
EBS volumes (3× 100GB gp3): $8 × 3 = $24
Data transfer: ~$50
EKS control plane: $73

Total: $1,134/month

# Equivalent ElastiCache (3-node cluster):
# 3× cache.r7g.xlarge: $329 × 3 = $987
# Backup storage: ~$20
Total: $1,007/month

# valkey.conf security hardening
bind 10.0.0.0/8  # Internal VPC only
protected-mode yes
requirepass "strong-password-here"  # Change immediately

# Disable dangerous commands
rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command CONFIG "CONFIG-a3f9b2c8"  # Obfuscate

# TLS for client connections
tls-port 6379
port 0  # Disable non-TLS
tls-cert-file /etc/valkey/tls/valkey.crt
tls-key-file /etc/valkey/tls/valkey.key
tls-ca-cert-file /etc/valkey/tls/ca.crt

# monitoring/valkey_exporter.py — Prometheus metrics
from prometheus_client import Counter, Histogram, Gauge, start_http_server
import valkey
import time

valkey_client = valkey.Valkey(host='localhost', port=6379)

# Metrics
cache_hits = Counter('valkey_cache_hits_total', 'Total cache hits')
cache_misses = Counter('valkey_cache_misses_total', 'Total cache misses')
command_duration = Histogram('valkey_command_duration_seconds', 'Command latency', ['command'])
connected_clients = Gauge('valkey_connected_clients', 'Number of connected clients')
used_memory = Gauge('valkey_used_memory_bytes', 'Memory usage in bytes')

def collect_metrics():
    info = valkey_client.info()
    
    # Update gauges
    connected_clients.set(info['connected_clients'])
    used_memory.set(info['used_memory'])
    
    # Cache hit ratio
    stats = valkey_client.info('stats')
    cache_hits._value.set(stats['keyspace_hits'])
    cache_misses._value.set(stats['keyspace_misses'])

if __name__ == '__main__':
    start_http_server(9121)  # Prometheus scrape endpoint
    while True:
        collect_metrics()
        time.sleep(15)

#!/bin/bash
# backup-valkey.sh — Automated RDB snapshots to S3

VALKEY_HOST="valkey-primary.local"
S3_BUCKET="s3://backups.example.com/valkey"
TIMESTAMP=$(date +%Y%m%d-%H%M%S)

# Trigger BGSAVE
valkey-cli -h $VALKEY_HOST BGSAVE

# Wait for save to complete
while [ $(valkey-cli -h $VALKEY_HOST LASTSAVE) -eq $(valkey-cli -h $VALKEY_HOST LASTSAVE) ]; do
    sleep 5
done

# Upload to S3
aws s3 cp /var/lib/valkey/dump.rdb \
    ${S3_BUCKET}/dump-${TIMESTAMP}.rdb \
    --storage-class STANDARD_IA

# Retention: delete backups older than 30 days
aws s3 ls ${S3_BUCKET}/ | \
    awk '{if ($1 < "'$(date -d '30 days ago' +%Y-%m-%d)'") print $4}' | \
    xargs -I {} aws s3 rm ${S3_BUCKET}/{}