一个六人技术团队,系统里装了 Nginx、网关、Redis、MySQL 主从、Kafka、Elasticsearch、对象存储、分布式调度、Prometheus、Grafana、日志收集、配置中心,一共十二个组件。每个组件都是「业界最佳实践」,选型时都有充分理由。真正的问题是没人能同时把这十二个都维护好:Redis 主从切换的哨兵配置只有一个人看得懂,他请假那天正好赶上主库宕机,首页挂了四十分钟。

这不是技术选型错误,而是「组件数量超过了团队容量」。每个组件都带来部署、升级、监控、故障处理、交接五类工作,这些工作不会因为团队小就消失,只会堆在少数几个人身上,直到某一天集中爆发。

这篇不谈「哪个中间件更好」,只谈「你这个团队养得起几个」。先算组件数量对可用性的影响,再算每个组件的真实成本,然后给出先减后加的顺序和一套六人团队够用的参考架构。可用性数字来自本机 Node 模型;本机的 Nginx、Redis、Kafka、ES、MySQL 主从都能作为巡检样本,但多组件长期运维无法在单机模拟。

先认出现象:组件多了会发生什么

组件过多的问题不会以「某个组件崩了」的形式出现,而是以「团队被拖住」的形式出现。下面这些现象,出现三个以上就该做一次组件审计。

现象真实原因第一步查什么
每天第一件事是刷告警群告警没有分级和收敛,每个组件都在直接喊人统计一周告警条数、其中真正需要处理的比例
组件升级要排一个周末没有统一升级流程,也没有回滚预案查每个组件的升级文档是否存在、是否演练过
中间件挂了,没人敢切高可用配置只有个别人懂,没做过切换演练查切换手册、最近一次演练时间、实际切换耗时
同一个需求有三套组件都能做选型没有约束,每次按当下喜好加一个列出组件与它承担的功能,找重复项
业务还没起量,机器先不够用每个组件都有自己的常驻内存和副本开销统计各组件的资源占用与闲置率
新人一个月不敢碰线上认知负担过重,文档与实际不一致让新人按文档做一次部署,记录卡住的步骤
备份每天在跑,恢复没试过备份被当成目的,可恢复性从未验证抽查一份备份,在测试环境真恢复一次
写业务的时间少于维护组件的时间组件数量超过团队可维护上限按人天统计运维与业务投入比例

最后一条是最直接的信号。如果团队一半以上的时间花在「让系统活着」,而不是「让业务变好」,那么再加一个中间件就是在借未来的债。这个债的利息,是每次故障时的手忙脚乱。

每加一层,可用性乘一次

可用性是可以算的。假设每个组件自身的可用性是 99.9%,也就是一年里大约有 8.76 小时不可用。当请求要依次穿过多个组件时,整体可用性是它们相乘,因为任何一个环节出问题,请求都失败。

本机模型按 99.9% 的单组件可用性,算了不同组件数量下的整体可用性和年停机时间。

3 个串联组件   99.700%   年停机 26.3 小时
4 个串联组件   99.601%   年停机 35.0 小时
6 个串联组件   99.401%   年停机 52.4 小时
8 个串联组件   99.203%   年停机 69.8 小时
12 个串联组件  98.807%   年停机 104.5 小时

从三个组件加到十二个,年停机时间从 26 小时涨到 104 小时,翻了四倍。注意,这里每个组件的单体可用性都没变,都是 99.9%,变差的只是「串联的层数」。这就是为什么「每个组件都很稳」的系统,整体可能一点也不稳。

要区分串联和并联。同一层的多个副本是并联,一个挂了另一个顶上,可用性会提高;跨层是串联,多一层就多一次失败机会。加一个缓存层,如果缓存挂了能让请求回源,那它是「可跳过的并联」;如果缓存挂了接口直接报错,那它就是串联。设计时要尽量让非核心层「可跳过」。

99.9% 是单组件的乐观假设。自建组件在没人专职维护时,实际可用性往往低于这个数。数量越多,估算越偏乐观,这也是小团队要控制组件数的一个理由。

组件不是免费的:五类成本

选型文档通常只比较功能和性能,不比较「养它要花多少人力」。下面五类成本,每一类都可以换算成小时。

部署与升级初次部署、版本升级、配置变更、证书轮换。一个组件每月至少两到四小时,升级大版本还要停机窗口和回滚预案。
监控与告警指标采集、看板、阈值、告警路由。没有监控的组件等于黑盒,有监控但没收敛的组件等于噪音源。
故障处理与演练写手册、做切换演练、复盘。没演练过的高可用配置,在真故障时约等于没有。
容量与资源内存、磁盘、连接数、副本数。每个组件都要预留冗余,冗余就是钱,也是要监控的对象。
认知与交接文档、培训、值班。人员流动时,没人懂的组件就是一颗定时炸弹。

粗略估算:一个组件每月四小时,十二个组件就是四十八小时,约等于零点三个全职人力。这还没算故障时的集中投入。六人团队里抽出零点三人专门维护中间件,听起来不多,但实际往往是「所有人都被切碎」,没人有完整时间做业务。

成本还会随组件之间的组合关系放大。两个组件各自要监控,它们之间的连接、认证、超时、重试又是第三份工作。组件越多,组合越多,故障定位越难,这是一条平方级的曲线,不是线性的。

先减后加:四种合并思路

控制组件数量的顺序应该是「先减,再考虑加」。减的方式有四种,按风险从低到高排列。

换成托管服务

对象存储、CDN、托管数据库、托管 Redis,把「部署升级扩容」交给云厂商,团队只保留使用和监控。代价是费用和一定程度的锁定,收益是省下最重的那部分运维。

一个组件多角色

Redis 同时做缓存、简单队列和分布式锁,适合量小且能接受互相影响的场景。必须设不同的库或前缀,并给每类用途单独的内存上限,否则一类暴涨会拖垮另一类。

用数据库替代轻量队列

任务量每秒个位数时,一张 outbox 表加定时扫描就够,不必上 Kafka。等积压和吞吐真的成为问题时再迁移,迁移成本远低于长期维护一套空转的集群。

应用内调度替代分布式调度

单实例加数据库行锁就能保证任务不重复执行,配合幂等和补偿,足够撑到多实例阶段。上分布式调度之前,先确认任务真的需要跨实例协调。

合并不是无脑省事。有两类组件不建议合并:一类是故障域必须隔离的,比如消息队列积压不能把在线接口拖垮;另一类是负载曲线完全不同的,比如缓存需要频繁扩容而数据库不需要。判断标准是「合在一起后,一个出问题会不会连带另一个」,会,就别合。

还要警惕「用 Redis 做一切」。Redis 做缓存很合适,做持久化队列、做全文搜索、做复杂聚合就不合适。把不适合的职责塞进去,短期省了一个组件,长期会多出无数补丁和一次痛苦的重构。

一套六人团队够用的参考架构

下面这套架构的目标不是「最强」,而是「六个人能维护、能排障、能交接」。组件总数控制在六个以内,每一层都留了明确的升级路径。

六人团队的参考部署
入口托管 CDN 加对象存储,静态资源与图片不走应用
负载均衡一台 Nginx 或云负载均衡,后端两到三个应用实例
应用无状态服务,配置从环境变量注入,日志输出到标准输出
缓存Redis 主从加哨兵,只做缓存和锁,不存唯一数据
数据MySQL 主从,备份每日一次并每月恢复演练

异步任务先用「outbox 表加定时扫描」,不引入消息队列。监控用一套指标加一套日志,告警只留能让人行动的那几条。配置中心在组件数少的时候可以省掉,用环境变量加发布流程管理即可。

每一层都要写清楚「什么时候该升级成更重的方案」。没有退出条件的架构,会一直停在原地,也会在需要演进时无从下手。

层当前做法升级触发条件
入口托管 CDN 与对象存储需要自定义回源鉴权或边缘计算时再自建
负载均衡单台 Nginx 或云负载均衡单台成为瓶颈,或需要跨机房容灾
缓存Redis 主从加哨兵单实例内存超限、需要分片或跨可用区
异步outbox 表加定时扫描日任务量超过百万,或需要多消费者独立扩容
搜索数据库 like 加索引需要分词、相关性排序、聚合分析
调度单实例加数据库锁任务需要跨实例分片、需要可视化与补偿

这张表的作用是「延迟决策」。不是永远不上,而是把上线的时机绑定到可观测的触发条件上,而不是绑定到「别人都在用」。触发条件写不出来,说明还不需要。

什么时候必须拆

控制组件数量不等于永远不拆。以下四种情况,拆是合理的,而且应该尽早拆。

第一,独立扩容需求明确。缓存 QPS 是数据库的几十倍,两者扩容节奏完全不同,合在一起会互相牵制。第二,故障隔离有硬要求。队列积压导致接口超时的事故发生过一次,就该把队列独立出去。第三,团队分工形成。不同小组维护不同组件,边界清晰比数量少更重要。第四,合规或数据边界要求,比如日志与业务数据不能同库。

拆之前要有数据,不是有情绪。用「当前组件的 CPU、内存、连接数、p99」说明它已经撑不住,比说「我觉得应该拆」有说服力得多。拆之后要能回答「多出来的这套谁来维护、告警发给谁、故障时谁处理」。答不上来,就先别拆。

冗余不等于高可用

很多团队用「我们做了主从」来回答高可用问题。主从只是「有副本」,不等于「故障时能切」。切换要满足三个条件:有自动或半自动的切换机制、切换过程演练过、切换后数据损失可接受。

演练要真做,不能只看配置。把主库停掉,记录从检测到恢复到可用的时间,检查应用是否自动重连、是否有请求失败、失败的那部分业务能不能补偿。这个时间就是你的真实恢复时间,比任何架构图都可靠。

备份也一样。备份成功不等于能恢复。每月抽一份备份,在独立环境恢复一次,记录耗时和缺失的数据。没恢复过的备份,只能算「有文件」,不能算「有备份」。

可用性目标要和业务对齐。99.9% 是年停机 8.76 小时,99.99% 是 52.6 分钟。后者需要的不只是多一个副本,还需要多可用区、自动化切换、值班响应。小团队定 99.99% 却按单机房部署,目标就只是写在文档里的一句话。

关键配置与巡检

下面给一个最小巡检脚本和一套部署约束,用于把「组件是否健康」变成每天能看到的数。单组件探活在本机跑过,多组件编排未实测。

#!/usr/bin/env bash
set -u
check() {
  local name="$1" cmd="$2"
  if eval "$cmd" >/dev/null 2>&1; then
    echo "OK   $name"
  else
    echo "FAIL $name"
  fi
}
check "mysql"    "mysqladmin ping -h db -u monitor"
check "redis"    "redis-cli -h cache ping"
check "nginx"    "curl -fsS http://lb/healthz"
check "disk"     "test $(df -P / | awk 'NR==2{print $5}' | tr -d '%') -lt 85"
check "backup"   "test $(find /backup -name '*.sql.gz' -mtime -1 | wc -l) -ge 1"

巡检脚本的价值在于「每天固定输出同一组判断」,而不是让人凭印象说「大概正常」。输出里出现 FAIL 就应该有人处理,否则脚本跑着也没意义。

# 部署约束(写进发布检查单)
1. 每个组件必须有:健康检查地址、告警接收人、升级文档、回滚步骤
2. 每个组件必须有:资源上限(内存、连接数、磁盘配额)
3. 每个有状态组件必须有:备份策略和最近一次恢复演练日期
4. 新增组件必须先回答:它替代了哪个旧组件,或解决了哪个已量化的问题
5. 没有 owner 的组件不允许上线

第四条最容易被跳过。新增组件时如果答不出「替代谁」,很可能是在原有组件上叠了一层,而不是解决问题。叠层带来的复杂度,往往比问题本身更难处理。

怎么验证:命令与成功判据

验证的目标不是「组件都能启动」,而是「团队真的能维护」。可以从四个角度检查,前三条在本机实跑,第四条的交接演练无法在单机模拟。

# 1. 数清组件与副本数量
docker ps --format '{{.Names}}' | sort
kubectl get deploy -A | wc -l

# 2. 统计一周告警,看有效比例
# 从告警平台导出后按接收人、级别分组

# 3. 停掉缓存,观察接口是否可降级
redis-cli -h cache shutdown nosave

# 4. 停掉主库,测量切换到可用的时间
# 记录开始时间与首个成功请求的时间差
# 本机探活输出(五个组件各自独立进程)
nginx -t                  -> test is successful
redis-cli -p 6381 ping    -> PONG
curl :9210/_cluster/health -> "status":"green"
kafka-topics --describe   -> PartitionCount: 3, Isr: 1
SHOW SLAVE STATUS         -> Yes / Yes / 0

五项都 OK 只证明组件能启动;脚本里真正难的是恢复演练和交接,这两项单机代替不了。

成功判据:组件与副本总数在团队能维护的范围内,且有清单和 owner;一周告警中需要人工处理的比例低于两成;缓存停掉后核心接口仍可用,只是变慢;主库停掉后能在可接受时间内恢复,且失败请求可补偿。

本机可跑的是可用性模型:把组件数量代进去,得到年停机时间。成功判据是能说出一句结论,比如「从六个组件减到四个,年停机从 52 小时降到 35 小时」。这个数能帮助团队在「再加一个组件」的讨论里做出清醒选择。

边界与代价

组件少不等于风险少。组件越少,单点越集中,一个组件挂掉影响的面越大。少组件的前提是「这个组件本身足够稳,且故障时可降级」,不是简单地做减法。

托管服务省了运维,但带来费用、锁定和可控性下降。关键业务用托管服务前,要确认导出路径、备份归属和故障时的支持响应时间,不要等到出事才发现「数据在别人那里、权限也不在你手上」。

合并会让边界模糊。Redis 既做缓存又做队列,内存互相挤占,出问题时很难判断是哪一类用途导致的。合并必须配隔离手段:独立实例、独立库、独立内存上限,至少占一样。

团队会成长,架构也要跟着变。今天够用的方案,两年后可能成为瓶颈。定期(比如每半年)做一次组件审计,比一次性设计一个「永远正确」的架构更现实。

当天能自验的五个练习

一,列出你负责系统的全部组件和副本,标上 owner 和最近一次升级时间。成功判据:没有无主组件,且能看出哪些组件半年没动过。

二,用本机模型算当前组件数的年停机时间,再算减掉两个组件后的数。成功判据:能说出减少的是哪两个、为什么可以减。

三,把缓存停掉,观察核心接口是否还能用。成功判据:接口变慢但不报错,或能明确说出「这里就是单点,暂时接受」。

四,让一个新同事按现有文档部署一套测试环境,记录他卡住的步骤。成功判据:卡点不超过三个,且每个都补进了文档。

五,抽查一份备份,在测试环境真恢复一次,记录耗时。成功判据:能给出「恢复需要多少分钟、会丢多少数据」两个具体数字。

和下一篇的关系

这一篇讲的是「维持住」,下一篇讲「怎么长上去」。从单机到集群不是一次换架构,而是一串有顺序的动作:先加什么、后加什么,每一步能换来多少容量,又会引入什么风险。顺序错了,会在最不该出事的时候出事。

记住这一篇的结论:组件数量要和团队容量匹配;可用性按串联相乘,多一层就多一次失败机会;先减后加,先托管后自建;每个组件都要有 owner、有退出条件。