来源书籍

从零开始学架构

Skill 版本:v23 系统架构类 经典原理(高信息浓度 × 高稳定性) 218 张卡片

全书是李运华在极客时间的专栏合集,共50讲,系统讲解架构设计的方法论、复杂度四大来源(高性能/高可用/可扩展性/低成本安全规模)、以及对应的经典技术方案。抽样精读第1讲(系统/子系统/模块/组件/框架/架构六个概念的严格辨析,从维基百科定义出发逐条提炼关键要素并给出反例)和第22讲(CAP理论,逐字对比Robert Greiner文章前后两版定义的措辞差异,精确辨析"see"与"read"、"every request"与"non-failing node"等用词差异背后的语义区别,并推导出分布式系统只能选CP或AP而非CA的结论)后确认:信息浓度极高——不是罗列"CAP是什么",而是追问"CAP的精确定义为什么会从第一版演进到第二版、每一个措辞改动背后解决了什么歧义";稳定性也很高——书中核心讲的是架构设计方法论、复杂度本质来源、CAP/FMEA等理论工具,这些内容即使脱离具体技术栈(书中提及的MySQL/Redis/Nginx等仅作为案例)依然成立,不会因为工具迭代而过时。因此判定为"经典原理",是目前v7重跑以来遇到的信息浓度与稳定性都属最高档的一本书。 **说明(2026-09-04)**:本书此前已有一版v6笔记(声明"Skill 版本:v6(2026-08-28 按 v6 规则续补;既有评级、章节进度与 75 张章节卡片保留)"),按v7重跑规则已用`git rm -rq`整体清空重建;本次评级结论、章节筛选、卡片内容均从零重新生成。EPUB内部结构:全书正文打包进5个`text0000N.html`大文件,`toc.ncx`用`filepos`锚点定位58个导航项,其中50个是正文编号讲(01-50),其余为说明/开篇词/结束语/书单/4次"华仔,放学别走"读者问答特别节目,非正式讲次不进入精读表。已确认50讲编号连续、无重复起始点,是李运华本人独立撰写的单本专栏合集,非拼装的多本书。 **提取脚本**:`notes/从零开始学架构/_extract.py`(已随笔记一起提交到git,`_epub-src/OEBPS/`为配套解压后的EPUB内容,同样已提交) (用法:`python3 notes/从零开始学架构/_extract.py <起始playOrder> <结束playOrder> <输出文件>`,playOrder取自`_epub-src/OEBPS/toc.ncx`中`<navPoint playOrder="N">`;每一讲对应一个独立的playOrder,起止传同一个数字即可提取单讲)

李运华(专栏作者;EPUB的creator为整理者) · 极客时间专栏整理本

类别清单覆盖

7/7

已覆盖 7 补充生成 0 未覆盖 0

全书导读

架构设计先识别业务和技术中的主要复杂度,再在性能、可用性、扩展性与成本等目标间判断取舍。本书从原则和四步设计流程进入数据库、缓存、并发模型、容错与系统拆分,最后讨论重构、技术演进和架构师学习。具体技术是回应约束的工具,不是预先决定的组件清单。

全书主线

简单、合适与演化原则为方案取舍提供约束。先识别主要复杂度,设计明显不同的备选,再按关键维度评估并细化;后面的技术章节展示这些选择如何落到具体访问模式、故障目标和团队能力上。技术模板帮助建立视野,不能代替当前需求的判断。

架构到底是指什么?

判断一堆东西是不是系统,看三点:关联,没有关联的个体堆在一起不构成系统,发动机、底盘、轮胎按设计组合才成为汽车;规则,个体按规定分工协作,如动力经变速器和传动轴传到车轮;能力,系统涌现出个体都不具备的能力,汽车能载重前进,零件单独都不能。子系统与系统定义相同,只是观察层级不同:朋友圈是微信的子系统,评论又是朋友圈的子系统。 进一步展开见系统三要素。

模块和组件常被混用,字典定义也分不清,真正的区别在拆分角度:从逻辑角度拆出的单元是模块,目的是职责分离;从物理角度拆出的单元是组件,目的是单元复用,强调独立、可替换。学生管理系统按业务分为登录注册、个人信息、成绩等模块;按部署分为 Nginx、Web 服务器、MySQL 等组件。讨论“要不要拆”时先问清是逻辑职责分离还是物理单元独立,两者是各自独立的决策。 进一步展开见模块逻辑拆组件物理拆。

框架关注规范:为实现某种标准或基本任务而提供的组件规范及配套基础产品,如 MVC 是规范,Spring MVC 是满足规范的产品。架构关注结构:系统的顶层结构及构造准则。结构没有限定切分角度,同一系统按业务逻辑、物理部署或开发规范去看,会得到三种不同却都正确的架构描述,这也是 4+1 视图用多个视角描述架构的原因。与其纠结叫框架还是架构,不如先说清讨论的是哪个维度。 进一步展开见框架是规范架构是结构。

作者把软件架构重新定义为“软件系统的顶层结构”,这一定义串起了前面几个概念:架构要明确系统由哪些个体(子系统、模块、组件)组成,也要明确这些个体按什么规则运作和协作。用“顶层”替换维基百科的“基础”,是为了区分系统与子系统:谈微信架构时只讲聊天、登录、支付这一层,不把子系统内部架构混进来。发散:评审架构图时先确认讨论的是哪一层。参见框架是规范架构是结构。 进一步展开见架构是系统的顶层结构。

原书依据 · 7 处

架构设计的历史背景

两次软件危机表现相似,根源不同。20 世纪 60 年代的第一次源于逻辑复杂:规模变大后代码流程难以掌控,IBM System/360 投入 5000 人年仍失控,解法是抛弃 goto、自顶向下逐步细化的结构化程序设计。80 年代的第二次源于扩展复杂:业务多变,结构化方法无力应对软件如何扩展,面向对象随之流行。一种方法论通常只能解决它诞生时针对的那类复杂度,不能指望它包治其他问题。 进一步展开见两次软件危机不同源。

“模块”“对象”“组件”这三个在不同年代先后诞生的概念,本质上做的是同一件事——把规模已经超出人脑单次能掌握范围的软件系统拆解成更小的单元,差别只在于拆分的粒度和层次随着软件复杂度的增长而不断变粗、变高。20世纪60年代第一次软件危机催生了结构化编程,创造出”模块”概念,用来把一段复杂的执行逻辑拆成一个个自顶向下、逐步细化的功能单元;20世纪80年代第二次软件危机催生了面向对象编程,创造出”对象”概念,把数据和行为封装到一起、按业务实体来组织代码,拆分的层次比单纯的逻辑模块更高一级;20世纪90年代,由于Rational和Microsoft内部的相关活动,”软件架构”开始流行,创造出”组件”概念,把系统拆成可以独立部署、独立复用的物理单元,拆分层次又比对象更高一级。作者据此认为软件架构的出现有其历史必然性,并假设:《人月神话》里1964年开发的IBM 360系统若放在20世纪90年代开发,质量、效率、成本都会好得多——当时结构化编程都还没被提出。 进一步展开见架构诞生的必然性。

此前的方法论都是为应对全行业共同的危机而生,软件架构不同:1994 年玛丽·肖与戴维·加兰指出,系统由许多部分组成时,“如何组织整个系统”本身会产生一类新的设计问题,且规模越大越突出。所以架构最早在大公司内部流行,只有大系统才会遇到耦合严重、牵一发动全身、难以排查的问题。判断一个系统要不要认真做架构,先问规模是否已大到组织方式本身成为难题,而不是技术栈够不够新。 进一步展开见架构源于系统规模。

原书依据 · 4 处

架构设计的目的

在真正理解”为什么要做架构设计”之前,实践中常见四种似是而非的回答,每一种看起来都有道理,但细究起来都站不住脚。第一种是”因为架构很重要,所以要做架构设计”——这是一句正确的废话,很多创业公司初期产品根本没有正规架构设计过程,撸起袖子就开始编码,上线运行反而更快更稳,说明”不做架构设计系统就跑不起来”这个隐含前提本身不成立。第二种是”不是每个系统都要做架构设计吗”——这是知其然不知其所以然,很容易让架构师走上生搬硬套业界其他公司现成架构的歧路,一旦强行引入水土不服的架构,最后往往不得不削足适履、不断重构甚至推倒重来。第三种是”公司流程要求系统开发过程中必须有架构设计”——这是舍本逐末,因为流程规定、或者”架构师总要做点事情”而做架构设计,会导致本来不需要架构设计的需求也走一遍形式,白白浪费时间拖慢进度。第四种也是最危险的一种,是”为了高性能、高可用、可扩展,所以要做架构设计”——持这种观点的架构师往往不管什么系统、什么业务,上来就要求”高性能、高可用、高扩展”面面俱到,结果架构设计复杂无比、项目落地遥遥无期、团队天天为方案吵架,费尽力气上线后却依然运行不稳定、出问题难解决、加个功能要改一个月。这四个误区共同的问题是:都没有回答”架构设计到底在解决什么具体问题”这个根本问题,只是拿”重要”“大家都做”“流程要求”“追求高指标”这类外部理由来搪塞。 进一步展开见架构设计四个误区。

架构设计的主要目的是解决软件系统复杂度带来的问题。新手不必把高性能、高可用、高扩展逐一做一遍,先识别复杂度在哪里再针对性设计;参考业界方案时,看它解决的复杂点与自己是否相似。老手可借此避免贪大求全:复杂度不在性能,追求 TPS 十万就没意义;照搬淘宝架构是复制别人的问题。学生管理系统逐项排查后,只有存储可靠性值得投入,其余用简单方案即可。 进一步展开见架构为解决复杂度。

原书依据 · 4 处

复杂度来源:高性能

新技术不一定带来复杂度,关键看它与旧技术的关系。若是彻底替代,如存储从纸带到磁带、磁盘再到 SSD,直接用新技术即可,不增加复杂度。若开辟了新领域却不能取代旧技术,设计时就必须在并存方案间选择或组合,这个决策本身就是复杂度来源——汽车没有让火车消失,出行就要权衡价格、时间与舒适度。评估新技术时先问是替代还是并存,并存关系的技术光是取舍就会增加设计负担。 进一步展开见并存技术才增加复杂度。

操作系统里”进程”“线程”这些概念不是一次性设计出来的,而是沿着一条”发现瓶颈→设计新机制解决→新机制又暴露新瓶颈”的链条逐步演进出来的,理解这条链条能帮助判断为什么某个并发机制会长这个样子。最早的计算机没有操作系统,靠用户手工输入指令、计算机执行,大部分时间计算机都在等人输入,效率很低。批处理操作系统解决了这个问题:预先把指令写成一份”任务”清单交给计算机连续执行,不再需要人工干预,但代价是一次只能执行一个任务,如果某个任务在等待I/O设备读取数据,CPU本该空闲那段时间完全被浪费掉。为了利用这段空闲时间,”进程”被发明出来:每个任务对应一个独立的进程、有自己独立的内存空间,操作系统靠给CPU分时间片的方式在多个进程之间切换,看起来像是多进程并行运行。但多进程天生互不相关,如果两个任务需要协作,只能通过慢吞吞的”A写存储、B读存储”方式交互,于是管道、消息队列、信号量、共享存储这些进程间通信机制被设计出来,解决进程之间没法直接沟通的问题。多进程解决了任务之间并行的问题,但单个进程内部依然只能串行处理——比如一个餐馆管理进程里,排位、点菜、买单这些子任务如果严格串行,某个客人买单卡壳(比如信用卡刷不出来)会拖住后面所有客人的点菜。为了让进程内部的子任务也能并行,”线程”被发明出来:线程是进程内部共享同一份数据的子任务,操作系统调度的最小单位从进程下沉到了线程,进程转而变成资源分配的最小单位;但多个线程共享数据又带来了新问题——数据可能被同时修改而出错,于是互斥锁机制被设计出来保证数据正确性。多进程多线程本质上仍是分时系统、并非真正的时间并行,要做到真正的多任务同时执行,最终要靠让多个CPU同时工作,这就是SMP(对称多处理器,即今天常见的多核处理器)、NUMA、MPP这几种真正硬件级并行方案存在的原因。 进一步展开见进程与线程演进链。

当单机性能撑不住业务量时,最直观的思路是”加机器”,但从1台服务器变成2台服务器这一步,架构复杂度就已经明显跳升了,而且这种复杂度会随着继续加机器而持续累积、并非线性增长。从1台到2台时,首先要新增一个任务分配器(可能是硬件网络设备如F5/交换机,也可能是软件负载均衡如LVS、Nginx、HAProxy,或者自研系统),选择合适的任务分配器本身就要综合权衡性能、成本、可维护性、可用性;其次任务分配器和业务服务器之间要建立连接并管理连接(连接建立、连接检测、连接中断后如何处理);最后任务分配器要决定用什么分配算法(轮询、按权重、还是按负载分配,按负载分配又要求业务服务器能主动上报自己的状态)。假设单台服务器每秒能处理5000次请求,理论上2台能撑到10000次(实际打8折约8000次),但如果业务量继续增长到每秒10万次这个量级,单纯堆业务服务器数量到25台并不够——因为随着业务服务器数量增加,任务分配器自己会先撑不住变成新的瓶颈,这时任务分配器本身也要从1台扩展成多台。这一步带来的复杂度比”1台任务分配器连多台业务服务器”更复杂:多台任务分配器意味着要先把不同用户分配到不同的任务分配器上(常见手段有DNS轮询、智能DNS、CDN、GSLB全局负载均衡),任务分配器和业务服务器之间的连接关系也从简单的”一对多”变成了”多对多”的网状结构,机器数量、状态管理、故障处理的复杂度都随之大幅上升。这个演进过程说明:”加机器”不只是简单把原有架构复制几份,规模每上一个台阶都可能带来新的结构性复杂度。 进一步展开见任务分配的复杂度递增。

单纯靠加机器(任务分配)来扩展性能,收益会随着业务复杂度上升而递减——业务简单时1台扩到10台可能提升8倍性能,业务复杂后1台扩到10台可能只提升5倍,因为单台机器处理复杂业务的效率本身在下降。这时需要用另一种手段:任务分解,把一个大一统的复杂业务系统拆成多个更小、更简单的子系统(如微信后台拆成接入、注册登录、消息、LBS、摇一摇、漂流瓶等子系统)。任务分解本身既不减少功能也不减少代码量(甚至可能因为要新增系统间接口调用而增加代码量),它能提升性能靠的是两个机制:一是简单的系统更容易做到高性能——功能越简单,影响性能的变量就越少,越容易精确定位并优化关键性能点;系统一旦复杂,不但难以找到真正的瓶颈,即使找到了修改起来也容易顾此失彼(提升了A点性能却意外拖累了B点)。二是可以针对单个任务做独立扩展——拆开之后哪个子系统先出现性能瓶颈,只需要优化或加机器给这一个子系统,其余子系统完全不用动,风险比改动整个系统小得多。但任务分解不是拆得越细越好:系统间调用要走网络,比系统内部函数调用慢得多,而完成一次用户请求所需要跨系统调用的次数会随着拆分粒度变细而急剧增加——拆成2个子系统只需要1次系统间请求,拆成4个子系统涨到3次,如果拆到100个子系统会暴增到99次。按一次网络请求耗时1毫秒、业务处理本身耗时50毫秒来估算,2个子系统处理一次用户访问总耗时约51毫秒,而100个子系统会飙升到149毫秒——业务处理性能本身是有上限的,任务分解能让实际性能逼近这个上限,但无法突破它,过度拆分反而会被暴涨的网络调用次数拖累,把原本该省下来的时间又搭进去。因此任务分解带来的性能收益是有一个合理粒度区间的,架构设计的关键功夫,就在于判断这个粒度该切在哪里。 进一步展开见任务分解的收益与上限。

多进程、多线程、进程间通信、多线程并发这些技术,不是越新越好,也不必只选一种,要结合业务判断和组合。同样实现了高性能,Nginx 可多进程也可多线程,JBoss 用多线程,Redis 是单进程,Memcache 是多线程,内部实现差异很大。所以单机高性能的复杂度不只在技术本身,更在选择和组合的判断上。发散:选并发模型看负载特征,不看技术新旧。参见进程与线程演进链。 进一步展开见单机并发模型无标准答案。

原书依据 · 10 处

复杂度来源:高可用

高可用要求系统无中断地运行,但硬件会坏、软件有 bug、断电地震不可预测,绝对不中断做不到,所以方案几乎都归结为冗余:两台机器、两个机房、多条线路。形式上与高性能“加机器”相同,目的却不同:高性能加机器是扩展处理能力,总吞吐随机器增加;高可用加机器是冗余处理单元,平时不多扛负载,只在故障时顶上。同样是加机器,前者问能撑多大量,后者问坏一个后还能否正常运转。 进一步展开见高可用靠冗余。

高可用问题在”计算”和”存储”这两类场景里的难度天差地别,根源在于两者能不能被”随意搬到另一台机器”这件事上有本质区别。计算指业务的逻辑处理,它有一个关键特点:同样的算法配上同样的输入数据,不管在哪台机器上跑,产出的结果都完全一样,因此把计算从一台机器迁移到另一台机器,对业务不会造成任何影响——计算高可用的复杂度大体上就等同于此前讲高性能时”单机变双机”的复杂度(新增任务分配器、连接管理、分配算法),并不会额外引入新的难题。存储则完全不同:数据要从一台机器搬到另一台机器,必须经过线路传输,传输本身需要时间——同机房内部是几毫秒级别,跨机房则是几十到上百毫秒(比如广州到北京稳定情况下ping延时约50ms,不稳定时可能到1秒以上),而且传输线路本身还可能中断、拥塞、错包丢包,故障时间短则十几分钟、长则数小时(如支付宝2015年光缆被挖断导致业务受影响超过4小时)。这意味着系统在某个时间点上,数据几乎必然是不一致的——按照”数据+逻辑=业务”这个公式,数据不一致,即使逻辑完全一样,最终业务表现出来的结果也会不同:如果用户存了1万块钱的写入还没同步到另一个机房,用户恰好被路由到那个机房查询,就会看到余额没有增加,第一反应很可能是怀疑钱被盗。因此存储高可用真正的难点,从来不是”怎么把数据备份出去”这个技术动作本身,而是”怎么减少或规避数据不一致给业务带来的负面影响”这个更根本的问题——分布式领域的CAP定理正是从理论上证明了这一点:一致性、可用性、分区容错性三者不可能同时满足,架构设计必须结合具体业务在其中做取舍。 进一步展开见计算与存储高可用差异。

无论是计算高可用还是存储高可用,都要先解决同一个基础问题:系统怎么判断当前状态是正常还是异常,判断错了,后面的任何补救行动都没有意义。但这里存在一个本质矛盾:恰恰是靠冗余实现的高可用系统,状态决策本身不可能做到完全正确,三种常见决策方式各自的缺陷都源于这个矛盾。独裁式决策由一个独立的”决策者”收集所有冗余节点上报的信息、统一做判断,好处是不会出现决策混乱(只有一个声音),但决策者本身就成了新的单点——它自己故障时整个系统就失去了准确判断状态的能力,而如果给决策者本身也搞一套高可用状态决策,就陷入了”由谁来判断这个判断者是否正常”的递归死循环。协商式决策靠两个独立个体交换信息后按规则决策,最常见的形式是主备决策:两台机器都从备机启动,建立连接、交换状态,某一台被推举为主机、另一台继续做备机。这套架构简单,难点全在”信息交换出问题”这一刻怎么办——如果主备之间的连接中断,备机要不要认为主机已经故障:认为故障就升级为主机,但主机其实没坏,系统就凭空多出两个主机;不认为故障就继续当备机,但如果主机这次真的坏了,系统就彻底没有主机了。加更多条连接(双连接、三连接)能降低误判概率,但降不到零,还会引入新问题——多条连接传回的信息不一致时该信谁的,这本身也是无解的。民主式决策靠多个独立个体投票、按”多数取胜”确定状态(原文举ZooKeeper选主“Paxos”,实际ZooKeeper用的是ZAB,书中第26讲亦写作ZAB),比协商式更复杂难懂,还有一个协商式没有的固有缺陷:脑裂——当集群因为连接中断被分割成两个互相看不见对方的子集群时,每个子集群会各自独立选出一个主节点,导致系统同时存在两个主节点、状态陷入混乱。应对脑裂的常规做法是要求”参与投票的节点数必须超过系统总节点数的一半”,未达到半数的子集群不进行选举——这确实能防止脑裂,但代价是降低了整体可用性:如果真的是过半节点故障(而非网络分区导致的脑裂),系统同样会因为凑不够半数投票节点而选不出主节点,即使剩下的少数节点本身完全健康,系统也等同于宕机了。三种方式没有一种能在所有场景下都不出问题,选哪种本身也是一个需要结合具体业务权衡的复杂判断。 进一步展开见高可用状态决策三方式。

原书依据 · 7 处

复杂度来源:可扩展性

可扩展性要求新需求出现时少改甚至不改就能支持,前提是两个独立条件:正确预测变化、完美封装变化。预测再准,封装方案选错照样难扩展;封装再灵活,没预测到真正的变化也用不上。务实做法是列出可能性大的变化点,按发生概率、影响时长和改造成本评估,代价高且预测不确定的就先不做,等需求真的出现再重构。与其追求无懈可击的灵活性,适度冗余往往能大幅降低方案复杂度。 进一步展开见可扩展需预测并封装变化。

“正确预测变化”本身就充满悖论:设计点成百上千,逐一预测未来变化成本高得难以承受,而且所有预测都可能出错;完全不考虑变化,遇到新需求又要推倒重来;即便认真预测,设计者也不是先知,“预测的没发生、没预测的发生了”都会真实出现。所以可扩展性设计不是能完美解答的题,而是在预测覆盖面与预测成本之间持续权衡。 进一步展开见预测变化的三重难题。

即使正确预测出了变化,还要靠”完美封装变化”才能真正获得可扩展性,业界应对这个问题主要有两类常见模式,各自把新的复杂度转移到了不同的地方。第一类是变化层与稳定层分离:把系统拆成一个不容易变的”稳定层”和一个专门用来兼容各种可能变化的”变化层”,两层之间通过接口连接——典型例子是数据库访问:业务逻辑(稳定层)不直接依赖某个具体数据库的语法,而是通过一层封装的数据访问接口去操作,当底层数据库从MySQL换成Oracle时,只需替换变化层的实现,不用动稳定层的业务代码;但这种做法的复杂度也真实存在,一是怎么判断某个设计点该分到哪一层,本身就没有标准答案;二是两层之间接口怎么设计才能既通用又不过度抽象,是一个需要经验判断的难题,例如同样是”插入并更新已存在记录”这个功能,MySQL用REPLACE INTO语法、Oracle却用MERGE INTO语法,接口设计必须能屏蔽掉这类具体差异。第二类是抽象层与实现层分离,常见落地形式是设计模式,例如装饰者模式(Decorator Pattern):先抽象出一个”组件”(Component)的通用接口,再让”装饰者”(Decorator)持有一个组件并在其基础上叠加新的行为,从而在不修改已有类的前提下动态扩展功能。这类方案的代价在于:抽象层与实现层之间的调用关系、类的角色划分一旦确定下来,就变成了这套方案的固定骨架,后续很难轻易修改——为了获得灵活性,反而要先设计出一套本身并不简单的类结构,把”一个简单的类”拆成了”多个互相配合的类”,这本身就是新增的设计与理解成本。 进一步展开见应对变化的两种方案。

原书依据 · 5 处

复杂度来源:低成本、安全、规模

低成本很少是首要目标,因为它与高性能、高可用天然冲突:后两者靠堆服务器,低成本要求用更少的服务器。实践中它是附加约束:先按性能与可用性设计方案,再用成本目标检验,不达标就返工;怎么也达不到,说明目标本身不合理。低成本带来的复杂度在于往往只能靠创新:引入 NoSQL、搜索引擎、Hadoop 等新技术,难在吃透并整合;自创新技术门槛更高,通常只有资源充裕的大公司才走得通。 进一步展开见低成本是附加约束。

安全带来的复杂度可以拆成两类性质完全不同的问题。功能安全对应的是XSS攻击、CSRF攻击、SQL注入、密码破解这类利用系统实现漏洞潜入的手法,本质上是”防小偷”:黑客像小偷一样找系统或代码里不完善的缝隙钻进去,破坏或窃取。它和具体编码强相关、和架构本身关系不大,虽然现在很多开发框架已经内置了常见防护,能省掉大量重复的安全开发工作,但框架只能覆盖已知的常见漏洞类型,无法预知尚未出现的新问题,框架本身也可能有漏洞(如Apache Struts2多次爆出远程代码执行高危漏洞)——功能安全因此注定是一个只能靠”攻防对抗”逐步完善、永远无法在设计阶段一劳永逸解决的持续过程。架构安全对应的则是”防强盗”:强盗不是悄悄潜入,而是直接砸门炸墙搞破坏,对系统的冲击也大得多,互联网时代全球任何地方都可能发起这种攻击。传统应对手段是防火墙,通过划分网络区域、制定跨区域访问控制策略来隔离风险,在传统银行、企业内网场景应用广泛;但防火墙的性能瓶颈使它在互联网领域并不适用——面对海量并发和DDoS攻击(历史上已出现665Gbps级别的攻击带宽),靠堆防火墙硬扛成本极高(一台中高端防火墙约10万元、抗25GB流量,扛住这种攻击级别就需要近30台、近300万元投入,且大部分时间闲置无用),更关键的是DDoS真正打垮的是机房出口总带宽——带宽一旦被占满,用户的正常请求根本进不来,防火墙再强也保护不了”进不来”这件事。所以互联网系统的架构安全目前没有很好的自研设计手段,更多只能依赖运营商或云服务商的带宽储备与流量清洗能力,较少由业务系统自己实现。 进一步展开见防小偷与防强盗。

没有高性能、高可用要求的系统也可能极其复杂,根源在规模。功能两两相关时,复杂度约为功能数加连接数:3 个功能是 3+3=6,8 个功能是 8+28=36,功能不到 3 倍,复杂度涨了 6 倍。数据规模同理:达到大数据量级时传统工具整体失效,GFS、Bigtable、MapReduce 由此诞生;MySQL 单表过大时加索引、改表结构要停机数小时。分表能缓解,却又引入拆分规则和跨表查询等新问题,复杂度只是转移了位置。 进一步展开见规模复杂度是量变质变。

原书依据 · 7 处

架构设计三原则

程序员与架构师之间的鸿沟在于不确定性。编程不允许不确定:同一段代码结果是确定的,有 bug 也是确定地出错。架构设计本质上不确定:不同公司为同一系统做出差异很大的架构,都能正常运行;选最先进的技术还是最熟悉的技术,选 MySQL 还是 MongoDB,没有语法式的硬约束。所以架构原则不是给出唯一答案的规则,而是在不确定中提供判断方向的经验,合适、简单、演化三原则正是如此。 进一步展开见架构是应对不确定性。

架构设计中最常见的一类误区,是把”达到甚至超越业界领先水平”当成方案本身的追求目标——这背后往往是技术人员想通过对标Google、阿里这类标杆来证明自己优秀的心态,但现实是这类照搬照抄式的雄心壮志大多以失败告终,根源可以归纳为三点。第一,”将军难打无兵之仗”:业界领先方案背后往往是几十上百人的专职团队长期投入的结果,而大多数团队只有十几人却妄图完成几十人团队的工作量并且做得更好,人力资源上的差距决定了这条路很难走通。第二,”罗马不是一天建成的”:业界领先方案不是一蹴而就的产物,而是经过数年实战积累、踩坑纠错才逐步成熟的(如阿里中间件团队从2008年成立到具备抗住”双11”的能力,用了十年),单靠短期的头脑风暴和拍脑袋设计,不可能替代真实业务场景下多年积累出来的经验。第三,”冰山下面才是关键”:业界领先方案的诞生,多数不是天才灵光一现的产物,而是被业务规模”逼”出来的——量变导致质变,旧方案撑不住了才倒逼出新方案(例如GFS诞生在Google而非Microsoft,关键因素是Google当时已经积累的海量数据规模,而非工程师更聪明);没有那种量级的真实业务场景,单纯想靠灵感复刻同等水平的方案是不现实的。三点合起来说明:真正优秀的架构,是在企业当前的人力、资源、业务约束条件下设计出来的、能快速落地并发挥最大效用的方案,而不是脱离约束条件、单纯对标业界最先进水平的方案——这也是不少大公司出身的架构师换到小公司或创业团队后反而做不出成绩的常见原因,脱离了原有的平台和资源积累,生搬硬套只会大概率失败。 进一步展开见合适原则。

简单原则宣言”简单优于复杂”,其中结构的复杂性专指组件数量更多、组件之间关系也更复杂这两个特征叠加带来的问题,具体表现为三重代价。第一重代价是可用性随组件数量增加而衰减,且衰减幅度比直觉预期更明显:假设每个组件的故障率是10%(即10%的时间不可用),3个组件串联的系统整体可用性是(1-10%)³=72.9%,5个组件则是(1-10%)⁵≈59%,仅仅多了2个组件,可用性就下降了约13个百分点——因为整体可用性是各组件可用性的乘积,组件越多,”没有任何一个组件出故障”的概率越低。第二重代价是改动的影响会沿组件间的依赖关系递归扩散:某个组件被修改或出现异常,会波及所有和它有直接关联的组件,被波及的组件又会继续影响与它们相关联的组件,一旦变更涉及外部系统,就需要多方协调评估、协调资源、协调上线,直接拖慢整体开发效率。第三重代价是故障定位的难度随组件数量和关系复杂度同步上升:组件越多,每个组件都有嫌疑,需要逐一排查;组件间关系越复杂,表现出故障症状的组件往往并不是真正的问题根源,容易在排查过程中被误导。这三重代价共同说明,架构设计不是”组件越多、结构越精细就越先进”,如果简单方案和复杂方案都能满足业务需求,应该优先选择组件更少、结构更简单的那一个。 进一步展开见结构复杂性的三重代价。

想靠减少组件来避免结构复杂性,走到极端就是把所有功能塞进一个组件,单个组件的逻辑复杂性随之暴涨:代码庞大、多人改同一份代码、分支难合并、频繁重启、排障要几十人上阵。复杂电路代表强大,复杂软件却是问题,因为电路定型后不再变,软件却要持续修改,复杂性在整个生命周期反复放大。另一种形态是算法复杂:ZooKeeper 用 ZAB 实现选举复杂度高,etcd 用更易理解的 Raft 则更低。 进一步展开见逻辑复杂性的两种形态。

演化原则宣言”演化优于一步到位”,其立论起点是拆穿一个字面类比制造的假象:软件架构在描述结构、模块、关系这个层面确实和建筑架构相似(软件架构描述系统的模块及其关系,建筑架构描述建筑的部件及其组成方式),但这层字面相似掩盖了一个本质差异——建筑一旦建成(甚至一旦开工)就基本定型不再变化(古埃及金字塔4000多年后仍是当初的架构,明长城600多年后结构未变,美国白宫200年来只做局部扩建,整体结构不变),而软件却必须随业务发展持续变化(对比Windows 1.0与Windows 8、Android 1.6与Android 6.0,前后已经是截然不同的系统)。也就是说,对建筑而言”永恒”是主题,对软件而言”变化”才是主题——即便设计Windows和Android的都是顶尖天才,也不可能在早期版本里就把后期版本的架构设计出来。没有把握住这个本质区别,架构设计就容易陷入”试图一步到位、期望架构不管业务怎么变都稳如磐石”的误区,为此要么照搬业界大公司已公开的方案,要么投入巨大资源做各种预测分析——但这类做法通常投入巨大、落地遥遥无期,即使拼死拼活落了地,事后往往还会发现当初的大量预测和分析根本不靠谱。正确的类比对象其实是生物演化:生物先适应当时的环境,通过繁殖把有利基因传下去、淘汰不利基因,环境变化时能快速调整适应,调整不了的就被淘汰,而新生物会继承旧生物的部分基因;软件架构同理,应该先满足当下的业务需要,在实际运行中不断迭代(保留优秀设计、修复缺陷设计、去掉无用设计),业务发生变化时架构随之扩展、重构甚至重写,代码可能重写,但有价值的经验、教训、逻辑和设计会像基因一样在新架构里延续下去。即使是资源充裕的大公司团队,设计新系统时同样要遵循这个原则,而不是仗着人多资源多就想一步做到位——业务的发展和变化速度,从来不是任何团队能够完美预测的。 进一步展开见演化原则。

原书依据 · 13 处

架构设计原则案例

淘宝早期两次升级都靠“买”:先买轻量网站快速上线,MySQL 撑不住后换 Oracle 加 NAS。这不是不懂技术,而是快速验证阶段“够快、够省事”就是最合适的选择。转折出现在 PHP 切换到 Java:连接池代理频繁死锁已影响用户,只能靠重构解决。此后分库、引入 Spring、加缓存和 CDN,源于量变引发质变,买硬件已无法覆盖。该买还是该重构,看的是“原方案有固有缺陷、量变已成质变”的信号是否出现。 进一步展开见淘宝从买到重构的转换。

手机 QQ 后台按在线规模经历十万、百万、千万、亿级四个阶段。前三次升级面对的都是可量化的资源瓶颈,如单台接入服务器存不下所有在线用户,解法是渐进改造。到亿级,问题变成架构灵活性跟不上:昵称长度增加一半要两个月,好友上限从 500 提到 1000 要三个月,还支撑不了隐私控制、多端互踢、异地容灾等新功能,只能重新设计出 IM 4.0。演化不一定是小步快跑,结构性缺陷出现时需要彻底重写。 进一步展开见手机QQ亿级推倒重来。

原书依据 · 6 处

架构设计流程:识别复杂度

架构设计第一步是识别复杂度,判断错了,方案越精美越南辕北辙:真正问题是业务耦合,却做出 TPS 五万的高性能架构。不要预设必须同时满足高性能、高可用、可扩展,多数场景只集中在一个维度;确有多个时要排优先级逐个解决。某“亿级用户平台”一开始对标 QQ 做了 40 多个子系统,运维与协作困难、实际 TPS 不到目标百分之一,接手团队先把子系统合并到 20 个以内,再叠加异地多活。 进一步展开见先识别复杂度。

经验不足时可逐个维度定量排查复杂度。性能要换算成每秒峰值:前浪微博每天 1000 万条消息、每条被读 10 次,平均写入约 115 条/秒、读取约 1150 条/秒,取峰值约为平均的 3 倍,再按业务增速预留余量(本例 4 倍,一般不超过 10 倍,切忌一上来按 100 倍),得出 TPS 1380、QPS 13800。可用性看出问题的后果:审核子系统丢消息可能违法,需要高可用。可扩展性看功能是否会变,消息队列功能边界明确,不是重点。 进一步展开见排查法识别复杂度。

按优先级逐个解决复杂度,常被担心先落地的方案会被后面推倒。作者认为现实中几乎不会:软件可塑易变,同一问题总有多个方案,总能挑出综合来看性价比最高的那个。真要推倒重来,新方案必须把已解决的复杂度一并解决,通常要靠新技术,如 Hadoop 同时解决高可用、高性能、大容量。经验不足时用“排查法”逐个维度分析。发散:不必为避免返工而一次全做。参见先识别复杂度。 进一步展开见逐个解决不致推倒重来。

判断一个性能指标高不高,靠的是对常见系统性能量级的熟悉。作者在留言区给出的参考(2018 年):Nginx 负载均衡约 3 万,Memcache 读取约 5 万,Kafka 号称百万级,ZooKeeper 读写 2 万以上,HTTP 请求约 2 万。具体数值随机器配置和测试用例变化,但量级不会差太多;业务系统差异大,还要靠自己压测建立基线。发散:量级要随硬件更新定期校准。参见排查法识别复杂度。 进一步展开见性能量级要烂熟于心。

原书依据 · 8 处

架构设计流程:设计备选方案

架构设计本质上不是凭空发明,而是对已经过时间检验的成熟技术模式(高可用的主备/集群方案、高性能的负载均衡/多路复用、可扩展的分层/插件化等)进行挑选组合和调整,只有在成熟方式完全无法满足需求时才需要真正创新,而创新本身多数情况下也是建立在已有技术之上的(如NoSQL本质是把数据库索引独立成缓存系统,Hadoop的基础是集群方案+数据复制方案)。正因为可选模式和组合方式非常多,”如何设计最终方案”这一步反而是架构师最容易犯错的地方,常见错误集中在三种。第一种是执着于设计”最优秀”的方案:出于证明自己技术能力的心理,倾向于选集群方案而非主备方案、选业界领先方案而非够用方案,这违背了合适原则——挑选适合自身业务、团队、技术能力的方案才是好方案,否则要么浪费大量资源做出没人用得起来的系统(如TPS 50000设计目标实际只跑出500的”亿级用户平台”案例),要么方案本身根本不可能落地(如10人团队想再造一个淘宝)。第二种是只做一个方案:仅凭简单的心理评估就锁定一个方案直接进入详细设计,弊端有三层——评估过于简单,容易因为某个局部缺点就否决掉综合来看其实最好的方案;架构师个人的经验和知识天然有局限,某条评估标准本身可能就是错的或已经过时;单一方案在评审时容易演变成”过度辩护”,评审焦点从”这个方案好不好”变成”架构师能不能自圆其说”。第三种是备选方案写得过于详细:把备选方案直接当成最终方案来精雕细琢,代价是耗费大量时间精力、注意力被拖进细节导致备选数量不够或差异不明显、评审时容易被参数级的争论(比如某个定时器该设1分钟还是30秒)带偏方向。这三种错误共同指向一个正确姿势:备选阶段应该聚焦在技术选型层面的差异(如ZooKeeper主备决策和Keepalived主备决策,差异就足够大),细节留到最终方案阶段再收敛,不需要在备选阶段就纠结。 进一步展开见备选方案三种常见错误。

设计备选方案有三条准则:数量以 3 到 5 个为宜,少于 3 个说明思考不够开阔,多于 5 个耗时且差别不明显;方案之间的差异要在架构层面,主备与集群是架构差异,都用 ZooKeeper 做主备只是检测周期不同则只是参数细节;技术范围不能局限于自己熟悉的技术,熟悉 MySQL 的人性能不够就想分库分表,其实加一层缓存也许就够了。团队技术背景会天然收窄可选范围,这也是合适原则的自然体现。 进一步展开见备选方案三条准则。

承接排查法识别复杂度中识别出的四点复杂度(高性能消息读取、高可用消息写入/存储/读取),”前浪微博”案例给出了三个备选方案,展示了备选方案设计三条准则的具体落地。方案一是直接采用开源的Kafka:Kafka本身功能强大、性能高、已被大公司广泛验证,是最省事、复用成熟方案的路线。方案二是”集群+MySQL存储”自建方案:单机高性能部分选择基于Netty(Java领域成熟的高性能网络库)自研,因为团队是Java背景,架构师判断没有必要为了语言性能优势让整个团队切换语言栈;由于单机QPS撑不住设计目标的13800,改用集群+轮询负载均衡来分摊压力;这个方案里最复杂的两块是”高可用存储”和”高可用读取”,架构师借助MySQL现成的主备复制能力来实现——集群按分组组织,每组一台主MySQL、一台备MySQL,组内主备数据复制、组间数据不同步,正常情况下主服务器对外提供读写服务,主服务器宕机时备服务器接管读服务。方案三是”集群+自研存储”:在方案二的基础上,把MySQL替换为参照Kafka思路自研的文件存储和复制方案,因为关系型数据库的特性和消息队列的数据特点本来就不太契合。三个方案的技术选型差异清晰可辨(开源直接用 vs 自建于关系型数据库之上 vs 自研专属存储引擎),但方案二和方案三在”单机高性能”这一层都收敛到了同一套基于Netty+Java的实现,恰恰印证了备选方案准则里”团队的技术背景会天然收窄备选范围”这一点——差异应该出现在真正有技术选型价值的地方(存储与复制机制),而不是被迫在团队根本不会用的语言/框架上硬造差异。 进一步展开见消息队列备选方案对比。

原书依据 · 11 处

架构设计流程:评估和选择备选方案

备选方案设计完成后,挑选哪个方案往往比设计备选方案本身更棘手,原因在于:每个方案都是可行的(不可行的方案本就不该进入候选名单);没有哪个方案是完美的(A方案有性能短板、B方案有成本短板、C方案有新技术不成熟的风险);评价标准本身主观性很强(”复杂”这类词很难量化,不同设计师对同一个方案的判断经常直接冲突)。正因如此,实践中常见四种朴素的挑选思路。”最简派”直接挑看起来最简单的方案(如全文搜索用MySQL而非Elasticsearch,图省去索引设计和分布式的麻烦);”最牛派”正相反,倾向挑技术上最强大、最先进的方案(如缓存选功能更全的Redis而非更简单的Memcache,仅因为”看起来更好”);”最熟派”基于个人过往经验挑自己最擅长的技术(如C++背景的开发者做运维系统时继续用C++,即使Python/Ruby可能更合适);”领导派”则是把决策权直接交给领导,方案选对了是领导英明,选错了也是领导背锅,设计师本人不承担判断责任。这四种思路本身没有绝对的对错——有时候确实该选最简单的方案,有时候确实该选最优秀的方案,有时候确实该选团队最熟悉的技术,甚至有时候真的适合领导拍板;它们共同的缺陷是缺少一套系统的判断标准来回答”这次到底该用哪一种思路”,全凭直觉或个人偏好决定,容易在评审时演变成各说各话的争论。 进一步展开见四种方案挑选思路。

挑选方案可用“360 度环评”:列出性能、可用性、硬件成本、项目投入、复杂度、安全性、可扩展性等质量属性,逐一评估各方案。关键是每个维度都遵循合适与简单原则,满足一段时期的业务即可:当前 TPS 1000、预计一年翻倍,及格线就是 2000,而不是对标淘宝。业务若意外暴涨,按演化原则重新设计,届时资源也会跟上。经验法则是按当前规模的 2 到 4 倍设计,基数低取大、基数高取小。 进一步展开见360度环评法。

完成360度环评法之后,会得到一张列出各方案在不同质量属性维度上优劣的环评表,但这张表本身并不会直接告诉你选哪个——因为几乎不会出现某个方案在所有维度上都最优的情况(开源方案工作量小但可运维性和可扩展性差,自研工作量大但可运维可维护性好,C语言性能高但团队技术积累少,Java技术积累多但性能不如C语言……),这时候容易掉进两种看似合理实则有问题的选择方法。第一种是”数量对比法”:单纯数哪个方案占优的维度更多就选哪个(比如5个维度里A方案占优3个、B方案占优2个,就选A)——这个方法的根本问题是把所有质量属性的重要性视为等同,忽略了优先级差异(对BAT这类公司,成本几乎不是问题,可用性和可扩展性远比成本重要;但对创业公司,成本可能才是关键),而且遇到两个方案优点数量打平时会彻底失效,若为了打破平局强行再加一个不重要的维度进去对比,这个临时凑数的维度反而成了决定胜负的关键,本质上还是没解决”优先级”这个根本问题。第二种是”加权法”:给每个质量属性打权重分(比如性能高中低对应10/5/3分,成本高中低对应5/3/1分),累加各方案的加权总分选最高的——问题在于权重分本身缺乏客观标准(为什么性能是10/5/3而不是5/3/1或100/80/60),容易沦为设计师为了让心仪方案胜出而反向调整权重的”数字游戏”。正确的做法是”按优先级选择”:架构师综合当前业务发展阶段、团队规模与技能、未来业务预测等因素,把质量属性按优先级排出先后顺序,先看谁能满足第一优先级,都满足再看第二优先级,依此类推——这个方法之所以在实践中很少卡在”多个方案完全打平”的困境,是因为在设计备选方案阶段就已经要求方案之间的差异必须足够明显,差异明显的方案天然不太可能在每个维度上都表现得一模一样。 进一步展开见按优先级选定方案。

前浪微博消息队列评审时,四方意见分歧:Kafka 成熟省事,但运维没有 Scala 经验,且它面向日志而非可靠的业务消息;集群加 MySQL 能融入现有运维体系,却被嫌性能不够、技术不够亮眼;自研存储最显技术实力,但运维有丢数据的前车之鉴。架构师选了 MySQL 方案:按合适原则排除 Kafka,按简单原则排除自研,用演化原则回应性能顾虑。同样三个方案,换一个团队可能选出完全不同的结果。 进一步展开见消息队列选型的决策。

理想方案是只靠加机器跟上增长,现实是量变会引起难以预判的质变。5 个人做的系统撑到 TPS 20000 时,团队已有 20 人,同一系统上开发效率很低,需要拆子系统;单机房也要升级为异地多活。提前为这些设计也不行:5 个人做不完 20 个人的架构,业务等不起。这正是按 2~4 倍预估、到时再重构的理由。发散:容量能平滑扩,组织和机房结构不能。参见360度环评法。 进一步展开见平滑扩容挡不住质变。

原书依据 · 9 处

架构设计流程:详细方案设计

详细方案设计的本质是把已经选定的备选方案里涉及的关键技术细节逐一确定下来(比如确定用Elasticsearch做全文搜索后,还要定索引是按业务拆分还是用一个大索引、副本数是2个还是4个;确定用MySQL分库分表后,还要定分哪些表、按什么维度分、分完后联合查询怎么处理)。这个阶段容易和备选方案阶段混淆,因为两者看起来都是在”选技术方案”(比如Nginx负载均衡策略有轮询、加权轮询、ip_hash、fair、url_hash五种可选),但两者的决策重量级完全不同:备选方案阶段的选择要走按优先级选定方案那套完整评估流程,而详细方案设计阶段的技术点选择是很轻量级的,只需要弄清每种技术的适用场景、按业务实际需求直接匹配即可,不需要再走一遍环评。以Nginx负载均衡为例:轮询(默认策略)按时间顺序把请求依次分配到各后端服务器,后端故障时能自动剔除,适合服务器性能相近的常规场景;加权轮询在轮询基础上按权重分配请求量,适合新老服务器混用、性能不均衡的场景;ip_hash按访问IP的哈希结果把同一个访客固定分配到同一台后端服务器,用来解决session问题,典型场景是购物车类应用;fair按后端服务器的实际响应时间分配请求、响应快的优先分配,能更好地平衡各服务器压力,还能防止性能不足的服务器因持续接收同样多请求而引发雪崩;url_hash按访问URL的哈希结果做定向分配,适合后端服务器能够缓存URL响应结果的场景。这几种策略的适用边界区分很明确,只要业务需求清楚(比如电商场景和session强相关,用ip_hash比较合适),挑选起来不构成真正的决策难题。 进一步展开见详细设计的轻量选型。

详细设计时才发现方案落不了地,往往是备选阶段漏评了关键技术点或质量属性,例如某方案进入细节后才发现要开发一年,只好废弃,根源是当初没考虑开发周期。预防有三招:架构师要真正理解备选技术的关键细节,别做只懂名词、扛不住追问的“PPT 架构师”;分步骤、分阶段、分系统降低方案复杂度,减少被某个细节推翻的概率;方案确实复杂时靠设计团队集体讨论,弥补个人盲区。 进一步展开见防止详细设计推翻方案。

选定“集群加 MySQL”后,还要细化到能动手:日志表先落盘即算发布成功,后台线程再搬到每队列一张的消息表,保留 30 天;复用 MySQL 主从复制,只同步消息表;用 ZooKeeper 临时节点做主备决策,主机节点消失即由备机接管;SDK 轮询写入,出错改发下一台;服务端为每个消费者维护进度;通信用 TCP 加 ProtocolBuffer 兼顾多语言。详细设计要让每个环节都有明确答案。 进一步展开见消息队列的详细设计。

原书依据 · 8 处

高性能数据库集群:读写分离

读写分离把读和写分散到不同节点:主机负责读写,从机只负责读,主机通过复制把数据同步给从机,每台都有全量数据。“主从”与“主备”不能混用:从机像仆从一样真正分担读流量,备机通常只做数据备份、不对外服务,用哪个词要看节点是否对外提供服务。读写分离只分散了访问压力,没有分散存储压力,每台仍存全量数据,这是它与分库分表的能力边界。 进一步展开见读写分离与主从主备。

MySQL 主从复制一般延迟约 1 秒,数据量大时可达 1 分钟。写完立刻读,读请求落到从机就会读到旧数据,出现“刚注册完登录却提示未注册”。三种应对:写后紧跟的读强制走主机,与业务强绑定,新人不了解就会出错;读从机失败后再读一次主机,与业务无关、实现简单,但失败多时会压垮主机,如遇暴力破解;关键业务读写全走主机,非关键业务才读写分离。本质是在业务侵入与主机压力之间权衡。 进一步展开见复制延迟的三种应对。

读写分离的第二个设计复杂度是”分配机制”——把读写操作区分开来分别发往不同数据库服务器这件事,具体由谁来做、放在哪一层做,有两种主流路径。程序代码封装是在业务代码里抽象出一个数据访问层,由这一层负责读写分离逻辑和数据库连接管理(如基于Hibernate做简单封装,淘宝的TDDL就是这条路线上比较有名的通用开源实现)。这种方式实现相对简单、可以按业务做较多定制,但缺点也很直接:每种编程语言都要各自实现一遍,无法跨语言复用,如果一个业务系统里同时有多种编程语言开发的子系统,重复开发的工作量会明显增加;而且一旦发生主从故障切换,可能所有接入的系统都要跟着改配置、重启,牵连面比较大。中间件封装则是把读写分离和数据库连接管理独立成一套单独的系统,这个中间件对业务服务器暴露标准SQL兼容协议——在业务服务器眼里,访问中间件和直接访问数据库没有区别,中间件本身在业务侧看起来就是一台数据库服务器。这种方式的优势是天然支持多种编程语言(因为暴露的是标准SQL接口),而且数据库主从切换对业务服务器完全无感知,由中间件自己去探测主从状态(比如向测试表写一条数据,写成功的就是当前的主机);但代价是中间件本身要完整实现SQL语法和数据库通信协议,细节极多、极易出bug,需要相当长时间才能稳定下来,而且所有数据库请求都要经过中间件这一层,对中间件自身的性能要求也很高。正因为中间件封装的复杂度比程序代码封装高出一个数量级,一般情况下推荐用程序代码封装或采用已经成熟的开源数据库中间件(如MySQL官方推出的MySQL Router、奇虎360开源的Atlas),只有具备足够人力投入、且预期未来会有大量业务系统接入的大公司,才值得自己投入研发一套数据库中间件——因为这类系统一旦做成,接入的业务系统越多,节省的重复开发成本就越可观。 进一步展开见读写分离的分配机制。

原书依据 · 7 处

高性能数据库集群:分库分表

单表达到千万乃至上亿行时,读写变慢、备份恢复耗时剧增、单机出事丢得更多,需要分散存储压力。业务分库按模块把用户、商品、订单放到不同服务器,却带来三个问题:join 失效,跨库查询只能先查订单拿到用户 ID,再去用户库二次查询;事务失效,XA 等分布式事务性能差,只能靠程序补偿,补偿出错就要人工修复;成本上升,一台变三台,算上主备可能从两台变成六台。 进一步展开见业务分库的三重代价。

面对业务分库的三重代价带来的复杂性,是否要一开始就做业务分库,答案要按公司/业务所处的阶段分情况判断,而不是有统一标准。对小公司的初创业务,不建议一开始就做业务分库,理由有三层:初创业务本身存在很大不确定性,大部分业务根本发展不起来,业务早期通常也谈不上真正的存储和访问压力,业务分库这时候创造不出实际价值;业务分库会立刻引入join查询和事务实现上的复杂性;而且分库后代码里要新增”数据类型到具体数据库”的映射逻辑,增加的这部分工作量恰恰会拖慢初创阶段最需要的”快速实现、快速验证”节奏。有人会问:如果业务真的发展很快,岂不是很快又要被迫做业务分库,那为什么不从一开始就设计好?用架构设计三原则可以直接回答这个疑虑:其一,”业务真的发展很快”这个”如果”本身发生概率就很低,十个业务里能活下来一个已经不错,快速爆发式增长的概率和中彩票差不多,如果每个业务从第一天就按淘宝、微信的规模去设计架构,只会把团队自己拖垮、还耽误业务本身;其二,即便真的发展很快,事后再做业务分库也不迟——业务发展好意味着能投入的人和钱也在同步增加,分库带来的代码复杂度问题可以用增加的人力去消化,成本问题也可以用增加的资金去覆盖;其三,单台数据库服务器的性能其实没有想象中那么弱,一般能支撑到10万用户量级的业务规模,而初创业务从0发展到10万用户,通常没有想象中那么快。但对业界成熟的大公司来说,情况本质不同——它们已经有了业务分库的成熟解决方案,而且即便是尝试性的新业务,起步用户规模也往往是海量的,因此这类新业务最好在设计之初就把业务分库、甚至更进一步的分表方案一并考虑进去。 进一步展开见业务分库的适用时机。

单个业务的数据继续膨胀,就要拆单表。用切蛋糕来理解:从上往下切是垂直分表,记录数相同、列不同;从左往右切是水平分表,列相同、行不同。拆出的表不一定要放到不同服务器,同库拆表往往已能显著提升性能,不够再分库。垂直分表适合把不常用又占空间的列拆出去,如婚恋网站把用于展示的昵称和长篇介绍与用于筛选的年龄、性别分开,查询更快,代价只是凑齐字段要多查一次。 进一步展开见垂直分表与水平分表。

垂直分表与水平分表中的水平分表适合表行数特别大的表(有的公司把5000万行作为经验参考线,但这不是绝对标准——复杂表可能超过1000万就要分表,简单表即使过亿也可以不分,关键还是看表的实际访问性能,但一旦看到千万级数据量,架构师就该对潜在的性能瓶颈保持警觉)。水平分表比垂直分表复杂得多,首要难题是”路由”:某条数据具体落在哪个切分后的子表,需要一套路由算法来决定,常见有三种。范围路由选取有序的列(如自增ID、时间戳)作为分段依据,比如按用户ID每100万一段分别路由到不同库表;它的复杂点在于分段大小的取舍——分段太小会导致子表数量膨胀、维护成本上升,分段太大又可能单表依然存在性能问题(经验区间大致在100万至2000万之间),优点是能随数据增长平滑扩充新表而不用动旧数据,隐含缺点是分布可能严重不均匀(某个分段实际只存了1000条,另一个分段却存了900万条)。Hash路由选取某列(或几列组合)做哈希运算,再按哈希结果分配到不同子表,比如用user_id % 10决定落在哪张表;优点是分布相对均匀,缺点是初始表数量的选取本身就是个难题(太多难维护、太少单表性能仍不够),而且一旦要扩充表数量,几乎所有数据都要重新分布,成本很高。配置路由则是单独建一张路由表(如user_router,记录user_id到table_id的映射),优点是设计简单、扩表时只需迁移指定数据并更新路由表,非常灵活,缺点是每次访问都要多查一次路由表,会拖慢整体性能,而且如果路由表本身数据量也大到需要分库分表,就陷入了”路由表本身要用什么路由算法”的递归死循环。三种路由算法本质上是在”扩展平滑度”和”分布均匀度”之间做取舍,没有绝对最优解,需要结合具体业务的增长模式选择。 进一步展开见水平分表路由算法。

水平分表后,join 要在代码或中间件中逐个子表查询再合并;order by 要各表查出后统一排序。count 有两种办法:各子表 count 相加,简单但慢,20 张表串行可能要几秒;维护记录数表,读取快,但每次增删都要同步更新,且无法与子表操作同处一个事务,容易不一致;不要求实时的业务可用定时任务刷新记录数表。分库分表的中间件还要识别 SQL 操作了哪张表、有无聚合与排序,比读写分离复杂得多。 进一步展开见水平分表的查询难题。

分库分表后,按其他维度的查询会变难:运营要看全量实时报表,商户要统计来自不同用户的订单。作者的思路是用数据冗余换查询:数据写两份,一份分库分表给线上用,一份不分给运营查;或者按不同维度各存一张订单表,一张按用户 id 分库、一张按订单 id 分库。跨库本身不一定有性能问题,有问题就尽量让常用查询不跨库。发散:分片键只能服务一种主查询,其余靠冗余。参见水平分表的查询难题。 进一步展开见多维查询靠数据冗余。

原书依据 · 18 处

高性能NoSQL

关系数据库凭借强大的SQL能力和ACID特性广泛应用,但并不完美,存在四个具体缺陷。其一,只能存储行记录,无法直接存储数据结构——比如微博”我关注的人”本质是一个用户ID列表,关系数据库只能把它拆成多行分别存储,再查询组装还原成列表,无法原生存一个列表。其二,表结构schema是强约束,业务变化时扩充列要执行DDL语句(CREATE、ALTER等),而且修改时可能长时间锁表(如MySQL某些场景下可能锁表长达1小时)。其三,大数据统计场景下I/O偏高——即使只对某一列做运算,关系数据库也会把整行数据从磁盘读入内存,造成明显的读取浪费。其四,全文搜索能力弱——只能用like做整表模糊扫描,性能很低,无法满足互联网场景下复杂的搜索需求。针对这四个缺陷,业界分别演化出四类NoSQL方案:K-V存储(以Redis为代表)解决数据结构存储问题;文档数据库(以MongoDB为代表)解决schema强约束问题;列式数据库(以HBase为代表)解决大数据I/O问题;全文搜索引擎(以Elasticsearch为代表)解决全文搜索性能问题。但NoSQL带来的优势本质上是靠牺牲ACID中的某个或某几个特性换来的,天下没有免费的午餐,因此不能把NoSQL当成万能银弹去替代关系数据库,而应该把它理解为SQL的有力补充——这也是”NoSQL”这个词真正的含义:不是No SQL(没有SQL),而是Not Only SQL(不仅仅是SQL)。 进一步展开见NoSQL是关系库的补充。

K-V 存储针对关系数据库无法存储数据结构的缺陷,Redis 的 value 可以是 list、hash、set、sorted set 等结构,常被称为数据结构服务器。LPOP 一条命令就能弹出队头;关系数据库要维护位置编号,查出、删除、再逐一前移后续记录。代价是事务只保证隔离性与一致性,不保证原子性与持久性。很多场景并不需要严格 ACID,如微博关注偶尔丢一次影响很小,是否选用应看业务的真实要求。 进一步展开见Redis是数据结构服务器。

文档数据库针对 schema 强约束的缺陷,以 JSON 或 BSON 存储,读取不存在的字段得到空值而不报错。好处是新增字段无需 DDL、历史数据不出错,并能自然存储嵌套结构:一个用户的爱好列表、地址、学历经历用一个 JSON 描述,关系库要拆成四张表。它很适合属性差异大的电商商品和游戏。代价是不支持事务,扣库存与建订单可能不一致;也无法 join,“买了苹果笔记本的女性用户”只能分两次查。 进一步展开见MongoDB以无模式换灵活。

NoSQL是关系库的补充里列式数据库(以HBase为代表)针对的是”大数据场景I/O高”这个缺陷,与之相对的关系数据库是按行存储数据(行式存储)。行式存储的优势体现在两方面:一次业务操作要同时读取一行里的多个列时效率很高(同一行的各列本就物理相邻,一次磁盘操作就能全部读入内存);能一次性完成对一行内多个列的写操作,天然保证了行级写操作的原子性和一致性——如果换成列式存储,理论上可能出现同一次写操作里某些列成功、某些列失败,导致行内数据不一致。但这些优势只在特定访问模式下成立,一旦场景变了(典型是海量数据统计),行式存储的优势会直接反转成劣势:比如统计某城市所有居民的体重超标情况,逻辑上只需要读取”体重”这一列,但行式存储即使最终只用一列,也必须把整行数据(假设每行1KB,体重字段只占4字节)全部读入内存,造成明显浪费;换成列式存储,每个用户只需读取体重那4字节,I/O会大幅减少。列式存储除了省I/O,还有更高的压缩比——行式数据库压缩率一般在3:1到5:1,列式数据库能达到8:1到30:1,因为同一列内的数据相似度天然比同一行内跨字段的数据相似度高,压缩效果自然更好。但列式存储同样有对应场景下的劣势:如果业务需要频繁更新多个列,由于不同列在磁盘上物理不连续,更新会变成随机写,效率远低于行式存储”一次磁盘写完成整行更新”的效率;而且列式存储的高压缩率在更新场景下也变成负担,因为更新前要先解压、更新后要再压缩才能写回磁盘。基于这组此消彼长的取舍,列式存储通常只用在离线的大数据分析和统计场景——这类场景的特点正好是主要针对少数列做单列运算、且数据写入后基本不再更新删除,恰好避开了列式存储的短板、发挥它的长处。 进一步展开见行存与列存看访问模式。

NoSQL是关系库的补充里全文搜索引擎(以Elasticsearch为代表)针对的是”关系数据库全文搜索弱”这个缺陷,根源在于关系数据库的索引机制天生不适合全文搜索:一方面全文搜索的条件可以任意组合,如果每种组合都要靠索引支撑,索引数量会爆炸式增长;另一方面全文搜索本质是模糊匹配,索引本身解决不了这个问题,只能退化成like整表扫描,性能极低。以一个”程序员发布信息、用户来搜索程序员”的婚恋网站为例:不同用户的搜索条件千差万别(有人搜”性别+PHP+上海”,有人搜”性别+鹅厂+旅游”,有人搜”性别+猫厂+北京+Java+技术专家”,有人只搜”性别+美丽+美女”),这些条件横跨姓名/地点/单位/爱好/语言/自我介绍等多个字段,且经常是模糊匹配,如果靠传统索引支撑,几乎要给每个字段都建索引还未必够用。全文搜索引擎的核心解法是倒排索引(Inverted Index):和关系数据库习惯的”正排索引”(建立文档到单词的索引,即知道文档ID去查它包含哪些内容,适合按文档名称查内容)方向相反,倒排索引建立的是单词到文档的索引——记录每个单词分别出现在哪些文档里,因此特别适合”按关键词找文档”这种全文搜索的核心诉求(比如想找所有提到”设计”这个词的文章,直接查”设计”这个单词对应的文档ID列表即可,不需要逐篇扫描)。由于全文搜索引擎的索引对象是”单词和文档”,和关系数据库”键和行”这套术语体系不是一回事,要让全文搜索引擎支持关系型数据的全文检索,需要先把关系型数据转换成JSON文档再喂给搜索引擎建索引;以Elasticsearch为例,它默认会给JSON文档里的每个字段都建立专属的倒排索引,并且能在同一次查询里同时利用多个字段的倒排索引,从而在复杂组合条件下依然能保持很高的检索速度。 进一步展开见倒排索引原理。

原书依据 · 17 处

高性能缓存架构

缓存的价值在于弥补存储系统在两类场景下的不足:需要复杂运算才能得出的数据(如实时统计在线人数,用MySQL做count(*)无论怎么优化性能都不会太高)、以及读多写少的数据(如一条微博被几千万人浏览,写只有一次insert,读却是几千万次select)——缓存把这类可复用数据放进内存,一次生成多次使用,从而大幅减轻存储系统压力。但缓存本身也会引入新的复杂性,”缓存穿透”是其中之一:业务系统查缓存却没查到数据,只好再回存储系统查一遍,缓存没有起到分担压力的作用,常见有两种成因。第一种是被访问的数据本身在存储系统里就不存在——通常存储系统没有的数据也不会被写进缓存,导致每次查询这类不存在的数据都要穿透到存储系统一趟,正常情况下这类请求量不大,但一旦被黑客盯上、故意大量访问某些确定不存在的数据,就有可能把存储系统直接拖垮;解法很简单,只要存储系统查不到数据,就在缓存里存一个默认值(可以是空值也可以是具体的兜底值),下次读缓存就能直接拿到默认值,不用再穿透到存储系统。第二种是数据本身存在,但生成对应的缓存数据本身很耗时或耗资源,一旦刚好在业务访问时这份缓存失效了,压力就会集中砸向存储系统——典型场景是电商商品分页,因为数据量巨大只能按分页缓存,正常用户访问集中在前几页、后面的分页缓存容易过期,一旦被竞争对手的爬虫从头到尾遍历一遍,大量失效的分页缓存会集中触发耗性能的数据库查询(如order by limit操作),把整个数据库拖慢;这种情况没有太好的根治方案,因为爬虫什么时候来、遍历多深都不确定,常见的应对只能是识别并禁止爬虫访问(代价是可能影响SEO和正常推广)、或者做好监控,靠爬虫攻击本身是渐进式而非瞬时暴力破坏这一点争取处理时间。 进一步展开见缓存穿透的成因与应对。

缓存雪崩指缓存失效(过期)后引发系统性能急剧下降的连锁反应:缓存一过期被清除,业务系统就要重新访问存储系统、重新做一遍耗时的运算才能生成新缓存(这个过程通常要几十到上百毫秒),而对高并发系统来说,这几百毫秒内可能同时涌入成百上千个请求——由于旧缓存已经没了、新缓存还没生成,而且每个处理请求的线程互相并不知道”已经有另一个线程正在生成缓存”,于是所有这些请求都会各自重新访问存储系统、各自重新做一遍运算,瞬间把原本该由缓存挡住的压力,成倍地砸向存储系统,严重时会直接压垮数据库,进而拖垮整个系统,这才是”雪崩”这个名字的由来——单点的缓存失效被并发请求放大成了系统性的连锁崩溃。常见的解决方法有两种。第一种是更新锁机制:给缓存更新操作加锁,保证同一时间只有一个线程能真正去更新缓存,没抢到锁的线程要么等锁释放后重新读缓存,要么先返回空值或默认值兜底;需要注意的是,如果业务系统本身是分布式集群(几十上百台服务器),即使每台机器内部只有一个线程负责更新,几十上百台机器加起来同一时刻依然可能有几十上百个线程在抢着更新缓存,本质上还是雪崩,所以分布式场景下要实现真正有效的更新锁,必须借助分布式锁(如ZooKeeper)而不能只在单机内加锁。第二种是后台更新机制:把缓存更新的职责从业务线程转移到专门的后台线程,缓存本身设为永不过期,由后台线程按固定周期主动刷新;这个方案要特别处理一种边界情况——缓存系统内存不够时可能会把某些数据”踢”出去,从被踢掉到后台线程下一次定时刷新之间这段空窗期,业务线程读到的就是空值,表现为”数据丢了”,应对方式有两种:一是后台线程除了定时更新,还高频(比如每秒或每100毫秒)轮询检查缓存是否被踢掉,一旦发现立刻补更新,实现简单但轮询间隔不能设太长;二是业务线程发现缓存失效时通过消息队列主动通知后台线程去更新(即使多个业务线程同时发消息也没关系,后台线程收到消息后先判断缓存是否已存在,存在就跳过),这种方式依赖消息队列、复杂度更高,但更新更及时、用户体验更好。后台更新机制天然适配单机多线程和分布式集群两种场景,实现上比更新锁机制简单,还可以顺带用于业务上线时的”缓存预热”——上线时直接把相关数据提前加载进缓存,而不是被动等第一个用户访问时才触发生成。 进一步展开见缓存雪崩的两种方案。

缓存系统整体性能再高,请求集中在同一份数据上,那台缓存服务器仍会被打爆,如明星发微博后千万人同时围观。解法是给热点数据复制多份,在 key 中加编号区分,读取时随机选一份,把压力分摊到多台服务器,例如粉丝超百万的账号每条微博存 100 份。关键细节是副本不能设相同的过期时间,否则会同时失效,把热点问题变成缓存雪崩;应在一个范围内随机取过期时间,让失效时间错开。 进一步展开见缓存热点多副本错峰。

原书依据 · 8 处

单服务器高性能模式:PPC与TPC

性能受磁盘、操作系统、CPU、内存、网络、语言和架构等各环节影响:一行不当的 debug 日志能把 TPS 从 30000 拖到 8000,一个 tcp_nodelay 配置错误能把响应从 2 毫秒拉到 40 毫秒。架构层面主要做两件事:把单机性能发挥到极致,单机不够时设计集群。二者角色不同:架构设计决定性能上限,实现细节决定能达到的下限。架构没留出空间,编码再精也提升有限,所以性能要从架构阶段开始考虑。 进一步展开见架构定上限实现定下限。

PPC(Process Per Connection)是每来一个新连接就fork一个新进程专门处理这个连接的传统UNIX网络服务器模型:父进程accept连接后fork出子进程,子进程负责这个连接的读写和业务处理,处理完后子进程close连接(父进程fork后立刻调用的close只是把连接文件描述符的引用计数减一,真正关闭要等子进程也close、引用计数归零才发生)。这个模型实现简单,在连接数不多的场景(如数据库服务器)或互联网兴起前的普通业务场景下运作良好,世界上第一个web服务器CERN httpd用的就是这套模型,但随着互联网并发量从几十暴涨到成千上万,它的三个瓶颈就凸显出来了:一是fork代价高——创建一个进程需要操作系统分配大量内核资源、把父进程的内存映像复制给子进程,即使有Copy on Write优化,总体代价依然很大;二是父子进程通信复杂——fork时文件描述符能通过内存映像复制传给子进程,但fork完成后父子进程之间要交换信息(比如子进程要把自己处理了多少请求汇报给父进程做全局统计)就必须借助IPC这类进程间通信机制,实现起来比较麻烦;三是支持的并发连接数量有限——如果连接存活时间长且新连接源源不断,进程数会持续膨胀,操作系统进程调度和切换的开销也随之上升,PPC方案通常最多也就能撑住几百并发连接。prefork是为了解决”fork代价高导致用户首次访问变慢”这个问题而生的变体:系统启动时就提前把进程创建好,等真正有连接进来时就省去了现场fork的开销;实现的关键是让多个子进程都去accept同一个socket,操作系统保证最终只有一个进程能accept成功,但这会带来”惊群”现象——虽然只有一个子进程真正accept成功,所有阻塞在accept上的子进程却都会被唤醒,造成不必要的进程调度和上下文切换(好在Linux 2.6内核之后这个问题已经被操作系统层面解决)。prefork虽然省去了现场fork的延迟,但父子进程通信复杂、并发连接数有限这两个PPC固有的瓶颈依然没有解决,因此实际应用不算多,Apache的MPM prefork模式默认最大只支持256个并发连接,通常只在需要高可靠性或兼容旧软件的场景下才被推荐使用。 进一步展开见PPC与prefork的瓶颈。

TPC(Thread Per Connection)是PPC与prefork的瓶颈的直接演化:每来一个新连接就创建一个线程去处理,而不是创建一个进程。因为线程比进程更轻量,创建代价明显更低,而且多线程共享同一进程的内存空间,线程间通信自然比进程间通信(IPC)简单得多,所以TPC本质上是解决(或至少大幅弱化)了PPC的两个核心痛点:fork代价高和父子进程通信复杂——流程上父进程accept连接后创建子线程处理读写和业务,子线程处理完直接close即可(不像PPC还要父进程也配合close一次,因为线程共享文件描述符,不存在复制)。但TPC并非没有代价,它引入了三个新问题:一是创建线程虽然比创建进程轻,但依然不是零成本,在真正的高并发场景(比如每秒上万连接)下仍然会遇到性能瓶颈;二是线程间不再需要进程通信,但共享内存本身带来了互斥和同步的复杂度,稍不注意就可能引入死锁;三是多线程共享同一进程空间意味着彼此会互相影响,某个线程一旦出现异常(比如内存越界),有可能直接拖垮整个进程。而且TPC依然没有摆脱CPU线程调度和上下文切换的开销这个和PPC类似的底层限制——正因如此,在并发数只有几百这个量级的场景下,实践中反而更多选择PPC而不是TPC,因为PPC没有死锁风险,也不存在多线程互相拖累的问题,稳定性反而更高。prethread是TPC对应的”预创建”变体,思路和prefork一致:提前把线程创建好,省去现场创建线程的开销;但因为多线程之间数据共享和通信天然方便,prethread在实现上比prefork更灵活,常见方式有主进程accept后把连接分发给某个线程处理、或者让多个子线程都尝试accept、最终由操作系统保证只有一个成功两种。Apache的MPM worker模式本质上就是一种prethread方案,并做了一个关键改进:先创建多个进程,每个进程内部再创建多个线程——这样即使某个进程内某个线程异常导致整个进程退出,其他进程依然能继续对外提供服务,不会造成服务器整体宕机,这个”进程套线程”的设计本身就是在拿多进程的隔离性去弥补多线程的脆弱性。理论上prethread能比prefork支撑更多并发,Apache MPM worker模式默认支持16×25=400个并发处理线程。 进一步展开见TPC与线程池预创建。

“高并发”要按两个维度拆开看:连接数量和请求数量。海量连接加海量请求,如抢购、双十一;常量连接(几十上百)加海量请求,如中间件;海量连接加常量请求,如门户网站;常量连接加常量请求,如内部运营和管理系统。PPC、TPC 适合连接少的场景;常量连接下用 NIO 除了复杂一点也没有坏处;海量连接时单机也必须扛住大量连接,否则集群成本太高。发散:选并发模型前先估连接数和请求数。参见TPC与线程池预创建。 进一步展开见高并发按连接与请求分四类。

原书依据 · 11 处

单服务器高性能模式:Reactor与Proactor

PPC 和 TPC 每个连接独占一个进程或线程,用完即销毁,代价大。改用进程池、线程池后,一个进程要服务多个连接,若阻塞在某个连接的 read 上,其他有数据的连接也得等。改成非阻塞轮询能避免卡死,但轮询耗 CPU,连接上万时效率很低。I/O 多路复用的两个要点是:多条连接共用一个阻塞对象,进程只在它上面等待;某条连接有数据时由操作系统通知进程处理。它与线程池结合,为 Reactor 打下了基础。 进一步展开见I/O多路复用的由来。

I/O多路复用的由来结合线程池后诞生了Reactor模式,本质是”来了事件我通知你,你来处理”——Reactor负责用select/epoll等机制统一监听所有连接上的事件,一旦有事件就通过dispatch分发给对应的处理逻辑(这也是Reactor又被叫做Dispatcher模式的原因)。Reactor模式的具体实现要看两个维度的组合:Reactor本身的数量(单个还是多个)、处理资源池的数量(单进程/线程还是多进程/线程),理论上有四种组合,但”多Reactor单进程”既复杂又没有性能优势,实践中不存在,真正落地的只有三种典型方案。第一种是单Reactor单进程/线程:Reactor通过select监听事件并dispatch,连接建立事件交给Acceptor处理(accept连接并创建对应的Handler),其余事件交给对应连接的Handler处理,Handler完整走完read→业务处理→send整个流程,全过程都在一个进程/线程里完成,好处是简单,没有进程间通信、没有资源竞争;坏处也很直接——单进程发挥不出多核CPU的性能(想用多核只能在一台机器上部署多套系统,运维复杂度陡增),而且Handler正在处理某个连接的业务时,整个进程没法处理其他连接的事件,很容易撞上性能瓶颈,因此这个方案只适合业务处理本身极快的场景,著名的开源实现是Redis(C语言系统一般用单Reactor单进程,Java系统因为JVM本身就是一个进程、内部本来就是多线程,一般用单Reactor单线程)。第二种是单Reactor多线程:为了发挥多核性能,把”业务处理”从Reactor所在的主线程里剥离出去——Handler只负责响应事件、读取数据,真正的业务处理交给独立的子线程(Processor)去做,处理完把结果传回主线程的Handler,再由Handler通过send返回给客户端;这个方案确实能利用多核,但也带来两个新问题:多线程间共享数据的互斥和保护变复杂了(比如Java NIO里Selector本身线程安全,但selectKeys()返回的键集合并非线程安全,处理时必须单线程或加同步保护);而且Reactor本身仍然只跑在主线程里、独自承担全部事件的监听和分发,遇到瞬间高并发依然会成为瓶颈。这里没有对应的”单Reactor多进程”方案,原因在于子进程完成业务处理后要把结果传回父进程、再由父进程发给对应client,这件事本身很麻烦——父子进程通信不是一条天然的”连接”,要模拟成连接纳入Reactor监听会相当复杂;而多线程天然共享数据,线程间传递结果虽然要处理同步问题,但复杂度比进程间通信低得多,这正是”单Reactor多进程”没被实际采用的根本原因。 进一步展开见单Reactor的两种形态。

针对单Reactor的两种形态里”Reactor本身仍是单点瓶颈”这个问题,最直接的解法就是把单Reactor也拆成多个,形成多Reactor多进程/线程方案:父进程里的mainReactor只负责用select监听”连接建立”这一类事件,通过Acceptor接收新连接后,把这个连接分配给某个子进程;子进程里的subReactor把分到的连接加入自己的监听队列,并创建对应的Handler,之后这个连接上发生的所有事件(数据可读、可写等)都由这个子进程自己的subReactor监听、自己的Handler走完read→业务处理→send的完整流程。这个方案表面上看比单Reactor多线程更复杂(多了一层Reactor),但实际实现起来反而更简单,原因有三层:父进程和子进程的职责被切得非常干净——父进程只管接新连接,子进程只管把接到的连接的后续业务处理完,不存在职责重叠;父子进程之间的交互也很简单——父进程只需要把新连接”甩”给子进程,子进程不需要再把处理结果传回父进程(不像单Reactor多线程里子线程处理完还要把结果传回主线程的Handler);子进程之间彼此独立,网络模型这一层(select、read、send等)完全不需要任何同步共享机制(虽然”业务处理”这一层本身仍可能需要同步共享,但和网络模型这层完全脱钩)。目前著名的开源实现里,Nginx用的是多Reactor多进程,Memcache和Netty用的是多Reactor多线程;不过Nginx的实际实现和标准的多Reactor多进程方案有一个关键差异——它的主进程只负责创建监听端口,并不创建单独的mainReactor去accept连接,accept这个动作实际上是由各个子进程自己的Reactor来做的,通过锁机制保证同一时刻只有一个子进程在执行accept,accept到新连接后这个连接就直接归属这个子进程自己的Reactor处理,不会再被分配给别的子进程——这个设计进一步简化了父子进程之间原本还需要”分配连接”这一步的交互。 进一步展开见多Reactor的职责分离。

Reactor 是非阻塞同步模型:多路复用通知哪个连接有事件,read 和 send 仍由用户进程执行,即“来了事件我通知你,你来处理”。Proactor 是异步模型,由内核完成 I/O 后再通知业务代码,理论上能借助 DMA 让 I/O 与计算重叠。但它需要操作系统支持:Windows 有 IOCP,Linux 的 AIO 不完善,所以 Linux 下仍以 Reactor 为主,Boost.Asio 在 Linux 上也用 epoll 模拟。 进一步展开见异步I/O的Proactor。

原书依据 · 11 处

高性能负载均衡:分类及架构

单机性能终有上限,集群靠多台服务器提升处理能力。由于同样的输入和逻辑在任何一台服务器上结果都相同,集群的复杂度全部集中在任务分配上,因此必然要引入一个任务分配组件。这个组件通称“负载均衡器”,但名字有误导性:分配算法未必追求负载均衡,有的按吞吐、响应时间追求性能最优,有的按业务规则把特定请求固定路由到特定服务器。沿用这个术语没问题,但选算法时别把它等同于平均分配。 进一步展开见集群的本质是任务分配。

承接集群的本质是任务分配,实现层面常见有三类负载均衡机制,各自的定位和取舍完全不同。DNS负载均衡靠DNS解析同一域名返回不同IP来实现,一般用于地理级别的均衡(比如北方用户解析到北京机房IP、南方用户解析到深圳机房IP);优点是简单成本低(负载均衡工作完全交给DNS服务器,无须自己开发维护)、能就近解析提升访问速度,缺点是DNS缓存时间长导致更新不及时(改了配置后仍有用户在访问旧IP)、控制权在域名商手里扩展性差、支持的分配算法少且无法感知后端服务器真实状态(为此对时延和故障敏感的业务,有公司自研了基于HTTP协议的私有DNS即HTTP-DNS,优缺点正好和通用DNS相反)。硬件负载均衡靠专门的硬件设备实现(典型代表F5、A10),性能极强(可支撑100万以上并发,远超软件方案的10万级)、功能全面(支持各层级负载均衡和全面的算法,还自带防火墙、防DDoS等安全能力)、稳定性经过大规模商用验证,但价格昂贵(一台F5的价格堪比一辆中高端汽车)、扩展定制能力差,通常只有资金充裕的大公司才会采用。软件负载均衡靠负载均衡软件实现,代表是Nginx(7层负载均衡,支持HTTP、E-mail等具体协议)和LVS(Linux内核层的4层负载均衡,和协议无关,几乎任何应用都能用,如聊天、数据库);优点是简单(部署维护都容易)、便宜(一台普通Linux服务器批发价约1万元,相比硬件设备是天壤之别)、灵活(可选4层或7层、可通过插件做业务定制),缺点是性能不如硬件(Nginx大约5万/秒,LVS据称可达80万/秒,但都明显低于F5的百万级)、功能不如硬件强大、通常也不具备防火墙防DDoS这类安全能力。三者的本质取舍是”简单成本低但控制力弱→功能强大但价格高昂→性能功能适中但灵活便宜”这条光谱,选择时要看具体业务体量和预算,而不是哪种绝对更好。 进一步展开见三种负载均衡机制。

三种负载均衡机制列出的DNS、硬件、软件三种方式,在实际大型系统里并不是非此即彼的单选题,而是按照各自的优势定位组合使用的:DNS负载均衡负责地理级别的分流,硬件负载均衡负责集群级别的分流,软件负载均衡负责机器级别的分流。以一个假想的大型系统为例:系统部署在北京、广州、上海三个机房,用户访问www.xxx.com时,DNS先根据用户的地理位置解析出离用户最近的机房IP(比如把某用户导向广州机房),这是第一层地理级负载均衡;请求到达广州机房后,由F5这类硬件设备接手,把请求分发到广州机房内部的某个具体集群(比如”广州集群2”),这是第二层集群级负载均衡;请求进入”广州集群2”后,再由Nginx这类软件负载均衡把请求分发到集群内某台具体服务器上,由这台服务器真正处理业务并返回响应,这是第三层机器级负载均衡。这套三层架构本质上是让每一层负载均衡都发挥自己最擅长的能力——DNS成本低、适合做粗粒度的跨地域分流;硬件性能强、适合承接单个机房内跨集群的大流量分发;软件灵活便宜、适合做集群内部对具体服务器的精细分发。但这套三层组合是为大型业务量级设计的,并不是所有系统都需要照搬——比如一个大学论坛这种规模不大的业务,完全不需要DNS负载均衡也不需要F5这类硬件设备,只用Nginx做一层简单的负载均衡就完全够用了;架构该做到多复杂,终究要看实际业务体量,而不是单纯追求”标准架构”的完整性。 进一步展开见三层负载均衡组合。

原书依据 · 7 处

高性能负载均衡:算法

负载均衡算法按目标可分四类:任务平分类,按数量或权重平均分配;负载均衡类,按 CPU、连接数、I/O 等当前压力分配;性能最优类,按响应时间优先分给最快的服务器;Hash 类,按关键信息哈希固定分配。轮询最简单,但完全不看服务器运行状态,死循环、CPU 爆满也照样派活,32 核与 16 核机器分得一样多;不过宕机或断连它能感知并剔除。加权轮询按配置设权重解决能力差异,但仍感知不到运行时负载。 进一步展开见负载均衡算法四大类。

负载均衡算法四大类中的轮询、加权轮询不感知服务器运行时状态,负载最低优先和性能最优类算法正是为了弥补这个缺陷而生,但代价都是复杂度大幅上升。负载最低优先把任务分配给当前负载最低的服务器,”负载”的衡量指标要按场景选(LVS这类4层设备常用连接数、Nginx这类7层系统需要扩展才能支持HTTP请求数、自研系统则按业务特点选CPU负载或I/O负载);但落地起来复杂度很高——最少连接数优先算法要求负载均衡系统持续统计每台服务器当前建立的连接数,且只适用于”每个连接请求都会转发给服务器处理”的场景,如果负载均衡系统和服务器之间是固定连接池方式(比如通过连接池连MySQL集群),就不适合用这种算法;CPU负载最低优先算法要求持续收集每台服务器的CPU负载,还要决定用1分钟还是15分钟的负载值作为判断标准——不存在哪个时间窗口绝对更好,窗口太短容易频繁波动、太长又可能在峰值来临时响应迟钝,不同业务的最优窗口不一样。用一个直观的对比来说:轮询可能5行代码就能实现,负载最低优先可能要上千行,甚至需要负载均衡系统和后端服务器两边都配合开发,一旦设计不当或不适配业务特点,这套复杂算法本身反而可能变成新的性能瓶颈——这也是为什么负载最低优先看起来效果最好,实际应用场景反而没有轮询和加权轮询普遍的原因。性能最优类站在客户端视角,优先把任务分给响应最快的服务器,本质上和负载最低优先一样是在感知服务器状态,只是换了个外部指标(响应时间)来衡量,因此也背负着类似的复杂度:一是要收集统计每台服务器每个任务的响应时间,任务量大时这个统计动作本身就会消耗不少性能;二是为了减轻统计开销可以改用采样,但采样率本身又是个难题——太低不准、太高依然耗性能;三是无论全量统计还是采样统计,都要选一个合适的统计周期(10秒最优、1分钟最优还是5分钟最优),没有放之四海而皆准的答案,往往需要系统上线后不断调优才能找到适合的设置。 进一步展开见感知状态的均衡算法。

Hash 类负载均衡把关键信息哈希值相同的请求固定分给同一台服务器,目的不是分摊压力,而是满足同一用户或会话必须落在同一台服务器的需求。源地址 Hash 按来源 IP 分配,适合网银登录这类会话只在单机临时保存、无需持久化的业务。ID Hash 按 session id 等业务标识分配,效果相同,但在移动网络切换导致出口 IP 变化、会话 ID 不变的场景下更可靠。 进一步展开见Hash均衡保持会话。

原书依据 · 8 处

想成为架构师,你必须知道CAP理论

CAP定理(又称布鲁尔定理)由Eric Brewer在2000年提出、2002年由MIT的Seth Gilbert和Nancy Lynch证明成立,但布鲁尔提出猜想时并没有给Consistency、Availability、Partition Tolerance三个词下精确定义,导致不同资料的表述有细微差异。以Robert Greiner的两版CAP解释为参照,第一版给出的是”任意分布式系统不可能同时满足C、A、P三者”这样一句极简结论;第二版把适用范围收窄为更精确的表述——”在一个由互相连接(interconnected)并共享数据(share data)的节点组成的分布式系统里,涉及一次读写操作(write/read pair)时,只能保证C、A、P三者中的两个”。这个收窄带来两个关键差异:一是CAP讨论的分布式系统必须满足”节点互联且共享数据”这两个条件——不是所有分布式系统都符合,比如Memcache集群里各节点之间互不连接、也不共享数据,因此不属于CAP理论要讨论的对象;而MySQL集群的节点之间是互联并做数据复制的,才真正落在CAP的讨论范围内。二是CAP关注的只是”对数据的读写操作”,而不是分布式系统的全部功能——比如ZooKeeper的选举机制本身不涉及数据读写,就不是CAP理论要讨论的对象。第二版定义虽然更严谨,但相对第一版更难记,因此实践中大多数技术人员谈CAP时依然沿用第一版这句简单的表述,只是理解上要清楚它省略了这些精确的适用边界。 进一步展开见CAP的适用范围。

CAP 中一致性的定义经过精确化:从“所有节点在同一时刻看到相同数据”改为“对某个客户端,读操作保证返回最新的写入结果”。变化有三:视角从节点转为客户端;用“读”代替不准确的“看到”;不再要求同一时刻数据相同。后一点看似奇怪,但事务执行期间系统本就会短暂处于不一致状态,只要失败就回滚;客户端读不到未提交数据,事务提交后才读到结果,所以只要求读到最新写入更站得住脚。 进一步展开见一致性是读到最新写入。

CAP 中可用性的定义从“每个请求都得到成功或失败的响应”精确化为“非故障节点在合理时间内返回合理响应,不是错误或超时”。其一,主语限定为非故障节点。其二,“成功或失败”几乎涵盖一切情况,等于没有约束;改为合理响应、合理时间,并排除错误和超时。关键是“合理”不等于“正确”:本该返回 100 却返回 90 也算合理。所以牺牲一致性换可用性时,系统仍能给出合理但未必最新的结果。 进一步展开见可用性是合理响应。

分区容忍性的定义从“出现消息丢失或部分故障时系统能继续 work”精确化为“出现网络分区时系统能继续 function”。work 只要求在运行,一直报错也算;function 要求履行职责、给出合理响应,标准更严。成因也从丢包这一具体原因改为网络分区这一现象:丢包、断连或拥塞,只要节点间无法正常通信都算。三个定义的精确化思路一致:用描述现象和结果的说法取代狭窄、易歧义的说法。 进一步展开见分区容忍是继续履职。

CAP理论说三者只能取二,但放到真实的分布式环境下推演会发现:P(分区容忍性)其实是无法放弃的必选项,因为网络本身做不到100%可靠,节点间出现分区是必然会发生的现象,不是”要不要接受”的问题。如果强行选择CA、放弃P,会出现自相矛盾:一旦真的发生分区,为了保住一致性C,系统只能对写请求返回错误(禁止写入),但返回error本身就直接违反了可用性A(A要求不能出现error、不能超时)——所以理论上分布式系统根本不存在真正意义上的CA架构,能选的只有CP或AP。CP(Consistency/Partition Tolerance)架构的做法是:假设N1和N2两个节点间的复制通道因为分区而中断,N1上的数据已经更新到y,但还没能同步给N2,此时客户端C如果去访问N2,为了不返回过期的旧数据(保证一致性),N2会直接返回Error告诉客户端”系统当前出错了”——这个处理方式本身就是在牺牲可用性去换取一致性,因此这类架构只能满足CP。AP(Availability/Partition Tolerance)架构的做法则相反:同样是N1已经更新到y但还没同步给N2,客户端C访问N2时,N2直接把自己当前拥有的旧数据x返回给客户端,而不是报错——这就不满足”客户端读操作要拿到最新写入结果”这个一致性要求了,因此这类架构只能满足AP。这里有个细节值得注意:AP架构里N2返回的旧值x虽然不是一个”正确”的结果,但依然是一个”合理”的结果——它是一个真实存在过的、没有错乱的旧数据,只是不是最新的而已,这正好呼应了可用性是合理响应里”合理不等于正确”这个精确定义。选CP还是选AP,本质上是架构师针对具体业务场景,在”宁可报错也不给旧数据”和”宁可给旧数据也不报错”之间做的取舍。 进一步展开见CP与AP的区分。

原书依据 · 15 处

想成为架构师,你必须掌握的CAP细节

Brewer 在回顾 CAP 时指出,C 与 A 的取舍可以在同一系统内以很细的粒度反复发生,因操作、数据或用户而异。CAP 用 system、node 描述,容易让人以为要给整个系统统一选 CP 或 AP,但系统通常处理多类数据,要求各不相同。用户管理系统中,账号密码不一致会导致登录判断出错,应选 CP;昵称、自我介绍暂时不同步影响很小,可选 AP。落地时应先按场景把数据分类,再分别选择策略。 进一步展开见CAP按数据粒度取舍。

CAP理论有一个隐含且容易被忽视的假设:它忽略了网络延迟。Brewer定义一致性时,默认事务一提交,数据就能瞬间复制到所有节点,但现实中从节点A把数据复制到节点B总要花时间——同机房可能是几毫秒,跨地域机房(比如北京到广州)可能要几十毫秒。这意味着CAP理论里的C在实践中永远不可能完美实现,在数据复制真正完成之前的这段时间窗口里,节点A和节点B的数据必然是不一致的。这几毫秒或几十毫秒的不一致,对多数业务无所谓,但对某些极端严苛的场景(比如涉及金钱的用户余额、涉及抢购的商品库存)却是不可接受的——业务上必须要求强一致性,但技术上分布式场景下完美的一致性根本做不到,因此像”单个用户的余额”“单个商品的库存”这类数据,理论上该选CP,实际上CP都无法真正满足,只能退而求其次选CA——也就是只允许单点写入、其他节点做备份,无法做到分布式多点同时写入。需要澄清的是,这并不意味着这类系统整体无法用分布式架构,只是”单个用户余额、单个商品库存”这一份具体数据无法真正分布式多写,系统整体依然可以走分布式路线——常见做法是按用户做分区,比如用户ID 0~100的数据放Node 1、101~200的放Node 2,客户端按用户ID路由到对应节点,单个用户的读写永远只发生在某一个节点上。这种设计有个明显代价:某个节点故障时,落在这个节点上的用户完全无法读写;但从系统整体看,这个代价是可以接受的——故障影响的只是这一部分用户(比如20%),而不是全部用户,这正是为什么现实中挖掘机挖断光缆导致支付宝出故障时,只有部分用户业务异常,而不是所有用户同时瘫痪。 进一步展开见CAP忽略网络延迟。

只能选 CP 或 AP 的前提是分区真的发生了。网络正常时没有理由放弃 C 或 A,应当两者都保证,所以架构既要设计分区时牺牲哪一个,也要设计正常时如何做到 CA。同一系统不同数据实现 CA 的方式也可以不同:账号数据用实时性更可控但较复杂的消息队列同步,用户信息用简单但延迟可能较高的数据库同步。CAP 落地是为每类数据同时准备“正常时如何 CA”和“分区时牺牲谁”两套预案。 进一步展开见无分区时要做到CA。

CAP 的“牺牲”只是分区期间无法同时保证 C 和 A,并非永久放弃。系统绝大部分时间正常,4 个 9 的系统一年不可用约 50 分钟,因此分区期间可以记日志,为恢复后重新收敛到 CA 做准备。账号数据选 CP:分区时节点 1 接受注册并记录日志,节点 2 拒绝请求,恢复后按日志同步。用户信息选 AP:两边都接受修改并各自记录,恢复后按“最后修改优先”等规则合并,或把冲突交给人工判断。 进一步展开见牺牲不等于什么都不做。

ACID 是数据库保证事务正确性的四个约束:原子性、一致性、隔离性和持久性。它与 CAP 共用字母却含义不同:ACID 的 A 是原子性,CAP 的 A 是可用性,毫无关联;两者的 C 都译作一致性,ACID 指单个数据库事务前后的完整性不被破坏,CAP 指分布式多个节点间数据是否一致。二者讨论的层面也不同,一个是单库内的事务,一个是跨节点的读写,直接拿来类比就像“关公战秦琼”。 进一步展开见ACID与CAP同名不同义。

BASE指基本可用(Basically Available)、软状态(Soft State)、最终一致性(Eventual Consistency),核心思想是:即使做不到CAP意义上的强一致性,应用也可以通过适合的方式最终达到一致状态。基本可用指分布式系统出现故障时,允许损失部分可用性,只保证核心功能可用——这里的关键词是”部分”和”核心”,判断哪些业务可以损失、哪些必须保住本身就是一项有挑战的工作:比如用户管理系统里,”登录”是核心(已注册用户登不进去,意味着充了钱的游戏玩不了、云存储用不了,损失和影响范围都很大),”注册”相对是非核心(新用户注册不了顶多是流失一小部分潜在用户,且新注册用户体量远小于已登录用户体量)。软状态指允许系统存在不会影响整体可用性的中间状态,这个”中间状态”本质上就是CAP理论里说的数据不一致状态。最终一致性指系统内所有数据副本经过一定时间后,最终会收敛到一致状态——关键词是”一定时间”和”最终”,”一定时间”和具体数据的特性强相关,不同数据能容忍的不一致窗口完全不同:比如微博系统里,用户账号数据最好能在1分钟内达成一致(用户在A节点登录后,短时间内不太可能立刻切到另一个节点,但十分钟后就有可能),而用户发布的最新微博可以容忍30分钟内达成一致(看不到明星最新发的微博,用户感知不到差异,只会以为明星还没发);”最终”意味着不管这个窗口多长,系统最后一定会达到一致状态,不是永远不一致。BASE理论本质上是对CAP理论的延伸和补充,更准确地说,是专门针对CAP里AP方案的补充:一方面,CAP理论忽略延迟这个假设意味着完美的CP场景根本不存在,即使只有几毫秒的数据复制延迟,这几毫秒内系统也不符合严格CP的要求,因此CAP里所谓的CP方案其实也是在实现最终一致性,只是它的”一定时间”短到只有几毫秒而已;另一方面,AP方案里牺牲一致性只发生在分区期间,而不是永久放弃一致性,这一点正是BASE理论真正延伸的地方——分区期间牺牲一致性,但分区故障恢复后系统应该达到最终一致性。综合来看,ACID是数据库事务完整性理论,CAP是分布式系统设计理论,BASE则是CAP理论中AP方案的进一步延伸。 进一步展开见BASE是AP的补充。

原书依据 · 16 处

FMEA方法,排除架构可用性隐患的利器

高可用比高性能更难,因为异常场景太多,漏掉一个就留下隐患,按墨菲定律迟早会出事,所以需要尽量全面的分析方法。FMEA 即故障模式与影响分析,最早由美国空军采用,后来用于半导体、医疗、软件等众多行业,因为它是一套思考方法而非特定工具。它不指导如何设计架构,而是在架构设计出来后用来检验:画出架构图,假设某部件故障,分析对功能的影响,判断是否需要优化,并用 FMEA 表记录整条分析链。 进一步展开见FMEA事后排查隐患。

FMEA事后排查隐患落地成的FMEA分析表,前几个核心字段的填写方式有明确讲究。”功能点”必须站在用户视角来划分,而不是按系统内部模块来划分——比如用户管理系统的FMEA分析里,”登录”“注册”才是功能点,数据库存储功能、Redis缓存功能这类系统内部实现细节不能作为功能点。”故障模式”指系统会出现什么样的故障现象,包括故障点和故障形式,但关键是不需要在这一步给出真正的故障原因——比如只需要假设”MySQL响应时间达到3秒”这个现象即可,不管背后是磁盘坏道、慢查询、网络故障还是MySQL bug导致的,只要现象一样,对业务的影响就是一样的(具体原因留到后面的”故障原因”字段单独展开);故障模式的描述要尽量精确、多用量化表述,比如应该写”MySQL响应时间达到3秒”而不是模糊的”MySQL响应慢”。”故障影响”描述当故障模式发生时,对应功能点具体会受什么影响(如偶尔不可用、完全不可用、部分用户不可用、响应缓慢、出错等),同样要求尽量精确量化——推荐”20%的用户无法登录”而不是笼统的”大部分用户无法登录”,但也不需要精确到21.25%这种没有实际意义的小数点,估算个大致区间(20%还是40%)就够了。”严重程度”是站在业务视角评估故障影响的程度,按公式”严重程度=功能点重要程度×故障影响范围×功能点受损程度”来判断,一般分致命/高/中/低/无五档——比如登录比修改资料重要得多、80%用户比20%用户范围更大、完全无法登录比登录缓慢更严重,同样级别的严重程度可能来自不同组合(如”超过70%用户无法登录”是致命,”所有用户都无法修改资料”只是中);某个具体故障到底该定哪一档,有时会有争议,没有绝对标准,一般由相关人员讨论确定即可,争执不下时由架构师直接裁定,不值得为此花太多时间纠结。 进一步展开见FMEA核心字段设计。

FMEA核心字段设计里”故障模式”只描述现象、不涉及原因,但FMEA表里依然单独设了一个”故障原因”字段,原因有三层:一是不同故障原因发生的概率不一样——比如同样导致MySQL查询响应慢,可能是MySQL本身有bug,也可能只是没建索引,前者的概率远低于后者,而概率高低直接影响该怎么应对;二是不同故障原因的检测手段不一样——磁盘坏道导致的响应慢需要靠专门的运维系统去做磁盘坏道检查,慢查询导致的响应慢只需要配置MySQL慢查询日志就能发现;三是不同故障原因的处理措施不一样——MySQL bug的应对通常只能是升级版本,没建索引的应对就是直接加索引。”故障概率”指某个具体故障原因发生的可能性,一般分高/中/低三档,评估时要重点考虑:硬件会随使用年限增加故障概率(新硬盘坏道率低,用了三年的硬盘坏道率明显更高);开源系统成熟版本bug率低、刚发布的版本bug率高,自己有使用经验的开源系统bug率低、刚开始尝试的bug率高;自研系统同理,成熟系统故障概率低、新开发的系统故障概率高。这里高中低只是为了确定优先级、决定后续资源投入方向,没必要也没办法做绝对精确的量化(比如某开源系统到底是3个月还是6个月故障一次,这种精确数字本身就评估不出来,强行量化反而是浪费成本)。有了严重程度和故障概率,就能算出”风险程度”:风险程度=严重程度×故障概率——这个公式说明影响再严重的故障,如果发生概率极低,最终风险程度依然可以很低(比如”某机房业务瘫痪”这个后果是致命的,但如果诱因是”地震”,广州5级以上地震20世纪仅1次,概率极低);反过来同样的故障影响,换一个更常见的诱因(比如”机房空调烧坏”可能两年一次,”机架掉电”可能一年一次),风险程度就会随概率的上升而明显变高——这也是为什么FMEA要把”故障原因”和”故障概率”单独拆出来分析,而不是只停留在”故障影响有多严重”这一层。 进一步展开见故障原因与风险程度。

FMEA表里的”已有措施”记录系统当前针对某个具体故障原因已经具备的应对手段,分三个层次由弱到强:检测告警是最基础的,系统只负责发现故障并告警,自己不处理,需要人工介入;容错是系统检测到故障后能通过备份手段自动应对,比如MySQL主备架构里,业务服务器一旦发现主机连不上,就自动切换去连备机读取数据;自恢复是系统检测到故障后能自己恢复,比如Hadoop发现某台机器故障后,会自动把原本存在这台机器上的副本重新分配到其他机器上——需要注意这里的”恢复”指的是业务层面的恢复,而不是真的把物理故障修好(Hadoop不可能把一块产生了坏道的磁盘真正修复成没有坏道)。除了已有措施,FMEA还区分”规避措施”(为了降低故障发生概率而做的事,可以是技术手段也可以是管理手段,比如为避免新引入的MongoDB丢数据而在MySQL里冗余一份,或者强制统一更换服役超过两年的磁盘)和”解决措施”(为了真正解决问题而做的事,通常是技术手段,比如为了防暴力破解密码而限制重试次数、为防拖库泄露而给敏感数据加密、为防非法访问而加白名单控制)。如果某个故障既能规避又能解决,应优先选解决措施——毕竟能真正解决问题总是更好;但很多时候有些故障系统自己根本没法解决(比如磁盘坏道、开源系统本身的bug),这类只能靠规避措施降低发生概率或减小影响,而系统能自己解决的故障,大多都和系统本身的功能设计直接相关。综合前面所有字段的分析结果,就能看出哪些故障目前完全没有对应措施、哪些已有措施还不够充分,结合风险程度排出优先级,给出”后续规划”——既可以是技术手段也可以是管理手段,既可以是规避也可以是解决,核心原则是优先投入资源解决风险程度最高的隐患(例如”地震导致机房业务中断”这种没法真正解决的故障,只能靠建备份中心来规避;”机柜断电导致业务中断”则可以通过把业务机器分散部署到不同机柜来规避;”敏感数据泄露”可以直接靠数据库加密这个技术手段解决)。以书中一个用户管理系统(MySQL存储+Memcache缓存+Server业务处理)的FMEA实战为例,分析下来汇总出的改进措施包括:给MySQL加备机、把Memcache从单机扩展为集群、给MySQL配置双网卡连接——这几条改进正是FMEA分析表”后续规划”列汇总后的直接产出。 进一步展开见已有措施与规避解决。

原书依据 · 9 处

高可用存储架构:双机架构

存储高可用都靠复制数据实现冗余,难点在复制延迟和中断带来的不一致,所以分析方案要回答四问:数据如何复制,各节点职责是什么,如何应对复制延迟,如何应对复制中断。主备复制最简单,主机读写、备机只备份,切换靠人工,客户端无需感知备机。缺点是备机资源闲置,故障恢复依赖人工,响应慢且操作少见容易出错。它适合变更少、丢点数据能人工补齐的内部管理系统。 进一步展开见存储高可用四问与主备。

主从的“从”是仆从,要真正干活:主机读写,从机承担读。好处是主机故障时读业务仍能运行,从机资源不再闲置。代价是客户端必须感知主从关系、把不同操作发到不同机器,复杂度高于主备;复制延迟大时会读到旧数据;故障恢复仍需人工。它适合读多写少的业务,如论坛、新闻网站,读量常是写量的几十倍,让从机分担读流量收益明显。 进一步展开见主从复制让从机干活。

主备、主从都存在主机故障后无法写入、需人工指定新主机的问题,双机切换要让系统自动决定并切换主机角色,需考虑三点:状态判断,包括状态传递渠道是互联还是第三方仲裁,检测掉电、进程还是响应慢;切换决策,包括切换时机、原主机恢复后的角色、是否需要人工确认;数据冲突解决,如切换前后两边各自生成了 ID=100 的记录,只能按业务处理。因此切换方案的复杂度比复制方案高一个量级。 进一步展开见双机切换三个设计点。

按双机切换三个设计点里”状态传递渠道”这个维度的不同实现,常见的主备切换架构有三种。互连式是主备机之间直接建一条状态传递通道(可以是网络连接也可以是串口,可以主推备取也可以备取主推,可以和数据复制通道共用也可以独立,甚至可以多条通道混合),配合客户端共享一个虚拟IP或同时记录主备地址来实现切换后的无感知;它最大的缺点在于状态通道本身也可能故障(比如网线被踢掉),一旦通道断了,备机会误以为主机故障、把自己升级为主机,而实际主机根本没坏,结果就是同时出现两个主机——即使增加多条通道也只能降低这种误判概率,无法根本解决,而且通道越多,备机收到的多路状态信息可能相互矛盾,决策反而更复杂。中介式是在主备之外引入第三方中介,主备都只连中介、通过中介传递和上报状态,看起来多了一层反而更复杂,但实际上状态传递和决策都更简单——连接管理更简单(主备只需要维护和中介的单一连接,不用管理多种类型的通道);状态决策也更简单(可以用一套固定算法:初始状态都是备机,与中介断连就自动降级为备机;主机与中介断连,中介立刻通知备机升级为主机;网络中断导致的断连,原主机自己降级、网络恢复后以新备机身份重新上报;掉电重启这类情况,原主机重启后发现已有主机在位就保持备机状态不变;连接都正常时,就按实际状态指标决定要不要切换)。中介式的真正代价在于中介本身也必须高可用——中介一旦宕机,系统就会陷入”双备机”状态、写操作直接不可用,这就掉进了一个递归陷阱:”为了实现高可用引入中介,中介本身又需要高可用,于是要为中介再设计高可用方案……”ZooKeeper、Keepalived这类成熟开源组件可以复用,降低实现中介高可用的成本,工程上推荐基于它们搭建中介式切换,但仍须按自身故障模型验证仲裁、网络分区和切换边界(MongoDB的Replica Set就是这种思路,用主节点+备节点+不存数据的仲裁节点组成)。模拟式是主备之间完全不传递状态数据,而是让备机伪装成一个客户端,主动向主机发起模拟的读写请求,靠这些请求的响应情况来判断主机状态;优点是实现最简单(省去了整套状态传递通道的建立和维护),但简单本身也是代价——模拟读写能拿到的状态信息只有响应层面的信息(如404、超时、响应超过3秒),远不如互连式能拿到的CPU负载、I/O负载、吞吐量等多维指标丰富,基于这么有限的信息做状态决策,容易出现误判。 进一步展开见双机切换三式的取舍。

主主复制中两台都是主机,互相复制,客户端随便读写,看似没有切换问题,简单得多。但它要求数据能安全地双向复制,而很多数据不行:自增用户 ID 可能在两边同时分到 100 而冲突;库存 100 件,一边扣 1 剩 99,另一边扣 2 剩 98,互相覆盖后结果错误,真实应为 97,余额同理。所以主主复制只适合临时的、可丢失、可覆盖的数据,如登录 session、行为日志、论坛草稿。 进一步展开见主主复制限制数据类型。

原书依据 · 16 处

高可用存储架构:集群和分区

主备、主从、主主架构都隐含一个假设:单台主机能存下所有数据,但硬件存储能力再怎么发展也追不上业务数据的增长速度(早在2013年Facebook就有2500亿张照片、共250PB数据、每天新增3.5亿张),单机撑不住时就需要多台服务器组成集群——所谓”集群”,数量上至少要3台起(区别于主备主从这类双机架构)。按机器角色划分,集群分为数据集中集群和数据分散集群两类。数据集中集群本质上和主备/主从架构相似,可以理解为”1主多备”或”1主多从”——数据只能往主机写,读操作则可以参照主备/主从的思路灵活安排;但因为机器数量更多,复杂度整体上一个台阶,具体体现在三点:一是主机往多个备机复制数据不再是单一通道,而是多条复制通道,既会增大主机复制的压力,也可能导致各个备机之间数据互不一致,需要额外做备机间的一致性检查和修正;二是原本只有一台备机需要判断主机状态,现在变成多台备机各自判断,不同备机的判断结果完全可能不一致,如何处理这种分歧本身就很复杂;三是主机故障后,理论上多台备机都具备升级为新主机的能力,但实际只能允许一台真正升级,选哪一台、备机之间怎么协调,也是个复杂问题。开源的数据集中集群典型代表是ZooKeeper,它靠ZAB算法解决了上述三个问题,但ZAB算法本身的复杂度也很高。数据集中集群和后续要讲的数据分散集群应用场景不同:数据集中集群适合数据量不大、集群机器数量也不多的场景(如ZooKeeper集群一般推荐5台左右,数据量单台服务器就能扛住);数据分散集群因为可伸缩性更好,适合数据量巨大、集群规模庞大的场景(如Hadoop、HBase集群,大规模时能到上百上千台服务器)。 进一步展开见数据集中集群的复杂性。

和数据集中集群的复杂性不同,数据分散集群指多台服务器组成一个集群,每台服务器都负责存储一部分数据,同时为了容错也各自备份一部分其他服务器的数据。数据分散集群的复杂点在于”怎么把数据分配到不同服务器”这套算法本身,需要同时满足三个设计要求:均衡性——各服务器承担的数据分区数量要大致相当,不能出现某台是另一台好几倍的失衡情况;容错性——部分服务器故障时,原本分配给它的数据分区要能重新分配给其他健康的服务器;可伸缩性——集群容量不够、扩充新服务器后,算法要能自动把部分数据分区迁移到新服务器上,并且保证扩容后整体依然均衡。数据分散集群和数据集中集群的关键区别在于:数据分散集群里每台服务器都能处理读写请求,不存在数据集中集群里那种专门负责写的”主机”角色;但集群依然必须有某个角色专门负责执行”数据该怎么分配”这套算法,这个角色可以是一台独立的服务器,也可以是集群自己选举出来的一台服务器——如果是后者,这台服务器有时也被称为”主机”,但它承担的职责和数据集中集群里的”主机”(负责所有写操作)是完全不同的两码事,不要混淆。Hadoop走的是独立服务器路线:专门用一台叫Namenode的服务器负责管理文件系统的名字空间和数据块到具体Datanode的映射,Datanode只负责实际存储和处理客户端的读写请求,在Namenode的统一调度下完成数据块的创建、删除和复制。Elasticsearch则走选举路线:从集群节点里选出一台叫master node的服务器,负责创建/删除索引、跟踪集群成员、决定分片该分配到哪个节点这类轻量级但对集群整体健康至关重要的调度工作。 进一步展开见数据分散集群的设计点。

主备、主从、集群等方案都以“部分硬件损坏”为前提,关注单机或节点粒度的故障。但水灾、大停电、地震可能让整个城市的基础设施瘫痪,影响的是所有硬件,同一机房里冗余再多也没用。数据分区因此诞生:把故障粒度提升到地理区域,按规则把数据分布在不同地点,每个分区只存一部分。某地发生灾难时只影响该地区的数据,其他地区的备份还能帮助其尽快恢复业务。 进一步展开见数据分区应对地理灾难。

设计数据分区要先看两点。数据量:2TB 用 4 台就能管理,200TB 却不是简单扩到 800 台,每周都可能有机器故障,定位难,新增机器还要改分区配置,容易牵连已有服务器,数据扎堆一城也有灾难风险,所以数据量越大规则越复杂。分区粒度:洲际之间延迟太大,通常只作备份;国家之间语言、法律、业务规则不同,一般也只作备份;同一国家内的城市分区延迟低,可以同时对外服务,这是异地多活的基础。 进一步展开见分区看数据量与地理粒度。

分区看数据量与地理粒度本身把数据分散到多个地区就已经相当于一层高可用保障,但每个分区自己承载的数据量往往依然很大,一旦某个分区本身的数据损坏或丢失,损失同样难以承受,所以即使做了分区,依然需要考虑每个分区自己的复制方案,常见有三种模式。集中式指存在一个统一的总备份中心,所有分区都把数据备份到这一个中心——优点是设计简单(各分区之间没有直接联系,互不影响)、扩展容易(新增一个分区,比如武汉分区,只需要把它的数据复制到备份中心即可,不影响其他分区),缺点是成本较高,需要单独建设并维护一个独立的备份中心。互备式指每个分区互相备份另一个分区的数据(比如广州分区把数据复制到北京分区)——优点是成本低(直接复用已有分区的设备,不需要额外建中心),缺点是设计比较复杂(每个分区除了要存自己的业务数据,还要承担备份别的分区的职责,彼此互相牵连影响),而且扩展很麻烦——比如新增一个武汉分区,原本”广州复制到北京”的关系要改成”广州复制到武汉、武汉复制到北京”,那原来北京分区里已经备份好的广州历史数据该怎么处理就成了一个棘手问题,不管是做数据迁移,还是让北京继续保留广州的历史数据、新数据改由武汉备份,操作起来都很麻烦。独立式指每个分区拥有自己独立的备份中心,且这个备份中心特意不和原分区放在同一个地方(比如北京分区的备份放在天津、上海的放在杭州、广州的放在汕头),这么设计的核心目的是规避”同城或相近地理位置同时遭遇灾难性故障”这种极端情况——如果备份中心和原分区都在同一座城市(比如北京分区在朝阳区、备份放在通州区),一旦整个北京停电,两边照样一起瘫痪,起不到分散风险的作用。独立式的优点同样是设计简单(各分区互不影响)、扩展容易(新分区只需要搭自己的备份中心即可),但缺点是成本最高——每个分区都要单独承担一个备份中心的场地成本,因此独立式的整体花费明显高于集中式。 进一步展开见分区复制规则三模式。

原书依据 · 14 处

如何设计计算高可用架构?

计算高可用靠增加服务器,复杂度集中在任务管理,有两个设计点:哪些服务器能执行任务,是每台都能,如无状态的页面访问,还是只有主机能,如 ZooKeeper 的 Leader 处理写;任务如何重新执行,是失败就不管、只保证新任务分给健康机器,还是由任务管理器追踪结果并重新分配。任务分配器是逻辑角色,未必独立存在:Nginx 兼任分配器,ZooKeeper 的 Follower 转发写请求时也是。 进一步展开见计算高可用两个设计点。

计算主备架构不涉及数据复制,比存储主备更简单:主机执行所有任务,故障时系统直接不可用,恢复不了就人工把备机升为主机,再补一台备机。按准备程度分两种:冷备只备好程序和配置,故障后要手动启动业务系统再切流量;温备的业务系统已启动但不对外服务,只需切流量,操作时间短得多,一般推荐温备。它简单,但依赖人工,发现慢、切换慢、易出错,只适合使用频率低的内部管理系统。 进一步展开见计算主备的冷备与温备。

计算主从架构中,从机也真正执行任务:任务分配器把一部分任务发给主机、另一部分发给从机。主机故障时,分配器不会自动转移主机那部分任务,仍照常发给主机;主机能恢复就继续原策略,恢复不了就人工把从机升为主机,再补一台从机。相比主备,它利用了从机的硬件资源,不再闲置;代价是任务分配器要先对任务分类,决定哪些发主机、哪些发从机,实现更复杂。 进一步展开见计算主从架构。

主备、主从都依赖人工切换,要求更高时需要集群自动切换。对称集群也叫负载均衡集群:分配器按轮询或随机等策略派发任务,发现某台故障就不再派给它,恢复后重新纳入。设计关键有二:分配策略较简单;状态检测较复杂,既要看服务器是否宕机,也要看任务是否卡死、耗时过长,通常靠心跳传递信息。判断条件必须按业务定制:页面系统可设“1 分钟内 80% 请求超过 1 秒”为故障,后台统计任务可设“单任务超 10 分钟”。 进一步展开见负载均衡集群的状态检测。

和负载均衡集群的状态检测里”每台服务器角色都一样”不同,非对称集群里不同服务器承担不同角色、执行不同职责,最常见的形式就是Master-Slave:部分任务只能由Master服务器执行,部分任务只能由Slave服务器执行。具体设计上,集群需要先通过某种方式区分角色(比如用ZAB算法选举,或者简单粗暴地取当前存活服务器里节点ID最小的那台当Master),任务分配器再把不同类型的任务发给不同角色(比如计算任务A发给Master、计算任务B发给Slave);当特定角色的服务器故障时,处理方式也不一样——如果是Master故障,需要从剩下的Slave里重新指定一台升级为Master;如果是Slave故障,则不需要重新分配角色,直接把这台故障机从集群里剔除即可。非对称集群相比负载均衡集群,复杂度多出两层:一是任务分配策略更复杂——不能像负载均衡集群那样简单轮询随机分配,而是要先把任务按类型划分清楚,再分别发给对应角色的节点;二是角色分配策略的实现更复杂——判断谁该当Master、Master挂了怎么重新选,往往需要ZAB、Raft这类相对复杂的一致性算法来支撑Leader选举。以ZooKeeper为例可以对照理解这两层复杂度具体落地成什么样:任务分配这一层,ZooKeeper里不存在一个独立的任务分配器节点,每个Server自己就是任务分配器——Follower节点收到请求后自己判断,是写请求就转发给Leader,是读请求就自己直接处理;角色指定这一层,ZooKeeper用ZAB算法来选举Leader,一旦Leader故障,所有Follower节点会先暂停对外的读写服务、进入选举流程,直到新Leader选出来才恢复对客户端的服务。 进一步展开见非对称集群的复杂度。

原书依据 · 14 处

业务高可用的保障:异地多活架构

机房断电、火灾、地震可能让全部服务器瘫痪,异地备份恢复常要半小时到十几小时。要在这类故障下几分钟内恢复,需要异地多活。判断标准有二:正常时访问任意地点都能得到正确服务;某地异常时访问其他地点也能得到正确服务。“活”与“备”本质不同,备平时不服务,切换要大量人工。异地多活会让复杂度质变、成本大增,新闻、博客、内部系统做异地备份即可;支付宝、滴滴这类中断影响直接的业务则必须做。 进一步展开见异地多活并非都值得。

异地多活按距离分同城异区、跨城异地和跨国异地。同城异区把业务部署在同城不同区的机房,用高速专线连接,几十公里的距离能达到接近同机房的网络速度,逻辑上可近似视为一个机房来设计,复杂度和成本都低得多。它挡不住波及整座城市的水灾这类极端灾难,但这类灾难多年一遇;而机房火灾、停电、空调故障概率更高,它恰好能应对。权衡复杂度、成本与故障概率,它是应对机房级故障的最优解。 进一步展开见同城异区应对机房故障。

同城异区应对机房故障应付不了区域级灾难,跨城异地正是为了补上这个缺口而生——把业务部署在距离比较远的不同城市(比如北京和广州,而不是距离很近的广州和深圳),必须”距离远”才能同时应对美加大停电(同城太近扛不住)和新奥尔良水灾(同城异区本身扛不住)这类极端事件。但”距离远”不只是数字上的变化,而是量变引起质变,直接推高了整体架构复杂度——首先是网络传输速度的下降,这不是工程能优化掉的,而是被物理定律锁死的(真空光速约每秒30万千米,光纤中约每秒20万千米,再加上沿途网络设备处理,实际速度还要打折扣);其次是中间传输链路上大量不可控因素(挖掘机挖断光纤、海底电缆被拖船扯断、骨干网故障,很多线路是第三方在维护,出了问题往往无从预知也无能为力)——比如广州到北京正常RTT大约50毫秒,网络波动时可能飙到500毫秒甚至1秒,遇上丢包问题延迟可能是几秒到几十秒。这些问题同城异区理论上也会遇到,但因为距离短、经过的线路和设备少,发生概率低得多,而且搭多条通道的成本也低;跨城异地则相反,距离远导致这类问题概率更高,搭建或使用多通道的成本也高得多。跨城异地的网络延迟问题给架构设计带来一个看似矛盾的挑战:要做到真正的”多活”,业务系统必须在数据短时间不一致的情况下依然能正常提供服务,但数据不一致业务照理说就不该”正常”——解法的关键在于按数据本身的特性来分类设计。对强一致性要求的数据(如银行存款余额、支付宝余额),实际上根本无法做到跨城异地多活:假设用户A在广州机房把余额从10000转出5000变成5000,此时挖掘机挖断了广州到北京的光缆,广州的变动无法同步给北京,用户A跑到北京一看余额还是10000,于是又转出10000变成0;等他回广州一看余额显示还有5000,又转走5000变成0——结果原本只有10000元的用户A,硬是转出去了20000元,这种漏洞一旦被恶意利用后果不堪设想,正因如此,支付宝这类金融系统的余额数据一般只能用同城异区、不会做跨城异地多活。而对一致性要求不高、或数据变化少、或丢失影响不大的业务(用户登录session、新闻类网站的当日新闻、微博类网站的用户发布内容),跨城异地多活就能很好地派上用场——用户登录数据不一致大不了重新登录,新闻和微博的少量数据丢失对整体业务影响有限。 进一步展开见跨城异地按数据分类。

跨国异地的数据同步延迟可达秒级,已无法满足“正常时访问任意地点都得到正确服务”:上海用户刚发的微博,访问纽约机房的关注者可能看不到。跨城异地延迟是几十毫秒,用户基本无感,跨国则明显可见,所以“多活”的含义已经不同,实际只剩两种场景:为不同地区用户提供相互独立的服务,如亚马逊中国与美国账号不通;只读类业务多活,如搜索引擎,结果基本一致,用户也不需要毫秒级的新数据。 进一步展开见跨国异地的多活含义。

原书依据 · 10 处

异地多活设计4大技巧

做跨城异地多活时,常见误区是想让所有业务都多活。用户系统中,注册无法多活:A 中心宕机时,B 中心判断不了手机号是否已在 A 注册,放行会破坏“一号一账户”的规则。修改资料也难:靠最后修改时间合并,各中心时钟不可能完全一致;靠全局递增 ID,又要求 ID 系统本身多活。正确做法是只保证核心业务多活。登录就是核心:日活千万,天天都有人登录,登录不了才是大事件;而每个中心都有全量账号,登录最容易多活。 进一步展开见只保证核心业务多活。

只保证核心业务多活之后还有一个常见的思维误区:”我要让所有数据都实时同步”。异地多活本质上是靠异地数据冗余来保证极端异常下业务依然可用,数据同步自然是核心,但同步速度受制于光速和网络传播速度这类物理定律,业务上想要”越快越好”和物理上”注定做不到很快”,这是一个无法彻底消除的矛盾,因此追求所有数据实时同步本身就是个达不到的目标。面对这个无法根治的矛盾,只能想办法降低影响,有三种可参考的方法。一是尽量缩短异地多活机房之间的距离、搭建高速网络——思路和同城异区类似,但跨城场景下搭高速网络的成本远超同城异区,一般只有资金雄厚的大公司才承担得起。二是尽量减少要同步的数据,只同步真正核心业务相关的数据——比如用户子系统里登录产生的token/session信息,数据量很大但完全不需要同步,因为丢了大不了让用户重新登录一次拿回来,这点体验代价比起同步全部数据的成本要划算得多。三是只追求最终一致性、不追求实时一致性——这正是BASE理论的具体应用,业务不依赖数据同步的实时性,只要求数据最终能收敛一致即可,比如A机房新注册的用户,正常情况下允许5分钟内同步到所有机房,异常情况下甚至可以放宽到1小时甚至1天。最终一致性落地时还要按数据特征做差异化处理:账号信息如果同步窗口内用户恰好跑到了还没收到数据的机房,就需要按路由规则回A机房现场取一次数据以保证业务正确;用户信息哪怕5分钟内还没同步也不至于出错,只是用户可能暂时看到旧信息,属于可以接受的体验代价而不需要额外补救措施。 进一步展开见保证核心数据最终一致。

大部分存储系统本身就自带同步能力(MySQL主备复制、Redis Cluster、Elasticsearch集群),这看起来能直接拿来用,但也容易让人陷入”只用存储系统自带同步功能”这个思维误区——绝大多数场景下确实够用,但极端情况下往往难以满足业务需求。以MySQL为例,5.1版本的复制是单线程的,网络抖动或大批量数据同步时经常出现延迟,短则十几秒、长则十几分钟,即使靠监控发现了延迟,也基本只能干等,没什么办法主动干预。Redis也有类似问题:3.0之前没有Cluster功能,只有主从复制,而且2.8之前的版本里从机一旦宕机或和主机断连,重连时会触发全量的主从复制——这个过程主机要生成内存快照(主机本身能继续对外服务,但作为读节点的从机在此期间完全无法对外提供服务),数据量一大,恢复时间会相当长。这说明存储系统自带的同步功能在异地多机房这种容易出现各种异常的部署场景下未必够用,只依赖它反而可能做不到真正的异地多活。解决办法是打开思路,把多种手段配合存储系统同步一起用,甚至完全自己设计同步方案。以只保证核心业务多活提到的用户子系统为例,可以按数据特性分别采用不同手段:账号数据只会新建不会改删,用消息队列同步到其他中心即可;如果消息队列也出现延迟(用户刚在A中心注册就跑去访问B中心),可以用二次读取(本地读不到就按路由规则去对端中心再读一次)来兜底;密码数据和用户信息数据修改频率低(用户不可能1秒内连续改多次密码),直接靠数据库自带的同步机制复制就够了;session数据量很大,可以完全不同步,A中心登录后跑去B中心,B中心拿着session id按路由判断出这条session属于A中心、直接回源到A中心去取即可(反之亦然),这叫回源读取;如果回源读取也失败了(比如A中心整个宕机了),就只能让用户在B中心重新登录、生成一份新的session数据,这叫重新生成数据。这几种手段配合下来,才真正撑起了这个用户子系统的异地多活同步方案,实际设计里的细节还会比这个示意更多。 进一步展开见多手段同步数据。

前三个技巧解决方案里都留了一个尾巴:密码没同步导致部分用户登录不了、用户信息没同步导致部分用户看到旧数据,这些损失该怎么办?这背后是又一个思维误区:”我要保证业务100%可用”。答案很直接:做不到,也没有巧妙的方案能绕开这一点——光速和网络传播速度、硬盘读写速度、各种极端异常情况的不可控性,这些都是物理规律决定的硬限制,异地多活理论上就不可能做到100%可用。面对这个思维误区,正确的心态是”忍”——接受一小部分用户或业务上的损失,因为如果非要为了保住最后0.01%用户的可用性去做一个”完美”方案,反而可能因为方案本身过于复杂脆弱,结果连99.99%的用户都保证不了。对实时强一致性要求高的业务,受影响的用户比例甚至可能更高——以银行转账为例,如果假设北京和上海两个业务中心都支持”实时转账”式的异地多活,某个异常场景下小明明明只有1万元存款,却可能在北京转给张三1万元的同时又在上海转给李四1万元,两笔都转账成功,这种漏洞一旦被利用后果严重,所以银行转账这类业务根本不能做”实时转账”式的异地多活。但可以换一种业务手段变相实现异地多活:除了”实时转账”,再提供一个”转账申请”通道——用户在上海提交转账申请后,上海中心不立即执行,而是先记录下这个申请,再异步向北京发起真正的转账操作;如果此时北京中心不可用,申请就先排队等待重试;等北京中心恢复了再去真正执行转账,如果那时候余额已经不够了,这笔申请就失败,用户登录后会看到”余额不足”的失败提示。这种”转账申请”方式确实是拿用户体验换来的——原本一次操作的事,现在拆成了”提交申请”和”确认结果”两步。但为了让用户少受这个体验损失,可以配合一些安抚和补偿手段:挂公告说明情况(不方便说明原因时,用”技术哥哥正在紧急处理”这类轻松说法也可以);事后给受影响用户补偿代金券、小礼包这类实惠;针对具体体验损失点做补充体验优化(比如转账申请成功或失败后直接发短信通知结果,用户就不用反复登录确认)。综合前面四个技巧,异地多活设计的核心思想可以归纳为一句话:采用多种手段,保证绝大部分用户的核心业务异地多活。 进一步展开见只保证绝大部分用户。

注册要做异地多活会遇到冲突:A 中心宕机前新注册的账号没同步到 B,B 无法判断手机号是否已注册。有人提议干脆允许一个手机号注册多个账号。作者认为不可行:“一个手机号一个账号”是核心业务规则,改它几乎所有业务都要重新设计,为了架构去改核心业务规则得不偿失。正确方向是缩小多活范围,只保证登录等核心业务多活。发散:架构服务业务,不能反过来让业务迁就架构。参见只保证核心业务多活。 进一步展开见不为架构改核心规则。

原书依据 · 15 处

异地多活设计4步走

跨城异地多活的第一步是业务分级,只为核心业务做多活,控制复杂度和成本。常见标准有三条:访问量大,如用户系统中的登录;核心业务,如 QQ 的聊天比空间更核心;产生大量收入,如 QQ 空间能插广告,按收入看优先级反而可能高于聊天。几条标准可能给出相互矛盾的排序,要结合业务实际判断,没有通用答案。用户系统中登录同时满足访问量大和核心业务两条,因此被选为多活对象。 进一步展开见业务分级的三条标准。

业务分级的三条标准选出核心业务后,第二步要对核心业务相关的数据做特征分析,这些特征会直接决定后续同步方案怎么设计,常见维度有五个。数据量:包括总量和新增/修改/删除量,异地多活真正要同步的是变更量,变更量越大,同步延迟发生的概率越高,同步方案要针对性考虑。唯一性:指多个异地机房各自产生的同类数据是否必须全局唯一,比如用户ID如果两个机房各自注册出了同一个ID就会直接出业务错误——数据要求唯一,就要么只能在一个中心生成、要么设计一套全局唯一生成算法;数据不要求唯一,两地各自产生同类数据就没问题。实时性:指A机房修改的数据要求多长时间内必须同步到B机房,实时性要求越高,同步方案的复杂度越高。可丢失性:指数据丢了对业务有没有重大影响,比如登录产生的session数据是可丢失的(用户重新登录就能拿到新的),但用户ID数据是不可丢失的(丢了会连带丢失该用户所有关联数据,比如好友关系、账户余额)。可恢复性:指数据丢了之后能不能通过某种手段找回来,能恢复就意味着实际影响没那么大、可以相应降低架构设计的复杂度——比如用户微博丢了可以重发一条一模一样的内容(可恢复),密码丢了可以走找回密码流程重设(可恢复),但用户账号本身丢了用户直接就没法登录、系统也没有其他途径能把这个账号找回来(不可恢复)。这五个维度合在一起,构成了判断”这份数据该用什么同步策略”的分析框架,比如登录业务涉及的账号数据(要求唯一、不可丢失、不可恢复)就必然需要比session数据(可丢失、可重新生成)严格得多的同步保障。 进一步展开见数据分类的五个维度。

按数据分类的五个维度分析清楚每类数据的特征后,就能针对性设计同步方案,常见有三种。存储系统同步是最常用也最简单的方式(如MySQL的主从/主主同步),优点是几乎主流存储系统都自带这套能力、用起来简单,缺点是这类同步是通用设计、无法针对具体业务数据特点做定制——比如MySQL不管要同步的数据量多大,通常只有一个同步通道,为了保证事务性,一旦数据量大或网络有延迟,同步延迟就会比较严重。消息队列同步靠独立的消息队列(Kafka、ActiveMQ、RocketMQ等)来做,适合无事务性、无时序性要求的数据——比如两个用户先后注册了账号A和B,即使异地同步时先同步了B再同步A,业务上也没问题,这类数据适合走消息队列;但如果是用户密码,用户先把密码改成m、又改成n,同步时必须严格保证先同步m再同步n,一旦顺序反了,最终同步过去的密码就是错的,这类对顺序敏感的数据就不适合用消息队列同步。重复生成则是完全不做数据同步,让每个机房各自独立生成数据,适合那些可以重复生成的数据,比如登录产生的cookie、session数据、缓存数据这类——反正每个机房都能按自己的逻辑重新造一份出来,没必要专门同步。三种方案的选择本质上是根据数据分类的五个维度分析出的数据特征来匹配:数据要求强顺序性/事务性就走存储系统同步,只要求最终到达、不要求顺序就走消息队列同步,能随时重新生成就干脆不同步、走重复生成。 进一步展开见数据同步三种方案。

不管数据同步三种方案设计得多好,极端异常下总会出现同步延迟、数据丢失、数据不一致这类问题,异常处理要达成三个目的:问题发生时避免少量数据异常拖垮整体业务、问题恢复后修正异常数据、对受影响用户做安抚补偿。常见措施有四类。多通道同步指用多种方式并行同步数据,一条通道故障时还有另一条兜底——比如用户账号数据本来用消息队列同步,考虑到消息队列通道可能中断或严重延迟,再加一条MySQL主从同步作为备份,两条通道同时故障的概率远低于单一通道;关键设计点是通常两条通道就够(更多通道理论上更保险,但成本涨得也快)、两条通道不能共用同一条网络连接(一个走公网、一个走内网这种物理隔离才有意义)、且要求数据本身可重复覆盖(谁先到谁后到最终结果都一样,比如新建账号数据符合、密码数据就不符合)。同步和访问结合指异地机房通过接口互相调用来读取对方的数据(比如B机房本地没有A机房刚同步过来的数据,就直接调A机房接口取),关键设计点是接口访问通道不能和数据库同步通道共用同一条网络、要有路由规则判断该访问哪个机房的接口、并且要优先读本地数据、本地读不到才走接口访问以降低跨机房调用量,特别适合实时性要求非常高的数据。日志记录用于故障恢复后修数据,做法是每个关键操作前后都记一条日志、单独保存,故障恢复后拿日志和实际数据比对修复——根据要应对的故障级别不同,日志保存方式也分级:存在服务器本地能应对单台数据库故障,存在独立本地系统能应对服务器和数据库同时宕机(比如两者部署在同一机架或同一电源线路上时会一起挂),日志异地保存则能应对整个机房宕机的极端情况,方案越能应对更严重的故障,复杂度和成本也越高,需要综合权衡。用户补偿则是承认前面三类措施终究无法做到100%没有影响(双通道也可能同时故障、日志本身也可能丢),系统方案的目标是保证99.99%的用户不受影响,剩下0.01%的损失只能靠人工补偿(代金券、礼包、礼品、红包等)来弥补、培养用户忠诚度——暴雪《炉石传说》2017年回档事故就是一个真实案例:给每个受影响玩家补偿了约合人民币200元的游戏物品(1000金币+15个卡牌包),最终玩家的反应是”求暴雪再来一次回档”,充分说明了到位的补偿能把一次故障转化成正向的用户口碑。 进一步展开见异常处理四类措施。

原书依据 · 11 处

如何应对接口级的故障?

异地多活应对的是宕机、机房、网络等系统级故障,影响大但概率低。接口级故障概率更高:系统没宕机、网络也没断,但业务出了问题,表现为响应缓慢、大量超时或异常,根源通常是压力太大,例如一条慢查询耗尽数据库资源。成因分内部,如 bug 死循环、慢查询、内存耗尽;和外部,如攻击、促销流量暴涨、第三方响应缓慢。应对思路与异地多活相通:优先保证核心业务和绝大部分用户,不追求百分之百不受影响。 进一步展开见接口级故障与应对思路。

降级是主动降低某些功能的水平,可以只保留部分功能,也可以直接停掉,例如论坛只能看帖不能发帖,App 的日志上传接口整段时间停用。核心思想是丢车保帅,论坛九成流量是看帖,就优先保住看帖。实现方式有两种:系统后门降级,预留带密码校验的 URL 作为降级指令,成本低,但服务器多时要逐台操作,故障时效率不够;独立降级系统,用多建一套系统的成本,换取权限管理和一键批量操作的响应速度。 进一步展开见降级是丢车保帅。

熔断和降级都会禁止某些功能,但对象不同:降级应对自身故障,熔断应对依赖的外部系统故障。A 服务的 X 功能依赖 B 服务的接口,B 变慢时 A 的线程大量卡在 X 上,最终拖垮 A 的其他功能;熔断让 A 发现 B 接口有问题后直接返回错误,不再发起请求,避免被连累。落地要点有二:必须有统一的 API 调用层做采样统计;阈值要合理,如“1 分钟内 30% 请求超过 1 秒”,一般先凭经验设定,上线后观察再调优。 进一步展开见熔断应对依赖方故障。

降级是丢车保帅是从系统功能优先级角度应对故障,限流则是从用户访问压力角度应对——只放行系统能扛住的访问量,超出部分直接丢弃,虽然”丢弃”这个词听起来不太友好,但能保证一部分请求正常响应,总比全部请求都扛不住要好。限流常见分两类。基于请求限流是从外部访问角度限制,又分两种:限制总量(限制某个指标的累积上限,如某直播间总用户数上限100万、某抢购活动参与用户上限1万)和限制时间量(限制一段时间内某指标的上限,如1分钟内只放10000用户访问);实现简单是共同优点,但共同的痛点是很难找到合适的阈值——可能设了1分钟10000用户,实际6000用户系统就扛不住了,也可能到了10000这个阈值时系统压力其实还很轻松就已经开始拒绝新用户了;而且硬件差异也会干扰阈值判断,一台32核机器和一台64核机器处理能力差别很大,但不能简单按核数做线性换算——64核相比32核,业务处理性能可能只是1.5倍甚至1.1倍,不是想当然的2倍。基于资源限流则是从系统内部出发,找到真正影响性能的关键资源(连接数、文件句柄、线程数、请求队列等)、限制其使用上限——比如用Netty实现的服务器给请求队列设个最大长度10000、满了就拒绝后续请求,或者CPU占用率超过80%就开始拒绝新请求;相比基于请求限流,基于资源限流能更真实地反映当前系统的实际压力,但同样面临两个难点:如何确定该盯住哪个关键资源、如何确定这个资源的合理阈值。两类限流的阈值确定都不是一次到位的事,通常都要经过”先按推断/性能压测定一个初始值→上线观察运行情况→发现不合理再调优”这个反复迭代的过程;基于请求限流因为逻辑相对简单,更适合功能比较单一的系统(负载均衡系统、网关系统、抢购系统这类)。 进一步展开见请求限流与资源限流。

排队本质上是请求限流与资源限流的一个变种:限流是直接拒绝超出承受能力的请求,排队则是让这些请求先排着、等一段时间再进系统(12306网站的排队是最典型的例子);但排队并不天然意味着更好的用户体验——用户排了很长时间才进来,体验未必比被限流直接拒绝好多少。由于排队需要临时缓存大量还没处理的业务请求,这个数据量单个系统内部通常撑不住,一般要用独立系统来实现,比如用Kafka这类消息队列专门缓存这些排队中的用户请求。以1号店”双11”秒杀排队系统为例,其架构由三个模块组成:排队模块负责接收用户的抢购请求,按先入先出的方式缓存下来,每个参与秒杀的商品单独维护一个队列,队列大小按参与秒杀的商品数量(外加一定余量)来定;调度模块负责在排队模块和服务模块之间做动态调度,不断检查服务模块是否还有处理能力空闲,一旦有空闲就从队头把请求调入服务模块,本质上不只是简单转发请求,还承担着根据服务模块实际处理能力来动态调节拉取速度这个更关键的职责;服务模块负责真正调用业务逻辑处理请求、产出结果,再回写给排队模块。这套架构的核心思路是把”瞬时涌入的海量请求”和”系统真正的处理能力”解耦开——排队模块负责削峰填谷式地暂存请求,调度模块负责按系统实际吞吐能力精确控制放行速度,而不是让所有请求一股脑同时冲击后端服务,这正是排队相比直接限流拒绝更”温和”的地方。 进一步展开见排队是限流的变种。

原书依据 · 14 处

可扩展架构的基本思想和模式

软件系统和硬件、建筑最根本的差异在于软件天生是可扩展的——一颗CPU生产出来就不会再回工厂加功能,一座金字塔矗立千年结构从未改变,但一个软件系统如果开发出来后再也没有更新迭代,反而说明它没有生命力,真正有生命力的系统(如Windows从3.0一路演化到10)都在持续发展。这种天生的可扩展性既是软件的魅力所在,也是难点所在:魅力在于可以不断通过修改扩展让系统跟上新需求;难点在于如何以最小代价完成扩展,因为很多时候牵一发动全身,扩展时到处都要改、到处都要推倒重来,改动范围越大,投入越大、出错概率也越大。可扩展性架构设计万变不离其宗,背后的核心思想可以归结为一个字:”拆”——把原本大一统的系统拆成多个小规模部分,扩展时只需要动其中一部分,不用整个系统到处改,从而缩小改动范围、降低改动风险。但软件系统的”拆”和日常生活里用推土机拆房子、用剪刀拆快递这种破坏性的拆完全不同,软件的拆是建设性的——目标不是摧毁系统,而是让系统变得更优美、更具备可扩展性,因此难度要高得多。按不同思路拆分软件系统,会得到不同架构,常见的拆分思路有三种,理解它们的关键是弄清”流程”“服务”“功能”三者的范围关系:从大到小依次是流程>服务>功能。以TCP/IP协议栈为例:流程对应”应用层→传输层→网络层→物理和数据链路层”这个不管应用层具体是什么、都固定不变的通信流程;服务对应应用层里的HTTP、FTP、SMTP这类具体服务(HTTP提供Web服务、FTP提供文件服务、SMTP提供邮件服务);功能对应每个服务内部更细粒度的能力(HTTP的GET/POST、FTP的上传下载、SMTP的邮件收发)。据此,面向流程拆分是把整个业务流程切成若干阶段、每个阶段作为一部分;面向服务拆分是把系统提供的各类服务分别独立出来;面向功能拆分是把每个服务内部提供的具体功能进一步拆细。 进一步展开见可扩展的基本思想是拆。

有人认为只要代码写得规范,不拆分也能控制修改范围。这只在团队全是熟悉业务的高手时成立。现实中团队水平参差:新手不知该改哪里就挑好改的地方改,有人粗心,有人某天状态不佳,新人不了解历史就把“丑代码”顺手改掉,破坏了隐藏的约束。合理的拆分能在这些不确定因素存在时,把出错范围强制限定在可控边界内,改错了也不会扩散到整个系统。拆分正是为应对团队不完美而存在的。 进一步展开见拆分约束出错范围。

可扩展的基本思想是拆里的流程/服务/功能三种拆分思路,各自带来不同的扩展优势,对应不同的典型架构。面向流程拆分时,扩展一个功能通常只需要改动其中一层、少数情况下改动相邻两层,不会所有层都跟着一起动——比如学生信息管理系统按”展示层→业务层→数据层→存储层”拆分后,要把存储层从只支持MySQL扩展到同时支持MySQL和Oracle,只需要改存储层和数据层,展示层和业务层完全不受影响;这种拆分方式对应的典型架构是分层架构。面向服务拆分时,扩展或新增某个服务,只需要动相关服务,其他服务不受影响——同样以学生管理系统为例,注册服务里要加”学号注册”功能,只需要改”注册服务”和”登录服务”,”信息管理服务”和”安全设置服务”完全不用动;这种拆分方式对应SOA和微服务架构。面向功能拆分时,扩展或新增某个功能,只需要动相关功能模块——比如新增”学号注册”功能,只需要新增一个功能模块、再改一下”登录功能”模块,其他功能模块都不受影响;这种拆分方式对应微内核架构。这三种拆分方式和对应的架构并不是互斥的单选题,而是可以在同一个系统里组合叠加使用——比如学生管理系统整体可以采用面向服务拆分的微服务架构,拆成注册服务、登录服务、信息管理服务、安全服务四个独立运行的子系统;其中”注册服务”这个子系统内部又可以进一步采用面向流程拆分的分层架构;”登录服务”这个子系统内部则可以采用面向功能拆分的微内核架构——不同粒度的拆分思路可以嵌套组合,按各自子系统的具体需求灵活选用。 进一步展开见三种拆分的典型架构。

原书依据 · 8 处

传统的可扩展架构模式:分层架构和SOA

三种拆分的典型架构里面向流程拆分对应的分层架构(也叫N层架构,N至少是2层,常见3层如MVC/MVP、4层,5层较少见、一般是操作系统内核这类复杂系统才会用到),按不同的划分维度和划分对象,会得到不同风格的分层架构。C/S架构、B/S架构划分的对象是整个业务系统,划分的维度是”用户交互”——把和用户直接打交道的部分独立成一层,支撑用户交互的后台作为另一层。MVC架构、MVP架构划分的对象是单个业务子系统,划分的维度是”职责”——把不同职责划到独立的层,但各层之间的依赖关系比较灵活,比如MVC里各层是两两交互的(不是严格单向)。逻辑分层架构划分的对象可以是单个业务子系统也可以是整个业务系统,同样按职责划分,但和MVC/MVP的关键区别在于它的层是自顶向下单向依赖的,典型代表是操作系统内核架构、TCP/IP架构、J2EE系统架构。无论用哪种维度分层,分层架构设计最核心的一条原则是:必须保证各层之间的差异足够清晰、边界足够明显,让人看一眼架构图就能看懂整个系统——这也是分层不能分太多层的原因,一旦两层之间的差异变得模糊,就会出现程序员小明认为某功能该放A层、程序员老王认为该放B层这种分歧,一旦这种混乱的架构真落地开发,A层和B层就会乱成一锅粥,分层也就失去了意义。 进一步展开见分层架构的三种维度。

分层能支撑扩展,是因为隔离关注点:每层只处理本层逻辑,扩展一层不影响其他层,如 Linux 新增文件系统只改存储层。但简单分层并不天然做到这一点,前提是层间依赖稳定。若没有抽象出 VFS,只是把 ext2、ext3 等归为一层,每新增一种文件系统,上层都要适配;有了 VFS,上层依赖稳定接口,新增文件系统只需适配 VFS。对复杂系统值得把接口独立成层,简单业务系统再加一层接口层就是画蛇添足。 进一步展开见分层扩展靠稳定依赖。

分层要求请求严格逐层传递,不能跨层,从而把依赖限定为相邻层之间,降低整体复杂度。代价是冗余:查看头像时 AvatarView、AvatarBizz、AvatarDao 三层方法几乎一样,只是转发。但不要为省事允许跨层,口子一开,久而久之表现层直连持久层,分层控制影响范围的价值就没了;转发函数本身几乎不费工。另一个代价是性能,每个请求都要穿越所有层,但以今天的硬件,这点损失通常可以忽略。 进一步展开见分层层层传递的代价。

SOA(Service Oriented Architecture,面向服务的架构)诞生于1990年代,是面向服务拆分对应的一种架构理念(不同于分层层层传递的代价所属的面向流程拆分)。它出现的背景是企业内部IT系统重复建设、协作效率低下:企业各部门往往各自有独立的IT系统(人力资源系统、财务系统、销售系统),这些系统可能都要重复实现类似人员管理这样的功能(比如某员工离职,要分别到三套系统里各自删一次权限);各系统还常常是不同供应商提供的,实现技术各不相同,企业自己也很难对它们统一重构;随着业务复杂度上升,越来越多流程需要多个IT系统协作完成,但这些系统本身没有统一的实现标准(比如人力资源系统用Java对外提供RPC、财务系统用C#对外提供SOAP),每次开发新的跨系统流程都要协调大量异构系统、逐一定制开发,效率很低。针对这些问题,SOA提出了三个关键概念。服务:所有业务功能都被视为一项服务,服务意味着要对外开放能力,别的系统要用时无须为它定制开发;服务的粒度可粗可细,比如”人力资源管理”可以整体是一项服务,其中”人员基本信息管理”“组织结构管理”也可以各自拆成独立的服务,具体粒度要看企业实际情况判断。ESB(Enterprise Service Bus,企业服务总线):借用计算机总线的思路,把企业内各个异构服务连接起来——因为各服务实现方式各不相同、对外接口各式各样,ESB负责屏蔽这些差异,统一完成协议转换、数据转换等工作,让服务之间能高效互联互通。松耦合:目的是减少各服务间的相互依赖和影响,因为SOA架构下各服务本应独立运行,如果做不到松耦合,某个服务一升级,依赖它的其他服务可能全部跟着故障——但真正做到完全后向兼容其实是一项复杂的工作,说起来容易做起来难。 进一步展开见SOA的服务与ESB。

SOA 是企业级的架构理念,通常说“企业用 SOA 构建 IT 系统”,而不说某个系统用 SOA:拆出人力资源、考勤、财务等服务后,人力资源服务本身多是外购的,不会再按 SOA 往下拆,也不会单独部署 ESB。SOA 解决了重复建设和协作低效,但 ESB 带来很大复杂性:要在多种协议与数据格式之间转换和路由,工作量大、耗资源,消息量大时会成为瓶颈。这是为兼容已运行多年的异构系统而做的妥协。 进一步展开见SOA是企业级理念。

原书依据 · 15 处

深入理解微服务架构:银弹 or 焦油坑?

关于微服务和SOA的关系,常见三种观点:微服务是SOA的一种具体实现方式;微服务是去掉ESB后的轻量化SOA;微服务和SOA只是相似、本质上是两种不同的架构理念。要判断哪种观点更准确,需要对比几个具体维度。服务粒度上,SOA的服务通常更粗(比如”员工管理系统”整体作为一项SOA服务),微服务的服务更细(同一个”员工管理系统”在微服务架构下会拆成员工信息管理、考勤管理、假期管理、福利管理等更多独立服务)。服务通信上,SOA靠ESB这个重量级组件负责服务定义、路由、消息转换、消息传递;微服务推荐用统一的轻量协议(RESTful、RPC),Martin Fowler把这种通信理念称为”Smart endpoints and dumb pipes”(聪明的终端,愚蠢的管道)——之所以说管道”愚蠢”,是相对ESB而言:ESB既知道每个服务用什么协议(RMI还是HTTP)、又知道数据类型(XML还是JSON)、还知道具体格式(日期是2017-01-01还是01/01/2017),而微服务的”dumb pipes”只负责传消息,对消息内容和格式一无所知。服务交付上,SOA对交付方式没有特殊要求(因为它更关注兼容已有系统),微服务的理念要求”快速交付”,因此天然要求自动化测试、持续集成、自动化部署这类敏捷开发能力,没有这些支撑,微服务数量一旦超过约20个,整体交付速度反而会明显变慢。应用场景上,SOA更适合庞大、复杂、异构的企业级系统(这正是SOA的诞生背景:很多系统已运行多年、技术栈各异、有自研有采购,无法推倒重来,只能靠ESB兼容),微服务更适合快速、轻量、基于Web的互联网系统(业务变化快、需要快速试错快速交付,虽然技术栈也可能不同,但对外基本都是HTTP RESTful接口,不需要ESB那套复杂适配)。综合这几个维度,微服务和SOA本质上是两种不同的架构设计理念,只是在”服务”这个点上有交集——这正对应前述第三种观点。Martin Fowler本人对微服务的定义精炼出了三个关键词:small(小)、lightweight(轻量)、automated(自动化),这三个词基本浓缩了微服务的精髓,也正是它和SOA的本质区别所在。 进一步展开见微服务与SOA四维对比。

微服务看似处处优于 SOA,容易被不加思考地照搬,第一个陷阱是服务划分过细。拆得越细,单个服务确实越简单,但整体复杂度没有消失,只是从系统内部转移到了系统之间:n 个服务两两相关时,关系数为 n(n-1)/2,随服务数量急剧增长。粗粒度时服务体量大但关系简单,细粒度时服务小但调用关系纵横交错。粒度与团队和业务不匹配时,得到的不是更简单的系统,而是更难驾驭的服务网络。 进一步展开见拆太细转移复杂度。

“微”字容易让人以为拆得越细越好,结果五六个人拆出三十多个服务,人均维护五个以上。一个简单需求被拆散到多个服务里,光接口就要设计六七个:开发要打开多个工程、同时部署多个程序调试、提测打多个包;测试要部署多套环境、准备多份数据;运维上线要操作多个相互依赖的服务,顺序稍错就出问题。细粒度拆分不是目的,要服务于团队和业务的实际需要,脱离团队规模追求“微”只会让协作处处多跑一趟。 进一步展开见微字迷思拆得过细。

微服务之间靠HTTP或RPC通信,每次调用都要走一趟网络,这会同时带来两个问题。第一是性能下降:线上业务接口之间的平均响应时间大约50毫秒,如果一次用户请求要串联6次微服务调用,光是这部分调用开销就要300毫秒,这在很多对性能要求高的业务场景下根本无法接受,为了硬扛住这个开销往往只能靠堆更多硬件,直接推高了硬件成本。第二是故障定位困难:拆成微服务后,一次用户请求要靠多个微服务协同处理,任意一个微服务出故障都可能导致整体业务失败,但因为微服务数量多、故障还会沿调用链扩散,快速定位到底是哪个环节出的问题变得很复杂——比如Service C的数据库出现慢查询,导致它给Service B的响应出错,Service B又把错误传给Service A,Service A最终把错误呈现给用户;但真实排查时不会像示意图这么清晰,最初往往只有”用户报错”这一个线索,排查团队通常先查Service A,导致Service A故障的可能原因非常多,可能要花半小时到一小时才发现其实是Service B的响应有问题,于是又要花类似的时间去查Service B,如此层层往下排查,最终定位到根因(Service C的数据库慢查询)可能要耗费好几个小时;如果多个微服务同时出现不同类型的故障(比如Service C数据库慢查询的同时,Service C到Service D的网络又出了问题),要确定到底是哪个原因导致了最终的错误响应,需要投入更多信息收集和人力排查,复杂度进一步叠加。 进一步展开见调用链变长的代价。

微服务理念强调”快速交付”,但如果没有自动化系统支撑、全靠人工操作,不仅达不到快速交付的目的,效率反而可能比一个大而全的单体系统还低:没有自动化测试,每次测试都要人工把大量接口测一遍;没有自动化部署,每次上线要在几十台机器上逐台敲shell命令部署6~7个服务,运维人员手都要敲麻;没有自动化监控,每次故障排查都要人工去翻几十台机器、几百个微服务各自的状态和日志文件。信奉微服务的人常常拿SOA的ESB当反面教材来凸显微服务”lightweight”的优越性,但实践后会发现,随着微服务种类和数量越来越多,没有服务治理系统支撑,这份”轻量级”反而会自己变成新的问题:服务路由——假设某个微服务有60个节点、分布在20台机器上,其他依赖它的服务怎么知道这个部署布局?服务故障隔离——如果这60个节点里有5个出了故障,依赖它的服务该怎么应对?服务注册与发现——如果决定把节点从60个扩容到80个、或者从60个缩到40个,新增或减少的节点怎么让依赖它的服务及时知道?如果这些场景全靠人工去管理,整个系统必然陷入混乱,唯一的出路是引入自动化的服务治理系统去承担这些工作——但一旦走到这一步,会发现微服务当初标榜的”轻量级”,最终演变成了和ESB几乎同等复杂的东西,只是复杂性从”服务间通信这一层”转移到了”服务治理这一层”而已。 进一步展开见缺治理的微服务成ESB。

原书依据 · 10 处

微服务架构最佳实践 - 方法篇

针对过分强调“小”的问题,可以按团队规模确定粒度,即“三个火枪手”原则:一个微服务由 3 人负责,团队从 6 人扩到 12 人时,微服务相应从 2 个拆成 4 个。为什么是 3 人:3 人负责的系统复杂度刚好让每个人都能全面理解又能分工;有人休假或被抽调,剩下 2 人仍能支撑,1 人则是单点;3 人讨论既不易僵持又能较快达成一致。该原则用于设计开发阶段,进入稳定维护期后可 1 人维护多个,但每个服务最好至少 2 人共同维护。 进一步展开见三个火枪手原则。

三个火枪手原则确定了大致该拆出多少个服务,但具体按什么维度拆,不是只能按业务这一条路,而是可以按不同目的灵活选择甚至组合。基于业务逻辑拆分是最常见的方式,按职责范围识别业务模块、每个模块独立成一个服务;但实践中最大的坑是团队对”职责范围”该划多细经常争执不下(比如电商系统拆成”商品、交易、用户”3个服务还是”商品、订单、支付、发货、买家、卖家”6个服务,业务角度看粗细都说得通,谁也说服不了谁)——根源在于业务逻辑本身既支持粗粒度也支持细粒度划分,判断粒度不该从业务逻辑本身出发,而该先按”三个火枪手”原则算出大致的服务数量范围,再据此反推合适的”职责范围”:团队10人,大约拆4个服务,”登录、注册、用户信息管理”可以合并进一个”用户服务”;团队100人,能支撑到40个服务,”用户登录”本身就能独立成一个服务;团队1000人,”用户连接管理”这种更细的点都可能独立成服务。基于可扩展拆分是按稳定性排序:已经成熟、改动很少的模块拆成”稳定服务”(粒度可以粗一点,甚至逻辑上没强关联的服务也能塞进同一个子系统,比如”日志服务”和”升级服务”放一起),经常变化迭代的模块拆成”变动服务”(粒度可以细一点,但也不能无节制细分,要始终盯住服务总数),目的是让快速迭代的部分不至于不小心影响到已经稳定的成熟功能。基于可靠性拆分是按优先级把可靠性要求高的核心服务和要求低的非核心服务分开,重点保证核心服务的高可用,好处有三层:避免非核心服务故障拖累核心服务(比如日志上报量激增不会影响到核心业务);核心服务本身逻辑更简单、数据更少、依赖组件更少,高可用方案设计起来也更简单;核心服务独立后占用的机器带宽等资源比不拆分时少很多,高可用成本自然也降下来了。基于性能拆分思路类似基于可靠性拆分,把性能要求高或压力大的模块单独拆出来,避免它拖累其他服务,比如电商抢购场景里压力最大的入口排队功能,就适合独立成一个服务。这四种拆分方式不是互斥的单选题,完全可以自由组合——比如基于可靠性拆出服务A、基于性能拆出服务B、基于可扩展拆出C/D/F三个服务,再加上原有服务X,最终一共形成A/B/C/D/F/X六个服务。 进一步展开见微服务拆分四维度。

大部分人关注微服务的”small”和”lightweight”,但真正决定微服务能否落地成功的,恰恰是最容易被忽视的”automated”——如果服务粒度划分不合理,团队遇到问题后自然会想办法拆服务或合服务来纠正;但如果”automated”相关的基础设施不健全,微服务就会变成一个焦油坑,让研发、测试、运维都陷进缺治理的微服务成ESB描述的各种困境。完整的微服务基础设施体系看起来阵仗很大,很容易让人怀疑:”这么多基础设施,还好意思说自己’轻量级’?”——确实如此,微服务并没有真正减少复杂度,只是把原本集中在ESB里的复杂度转移分散到了这一整套基础设施里:”服务发现”“服务路由”这些能力本质上就是ESB原本承担的功能,只是在微服务架构里被剥离出来,各自变成了独立的基础系统。不过团队规模小、公司体量不大也不必因此对微服务望而却步,原因有两点:一是已经有成熟的开源微服务基础设施全家桶可以直接用(比如Spring Cloud,涵盖服务发现、服务路由、网关、配置中心等能力);二是微服务数量不多的情况下,并非每一层基础设施都是刚需,可以按优先级分阶段搭建。建议的优先级是:第一层,服务发现、服务路由、服务容错——这是最基本、无论如何都需要的微服务基础设施;第二层,接口框架、API网关——主要是为了提升开发效率,接口框架提升内部服务间的开发效率,API网关提升和外部系统对接的效率;第三层,自动化部署、自动化测试、配置中心——主要是为了提升测试和运维效率;第四层,服务监控、服务跟踪、服务安全——主要是为了进一步提升运维效率。第三层和第四层的重要性会随微服务节点数量增加而水涨船高,但在节点数量还不多的阶段,靠人工方式支撑虽然效率不高,也基本能顶住,不必一开始就追求把四层基础设施全部一次性建齐。 进一步展开见微服务基础设施优先级。

原书依据 · 8 处

微服务架构最佳实践 - 基础设施篇

微服务下人工操作的规模已不可持续。测试方面:拆分后服务间接口大量增加,又追求快速交付、频繁更新,人工回归跟不上,应由自动化测试覆盖单元测试、集成测试和接口测试,人力有限时至少保证接口测试自动化,因为接口最易出问题。部署方面:节点数是单体的几倍到十几倍,部署频率也大幅提高,某系统七成工作日都有部署,总次数可达单体的几十倍,需要自动化部署系统负责版本、资源、部署和回退。 进一步展开见自动化测试与部署。

微服务节点众多,逐台登录修改配置效率低、易出错,运行期配置还需要动态修改并即时生效,因此需要统一的配置中心,负责版本管理、增删改查、节点管理和配置推送,并能区分同一服务不同节点组的配置值。接口框架解决另一个问题:只统一 HTTP/REST 或 RPC 协议还不够,还要统一数据格式与字段规范,否则每个服务都要适配多套格式,等于把 ESB 的活摊给了每个服务。接口框架以各语言的库形式提供,而非独立系统。 进一步展开见配置中心与接口框架。

微服务内部可以点对点互相访问,但外部系统若也这样调用会很困难:它不需要、也无法理解内部众多服务的职责边界,只关心自己需要的能力。外部访问还涉及安全与权限,若直接访问各个微服务,每个服务都要各自实现一套安全和权限功能,工作量大且重复。解法是统一的 API 网关:所有外部接入都经过它,由它统一负责接入鉴权、权限控制、传输加密、请求路由和流量控制,外部系统无需感知内部服务的划分。 进一步展开见API网关统一外部入口。

服务发现要解决的问题是:微服务种类数量庞大,如果节点信息全靠手工配置写进每个微服务节点,配置文件可能要写几百上千行、几十个节点加起来就是几万几十万行,人工维护是灾难;而且节点经常变化(扩容、故障隔离部分节点、灰度升级新老版本共存),这些变化需要及时同步给所有依赖的微服务,手工配置根本做不到实时生效,因此需要一套自动化的服务注册与发现系统。服务发现有两种主流实现方式。自理式是每个微服务自己完成服务发现——比如服务实例A先访问服务注册表拿到服务注册信息,再直接访问服务实例B;这种方式实现相对简单,因为服务发现的逻辑一般通过统一的程序库或包提供给各微服务调用,不需要每个微服务重复造轮子,而且每个微服务都自己承担了服务发现的工作,访问压力天然分散到了各个节点,性能和可用性上都没有明显的集中风险。代理式是在微服务之间加一个负载均衡系统,由它统一完成服务发现——微服务本身实现变简单了,但这种集中化设计有两个明显风险:一是可用性风险,负载均衡系统一旦故障,会波及所有微服务之间的调用;二是性能风险,所有微服务间的调用流量都要经过这个负载均衡系统,压力会随微服务数量和流量增长而不断累积、最终可能成为性能瓶颈——为了应对这两个风险,负载均衡系统通常还得再设计成集群模式,而这本身又给系统引入了新的复杂性。不管走自理式还是代理式,服务发现的核心都是一份服务注册表,记录所有服务节点的配置和状态,每个微服务启动后要把自己的信息注册进去,之后由微服务自己(自理式)或负载均衡系统(代理式)到注册表里查询可用的服务。 进一步展开见服务发现两种方式。

服务发现两种方式解决了”知道有哪些可用节点”,服务路由解决的是”这次调用具体挑哪个节点”——路由和发现关系紧密,通常不会独立成一个系统,而是内嵌在发现系统里实现:自理式下路由逻辑在微服务内部实现,代理式下路由逻辑在负载均衡系统里实现;不管放在哪里,核心都是路由算法,常见的有随机路由、轮询路由、最小压力路由、最小连接数路由。服务容错针对的是微服务架构特有的”故障扩散”问题:拆成微服务后单个节点故障的概率变小、影响范围也变小,但节点总数大大增加,从整体看某个微服务出故障的概率反而变大,如果不及时处理,故障会沿调用链扩散、看起来像很多服务同时出了问题;靠人工逐个处理既投入大又速度慢,处理速度一慢故障扩散得更快,所以必须要有自动容错能力,常见手段包括请求重试、流控、服务隔离,通常也是集成在服务发现和服务路由系统里实现。服务监控解决的是”节点数量暴增后,靠人力监控和排障已经不现实”这个问题——需要监控的机器、网络、进程、接口调用数量都随节点数暴增,用户投诉后如果靠人工去几十个节点上翻日志,光是打开这些日志就要十几分钟;服务监控系统要做的是实时采集分析信息(避免故障后才临时分析、缩短处理时间)并在此基础上做预警(在问题萌芽阶段就发现,缩小影响范围和时长);因为需要采集处理大量数据,建议做成独立系统,不要塞进服务发现、API网关这类系统里。服务跟踪和服务监控的区别是宏观和微观:监控记录的是聚合统计信息(比如A服务请求B服务10次,B返回JSON,监控记录的是请求次数、平均/最高响应时间、错误码分布这类汇总数据),跟踪记录的是单次请求的完整链路细节(某一次请求的发起时间、响应时间、错误码、请求参数、返回内容等),目前业界绝大多数分布式跟踪和微服务跟踪的实现都基于Google的Dapper论文。服务安全解决的是”微服务之间技术上互联互通,但业务上敏感数据/操作只该部分服务能访问”这个矛盾,主要分接入安全、数据安全、传输安全三部分;通常集成在配置中心里实现——配置中心统一配置各微服务的接入安全策略和数据安全策略,微服务节点从配置中心拉取这些策略、处理具体调用请求时按策略执行,由于策略逻辑是通用的,一般也会封装成公共库供各微服务调用。 进一步展开见服务治理核心功能。

原书依据 · 15 处

微内核架构详解

微内核架构(也叫插件化架构)是面向功能拆分的可扩展架构,常用于基于产品的应用(如Eclipse这类IDE、UNIX这类操作系统、淘宝App这类客户端软件,甚至保险公司把不同险种的核算逻辑各自封装成插件)。它由两类组件构成:核心系统负责和具体业务无关的通用能力(模块加载、模块间通信等),插件模块负责实现具体业务逻辑(比如学生信息管理系统里的”手机号注册”功能)。核心系统本身相对稳定,不会因为业务扩展而频繁改动,插件模块则可以根据业务需要不断扩展——本质就是把”变化的部分”封装进插件,既能灵活扩展、又不影响整体系统的稳定性。核心系统的设计要解决三个关键点。插件管理:核心系统要知道当前有哪些插件可用、怎么加载、什么时候加载,常见做法是插件注册表机制——注册表可以是配置文件、代码,也可以是数据库,记录每个插件的名字、位置、加载时机(启动即加载还是按需加载)等信息。插件连接:指插件如何接入核心系统,核心系统必须先定义好插件的连接规范,插件按规范实现、核心系统按规范加载,常见连接机制有OSGi(Eclipse采用)、消息模式、依赖注入(Spring采用),甚至用RPC或HTTP这类分布式协议也可以。插件通信:设计上插件之间理应完全解耦,但实际业务运行时某个流程往往需要多个插件协作,这就要求插件间能通信——由于插件彼此没有直接联系,通信必须经过核心系统转接,核心系统因此要提供专门的插件通信机制,这个道理和计算机硬件很像:CPU、硬盘、内存、网卡是各自独立设计的配件,但运行时CPU和内存、内存和硬盘之间必然要通信,计算机靠主板上的总线来承载这些配件之间的通信,微内核的核心系统扮演的正是这个”总线”的角色。 进一步展开见微内核三个设计关键。

OSGi(Open Services Gateway initiative)诞生于1999年,最初由Sun、IBM、爱立信等公司组成的联盟制定,目标是为嵌入式设备(机顶盒、服务网关、手机、汽车)建立开放服务标准,后来因为动态化、热插拔、高复用性等优点被引入PC应用开发,尤其是Eclipse从3.0版本起弃用自己实现的插件框架、改用OSGi后,OSGi成了插件化标准的首选——需要注意OSGi本身只是一套规范标准,不是可运行框架,Eclipse用的具体实现叫Equinox,同类实现还有Apache Felix、Spring DM。OSGi的逻辑架构正好对应微内核三个设计关键的三个设计点。模块层实现插件管理功能:OSGi里插件被称为Bundle,每个Bundle是一个Java JAR文件,内含一个MANIFEST.MF元数据文件,记录Bundle的名称、描述、开发商、classpath以及需要导入/导出的包等信息,OSGi核心系统会把这些信息加载进系统供后续使用。生命周期层实现插件连接功能:提供运行时的模块管理和对底层OSGi框架的访问能力,精确定义了Bundle生命周期的各项操作(安装、更新、启动、停止、卸载),每个Bundle必须实现一个BundleActivator接口,在start()和stop()方法里定义自己启动和停止时该做什么。服务层实现插件通信功能:OSGi提供服务注册中心,各插件把自己能提供的服务注册进去,其他插件要用某个服务时直接去服务注册中心检索即可——比如一个Bundle在start()里用context.registerService()注册服务,无须在stop()里手动注销(Bundle停止时会自动注销它注册过的服务);另一个Bundle作为客户端,先用context.getServiceReference()从注册表拿到”服务引用”,再用这个引用去访问实际的服务实例。需要特别注意的是,这里的”服务注册”和模块层的”插件注册”不是一回事——插件注册解决的是核心系统怎么知道有哪些插件、如何加载它们,服务注册解决的是插件之间怎么互相发现和调用对方提供的能力,前者对应插件管理、后者对应插件通信。 进一步展开见OSGi落地微内核。

规则引擎从结构上看也是微内核三个设计关键的一种具体实现,执行引擎相当于微内核,负责解析配置好的业务流、执行其中的条件和规则。规则引擎在计费、保险、促销这类业务领域应用广泛,以电商促销为例,常见规则有”满100送50”“3件立减50”“3件8折”“第3件免费”“跨店满200减100”“新用户立减50”等,实际业务里完整列下来可能有几十上百种,再叠加各种排列组合,促销方案可能达到几百上千种——这种规模的业务如果完全靠写代码硬编码,开发效率根本跟不上业务变化的速度,而规则引擎能很好地应对这类需求,原因有三层:可扩展——引入规则引擎后业务逻辑和业务系统本身分离,扩展新业务功能不需要改动业务系统代码;易理解——规则用接近自然语言的方式描述,业务人员自己就能理解和操作,不像代码那样只有程序员才懂;高效率——规则引擎系统通常提供可视化的规则定制、审批、查询、管理界面,业务人员能自己快速配置新规则。规则引擎的运作流程是:开发人员把业务功能拆解提炼成多条规则、存入规则库;业务人员根据实际需要把这些规则排列组合、配置成业务流程、存入业务库;规则引擎读取执行这些业务流程来实现具体的业务功能。对照微内核架构的三个设计点:插件管理对应规则库——规则就是微内核架构里的插件、引擎就是内核,规则可以被引擎加载执行,规则通常存在数据库里;插件连接对应规则语言——就像程序员开发要用Java、C++这类语言,规则引擎也规定了专属的规则语言,业务人员基于这套语言编写规则文件,交由引擎加载执行,这套规则语言本身就是插件连接机制;插件通信对应数据流和事件流——因为单条规则不需要主动依赖其他规则,规则之间没有主动通信,每条规则只负责输出数据或事件,由引擎负责把这些数据/事件传递给下一条规则。目前最常用的开源规则引擎是JBoss Drools,用Java编写、基于Rete算法,社区活跃、执行速度快、兼容Java Rule Engine API(JSR-94),还提供基于Web的规则管理知识库Guvnor(支持版本控制和在线修改编译);但Drools号称简单易用,实际上其规则语言依然和编程语言比较接近,普通业务人员直接上手学习和理解成本仍然偏高,因此实践中通常需要在Drools基础上再做一层封装,把规则配置做成真正可视化的操作界面。 进一步展开见规则引擎与微内核。

原书依据 · 7 处

架构师应该如何判断技术演进的方向?

面对层出不穷的新技术,架构师常见有三种典型判断派别,本质是三种不同的价值观。潮流派热衷新技术,一有新技术出现就迫切想引入自己产品(比如”NoSQL很火,咱们要大规模切换成NoSQL”),价值观是”新技术肯定能带来很大收益”;问题在于新技术需要时间成熟,刚出来就用很可能自己成了实验小白鼠、踩各种坑,而且学习新技术本身要花时间成本,如果学完发现不适用,就是一笔较大的人力浪费。保守派对新技术保持很强的戒备心,”稳定压倒一切”,掌握了一种技术就一直用它打天下(就像那句俗语”如果你手里有一把锤子,那么所有的问题都变成了钉子”);问题在于享受不到新技术带来的收益——很多新技术本质是为了解决旧技术的固有缺陷,带来的往往不是线性的量变,而是爆发式的质变(就像汽车取代马车),无视技术发展,就好比有了拖拉机还偏偏要用牛车。跟风派不是跟技术潮流走,而是跟竞争对手走——竞争对手用了就跟着用,没用就先观望(比如”腾讯用了我们就用”“阿里用了Hadoop,咱们也要尽快用起来”);看起来很讨巧,既不承担潮流派的风险,也不遭受保守派的损失,花的资源也少,但最大的问题是”没风可跟怎么办”——如果自己恰恰是行业领头羊,没有可参照的对手;即使有竞争对手,对方的技术信息也未必容易获取,拿到的信息大概率也不完整,盲目照搬容易变成邯郸学步;而且适用于竞争对手的技术未必适用于自己,盲目模仿反而可能适得其反。三种派别共同的问题是:它们都站在”技术本身”的角度考虑问题,正所谓”不识庐山真面,只缘身在此山中”。 进一步展开见三种技术判断派别。

三种技术判断派别共同的盲点是都站在技术本身看问题,真正要看清方向,必须跳出技术、从企业业务发展这个更高的角度来看——支撑业务发展的是市场、技术、管理这个铁三角,业务处于三角形中心,三者都是为业务服务的。企业业务大致可分两类:产品类(360杀毒软件、iPhone、UC浏览器等,本质和传统制造业产品类似,用户购买或使用来完成任务,对产品是”独占”的)和服务类(百度搜索、淘宝购物、微信IM等,大量用户用它和别人交互,是”使用”而非”独占”,服务用户越多价值越大,正体现互联网”互联”+“网”的本质)。对产品类业务,答案是技术创新推动业务发展——比如苹果靠智能手机的技术创新把诺基亚拉下王座、UC浏览器靠云端架构和自研U3内核成为最大第三方手机浏览器,原因在于用户选择产品的根本驱动力是”功能是否更好地帮自己完成任务”,功能、性能、体验、外观都要靠技术支撑,因此技术领先能直接转化为产品竞争力。对服务类业务,答案正好相反:业务发展推动技术发展——原因是用户选择服务的根本驱动力不是”功能”而是”规模”:选UC浏览器还是QQ浏览器看个人喜好和体验,但选微信还是WhatsApp不是看功能差异,而是看身边人用哪个(哪怕个人更喜欢WhatsApp的简洁,身边人都用微信,也不得不用微信)。一旦”规模”成为决定因素,服务模式的创新才是业务发展的核心驱动力,产品只是承载服务的载体——淘宝提供的是”网络购物”这种服务,即便有软件公司半年内模仿出淘宝网、支付宝、菜鸟物流这些产品,也没有意义,因为用户选择的是淘宝那一整套已具规模的服务体系,不会因为对手产品功能更强就转投过去;同理,即使做出耗电量只有微信十分之一、体验好十倍的产品,绝大多数微信用户也不会因此改用它,因为微信不是一个”互联网产品”而是一个”互联网服务”,一个人单独换到同类产品毫无意义。服务类业务的发展路径是循环往复的:提出创新服务模式→吸引一批用户→业务开始发展→吸引更多用户→服务模式不断完善创新→吸引更多用户,在这条路径里技术不是驱动力,反而是用户规模扩大和业务不断创新对技术提出越来越高的要求,是业务在驱动技术。即使是产品类业务,把时间线拉长来看,技术创新开创一个新业务之后,后续的业务发展同样会反向推动技术发展(比如第一代iPhone不支持3G、只能通过Web发应用,第二代才开始支持3G并内置GPS;UC浏览器随功能越来越强大,架构也不得不从7.0一路演进到9.0)。综合来看,除非是开创新技术、直接推动或创造一种全新业务,绝大多数情况下都是业务的发展在推动技术的发展。 进一步展开见技术演进的动力。

技术该往哪里演进,答案在复杂度:业务需要技术跟进时,都是因为功能叠加或规模扩大使复杂度超出了原有技术的承受力。架构师的核心能力是判断当前及接下来的主要复杂度,这要基于行业和企业的发展阶段。银行在 90 年代面对功能与系统数量激增,2004 年后是网银的稳定与安全,2009 年后是需与支付机构协作应对的海量移动支付;淘宝则依次经历快速开发、性能、稳定性,到 2008 年变成内部过度耦合,于是做了系统解耦。 进一步展开见按发展阶段判断复杂度。

原书依据 · 11 处

互联网技术演进的模式

互联网业务通常经历初创、发展、竞争、成熟四个阶段。初创期重在创新而非完善,靠用户使用、快速试错来逐步完善,对技术的唯一要求是“快”,而这时团队最弱小,所以能买就买、有开源就用开源,第一版淘宝和 QQ 与今天几乎认不出是同一个产品。业务被验证后进入发展期,要不断完善功能,技术的核心工作是快速实现需求,先是在现有系统上不断堆功能;这时顾不上重构优化,不是偷懒,而是当下最理性的选择。 进一步展开见初创期只求快。

承接初创期只求快的堆功能期,功能越堆越多之后系统会变得越来越复杂,继续堆功能会越来越吃力、越来越慢,典型症状是改一个需求要动好多地方、一不小心就改出问题,直到团队再也受不了这种慢,才会下决心解决——这时通常会分裂成两派。优化派主张优化现有系统(重构代码、分层、优化某个MySQL查询、机械硬盘换SSD、MySQL换Oracle、加Memcache缓存),优点是改动小、能快速落地,缺点是可能撑不了多久系统又扛不住了。架构派主张调整系统架构,把原来的大系统拆成多个互相配合的小系统(比如把购物系统拆成登录认证、订单、查询、分析等子系统),优点是一次调整能支撑较长期的发展,缺点是动作大、耗时长、对业务的影响也更大。现实中大部分公司这个阶段都是优化派先赢,原因很直接:此时”优化”就是最快的方式,至于优化派撑不了多久这个问题,反而不是当下最要紧的事——毕竟业务能不能真的发展到那个阶段本身就是未知数,保住当下的竞争力才是第一位的。但如果业务真的继续发展,优化早晚会撑不住——再怎么优化,单机系统的能力总有极限(Oracle再强也扛不住1亿交易量,小型机再好也撑不住100万在线人数),这时候就没有别的选择,只能进入架构期,先前被压制的架构派开始扬眉吐气。架构期能用的手段很多,但归根结底就是一个字”拆”,可以拆的地方包括:拆功能(把购物系统拆成登录认证子系统、订单系统、查询系统、分析系统)、拆数据库(MySQL从一台变两台、两台变四台,加DBProxy、做分库分表)、拆服务器(服务器从一台变两台、两台变四台,加Nginx、HAProxy这类负载均衡系统)。 进一步展开见优化派与架构派之争。

承接优化派与架构派之争,业务发展到一定规模后必然会引来竞争对手,大家互相学习模仿、催生更多新业务创新,同时竞争压力也把技术要求推上一个新台阶。新业务创新意味着更多新系统,架构拆分又让原有系统越拆越多,两股力量叠加,系统数量在原有基础上进一步暴增,好不容易靠拆分换来的”快”又开始变”慢”——这背后是系统数量的量变到了临界点、引发了技术工作的质变,具体表现在两方面。一是”重复造轮子”:系统越来越多,各系统需要处理的相似问题也越来越多(每个系统都要存储、都要缓存、都要数据库),新建一个系统,这些基础工作又要重新做一遍,即使别的系统早就做过,也没法直接复用,速度自然快不起来。二是”系统交互一团乱麻”:系统之间的交互关系变成网状结构,交互数量和系统数量呈平方比关系(4个系统交互路径是6条,10个系统就变成45条),实现一个业务需求往往要同时改好几个甚至十几个系统、还要处理它们之间层层调用,联调成了研发的灾难、联测成了测试的灾难、部署成了运维的灾难。针对这两个问题,技术上主要的应对手段是平台化和服务化。平台化专门解决”重复造轮子”:把通用的基础能力沉淀成统一平台,比如存储平台化(淘宝TFS、京东JFS)、数据库平台化(百度DBProxy、淘宝TDDL)、缓存平台化(Twitter Twemproxy、豆瓣BeansDB、腾讯TTC),让新系统直接复用这些平台能力,不用每次都从零造轮子。服务化专门解决”系统交互混乱”:常见做法是用消息队列完成系统间的异步通知(淘宝Notify/MetaQ,开源Kafka/ActiveMQ),用服务框架完成系统间的同步调用(Facebook thrift、当当Dubbox、淘宝HSF),把原本网状的点对点调用收敛成有规范的通信方式。 进一步展开见竞争期平台化服务化。

熬过竞争期平台化服务化、成为行业领头羊或行业整体进入成熟阶段后,市场地位已经比较牢固,业务创新的空间和竞争压力都不再那么激烈,业务重心从”求快求新”转向”求精”——比拼响应时间是否更快、用户体验是否更好、成本是否更低。这个阶段技术上该拆的也拆了、该平台化的也平台化了,大动作已经不多,更多是精细化优化,但有些优化目标本身可能牵动很多方面(比如要把响应时间从200ms降到50ms,可能要同时优化CDN、数据库、网络等多个环节),这类优化没有固定套路,只能按竞争对手的对比结果找出自己的短板逐项优化,具体手段可以从前面各阶段(堆功能、优化、架构拆分、平台化、服务化)里灵活借用。除了业务复杂性这条主线,用户规模是互联网技术演进的另一条主线,同样贯穿初创期到成熟期,用户量增大对技术的影响集中在两方面。性能:以MySQL为例,单台机器不管配置多高,能撑住的TPS/QPS基本封顶在万级(低则几千、高不过几万),用户量涨上去后必须上多台MySQL,而”从一台到多台”不是简单的数量增加,是本质变化——从集中式存储变成了分布式存储,分布式意味着要处理分库分表、读写分离、复制同步这一整套新增复杂度。可用性:用户1万时宕机1小时可能没什么感觉,用户100万时宕机10分钟投诉电话就被打爆,用户还会在朋友圈吐槽,很可能就断送了接下来发展下一个100万用户的机会;从收入角度看同理,1万用户宕机1小时可能只损失几千元,100万用户宕机10分钟可能就是几十万元的损失——可用性的容错空间随用户规模扩大而急剧收窄。业务复杂性和用户规模这两条主线,本质上都是同一个规律的体现:”量变带来质变”——不管在哪个发展阶段,一旦发现业务已经”快不起来”了,就说明当前的技术水平已经跟不上业务发展的需要,是技术该变革的信号;更理想的做法是在问题真正暴露之前,就能根据发展趋势提前预判下一个转折点、提前做好技术准备,这对技术人员的判断力要求非常高。 进一步展开见成熟期求精与量变。

原书依据 · 13 处

互联网架构模板:”存储层”技术

NoSQL火了几年后大家发现关系数据不可能被完全抛弃,NoSQL不是No SQL、而是Not Only SQL,是对SQL的补充,因此互联网行业依然离不开关系数据,考虑到Oracle太贵还需要专人维护,一般都用MySQL、PostgreSQL这类开源数据库——优点是开源免费、拿来就用,缺点是性能不如商业数据库。SQL存储的演进大致分三个阶段。第一阶段是直接使用:业务量不大时直接用单实例数据库就够了;但随着业务发展,性能要求越来越高,必然要把数据拆到多个数据库实例才能撑住(这个瓶颈Oracle同样会遇到,只是时间早晚问题)。第二阶段是中间件:数据库拆分解决了性能问题,却带来”数据怎么拆、怎么组合”这个复杂度问题,如果每个业务都各自实现一遍,重复造轮子会浪费投入、拖慢业务开发速度,因此互联网公司普遍的做法是业务发展到一定阶段后,把分库分表这部分能力独立成中间件(如百度DBProxy、淘宝TDDL)——但把分库分表做到自动化、平台化本身技术门槛很高,通常只有规模足够大的公司才自己做,中小公司更适合直接用开源方案(MySQL官方推荐的MySQL Router、360开源的Atlas)。第三阶段是SQL存储平台:如果业务继续扩大、SQL服务器越来越多,每个业务都基于统一中间件各自独立部署一套SQL集群,又会带来新的复杂度——数据库资源利用率不高、各SQL集群分开维护导致维护成本持续攀升;因此实力雄厚的大公司会在SQL集群之上再构建统一的SQL存储平台,以对业务透明的方式统一提供资源分配、数据备份、迁移、容灾、读写分离、分库分表等一整套服务(比如淘宝的UMP,Unified MySQL Platform)。 进一步展开见SQL存储三阶段演进。

NoSQL 弥补了关系数据库存不了数据结构的短板,普遍以性能为卖点,且大多自带集群能力,如 Memcache 的一致性 Hash、Redis 3.0 集群,起步时用起来很方便,通常不必急于做成存储平台。当节点规模涨到上千甚至几千台时,统一存储平台才真正划算:集中管理提升运维效率,资源利用率提升 10% 就能在 2000 台中省下 200 台。平台主要提供三项能力:资源按需动态分配、资源自动化管理、故障自动化处理。 进一步展开见NoSQL平台规模大才划算。

除了结构化的业务数据,互联网行业还有大量用于展示的数据(淘宝商品图片、Facebook用户头像、微博内容),这类小文件有三个典型特征:单个文件小(一般1MB以下)、数量巨大(Facebook 2013年每天上传照片就达3.5亿张)、访问量巨大(Facebook每天访问量超10亿)。因为几乎每个业务都会产生大量小文件,如果每个业务各自设计海量存储和海量访问方案,效率必然低下、重复造轮子,因此自然要把小文件存储做成统一的、和具体业务无关的平台。和SQL存储三阶段演进、NoSQL平台规模大才划算不同的是,小文件存储不需要等到公司或业务规模很大才值得做,基本上业务在起步阶段就可以考虑统一存储——得益于开源生态的成熟,在HBase、Hadoop、Hypertable、FastDFS这类开源方案基础上封装一个小文件存储平台并不算太难,典型实现有淘宝TFS、京东JFS、Facebook Haystack。大文件则主要分两类:一类是业务本身的大数据(YouTube的视频、电影网站的电影),一类是海量日志数据(访问日志、操作日志、用户轨迹日志);和小文件正相反,大文件数量不算多,但单个文件体积巨大(几百MB到几GB常见,几十GB甚至几TB也有可能),存储方式和小文件系统有本质差别,不能直接拿小文件存储系统来存大文件。大文件存储和处理领域的技术格局主要由Google和Yahoo奠定:Google的三篇大数据论文(Bigtable/MapReduce/GFS)开启了大数据时代,Yahoo开源的Hadoop系列(HDFS、HBase等)几乎垄断了开源界的大数据处理生态,后续虽然又涌现出更多优秀开源方案,但整体思路已经定型。正因为要照Google论文原样自研一整套大数据处理方案的难度和成本太高、而开源方案又已经足够成熟,大数据存储和处理这块反而是相对”最简单”的技术选型——因为可选项本来就不多,基本只能在Hadoop、HBase、Storm、Hive这几个主流开源方案里选,实力雄厚的大公司会在这些开源方案基础上结合自身业务封装成大数据平台(如淘宝云梯、腾讯TDW)。 进一步展开见小文件与大文件存储。

原书依据 · 8 处

互联网架构模板:”开发层”和”服务层”技术

系统变多、由不同小组开发时,如果各用各的框架和技术栈,会出现三个问题:技术人员缺乏共同语言、交流合作少;每种技术都要单独投入人力去掌握;人员难以在团队间流动。因此互联网公司普遍会统一技术方向和开发框架。选框架的总原则是优选成熟框架、不盲目追新:文档齐全、坑已被人踩过,遇到问题容易找到答案;受众广,容易招到人;稳定、少有大的不兼容变更,适合长期发展。 进一步展开见统一开发框架优选成熟。

自研成熟的 Web 服务器成本很高,互联网行业基本是拿来主义:按开发语言选 Tomcat、Nginx 或 Apache 等开源服务器,摸透并调优即可,大公司才会二次开发,如淘宝的 Tengine;性能不必过早担心,真撑不住时再换。以 Docker 为代表的容器启动快、几乎不占资源,将从两方面改变格局:运维会转向自动化、智能化;启动实例代价极低会推动设计走向微服务,登录、搜索等功能从一开始就可以按服务独立设计。 进一步展开见Web服务器拿来用。

系统数量增加后,系统间关联路径急剧增长,3 个系统有 3 条,6 个系统就有 15 条。各系统分散管理配置会带来麻烦:上线需要多系统配合时检查协调耗时;排查问题时收集信息效率低;手工编辑缺少校验,把 IP 中的 0 误打成字母 O 都难以发现。统一配置中心有四个好处:集中操作效率高;汇聚在一处便于检查协作;可做程序化规则校验;相当于配置备份,整机故障需要重建环境时能快速恢复。 进一步展开见配置中心集中管理。

系统数量不多时,系统间调用一般直接记录在各系统内部的配置文件里,但系统一多,这种做法就会出问题:比如有10个系统依赖A系统的X接口,A系统实现了功能更好的新接口Y,要让这10个系统全部切到Y接口,就要挨个改这10个系统几十上百台机器的配置再重启,效率极低;再比如A系统总共20台机器,其中5台故障了,如果其他系统是通过域名访问A系统,域名缓存失效前依然可能访问到这5台坏机器;如果是通过IP直接访问,那A系统每增删一台机器,其他所有依赖它的系统的所有机器配置都要同步跟着改,协调成本非常高。服务中心正是为了解决这种跨系统依赖的”配置”和”调度”问题,常见有两种实现方式。服务名字系统(Service Name System)本质上和DNS(Domain Name System)思路一致——DNS把域名解析成IP地址(因为人记不住太多数字IP),服务名字系统则把服务名称解析成”host+port+接口名称”,但和DNS一样,真正发起请求的还是请求方自己,服务名字系统只负责”告诉你去哪找”,不负责”帮你去调”。服务总线系统(Service Bus System)则更进一步,类似计算机主板的总线概念——由总线系统统一完成调用,服务请求方完全不需要直接和服务提供方交互,请求方只需要跟总线打交道,具体转发到哪台服务器由总线系统负责。两者的核心差异在于:”谁来真正发起对目标服务的调用”:服务名字系统只提供地址解析,调用动作还是由请求方自己完成;服务总线系统则把调用这个动作也接管了,请求方彻底不用感知目标服务具体在哪。 进一步展开见服务中心两种实现。

互联网业务讲究”快”,很多业务处理必须走异步——比如大V发一条微博后,系统要通知所有关注他的用户,不可能等所有通知都发完才告诉大V”发布成功”,只能先让大V发布成功、再异步通知关注者。传统的异步通知方式是消息生产者直接调用消息消费者提供的接口,业务规模变大、子系统一多,这种点对点通知会让系统间交互变得极其复杂——各系统互相依赖调用,整个系统结构变成一张蜘蛛网。消息队列正是为了实现这种跨系统异步通知的中间件,既能”一对一”通知,也能”一对多”广播(还是以微博为例,一条微博发布事件可以广播给成千上万个关注者)。引入消息队列后相比蜘蛛网式的直接调用,能带来五个明显好处:整体结构从网状变成线性结构,架构一目了然;消息生产和消息消费彻底解耦,双方实现都变简单;新增一个消息消费者时,消息生产者完全不需要任何改动,扩展起来很方便;消息队列系统本身可以统一做高可用、高性能,避免每个业务子系统各自重复造一套异步通知机制、白白浪费工作量;业务子系统因此可以只聚焦在自己的业务逻辑上,实现更简单。消息队列的基本功能(发消息、收消息)实现起来不算难,但真要做到高性能、高可用,同时还要保证消息时序性、消息事务性,就比较有挑战了。业界已经有很多成熟的开源实现(RocketMQ、Kafka、ActiveMQ等),如果对消息可靠性、时序、事务性要求不高,直接拿开源方案用就行;但如果业务对这几点要求很高,就必须深入研究这些开源方案的实现细节,否则很容易踩坑。开源方案用起来方便,但真要改动它就比较麻烦了,因此不少公司也会花人力时间重复造一个消息队列的轮子——这种”重复造轮子”未必是坏事,好处在于自己造的轮子可以根据自身业务特点快速做定制化适配。 进一步展开见消息队列的五个好处。

原书依据 · 13 处

互联网架构模板:”网络层”技术

传统 DNS 只能做地理级负载均衡,无法细到机器级,因为公网 IP 成本太高,不可能给上万台机器各配一个。它还有两个缺陷:缓存时间长,换 IP 后仍有用户访问旧地址;由第三方提供,感知不到后端状态,出问题只能等运营商处理。私有 HTTP-DNS 改用 HTTP 请求自建的解析服务,灵活、可控、及时,能更快隔离故障服务器;代价是开发成本高、需要改造业务代码。所以它主要用于 App,浏览器负责解析的 Web 业务较难推广。 进一步展开见HTTP-DNS的得失。

单机能力有限,复杂业务每秒可能只处理几百个请求,而互联网业务常见万级乃至十万级并发,所以数据中心内需要机器级负载均衡。三者量级不同:Nginx 约 5 万每秒;LVS 在内核态,约十万级;F5 是硬件,百万级。F5 虽要几十万,但要处理每秒 100 万请求,用 Nginx 约需 20 台服务器,量大时硬件反而更划算。Nginx 偏七层,支持 HTTP 等协议;LVS 与 F5 工作在四层,可以为数据库、聊天等任意应用做均衡。 进一步展开见硬件均衡量大反而省钱。

访问速度除了取决于业务系统本身,还受用户所在地区和运营商到业务机房之间的传输影响,同一地区的电信用户访问联通网络也会慢,这就是“最后一公里”问题。CDN 以空间换时间,把内容缓存到离用户最近的地方,用户不必每次跨运营商、跨地区回源。它已发展成包含分布式存储、全局负载均衡、网络重定向、流量控制的庞大体系,是视频、直播的关键技术。自建成本极高,最恰当的做法是直接购买 CDN 厂商或云厂商的服务。 进一步展开见CDN买而不造。

单机房架构在全局网络层面是单点,无法保证异地容灾场景下的高可用——断电、网络中断、地震、水灾等都可能导致整个数据中心不可用,因此需要多机房设计。多机房设计核心要解决的是”距离带来的延时问题”,常见有三种方式:同城多机房(距离较近,可以投入重金搭建私有高速网络,让多机房性能接近单机房,但因为投入成本太高,只有大公司才能这样做,且遇到极端地震、水灾等波及全城的灾难时依然存在风险);跨城多机房(不同城市的机房,数据通过网络进行复制,例如MySQL主备复制,但由于跨城网络延迟较大,业务上要接受一定妥协——不需要数据实时强一致,只需要最终一致即可,比如微博,A用户在北京机房发布微博,B用户在广州机房不需要实时看到,10分钟后看到也可以接受;这种方式实现简单,但和具体业务强相关,微博能接受,但类似支付宝转账这种要求余额强一致的业务就不能这样做);跨国多机房(与跨城类似,但地理距离更远、延迟更大,由于延迟过大、跨国用户访问速度慢,跨国多机房一般只用于备份,以及服务当地用户)。而”多中心”和”多机房”有本质区别,绝非同一件事的简单升级:多机房设计的首要目标是”容灾”——数据中心出问题后,业务能够比较快地切换到另一个数据中心,但这个切换允许一定的中断时间(例如10分钟、1小时),且允许一定的业务损失(例如部分没有同步的数据无法立即恢复,甚至可能永远无法恢复);而多中心要求每个中心都同时对外提供服务,业务能自动在多个中心之间切换,做到故障后自动恢复,无需或仅需很少的人工干预。多中心设计的核心难点在于要保证”数据一致性”和”数据事务性”,而这两点又和具体业务紧密相关,目前没有很成熟的通用方案,都需要基于业务特点进行详细的分析和设计——比如淘宝号称实现了多中心,但实际上商品浏览、订单、支付等不同业务都是各自独立设计和实现多中心方案的,并不存在一个统一的多中心方案可以套用所有业务。正因为难度如此之高,(2018年时)国内银行、支付宝这类系统尚未完全实现多中心(曾经发生过挖掘机意外挖断光缆导致支付宝服务中断4小时的真实案例,正说明了这个差距)。 进一步展开见多中心是质变。

原书依据 · 9 处

互联网架构模板:”用户层”和”业务层”技术

稍大的互联网业务会有多个子系统,不可能各自管理用户,由此引出两个目标:单点登录,可用 cookie、token 等实现,最成熟的开源方案是 CAS;授权登录,业务做成平台后允许第三方接入,OAuth 2.0 已是事实标准,私有协议漏洞多、接入麻烦。用户系统的挑战看似是千万到亿级的用户量,但实现并不难,因为用户之间没有强业务关联,A 登录与 B 登录互不相干,用简单的负载均衡架构就能应对。 进一步展开见用户管理量大不难。

短信、邮件、站内信推送调用服务商接口即可,App 推送分两边:iOS 规范封闭,基本只能用苹果的 APNS;国内 Android 则复杂得多,GCM 在国内不能用,各厂商的定制系统推送实现也不同,于是大厂自建推送,也有第三方商业服务。中小公司若不涉及敏感数据,推荐直接用第三方服务,到达率有保障;涉及敏感数据才需要自建,包括设备管理、连接管理和消息管理,其中最难的是后台限制下的连接保活。 进一步展开见Android推送为何复杂。

用户上传的文件量大、体积小、访问集中在刚上传的时候,2016 年微信朋友圈每天就上传约 10 亿张图片,需要小文件存储技术。存储云和图片云通常都是“CDN 加小文件存储”,除非达到 BAT 规模,直接买云服务最快最省。既然底层技术相同,为何拆成两个系统?原因不在存储技术,而在上层业务复杂度:普通文件只需存储和访问,图片还涉及裁剪、压缩、美化、审核、水印等专属处理,所以图片云通常独立出来。 进一步展开见图片云为何单独拆出。

互联网的业务千差万别,不同业务分解下来对应不同的子系统,所以业务层没办法像用户层那样提炼出公共组件。抛开具体业务差异,各互联网业务发展最终面临的问题都类似:业务复杂度越来越高,而复杂度越来越高的一个主要原因就是系统越来越庞大、业务越来越多。应对业务层复杂度的核心方法只有一把”屠龙宝刀”——”拆”,化整为零、分而治之,把整体复杂性分散到多个子业务或子系统里(具体拆的方式即分层架构、微服务、微内核等)。以一个电商系统为例:第一阶段所有功能都在一个系统里;第二阶段拆分成商品、订单两个子系统;第三阶段商品子系统和订单子系统又分别拆成更小的共6个子系统。这只是样例,实际业务发展中子系统会越来越多,据说淘宝内部大大小小的子系统已经有成百上千个。但当子系统数量拆到几百上千时,另一个复杂度问题会凸显出来:系统数量太多,已经没有人能说清楚业务的完整调用流程了,出问题排查也会特别复杂——此时不可能把子系统再合并回大系统(那样又会回到最初的问题),真正的答案还是”合”,正所谓”合久必分、分久必合”,但这次”合”的方式不一样:按照”高内聚、低耦合”的原则,把职责关联比较强的一组子系统合成一个”虚拟业务域”,然后通过网关对外统一呈现——本质上类似设计模式中的Facade(外观)模式:把一堆职责相关的子系统包装在网关背后,对外部调用方呈现出一个统一、简化的接口,调用方无需感知域内部具体有多少个子系统、调用链路如何流转。 进一步展开见虚拟业务域收编子系统。

原书依据 · 6 处

互联网架构模板:”平台”技术

业务规模小、系统复杂度不高时,运维、测试、数据分析、管理等支撑功能主要由各系统或团队独立完成;但随着业务规模变大、子系统数量增多,如果继续各自为政地实现这些支撑功能,会发现重复工作非常多——这正是把支撑功能沉淀为”平台”的动机:避免重复造轮子,减少不规范带来的沟通协作成本。运维平台的核心职责分为四大块,恰好对应系统生命周期的四个阶段:配置(负责资源管理,如机器管理、IP地址管理、虚拟机管理)、部署(负责将系统发布到线上,如包管理、灰度发布管理、回滚)、监控(负责收集系统上线运行后的相关数据并监控,以便及时发现问题)、应急(负责系统出故障后的处理,如停止程序、下线故障机器、切换IP)。支撑这四大职责的核心设计要素是”四化”:标准化(制定运维标准,规范配置管理、部署流程、监控指标、应急能力,各系统按标准来实现,避免不同系统不同处理方式——标准化是运维平台的基础,没有标准化就没有运维平台)、平台化(在标准化基础上,把运维相关操作都集成到运维平台中完成,好处是可将标准固化到平台无须运维人员死记硬背、操作简单方便优于人工、且一套平台可复用支撑几百上千个业务系统)、自动化(把传统手工运维中大量重复的操作固化下来由系统自动完成,例如部署原本要登录机器、上传包、解压包、备份旧系统、覆盖旧系统、启动新系统一系列步骤,有了运维平台后只需单击”开始部署”,系统自动完成后通知即可)、可视化(把运维平台海量数据以直观方式呈现,提升数据查看效率,尤其在故障应急时争分夺秒,减少1分钟排查时间可能挽回几十万元损失)。 进一步展开见运维平台四化。

运维平台的根基是标准化:统一配置管理、部署流程、监控指标和应急能力,各系统按标准实现。遇到某个系统无法改造自身来满足标准时,常见做法不是强行改它,而是引入中间层做规范适配:系统保持原样,由中间层把它的输出转换成标准格式。例如系统只提供查询性能指标的 RESTful 接口,而标准要求定时以日志上报,就写个定时程序调用接口,把数据转成日志格式上报,兼容问题在中间层被消化。 进一步展开见中间层适配运维标准。

运维平台数据量很大,靠人工逐条查询判断效率太低,故障应急时每减少 1 分钟排查都可能挽回大笔损失,可视化就是为了提升看数据的效率。它的原理像汽车仪表盘:一串数字让人眼花,指针位置和区域颜色却让人一眼看出是低速还是高速。可视化能直观展示数据属性,如刻度范围和单位;能直接表达含义,如红区代表危险;能把关联数据整合展示,如速度与里程。它把“读数据”变成“看状态”,缩短排障与决策时间。 进一步展开见可视化是信息压缩。

测试平台核心的职责是测试,包括单元测试、集成测试、接口测试、性能测试等都可以在测试平台完成。测试平台的核心目的是提升测试效率从而提升产品质量,设计关键就是”自动化”——传统测试方式靠测试人员手工执行用例,效率低、重复劳动多,通过测试平台的自动化能力,用例能重复执行、无须人工参与,效率大幅提升。为达到自动化目标,测试平台由四个模块组成:用例管理(测试自动化的主要手段是通过脚本或代码进行测试,例如单元测试用例是代码、接口测试用例可以用Python写、可靠性测试用例可以用Shell写;为了能重复执行这些用例,需要按业务、系统、测试类型、用例代码等维度把用例管理起来)、资源管理(测试用例要放到具体运行环境才能真正执行,运行环境包括硬件如服务器/手机/平板、软件如操作系统/数据库/JVM、以及被测的业务系统本身;除性能测试外,一般自动化测试对性能要求不高,所以为提升资源利用率,大部分测试平台会用虚拟机、Docker等虚拟化技术来充分利用硬件资源)、任务管理(主要职责是把测试用例分配到具体资源上执行,并跟踪执行情况——这是测试平台设计的核心,把用例管理、资源管理等各部分串联起来,真正完成自动化测试的闭环)、数据管理(测试任务执行完成后需要记录执行时间、执行结果、CPU/内存占用等各种相关数据,这些数据有三个作用:展现当前用例执行情况;作为历史数据,方便和后续测试对比发现明显变化趋势,比如某版本后单元测试覆盖率从90%降到70%;作为大数据的一部分支撑数据挖掘,比如规模复杂度相近的两个业务,一个一年执行1万个用例测试、另一个只执行1000个,可以据此深挖差异原因)。 进一步展开见测试平台四模块。

数据平台的核心职责主要分三部分:数据管理、数据分析、数据应用。数据管理是基础功能,包含数据采集(从业务系统搜集日志、用户行为、业务数据等,传送到数据平台)、数据存储(把采集到的数据存储起来用于后续分析)、数据访问(对外提供SQL、Hive、Key-Value等各种协议用于读写数据)、数据安全(数据平台通常是多业务共享的,部分业务敏感数据需要保护,防止被其他业务读取甚至修改,因此需要设计数据安全策略)四个子职责。数据分析包含数据统计(根据原始数据统计出总览数据,如PV、UV、交易额)、数据挖掘(为了与机器学习/深度学习区分,这里特指传统数据挖掘方式,即有经验的数据分析人员基于数据仓库构建一系列规则来分析数据、发现隐含规律,经典案例是沃尔玛啤酒与尿布的关联发现)、机器学习与深度学习(属于数据挖掘的具体实现方式,但因实现方式与传统数据挖掘差异较大,数据平台需要针对二者独立设计)三个层次。数据应用则很广泛,既包括在线业务(如推荐、广告),也包括离线业务(如报表、欺诈检测、异常检测)。但数据应用能发挥价值有一个前提门槛:必须有”大数据”,只有数据规模达到一定程度,基于数据的分析、挖掘才能发现有价值的规律、现象、问题;如果数据没有达到一定规模,通常只做好数据统计就足够了——尤其很多初创企业,完全没必要一开始就照搬BAT级别的数据平台架构来建设自己的系统。 进一步展开见数据平台三大职责。

业务系统、中间件、平台系统都需要权限管理,各自实现效率低、重复多,因此需要统一的管理平台。权限管理分两部分:身份认证确定操作者是谁,防止非法人员进入,通常用企业账号统一认证登录;权限控制根据身份确定能做什么,防止越权,如不允许研发人员查看财务系统中别人的工资。二者缺一不可:只有认证没有控制,合法用户可能越权;只有控制没有认证,权限判断无从谈起。 进一步展开见权限管理分认证与控制。

原书依据 · 14 处

架构重构内功心法第一式:有的放矢

系统的架构是不断演化的,少部分架构演化需要推倒重来进行重写,但绝大部分架构演化是通过架构重构来实现的。相比全新的架构设计,架构重构对架构师的要求更高,主要体现在三点:第一,业务已经上线,不能停下来——架构重构时业务已经上线运行,重构既要尽量保证业务继续往前发展,又要完成架构调整,这就好比”给飞行中的波音747换引擎”;而如果是新设计架构,业务还没上线,即使做砸了对业务也不会有太大影响。第二,关联方众多,牵一发动全身——架构重构涉及的业务关联方很多,不同关联方的资源投入程度、业务发展速度、对架构痛点的敏感度都有很大差异,如何尽量减少对关联方的影响、或协调关联方统一行动,是一项很大的挑战;而新设计架构在上线前对关联方没有影响。第三,旧架构的约束——架构重构需要在旧架构基础上进行,这是很强的约束,会限制架构师的技术选择范围;而新设计架构的技术选择余地大得多。即使决定推倒重来、完全抛弃旧架构去设计新架构,新架构依然会受旧架构约束和影响,因为业务在旧架构上产生的数据不能推倒重来,新架构必须考虑如何把旧架构产生的数据转换过来。正因如此,架构重构对架构师的综合能力要求非常高:业务上要能说服产品经理暂缓甚至暂停业务来配合重构;团队上要能与其他团队达成一致的重构计划和步骤;技术上要给出让技术团队认可的重构方案——既要说得动老板,也要镇得住同事,既要技术攻关又要协调资源,既要保证业务正常发展又要在指定时间内完成目标。 进一步展开见重构比新设计难在三点。

架构跟不上业务时,系统会不断出问题:响应慢、数据错、宕机或开发效率低。开始重构分析时,架构师常像走进迷雾森林,列出上百行问题清单无从下手。指望一次重构解决所有问题不现实,首要任务是识别出真正需要靠架构重构解决的核心问题并集中解决,否则会陷入“人少事多头绪乱”,忙了大半年每个问题都还在。新接手系统时要克制“新官上任三把火”。其余问题可在重构后另立优化项目,届时多由团队内部完成,推进反而更快。 进一步展开见重构要有的放矢。

面对一堆问题,该重构还是优化,判断带有主观性:不能一见问题就重构,也不能事事都只优化。一个可操作的方法是:假设从零开始设计当前系统,看新架构与现有架构是否类似。差异不大,说明大方向是对的,只是局部有瑕疵,做系统优化即可;差异很大,说明现有架构的方向已与业务需要脱节,可能需要重构。它把“要不要重构”这种凭感觉的决策,转化成对比理想架构与现实架构结构差异的具体动作。 进一步展开见从零设计判断是否重构。

三个真实的架构重构案例,表面看有些相似,实则根因各不相同,恰好体现了”有的放矢”——必须找准真正的核心问题,而不是笼统地说”系统要重构”。案例一:后台系统M系统重构,解决不合理的耦合——M系统是管理所有游戏相关数据的后台管理系统,问题根因是耦合了P业务独有的数据和所有业务公用的数据(例如数据库某张表一部分字段是公用”游戏数据”、一部分是P业务”独有数据”,改动时代码逻辑复杂、效率很低),导致可扩展性差;重构方案是把游戏数据和业务数据拆开解耦,让两个系统能独立快速发展;重构后M系统和P业务后台系统每月上线版本数是重构前的4倍。案例二:游戏接入S系统重构,解决全局单点的可用性问题——S系统是游戏接入核心系统,一旦故障大量玩家无法登录,其数据库主库是全局单点,一旦主库不可用两个集群的写业务全部不可用,且S系统不具备多中心能力,主机房宕机整个业务就不可用;重构目标是实现双中心,任意一个机房都能提供完整服务,某机房故障时另一机房能全部接管;重构后系统可用性从3个9提升到4个9,重构前最夸张一个月发生4次较大线上故障,重构后即使经历机房交换机宕机、运营商线路故障、机柜断电等问题,对业务也没有大影响。案例三:X系统重构,解决大系统带来的开发效率问题——X系统是创新业务主系统,早期为了快速尝试和快速发展,怎么方便怎么做,很多功能都”塞”进同一个系统,导致后来改不动,做新功能要花大量时间讨论梳理各种业务逻辑;X系统的问题看起来和M系统类似(都是可扩展性不足),但根本原因不一样:M系统是耦合了不同业务的数据,X系统是把业务相关的所有功能都放在同一个系统中,而且所有功能挤在一个系统还会导致一个功能出问题、整站都跟着不可用(比如某个功能拖慢数据库,全站业务都变慢);重构目标是把各功能拆分到不同子系统中降低单系统复杂度;重构后虽然系统间要通过接口交互、看似增加了接口工作量,但各系统的发展和开发速度比原来快了很多,也不再出现一个子系统有问题、所有业务全跟着遭殃的情况。 进一步展开见三个重构案例的根因。

原书依据 · 9 处

架构重构内功心法第二式:合纵连横

重构持续时间长、占用研发资源,要启动它必须先与利益相关方达成共识。技术术语常让非技术人员无法理解,说“可用性才 3 个 9”,项目经理只觉得差一个 9 而已;只说“耦合导致效率低”又没有数据,别人也没直观印象。关键是把技术语言翻译成通俗语言,用事实和数据说话:M 系统整理了一个月的版本数据,讨论两周、开发两天、再等一个月才上线;S 系统整理故障次数、影响时长和用户数,并与其他系统对比。 进一步展开见合纵用数据沟通。

除了和上下游非技术人员沟通协调(合纵),有的架构重构还需要和其他相关或配合的系统进行沟通协调(连横)。由于大家都是做技术的,有比较多共同语言,这部分沟通相对容易一些,但也不是想推动就能推动,主要阻力来自两类心态:”这对我有什么好处”和”这部分我这边现在不急”。对于”这对我有什么好处”,有人会简单归为自私、不顾大局,于是沟通时把问题人为拔高,比如说”你应该站在部门角度考虑”“这对公司整体利益有帮助”——但这种沟通效果其实很差:一来这种拔高一般比较虚、无法明确,不同人理解也不一样,难以达成共识;二来如果对公司和部门有利、但对某个小组没用甚至不利,那有可能是当前方案本身不够好,还可以考虑别的方案。真正有效的策略是”换位思考、合作双赢、关注长期”——站在对方角度思考,重构对他有什么好处、能帮他解决什么问题、带来什么收益;如果确实出现对公司/部门有利、对某个小组不利的情况,那可能需要协调更高层级管理者来推动,同级别平级推动是比较难的。对于”这部分我这边现在不急”,有可能是找借口,但即便是找借口,往往也是因为大家没达成一致意见、对方不好意思直接拒绝,这种情况同样可以用”换位思考”的方法处理;如果对方是真的有其他更重要的业务,此时勉强推进也不好,因为大部分需要重构的系统并非到了火烧眉毛的紧急程度才启动,本身有一定前瞻性规划,可以采取等待策略,但必须明确正式启动的时间点(例如”3个月后开始”“6月份开始”),千万不能说”以后”“等不忙的时候”这种无法明确的时间点;同时计划和方案上也可以灵活一点,比如先不做这部分相关的重构,先把其他需要重构的做完,因为大部分需要重构的系统要做的事情很多,分阶段处理在风险规避、计划安排上更加灵活可控。 进一步展开见连横的两大阻力。

M 系统重构要求原本直连同一数据库的 C 系统改为调用 M 的接口,C 系统短期要改十几个功能,起初觉得对自己没好处。深入沟通后发现,C 系统同样深受其苦:两边都写同一个库,数据经常出错要排查;M 系统一加表或字段,C 系统就要跟着理解业务逻辑、同步开发;C 系统要连两个数据库,出问题难查。重构后这些问题都能解决,C 系统因此乐意配合。表面上对对方无益的重构,深挖后往往能找到对方自己的收益。 进一步展开见找到对方的真实痛点。

原书依据 · 9 处

架构重构内功心法第三式:运筹帷幄

需要重构的系统通常积累了大量历史问题,只针对关键复杂度重构往往无法落地,因为前置条件不具备,必须先识别准备工作和前置问题。面对清单,逐个挑来解决看似简单,效果却很差:不分优先级,资源没有集中在关键问题上,忙了大半年没有阶段性成果;不分类,相似问题没有统筹,方案反复;迫于业务压力专挑软柿子,难题被一再搁置。X 系统就曾这样挑好落地的先做,半年下来整体几乎没有进展,这正是需要分段实施的原因。 进一步展开见逐个解决问题的缺陷。

成立”X项目”后,团队在原来整理的问题基础上,重新识别出X系统架构的核心复杂度体现在:庞大的系统集成了太多功能,导致可扩展性不足;但当时系统的可用性也不高,经常出线上问题,耗费大量人力去处理。团队据此判断:要做架构重构,需要系统先处于一个比较稳定的状态,不能经常出线上问题;而当时可用性不高,一部分是硬件资源不够用、部分系统组件使用不合理,一部分是架构本身有问题。基于这个分析,团队制定了三阶段策略:第一阶段先”救火”,解决因机器过载、缓存响应慢、虚拟机挂死等直接导致故障的问题;第二阶段解决因组件、外部系统故障导致系统故障的问题(例如把多个底层系统切换到公司统一的公共组件),提升整体可用性;完成前两个阶段、系统进入相对稳定状态后,才安心进入第三阶段——真正的”服务化”架构重构。如果没有第一、二阶段的铺垫,直接上来做第三阶段的架构重构,方案就得糅合业务降级、接入服务中心等一大堆事项,导致方案不聚焦、异常复杂。S系统的重构做法类似,但S系统当时的主要问题是可用性不高,并没有系统耦合的问题,所以策略是”先救火、后优化、再重构”:救火阶段做扩容(防止资源不足导致系统被压死)和Nginx一键切换功能(故障时快速切换);优化阶段解决一些明显的可用性问题(包括性能问题等);重构阶段把原来的单点数据库改造成多中心架构。两个案例共同验证了同一个道理:采用分阶段策略是为了集中有限资源,让某个阶段只集中解决某一类问题——这样做首先效率高,因为阶段目标明确,决策和方案不需要太多取舍;其次每个阶段都能看到明显成果,给团队很大信心。 进一步展开见两系统分段实施对比。

“分段实施”的做法,本质是把要解决的问题根据优先级、重要性、实施难度等划分为不同阶段,每个阶段聚焦于一个整体目标,集中精力和资源解决一类问题。这样做有几个好处:每个阶段都有明确目标,做完之后效果明显,团队信心足,后续推进更容易;每个阶段的工作量不会太大,可以和业务并行;每个阶段的改动不会太大,降低了总体风险。具体制定策略分四步:第一步是优先级排序——把明显且比较紧急的事项优先落地,先解决当下最主要的问题,例如扩容在S系统和X系统里都是最优先实施的一项,因为不扩容的话系统会隔三差五出现响应超时报警、过载报警、大面积不可用,这些问题耗费大量人力精力,团队根本没法腾出手做别的事情。第二步是问题分类——把问题按性质分类,每个阶段集中解决一类问题,例如X系统的第二阶段就是把多个底层系统统一切换到公司公共组件,专门提升整体可用性。第三步是先易后难——这点和很多人的直觉不太一样,有人认为应该先攻克最难的问题(”擒贼先擒王”),解决了最难的问题其他问题就不在话下,但实际上这样做不可行。第四步是循序渐进——划分好实施阶段后,需要评估每个阶段所需时间,可能会出现有的阶段只需1个月、有的却需要6个月,虽然这可能确实是客观事实,但通常按固定的步骤和节奏推进更有利于项目管理;作者的经验是每个阶段最少1个月,最长不超过3个月,如果评估超过3个月,就再拆分成更多阶段——当任务子集比较小时可以多个并行,任务子集比较大时就当作一个独立里程碑单独推进。 进一步展开见分段实施四步法。

很多人主张先攻最难的问题,“擒贼先擒王”,但实际不可行:最难的问题往往要先解决其他相对容易的问题;它耗时长、占资源多,一两个月没成果会影响外界评价和团队士气;最初的分析未必全面,对“最难最关键”的判断本身可能有误。先易后难则能避免这些问题:简单问题解决后,难题往往变得不那么难,甚至因前置条件已满足而消失;能较快看到成效,有利于推进和士气;遗漏或误判会逐渐暴露,便于及时调整策略。 进一步展开见重构应先易后难。

原书依据 · 11 处

再谈开源项目:如何选择、使用以及二次开发?

引入开源项目能节省大量人力,但也可能带来宕机乃至丢数据;而开源世界相似的轮子太多,选择本身就让人头疼。常见误区是纠结哪个项目更优秀,正确做法是看是否满足业务。某团队看中 TT 既能当缓存又能持久化,大量引入后发现它不能完全替代 MySQL、bug 多、需要很长时间熟悉,其实 Memcached 加 MySQL 就够了。业务只要 1000 TPS,2 万和 5 万 TPS 的项目对你没有区别;将来真需要时再演进架构即可。 进一步展开见选开源看是否满足业务。

新开源项目常宣称性能更高、功能更强,却隐藏了一个问题:更不成熟。顶级开发者写的系统同样有 bug,不成熟的项目在生产环境轻则宕机,重则重启都恢复不了甚至丢数据。TT 就曾因异常断电损坏文件无法重启,只能用前一天的备份恢复,当天数据全丢,后来研究源码写工具才救回一部分。考察成熟度看三点:版本号,不选 0.X,至少 1.X;使用公司的数量与规模;社区活跃度,包括发帖、回复和问题处理速度。 进一步展开见选开源看是否成熟。

架构师选开源项目时多盯着性能、可用性、功能等技术指标,很少关注运维能力,但上线后一旦出问题,没有运维能力就只能干瞪眼。考察三点:日志是否齐全,有的项目只有寥寥几行启停日志,出了问题无从排查;是否有命令行、管理控制台等工具能看到运行状况;是否具备告警、切换等故障检测与恢复能力。若是 Netty 这类开源库,本身没有运维能力,就要在使用层主动记录关键日志,把运维能力补上。 进一步展开见选开源看运维能力。

很多人用开源项目是拿来主义:看几个 Demo、跑起来就上线,就像只看了驾驶指南就开车上路。某团队用 Elasticsearch 时配置全用默认值,结果剔除异常节点太慢导致整站挂掉;不少团队抱怨 MySQL 慢,其实是关键参数没配或配错。正确做法包括:通读设计文档;核对每个配置项并找出关键项;做多场景性能测试;连续数天压力测试并观察资源指标;做 kill、断电、拔网线、反复重启等故障测试。 进一步展开见用开源要深入研究测试。

深入研究、仔细测试之后也不能直接全面上线,因为研究和测试只能降低风险,无法覆盖所有线上场景。TT 引入前专门安排高手看源码、测试了约一个月,上线后仍然遇到各种问题,线上环境的复杂度远超测试能覆盖的范围。所以无论多有把握,都要对线上环境保持敬畏:先在非核心业务上使用,积累实际经验后再逐步扩展到更核心的业务,而不是测试一结束就全面铺开。 进一步展开见研究测试替代不了灰度。

即使选型、研究、测试、灰度都做足,初期仍可能碰上全世界都没遇到过的 bug,存储出事且无法恢复就是致命打击。某业务使用 MongoDB,宕机后部分数据丢失且没有其他备份,只能来一个投诉处理一个,DBA 和运维从此反对再用它。因一次故障全面拒绝有些过度,但它提醒我们:重要业务和数据使用开源项目时,最好有另一套成熟方案做备份,例如用 MySQL 备份 MongoDB 或 Redis 的数据,关键时刻能救命。 进一步展开见重要存储要有备份方案。

开源项目不满足需求时,从内到外改造一遍有两个问题:投入大,改 Redis 这种项目至少要两人一个多月;改得越多,与原项目差异越大,就无法再跟随上游演进。更好的做法是不动原系统,开发监控、报警、负载均衡、管理等辅助系统来补能力。给 Redis 加集群就在外面加 proxy 层,Twemproxy 正是如此;Redis 3.0 提供原生集群后就能平滑切换。实在要改原系统,优先向官方提需求或 bug,特别紧急才自己改。 进一步展开见改开源只做外围包装。

绕回“重复发明轮子”并不矛盾,本质是成本收益权衡:没有完全适合你的轮子。软件没有硬件那样的工业标准,相似的轮子到处可替换;开源项目追求通用,而不同业务差异很大。某业务要求缓存宕机一台也不能拖慢整体,Memcached 没有备份能力,当时 Redis 也无集群,团队用两到四人约两个月基于 LevelDB 原理自研了支持存储、备份和集群的缓存。有钱有人有时间时,自研贴合业务的轮子也是好选择。 进一步展开见没有完全合适的轮子。

原书依据 · 20 处

谈谈App架构的演进

架构设计相关的理念、技术、实践主要聚焦在后端系统(存储高可用、微服务、异地多活等),但这并不意味着App、前端就没有架构设计——专栏所讲的整套架构设计理念,虽然来源于后端设计经验,一旦形成完善的技术理论后,同样适用于App和前端。回顾这套理念的关键点:架构是系统的顶层结构;架构设计的主要目的是解决软件系统复杂度带来的问题;架构设计需要遵循合适原则、简单原则、演化原则;架构设计首先要掌握业界已成熟的各种架构模式,然后再优化、调整、创新。App架构的演进正是这套理念的具体体现,大致经历五个阶段。第一阶段Web App(包壳架构):在Web业务上包装一个App壳,业务逻辑完全由Web实现,App壳只完成安装功能。约2010年前后,移动互联网还是新鲜事物、发展前景不明朗(淘宝2013年才决定”All in无线”),业务重心仍在PC互联网,移动端更多是尝试性质,因此需要”快速开发”和”低成本”,原生开发成本太高,Web App成为首选——遵循”合适原则”和”简单原则”。第二阶段原生App:随着移动设备发展速度远超Web技术、App承载的业务逻辑越来越复杂、且只有原生才能利用移动设备的用户体验优化技术,复杂度焦点从”快速开发/低成本”转向”用户体验”,原生App成为最合适的选择——遵循”演化原则”(约2013年前后快速发展)。第三阶段Hybrid App:移动互联网已成明确大趋势,竞争关键变成”谁更快抓住用户需求”,复杂度又回到”快速开发”,但原生App在Android/iOS/Windows Phone三平台间完全不兼容、同样功能要重复开发三遍;由于Web体验又不如原生,于是按业务需求分别选型——体验要求高的用原生、要求不高的用Web,这就是Hybrid App的核心设计思想,是”用户体验”和”快速开发”两个复杂度之间的平衡(不是同时解决),遵循”合适原则”。第四阶段组件化/容器化:超级App(如手机淘宝、微信)在一个App里承载几十上百个子业务,且每个业务由独立团队开发、还在不断扩展,引入了新的可扩展性复杂度;解决办法是把超级App拆分成众多遵循统一规范、可独立开发测试上线的组件,组件间通过消息系统通信实现隔离——这只在业务复杂度发展到一定规模后才适用,遵循”演化原则”,中小公司通常不需要。第五阶段跨平台App:前面除Web App外的方案都面临同一功能要在Android、iOS各开发一遍的重复投入问题,违背”简单原则”,于是React Native、Weex、Flutter等跨平台方案不断涌现,但目前都不算成熟,用户体验上也和原生App有差距(例如Airbnb已宣布放弃React Native、回归原生技术)。 进一步展开见App架构五阶段演进。

可扩展的基本思想都是“拆”,但 App 与后端有两个本质区别:App 面向用户,再怎么拆对用户也只能是同一个 App,后端则可以拆成成百上千个服务;App 内各业务必须使用相同的技术栈才能集成,后端不同服务可以用不同技术栈。正因为对外呈现单一、技术栈统一,App 的拆分发展出组件化、容器化等专门形式:把超级 App 拆成遵循统一规范、可独立开发测试上线的组件,组件间通过消息系统通信实现隔离。 进一步展开见App拆分不同于后端。

组件化和容器化在规范、拆分和团队协作上基本一致:都把超级 App 拆成遵循预定规范的组件,各自独立开发、测试、上线,组件间通过消息系统通信,避免团队间相互影响。真正的区别在发布方式:组件化是静态发布,组件开发测试完后跟随 App 的某个版本统一上线;容器化是动态发布,容器可以动态加载组件,组件准备好就能直接发布,不必等固定版本。容器化把单个组件的发布节奏从 App 整体版本中解耦出来。 进一步展开见组件化与容器化之别。

除 Web App 外,各种 App 架构都要为 Android 和 iOS 各开发一遍,因此出现了 React Native、Weex、Flutter 等跨平台方案。书中是 2018 年的判断:这些方案当时还不成熟,体验与原生有差距,Airbnb 也宣布放弃 React Native 回归原生。可迁移的是稳定的权衡:跨平台省下重复开发成本,代价可能是部分体验;是否采用看业务对体验的敏感度,并按当下框架的实际成熟度重新评估。 进一步展开见2018年跨平台方案取舍。

原书依据 · 8 处

架构实战:架构设计文档模板

架构设计中”备选方案”文档的核心是把需求全方位描述清楚,常用的框架分三层。第一层是5W:Who(需求利益干系人,包括开发者、使用者、购买者、决策者等)、When(需求使用时间,包括季节、时间、里程碑等)、What(需求的产出是什么,包括系统、数据、文件、开发库、平台等)、Where(需求的应用场景,包括国家、地点、环境等,例如测试平台只会在测试环境使用)、Why(需求需要解决的问题,通常和需求背景相关)。第二层是1H(How)——这里的How不是设计方案也不是架构方案,而是关键业务流程;如果业务系统本身比较简单,1H就是几句话说清楚核心功能,如果是复杂的业务系统,这部分甚至可以独立成一份”用例文档”。第三层是8C,即8个约束和限制(Constraints):Performance性能、Cost成本、Time时间、Reliability可靠性、Security安全性、Compliance合规性、Technology技术性、Compatibility兼容性。一个容易被忽略但很关键的提醒是:需求中涉及的性能、成本、可靠性等约束仅仅是利益关联方提出的诉求,不一定准确——如果经过分析发现某个约束没有必要,或者成本太高、难度太大,这些约束本身是可以被架构师提出来调整的,而不是照单全收当成铁律。以书中”前浪微博”消息队列为例:Who是各业务子系统;When是子系统需要发送异步通知时;What是需要开发的消息队列系统本身;Where是开发、测试、生产环境都要部署;Why是把子系统解耦、把同步调用改为异步通知;1H是”业务子系统发消息给消息队列”和”业务子系统从消息队列获取消息”两大核心功能;8C则具体列出了性能要达到Kafka水平、成本不超过10台服务器、3个月内上线第一版、可靠性99.99%、仅内网使用无需考虑网络安全(消息若含敏感信息由发送方自行加密)、按公司DevOps规范开发、团队主要用Java所以最好用Java开发、无历史系统所以无需考虑兼容性。 进一步展开见需求分析5W1H8C。

复杂度分析忌拍脑袋,约束都应有推导过程。前浪微博示例中,每天 1000 万条微博、每条被 10 个子系统读取,折算为平均每秒写 115 条、读 1150 条;峰值一般取均值 3 倍,本例余量取峰值 4 倍,得出 TPS 1380、QPS 13800,从而判断读取才是复杂度焦点。余量倍数按业务增速可取 2~8 倍,一般不超过 10 倍(压测验证是卡片补充)。要紧的是这条从业务量到性能目标、可追溯可复现的推导链。 进一步展开见从业务量倒推性能目标。

备选方案评估完成、确定要落地哪个方案后,接下来要写的是”架构设计文档”,用来详细描述细化后的具体方案,整体结构分四大部分。第一部分是总体方案:需要从整体上描述方案的结构,核心内容就是架构图以及针对架构图的描述,包括”架构总览”(给出架构图和架构描述,例如消息队列案例中给出的关键设计点:采用数据分散集群架构、每个分组一主一备MySQL、正常情况下只有主服务器对外提供读写服务、客户端采取轮询策略读写)和”核心流程”(列出消息发送流程、消息读取流程等关键业务流程的具体步骤)。第二部分是详细设计:需要描述具体的实现细节,一般按复杂度维度展开——高可用设计(例如消息发送/存储/读取各自的可靠性保障机制)、高性能设计、可扩展设计(如果方案本身不涉及可扩展性,也要明确写”无”,而不是完全不写这一节)、安全设计(例如身份识别和队列权限两部分的权限控制机制)、其他设计(例如是否要接入公司已有的运维平台、监控平台等杂项考虑点)。第三部分是部署方案:主要包括硬件要求、服务器部署方式、组网方式等,例如消息队列案例中提到消息队列服务器和数据库服务器采取混布方式(消息队列是CPU密集型,MySQL是磁盘密集型,二者混布互相影响概率不大),以及具体的硬件配置要求(32核48G内存512G SSD,用物理机而非虚拟机,因为动态扩容需求不高但性能要求高)。第四部分是架构演进规划:通常规划和设计的需求比较完善,但如果一次性全部做完,项目周期可能会很长,因此可以采取分阶段实施的方式,明确写出第一期做什么、第二期做什么,例如消息队列案例分三期——第一期实现消息发送和权限控制(预计3个月)、第二期实现消息读取(预计1个月)、第三期实现主备基于ZooKeeper的切换功能(预计2周)。 进一步展开见架构设计文档结构。

消息队列的高可用设计没有宣称绝对可靠,而是写明失败边界:发送时 SDK 轮询各分组主机重发,全部失败可缓存或丢弃,但缓存期间业务服务器重启会永久丢失,关键消息需业务方自行持久化;存储用 MySQL 一主一备,复制延迟时主机宕机会丢部分消息,由 DBA 监控延迟、超过 30 秒告警;读取时备机平时不服务,借助 ZooKeeper 临时节点判断主机故障后才接管。高可用设计的价值在于讲清在什么条件下丢、丢多少、由谁兜底。 进一步展开见写清楚哪里会丢。

架构设计文档中,若方案确实不涉及某个维度,例如可扩展设计,应在对应章节明确写“无”,表示已经考虑过、判断不需要针对性设计,而不是把这一节删掉。完全不写时,评审人很容易认为设计者遗漏了这个点,从而质疑方案的完整性。文档要能替设计者证明“考虑到了、只是判断不用做”,而不是让评审人去猜空白处究竟是想过不需要,还是根本没想到。 进一步展开见不涉及也要写无。

原书依据 · 11 处

特别放送|“华仔,放学别走!”第1期

这一期访谈回答的是如何学习架构,而非再引入一组架构模式。作者把知识分享看作暴露理解缺口的过程:写作会迫使人补齐细节、澄清疑问,读者的反馈又能帮助校正认识。博客只是这种表达与反馈循环的一种载体,重要的是把自己认为懂的内容讲清,而非用篇数代替掌握程度。

理论与实践在这里相互校正。先了解架构的目的、复杂度与原则,可以减少只凭感觉选方案的情况;随后用真实业务检验这些理解。没有亲自负责新系统的机会,也可以分析已有系统或公开案例:它解决了什么问题,为什么采用这个边界,有什么未被解释的代价。循序渐进地写笔记、比较判断,并与同伴讨论,比单纯赶进度更接近作者倡导的学法。

访谈还给出技术、个人成长和人生选择三个层面的延伸书目,并通过留言回应组织与团队条件对设计的影响。这些内容提供学习背景和反思入口,不把作者个人的阅读感受、书单或“10000小时”叙述提升为普遍成功公式。

特别放送|“华仔,放学别走!”第2期

甲方不顾业务需要、硬要采用流行技术时,不必用三原则去否定它:业务第一,拿不到订单就谈不上架构。这类要求属于“架构约束”,是必须遵守的前提,不是架构师可以选择的。三原则仍用在约束之内的选择上:客户要求 Docker,就选更简单的 host 网络模式;要统一管理 Docker,按简单原则直接用 Kubernetes,不自研平台。发散:先把约束和可选项分开。参见合适原则。 进一步展开见硬性要求属于架构约束。

架构师还承担业务、项目和技术之间的沟通:当方案取舍缺少统一量化标准时,需要解释判断依据,使各方形成能执行的共识。沟通可信度建立在技术能力之上,表达技巧不能替代可靠方案。技术判断需要跨方共识解释这一跨方协调机制,与重构章节讨论的具体阻力和数据沟通方法相互补充。

原书依据 · 2 处

特别放送|如何高效地学习开源项目(第3期)

学习开源项目时,源码阅读不是第一步而应是最后一步——顺序是先安装、再运行、再研究原理、再测试,最后才看源码。安装过程能通过依赖库反推系统设计(依赖 libevent 就能推测网络模型是 Reactor);运行阶段靠命令行参数摸清能力边界;原理研究要做到”系统性”,既懂实现原理也能对比方案优缺点。缺少问题意识就一头扎进源码,效率不高;带着问题学效率最高。发散:先建心智模型。参见懂优缺点才算掌握。 进一步展开见学开源项目自顶向下。

只有清楚一门技术方案的优缺点,才算真正掌握它,也只有如此才能在架构设计时做出合理选型。优缺点主要靠对比分析得出——把两个类似系统放在一起比较实现差异,比如对比 Memcache 多线程模型和 Redis 单进程模型的取舍,或同一系统内部不同模式的对比(如 Redis 的 RDB 和 AOF)。发散:”会用某技术”和”掌握了某技术”是两回事,后者看能否在类似方案间取舍。参见学开源项目自顶向下。 进一步展开见懂优缺点才算掌握。

项目里要用开源系统就必须自己测:版本不同结果差异大,别人测 128 字节的 value,你的场景是 128K,结论不能照搬。测试还必须放在原理研究之后,否则配置或运行模式用错,结论会误导设计。有团队装好 MySQL 5.1 就压测,结果奇差,排查才发现 innodb_buffer_pool_size 还是默认的 8M。发散:压测报告应附关键配置。参见用开源要深入研究测试。 进一步展开见先懂原理再做测试。

学开源项目的五步不必一次做完:安装、运行、原理研究这前三步必做;测试等到真要采用时再做;源码研究按时间灵活安排,但不是省略。时间不够时,与其蜻蜓点水把每个项目都了解一下,不如集中精力把一个项目研究透,哪怕每季度只学一个,几年下来也很可观;吃透一个之后再学同类项目会很快,因为共性已掌握,只需学差异。发散:深度会迁移,广度靠深度复利。参见学开源项目自顶向下。 进一步展开见一次吃透一个开源项目。

原书依据 · 8 处

特别放送|架构师成长之路(第4期)

架构设计原则(如”合适原则”)无法给出放之四海而皆准的标准,”合适”依赖业务、团队、技术实力等具体情境,最终要靠架构师的”内功”判断。内功拆成三层:判断力(准确看出系统复杂度所在)、执行力(用合适方案解决已识别问题)、创新力(创造前所未有的新方案)。发散:”知道原则”和”会用原则”之间隔着内功训练。参见内功来自经验视野思考。 进一步展开见架构师的三种内功。

判断力、执行力、创新力这类”内功”来自三个源头:经验(亲手设计、踩坑、填坑积累的体感)、视野(掌握足够多知识,站在他人经验之上)、思考(把经验和视野”消化”成判断模式)。经验和视野是外部输入,思考才是把输入转化为可迁移能力的关键,也是新想法和灵感的来源。发散:这套框架不局限于技术领域,任何专业能力精进本质都是”多经历、多参照、多消化”的循环。参见架构师的三种内功。 进一步展开见内功来自经验视野思考。

技术成长路径大致是:工程师(积累基础技能)→高级工程师(积累设计经验,从知道How到知道Why)→技术专家(拓展技术宽度)→初级架构师(形成方法论)→中级架构师(补齐理论深度)→高级架构师(创造新架构模式)。作者提醒:在正确的阶段采取错误的方法,可能事倍功半;如CAP等理论,到中级架构师面对高复杂度系统时才真正用得上、理解得透。发散:理论常要遇到匹配的问题才能内化。参见架构师的三种内功。 进一步展开见技术成长六阶段。

观察谷歌大数据论文、Storm、Docker等开创性架构的诞生背景,作者归纳了四个可能的背景条件:足够复杂的业务场景(复杂度倒逼突破)、足够强的技术团队(能落地想法)、不满足现状的态度(虚拟机太重才有Docker)、尊重技术价值的文化(允许不成熟探索,不被短期KPI否决)。作者也坦言创造性更多靠天分或灵感,难以教会。发散:环境条件只是土壤,不保证结果。参见技术演进的动力。 进一步展开见创造性架构的四个条件。

原书依据 · 14 处

结束语|坚持,成就你的技术梦想

把学到的东西讲给别人听、写成文章,是检验和加深理解的有效手段——很多自认为已掌握的知识,一旦要讲给别人听或写成文字,会发现还有很多细节没想清楚,需重新研究。输出不需追求篇幅或阅读量,哪怕只是一段话,只要持续做,就能推动自己把知识吃透,同时锻炼表达和临场反应能力。发散:这本质是费曼学习法的应用,能否讲清楚是检验是否真懂的标准。参见成长瓶颈在长期投入。 进一步展开见输出是很好的学习手段。

作者把从工程师成长为架构师这类能力提升,类比为他提到的”一万小时理论”——每天投入约3小时、坚持10年才达到量级(作者称之为著名定律,并认为技术成长基本遵循它;卡片注:这是经验性说法,非严格论证)。对大多数人而言,理论、方法、技巧往往都能知道,真正的瓶颈是能否长期坚持投入;所谓成长,就是不断学习、踩坑、填坑的过程。参见输出是很好的学习手段。 进一步展开见成长瓶颈在长期投入。

原书依据 · 5 处

特别放送|架构师必读书单(第5期)

技术方向差别很大,与其照搬书单,不如按通用路径拆解学习:一是深入学习代码运行环境,如 Linux 程序员学操作系统、前端学浏览器原理;二是深入学习核心工具,如 Java、MySQL;三是深入学习领域基础知识,如网络编程、算法;四是广泛学习领域通用的成熟技术,如 Netty、Spring、Redis。前三层求深,第四层求广。发散:囤书不是目的,坚持阅读、记录、分享才有收获。参见成长瓶颈在长期投入。 进一步展开见技术书籍按四层路径读。

原书依据 · 1 处

跨章综合

性能与可用性都可能采用冗余,却有不同目的:前者增加处理能力,后者面对部分组件失效仍提供服务。因此,读写分离、分片与副本不能仅按机器数量看成同一方案。缓存和消息队列改变请求在何时、何处被处理,也改变一致性、积压与恢复的责任。

分层、服务拆分与重构进一步把变化隔离到边界内。边界越多,跨边界通信和部署治理越值得关注;这与前面的简单及演化原则相呼应:应从主要问题出发逐步获得收益,而不是为尚未发生的规模无限提前建设。具体用户容量、产品版本与技术生态保留出版时语境,不作为当前运行保证。

发散与实践

读者延伸:实践计划及其准备材料保留在本书ideas目录。已有历史记录与本轮计划区分,尚未执行的观察、测量或验证不作为实际结果;涉及实现深读的项目与版本单独记录核验入口。

生成进度与管理记录

从零开始学架构

Skill 版本:v7

本次实际使用规则:book-notes v10(2026-10-03 按逐 spine 覆盖台账重跑,进行中);历史使用规则:book-notes v8(2026-09-24 按 _card_review.md 执行 S4 修订:压缩 108 张超长正文、全部标题缩至≤15字、修正第 25/49/50 讲 3 处表述;另补主题索引维护),详见 _workflow.md。

类别:系统架构类

四象限结论:经典原理(高信息浓度 × 高稳定性)

理由:全书是李运华在极客时间的专栏合集,共50讲,系统讲解架构设计的方法论、复杂度四大来源(高性能/高可用/可扩展性/低成本安全规模)、以及对应的经典技术方案。抽样精读第1讲(系统/子系统/模块/组件/框架/架构六个概念的严格辨析,从维基百科定义出发逐条提炼关键要素并给出反例)和第22讲(CAP理论,逐字对比Robert Greiner文章前后两版定义的措辞差异,精确辨析”see”与”read”、”every request”与”non-failing node”等用词差异背后的语义区别,并推导出分布式系统只能选CP或AP而非CA的结论)后确认:信息浓度极高——不是罗列”CAP是什么”,而是追问”CAP的精确定义为什么会从第一版演进到第二版、每一个措辞改动背后解决了什么歧义”;稳定性也很高——书中核心讲的是架构设计方法论、复杂度本质来源、CAP/FMEA等理论工具,这些内容即使脱离具体技术栈(书中提及的MySQL/Redis/Nginx等仅作为案例)依然成立,不会因为工具迭代而过时。因此判定为”经典原理”,是目前v7重跑以来遇到的信息浓度与稳定性都属最高档的一本书。

说明(2026-09-04):本书此前已有一版v6笔记(声明”Skill 版本:v6(2026-08-28 按 v6 规则续补;既有评级、章节进度与 75 张章节卡片保留)”),按v7重跑规则已用git rm -rq整体清空重建;本次评级结论、章节筛选、卡片内容均从零重新生成。EPUB内部结构:全书正文打包进5个text0000N.html大文件,toc.ncx用filepos锚点定位58个导航项,其中50个是正文编号讲(01-50),其余为说明/开篇词/结束语/书单/4次”华仔,放学别走”读者问答特别节目,非正式讲次不进入精读表。已确认50讲编号连续、无重复起始点,是李运华本人独立撰写的单本专栏合集,非拼装的多本书。

提取脚本:notes/从零开始学架构/_extract.py(已随笔记一起提交到git,_epub-src/OEBPS/为配套解压后的EPUB内容,同样已提交) (用法:python3 notes/从零开始学架构/_extract.py <起始playOrder> <结束playOrder> <输出文件>,playOrder取自_epub-src/OEBPS/toc.ncx中<navPoint playOrder="N">;每一讲对应一个独立的playOrder,起止传同一个数字即可提取单讲)

章节筛选

全书50讲围绕架构设计方法论与四大复杂度来源(高性能/高可用/可扩展性/低成本安全规模)展开,信息浓度普遍很高,按”硬性优先”规则全部标记精读;”华仔,放学别走”读者问答特别节目、开篇词、结束语、书单等非编号正文内容标记略读,不进入卡片生成。

V10 重跑(2026-10-03):历史表没有逐 spine 覆盖记录,已按 _coverage.md 逐来源项、逐单元重读后全部恢复 done;卡片数为当前 cards 文件实数,合计 217 张(S2 新增 15 张,S4 依审查补 5 张)。

讲次 标题 playOrder 精读/略读 状态(pending/done) 卡片数
01 架构到底是指什么? 3 精读 done 4
02 架构设计的历史背景 4 精读 done 3
03 架构设计的目的 5 精读 done 2
04 复杂度来源:高性能 6 精读 done 5
05 复杂度来源:高可用 7 精读 done 3
06 复杂度来源:可扩展性 8 精读 done 3
07 复杂度来源:低成本、安全、规模 9 精读 done 3
08 架构设计三原则 10 精读 done 5
09 架构设计原则案例 11 精读 done 2
10 架构设计流程:识别复杂度 13 精读 done 4
11 架构设计流程:设计备选方案 14 精读 done 3
12 架构设计流程:评估和选择备选方案 15 精读 done 5
13 架构设计流程:详细方案设计 16 精读 done 3
14 高性能数据库集群:读写分离 17 精读 done 3
15 高性能数据库集群:分库分表 18 精读 done 6
16 高性能NoSQL 20 精读 done 5
17 高性能缓存架构 21 精读 done 3
18 单服务器高性能模式:PPC与TPC 22 精读 done 4
19 单服务器高性能模式:Reactor与Proactor 23 精读 done 4
20 高性能负载均衡:分类及架构 24 精读 done 3
21 高性能负载均衡:算法 25 精读 done 3
22 想成为架构师,你必须知道CAP理论 26 精读 done 5
23 想成为架构师,你必须掌握的CAP细节 27 精读 done 6
24 FMEA方法,排除架构可用性隐患的利器 28 精读 done 4
25 高可用存储架构:双机架构 29 精读 done 5
26 高可用存储架构:集群和分区 30 精读 done 5
27 如何设计计算高可用架构? 31 精读 done 5
28 业务高可用的保障:异地多活架构 33 精读 done 4
29 异地多活设计4大技巧 34 精读 done 5
30 异地多活设计4步走 35 精读 done 4
31 如何应对接口级的故障? 36 精读 done 5
32 可扩展架构的基本思想和模式 37 精读 done 3
33 传统的可扩展架构模式:分层架构和SOA 38 精读 done 5
34 深入理解微服务架构:银弹 or 焦油坑? 39 精读 done 5
35 微服务架构最佳实践 - 方法篇 40 精读 done 3
36 微服务架构最佳实践 - 基础设施篇 41 精读 done 5
37 微内核架构详解 42 精读 done 3
38 架构师应该如何判断技术演进的方向? 43 精读 done 3
39 互联网技术演进的模式 44 精读 done 4
40 互联网架构模板:”存储层”技术 45 精读 done 3
41 互联网架构模板:”开发层”和”服务层”技术 46 精读 done 5
42 互联网架构模板:”网络层”技术 47 精读 done 4
43 互联网架构模板:”用户层”和”业务层”技术 48 精读 done 4
44 互联网架构模板:”平台”技术 49 精读 done 6
45 架构重构内功心法第一式:有的放矢 50 精读 done 4
46 架构重构内功心法第二式:合纵连横 51 精读 done 3
47 架构重构内功心法第三式:运筹帷幄 52 精读 done 4
48 再谈开源项目:如何选择、使用以及二次开发? 53 精读 done 8
49 谈谈App架构的演进 54 精读 done 4
50 架构实战:架构设计文档模板 55 精读 done 5
51 特别放送|“华仔,放学别走!”第1期 12 略读 done 0
52 特别放送|“华仔,放学别走!”第2期 19 精读 done 2
53 特别放送|如何高效地学习开源项目(第3期) 32 精读 done 4
54 特别放送|架构师成长之路(第4期) 56 精读 done 4
55 结束语|坚持,成就你的技术梦想 57 精读 done 2
56 特别放送|架构师必读书单(第5期) 58 精读 done 1

(V10 调整:说明与目录为非正文;开篇词(playOrder 2)逐单元核对后并入第08讲卡;特别放送第2–5期与结束语经逐单元取材后有合格候选,按 ch52–ch56 编号补卡;第1期无合格候选,仍为略读。各讲后附的读者留言为读者观点,跳过,其中作者有实质内容的回复单独成卡,即 ch10-004、ch15-006。)

实践卡进度

序号 实践标题 实践方式 状态(pending/done) 关联章节 产出
1 React Native / Weex / Flutter:跨平台格局核验 证据验证 done 第49讲 已通过WebSearch核验Weex已于2021年从Apache Incubator退休、当前边缘化,React Native与Flutter仍是2026年跨平台开发两大主流方案(份额约35%对46%),产出《2018年三方案格局 vs 2026年现状》对照表框架,见ideas/idea-001-React Native Weex Flutter跨平台格局核验.md
2 服务网格:服务中心两种模式之外的”第三条路”核验 证据验证 done 第41讲 已通过WebSearch核验Service Mesh(Istio+Envoy)是当前微服务治理主流方案,其sidecar代理模式介于书中”服务名字系统”与”服务总线系统”之间、书中二分类框架未能覆盖,产出对照说明框架,见ideas/idea-002-服务网格是服务中心两种模式之外的第三条路核验.md

V10 复核(2026-10-03):结合新增 15 张卡重新筛选,开源学习“自顶向下”可对照已有 idea 的证据核验方式,但缺少明确交付物;成长与书单类内容为个人习惯建议,难以验证。均未采用,维持 2 张实践卡。

待关联术语

术语名 出现章节 一句话语境
备选方案模板中”备选方案1直接引入Kafka/方案2集群+MySQL存储/方案3集群+自研存储”三个方案的具体描述、”备选方案评估”360度环评具体展开、高性能/其他设计的具体章节留白提示 50 原文对具体方案描述与360度环评均注明”此处省略”,属于占位性模板说明而非实际内容;核心方法论(5W1H8C框架、性能定量推导、文档四段结构、高可用明确失败边界、无设计点也要写明)已在ch50-001至ch50-005中概括,未单独展开生卡
手机淘宝首页/微信”发现”tab配图、《Atlas:手淘Native容器化框架和思考》《微信Android客户端架构演进之路》《Web研发模式演变》三篇外部引用文章、本讲结尾思考题”App架构接下来会如何演进” 49 属于外链配图与延伸阅读文章链接及开放式思考题,非本讲结论性正文内容;核心方法论(五阶段演进、App与后端拆分区别、组件化容器化发布方式区别、跨平台现状)已在ch49-001至ch49-004中概括,未单独展开生卡
本讲结尾思考题”倾向购买云厂商托管的开源同款系统还是自建”、”专栏特别放送第3期《如何高效学习开源项目》”引用链接 48 属于开放式思考题与跨期引用链接,非本讲结论性正文内容;核心方法论(选的三聚焦、用的三要点、改的两策略)已在ch48-001至ch48-008中概括,未单独展开生卡
X项目三阶段策略配图、本讲结尾思考题”2年才能完成的架构重构项目该如何处理” 47 属于外链配图与开放式思考题,非结论性正文内容;核心方法论(三大缺陷、X/S系统三阶段对比、分段实施四步法、先易后难三理由)已在ch47-001至ch47-004中概括,未单独展开生卡
本讲结尾思考题”架构师为何要做沟通推动而非交给项目经理”及读者评论区三点回答与作者回复 46 读者评论区问答内容非作者原文正文,属于非作者生成内容;核心方法论(合纵用数据说话、连横两大阻力应对、C系统换位思考案例)已在ch46-001至ch46-003中概括,未单独展开生卡
M/S/X三系统各自的原始架构配图与重构后架构配图、本讲结尾思考题”分析你目前开发的系统是否需要架构重构” 45 属于外链架构配图与开放式思考题,非结论性正文内容;核心方法论(重构三难点、有的放矢识别核心问题、重构vs优化判断法、三案例根因对比)已在ch45-001至ch45-004中概括,未单独展开生卡
运维平台/测试平台/数据平台/管理平台各自的架构配图、本讲结尾思考题”运维/测试平台该由中间件团队还是运维测试团队自建” 44 属于外链架构图与开放式思考题,非结论性正文内容;核心方法论(四大职责/四化、标准化中间层适配、可视化本质、测试平台任务管理串联、数据平台规模门槛、权限管理两分法)已在ch44-001至ch44-006中概括,未单独展开生卡
CAS单点登录具体架构图链接、电商系统三阶段拆分与虚拟业务域架构的配图、本讲结尾思考题”虚拟业务域划分粒度粗细及数量建议” 43 属于外链架构图与开放式思考题,非文字性结论内容;核心方法论(SSO/OAuth两大目标、用户管理为何数据量大却不难、虚拟业务域用网关Facade收编子系统爆炸)已在ch43-001/ch43-004中概括,未单独展开生卡
本讲结尾思考题”为什么可以购买负载均衡和CDN服务,但却不能购买多机房和多中心服务?” 42 思考题本身是作者留给读者的开放提问,非结论性正文内容,核心答案已在ch42-004多中心质变结论中给出(数据一致性/事务性与具体业务强绑定,无通用方案可买),未单独展开生卡
主备算法细分(冷备/温备/热备)、1主3备/2主2备/3主1备/4主0备等集群分配算法的具体展开、ZooKeeper(1主多备)与Memcached(全主0备)的具体案例 05 属于具体分配算法参数和工具案例的简短提及,核心可迁移方法论(高可用本质是冗余而非扩展/计算与存储高可用差异/状态决策三种方式及固有缺陷)已在ch05-001至ch05-003中概括,未单独展开生卡
摩尔定律与CPU硬件性能发展历史、Nginx/JBoss/Redis/Memcache各自采用多进程或多线程或单进程实现高性能的具体案例对比(体现”没有最新的就是最好的”,可与ch04-002进程线程演进链条关联但未单独展开)、支付宝双11每秒12万笔支付/微信红包每秒76万个的具体业务数据 04 属于硬件发展史背景与具体技术组件实现案例罗列,核心可迁移方法论(技术带来复杂度取决于替代还是并存关系/进程线程演进链条/任务分配复杂度递增/任务分解的收益与代价)已在ch04-001至ch04-004中概括,未单独展开生卡
机器语言/汇编语言/高级语言的具体演进历史与代码示例(Fortran/LISP/Cobol)、NATO会议与”软件工程”一词的由来、《人月神话》与IBM System/360项目背景 02 属于计算机语言发展史的背景铺垫,是通俗历史科普而非架构原理本身,核心可迁移方法论(两次软件危机的根本原因/模块对象组件的拆分粒度递进/软件架构问题的独特起源)已在ch02-001至ch02-003中概括,未单独展开生卡
讲末读者留言与作者回复(如具体业务场景下是否要做可扩展性设计的个案讨论) 06 EPUB导出正文时附带的读者评论区,非作者原创正文内容,仅作为ch06-001卡片”评估代价过大可暂缓/适度冗余降低复杂度”结论的辅助佐证摘录,不单独生卡
淘宝架构各阶段具体技术选型细节(SQL Relay连接池死锁问题、Oracle RAC/NetApp NAS存储、数据分库/放弃EJB/引入Spring/加缓存/加CDN/采用JBoss的具体动作清单、去IOE的具体实施) 09 属于具体技术组件名称和历史选型细节的罗列,核心可迁移方法论(”买→重构→自研”的原则转换逻辑)已在ch09-001中概括,未单独展开生卡
手机QQ各阶段具体架构图与容量数字(接入服务器内存2KB/在线用户估算、IM 2.X/3.X/4.X具体架构图、存储架构与通信架构的内部模块划分) 09 属于具体容量估算数据和架构图细节,核心可迁移方法论(用户规模倒逼升级/亿级阶段从打补丁转向推倒重来)已在ch09-002中概括,未单独展开生卡
消息队列开源方案罗列(ActiveMQ、RabbitMQ)、集群存储可选组件(HBase、Redis与MySQL结合)、自研文件系统可参考对象(LevelDB、HBase)、《技术的本质》一书对技术”组合”与”递归”特征的论述 11 属于具体可选技术组件的罗列示例,核心可迁移方法论(备选方案设计三准则、技术组合本质)已在ch11-001至ch11-003中概括,未单独展开生卡
讲末读者留言对Kafka与RocketMQ的详细技术对比(适用场景/单机TPS/刷盘与Replication方式/消息顺序性/消费失败重试/定时消息/分布式事务消息/消息查询与回溯等7个维度) 12 EPUB导出正文附带的读者评论区内容,非作者原创正文,属于读者自行整理的延伸技术资料,不计入本讲卡片来源
讲末大量读者留言与作者回复(数据库性能优化的完整排查顺序:硬件优化→数据库调优→引入缓存→程序优化→再分库分表;分库分表的进一步实操讨论,如淘宝单元化改造按买家维度拆分卖家维度不拆分、水平拆分后分页查询要”先组合查后分页”、二次order by的性能权衡等) 15 EPUB导出正文附带的读者评论区内容,非作者原创正文,属于读者与作者的问答延伸,不计入本讲卡片来源
讲末读者留言关于”为何没有开源存储平台方案但云计算都提供存储平台服务”的分析(开发成本高需高级工程师/需求方主要是大公司数量少/云平台收费能变现而开源投入大受众少) 40 EPUB导出正文附带的读者评论区内容,非作者原创正文,属于读者对思考题的回答,不计入本讲卡片来源

引用文献

标题 类型 出现章节 一句话语境

类别清单核对(系统架构类)

维度 覆盖状态 关联卡片标题或未覆盖理由
服务拆分原则 已覆盖 ch32-001可扩展的基本思想是拆及三种拆分思路的范围关系、ch33-004SOA的诞生背景及三个关键概念服务ESB与松耦合、ch43-004虚拟业务域分久必合用网关Facade收编子系统爆炸
通信机制(同步/异步取舍) 已覆盖 ch41-004服务中心的两种实现方式服务名字系统与服务总线系统、ch41-005消息队列解决蜘蛛网式异步通知问题带来的五个好处、ch11/ch12/ch13消息队列备选方案对比与最终决策
一致性与事务权衡 已覆盖 ch22-002一致性定义的精确化从节点同时可见到客户端读到最新写入、ch23-005ACID与CAP的A和C同名不同义、ch16-002/ch16-003 KV存储与文档数据库用数据结构或no-schema换取部分ACID
可观测性设计 已覆盖 ch44-001运维平台四大职责与四化设计要素、ch44-003可视化的本质是仪表盘式的信息压缩、ch50-004高可用设计要写清楚哪里会丢而非假装100%可靠
容错设计(熔断/降级/重试) 已覆盖 ch31-002降级丢车保帅的核心思想及两种实现方式的取舍、ch31-003熔断与降级的本质区别应对自身故障还是依赖方故障、ch31-004限流基于请求限流与基于资源限流的对比
扩展性瓶颈与应对 已覆盖 ch12-005平滑扩容挡不住质变、ch15-006多维查询靠数据冗余、ch20-001高性能集群的本质是任务分配、ch32系列可扩展基本思想是拆及三种拆分方式对应的典型架构、ch44-005数据平台三大职责与数据价值的规模门槛
部署与发布策略(灰度/回滚) 已覆盖 ch49-003组件化与容器化的核心区别静态发布与动态发布、ch48-005用开源项目再深入的研究测试也替代不了灰度、ch47系列分段实施策略中的分阶段上线节奏规划

7/7维度已覆盖,均为书中已有卡片充分论证,无需补充生成新卡片。V10 复核(2026-10-03)补入新卡后结论不变。

资金安全问题案例

问题标题 问题卡 解决方案卡(如有) 出现章节 一句话说明

主题索引维护

本书与第11条《从0开始学架构》为同一作者同一专栏的不同版本,按讲次复用该书建立的 18 个主题,另新建 1 个“互联网通用技术架构分层”。本表基于 S4 修订后的 197 张稳定卡。V10(2026-10-03)新增 15 张卡全部加入 4 个已有主题(已复用 15),S4 依审查补卡 5 张,加入 3 个已有主题(已复用 5);当前 217 张卡结论齐全,无需加入 0、待复核 0。

卡片标题 结论 主题文件或原因
系统三要素 已复用 notes/_topics/architecture-principles-complexity.md
模块逻辑拆组件物理拆 已复用 notes/_topics/architecture-principles-complexity.md
框架是规范架构是结构 已复用 notes/_topics/architecture-principles-complexity.md
两次软件危机不同源 已复用 notes/_topics/architecture-principles-complexity.md
架构诞生的必然性 已复用 notes/_topics/architecture-principles-complexity.md
架构源于系统规模 已复用 notes/_topics/architecture-principles-complexity.md
架构设计四个误区 已复用 notes/_topics/architecture-principles-complexity.md
架构为解决复杂度 已复用 notes/_topics/architecture-principles-complexity.md
并存技术才增加复杂度 已复用 notes/_topics/architecture-principles-complexity.md
进程与线程演进链 已复用 notes/_topics/architecture-principles-complexity.md
任务分配的复杂度递增 已复用 notes/_topics/architecture-principles-complexity.md
任务分解的收益与上限 已复用 notes/_topics/architecture-principles-complexity.md
高可用靠冗余 已复用 notes/_topics/architecture-principles-complexity.md
计算与存储高可用差异 已复用 notes/_topics/architecture-principles-complexity.md
高可用状态决策三方式 已复用 notes/_topics/architecture-principles-complexity.md
可扩展需预测并封装变化 已复用 notes/_topics/architecture-principles-complexity.md
预测变化的三重难题 已复用 notes/_topics/architecture-principles-complexity.md
应对变化的两种方案 已复用 notes/_topics/architecture-principles-complexity.md
低成本是附加约束 已复用 notes/_topics/architecture-principles-complexity.md
防小偷与防强盗 已复用 notes/_topics/architecture-principles-complexity.md
规模复杂度是量变质变 已复用 notes/_topics/architecture-principles-complexity.md
架构是应对不确定性 已复用 notes/_topics/architecture-principles-complexity.md
合适原则 已复用 notes/_topics/architecture-principles-complexity.md
结构复杂性的三重代价 已复用 notes/_topics/architecture-principles-complexity.md
逻辑复杂性的两种形态 已复用 notes/_topics/architecture-principles-complexity.md
演化原则 已复用 notes/_topics/architecture-principles-complexity.md
淘宝从买到重构的转换 已复用 notes/_topics/architecture-principles-complexity.md
手机QQ亿级推倒重来 已复用 notes/_topics/architecture-principles-complexity.md
先识别复杂度 已复用 notes/_topics/architecture-design-process.md
排查法识别复杂度 已复用 notes/_topics/architecture-design-process.md
备选方案三种常见错误 已复用 notes/_topics/architecture-design-process.md
备选方案三条准则 已复用 notes/_topics/architecture-design-process.md
消息队列备选方案对比 已复用 notes/_topics/architecture-design-process.md
四种方案挑选思路 已复用 notes/_topics/architecture-design-process.md
360度环评法 已复用 notes/_topics/architecture-design-process.md
按优先级选定方案 已复用 notes/_topics/architecture-design-process.md
消息队列选型的决策 已复用 notes/_topics/architecture-design-process.md
详细设计的轻量选型 已复用 notes/_topics/architecture-design-process.md
防止详细设计推翻方案 已复用 notes/_topics/architecture-design-process.md
消息队列的详细设计 已复用 notes/_topics/architecture-design-process.md
读写分离与主从主备 已复用 notes/_topics/distributed-data-sharding.md
复制延迟的三种应对 已复用 notes/_topics/distributed-data-sharding.md
读写分离的分配机制 已复用 notes/_topics/distributed-data-sharding.md
业务分库的三重代价 已复用 notes/_topics/distributed-data-sharding.md
业务分库的适用时机 已复用 notes/_topics/distributed-data-sharding.md
垂直分表与水平分表 已复用 notes/_topics/distributed-data-sharding.md
水平分表路由算法 已复用 notes/_topics/distributed-data-sharding.md
水平分表的查询难题 已复用 notes/_topics/distributed-data-sharding.md
NoSQL是关系库的补充 已复用 notes/_topics/storage-model-choices.md
Redis是数据结构服务器 已复用 notes/_topics/storage-model-choices.md
MongoDB以无模式换灵活 已复用 notes/_topics/storage-model-choices.md
行存与列存看访问模式 已复用 notes/_topics/storage-model-choices.md
倒排索引原理 已复用 notes/_topics/storage-model-choices.md
缓存穿透的成因与应对 已复用 notes/_topics/caching-strategies.md
缓存雪崩的两种方案 已复用 notes/_topics/caching-strategies.md
缓存热点多副本错峰 已复用 notes/_topics/caching-strategies.md
架构定上限实现定下限 已复用 notes/_topics/server-io-concurrency-models.md
PPC与prefork的瓶颈 已复用 notes/_topics/server-io-concurrency-models.md
TPC与线程池预创建 已复用 notes/_topics/server-io-concurrency-models.md
I/O多路复用的由来 已复用 notes/_topics/server-io-concurrency-models.md
单Reactor的两种形态 已复用 notes/_topics/server-io-concurrency-models.md
多Reactor的职责分离 已复用 notes/_topics/server-io-concurrency-models.md
异步I/O的Proactor 已复用 notes/_topics/server-io-concurrency-models.md
集群的本质是任务分配 已复用 notes/_topics/load-balancing.md
三种负载均衡机制 已复用 notes/_topics/load-balancing.md
三层负载均衡组合 已复用 notes/_topics/load-balancing.md
负载均衡算法四大类 已复用 notes/_topics/load-balancing.md
感知状态的均衡算法 已复用 notes/_topics/load-balancing.md
Hash均衡保持会话 已复用 notes/_topics/load-balancing.md
CAP的适用范围 已复用 notes/_topics/distributed-consensus.md
一致性是读到最新写入 已复用 notes/_topics/distributed-consensus.md
可用性是合理响应 已复用 notes/_topics/distributed-consensus.md
分区容忍是继续履职 已复用 notes/_topics/distributed-consensus.md
CP与AP的区分 已复用 notes/_topics/distributed-consensus.md
CAP按数据粒度取舍 已复用 notes/_topics/distributed-consensus.md
CAP忽略网络延迟 已复用 notes/_topics/distributed-consensus.md
无分区时要做到CA 已复用 notes/_topics/distributed-consensus.md
牺牲不等于什么都不做 已复用 notes/_topics/distributed-consensus.md
ACID与CAP同名不同义 已复用 notes/_topics/distributed-consensus.md
BASE是AP的补充 已复用 notes/_topics/distributed-consensus.md
FMEA事后排查隐患 已复用 notes/_topics/nfr-in-design.md
FMEA核心字段设计 已复用 notes/_topics/nfr-in-design.md
故障原因与风险程度 已复用 notes/_topics/nfr-in-design.md
已有措施与规避解决 已复用 notes/_topics/nfr-in-design.md
存储高可用四问与主备 已复用 notes/_topics/high-availability-architecture.md
主从复制让从机干活 已复用 notes/_topics/high-availability-architecture.md
双机切换三个设计点 已复用 notes/_topics/high-availability-architecture.md
双机切换三式的取舍 已复用 notes/_topics/high-availability-architecture.md
主主复制限制数据类型 已复用 notes/_topics/high-availability-architecture.md
数据集中集群的复杂性 已复用 notes/_topics/high-availability-architecture.md
数据分散集群的设计点 已复用 notes/_topics/high-availability-architecture.md
数据分区应对地理灾难 已复用 notes/_topics/high-availability-architecture.md
分区看数据量与地理粒度 已复用 notes/_topics/high-availability-architecture.md
分区复制规则三模式 已复用 notes/_topics/high-availability-architecture.md
计算高可用两个设计点 已复用 notes/_topics/high-availability-architecture.md
计算主备的冷备与温备 已复用 notes/_topics/high-availability-architecture.md
计算主从架构 已复用 notes/_topics/high-availability-architecture.md
负载均衡集群的状态检测 已复用 notes/_topics/high-availability-architecture.md
非对称集群的复杂度 已复用 notes/_topics/high-availability-architecture.md
异地多活并非都值得 已复用 notes/_topics/high-availability-architecture.md
同城异区应对机房故障 已复用 notes/_topics/high-availability-architecture.md
跨城异地按数据分类 已复用 notes/_topics/high-availability-architecture.md
跨国异地的多活含义 已复用 notes/_topics/high-availability-architecture.md
只保证核心业务多活 已复用 notes/_topics/high-availability-architecture.md
保证核心数据最终一致 已复用 notes/_topics/high-availability-architecture.md
多手段同步数据 已复用 notes/_topics/high-availability-architecture.md
只保证绝大部分用户 已复用 notes/_topics/high-availability-architecture.md
业务分级的三条标准 已复用 notes/_topics/high-availability-architecture.md
数据分类的五个维度 已复用 notes/_topics/high-availability-architecture.md
数据同步三种方案 已复用 notes/_topics/high-availability-architecture.md
异常处理四类措施 已复用 notes/_topics/high-availability-architecture.md
接口级故障与应对思路 已复用 notes/_topics/overload-protection-degradation.md
降级是丢车保帅 已复用 notes/_topics/overload-protection-degradation.md
熔断应对依赖方故障 已复用 notes/_topics/overload-protection-degradation.md
请求限流与资源限流 已复用 notes/_topics/overload-protection-degradation.md
排队是限流的变种 已复用 notes/_topics/overload-protection-degradation.md
可扩展的基本思想是拆 已复用 notes/_topics/scalability-dimensions.md
拆分约束出错范围 已复用 notes/_topics/scalability-dimensions.md
三种拆分的典型架构 已复用 notes/_topics/scalability-dimensions.md
分层架构的三种维度 已复用 notes/_topics/layered-architecture-ports.md
分层扩展靠稳定依赖 已复用 notes/_topics/layered-architecture-ports.md
分层层层传递的代价 已复用 notes/_topics/layered-architecture-ports.md
SOA的服务与ESB 已复用 notes/_topics/microservice-boundaries-evolution.md
SOA是企业级理念 已复用 notes/_topics/microservice-boundaries-evolution.md
微服务与SOA四维对比 已复用 notes/_topics/microservice-boundaries-evolution.md
拆太细转移复杂度 已复用 notes/_topics/microservice-boundaries-evolution.md
微字迷思拆得过细 已复用 notes/_topics/microservice-boundaries-evolution.md
调用链变长的代价 已复用 notes/_topics/microservice-boundaries-evolution.md
缺治理的微服务成ESB 已复用 notes/_topics/microservice-boundaries-evolution.md
三个火枪手原则 已复用 notes/_topics/microservice-boundaries-evolution.md
微服务拆分四维度 已复用 notes/_topics/microservice-boundaries-evolution.md
微服务基础设施优先级 已复用 notes/_topics/microservice-boundaries-evolution.md
自动化测试与部署 已复用 notes/_topics/microservice-boundaries-evolution.md
配置中心与接口框架 已复用 notes/_topics/microservice-boundaries-evolution.md
API网关统一外部入口 已复用 notes/_topics/microservice-boundaries-evolution.md
服务发现两种方式 已复用 notes/_topics/microservice-boundaries-evolution.md
服务治理核心功能 已复用 notes/_topics/microservice-boundaries-evolution.md
微内核三个设计关键 已复用 notes/_topics/modularity-information-hiding.md
OSGi落地微内核 已复用 notes/_topics/modularity-information-hiding.md
规则引擎与微内核 已复用 notes/_topics/modularity-information-hiding.md
三种技术判断派别 已复用 notes/_topics/business-driven-tech-evolution.md
技术演进的动力 已复用 notes/_topics/business-driven-tech-evolution.md
按发展阶段判断复杂度 已复用 notes/_topics/business-driven-tech-evolution.md
初创期只求快 已复用 notes/_topics/business-driven-tech-evolution.md
优化派与架构派之争 已复用 notes/_topics/business-driven-tech-evolution.md
竞争期平台化服务化 已复用 notes/_topics/business-driven-tech-evolution.md
成熟期求精与量变 已复用 notes/_topics/business-driven-tech-evolution.md
SQL存储三阶段演进 已创建 notes/_topics/internet-architecture-template.md
NoSQL平台规模大才划算 已创建 notes/_topics/internet-architecture-template.md
小文件与大文件存储 已创建 notes/_topics/internet-architecture-template.md
统一开发框架优选成熟 已创建 notes/_topics/internet-architecture-template.md
Web服务器拿来用 已创建 notes/_topics/internet-architecture-template.md
配置中心集中管理 已创建 notes/_topics/internet-architecture-template.md
服务中心两种实现 已创建 notes/_topics/internet-architecture-template.md
消息队列的五个好处 已创建 notes/_topics/internet-architecture-template.md
HTTP-DNS的得失 已创建 notes/_topics/internet-architecture-template.md
硬件均衡量大反而省钱 已创建 notes/_topics/internet-architecture-template.md
CDN买而不造 已创建 notes/_topics/internet-architecture-template.md
多中心是质变 已创建 notes/_topics/internet-architecture-template.md
用户管理量大不难 已创建 notes/_topics/internet-architecture-template.md
Android推送为何复杂 已创建 notes/_topics/internet-architecture-template.md
图片云为何单独拆出 已创建 notes/_topics/internet-architecture-template.md
虚拟业务域收编子系统 已创建 notes/_topics/internet-architecture-template.md
运维平台四化 已创建 notes/_topics/internet-architecture-template.md
中间层适配运维标准 已创建 notes/_topics/internet-architecture-template.md
可视化是信息压缩 已创建 notes/_topics/internet-architecture-template.md
测试平台四模块 已创建 notes/_topics/internet-architecture-template.md
数据平台三大职责 已创建 notes/_topics/internet-architecture-template.md
权限管理分认证与控制 已创建 notes/_topics/internet-architecture-template.md
重构比新设计难在三点 已复用 notes/_topics/architecture-refactoring.md
重构要有的放矢 已复用 notes/_topics/architecture-refactoring.md
从零设计判断是否重构 已复用 notes/_topics/architecture-refactoring.md
三个重构案例的根因 已复用 notes/_topics/architecture-refactoring.md
合纵用数据沟通 已复用 notes/_topics/architecture-refactoring.md
连横的两大阻力 已复用 notes/_topics/architecture-refactoring.md
找到对方的真实痛点 已复用 notes/_topics/architecture-refactoring.md
逐个解决问题的缺陷 已复用 notes/_topics/architecture-refactoring.md
两系统分段实施对比 已复用 notes/_topics/architecture-refactoring.md
分段实施四步法 已复用 notes/_topics/architecture-refactoring.md
重构应先易后难 已复用 notes/_topics/architecture-refactoring.md
选开源看是否满足业务 已复用 notes/_topics/open-source-adoption.md
选开源看是否成熟 已复用 notes/_topics/open-source-adoption.md
选开源看运维能力 已复用 notes/_topics/open-source-adoption.md
用开源要深入研究测试 已复用 notes/_topics/open-source-adoption.md
研究测试替代不了灰度 已复用 notes/_topics/open-source-adoption.md
重要存储要有备份方案 已复用 notes/_topics/open-source-adoption.md
改开源只做外围包装 已复用 notes/_topics/open-source-adoption.md
没有完全合适的轮子 已复用 notes/_topics/open-source-adoption.md
App架构五阶段演进 已复用 notes/_topics/business-driven-tech-evolution.md
App拆分不同于后端 已复用 notes/_topics/business-driven-tech-evolution.md
组件化与容器化之别 已复用 notes/_topics/business-driven-tech-evolution.md
2018年跨平台方案取舍 已复用 notes/_topics/business-driven-tech-evolution.md
需求分析5W1H8C 已复用 notes/_topics/architecture-design-process.md
从业务量倒推性能目标 已复用 notes/_topics/architecture-design-process.md
架构设计文档结构 已复用 notes/_topics/architecture-design-process.md
写清楚哪里会丢 已复用 notes/_topics/architecture-design-process.md
不涉及也要写无 已复用 notes/_topics/architecture-design-process.md
逐个解决不致推倒重来 已复用 notes/_topics/architecture-design-process.md
性能量级要烂熟于心 已复用 notes/_topics/architecture-design-process.md
平滑扩容挡不住质变 已复用 notes/_topics/architecture-design-process.md
多维查询靠数据冗余 已复用 notes/_topics/distributed-data-sharding.md
硬性要求属于架构约束 已复用 notes/_topics/architecture-design-process.md
学开源项目自顶向下 已复用 notes/_topics/open-source-adoption.md
懂优缺点才算掌握 已复用 notes/_topics/open-source-adoption.md
先懂原理再做测试 已复用 notes/_topics/open-source-adoption.md
架构师的三种内功 已复用 notes/_topics/architect-growth.md
内功来自经验视野思考 已复用 notes/_topics/architect-growth.md
技术成长六阶段 已复用 notes/_topics/architect-growth.md
创造性架构的四个条件 已复用 notes/_topics/architect-growth.md
输出是很好的学习手段 已复用 notes/_topics/architect-growth.md
成长瓶颈在长期投入 已复用 notes/_topics/architect-growth.md
技术书籍按四层路径读 已复用 notes/_topics/architect-growth.md
架构是系统的顶层结构 已复用 notes/_topics/architecture-principles-complexity.md
单机并发模型无标准答案 已复用 notes/_topics/server-io-concurrency-models.md
高并发按连接与请求分四类 已复用 notes/_topics/server-io-concurrency-models.md
不为架构改核心规则 已复用 notes/_topics/high-availability-architecture.md
一次吃透一个开源项目 已复用 notes/_topics/open-source-adoption.md

2026-10-23 v23轻量恢复

执行模式:light

  • 首次生成Skill版本保留;本轮实际使用book-notes v23 / book-workflow v4。
  • 复用来源匹配的有效全文阅读和217张知识卡;未批量改写历史学习元数据。
  • 整书笔记:_book_note.md,schema 1,SHA-256 aaa2c79a6586922fece5c055cba57e751e760f5220efce22258f12c75b47ebcf;217个primary、554处原书来源。
  • 未执行笔记复核、独立审查及审查结果优化。实践筛选与导入归档结果另见本轮交接,不凭历史done宣称本次已经执行。
本轮实践交付
  • 实践候选筛选:done(已筛选完毕)。保留两项不同对象的证据验证,已实际填首轮官方事实对照;未采用重复的部署/性能演示计划。
  • 两张ideas均done指生成交付;后续调研与实测未执行。撤回旧卡无法从一手证据推出的市场份额、原生体验全面追平和无中心风险等主张;历史文件留于_v23_evidence/historical-ideas。
  • 历史P2“架构师沟通能力”独立卡暂缓仍保留:重构沟通卡已覆盖相关语境,当前无核心缺口;需将来确认独立新机制再补。

2026-10-24 历史P2补齐

  • 用户明确要求补齐历史后续项;新增“技术判断需要跨方共识”,当前218张知识卡、2项未执行实践计划。
  • 第2期访谈的跨方共识机制已独立保留,原沟通能力P2关闭。
  • 整书笔记及来源投影已同步:218个primary、555条出处,SHA-256 6fdd949bb3ca2a2d4d749ee966332b46505f15d421c79ccbaa7e1a88218dd9f4。
  • light;未执行笔记复核、独立审查及审查结果优化。重新导入、对账与归档均已完成,原沟通能力后续项关闭。

相关主题

从本书的主题进入跨书阅读,对照其他书籍的讲解。下方数量包含主题关联的全部卡片与书籍。

主题索引

存储模型选型

比较关系型、键值、列式、文档与全文检索等存储模型的特性取舍与适用场景。

699 张卡片 · 63 本书

主题索引

微服务拆分与演进

比较微服务拆分的边界依据、粒度与非业务因素,以及从单体演进和持续重组的策略。

444 张卡片 · 71 本书

主题索引

高可用与异地多活架构

比较主备、主从、集群、分区与异地多活等高可用架构的适用范围、数据同步与代价。

398 张卡片 · 79 本书

主题索引

过载保护与优雅降级

比较限流、减载、退避重试、分级依赖与防御成本的过载应对手段。

386 张卡片 · 68 本书

主题索引

分布式共识与领导者选举

比较分布式共识、领导者选举、副本数量与一致性模型的可靠性取舍。

376 张卡片 · 41 本书

主题索引

架构方案设计与评估

比较备选方案设计、评估选择、容量预估与详细设计等架构设计流程中的判断方法。

352 张卡片 · 40 本书

主题索引

缓存架构与失效问题

比较缓存穿透、雪崩、热点等问题的成因与应对方案。

345 张卡片 · 58 本书

主题索引

架构设计原则与复杂度来源

比较架构要解决的复杂度来源(性能、可用性、扩展、成本、安全、规模)以及合适、简单、演化等设计原则。

228 张卡片 · 40 本书

主题索引

单机高性能与I/O模型

比较进程/线程并发模型、I/O 多路复用、Reactor 与 Proactor 等单机高性能设计。

226 张卡片 · 46 本书

主题索引

模块化与信息隐藏

比较以函数、闭包、包或服务划定模块边界并隐藏实现细节的方法。

209 张卡片 · 51 本书

主题索引

分层、洋葱与六边形架构

比较分层、洋葱与六边形架构如何隔离核心业务逻辑与外部技术细节,以及各层职责与调用规则。

196 张卡片 · 43 本书

主题索引

负载均衡

比较负载均衡的分层组合方式与各类分配算法的取舍。

163 张卡片 · 55 本书

主题索引

架构师成长路径

比较架构师所需的判断力、执行力、创新力及其积累方式与成长阶段。

157 张卡片 · 36 本书

主题索引

架构重构

比较识别重构目标、沟通推动与分段实施等架构重构方法。

138 张卡片 · 29 本书

主题索引

系统扩展的维度

比较水平复制、按业务拆分与数据分片等不同维度的扩展手段及其适用问题。

134 张卡片 · 52 本书

主题索引

技术沟通与架构表达

比较面向不同受众的技术写作、演示与架构图方法:循序渐进的讲解、文档与幻灯片的取舍,以及让图表达连接与语义。

124 张卡片 · 27 本书

主题索引

业务驱动的技术演进

比较业务规模与复杂度变化如何驱动技术选型和架构分阶段演进。

88 张卡片 · 37 本书

主题索引

开源项目选型与使用

比较学习、选型、灰度引入与二次开发开源项目的方法与风险控制。

75 张卡片 · 34 本书

主题索引

互联网通用技术架构分层

比较互联网业务常见的存储层、开发层、服务层、网络层、用户层与平台层技术及其选型要点。

30 张卡片 · 5 本书