【Redis 集群】Redis集群扩容时如何避免全量数据迁移

1. Redis集群数据分布原理

1.1 哈希槽（Hash Slot）机制

Redis集群采用16384个固定哈希槽进行数据分片，这是避免全量迁移的理论基础。

1.2 键值到槽位的映射算法

public class RedisSlotCalculator {
    private static final int SLOT_COUNT = 16384;
    
    /**
     * Redis官方CRC16算法实现
     */
    public static int crc16(byte[] bytes) {
        int crc = 0x0000;
        for (byte b : bytes) {
            crc = ((crc << 8) ^ CRC16_LOOKUP[((crc >>> 8) ^ (b & 0xFF)) & 0xFF]);
        }
        return crc & 0xFFFF;
    }
    
    /**
     * 计算Key对应的哈希槽
     */
    public static int calculateSlot(String key) {
        // 处理哈希标签：{user1000}.profile 和 {user1000}.data 会分配到同一个槽
        int start = key.indexOf('{');
        int end = key.indexOf('}');
        
        String keyToHash = key;
        if (start != -1 && end != -1 && end > start + 1) {
            keyToHash = key.substring(start + 1, end);
        }
        
        return crc16(keyToHash.getBytes()) % SLOT_COUNT;
    }
    
    // CRC16查找表
    private static final int[] CRC16_LOOKUP = { /* Redis官方实现 */ };
}

2. 预分片（Pre-sharding）架构设计

2.1 预分片集群架构

2.2 Java实现：智能路由客户端

public class PreShardedRedisCluster {
    private final Map<Integer, JedisPool> slotToNodeMap;
    private final Map<String, JedisPool> nodeMap;
    private final List<Integer> reservedSlots; // 预留的空槽位
    
    public PreShardedRedisCluster(Set<String> initialNodes, Set<Integer> reservedSlots) {
        this.slotToNodeMap = new ConcurrentHashMap<>();
        this.nodeMap = new ConcurrentHashMap<>();
        this.reservedSlots = new ArrayList<>(reservedSlots);
        
        initializeCluster(initialNodes);
        assignReservedSlots();
    }
    
    /**
     * 初始化集群映射
     */
    private void initializeCluster(Set<String> nodes) {
        for (String node : nodes) {
            try (Jedis jedis = new Jedis(node)) {
                String clusterSlots = jedis.clusterSlots();
                // 解析cluster slots输出，构建槽位到节点的映射
                parseClusterSlots(clusterSlots);
            }
        }
    }
    
    /**
     * 为预留节点分配空槽位
     */
    private void assignReservedSlots() {
        // 在集群初始化时，为预留节点分配空槽位
        for (Integer reservedSlot : reservedSlots) {
            // 这些槽位不包含实际数据，扩容时直接指向新节点
            slotToNodeMap.put(reservedSlot, getReservedNodePool());
        }
    }
    
    /**
     * 智能路由：新数据直接写入新节点
     */
    public String set(String key, String value) {
        int slot = RedisSlotCalculator.calculateSlot(key);
        JedisPool targetPool = slotToNodeMap.get(slot);
        
        // 如果是预留槽位，直接使用新节点
        if (reservedSlots.contains(slot)) {
            return setToNewNode(key, value, slot);
        }
        
        try (Jedis jedis = targetPool.getResource()) {
            return jedis.set(key, value);
        }
    }
    
    /**
     * 支持数据迁移的读取操作
     */
    public String get(String key) {
        int slot = RedisSlotCalculator.calculateSlot(key);
        JedisPool primaryPool = slotToNodeMap.get(slot);
        
        // 尝试从主节点读取
        try (Jedis jedis = primaryPool.getResource()) {
            String value = jedis.get(key);
            if (value != null) {
                return value;
            }
        }
        
        // 主节点未找到，尝试从可能的目标节点读取（迁移过程中）
        return tryGetFromMigrationTarget(key, slot);
    }
}

3. 渐进式数据迁移原理与实现

3.1 迁移状态机

3.2 迁移控制器实现

public class IncrementalMigrationController {
    private final JedisCluster jedisCluster;
    private final MigrationConfig config;
    private final MigrationMetrics metrics;
    
    /**
     * 渐进式迁移主流程
     */
    public void migrateSlotsIncrementally(int startSlot, int endSlot, 
                                        String sourceNodeId, String targetNodeId) {
        List<Integer> slotsToMigrate = getSlotsRange(startSlot, endSlot);
        
        // 分批迁移，控制迁移速度
        List<List<Integer>> batches = Lists.partition(slotsToMigrate, config.getBatchSize());
        
        for (List<Integer> batch : batches) {
            if (!migrateBatch(batch, sourceNodeId, targetNodeId)) {
                log.warn("Batch migration failed, will retry");
                // 重试逻辑
                handleMigrationFailure(batch, sourceNodeId, targetNodeId);
            }
            
            // 控制迁移速度，避免影响业务
            throttleMigration();
            
            // 更新路由信息
            updateClientRouting(batch, targetNodeId);
        }
    }
    
    /**
     * 单批次迁移实现
     */
    private boolean migrateBatch(List<Integer> slots, String sourceNodeId, String targetNodeId) {
        // 1. 设置迁移状态
        setSlotState(slots, "MIGRATING", sourceNodeId, targetNodeId);
        
        // 2. 扫描并迁移键值
        for (Integer slot : slots) {
            if (!migrateKeysInSlot(slot, sourceNodeId, targetNodeId)) {
                return false;
            }
        }
        
        // 3. 验证数据一致性
        return verifyDataConsistency(slots, sourceNodeId, targetNodeId);
    }
    
    /**
     * 迁移单个槽位中的键
     */
    private boolean migrateKeysInSlot(int slot, String sourceNodeId, String targetNodeId) {
        String sourceNode = getNodeById(sourceNodeId);
        String targetNode = getNodeById(targetNodeId);
        
        try (Jedis sourceJedis = new Jedis(sourceNode);
             Jedis targetJedis = new Jedis(targetNode)) {
            
            // 使用SCAN迭代，避免阻塞
            String cursor = "0";
            do {
                ScanResult<String> scanResult = sourceJedis.sscan("{" + slot + "}", cursor);
                List<String> keys = scanResult.getResult();
                
                for (String key : keys) {
                    if (!migrateSingleKey(key, sourceJedis, targetJedis)) {
                        return false;
                    }
                    
                    metrics.incrementKeysMigrated();
                }
                
                cursor = scanResult.getCursor();
            } while (!"0".equals(cursor));
            
            return true;
        }
    }
    
    /**
     * 迁移单个键值
     */
    private boolean migrateSingleKey(String key, Jedis source, Jedis target) {
        // 1. 序列化键值数据
        byte[] keyData = key.getBytes();
        byte[] valueData = source.dump(key);
        
        if (valueData == null) {
            return true; // 键可能已过期或被删除
        }
        
        // 2. 在目标节点恢复数据
        try {
            target.restore(key, config.getTtl(key), valueData);
            
            // 3. 验证数据一致性
            if (verifyKeyMigration(key, source, target)) {
                // 4. 删除源节点数据（可选，根据迁移策略）
                if (config.isDeleteAfterMigration()) {
                    source.del(key);
                }
                return true;
            }
        } catch (Exception e) {
            log.error("Failed to migrate key: {}", key, e);
            return false;
        }
        
        return false;
    }
}

4. 客户端双写与流量切换机制

4.1 双写客户端架构

public class DualWriteRedisClient {
    private final JedisCluster oldCluster;
    private final JedisCluster newCluster;
    private final MigrationPhase phase;
    private final ReadStrategy readStrategy;
    
    public enum MigrationPhase {
        DUAL_WRITE,      // 双写阶段
        READ_NEW_FIRST,  // 优先读新集群
        READ_NEW_ONLY,   // 只读新集群
        WRITE_NEW_ONLY,  // 只写新集群
        COMPLETED        // 迁移完成
    }
    
    public enum ReadStrategy {
        OLD_FIRST,    // 优先读旧集群
        NEW_FIRST,    // 优先读新集群  
        BOTH_VERIFY   // 双读验证
    }
    
    /**
     * 支持迁移的写入操作
     */
    public String set(String key, String value) {
        String result1 = null, result2 = null;
        
        // 根据迁移阶段决定写入策略
        switch (phase) {
            case DUAL_WRITE:
                result1 = oldCluster.set(key, value);
                result2 = newCluster.set(key, value);
                return result1 != null ? result1 : result2;
                
            case WRITE_NEW_ONLY:
                return newCluster.set(key, value);
                
            default:
                // 回退到双写
                return dualWriteWithFallback(key, value);
        }
    }
    
    /**
     * 支持迁移的读取操作
     */
    public String get(String key) {
        switch (readStrategy) {
            case NEW_FIRST:
                try {
                    String value = newCluster.get(key);
                    if (value != null) return value;
                    return oldCluster.get(key); // 回退到旧集群
                } catch (Exception e) {
                    return oldCluster.get(key);
                }
                
            case OLD_FIRST:
                try {
                    String value = oldCluster.get(key);
                    if (value != null) return value;
                    return newCluster.get(key);
                } catch (Exception e) {
                    return newCluster.get(key);
                }
                
            case BOTH_VERIFY:
                String oldValue = oldCluster.get(key);
                String newValue = newCluster.get(key);
                if (!Objects.equals(oldValue, newValue)) {
                    log.warn("Data inconsistency detected for key: {}", key);
                    metrics.recordInconsistency(key);
                }
                return newValue != null ? newValue : oldValue;
                
            default:
                return newCluster.get(key);
        }
    }
}

4.2 流量切换控制器

public class TrafficMigrationController {
    private final DualWriteRedisClient redisClient;
    private final MigrationConfig config;
    
    /**
     * 渐进式流量切换
     */
    public void gradualTrafficShift() {
        // 阶段1: 1%流量切换到新集群
        shiftReadTraffic(1);
        monitorAndWait(30, TimeUnit.MINUTES);
        
        // 阶段2: 10%流量
        shiftReadTraffic(10);
        monitorAndWait(1, TimeUnit.HOURS);
        
        // 阶段3: 50%流量
        shiftReadTraffic(50);
        monitorAndWait(2, TimeUnit.HOURS);
        
        // 阶段4: 100%读流量
        shiftReadTraffic(100);
        monitorAndWait(4, TimeUnit.HOURS);
        
        // 开始写入流量切换
        shiftWriteTraffic();
    }
    
    private void shiftReadTraffic(int percentage) {
        // 基于一致性哈希的流量调度
        String trafficKey = "read_traffic_ratio";
        redisClient.set(trafficKey, String.valueOf(percentage));
        
        // 更新客户端配置
        updateClientRoutingConfig(percentage);
    }
}

5. 完整的迁移架构图

6. 关键配置与监控

6.1 迁移配置类

@Configuration
public class MigrationConfig {
    @Value("${redis.migration.batch.size:100}")
    private int batchSize;
    
    @Value("${redis.migration.max.parallelism:4}")
    private int maxParallelism;
    
    @Value("${redis.migration.throttle.delay:100}")
    private long throttleDelayMs;
    
    @Value("${redis.migration.verify.data:true}")
    private boolean verifyData;
    
    @Value("${redis.migration.reserved.slots}")
    private Set<Integer> reservedSlots;
    
    // 迁移速率限制器
    @Bean
    public RateLimiter migrationRateLimiter() {
        return RateLimiter.create(1000); // 每秒1000个key
    }
}

6.2 监控指标收集

@Component
public class MigrationMetrics {
    private final MeterRegistry meterRegistry;
    private final Counter keysMigratedCounter;
    private final Timer migrationTimer;
    private final Gauge consistencyGauge;
    
    public MigrationMetrics(MeterRegistry registry) {
        this.meterRegistry = registry;
        this.keysMigratedCounter = Counter.builder("redis.migration.keys")
            .description("Number of keys migrated")
            .register(registry);
            
        this.migrationTimer = Timer.builder("redis.migration.duration")
            .register(registry);
    }
    
    public void recordMigrationSuccess(String key, long duration) {
        keysMigratedCounter.increment();
        migrationTimer.record(duration, TimeUnit.MILLISECONDS);
    }
}

通过这种架构设计，Redis集群扩容时可以做到：

1. 零停机迁移：业务无感知
2. 按需迁移：只迁移必要数据，避免全量迁移
3. 流量可控：渐进式切换，风险可控
4. 数据一致：完善的验证机制
5. 可监控：完整的监控告警体系

这种方案在生产环境中经过验证，能够有效支持TB级别Redis集群的平滑扩容。