How to fix ASK Temporary redirect during slot migration in Redis

-MOVED 8379 127.0.0.1:7002

-ASK 8379 127.0.0.1:7002

# When you get -ASK 8379 127.0.0.1:7002, connect to that node:
redis-cli -h 127.0.0.1 -p 7002

# In the redis-cli:
127.0.0.1:7002> ASKING
OK
127.0.0.1:7002> GET mykey
"value"

import redis

# Basic manual handling
def handle_ask_redirect(client, slot, host, port, command, *args):
    try:
        # Retry with ASKING
        temp_client = redis.StrictRedis(host=host, port=port)
        temp_client.execute_command("ASKING")
        result = temp_client.execute_command(command, *args)
        temp_client.close()
        return result
    except Exception as e:
        print(f"Error after ASK redirect: {e}")
        raise

# Most clients handle this automatically
client = redis.RedisCluster(startup_nodes=[...], skip_full_coverage_check=True)
result = client.get("mykey")  # Handles ASK redirects internally

import { createCluster } from "redis";

const cluster = createCluster({
  rootNodes: [
    { host: "127.0.0.1", port: 7000 },
    { host: "127.0.0.1", port: 7001 },
  ],
});

// The client automatically handles -ASK redirects
cluster.on("error", (err) => console.log("Cluster error:", err));

await cluster.connect();
const value = await cluster.get("mykey"); // Handles ASK internally
await cluster.disconnect();

using StackExchange.Redis;

var options = ConfigurationOptions.Parse("localhost:7000,localhost:7001");
options.TieBreaker = "";
IConnectionMultiplexer redis = await ConnectionMultiplexer.ConnectAsync(options);

// The client automatically handles -ASK and -MOVED redirects
var db = redis.GetDatabase();
var value = await db.StringGetAsync("mykey");

redis.Dispose();

# Python: Ensure using redis-py with cluster support
from rediscluster import RedisCluster

startup_nodes = [{"host": "127.0.0.1", "port": 7000}]
rc = RedisCluster(startup_nodes=startup_nodes, decode_responses=True)
value = rc.get("mykey")  # Automatically handles ASK

// Node.js: Use cluster-aware client
const Redis = require("ioredis");

const cluster = new Redis.Cluster([
  { host: "127.0.0.1", port: 7000 },
  { host: "127.0.0.1", port: 7001 },
]);

cluster.on("error", (err) => {
  console.error("Redis Cluster error:", err);
});

const value = await cluster.get("mykey"); // Handles ASK internally

# Python
pip show redis-py

# Node.js
npm list redis

# Java (Maven)
mvn dependency:tree | grep jedis

# Connect to any cluster node
redis-cli -h 127.0.0.1 -p 7000

# View cluster info and migration status
127.0.0.1:7000> CLUSTER INFO
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:7
cluster_my_epoch:2
cluster_stats_messages_sent:12345
cluster_stats_messages_received:12340

# View detailed slot assignment
127.0.0.1:7000> CLUSTER SLOTS
1) 1) (integer) 5461
   2) (integer) 10922
   3) 1) "127.0.0.1"
      2) (integer) 7001
   4) 1) "127.0.0.1"
      2) (integer) 7004
2) 1) (integer) 10923
   2) (integer) 16383
   3) 1) "127.0.0.1"
      2) (integer) 7002
   4) 1) "127.0.0.1"
      2) (integer) 7005
3) 1) (integer) 0
   2) (integer) 5460
   3) 1) "127.0.0.1"
      2) (integer) 7000
   4) 1) "127.0.0.1"
      2) (integer) 7003

# Check if any slots are migrating
127.0.0.1:7000> CLUSTER NODES
ccb5b74f2e5a7a9f0a0b1c2d3e4f5a6b 127.0.0.1:7000@17000 myself,master - 0 1640000000000 1 connected 0-5460
7a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d 127.0.0.1:7001@17001 master - 0 1640000000000 2 connected 5461-10922
2c3d4e5f6a7b8c9d0e1f2a3b4c5d6a7b 127.0.0.1:7002@17002 master - 0 1640000000000 3 connected 10923-16383 [5461-<-ccb5b74f2e5a7a9f0a0b1c2d3e4f5a6b]

# View logs to see when migration completes
redis-cli -h 127.0.0.1 -p 7000 --csv INFO replication

# Monitor real-time cluster events
redis-cli -h 127.0.0.1 -p 7000 MONITOR

# Multi-key command with keys on different slots
127.0.0.1:7000> MGET key1 key2 key3
# If some keys are on a migrating slot: -TRYAGAIN

# Redis returns -TRYAGAIN instead of -ASK for multi-key commands
# Client should retry the entire command after a brief delay

import time
from rediscluster import RedisCluster

startup_nodes = [{"host": "127.0.0.1", "port": 7000}]
rc = RedisCluster(startup_nodes=startup_nodes)

def mget_with_retry(rc, keys, max_retries=5):
    for attempt in range(max_retries):
        try:
            return rc.mget(keys)
        except redis.exceptions.TryAgainError:
            wait_time = min(2 ** attempt, 10)  # Exponential backoff
            print(f"Slot migration in progress, retrying in {wait_time}s...")
            time.sleep(wait_time)
        except Exception as e:
            raise

    raise RuntimeError("Max retries exceeded for multi-key command")

values = mget_with_retry(rc, ["key1", "key2", "key3"])

**Using pipelines to avoid multi-key errors:**

# Python: redis-py
from redis import Redis

# Set socket timeout for handling redirects
redis = Redis(
    host="127.0.0.1",
    port=7000,
    socket_timeout=5,      # 5 second socket timeout
    socket_connect_timeout=5,
    retry_on_timeout=True,
)

# For cluster
from rediscluster import RedisCluster

rc = RedisCluster(
    startup_nodes=[{"host": "127.0.0.1", "port": 7000}],
    socket_timeout=5,
    connection_timeout=5,
    skip_full_coverage_check=True,
)

// Node.js: ioredis
const Redis = require("ioredis");

const cluster = new Redis.Cluster([
  { host: "127.0.0.1", port: 7000 },
  { host: "127.0.0.1", port: 7001 },
  { host: "127.0.0.1", port: 7002 },
]);

cluster.on("error", (err) => {
  console.error("Cluster error:", err);
});

// Set timeouts
cluster.setMaxListeners(100);

// Configure command timeout
cluster.on("error", (err) => {
  if (err.code === "TIMEOUT") {
    console.log("Command timeout during migration");
  }
});

// C#/.NET: StackExchange.Redis
using StackExchange.Redis;

var options = ConfigurationOptions.Parse("localhost:7000,localhost:7001");
options.ConnectTimeout = 5000;     // 5 second timeout
options.SyncTimeout = 5000;        // 5 second sync timeout
options.AbortOnConnectFail = false; // Continue if initial connection fails

IConnectionMultiplexer redis = await ConnectionMultiplexer.ConnectAsync(options);

# Test communication between cluster nodes
# From one node, verify it can reach others

redis-cli -h 127.0.0.1 -p 7000

# Ping all cluster nodes
127.0.0.1:7000> PING
PONG

# Check node connectivity
127.0.0.1:7000> CLUSTER INFO
cluster_state:ok
cluster_nodes_in_cron_updates:6

# Detailed node information
127.0.0.1:7000> CLUSTER NODES
# Shows: [node-id] [ip:port] [flags] [master] [epoch] [slots]
# Connection status indicated by flags: connected, disconnected, fail

# If any nodes show as 'disconnected' or 'fail':
127.0.0.1:7000> CLUSTER MEET 127.0.0.1 7001  # Reconnect to specific node

# From the application server, verify connectivity
nc -zv 127.0.0.1 7000
nc -zv 127.0.0.1 7001
nc -zv 127.0.0.1 7002

# Check firewall rules
sudo ufw status
sudo iptables -L -n | grep 700

# Test with redis-cli from different servers
redis-cli -h redis-node-1 -p 7000 CLUSTER INFO
redis-cli -h redis-node-2 -p 7000 CLUSTER INFO

# Python: Comprehensive retry handler
import time
from rediscluster import RedisCluster
from redis.exceptions import (
    ClusterError,
    TryAgainError,
    ResponseError,
)

class RedisWithRetry:
    def __init__(self, startup_nodes, max_retries=5):
        self.redis = RedisCluster(
            startup_nodes=startup_nodes,
            skip_full_coverage_check=True,
        )
        self.max_retries = max_retries

    def execute_with_retry(self, func, *args, **kwargs):
        """Execute Redis command with retry on ASK/TRYAGAIN"""
        base_delay = 0.1  # Start with 100ms

        for attempt in range(self.max_retries):
            try:
                return func(*args, **kwargs)
            except TryAgainError:
                # Slot migration in progress
                wait_time = min(base_delay * (2 ** attempt), 10)
                print(f"Retry {attempt + 1}/{self.max_retries}: Slot migration, waiting {wait_time}s")
                time.sleep(wait_time)
            except ClusterError as e:
                # Connection or cluster error
                if "MOVED" in str(e) or "ASK" in str(e):
                    # Client should have handled this automatically
                    print(f"Unexpected redirect: {e}")
                raise
            except Exception as e:
                print(f"Error: {e}")
                raise

        raise RuntimeError(f"Max retries ({self.max_retries}) exceeded")

    def get(self, key):
        return self.execute_with_retry(self.redis.get, key)

    def set(self, key, value):
        return self.execute_with_retry(self.redis.set, key, value)

# Usage
rc = RedisWithRetry([{"host": "127.0.0.1", "port": 7000}])
value = rc.get("mykey")

// Node.js: Comprehensive retry handler
const Redis = require("ioredis");

class RedisClusterWithRetry {
  constructor(nodes, maxRetries = 5) {
    this.cluster = new Redis.Cluster(nodes);
    this.maxRetries = maxRetries;
  }

  async executeWithRetry(command, args, attempt = 0) {
    try {
      return await this.cluster[command](...args);
    } catch (error) {
      if (attempt >= this.maxRetries) {
        throw new Error(
          `Max retries (${this.maxRetries}) exceeded: ${error.message}`
        );
      }

      // Determine if we should retry
      const shouldRetry =
        error.code === "CLUSTERDOWN" ||
        error.code === "TRYAGAIN" ||
        error.message.includes("slot");

      if (shouldRetry) {
        const baseDelay = 100; // 100ms
        const wait = Math.min(baseDelay * Math.pow(2, attempt), 10000);
        console.log(
          `Retry ${attempt + 1}/${this.maxRetries}: waiting ${wait}ms`
        );
        await new Promise((resolve) => setTimeout(resolve, wait));
        return this.executeWithRetry(command, args, attempt + 1);
      }

      throw error;
    }
  }

  async get(key) {
    return this.executeWithRetry("get", [key]);
  }

  async set(key, value) {
    return this.executeWithRetry("set", [key, value]);
  }
}

// Usage
const rc = new RedisClusterWithRetry([
  { host: "127.0.0.1", port: 7000 },
]);
const value = await rc.get("mykey");