IOREDIS：单主节点多从节点场景下如何实现读请求负载均衡

随机选择节点是否足以实现负载分发？ #

在大多数常规场景下，随机选择节点已经能满足基本的负载分发需求：当请求量足够大时，概率上每个从节点接收的请求量会趋于均衡，而且这种策略实现简单，没有额外的计算或状态维护开销。

但如果遇到以下情况，随机策略可能会导致负载不均：

• 请求量波动极大，短时间内大量请求集中到少数节点；
• 各从节点的硬件配置、性能差异明显；
• 系统对负载均衡的均匀性要求极高（比如金融、实时计算场景）。

如何实现主节点下所有从节点的自定义负载均衡？ #

Ioredis允许通过自定义scaleReads函数替代默认的随机策略，你可以根据需求实现轮询、加权轮询、基于节点负载的动态选择等方案：

1. 轮询策略（Round Robin） #

实现最简单的均匀分发，按顺序循环选择从节点：

const Redis = require('ioredis');

// 维护每个主节点对应的从节点轮询索引
const slaveRoundRobinIndex = new Map();

const cluster = new Redis.Cluster([{ host: 'your-cluster-host', port: 6379 }], {
  scaleReads: (masters, slaves) => {
    // 无可用从节点时回退到主节点
    if (slaves.length === 0) {
      return masters[0];
    }
    // 以当前主节点ID作为索引键，避免不同主节点的轮询互相干扰
    const masterId = masters[0].id;
    let currentIndex = slaveRoundRobinIndex.get(masterId) || 0;
    const selectedSlave = slaves[currentIndex];
    // 更新索引，循环复用
    currentIndex = (currentIndex + 1) % slaves.length;
    slaveRoundRobinIndex.set(masterId, currentIndex);
    return selectedSlave;
  }
});

2. 加权轮询策略 #

针对性能差异明显的从节点，按权重分配请求比例：

const Redis = require('ioredis');

// 配置每个从节点的权重（示例：按节点ID映射）
const slaveWeights = new Map([
  ['slave-node-1', 3],
  ['slave-node-2', 2],
  ['slave-node-3', 1]
]);
const slaveWeightIndex = new Map();

const cluster = new Redis.Cluster([{ host: 'your-cluster-host', port: 6379 }], {
  scaleReads: (masters, slaves) => {
    if (slaves.length === 0) {
      return masters[0];
    }
    const masterId = masters[0].id;
    let currentWeight = slaveWeightIndex.get(masterId) || 0;
    // 计算总权重
    const totalWeight = slaves.reduce((sum, slave) => sum + (slaveWeights.get(slave.id) || 1), 0);
    // 按权重步进选择节点
    currentWeight = (currentWeight + 1) % totalWeight;
    let accumulatedWeight = 0;
    for (const slave of slaves) {
      const weight = slaveWeights.get(slave.id) || 1;
      accumulatedWeight += weight;
      if (currentWeight < accumulatedWeight) {
        slaveWeightIndex.set(masterId, currentWeight);
        return slave;
      }
    }
    // 兜底返回第一个从节点
    return slaves[0];
  }
});

3. 基于节点负载的动态选择 #

通过Redis的INFO命令获取节点实时负载（如内存占用、连接数），选择负载最低的节点。注意这种策略会有额外性能开销，建议缓存负载信息：

const Redis = require('ioredis');

// 缓存节点负载信息，5秒更新一次
const slaveLoadCache = new Map();
const CACHE_TTL = 5000;

// 获取节点负载值（数值越小负载越低）
async function getSlaveLoad(slave) {
  const cacheKey = slave.id;
  const cached = slaveLoadCache.get(cacheKey);
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.load;
  }
  // 创建临时连接获取节点INFO
  const tempClient = new Redis({ host: slave.host, port: slave.port });
  try {
    const info = await tempClient.info('stats');
    const connectedClients = parseInt(info.match(/connected_clients:(\d+)/)[1], 10);
    const usedMemory = parseInt(info.match(/used_memory:(\d+)/)[1], 10);
    // 综合计算负载值（可根据需求调整权重）
    const load = connectedClients * 0.6 + (usedMemory / 1024 / 1024) * 0.4;
    slaveLoadCache.set(cacheKey, { load, timestamp: Date.now() });
    return load;
  } finally {
    await tempClient.quit();
  }
}

const cluster = new Redis.Cluster([{ host: 'your-cluster-host', port: 6379 }], {
  scaleReads: async (masters, slaves) => {
    if (slaves.length === 0) {
      return masters[0];
    }
    // 并行获取所有从节点负载
    const loadPromises = slaves.map(async slave => ({ slave, load: await getSlaveLoad(slave) }));
    const slaveLoads = await Promise.all(loadPromises);
    // 选择负载最低的节点
    return slaveLoads.sort((a, b) => a.load - b.load)[0].slave;
  }
});

相关建议 #

• 优先使用默认随机策略：如果你的系统请求量稳定、各从节点性能接近，随机策略足够用，无需额外开发，避免引入不必要的复杂度。
• 轮询策略适合小流量场景：当请求量较小，随机策略可能导致请求分布不均时，轮询能保证绝对均匀的分发。
• 加权轮询适配异构节点：如果集群内从节点配置差异大，用加权轮询能让高性能节点承担更多请求，提升整体吞吐量。
• 动态负载策略谨慎使用：仅在对负载均衡要求极高的场景下使用，同时要做好负载信息的缓存，避免频繁请求节点INFO带来的性能损耗。
• 故障处理不可忽视：自定义策略时要确保节点不可用时能自动切换到其他节点，Ioredis本身具备节点健康检测能力，但在自定义函数中最好增加节点可用性判断逻辑。

内容的提问来源于stack exchange，提问作者Suriyaa Thanigaivel