分片集群开发指南

// ==========================================
// 案例 A：评估 customer_id 字段的基数
// ==========================================
// 注意：大表执行此命令会触发全表扫描，请在测试环境进行验证，线上环境谨慎操作！
db.t_orders.aggregate([
    { $group: { _id: "$customer_id" } },
    { $count: "cardinality" }
], { allowDiskUse: true }) // 建议加上 allowDiskUse，防止内存超限报错

// 执行结果：{ "cardinality": 2500000 } 
// 结论评估：高基数字段，具备极佳的数据离散度，适合作为分片键。


// ==========================================
// 案例 B：评估 status 字段的基数
// ==========================================
// 注意：大表执行此命令会触发全表扫描，请在测试环境进行验证，线上环境谨慎操作！
db.t_orders.aggregate([
    { $group: { _id: "$status" } },
    { $count: "cardinality" }
])

// 执行结果：{ "cardinality": 6 } 
// 结论评估：极低基数字段，极易引发 Jumbo Chunk 与数据倾斜，【禁止】单独作为分片键！

时间线 ─────────────────────────────────────────────────────►

        Chunk 1        Chunk 2        Chunk 3        Chunk 4
      [2024-01-01]   [2024-02-01]   [2024-03-01]   [2024-04-01]
         ↑              ↑              ↑              ↑
        冷数据         冷数据          冷数据     ←── 所有写入集中在此（热点）

// 错误设计：对递增键使用范围分片，必然导致单一节点的写入热点 
sh.shardCollection("mydb.t_orders", { _id: 1 }) 
sh.shardCollection("mydb.t_orders", { createTime: 1 })  

// 规范动作：点查比较多的场景，建议使用 Hash 分片，强制打散数据 
sh.shardCollection("mydb.t_orders", { _id: "hashed" })  

// 规范动作：范围查询比较多的场景，建议采用 Hash 分片以追求均衡 
sh.shardCollection("mydb.t_orders", { orderNo: "hashed" })

 // 分片键：{ user_id: 1 }
 
 // 定向查询：条件包含分片键，直接路由到目标分片
 db.t_messages.find({ user_id: "U001", create_time: { $gt: ISODate("2024-01-01") } })
 
 // 广播查询：条件不含分片键，广播到所有分片
 db.t_messages.find({ create_time: { $gt: ISODate("2024-01-01") } })

// 模式一：前缀定向 + 后缀打散
// 适用：查询总是按某字段过滤，但该字段基数不够高
sh.shardCollection("db.t_orders", { customer_id: 1, order_id: "hashed" })

// 模式二：时间范围 + 随机打散
// 适用：需要时间范围查询，但写入要均匀
sh.shardCollection("db.t_logs", { month: 1,  order_id: "hashed" })
// month 字段为 "2024-01" 格式，每月一个范围，月内哈希打散。

                    ┌─────────────┐
                    │  应用程序   │
                    └──────┬──────┘
                           │
                    ┌──────▼──────┐
                    │   mongos    │  ◄── 必须通过 mongos 访问
                    └──────┬──────┘
           ┌───────────────┼───────────────┐
           │               │               │
    ┌──────▼──────┐ ┌──────▼──────┐ ┌──────▼──────┐
    │   Shard 1   │ │   Shard 2   │ │   Shard 3   │
    │  (副本集)   │ │  (副本集)   │ │  (副本集)   │
    └─────────────┘ └─────────────┘ └─────────────┘
          ↑               ↑               ↑
          └───────────────┴───────────────┘
                   ❌ 禁止直连

 # 正确：通过 mongos 连接
 mongodb://mongouser:password@10.0.0.1:27017,10.0.0.2:27017/admin
 
 # 错误：直连 shard 节点
 mongodb://mongouser:password@shard1-node1:27018/admin

 # 正确：连接串中包含所有 mongos 地址
 uri = "mongodb://user:pass@mongos1:27017,mongos2:27017,mongos3:27017/admin"
 
 # 错误：仅配置单个 mongos
 uri = "mongodb://user:pass@mongos1:27017/admin"

 // 设置 Balancer 运行时间窗口（凌晨 2:00 - 6:00）
 use config
 db.settings.updateOne(
     { _id: "balancer" },
     {
         $set: {
             activeWindow: {
                 start: "02:00",
                 stop: "06:00"
             }
         }
     },
     { upsert: true }
 )
 
 
 // 大促期间临时停止 Balancer
 sh.stopBalancer()
 
 // 确认 Balancer 已停止
 sh.isBalancerRunning()  // 应返回 false
 
 // 大促结束后启动 Balancer
 sh.startBalancer()

 // 查找所有 Jumbo Chunk
 use config
 db.chunks.find({ jumbo: true }).forEach(function(chunk) {
     print("Jumbo Chunk: " + chunk.ns + " [" +
           tojson(chunk.min) + " -> " + tojson(chunk.max) + "]")
 })
 
 // 统计各分片的 Chunk 数量（检查是否均衡）
 db.chunks.aggregate([
     { $match: { ns: "mydb.mycollection" } },
     { $group: { _id: "$shard", count: { $sum: 1 } } },
     { $sort: { count: -1 } }
 ])

 // 分片键：{ user_id: 1 }
 
 // 错误：唯一索引不包含分片键
 db.t_users.createIndex({ email: 1 }, { unique: true })
 // 报错：can't shard collection with unique index on { email: 1 }
 
 // 正确：唯一索引包含分片键
 db.t_users.createIndex({ user_id: 1, email: 1 }, { unique: true })
 
 // 正确：_id 索引天然唯一（每个分片独立）
 // 注意：分片集合的 _id 仅在分片内唯一，跨分片可能重复

 // 哈希分片预分片：指定预创建 Chunk 数量
 sh.shardCollection(
     "mydb.t_orders",
     { order_id: "hashed" },
     false,  // unique
     { numInitialChunks: 64 }  // 预创建 64 个 Chunk
 )
 // Chunk 会自动均匀分布到各分片
 
 // 范围分片预分片：手动划分 Chunk 边界
 sh.shardCollection("mydb.t_logs", { month: 1, _id: 1 })
 
 // 手动划分 Chunk 边界
 sh.splitAt("mydb.t_logs", { month: "2024-01", _id: MinKey })
 sh.splitAt("mydb.t_logs", { month: "2024-02", _id: MinKey })
 sh.splitAt("mydb.t_logs", { month: "2024-03", _id: MinKey })
 
 // 手动迁移 Chunk 到指定分片（可选，Balancer 也会自动均衡）
 sh.moveChunk("mydb.t_logs", { month: "2024-01", _id: MinKey }, "shard1")
 sh.moveChunk("mydb.t_logs", { month: "2024-02", _id: MinKey }, "shard2")

sh.stopBalancer()
// 验证状态是否已成功关闭
sh.getBalancerState() // 预期返回 false

sh.startBalancer()