How to fix LOADING Redis is loading the dataset in memory in Redis

# Watch Redis startup logs
redis-cli INFO server | grep loading

# Output: loading:0 means finished, loading:1 means still loading
# Check how much is loaded
redis-cli INFO server | grep loading_changes_per_sec

# Check logs to see when loading completes
docker logs <container_name> | grep "Ready to accept"

# This message indicates loading is complete

const Redis = require('ioredis');

const redis = new Redis({
  host: 'localhost',
  port: 6379,
  maxRetriesPerRequest: null,
  enableReadyCheck: false,
  // Exponential backoff for retries
  retryStrategy: (times) => {
    const delay = Math.min(times * 50, 2000);
    return delay;
  },
  // Handle LOADING error
  lazyConnect: true,
});

redis.on('error', (err) => {
  if (err.message.includes('LOADING')) {
    console.log('Redis is loading, retrying...');
    // ioredis automatically retries with backoff
  }
});

// Connect with retry
await redis.connect();

const { createClient } = require('redis');

const client = createClient({
  host: 'localhost',
  port: 6379,
  socket: {
    reconnectStrategy: (retries) => {
      if (retries > 10) return new Error('Max retries reached');
      return Math.min(retries * 50, 500);
    },
  },
});

client.on('error', (err) => {
  if (err.message.includes('LOADING')) {
    console.log('Waiting for Redis to load...');
  }
});

await client.connect();

import redis
import time

def get_redis_with_retry(host='localhost', port=6379, max_retries=30):
    for attempt in range(max_retries):
        try:
            r = redis.Redis(host=host, port=port, decode_responses=True)
            r.ping()  # Test connection
            return r
        except redis.ConnectionError as e:
            if 'LOADING' in str(e):
                print(f"Redis loading, retrying in {2**attempt}ms...")
                time.sleep(2**attempt / 1000)
            else:
                raise
    raise Exception("Could not connect to Redis after retries")

redis_client = get_redis_with_retry()

package main

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

func main() {
  opts := &redis.Options{
    Addr: "localhost:6379",
  }

  // Add custom retry backoff
  opts.Retry = func(ctx context.Context, attempt int, err error) time.Duration {
    if strings.Contains(err.Error(), "LOADING") {
      backoff := time.Duration(math.Pow(2, float64(attempt))) * 50 * time.Millisecond
      return backoff
    }
    return 0
  }

  client := redis.NewClient(opts)
  _ = client.Ping(ctx)
}

FROM redis:latest

# Simple approach: wait before first health check
HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=3 \
  CMD redis-cli ping || exit 1

apiVersion: v1
kind: Pod
metadata:
  name: redis
spec:
  containers:
  - name: redis
    image: redis:latest
    ports:
    - containerPort: 6379

    # Readiness probe: waits before declaring "ready"
    readinessProbe:
      exec:
        command:
        - redis-cli
        - ping
      initialDelaySeconds: 15  # Wait 15 seconds before first check
      periodSeconds: 5
      timeoutSeconds: 3
      failureThreshold: 3

    # Liveness probe: restarts if stuck in LOADING
    livenessProbe:
      exec:
        command:
        - redis-cli
        - ping
      initialDelaySeconds: 30  # Wait 30 seconds before checking
      periodSeconds: 10
      failureThreshold: 3

version: '3.8'
services:
  redis:
    image: redis:latest
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 3
      start_period: 10s  # Critical: wait 10s before health checks

# Check RDB snapshot size
ls -lh /var/lib/redis/dump.rdb

# Check AOF size (can grow very large)
ls -lh /var/lib/redis/appendonly.aof

# Expected load times (rough estimates):
# 1GB: ~1-2 seconds (depends on disk speed)
# 10GB: ~10-20 seconds
# 100GB: ~100+ seconds

# 1. Use RDB-only mode for faster startup (trades durability for speed)
# In redis.conf:
appendonly no
save 900 1  # Snapshot every 15 minutes with 1+ changes

# 2. Enable Redis Hybrid Persistence (Redis 4.0+) - combines RDB + AOF for fastest recovery
# in redis.conf:
aof-use-rdb-preamble yes

# 3. For very large datasets, consider switching to faster storage
# Mount Redis data on NVMe or SSD instead of HDD

# In another terminal, watch the loading progress
watch -n 1 "redis-cli INFO server | grep loading"

# Check system I/O during loading
iostat -x 1  # Linux
# or
ioutil # macOS

# Check RDB file integrity
redis-check-rdb /var/lib/redis/dump.rdb

# If corrupted, delete it (data will be lost)
# But Redis will start immediately
redis-cli SHUTDOWN
rm /var/lib/redis/dump.rdb
systemctl start redis

# To prevent data loss, ensure replicas are running
# Copy RDB from a healthy replica instead of deleting

# AOF files can become corrupted at the end (disk full, crash, etc.)
# Check and auto-repair
redis-check-aof --fix /var/lib/redis/appendonly.aof

# This will truncate corrupted entries and write a backup:
# /var/lib/redis/appendonly.aof.bak

# Then restart Redis
systemctl restart redis

# If both files exist, AOF takes precedence
# Check if AOF is causing the slowness
redis-cli CONFIG GET appendonly
# If yes, temporarily disable it for faster startup
redis-cli CONFIG SET appendonly no
# Then BGSAVE to create a fresh RDB snapshot
redis-cli BGSAVE

# Enable AOF rewrite to keep AOF file smaller and corruption-resistant
redis-cli CONFIG SET auto-aof-rewrite-percentage 100
redis-cli CONFIG SET auto-aof-rewrite-min-size 67108864  # 64MB

# Enable RDB checksums (Redis 5.0+)
redis-cli CONFIG SET rdb-save-incremental-fsync yes

# Connect to the replica and check its status
redis-cli -p 6380 INFO replication

# Look for these fields:
# - role: slave
# - master_link_status: up/down
# - slave_read_only: yes
# - repl_backlog_active: 1 (syncing)

# In redis.conf, tune replication settings:

# Increase repl-diskless-sync for large datasets
repl-diskless-sync yes
repl-diskless-sync-delay 5

# Increase backlog to prevent full syncs on minor disconnects
repl-backlog-size 512mb  # Default 1MB is too small
repl-backlog-ttl 3600    # Keep backlog for 1 hour

# Increase timeout to avoid unnecessary resync attempts
repl-timeout 60

# After changing, restart replica
systemctl restart redis-replica

# If you have cascading replicas, partial resync is even more critical
# Configure each replica to keep a large backlog

# Monitor replication chain
redis-cli INFO replication  # On each instance

# Disable persistence entirely for instant startup
# In redis.conf:
save ""                    # Disable RDB snapshots
appendonly no              # Disable AOF

# This trades durability for availability
# Suitable for session stores, real-time caching, leaderboards
systemctl restart redis

# Redis will start immediately and be ready to serve

# Redis Sentinel automatically fails over to a healthy replica
# Replicas are promoted instantly without re-syncing the entire dataset

# Configuration in sentinel.conf:
sentinel monitor mymaster 127.0.0.1 6379 1
sentinel down-after-milliseconds mymaster 5000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 10000

# Start Sentinel
redis-sentinel /etc/redis/sentinel.conf

# Use Redis Cluster with multiple masters
# Shards remain available even if one node is loading

# Example with 3 masters + 3 replicas:
redis-cluster create \
  127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 \
  127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005

# One node loading doesn't affect the other 5

// Implement fallback logic
async function getFromRedisWithFallback(key) {
  try {
    const val = await redis.get(key);
    return val;
  } catch (err) {
    if (err.message.includes('LOADING')) {
      // Fall back to database during Redis loading
      return await database.get(key);
    }
    throw err;
  }
}

# Test basic command execution
redis-cli ping
# Should respond with PONG, not LOADING

# Check INFO server output
redis-cli INFO server | grep loading
# Should show: loading:0

# For replication, verify sync completed
redis-cli INFO replication
# Master: should show connected_slaves > 0
# Replica: should show master_link_status:up

# For large datasets, verify all keys loaded
redis-cli DBSIZE
# Should return the expected number of keys

# Test application connection
# Your application should be able to execute commands normally

# Watch memory usage during loading
redis-cli INFO memory | grep used_memory_human

# Check instantaneous operations per second
redis-cli INFO stats | grep instantaneous_ops_per_sec

# Once loading is complete, this should increase dramatically
# showing Redis is now actively serving requests