MongoDB: 副本集Replication：高可用架构

# === 启动第一个节点（副本集模式）===
mongod --replSet rs0 --port 27017 --dbpath /data/db1 --bind_ip localhost

# === mongosh 初始化 ===
mongosh
> rs.initiate({
    _id: 'rs0',
    members: [
      { _id: 0, host: 'localhost:27017' },
      { _id: 1, host: 'localhost:27018' },
      { _id: 2, host: 'localhost:27019' }
    ]
  });

// === 添加新节点 ===
rs.add('localhost:27020');

// === 添加 Arbiter（不存数据）===
rs.addArb('localhost:27021');

// === 移除节点 ===
rs.remove('localhost:27020');

// === 查看副本集状态 ===
rs.status();

// TechCorp：让更强的服务器优先当选 Primary
rs.reconfig({
  _id: 'rs0',
  members: [
    { _id: 0, host: 'mongo1:27017', priority: 3 },   // 最强服务器，优先当选
    { _id: 1, host: 'mongo2:27017', priority: 2 },   // 次选
    { _id: 2, host: 'mongo3:27017', priority: 1 },   // 最低优先级
    { _id: 3, host: 'mongo4:27017', priority: 0 }    // 永不当选（冷备）
  ]
});

// priority: 0 的节点永不当选 Primary，适合做冷备或报表服务器
// 调整 priority 会触发重新选举（如果当前 Primary 不再是最优）

// 执行成功

// === 默认：所有读写都在 Primary ===
const user = await User.findById(userId);

// === 读从节点（减轻 Primary 压力）===
const products = await Product.find().read('secondary');

// === 读偏好选项 ===
await Product.find().read('primary');              // 仅主节点
await Product.find().read('primaryPreferred');     // 优先主节点
await Product.find().read('secondary');            // 仅从节点
await Product.find().read('secondaryPreferred');    // 优先从节点
await Product.find().read('nearest');              // 网络最近

# docker-compose.yml
version: '3.8'
services:
  mongo1:
    image: mongo:7.0
    command: mongod --replSet rs0 --port 27017
    ports:
      - "27017:27017"

  mongo2:
    image: mongo:7.0
    command: mongod --replSet rs0 --port 27017
    ports:
      - "27018:27017"

  mongo3:
    image: mongo:7.0
    command: mongod --replSet rs0 --port 27017
    ports:
      - "27019:27017"

// === 初始化副本集 ===
rs.initiate({
  _id: 'rs0',
  members: [
    { _id: 0, host: 'mongo1:27017' },
    { _id: 1, host: 'mongo2:27017' },
    { _id: 2, host: 'mongo3:27017' }
  ]
});

# === Primary 宕机模拟 ===
# 杀死 mongo1 容器
docker stop mongo1

# === 自动选举（30 秒内完成）===
# mongo2 或 mongo3 自动提升为 Primary

# === 应用自动重连（mongoose 配置）===
mongoose.connect('mongodb://mongo1,mongo2,mongo3/shopdb?replicaSet=rs0');

# === 1. docker-compose.yml ===
# version: '3.8'
# services:
#   mongo1:
#     image: mongo:7.0
#     command: mongod --replSet rs0 --bind_ip_all --port 27017
#     ports: ["27017:27017"]
#     networks: [mongo-net]
#
#   mongo2:
#     image: mongo:7.0
#     command: mongod --replSet rs0 --bind_ip_all --port 27017
#     ports: ["27018:27017"]
#     networks: [mongo-net]
#
#   mongo3:
#     image: mongo:7.0
#     command: mongod --replSet rs0 --bind_ip_all --port 27017
#     ports: ["27019:27017"]
#     networks: [mongo-net]
#
# networks:
#   mongo-net:
#     driver: bridge

# 启动 3 节点
docker-compose up -d

# === 2. 初始化副本集 ===
mongosh --port 27017 --eval '
  rs.initiate({
    _id: "rs0",
    members: [
      { _id: 0, host: "localhost:27017" },
      { _id: 1, host: "localhost:27018" },
      { _id: 2, host: "localhost:27019" }
    ]
  });
'

# === 3. 验证副本集状态 ===
mongosh --port 27017 --eval 'rs.status();'
# 输出：
# {
#   set: 'rs0',
#   members: [
#     { name: 'localhost:27017', stateStr: 'PRIMARY' },
#     { name: 'localhost:27018', stateStr: 'SECONDARY' },
#     { name: 'localhost:27019', stateStr: 'SECONDARY' }
#   ]
# }

# === 4. 测试数据写入（自动复制到 Secondary）===
mongosh --port 27017 --eval '
  db.products.insertOne({ sku: "PHONE-001", title: "Smartphone X", price: 599 });
'

# === 5. 验证数据复制 ===
mongosh --port 27018 --eval '
  db.setSecondaryOk();  // 允许读 Secondary
  db.products.findOne({ sku: "PHONE-001" });
'
# 返回相同文档，证明复制成功

# === 6. 故障转移测试 ===
# 停止 Primary
docker stop mongo1

# 在 mongo2 上查看
mongosh --port 27018 --eval 'rs.status();'
# 输出：mongo2 自动提升为 PRIMARY（30 秒内完成）

# === 7. 应用自动重连（mongoose）===

CONTAINER ID   IMAGE     STATUS    
abc123         latest    Up 2 hours

// mongoose 连接串自动发现所有节点
const mongoose = require('mongoose');
await mongoose.connect(
  'mongodb://localhost:27017,localhost:27018,localhost:27019/shopdb?replicaSet=rs0'
);

// 即使 Primary 挂了，应用自动连接新的 Primary
const products = await Product.find();  // 自动重试，不报错

// === 8. 读写分离配置 ===
// 写操作走 Primary
await Product.create({ sku: 'PHONE-002', title: 'Phone 2' });

// 读操作可以走 Secondary（减轻 Primary 压力）
const products = await Product.find().read('secondaryPreferred');

// === 9. 恢复故障节点 ===
docker start mongo1
# mongo1 自动以 Secondary 身份加入副本集，从新 Primary 同步数据

// === 1. mongoose 连接配置读写分离 ===
const mongoose = require('mongoose');

// 主连接：写操作 + 强一致性读
const primaryConn = await mongoose.createConnection(process.env.MONGODB_URI, {
  readPreference: 'primary',
  writeConcern: { w: 'majority', j: true, wtimeout: 5000 },
  maxPoolSize: 20
});

// 只读连接：读操作分散到 Secondary
const secondaryConn = await mongoose.createConnection(process.env.MONGODB_URI, {
  readPreference: 'secondaryPreferred',
  maxPoolSize: 30
});

// === 2. 按业务场景选择 readPreference ===
// 场景 A：金融交易——必须读最新数据
const Transaction = primaryConn.model('Transaction', txSchema);
app.get('/api/balance/:userId', async (req, res) => {
  const user = await Transaction.findById(req.params.userId)
    .read('primary');  // 强制从 Primary 读取
  res.json({ balance: user.balance });
});

// 场景 B：商品列表——允许秒级延迟，优先 Secondary
const Product = secondaryConn.model('Product', productSchema);
app.get('/api/products', async (req, res) => {
  const products = await Product.find()
    .read('secondaryPreferred')  // 优先 Secondary，不可用时回退 Primary
    .lean();
  res.json(products);
});

// 场景 C：报表统计——可容忍分钟级延迟，强制 Secondary
const Order = secondaryConn.model('Order', orderSchema);
app.get('/api/reports/daily', async (req, res) => {
  const report = await Order.aggregate([
    { $match: { createdAt: { $gte: yesterday } } },
    { $group: { _id: null, total: { $sum: '$total' }, count: { $sum: 1 } } }
  ]).read('secondary');  // 强制从 Secondary 读取
  res.json(report);
});

// === 3. writeConcern 按数据重要性分级 ===
// 关键数据（支付、余额）：w:majority + journal
app.post('/api/payments', async (req, res) => {
  const payment = await Payment.create(
    { ...req.body, userId: req.user._id },
    { writeConcern: { w: 'majority', j: true } }  // 确保多数节点写入 + 日志落盘
  );
  res.status(201).json(payment);
});

// 普通数据（评论、浏览记录）：w:1（只需 Primary 确认）
app.post('/api/comments', async (req, res) => {
  const comment = await Comment.create(
    req.body,
    { writeConcern: { w: 1 } }  // 只需 Primary 确认，性能优先
  );
  res.status(201).json(comment);
});

// 批量导入（历史数据迁移）：w:0（不等待确认，最快）
app.post('/api/import', async (req, res) => {
  await HistoricalData.insertMany(req.body.records, {
    writeConcern: { w: 0 },  // 发送后不等确认，批量场景适用
    ordered: false  // 并行写入，不按顺序
  });
  res.json({ imported: req.body.records.length });
});

// === 4. 监控复制延迟 ===
app.get('/api/health/replication', async (req, res) => {
  const status = await primaryConn.db.adminCommand({ replSetGetStatus: 1 });
  const primary = status.members.find(m => m.stateStr === 'PRIMARY');
  const secondaries = status.members.filter(m => m.stateStr === 'SECONDARY');

  const replicationLag = secondaries.map(s => ({
    host: s.name,
    lagSeconds: primary.optimeDate.getTime() - s.optimeDate.getTime(),
    health: s.health
  }));

  const maxLag = Math.max(...replicationLag.map(s => s.lagSeconds / 1000));
  const healthy = maxLag < 10;  // 延迟 > 10 秒视为不健康

  res.json({ healthy, maxLagSeconds: maxLag, secondaries: replicationLag });
});