27. MongoDB 多租户与隔离架构设计

// 为租户创建独立库
db.getSiblingDB("tenant_acme_orders").orders.insertOne({
  orderNo: "A-1001",
  amount: 1200,
  status: "shipped"
})

// 租户级备份/恢复（mongodump --db）
// mongodump --uri="$MONGO_URI" --db=tenant_acme_orders --out=/backup/acme

// 集合名 = 前缀 + 业务名
db.getCollection("tenant_abc_orders").insertOne({ orderNo: "B-2002" })

// 按租户遍历集合
db.getCollectionNames().filter(n => n.startsWith("tenant_abc_"))

db.orders.insertOne({
  tenantId: "t_1001",
  orderNo: "C-3001",
  amount: 99,
  createdAt: new Date()
})

// 强制约束：任何查询都必须带 tenantId（应用层约定 + 校验兜底）
db.orders.createIndex({ tenantId: 1, createdAt: -1 })

// 正确：tenantId 前置，查询可被索引裁剪
db.orders.createIndex({ tenantId: 1, status: 1, createdAt: -1 })

// 错误：tenantId 未在前缀，查询退化为 COLLSCAN
db.orders.createIndex({ status: 1, createdAt: -1 })

// 查询示例：某租户的待发货订单
db.orders.find({
  tenantId: "t_1001",
  status: "pending",
  createdAt: { $gte: ISODate("2026-09-01T00:00:00Z") }
}).sort({ createdAt: -1 }).limit(50)

// explain 确认命中索引
db.orders.find({ tenantId: "t_1001", status: "pending" }).explain("executionStats")

// 为租户定义视图：只暴露该租户的订单
db.createView("tenant_t_1001_orders", "orders", [
  { $match: { tenantId: "t_1001" } },
  { $project: { _id: 0, orderNo: 1, amount: 1, status: 1, createdAt: 1 } }
])

// 应用层使用视图
db.getCollection("tenant_t_1001_orders").find({ status: "shipped" })

db.runCommand({
  collMod: "orders",
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["tenantId", "orderNo"],
      properties: {
        tenantId: { bsonType: "string", pattern: "^t_[0-9]+$" }
      }
    }
  },
  validationLevel: "strict",
  validationAction: "error"
})

# mongod.conf
net:
  maxIncomingConnections: 2000   # 硬上限

# /etc/security/limits.conf
mongod  soft  nofile  65535
mongod  hard  nofile  65535

// 为副本集成员打标签（示例：把报表租户读流量分流到特定 Secondary）
conf = rs.conf()
conf.members[1].tags = { "tenant-tier": "reporting" }
conf.members[2].tags = { "tenant-tier": "default" }
rs.reconfig(conf)

// 应用连接串指定 readPreferenceTags
// mongodb://app:pass@rs0:27017/?replicaSet=rs0&readPreference=secondaryPreferred&readPreferenceTags=tenant-tier:reporting

// 简单的按租户令牌桶限流（示意）
const buckets = new Map()          // tenantId -> { tokens, last }
function acquireToken(tenantId, rate) {
  const now = Date.now()
  let b = buckets.get(tenantId)
  if (!b) { b = { tokens: rate, last: now }; buckets.set(tenantId, b) }
  b.tokens = Math.min(rate, b.tokens + (now - b.last) / 1000 * rate)
  b.last = now
  if (b.tokens < 1) throw new Error("rate_limited")
  b.tokens -= 1
}

// 以 tenantId 为分片键（ranged）：单租户数据聚到一个分片，查询隔离好
sh.shardCollection("shop.orders", { tenantId: 1, orderNo: 1 })

// 写入热点风险：超大租户独占一个分片
// 折中：复合分片键 或 hashed
sh.shardCollection("shop.orders", { tenantId: "hashed" })

// Zone Sharding：把超大租户隔离到专用分片
sh.addShardToZone("shard-large", "LARGE_TENANTS")
sh.updateZoneKeyRange(
  "shop.orders",
  { tenantId: "t_big", orderNo: MinKey },
  { tenantId: "t_big", orderNo: MaxKey },
  "LARGE_TENANTS"
)

// 统计某租户在共享集合中的数据量（按 tenantId 分组）
db.orders.aggregate([
  { $group: {
      _id: "$tenantId",
      docCount: { $sum: 1 },
      // 用 $bsonSize 近似估算字节（代价高，可抽样）
      totalBytes: { $sum: { $bsonSize: "$$CURRENT" } }
  }},
  { $sort: { totalBytes: -1 } }
])

// 计量集合：按天 + 租户累计写入量
db.usage.aggregate([
  { $match: { tenantId: "t_1001", day: "2026-09-27" } },
  { $group: { _id: null, total: { $sum: "$bytes" }, ops: { $sum: "$ops" } } }
])

// 删除某租户全部数据（大租户建议按 _id 分批，避免长事务）
const cursor = db.orders.find({ tenantId: "t_1001" }, { _id: 1 })
while (cursor.hasNext()) {
  const doc = cursor.next()
  db.orders.deleteOne({ _id: doc._id })
}

// 更可控的批量删除 + 验证
db.orders.deleteMany({ tenantId: "t_1001" })
db.orders.countDocuments({ tenantId: "t_1001" })   // 应为 0

db.getSiblingDB("tenant_acme_orders").dropDatabase()

// 场景：把 t_big 从共享集合迁到独立库
// 1) 在目标库建好结构与索引
db.getSiblingDB("tenant_t_big").orders.createIndex({ orderNo: 1 })

// 2) 分批复制数据（示例：按 _id 范围游标）
const src = db.getSiblingDB("shop").orders
const dst = db.getSiblingDB("tenant_t_big").orders
src.find({ tenantId: "t_big" }).forEach(d => {
  delete d.tenantId
  dst.insertOne(d)
})

// 3) 校验两边计数与指纹
print(src.countDocuments({ tenantId: "t_big" }), dst.countDocuments({}))

// 4) 应用切换路由，5) 确认后清理源端
src.deleteMany({ tenantId: "t_big" })