先说一次真实的事故。一个订单归档库,从副本集扩到分片集群,选择 _id 做分片键——理由很朴素:「所有查询都带 _id,唯一,天然均匀」。两个分片上线第一周就出问题:监控上最后一个 chunk 的写入量是第一个的 8 倍,晚上十点到凌晨两点 balancer 一直在搬数据,网络和磁盘 IO 都被迁移吃掉,应用侧的 P99 从 30ms 抬到 400ms。

根因不是配置问题。ObjectId 的前 4 个字节是时间戳,所以按 _id 做范围分片,等价于按时间分片:新写入永远落在「时间最大」的那个区间,也就是最后一个 chunk、最后那个分片。第二个分片只在数据搬过去之后才被动地接一点活。这叫「热点尾写」,是范围内分片配单调递增键的典型后果。

改法有两种:换成 hashed(_id),写入立刻摊到两个分片;或者改成复合分片键 { tenant_id: 1, _id: 1 },让前缀先把租户分开。两种改法代价都很大,后面会算。这篇讲三件事:数据在磁盘上怎么组织(WiredTiger)、查询凭什么快(索引)、数据凭什么摊开(分片)。它们不是三个独立话题,而是一条链上的三环。

同样声明一下:本机没有 mongosh,也没有可用的分片集群,下面的命令输出全部是按 MongoDB 6.0/7.0 行为写的预期结果,未在本机实测。命令本身可以直接拷去执行,字段名和结构是对的,数值会随你的数据变化。

把一条写入拆开:WiredTiger 做了什么

很多人对「MongoDB 快」的印象来自内存映射或者「它是个内存数据库」。这两个说法都已经过时了。从 3.0 起,默认存储引擎是 WiredTiger,它的写路径大致是这样:

第一步:改内存里的 B 树写入先落到内存中的 B 树页,同时把这次改动记进事务日志(journal)。锁的粒度是文档级:两个事务改同一个文档要排队,改不同文档可以并行。这比 MyISAM 的表锁细,也比「整库一把锁」的库细。
第二步:定期 checkpoint默认每 60 秒做一次 checkpoint,把内存里的脏页快照刷到磁盘。checkpoint 之后的页才算持久化,之前的改动靠 journal 保证崩溃可恢复——「写完就断电」不丢数据的前提是 journal 已落盘。
第三步:压缩集合默认用 snappy 压缩,索引默认用前缀压缩。压缩省磁盘,也省 IO,代价是 CPU。数据本身重复度高(字段名、枚举值)的时候,压缩比通常很可观;已经是随机二进制的内容,压缩几乎是白费 CPU。

这套机制解释了几件看起来奇怪的事:删掉的文档空间不会立刻还给操作系统,WiredTiger 在 checkpoint 时复用;db.stats() 里 storageSize 和 dataSize 的差距,来自压缩;而「文档级并发」也不等于没有锁竞争,热点文档被高频更新时照样要在文档这一层排队。

checkpoint 间隔一般不建议动;真正要关注的是 journal 所在磁盘的写延迟,它决定了「提交返回」有多可信。

索引是 B 树,所以它有 B 树的脾气

MongoDB 的索引默认是 B 树(严格说是 B+ 树的变体),不是哈希表,也不是倒排索引。这个事实决定了它能做什么、不能做什么。

能做的是:等值匹配、范围扫描、排序、前缀匹配。因为 B 树按 key 有序,{ status: 1 } 上建了索引之后,status = "paid" 是一次定位,status 在 ["paid","refunded"] 之间是一次范围扫描,sort({ status: 1 }) 可以直接顺着索引读,不必额外排序。

不能做的是:中间匹配和正则模糊匹配。{ title: /手机/ } 这种不带锚点的正则,索引只能当摆设,必须逐条扫文档。原因和关系库的 LIKE '%手机%' 一样:B 树按前缀排序,你给的是后缀条件,它没法跳到中间去。这个问题会在第 7 篇用倒排索引解决。

还有一类索引值得单独提:覆盖查询(covered query)。如果查询条件和要返回的字段全在索引里,MongoDB 可以只读索引、不碰文档。比如:

db.products.createIndex({ category: 1, price: 1 })

db.products.find(
  { category: "apparel", price: { $lte: 200 } },
  { _id: 0, category: 1, price: 1 }
)

# explain 里的关键字段(未在本机实测):
# "totalKeysExamined": 42,
# "totalDocsExamined": 0,     ← 没读文档,就是覆盖查询
# "nReturned": 42

totalDocsExamined 为 0 是好消息,但有前提:投影里不能有索引外的字段,也不能带 _id(除非索引包含它)。

复合索引的顺序:ESR 三个字母

难的是复合索引:几个字段拼在一起,谁在前谁在后。这里有一条被反复验证的经验,叫 ESR:等值(Equality)在前,排序(Sort)在中,范围(Range)在后。

为什么是这个顺序,用 B 树的物理结构就能想明白。索引按「第一字段、第二字段、第三字段」的字典序排列:第一字段是等值条件时,满足条件的记录在索引里是一段连续区间,后续字段在这段区间内仍然有序,范围扫描和排序都能顺着走;第一字段是范围条件时,区间内第二字段的取值是跳跃的,排序就用不上索引了。

顺序对:{ category: 1, status: 1, price: 1 }

查询是 { category: "apparel", status: "on_sale", price: { $gte: 100, $lte: 300 } },排序按 price。两个等值字段在前,范围字段在后,索引能一次定位到 category + status 的连续区间,再在这个区间内按 price 做范围扫描,排序也由索引顺序提供,不需要额外 SORT 阶段。

顺序错:{ category: 1, price: 1, status: 1 }

同样的查询,索引先按 category 定位,再按 price 范围扫,status 夹在范围字段之后,只能作为过滤条件在扫描过程中逐条判断。explain 里会看到 totalKeysExamined 明显大于 nReturned,因为扫过了大量 status 不对的索引项。数据量越大,差距越明显。

还有两条实用规则。第一,排序方向要和索引方向一致,或者整体取反。索引 { a: 1, b: -1 } 能服务 sort({ a: 1, b: -1 }) 和 sort({ a: -1, b: 1 }),但不能服务 sort({ a: 1, b: 1 })。第二,索引前缀可以用。{ a: 1, b: 1, c: 1 } 能服务只带 a 的查询、带 a + b 的查询,但不能服务只带 b 的查询。这是很多人建了一堆单字段索引的原因,也是索引数量失控的原因。

用 explain 判断索引到底有没有生效

索引建了不等于被用上。判断方法只有一个:explain("executionStats"),然后看三个数字。它们的关系是一道很直接的算术题:

字段含义健康值
nReturned最终返回多少条业务期望的数量
totalKeysExamined扫描了多少个索引项接近 nReturned,或略大
totalDocsExamined回表读了多少个文档接近 nReturned;为 0 说明是覆盖查询

执行下面这条:

db.products.find(
  { category: "apparel", price: { $lte: 200 } }
).sort({ created_at: -1 }).explain("executionStats")

# 预期输出(未在本机实测,只保留关键字段):
# {
#   queryPlanner: { winningPlan: { stage: 'SORT',
#     inputStage: { stage: 'COLLSCAN' } } },
#   executionStats: {
#     nReturned: 42,
#     totalKeysExamined: 0,
#     totalDocsExamined: 2000000,
#     executionTimeMillis: 3187
#   }
# }

这张输出是典型的坏结果:COLLSCAN 说明没走索引,扫了两百万个文档只为返回 42 条,放大四万七千倍。看到这种数字,先确认查询字段与索引字段是否完全一致(包括类型),再确认排序字段有没有进索引。

加了 { category: 1, created_at: -1 } 之后,理想情况是 IXSCAN 加 SORT_MERGE 或者干脆没有 SORT 阶段,totalKeysExamined 落到几十的量级。如果还是出现 SORT 阶段,说明排序字段的顺序或方向不对;如果 totalDocsExamined 仍然很大,说明索引只覆盖了筛选的一部分,回表还是扫了很多。

不要用不带参数的 explain() 下结论:默认只给「选中的计划」,不给实际扫描量,必须用 executionStats 才看得到真实开销。

分片集群里到底有几个角色

索引解决的是「在单个节点上怎么找得快」,分片解决的是「数据多到单节点放不下、写不住」。这两件事的层级不一样,所以调优顺序也不能反:先确认索引没问题,再考虑分片。一个没索引的集合分到八个分片,查询会变成八次全表扫描再归并,比单机慢。

分片集群有四个角色,缺一不可:

应用连 mongos
mongos 查 config server 定位路由
按分片键转发到目标 shard
若跨分片则归并结果
mongos:路由层客户端连的入口,本身不存数据。它缓存 chunk 到分片的映射表,收到查询后算出要打哪些分片,再做结果归并。代价是多了一跳网络和一个可能过期的路由缓存。
config server:元数据存着 chunk 的分布、分片键定义、集群平衡状态。必须是副本集(3 个节点起),它挂了整个集群没法路由。数据量很小,但地位关键。
shard:真正的存储每个 shard 本身是一个副本集,负责一段数据。分片不是「一台机器」,是「一组机器」,所以至少要有 3 个节点才能保证一个 shard 的高可用。
chunk 与 balancer:分布与搬移数据按分片键切成一段一段的 chunk,默认大小 128MB(可调)。某个 shard 上的 chunk 数明显多于其他,balancer 就在后台搬 chunk。搬的过程是复制加删除,会消耗两端和 config server 的资源。

这里有一个容易被忽略的成本:chunk 迁移不是免费的。一次迁移要读源分片的数据、写到目标分片、更新 config server 的元数据、再删源数据。128MB 的 chunk 跨机房可能要走几分钟,期间还有写入冲突要处理。所以「先加机器再说」通常带来一段抖动,而不是线性提升。

分片键怎么选:高基数、写分散、查询常用

分片键(shard key)必须是每个文档都有的字段,且一旦集合分片就不能随便改。选它要同时满足三个条件,缺一条都会出问题:

高基数。取值范围要大,最好接近唯一。用只有四五个取值的 status 做分片键,最多分出四五个 chunk,数据全挤在几块里,加再多分片也没用。

写分散。新插入的文档要落在不同的 chunk 上。单调递增的键(ObjectId、自增 ID、创建时间)在范围分片下会全部落到最后一个 chunk,就是开头那次事故。

查询常用。分片键是路由的依据,查询里不带它,mongos 只能把请求广播到所有分片再归并,这叫 scatter-gather。分片越多,广播越慢。

两种分片方式各有各的账:

方式路由方式适合的键代价
范围(ranged)按键的区间定位,通常只打一个分片时间、地区、租户这类有业务含义、常做范围查的键单调递增键会有尾写热点;数据倾斜要靠 balancer 慢慢搬
哈希(hashed)按键的哈希值定位,写入均匀高基数字段,如 user_id、_id范围查询会广播到所有分片;同一个前缀的连续数据被打散

选择逻辑很朴素:最常见的查询是范围扫描,就用范围分片,但要配复合键防止写入集中;最常见的查询是按 id 精确取一条、写入量大且要求均匀,就用哈希分片,接受范围查询变慢。两者都想要,用 { tenant_id: "hashed", created_at: 1 } 这类复合键,前缀摊开写入,后缀支持时间范围。

场景走查:从副本集扩到分片,选错键要付多少钱

还是开头那个订单归档库,把数字补齐。起点:单副本集,三节点,订单 1.2 亿条,日增 400 万条,单文档平均 4KB(含明细内嵌),总数据约 480GB。写入峰值 2500 TPS,读请求 70% 带 order_id 精确查,20% 按 user_id 查最近三个月,10% 是运营按时间范围导出。

第一步,判断要不要分片。480GB 数据加索引约 700GB,三节点各扛一份,磁盘还没到瓶颈;真正的瓶颈是写入:单主库 2500 TPS 时 WiredTiger 的 checkpoint 已经出现 200ms 以上的抖动。所以目标是摊开写入,而不是摊开存储。这一步结论直接决定了分片键的优先级:写分散 > 查询方便。

第二步,选键。三个候选:_id(ObjectId,单调递增)、user_id(整数,高基数)、{ user_id: "hashed" }。选 _id 就是开头那次事故:两个分片下写入比 8:1,balancer 夜间不停。选 user_id 范围分片,效果好一些,但用户注册 id 也是递增的,新用户全部落在尾部,热点只是从「全局尾部」变成「尾部用户段」,白天写入仍然集中。

最终选 { user_id: "hashed" }。上线后两个分片的写入比是 1.06:1,夜间迁移次数从每小时 4 次降到 0。代价立刻出现:那 10% 按时间范围导出的查询,原本能定位到一个分片,现在要广播到两个分片再归并,单次导出从 4 分钟变成 7 分钟;等分片加到四个,会变成 14 分钟。运营同学的感受是「系统变慢了」,而监控上写入明明变好了。

第三步,补救。给导出场景单独建一条链路:不查分片集合,改为从备份快照或者一个按天落到对象存储的明细文件里算。这是分片系统里很常见的一步——不是所有查询都值得为它优化分片键,有些查询应该被挪走。

第四步,如果键选错了。MongoDB 5.0 起提供 reshardCollection,可以在线改分片键,不用 dump 再 reload。命令大致是:

db.adminCommand({
  reshardCollection: "shop.orders",
  key: { user_id: "hashed" },
  numInitialChunks: 16
})

# 预期输出结构(未在本机实测):
# { ok: 1, collectionsharded: "shop.orders",
#   newShardKey: { user_id: "hashed" } }

但它不免费。reshard 的实质是按新键把所有数据重写一遍:1.2 亿条、480GB,集群要有接近两倍的临时空间,期间源集合仍接受写入,增量要持续追平,窗口按经验是十几个小时到一天。更麻烦的是应用层要改代码:查询、写入、索引设计都要按新键重新审视。所以「先随便选一个,不行再 reshard」不是可执行的策略。

分片键还有一个隐形限制:它必须能支持唯一索引。如果集合上要建唯一索引,唯一索引的字段必须包含分片键作为前缀,否则 mongos 无法在分片间保证唯一性,建索引会直接失败。

分片之后最常见的七种异常

分片集群的故障很少是报错,更多是「某个指标不对劲,但功能正常」。下面这张表按出现频率排序。

现象真实原因第一步查什么
所有写入都压在一个分片上,其余分片 CPU 个位数分片键单调递增(ObjectId、自增 ID、创建时间)+ 范围分片,新数据永远落在最后一个 chunkdb.collection.getShardDistribution() 看各分片的文档数和 chunk 数,再确认分片键类型
夜间应用延迟周期性抖动,白天正常balancer 在低峰期搬 chunk,迁移读写把两端的 IO 和网络占满看 sh.status() 里是否有正在进行的迁移,对比迁移时段与延迟曲线是否吻合
加了分片之后查询反而更慢查询不带分片键,mongos 广播到所有分片,每个分片各扫一遍再归并explain("executionStats") 看 winningPlan 是否出现 SHARD_MERGE 且子计划数等于分片数
某个 chunk 永远搬不走,迁移反复失败jumbo chunk:单个 chunk 内文档太多或单文档太大,超过设定的 chunk 上限,无法分裂sh.status() 里标 jumbo 的 chunk,先确认是不是分片键基数太低导致无法再切
内存占用随索引数量上升,最后频繁从磁盘读页WiredTiger 的缓存要同时装热数据页和索引页;索引越多,常驻内存的 B 树内部节点越多看 db.serverStatus().wiredTiger.cache 中 bytes currently in the cache 与淘汰次数
分片后同一个聚合从 2 秒变成 20 秒聚合的第一阶段在每个分片各跑一遍,再在 mongos 上归并;如果 $group 的 key 不是分片键,归并的数据量等于全量看 explain 里 mergeType,确认 $match 是否下推到了各分片
建唯一索引直接失败唯一索引的字段没有以分片键为前缀,mongos 无法跨分片保证唯一核对索引定义与分片键定义,调整索引字段顺序或改成非唯一索引加应用层校验

边界与代价:分片换来了什么,又拿走了什么

分片键基本不能改。4.4 之前只能重建集合,4.4 起只能在末尾追加字段,5.0 才有 reshardCollection。但如上一节算的,代价是双倍空间、十几个小时的窗口和一轮应用改造,选键前要把未来三年的查询模式想清楚。

mongos 是多出来的一层。所有请求都要经过它,它要缓存路由表、部署多个避免单点、处理路由缓存过期后的重试。这一层不存数据,却决定了整个集群的可用性——很多团队的分片集群第一次故障,是 mongos 的连接数打满。

备份和恢复变复杂。单副本集可以用 mongodump 或文件系统快照,分片集群则要保证各分片时间点一致:先停 balancer,再对每个 shard 做快照,恢复时按同样拓扑重建。这套流程如果等到出事那天才第一次跑,基本一定会出问题。

单分片故障影响面反而变小,但不会消失。一个 shard 挂了,只有落在这个 shard 上的数据不可用,其他分片照常服务——这是分片的好处。但 config server 挂了,整个集群都没法路由;某个 shard 的副本集选主慢了,落在它上面的请求就超时。高可用不是「分片」自带的,是每个组件各自做副本集换来的。

运维门槛实实在在上了一个台阶。分片集群要盯的指标比副本集多一倍:chunk 分布、迁移速率、mongos 连接数、config server 的元数据写入、各 shard 的 oplog 窗口。排查路径也长:应用、mongos、config、shard、WiredTiger,每层有自己的日志格式。这些只能靠一次次的故障积累。

不要在数据量还小的时候为了「以后好扩展」提前分片。一个 20GB 的库分到三个 shard,每个 shard 的 chunk 数很少,balancer 一动就是大比例的数据搬迁,抖动比收益明显得多。分片应该在单副本集真的顶不住写入或存储时再上。

小结

这篇的三块内容是连着的:WiredTiger 决定了一条写入的成本和持久化时机,B 树索引决定了查询能不能只碰一小段数据,分片决定了这些数据和写入能不能摊到多台机器上。调优的顺序也必须是这个顺序:先看 explain 里的三个数字,再谈索引设计,最后才考虑分片。

如果只能记住一句话:分片键是一次性决定,选它的时候要按「写分散优先、查询常用其次」排序,而不是按「哪个字段看起来最唯一」。开头那次事故的根因不是运维疏忽,是选键时只想到了唯一性,没想到 ObjectId 里藏着时间戳。

当天可以自己验证的练习:

  1. 用 Docker 起一个单节点副本集(--replSet rs0 加 rs.initiate()),造十万条文档,对比有索引和无索引时 explain("executionStats") 的 totalDocsExamined。
  2. 建一个 { a: 1, b: 1, c: 1 } 的复合索引,分别用 a、a+b、b 查询,记录哪种能走 IXSCAN,验证「前缀可用」。
  3. 把 { category: 1, price: 1 } 和 { category: 1, created_at: -1 } 两种索引各建一次,用同一条带排序的查询比较 totalKeysExamined,看 ESR 顺序的实际影响。
  4. 在单机上用 mongos 加两个单节点 shard 起一个最小分片集群,插入十万条带时间戳的数据,观察 getShardDistribution() 的倾斜,再把分片键换成 hashed 重建,对比分布。
  5. 用 db.serverStatus().wiredTiger.cache 记录一次大批量写入前后的缓存占用和淘汰次数,理解「内存里装的是页,不是文档」。

下一篇讲倒排索引与全文检索。到这里,精确查询和范围查询都已经有了答案:索引让它们能在毫秒级返回。但业务接下来一定会提一个需求——「按关键词搜」:LIKE '%手机%' 在 B 树上必然全表扫,两千万行要八秒,而且搜「手机」会把「手机壳」也带出来。这个问题换分片解决不了,得换一种索引结构。