MongoDB 副本集与分片架构：从选举到槽迁移的高可用之路

// rs.conf() 典型的 PSS 配置输出
{
  _id: "rs0",
  members: [
    { _id: 0, host: "mongo1:27017", priority: 2 },
    { _id: 1, host: "mongo2:27017", priority: 1 },
    { _id: 2, host: "mongo3:27017", priority: 1 }
  ]
}

// rs.conf() 典型的 PSA 配置
{
  _id: "rs0",
  members: [
    { _id: 0, host: "mongo1:27017" },
    { _id: 1, host: "mongo2:27017" },
    { _id: 2, host: "arbiter:27017", arbiterOnly: true }
  ]
}

// 查看副本集状态和选举信息
rs.status()

// 典型输出中的关键字段
{
  "set": "rs0",
  "myState": 1,              // 1 = PRIMARY, 2 = SECONDARY, 7 = ARBITER
  "term": 3,                 // 当前任期号，每次选举递增
  "heartbeatIntervalMillis": 2000,
  "members": [
    {
      "_id": 0,
      "name": "mongo1:27017",
      "stateStr": "PRIMARY",
      "optime": { "ts": Timestamp(1755052800, 1), "t": 3 },
      "lastHeartbeatMessage": "",
      "electionTime": Timestamp(1755052700, 1),
      "configVersion": 1
    },
    {
      "_id": 1,
      "name": "mongo2:27017",
      "stateStr": "SECONDARY",
      "syncSource": "mongo1:27017"
    }
  ]
}

// 设置节点优先级——高优先级的 Secondary 更有可能成为 Primary
rs.reconfig({
  _id: "rs0",
  members: [
    { _id: 0, host: "mongo1:27017", priority: 10 },
    { _id: 1, host: "mongo2:27017", priority: 5 },
    { _id: 2, host: "mongo3:27017", priority: 0 }    // priority 0 永远不会当选 Primary
  ]
})

// 查看 Oplog 状态
db.getReplicationInfo()

// 等价于直接查询 oplog.rs
db.oplog.rs.find().sort({ $natural: -1 }).limit(5)

{
  "ts": Timestamp(1755052800, 1),    // 操作时间戳
  "t": Long("3"),                    // 选举任期号
  "h": Long("-123456789012345678"),  // 操作哈希值
  "v": 2,                            // 版本号
  "op": "i",                         // 操作类型：i=insert, u=update, d=delete, c=command
  "ns": "mydb.users",                // 命名空间
  "ui": UUID("..."),                 // 集合的 UUID
  "o": { "_id": ObjectId("..."), "name": "Alice" },  // 操作文档
  "wall": ISODate("2026-08-13T10:00:00.000Z")         // 操作发生时间
}

# mongod.conf
replication:
  oplogSizeMB: 5120    # 5GB，可根据业务写入量调整

// 计算 Oplog 窗口
db.getReplicationInfo().logLengthStart.toString()
// 理想情况下，Oplog 窗口应至少是计划维护窗口的 2-3 倍

// 连接级别设置
MongoClient.connect(uri, {
  writeConcern: {
    w: "majority",       // 要求大多数节点确认
    j: true,             // 要求写入 journal（持久化到磁盘）
    wtimeout: 5000       // 等待超时时间（毫秒）
  }
})

// 单条语句级别设置
db.users.insertOne(
  { name: "Alice", age: 30 },
  { writeConcern: { w: 3, j: true, wtimeout: 5000 } }
)

// Node.js 驱动示例
const collection = db.collection('users');

// 优先从 Secondary 读取（可能读到过期数据）
const docs = await collection.find({})
  .readPref('secondary', [{ datacenter: "east" }])
  .toArray();

// 从最近的节点读取（基于网络延迟）
const doc = await collection.findOne({ _id: userId })
  .readPref('nearest');

// 只读取延迟不超过 90 秒的 Secondary
db.collection('users').find({})
  .readPref('secondary', [], { maxStalenessSeconds: 90 })

// 配置延迟节点（延迟 1 小时）
rs.reconfig({
  _id: "rs0",
  members: [
    { _id: 0, host: "mongo1:27017" },
    { _id: 1, host: "mongo2:27017" },
    { _id: 2, host: "mongo3:27017", slaveDelay: 3600, priority: 0 }
  ]
})

// 配置隐藏节点
{ _id: 3, host: "backup:27017", hidden: true, priority: 0 }

// Arbiter 日志通常很少，几乎不需要资源
// 但 Arbiter 仍应部署在独立的服务器上，避免与 Primary/Secondary 共享故障域

// 创建 hashed 分片
db.collection.createIndex({ user_id: "hashed" });

sh.shardCollection("mydb.users", { user_id: "hashed" });

// 查看 chunk 分布
sh.status()

// 创建 ranged 分片（默认方式）
db.orders.createIndex({ created_at: 1 });

sh.shardCollection("mydb.orders", { created_at: 1 });

// 手动预分片，控制初始 chunk 边界
sh.splitAt("mydb.orders", { created_at: ISODate("2026-01-01") });
sh.splitAt("mydb.orders", { created_at: ISODate("2026-04-01") });
sh.splitAt("mydb.orders", { created_at: ISODate("2026-07-01") });

// 复合片键：{ region: 1, user_id: 1 }
// 先按 region 分区，同一 region 内按 user_id 分散
sh.shardCollection("mydb.orders", { region: 1, user_id: 1 });

// 定义 Zone：将欧洲用户数据固定在欧洲分片
sh.addShardToZone("shard0000", "EU");
sh.addShardToZone("shard0001", "US");
sh.addShardToZone("shard0002", "ASIA");

// 为集合关联 Zone 范围
sh.updateZoneKeyRange(
  "mydb.users",
  { region: "EU", _id: MinKey },
  { region: "EU", _id: MaxKey },
  "EU"
);

sh.updateZoneKeyRange(
  "mydb.users",
  { region: "US", _id: MinKey },
  { region: "US", _id: MaxKey },
  "US"
);

sh.updateZoneKeyRange(
  "mydb.users",
  { region: "ASIA", _id: MinKey },
  { region: "ASIA", _id: MaxKey },
  "ASIA"
);

// 查看集合的 chunk 分布
sh.status()

// 或精确查看
db.chunks.find({ ns: "mydb.users" }).pretty()

{
  "_id": "mydb.users-user_id_MinKey",
  "ns": "mydb.users",
  "min": { "user_id": MinKey },
  "max": { "user_id": MaxKey },
  "shard": "shard0000",
  "lastmod": Timestamp(1, 0),
  "lastmodEpoch": ObjectId("...")
}

// 查看平衡器状态
sh.getBalancerState()       // 是否启用
sh.isBalancerRunning()      // 是否正在运行

// 临时关闭平衡器（执行维护操作时建议关闭）
sh.stopBalancer()
// ... 维护操作 ...
sh.startBalancer()

// 设置平衡器运行时间窗口（仅在业务低峰期运行）
use config
db.settings.updateOne(
  { _id: "balancer" },
  {
    $set: {
      activeWindow: {
        start: "02:00",
        stop: "06:00"
      }
    }
  },
  { upsert: true }
)

// 查找 jumbo chunk
sh.status(true)  // verbose 模式显示 jumbo 标记

// 查看具体 chunk 大小
db.chunks.find({ ns: "mydb.users", jumbo: true })

# Config Server 启动参数
mongod --configsvr --replSet configRS --dbpath /data/configdb --port 27019

use config

// 所有分片信息
db.shards.find().pretty()

// 所有数据库及其主分片
db.databases.find().pretty()

// 所有集合的分片状态
db.collections.find().pretty()

// 所有 chunk 信息
db.chunks.find().pretty()

// 平衡器锁
db.locks.find({ _id: "balancer" }).pretty()

// 查询包含完整的片键前缀——路由到单一分片
db.orders.find({ user_id: "u123", order_id: "o456" })

// 更新指定 _id——路由到单一分片
db.users.updateOne({ _id: ObjectId("...") }, { $set: { name: "Bob" } })

// 查询不包含片键——需要向所有分片广播
db.orders.find({ status: "pending" })

// 不带片键条件的聚合——全分片聚合后合并
db.orders.aggregate([
  { $group: { _id: "$status", count: { $sum: 1 } } }
])

# docker-compose 中的 mongos 服务示例
mongos:
  image: mongo:7.0
  command: mongos --configdb configRS/configsvr1:27019,configsvr2:27019,configsvr3:27019 --port 27017 --bind_ip_all

// 片键是 { region: 1, user_id: 1 }

// 优秀：包含片键前缀，定向路由
db.orders.find({ region: "US", user_id: "u123" })

// 尚可：只包含前缀第一个字段，定向到 region 分片组的少数 chunk
db.orders.find({ region: "US" })

// 糟糕：不包含片键前缀，广播到所有分片
db.orders.find({ user_id: "u123" })

// 对于单字段片键，使用 $in 仍可保持定向
db.users.find({ user_id: { $in: ["u1", "u2", "u3"] } })
// mongos 会将此查询拆分为多个定向查询并行执行

// 创建覆盖索引
db.orders.createIndex({ user_id: 1, status: 1, amount: 1 });

// 查询只从索引获取数据，不需要访问文档本身
db.orders.find(
  { user_id: "u123" },
  { _id: 0, status: 1, amount: 1 }
)

version: "3.8"

services:
  mongo1:
    image: mongo:7.0
    container_name: mongo1
    hostname: mongo1
    restart: unless-stopped
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: admin123
    volumes:
      - mongo1_data:/data/db
      - ./mongo.key:/data/mongo.key:ro
      - ./init-scripts:/docker-entrypoint-initdb.d:ro
    command: >
      mongod
      --replSet rs0
      --bind_ip_all
      --port 27017
      --auth
      --keyFile /data/mongo.key
      --oplogSize 512
    networks:
      - mongo-network
    healthcheck:
      test: echo 'db.runCommand("ping").ok' | mongosh localhost:27017/admin -u admin -p admin123 --quiet
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  mongo2:
    image: mongo:7.0
    container_name: mongo2
    hostname: mongo2
    restart: unless-stopped
    ports:
      - "27018:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: admin123
    volumes:
      - mongo2_data:/data/db
      - ./mongo.key:/data/mongo.key:ro
    command: >
      mongod
      --replSet rs0
      --bind_ip_all
      --port 27017
      --auth
      --keyFile /data/mongo.key
      --oplogSize 512
    networks:
      - mongo-network
    depends_on:
      - mongo1

  mongo3:
    image: mongo:7.0
    container_name: mongo3
    hostname: mongo3
    restart: unless-stopped
    ports:
      - "27019:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: admin123
    volumes:
      - mongo3_data:/data/db
      - ./mongo.key:/data/mongo.key:ro
    command: >
      mongod
      --replSet rs0
      --bind_ip_all
      --port 27017
      --auth
      --keyFile /data/mongo.key
      --oplogSize 512
    networks:
      - mongo-network
    depends_on:
      - mongo1

volumes:
  mongo1_data:
  mongo2_data:
  mongo3_data:

networks:
  mongo-network:
    driver: bridge

# 生成 756 字节的密钥文件（MongoDB 要求）
openssl rand -base64 756 > mongo.key
chmod 400 mongo.key

// init-scripts/init-replica.js
rs.initiate({
  _id: "rs0",
  members: [
    { _id: 0, host: "mongo1:27017", priority: 2 },
    { _id: 1, host: "mongo2:27017", priority: 1 },
    { _id: 2, host: "mongo3:27017", priority: 1 }
  ]
});

// 等待副本集初始化完成
while (true) {
  const status = rs.status();
  const primary = status.members.find(m => m.stateStr === "PRIMARY");
  if (primary) {
    print("Replica set initialized. Primary:", primary.name);
    break;
  }
  sleep(1000);
}

# 启动所有节点
docker-compose up -d

# 等待几秒钟让副本集初始化完成
sleep 10

# 连接到 Primary 节点验证状态
docker exec -it mongo1 mongosh -u admin -p admin123 --authenticationDatabase admin --eval "rs.status()"

# 连接到 Secondary 节点验证同步（需要设置 rs.secondaryOk()）
docker exec -it mongo2 mongosh -u admin -p admin123 --authenticationDatabase admin --eval "rs.secondaryOk(); db.version()"

# 停止 Primary 容器
docker stop mongo1

# 等待 10-15 秒后，查看剩余节点的状态——其中一个会成为新的 Primary
docker exec -it mongo2 mongosh -u admin -p admin123 --authenticationDatabase admin --eval "rs.status()"

# 重新启动原 Primary
docker start mongo1

# 它的状态会恢复为 SECONDARY，并从新的 Primary 同步数据
docker exec -it mongo1 mongosh -u admin -p admin123 --authenticationDatabase admin --eval "rs.status()"

// 以管理员连接到 Primary
mongosh "mongodb://admin:admin123@localhost:27017/admin?replicaSet=rs0"

// 创建应用数据库和用户
use shop
db.createUser({
  user: "appuser",
  pwd: "app123",
  roles: [
    { role: "readWrite", db: "shop" }
  ]
});

// 创建带 TTL 的集合
db.orders.createIndex({ created_at: 1 }, { expireAfterSeconds: 604800 });  // 7天后过期

// 插入测试数据
db.orders.insertMany([
  { order_id: "o1", user_id: "u1", amount: 100, status: "paid", created_at: new Date() },
  { order_id: "o2", user_id: "u2", amount: 200, status: "pending", created_at: new Date() },
  { order_id: "o3", user_id: "u1", amount: 150, status: "shipped", created_at: new Date() }
]);

// Node.js 应用连接示例（读写分离）
const { MongoClient, ReadPreference } = require('mongodb');

const uri = 'mongodb://appuser:app123@localhost:27017,localhost:27018,localhost:27019/shop?replicaSet=rs0';

const client = new MongoClient(uri, {
  readPreference: ReadPreference.SECONDARY_PREFERRED,
  retryWrites: true,
  w: 'majority',
  wtimeoutMS: 5000
});

async function run() {
  await client.connect();
  const db = client.db('shop');

  // 写入操作自动路由到 Primary
  const writeResult = await db.collection('orders').insertOne({
    order_id: 'o4',
    user_id: 'u3',
    amount: 300,
    status: 'paid',
    created_at: new Date()
  });
  console.log('Inserted:', writeResult.insertedId);

  // 读取操作优先从 Secondary 获取
  const orders = await db.collection('orders')
    .find({ user_id: 'u1' })
    .toArray();
  console.log('Orders for u1:', orders);

  await client.close();
}

run().catch(console.error);

// 副本集健康检查脚本
const primary = rs.isMaster().ismaster;
const members = rs.status().members;
const healthySecondaries = members.filter(m =>
  m.stateStr === "SECONDARY" && m.health === 1
).length;

if (!primary) {
  print("CRITICAL: NO PRIMARY IN REPLICA SET");
} else if (healthySecondaries < 1) {
  print("WARNING: ONLY PRIMARY AVAILABLE, NO HEALTHY SECONDARY");
} else {
  print("OK: Replica set is healthy");
}

// 检查 Oplog 窗口（应至少为 24 小时）
const oplogInfo = db.getReplicationInfo();
const windowHours = oplogInfo.timeDiffHours;
print("Oplog window:", windowHours, "hours");
if (windowHours < 24) {
  print("WARNING: Oplog window is less than 24 hours!");
}

// 检查复制延迟
rs.status().members.forEach(m => {
  if (m.stateStr === "SECONDARY" && m.optimeDate) {
    const lag = new Date() - m.optimeDate;
    print(`Secondary ${m.name} lag: ${lag}ms`);
  }
});

// 降级 Primary 触发选举
rs.stepDown(60)   // 60秒内不参与选举

// 添加新节点
rs.add({ host: "mongo4:27017", priority: 0, votes: 1 })

// 等待新节点同步完成后，再调整优先级
rs.reconfig({
  _id: "rs0",
  members: [
    { _id: 0, host: "mongo1:27017", priority: 2 },
    { _id: 1, host: "mongo2:27017", priority: 1 },
    { _id: 2, host: "mongo3:27017", priority: 1 },
    { _id: 3, host: "mongo4:27017", priority: 1 }
  ]
})

# 在 Secondary 上停止 mongod，清空数据目录，重启
docker exec mongo2 mongosh -u admin -p admin123 --authenticationDatabase admin --eval "db.shutdownServer()"
docker exec mongo2 rm -rf /data/db/*
docker restart mongo2

# 新启动的 Secondary 会自动触发 Initial Sync

# 1. 启动 Config Server 副本集（3节点）
# 2. 启动各 Shard 的副本集（每个 Shard 3节点）
# 3. 启动 mongos，指定 Config Server
mongos --configdb configRS/config1:27019,config2:27019,config3:27019 --port 27017

# 4. 在 mongos 上添加分片
mongosh mongos:27017/admin
sh.addShard("shard0rs/shard0a:27018,shard0b:27018,shard0c:27018")
sh.addShard("shard1rs/shard1a:27018,shard1b:27018,shard1c:27018")

# 5. 启用数据库分片并配置片键
sh.enableSharding("mydb")
sh.shardCollection("mydb.users", { user_id: "hashed" })

# 6. 验证分片状态
sh.status()