跳至主内容
博客

不停机迁移 MongoDB 到 PostgreSQL

Flashduty 把告警和故障存储从 MongoDB 迁到了 PostgreSQL,全程没有停机。本文是一份生产迁移记录:为什么分片集群解决不了我们的问题,用了 PostgreSQL 的哪些分区能力,如何按数据类别、账号和比例灰度,冷数据怎样搬到对象存储,以及团队和 AI 代理在迁移中各自做了什么。

Flashduty 工程团队

不停机迁移 MongoDB 到 PostgreSQL

Flashduty 的告警、告警事件、故障和故障时间线,从产品上线起就存在 MongoDB 上。今年我们把这部分存储迁到了 PostgreSQL,22 类数据逐类切换,全程没有停机窗口。

写这篇文章,是因为我们准备迁移时,没有找到一份足够详实的同类生产操作记录。下面写的是我们的场景、我们的约束和我们的做法,仅供参考。

先说结论:这次迁移要解决的是数据的物理组织方式,换哪个数据库引擎是次要的。我们的数据热点集中在少数租户上,冷热按时间分明,而 MongoDB 只能让所有数据共用同一套索引、同一块磁盘、同一份缓存。PostgreSQL 的分区能力让数据的存放方式和访问方式对齐。

全文按顺序回答四个问题:为什么要迁移,新的存储怎样设计,怎样在不停机的前提下迁过去,结果如何、踩过哪些坑。最后是几点选型体会。

为什么要迁移

迁移的原因是:随着业务发展、客户越来越多,最初的存储设计越来越不能胜任。

这不是 MongoDB 不好用。它支撑了我们 4 年:告警标签是任意键值对,用文档模型存储不需要预先设计表结构(schema),产品早期迭代很快;核心集群的节点连续运行一年多没有重启过。

WiredTiger 的块压缩效果也很好,压缩后磁盘占用约为逻辑数据的四分之一。迁移后实测,PostgreSQL 未压缩的堆表与 MongoDB 的逻辑数据大小相当,同样的数据在 PostgreSQL 上反而更占磁盘。

问题集中在下面三点,第四小节说明为什么 MongoDB 的分片集群解决不了它们。

热点明显,数据不均

租户之间的数据量相差上千倍。有的客户每天投递的告警超过 100 万条,大多数客户每天不到 1000 条。

最早我们用的是简单的分表方案:严格按租户 ID 哈希,把每个租户的数据固定分到某一张表里。哈希只决定租户落在哪张表,不管表有多大,几个大租户所在的分表远大于其他分表。

私有化环境通常只有一个租户,所有数据都在一张表里,分表等于没分。

冷热没有分层

访问集中在最近一个月,数据却大部分是旧的:

  • 控制台默认只查询最近 30 天,我们估计约 99% 的查询都落在这个范围内。实测一个工作日的高峰时段,读 90 天以前数据的请求不到 0.5%。
  • 另一次统计中,9 周以前的数据在一小时内没有任何写入。
  • 故障数据保留一年左右,按数据年龄算,90 天以前的数据约占三分之二。

MongoDB 里这些数据没有按时间分开存放,每种查询都需要一棵覆盖全部历史数据的索引。索引总量约为压缩后数据量的 94%,是 WiredTiger 缓存上限的 25 倍左右,缓存一直满载,页面不断换入换出。

我们用 $indexStats 统计了一年多的索引访问情况,从没被访问过的索引不到总量的十万分之一。也就是说,没有可以删掉的索引。

性能不足,慢查询过多

前两点的直接后果是慢。慢查询日志的记录门槛是 100 ms,每天记录上万条。

写入一条告警要更新 8 棵索引树;过期清理只能逐条删除文档,每条删除都要连带更新所有索引,夜间清理任务是慢日志的主要来源之一。

最典型的场景是计数(count)。告警和故障列表要显示总数,而 MongoDB 不维护按条件的计数:

  • 不带条件的总数可以从集合元数据直接读。
  • 带过滤条件的 countDocuments 实际是一次聚合,要把满足条件的记录逐条数出来。
  • 只有当过滤条件全部落在同一个索引的一段连续范围上时,才能只数索引键(COUNT_SCAN)。

我们的列表可以按状态、严重度、渠道、标签和时间任意组合过滤,大多数组合只能用索引缩小一部分范围,剩下的条件要逐条取出文档判断。数据越多,候选范围越大,被取出的旧文档大多不在缓存里,要从磁盘读。

我们给计数加了 1000 条的上限,但上限只在匹配的记录足够多时有用。条件很严、匹配很少时,扫完整个候选范围也凑不满 1000 条。

结果是两类现象:

  • 慢日志里有一类记录正好停在 2 秒左右,就是这种计数撞上了客户端超时:列表能打开,总数却算不出来。
  • 按严重度对 30 天的活跃故障做分组计数,最慢的一次用了 19.5 秒。

加内存只能推迟问题:缓存翻倍后,只够抵消一年多的数据增长,年费却要涨到约 1.5 倍。

分片集群解决不了这三点

分片和分区解决的是两类问题,而我们缺的是分区。团队用了 4 年 MongoDB,最自然的下一步就是分片集群,所以我们先认真评估了它。

分片集群把数据分到多台机器上,但每个分片内部仍是冷热混放、索引覆盖全部历史;分区把同一张表按时间和租户切成可以单独管理的块

分片决定一条数据放在哪台机器上,解决的是一台机器存不下、扛不住的问题。分区把一张表按访问方式切成多个块,每个块可以单独删除、单独换存储介质、单独维护。

MongoDB 能分片,但没有表分区:分片之后,每个分片内部仍然是全部历史混在一起的集合和索引。上面三点都出在单个节点内部的数据组织上,片键怎么选都改变不了这一点:

片键写入分布冷热和清理
账号 + 时间大租户可以拆成多个 chunk,但它的写入总是落在最新时间段所在的那个 chunk 上每个分片内冷热混放,过期仍要逐条删除
时间所有写入都集中在最新的分片上旧数据可以随 chunk 迁走,但迁移靠均衡器逐个 chunk 搬
哈希写入均匀按时间范围查列表要查遍所有分片,冷热完全打散

MongoDB 里能拼出来的几种办法,我们也逐一评估过:

  • TTL 索引能自动删除过期数据,但仍是后台逐条删除,每条都要更新所有索引,和我们现在的夜间清理是同一种成本。
  • Zone 分片可以把旧数据所在的 chunk 固定到配置较低的分片上。数据要靠均衡器逐个 chunk 迁移,每个分片的索引仍覆盖它持有的全部数据。
  • 时序集合面向写入后不再修改的测量数据。我们使用的 5.0 版本,时序集合不支持更新;新版本放开了更新,但数据仍按桶存储,不适合计数累加、状态变化、分派处理人这类频繁修改的业务记录。
  • Online Archive 能把旧数据自动转到对象存储,但它只在 MongoDB Atlas 上提供。我们在 SaaS 上用的是国内云厂商的托管服务,私有化环境更用不了。
  • 在应用层按月建集合,等于自己实现一套分区。在现有哈希分表的基础上再按月拆分,集合数量要再乘以 12;索引靠脚本逐个创建,查询靠代码拼出该查哪些集合。我们排查时发现,现有分表里已经有一组索引只在约三分之一的分表上建成,其余分表还是旧结构,一直没人发现。

所以结论是:MongoDB 能做到,但需要我们在应用层自己实现分区,并长期维护它。

成本和运维也不占优势。分片集群的每个分片本身就是一套副本集,此外还需要 Config Server 和 mongos,节点数成倍增加。私有化环境也得部署同样一整套组件。

既然缺的是分区,下一步就是找一个原生支持分区的数据库,并围绕分区重新设计存储。

新的存储设计

新设计只做一件事:让数据的存放方式和访问方式一致,热点租户单独放,冷热按时间分开。

数据库选了 PostgreSQL。部分索引、多级分区、对任意标签键的 GIN 索引、数组操作和咨询锁,PostgreSQL 都原生支持,在 MySQL 上要多建表或在应用层补逻辑。

下面依次说明四件事:表怎样分区,查询怎样只访问相关分区,冷数据怎样搬走,两种环境怎样部署。最后用一条告警把它们串起来。

两级分区:先时间,后租户

告警、告警事件、故障和时间线这四类表都采用同一套两级分区结构,时间维度决定冷热,账号维度隔离热点。

四类表的分区结构:第一级按时间,第二级按租户;最近的分区常驻内存,旧分区移到对象存储,超过保留期的整块删除

第一级按时间做 RANGE 分区,第二级在每个时间分区内按账号做 LIST 分区:大租户各占一个分区,其余租户共用一个 DEFAULT 分区。时间粒度根据单个分区的大小来定,图中按周,数据量更大时可以按天。

大租户升格不搬历史数据。 我们无法事先知道哪个账号会成为大租户,所以由夜间任务统计 DEFAULT 分区里各账号的行数,超过阈值的账号从下一个时间分区开始拥有自己的分区。

下一个时间分区还是空的,给它加一个 LIST 分区只是元数据操作,瞬间完成。历史数据留在原来的 DEFAULT 分区里,到期后随整个时间分区一起删除。

这也是我们把时间放在第一级的原因。如果第一级按账号分区,升格就要先 DETACH DEFAULT 分区、搬数据、再 ATTACH 回去,搬数据期间其他租户的数据在父表上看不到。验证阶段两种顺序都试过,剪裁出的分区集合完全相同。

查询只访问相关分区

分区只有在查询被剪裁到少数分区时才有用,所以剪裁不能靠约定,要由代码强制。

不带时间范围的查询直接拒绝。 查询带上时间范围后,PostgreSQL 在规划和执行时只访问相关分区。但只要有一条查询忘了带时间范围,就会扫描全部分区。

所以我们在 ORM 回调里加了检查:查询分区表的语句不带时间范围就拒绝执行。上线后,扫描全部保留期的语句从每 10 分钟 183 条降到 0。

按 ID 查询也要能剪裁。 在 MongoDB 里,告警和故障的 ID 是 ObjectId,前 4 个字节是生成时的秒级时间戳;我们的 API 也支持直接按 ID 查询。

迁到 PostgreSQL 后 ID 保持不变,但只给 ID、不给时间范围的查询会被上面的检查拒绝。我们的做法是从 ID 里取出时间,换算成查询的时间范围:

  • 新数据的 ID 由我们自己生成,生成方式和 ObjectId 相同,只是前 4 个字节写入分区键的时间。ID 时间和分区键一致,查询只看前后 1 小时,通常落在 1–2 个分区里。
  • 旧数据的 ID 时间是写入时间,而分区键是业务时间(例如告警开始的时间)。我们逐个分区体检了全部历史数据,两者最多相差 29 天,所以旧 ID 的查询范围放宽到 ID 时间之前 30 天,约 5–6 个分区。旧数据过了保留期后,这个宽窗口也随之消失。

部分索引让热路径更小。 MongoDB 也支持部分索引,我们换引擎并不是为了它,但它和分区叠加后效果明显。去重时要判断“这个告警现在是否还有活跃记录”,而活跃告警只占很小一部分,我们为活跃告警单独建了一棵部分索引。

验证阶段,一个大租户的这棵索引约为全量索引的十分之一,打开活跃告警首页的耗时从 308 ms 降到 0.4 ms,读取的页数从 13.2 万页降到 59 页。写入一条告警要更新的索引树也从 8 棵减少到 3–4 棵。

并发写入用事务和咨询锁保护。 告警合并、故障与告警的级联写入,都在同一个事务中完成。去重时用 pg_advisory_xact_lock 锁住同一个告警键,作为 Kafka 按键分区之外的第二道并发保护。

对计数的效果。 PostgreSQL 的 count 同样要逐条去数,没有捷径。区别在于剪裁之后只数时间窗口内、该租户所在的那几个分区,要数的范围不再随历史数据增长。

验证阶段,我们从生产慢日志中挑出最慢的 18 类查询,在 PostgreSQL 上重跑:

  • 那条在 MongoDB 上 2 秒内算不完的封顶计数用了 23 ms。
  • 按严重度分组计数从 19.5 秒降到 250 ms。

验证环境规格更小、没有并发、数据只有 90 天,这些数字只能看量级,不代表精确的倍数。

冷数据搬到对象存储

分区之后,数据的生命周期可以按整个分区来管理:定时任务提前创建未来的分区,旧分区搬到对象存储,过期分区直接 DROP。DROP 是元数据操作,不需要逐条删除。

三件事里只有搬冷数据不顺利,它是这次迁移中花时间最多的部分,方案前后改了四次。

目标很简单:约 3 个月以前的分区,只把表数据搬到对象存储,索引留在本地盘,读取时按需从对象存储取页。对象存储的单价约为云盘的十五分之一。代价是读冷数据变慢:按 ID 查冷数据的 p50 是 4.8 ms,同类查询在云盘上是 2.3 ms。

冷数据搬迁的四次尝试:直接改表空间会长时间锁表;只搬没人读的分区不可行;先卸下再搬遇到 IO 放大;最终方案是限速复制到对象存储上的新表,再短锁换入

第一次:直接改表空间。 ALTER TABLE ... SET TABLESPACE 在执行期间一直持有排他锁,搬一个分区要 38–87 秒,只读节点也会同步持有这把锁。

不带时间范围的查询要访问所有分区,因此会被正在搬的那个分区挡住。上一小节“不带时间范围的查询直接拒绝”,就是这时定下的规矩。

第二次:只搬没人读的分区。 我们统计了一小时内各冷分区的访问情况,结果所有冷分区都被读过。

一方面是按 ID 查询,另一方面是一些开了几个月仍未关闭的故障,统计它们的告警时会从故障开始时间一直读到今天。所以没有“不会被读”的冷分区,这个思路行不通。

第三次:先卸下,再搬,再挂回。 先给分区加一个与分区边界相同的 CHECK 约束,这样重新 ATTACH 时不需要扫描校验;然后 DETACH(锁等待超过 3 秒就放弃),改表空间,再 ATTACH。

锁的问题解决了,但搬 15 GB 数据时,存储层产生了约 13 倍的读和 6 倍的写,几分钟内就把节点的 IOPS 打满,我们只好止损。

第四次:限速复制,短锁换入。 这是现在在用的方案:

  • 在对象存储表空间上建一张新表,按 4096 页一块复制数据,每块复制后立即 VACUUM FREEZE。
  • 复制速度按索引数量折算(每多一个索引,写入量就多一份),每晚在固定窗口内运行,有时间预算。
  • 复制完成后检查原分区在复制期间有没有新写入,没有才短锁换入;没换成的副本由下一次运行清理。

现在每晚搬两个分区,ATTACH 耗时约 1 秒,期间主节点 IOPS 不超过 14%,没有锁等待。

搬迁中另外遇到过两个问题。

托管服务内核的缺陷。 只读节点读取冷数据时,在主节点的缓存上留下的引用没有释放,之后删除冷分区或 VACUUM 截断时就会挂住。我们暂停了冷数据搬迁和过期删除,等厂商修复内核、用合成场景复现验证通过后才恢复。

事务号冻结。 复制表的最后一两个块,以及回填后不再写入的旧分区,没有被冻结,自动清理也不会再访问它们。这些分区的事务号年龄会在同一时间达到上限,届时会同时触发防回卷的强制 VACUUM,扫描数百 GB 数据。

我们提前在低峰时段按表手动执行 VACUUM (FREEZE),把年龄降了下来。

SaaS 和私有化的部署

同一套设计要在两种环境里运行,而两边的运维条件差别很大,所以部署方式分开考虑。

SaaS 用云厂商的托管服务。 只要协议兼容 PostgreSQL,我们倾向于选带代理层的方案:

  • 应用只连代理,主从切换由代理完成,切换时间更短。
  • 数据在多个可用区之间热备,一个可用区故障时服务不会全面瘫痪。
  • 冷数据搬到 S3 兼容的对象存储。

这些能力由托管服务提供,我们的代码只使用标准的 PostgreSQL 协议。

私有化尽量简化。 私有化客户自己运维数据库,我们只要求一主一从或双主这类常见部署。两级分区全在一个 PostgreSQL 实例内部完成,查询由规划器直接剪裁到对应分区,不需要额外的路由层或代理。

我们其他的 Go 服务在私有化交付包里早就支持 PostgreSQL,MongoDB 是交付包里唯一没有替代选项的组件,迁移之后数据库种类只会减少。

合起来看:一条告警的一生

把上面几部分放在同一条数据上,就是它从写入到删除的全过程。

一条告警的一生:写入本周的热分区,约 3 个月后所在分区搬到对象存储,过保留期后随整个分区删除;任何时候查询都只访问时间范围内的分区

写入。 应用生成 ID,前 4 个字节写入分区键的时间。数据落到本周分区里该租户所在的子分区,只更新 3–4 棵索引树。

最近几周。 分区在本地盘,常驻内存。列表查询带时间范围,只访问最近的几个分区;按 ID 查询从 ID 里取出时间,落到 1–2 个分区。

约 3 个月后。 夜间任务把所在分区的表数据复制到对象存储并换入,索引留在本地盘。偶尔被查到时,读取变慢但仍然可用。

过了保留期。 整个时间分区被 DROP,不逐条删除,也不更新任何索引。

设计到这里就定了。剩下的问题是:线上一直在写入和查询,怎样把数据和流量换过去。

怎么迁

迁移的约束有两条:不能停机,任何一步都要能在几分钟内退回。所有做法都是从这两条推出来的。

我们在代码的 model 层为每类数据定义了一个 Store 接口,同时提供 MongoDB 和 PostgreSQL 两套实现。22 类数据各自独立推进,每类数据有两组开关,都存在 Redis 里:

  • 一组控制写入方式:只写 MongoDB、双写、只写 PostgreSQL。
  • 一组控制哪些账号从 PostgreSQL 读取。

服务进程在本地缓存开关 1 分钟,所以回滚只需要改回一个键,1 分钟内就会生效。

六个阶段

每类数据都走同样的六个阶段,前一个阶段的结果是后一个阶段的前提。

迁移的六个阶段:设计验证、双写、回填与对账、双读比对、灰度切读、停写与下线;每个阶段人负责什么、AI 代理负责什么

1. 设计和验证。 先确认迁得动:逐个列出代码里所有访问 MongoDB 的 model 方法,共 319 个,没有一个是关系型数据库做不到的;其中约 68 个已经没有任何调用,可以直接删掉。

然后从线上按账号抽样,搭一个小规模 PostgreSQL 实例,回放 66 种查询形态,把每条查询在两个库上的结果逐条比对。

2. 双写。 让新写入的数据同时进两个库。主库写入成功后,请求立即返回;写另一个库(影子库)的操作进入本进程的队列异步执行,30 秒内没有写成功,就把账号和 ID 记入待补集合。

双写流程:请求写主库后立即返回;写影子库的操作在本进程队列中异步执行,失败的记录进入待补集合,由对账任务补齐

不同进程的队列之间没有先后顺序,所以影子库的每次更新都带 updated_at 检查,只接受比现有记录更新的版本。ID 由应用在写入前生成,两边一致。

3. 回填和对账。 双写只覆盖新数据,历史数据要回填。回填使用 ON CONFLICT ... DO UPDATE ... WHERE excluded.updated_at >= updated_at,保证旧版本不会覆盖双写期间写入的新版本。

对账任务按天比对两边的 ID 集合并抽样比对字段,差异以该账号当前的主库为准补齐。另一边多出来的数据只报告、不删除。

4. 双读比对。 数据齐了,还要确认查出来的结果一样。读请求同时读两个库,比对结果只记录、不返回给用户。结果不同时,在 1 秒和 5 秒后各重读一次,双写延迟造成的差异会在重读时消失,剩下的才需要归因。

5. 灰度切读。 结果一致后,才把真实的读流量切过去。切读按数据类别、账号和比例三个维度推进,具体做法见下一小节。

6. 停写和下线。 读全部切完后停掉 MongoDB 的写入。分两批切换为只写 PostgreSQL:先切 18 类配置数据,约 20 分钟后再切 4 类时序数据。切换后 MongoDB 的写入降到 0,待补集合清零。

之后关掉 MongoDB 的相关告警,重启 MongoDB 主节点观察 90 分钟,没有出现相关错误,把数据备份到对象存储后再下线实例。

灰度切读

切读是唯一会让用户直接感知到新库的一步,所以开关做成三个维度,出问题时影响面可以收到最小。

灰度的三个维度:每类数据独立;同一类数据先放自己的账号,再放单个客户,再按比例放量;任何一层都能单独回滚

按数据类别。 22 类数据各有一个开关,互不影响。例如告警事件放到 100% 后,发现一类按渠道过滤的查询缺索引,我们只把告警事件这一类降回 0,其余 21 类保持 100%,补完索引再放。

按账号白名单。 白名单里的账号直接读 PostgreSQL。最先放的是我们自己的账号,然后是愿意配合的单个客户。白名单可以单独加减某个账号,出问题时只影响这一个账号。

按比例。 账号 ID 对 100 取模,小于设定比例的账号读 PostgreSQL。同一个账号的请求总是落在同一侧,不会这次读 MongoDB、下次读 PostgreSQL。我们按 20%、50%、100% 逐档放量,中间降回过三次,原因见“遇到的四个问题”。

双读比对也用同一套开关,可以只对白名单账号或一定比例的账号打开。

人和 AI 代理的分工

这些步骤的工作量很大,大部分由 AI 代理完成。人负责定方案、审批每一次生产写操作,并在代理报告异常时决定下一步怎么做。

AI 代理的值守循环:人审批写操作,代理执行、按固定间隔采样告警和止损指标,一旦越线就停止推进并按回滚方案处理

切换前,先让团队熟悉 PostgreSQL。 团队过去主要用 MongoDB,所以我们用 AI 制作了一份 PostgreSQL 上手教程,内容完全基于我们自己的表结构,分 14 个小节:

  • 怎样连库、psql 的常用元命令。
  • 类型转换和时间列、二进制 ID 的查法、NULL 和 JSON null 的区别。
  • 35 张表之间的关系、分区规则、数据保留期、怎样建表和建索引。
  • 12 条典型查询,每条都和原来的 MongoDB 写法对照。

这样到了要排查问题的时候,大家已经会查新库了。

设计阶段,代理读代码、做验证。 第一阶段的方法清单由 6 个代理并行审计全仓库后整理出来,每一条都标明了文件和行号。查询回放和两个库的结果比对,也是代理搭环境、写脚本、跑完的。

我们之前有一个“有 56 GB 索引可以直接删”的判断,就是被代理用一年多的索引访问统计推翻的。

编码阶段,代理写两套实现。 每类数据的两套 Store 实现,加上双写、回填、对账、分区维护和冷数据搬迁的工具,代码量大但写法高度一致,适合交给代理批量完成。人负责审查接口设计和关键的并发语义。

执行阶段,代理推进和值守。 每一次生产写操作,都由代理先写好变更单,内容包括执行步骤、回滚命令和带具体数字的止损条件,人审批后代理再执行。

执行过程中,代理每 60 秒检查一次新告警,每 2 分钟采样一次止损指标:5xx 数量、存储写入失败日志、消息队列积压、数据库 CPU 和 IOPS。任何一项越线就停止推进。

值守中有两个例子:

  • 切读放量到 20% 时,代理看到网关开始返回 504,就把比例降回 0,并按慢查询形态找到缺少的索引(经过见“遇到的四个问题”的第一个)。
  • 停写后的第二天,代理发现接口 p99 比前一天高,没有直接关单,而是先查清原因:一个客户的脚本开始高频调用某个接口,与这次切换无关。

想了解 Flashduty 的 AI SRE,可以看产品介绍。

结果和问题

迁移完成后,我们对比了前后的生产指标,也记下了过程中没有预料到的四个问题。

迁移效果

故障列表和故障详情的慢请求明显减少,热存储减少约四成,告警列表的长尾没有改善。

迁移前后对比:故障列表和故障详情超过 500 ms 的请求占比明显下降,告警列表没有改善;热存储减少约四成;扫描全部保留期的语句降到 0

接口耗时取自生产监控,对比的是迁移前一个全部读 MongoDB 的工作日,和全部读 PostgreSQL 之后的一个工作日。两天的指标采集范围不同,所以只比较各耗时区间的占比,不比较请求数。

指标迁移前(MongoDB)迁移后(PostgreSQL)
故障列表:超过 500 ms 的请求0.21%0.05%
故障列表:超过 1 秒的请求0.06%不到 0.01%
故障列表:p95100–200 ms100 ms 以内
故障详情:超过 1 秒的请求0.11%不到 0.01%
两个告警列表:超过 500 ms 的请求0–0.02%0.04–0.05%
热存储100%约 56%
扫描全部保留期的语句每 10 分钟 183 条0

监控直方图的桶边界是 10、100、200、500、1000 ms,p95 只能看出落在哪个区间。图中其余接口的 p95 迁移前后都在 100 ms 以内。

告警列表的长尾我们还在逐条分析。

遇到的四个问题

四个问题都出在灰度放量和切换的过程中,都靠降回开关止住,修复后重新放量。

影子路径隐藏了慢查询。 影子读的超时时间是 1 秒,PostgreSQL 上因为缺索引而变慢的查询,在影子路径里只会记为一次“影子读错误”,不影响用户。

放量到 20% 时,按标题正则搜索、带上限的计数、多渠道过滤这三类查询开始超时,网关返回 504。教训是:放量前先按影子路径上的慢查询补索引,整体 p99 看不出这种长尾。

关注的渠道一多,查询计划就退化。 一个账号同时关注 276 个渠道,超过了按渠道逐个走索引的上限 256,查询退回成 channel_id = ANY(...) 的形式并读到了冷数据,耗时 4.5–5.6 秒。我们把上限提高到 1024 后重新放量。

切换窗口内新旧两种模式的进程同时存在。 开关有 1 分钟的本地缓存,切换后的 1 分钟内,有的进程已经切到新模式,有的还在旧模式。

其中一类数据的更新方式是先按 ID 删除再重建,两种模式的进程生成了不同的 ID,PostgreSQL 上出现了唯一约束冲突。我们把这类数据改成按业务键删除,修复后重新切换。

全局执行计划缓存让查询变慢。 我们使用的托管 PostgreSQL 有一个跨连接共享的执行计划缓存。某条语句的通用执行计划被缓存后,新连接执行同样的 SQL 时直接沿用了它,一个大租户的查询从 66 ms 变成了 14.8 秒。

给应用使用的数据库角色设置 plan_cache_mode = force_custom_plan 之后,查询恢复正常。

选型的几点体会

回头看,这次迁移里真正起作用的是选型阶段的几个判断。它们不限于 MongoDB 和 PostgreSQL。

先看数据,再看引擎。 选型之前先量清楚三样东西:数据在租户之间怎样分布,访问在时间上怎样分布,数据保留多久、写入后还改不改。我们的答案是租户相差上千倍、约 99% 的查询在 30 天内、数据保留一年且频繁修改。有了这三个答案,才看得出缺的是分区而不是分片。从“哪个数据库更好”出发得不到这个结论。

运维成本要按每一种部署环境分别算。 SaaS 有托管服务兜底,私有化是客户自己运维。同一个方案,在 SaaS 上只是多几个节点,在私有化环境里就是多几种要客户学会的组件。我们最后要求的私有化部署是一主一从,交付包里的数据库种类比迁移前少。

使用成本看数据怎么放,不看引擎单价。 换引擎本身并不省钱,同样的数据在 PostgreSQL 上还更占磁盘。省下来的成本来自两处:过期数据按分区删除,冷数据搬到单价约为云盘十五分之一的对象存储。反过来,继续加内存是年费涨到 1.5 倍、只换来一年多的时间。

AI 降低了迁移成本,所以可以直接选端态方案。 过去不敢换数据库,主要是因为工作量:几百个方法要重写,两套实现要并存,还要写回放、对账和回填工具,每一步都要人盯。这次这些工作大部分由 AI 代理完成。

迁移成本降下来之后,过渡方案就不划算了。在应用层按月建集合这类办法,当时看是改动最小的一条路,但它要长期维护,问题也没有消失,以后还要再迁一次。我们的做法是一步到位,直接做到想要的最终结构。

方案一步到位,上线分步走。 选端态方案不等于一次切过去。每类数据独立开关、三个维度的灰度、1 分钟回滚,都是为了让最终方案可以一小步一小步地上线。

代价要事先写明,并让它落在访问最少的地方。 没有不付代价的方案。我们付的代价是冷数据读取变慢,而读 90 天以前数据的请求不到 0.5%。告警列表的长尾则是还没有解决的问题。

规矩靠代码强制,不靠约定。 约定迟早会被绕过:旧分表里有一组索引只在约三分之一的分表上建成,一直没人发现。新设计里“查询必须带时间范围”由 ORM 回调检查,新写的查询不满足就无法执行。

如果数据同样是少数租户占大头、冷热按时间分明,希望这份记录能省掉一部分试错。

相关阅读