详解淘宝双十一高并发架构、数据库分库分表、异地多活、多级缓存、负载均衡等核心技术与架构设计
前言
“双十一每秒54万笔交易，为什么数据库不会挂？”
“十几亿用户同时访问，为什么页面秒开？”
“下单后数据库怎么扛住的压力？”
“多地机房怎么同步数据？”
这些问题困扰着很多技术人。今天我们就来深度剖析淘宝的架构设计，揭示支撑十几亿用户的核心技术秘密。
一、淘宝业务规模
1.1 双十一数据震撼
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
┌─────────────────────────────────────────────────────────────────┐
│ 双十一数据震撼 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 2023年双十一数据： │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 交易峰值 │ │
│ │ ████████████████████████████████████████████████ │ │
│ │ 54.4万笔/秒 │ │
│ │ │ │
│ │ 订单创建峰值 │ │
│ │ ████████████████████████████████████████████████ │ │
│ │ 58.3万笔/秒 │ │
│ │ │ │
│ │ 支付峰值 │ │
│ │ ████████████████████████████████████████████████ │ │
│ │ 45.9万笔/秒 │ │
│ │ │ │
│ │ 总交易额 │ │
│ │ ████████████████████████████████████████████████ │ │
│ │ 2135亿元 │ │
│ │ │ │
│ │ 物流订单 │ │
│ │ ████████████████████████████████████████████████ │ │
│ │ 13.52亿件 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 对比参考： │
│ ├── 普通电商网站：100-1000 TPS │
│ ├── 双十一淘宝：54万+ TPS │
│ └── 差距：500-5000倍 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
1.2 技术挑战
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
┌─────────────────────────────────────────────────────────────────┐
│ 淘宝面临的技术挑战 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 挑战1：海量用户 │ │
│ │ ├── 注册用户：13亿+ │ │
│ │ ├── 日活用户：数亿 │ │
│ │ └── 同时在线：千万级 │ │
│ │ │ │
│ │ 挑战2：海量数据 │ │
│ │ ├── 商品数据：数十亿 │ │
│ │ ├── 订单数据：千亿级 │ │
│ │ ├── 用户数据：13亿+ │ │
│ │ └── 日增数据：TB级 │ │
│ │ │ │
│ │ 挑战3：高并发 │ │
│ │ ├── 峰值QPS：百万级 │ │
│ │ ├── 峰值TPS：十万级 │ │
│ │ └── 持续时间：数小时 │ │
│ │ │ │
│ │ 挑战4：低延迟 │ │
│ │ ├── 接口响应：<100ms │ │
│ │ ├── 页面加载：<3秒 │ │
│ │ └── 搜索响应：<200ms │ │
│ │ │ │
│ │ 挑战5：高可用 │ │
│ │ ├── 可用性要求：99.99%+ │ │
│ │ ├── 年停机时间：<53分钟 │ │
│ │ └── 容灾切换：秒级 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
二、整体技术架构
2.1 分层架构概览
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
┌─────────────────────────────────────────────────────────────────┐
│ 淘宝整体技术架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 用户请求 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 接入层 (Edge) │ │ │
│ │ │ CDN + DNS + LVS + Nginx + Haproxy │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 网关层 (Gateway) │ │ │
│ │ │ Tengine + Zuul/Gateway │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 应用层 (Application) │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │ 用户 │ │ 商品 │ │ 订单 │ │ │ │
│ │ │ │ 服务 │ │ 服务 │ │ 服务 │ │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │ 支付 │ │ 搜索 │ │ 推荐服务 │ │ │ │
│ │ │ │ 服务 │ │ 服务 │ │ │ │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 服务治理层 (Governance) │ │ │
│ │ │ Dubbo/SOA + Zookeeper/Nacos + Sentinel │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 数据访问层 (Data Access) │ │ │
│ │ │ │ │ │
│ │ │ ┌────────┐ ┌────────┐ ┌────────┐ │ │ │
│ │ │ │ 缓存层 │ │ 数据库 │ │ 搜索层 │ │ │ │
│ │ │ │Tair │ │ MySQL │ │ ES │ │ │ │
│ │ │ │Redis │ │OceanBase│ │Search │ │ │ │
│ │ │ └────────┘ └────────┘ └────────┘ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
2.2 每秒请求处理流程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
┌─────────────────────────────────────────────────────────────────┐
│ 用户请求处理流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 用户点击下单 → 毫秒级响应 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ T=0ms: 用户点击"提交订单" │ │
│ │ │ │ │
│ │ T=1ms: ──── DNS解析 ───→ 就近接入 │ │
│ │ │ │ │
│ │ T=2ms: ──── CDN检测 ───→ 命中缓存? │ │
│ │ │ │ │
│ │ T=3ms: ──── LVS负载 ───→ Nginx │ │
│ │ │ │ │
│ │ T=5ms: ──── 网关路由 ───→ 订单服务 │ │
│ │ │ │ │
│ │ T=10ms: ──── 登录验证 ───→ Session检查 │ │
│ │ │ │ │
│ │ T=15ms: ──── 库存锁定 ───→ Redis Lua脚本 │ │
│ │ │ │ │
│ │ T=20ms: ──── 订单创建 ───→ 分库分表写入 │ │
│ │ │ │ │
│ │ T=25ms: ──── 支付调用 ───→ 支付宝 │ │
│ │ │ │ │
│ │ T=30ms: ──── 返回成功 ───→ 前端展示 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 关键技术点： │
│ ├── 就近接入：全国部署CDN和边缘节点 │
│ ├── 多级缓存：CDN→本地Cache→Redis→MySQL │
│ ├── 异步处理：消息队列削峰填谷 │
│ ├── 流量控制：Sentinel限流熔断 │
│ └── 数据分层：读写分离 + 分库分表 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
三、多级缓存体系
3.1 缓存架构全景
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
|
┌─────────────────────────────────────────────────────────────────┐
│ 多级缓存架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 用户浏览器 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 第一级：浏览器缓存 (Browser Cache) │ │ │
│ │ │ │ │ │
│ │ │ • 强缓存: Cache-Control/Expires │ │ │
│ │ │ • 协商缓存: ETag/Last-Modified │ │ │
│ │ │ • LocalStorage/SessionStorage │ │ │
│ │ │ • 命中时间: <1ms │ │ │
│ │ │ • 命中率: 30-50% │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 第二级：CDN缓存 (Content Delivery) │ │ │
│ │ │ │ │ │
│ │ │ • 静态资源: 图片/CSS/JS │ │ │
│ │ │ • 热点数据: 爆款商品页面 │ │ │
│ │ │ • 边缘节点: 全国1000+ │ │ │
│ │ │ • 命中时间: <10ms │ │ │
│ │ │ • 命中率: 80-95% │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 第三级：Nginx本地缓存 (Proxy Cache) │ │ │
│ │ │ │ │ │
│ │ │ • Lua脚本实现 │ │ │
│ │ │ • Lua-shared-dict: 共享内存 │ │ │
│ │ │ • L1缓存: 热点数据 │ │ │
│ │ │ • 命中时间: <1ms │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 第四级：应用本地缓存 (Local Cache) │ │ │
│ │ │ │ │ │
│ │ │ • JVM堆内缓存: Guava/Caffeine │ │ │
│ │ │ • 命中时间: <0.1ms │ │ │
│ │ │ • Ehcache堆外缓存 │ │ │
│ │ │ • 命中时间: <0.5ms │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 第五级：分布式缓存 (Tair/Redis) │ │ │
│ │ │ │ │ │
│ │ │ • 集群模式: Proxy + Cluster │ │ │
│ │ │ • 主从复制: 高可用 │ │ │
│ │ │ • 数据分片: 哈希槽 │ │ │
│ │ │ • 命中时间: <5ms │ │ │
│ │ │ • 命中率: 90-99% │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 第六级：数据库 (MySQL/OceanBase) │ │ │
│ │ │ │ │ │
│ │ │ • 分库分表 │ │ │
│ │ │ • 读写分离 │ │ │
│ │ │ • 访问时间: 5-50ms │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 缓存命中率优化策略： │
│ ├── 预热：秒杀前提前加载热点数据 │
│ ├── 分级：冷热数据分离 │
│ ├── 失效：渐进式过期，避免雪崩 │
│ └── 隔离：核心和非核心缓存隔离 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
3.2 Tair分布式缓存
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
┌─────────────────────────────────────────────────────────────────┐
│ Tair分布式缓存架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 阿里自研缓存，支持多种引擎： │
│ ├── LDB (LevelDB引擎): 高性能 │
│ ├── MDB (Memcached引擎): 大容量 │
│ └── RDB (Redis引擎): 丰富数据结构 │
│ │
│ 集群架构： │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌─────────────────────────────────────────┐ │ │
│ │ │ Client SDK │ │ │
│ │ └──────────────────┬──────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────┐ │ │
│ │ │ Config Server │ │ │
│ │ │ (配置中心/路由规则/集群管理) │ │ │
│ │ └──────────────────┬──────────────────────┘ │ │
│ │ │ │ │
│ │ ┌───────────────┼───────────────┐ │ │
│ │ │ │ │ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │DataNode│ │DataNode│ │DataNode│ │ │
│ │ │Group 1 │ │Group 2 │ │Group 3 │ │ │
│ │ │(主+备) │ │(主+备) │ │(主+备) │ │ │
│ │ └────────┘ └────────┘ └────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 数据分片策略： │
│ ├── 一致性哈希: 节点增减时数据迁移少 │
│ ├── 虚拟节点: 解决数据倾斜问题 │
│ └── 副本同步: 主从自动切换 │
│ │
│ 容量：单集群支持PB级数据 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
3.3 缓存使用模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
// 缓存使用模式
public Product getProduct(Long productId) {
// 1. 先查本地缓存
Product product = localCache.get(productId);
if (product != null) {
return product;
}
// 2. 再查分布式缓存
product = redis.get("product:" + productId);
if (product != null) {
// 回填本地缓存
localCache.put(productId, product);
return product;
}
// 3. 最后查数据库
product = productMapper.selectById(productId);
if (product != null) {
// 回填缓存
redis.setex("product:" + productId, 3600, product);
localCache.put(productId, product);
}
return product;
}
// 缓存更新策略
public void updateProduct(Product product) {
// 1. 更新数据库
productMapper.updateById(product);
// 2. 删除缓存（而不是更新）
redis.del("product:" + product.getId());
localCache.invalidate(product.getId());
// 3. 延迟双删保证一致性
try {
Thread.sleep(100);
redis.del("product:" + product.getId());
} catch (Exception e) {
// log
}
}
|
四、负载均衡与接入层
4.1 全局负载均衡GSLB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
┌─────────────────────────────────────────────────────────────────┐
│ 全局负载均衡GSLB │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 用户请求DNS: www.taobao.com │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ DNS智能解析 │ │ │
│ │ │ │ │ │
│ │ │ • 就近接入: 返回最近机房的IP │ │ │
│ │ │ • 健康检查: 剔除故障节点 │ │ │
│ │ │ • 负载均衡: 按权重分配 │ │ │
│ │ │ • 动态调度: 根据网络状况调整 │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────┬──────────┬──────────┬──────────┐ │ │
│ │ │ │ │ │ │ │ │
│ │ ▼ ▼ ▼ ▼ ▼ │ │
│ │ ┌────────┐┌────────┐┌────────┐┌────────┐┌────────┐ │ │
│ │ │ 杭州 ││ 上海 ││ 北京 ││ 广州 ││ 海外 │ │ │
│ │ │ 机房 ││ 机房 ││ 机房 ││ 机房 ││ 节点 │ │ │
│ │ │ ~20ms ││ ~10ms ││ ~30ms ││ ~20ms ││ ~100ms│ │ │
│ │ └────────┘└────────┘└────────┘└────────┘└────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 技术实现： │
│ ├── DNS轮询: 基础负载均衡 │
│ ├── GSLB设备: F5/BigIP 或 自研GSLB │
│ ├── DNS策略: 基于地域/运营商/负载的智能解析 │
│ └── Anycast: BGP任播加速 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
4.2 四层/七层负载均衡
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
┌─────────────────────────────────────────────────────────────────┐
│ 四层与七层负载均衡 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 四层负载均衡 (LVS) │ │
│ │ (传输层/TCP协议) │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 原理： │ │
│ │ ├── 基于源/目标IP + 端口 │ │
│ │ ├── 修改报文目标MAC地址 │ │
│ │ └── 转发模式: NAT/DR/Tunnel │ │
│ │ │ │
│ │ 优势： │ │
│ │ ├── 性能高: 处理速度快 │ │
│ │ ├── 吞吐大: 支持千万级并发 │ │
│ │ └── 稳定: 抗DDOS能力强 │ │
│ │ │ │
│ │ 调度算法： │ │
│ │ ├── 轮询 (RR) │ │
│ │ ├── 加权轮询 (WRR) │ │
│ │ ├── 最少连接 (LC) │ │
│ │ ├── 源地址哈希 (SH) │ │
│ │ └── 一致性哈希 (CH) │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 七层负载均衡 (Tengine/Nginx) │ │
│ │ (应用层/HTTP协议) │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 原理： │ │
│ │ ├── 基于URL/Host/Header/Cookie │ │
│ │ ├── 解析HTTP协议内容 │ │
│ │ └── 反向代理 │ │
│ │ │ │
│ │ 优势： │ │
│ │ ├── 功能丰富: 缓存/压缩/重写 │ │
│ │ ├── 智能路由: 基于内容的路由 │ │
│ │ └── SSL终结: 减轻后端压力 │ │
│ │ │ │
│ │ 功能： │ │
│ │ ├── URL重写 │ │
│ │ ├── 请求限流 │ │
│ │ ├── 黑白名单 │ │
│ │ ├── WAF防火墙 │ │
│ │ └── HTTP/2支持 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 组合策略： │
│ LVS (四层) → Tengine (七层) → Nginx (应用网关) → 服务 │
│ 高速转发 智能路由 请求处理 业务逻辑 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
4.3 接入层高可用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
┌─────────────────────────────────────────────────────────────────┐
│ 接入层高可用架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 用户 ──→ CDN ──→ DNS ──→ GSLB │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ LVS集群 (主备) │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────────┐ ┌─────────────┐ │ │ │
│ │ │ │ Master │───▶│ Backup │ │ │ │
│ │ │ │ (主) │心跳 │ (备) │ │ │ │
│ │ │ └─────────────┘ └─────────────┘ │ │ │
│ │ │ │ │ │ │
│ │ │ │ Keepalived检测 │ │ │
│ │ │ ▼ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ Tengine集群 (多实例) │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │Tengine-1│ │Tengine-2│ │Tengine-3│ ... │ │ │
│ │ │ └────┬────┘ └────┬────┘ └────┬────┘ │ │ │
│ │ │ │ │ │ │ │ │
│ │ └────────┼────────────┼────────────┼──────────────┘ │ │
│ │ │ │ │ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 应用服务器集群 │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │ Server-1│ │Server-2│ │Server-3│ ... │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 高可用机制： │
│ ├── LVS: Keepalived + VRRP协议 │
│ ├── Tengine: 健康检查 + 自动剔除 │
│ ├── 应用: 注册中心 + 心跳检测 │
│ └── 故障切换: <30秒 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
五、微服务架构
5.1 服务拆分
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
┌─────────────────────────────────────────────────────────────────┐
│ 淘宝微服务拆分 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 早期单体架构 → 拆分原则 → 微服务架构 │
│ │
│ 拆分原则： │
│ ├── 单一职责: 每个服务只做一件事 │
│ ├── 业务边界: 按业务领域拆分 │
│ ├── 独立部署: 服务可独立发布 │
│ ├── 技术异构: 不同服务可用不同技术 │
│ └── 团队自治: 每个团队负责自己的服务 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 核心服务: │ │
│ │ ├── 用户服务 (注册/登录/权限) │ │
│ │ ├── 商品服务 (商品信息/库存) │ │
│ │ ├── 订单服务 (下单/支付/取消) │ │
│ │ ├── 支付服务 (支付宝/微信/银行卡) │ │
│ │ ├── 物流服务 (发货/追踪/签收) │ │
│ │ ├── 搜索服务 (商品搜索/推荐) │ │
│ │ ├── 评价服务 (评论/晒图/问答) │ │
│ │ └── 营销服务 (优惠券/活动/秒杀) │ │
│ │ │ │
│ │ 基础服务: │ │
│ │ ├── 消息服务 │ │
│ │ ├── 通知服务 │ │
│ │ ├── 文件服务 │ │
│ │ ├── 搜索服务 │ │
│ │ └── 日志服务 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
5.2 服务治理
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
┌─────────────────────────────────────────────────────────────────┐
│ 服务治理框架 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ Dubbo分布式服务框架 │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 核心能力 │ │ │
│ │ ├─────────────────────────────────────────────────┤ │ │
│ │ │ │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │ RPC │ │ 负载均衡 │ │ 容错 │ │ │ │
│ │ │ │ 通信 │ │ Failover│ │ 降级 │ │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │ 注册发现 │ │ 路由 │ │ 限流 │ │ │ │
│ │ │ │ ZK/Nacos│ │ 条件路由│ │ Sentinel│ │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Sentinel流量控制 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 功能： │ │
│ │ ├── 流控规则: QPS/并发线程数限流 │ │
│ │ ├── 降级规则: RT/异常比例/异常数降级 │ │
│ │ ├── 热点规则: 参数限流 │ │
│ │ ├── 系统规则: Load/CPU/入口QPS限流 │ │
│ │ └── 授权规则: 白名单/黑名单 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Nacos配置中心与注册中心 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 功能： │ │
│ │ ├── 服务注册/发现 │ │
│ │ ├── 动态配置管理 │ │
│ │ ├── 命名空间隔离 │ │
│ │ └── 配置变更推送 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
5.3 服务间通信
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
┌─────────────────────────────────────────────────────────────────┐
│ 服务间通信方式 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 同步通信 (Dubbo RPC) │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 适用场景： │ │
│ │ ├── 强依赖调用 │ │
│ │ └── 需要实时返回结果 │ │
│ │ │ │
│ │ 协议选择： │ │
│ │ ├── Dubbo协议: 高性能，默认使用 │ │
│ │ ├── HTTP协议: 跨语言 │ │
│ │ └── gRPC: 高性能，Protobuf序列化 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 异步通信 (消息队列) │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 适用场景： │ │
│ │ ├── 弱依赖调用 │ │
│ │ ├── 异步处理 │ │
│ │ ├── 流量削峰 │ │
│ │ └── 系统解耦 │ │
│ │ │ │
│ │ 消息队列： │ │
│ │ ├── RocketMQ: 阿里巴巴自研，支持事务消息 │ │
│ │ ├── Kafka: 高吞吐，日志收集 │ │
│ │ └── RabbitMQ: 灵活路由 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 下单流程示例 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 同步调用链： │ │
│ │ 订单服务 ──→ 用户服务(验证) ──→ 商品服务(查库存) │ │
│ │ │ │
│ │ 异步通知链： │ │
│ │ 订单服务 ──→ MQ ──→ 库存服务(扣库存) │ │
│ │ │ │ │ │
│ │ │ ├──→ 物流服务(创建物流) │ │
│ │ │ ├──→ 积分服务(增加积分) │ │
│ │ │ └──→ 通知服务(发送通知) │ │
│ │ │ │ │
│ │ └──→ 支付服务(待支付) │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
六、数据库架构
6.1 淘宝数据库演进
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
┌─────────────────────────────────────────────────────────────────┐
│ 淘宝数据库技术演进 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 2003年: Oracle单机 │ │
│ │ ├── 当时数据量小，Oracle足够 │ │
│ │ └── 单机性能瓶颈 │ │
│ │ │ │
│ │ 2004-2006年: MySQL读写分离 │ │
│ │ ├── 垂直拆分: 按业务拆分 │ │
│ │ ├── 读写分离: 主从同步 │ │
│ │ └── 数据量增长遇到瓶颈 │ │
│ │ │ │
│ │ 2006-2008年: 分库分表 │ │
│ │ ├── 水平拆分: 按用户ID分片 │ │
│ │ ├── 自研TDDL中间件 │ │
│ │ └── 解决数据量问题 │ │
│ │ │ │
│ │ 2009-2015年: 多元化数据存储 │ │
│ │ ├── MySQL + TDDL │ │
│ │ ├── OceanBase: 分布式数据库 │ │
│ │ ├── Redis: 缓存 │ │
│ │ └── HBase: 海量日志 │ │
│ │ │ │
│ │ 2016年至今: 云原生与智能化 │ │
│ │ ├── PolarDB: 云原生数据库 │ │
│ │ ├── DRDS: 分布式数据库服务 │ │
│ │ ├──ADB: 分析型数据库 │ │
│ │ └── 数据库自动驾驶 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
6.2 分库分表架构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
|
┌─────────────────────────────────────────────────────────────────┐
│ 分库分表架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 为什么需要分库分表？ │
│ ├── 单机MySQL: 约2000-5000 QPS │
│ ├── 单表数据: >5000万行性能下降 │
│ ├── 单库数据: >1TB性能下降 │
│ └── 淘宝订单: >1000亿条 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 分片策略 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 按用户ID分片 (常见): │ │
│ │ shard_key = user_id % 32 │ │
│ │ │ │
│ │ shard_key = hash(user_id) % 32 │ │
│ │ │ │
│ │ 按时间分片: │ │
│ │ shard_key = year * 100 + month │ │
│ │ │ │
│ │ 按地区分片: │ │
│ │ shard_key = region_id │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 分库分表架构图 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 应用层 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────┐ │ │
│ │ │ TDDL │ (数据库中间件) │ │
│ │ │Proxy │ │ │
│ │ └────┬────┘ │ │
│ │ │ │ │
│ │ ├──────────────────┬──────────────────┐ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ DB 0-7 │ │ DB 8-15 │ │DB 16-23 │ │ │
│ │ │ 分片0 │ │ 分片1 │ │ 分片2 │ │ │
│ │ └────┬────┘ └────┬────┘ └────┬────┘ │ │
│ │ │ │ │ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌────┬────┐ ┌────┬────┐ ┌────┬────┐ │ │
│ │ │Master│Slave│ │Master│Slave│ │Master│Slave│ │ │
│ │ └────┴────┘ └────┴────┘ └────┴────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 分片数量选择： │
│ ├── 初期: 8或16个分片 │
│ ├── 中期: 32或64个分片 │
│ └── 扩展: 支持在线扩容 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
6.3 读写分离
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
┌─────────────────────────────────────────────────────────────────┐
│ 读写分离架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 原理： │
│ ├── 主库: 负责写操作 (INSERT/UPDATE/DELETE) │
│ └── 从库: 负责读操作 (SELECT) │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ┌───────────────┐ │ │
│ │ │ 应用层 │ │ │
│ │ └───────┬───────┘ │ │
│ │ │ │ │
│ │ ┌───────────┴───────────┐ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ 写操作 │ │ 读操作 │ │ │
│ │ │ (主库) │ │ (从库) │ │ │
│ │ └──────┬─────┘ └──────┬─────┘ │ │
│ │ │ │ │ │
│ │ └──────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────┐ │ │
│ │ │ Master │ │ │
│ │ │ (主库) │ │ │
│ │ └──────┬──────┘ │ │
│ │ │ │ │ │
│ │ ┌─────────┘ └─────────┐ │ │
│ │ ▼ ▼ │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Slave 1 │ │ Slave 2 │ │ │
│ │ │ (从库1) │ │ (从库2) │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ 同步方式: 主从复制 (Async/Semi-sync) │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 数据同步方式： │
│ ├── 异步复制: 延迟大，性能好 │
│ ├── 半同步复制: 至少一个从库确认 │
│ └── GTID复制: 全局事务ID，追踪方便 │
│ │
│ 读写分离中间件： │
│ ├── ShardingSphere │
│ ├── MyCat │
│ ├── Vitess │
│ └── DRDS (阿里云) │
│ │
└─────────────────────────────────────────────────────────────────┘
|
6.4 OceanBase分布式数据库
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
┌─────────────────────────────────────────────────────────────────┐
│ OceanBase分布式数据库 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ OceanBase概述： │
│ ├── 阿里自研分布式关系数据库 │
│ ├── 兼容MySQL/Oracle协议 │
│ ├── 支持TB到PB级数据 │
│ └── 支撑支付宝全部核心业务 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 架构图 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────────────────────────────────┐ │ │
│ │ │ 应用层 (OBProxy) │ │ │
│ │ │ (SQL路由/负载均衡) │ │ │
│ │ └──────────────────┬──────────────────────┘ │ │
│ │ │ │ │
│ │ ┌─────────────────┼─────────────────┐ │ │
│ │ │ │ │ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │ Zone 1 │ │ Zone 2 │ │ Zone 3 │ │ │
│ │ │ (杭州) │ │ (上海) │ │ (北京) │ │ │
│ │ ├────────────┤ ├────────────┤ ├────────────┤ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ ┌──────┐ │ │ ┌──────┐ │ │ ┌──────┐ │ │ │
│ │ │ │Observer│ │ │ │Observer│ │ │ │Observer│ │ │ │
│ │ │ │ 主 │ │ │ │ 主 │ │ │ │ 主 │ │ │ │
│ │ │ └──────┘ │ │ └──────┘ │ │ └──────┘ │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ ┌──────┐ │ │ ┌──────┐ │ │ ┌──────┐ │ │ │
│ │ │ │Observer│ │ │ │Observer│ │ │ │Observer│ │ │ │
│ │ │ │ 从 │ │ │ │ 从 │ │ │ │ 从 │ │ │ │
│ │ │ └──────┘ │ │ └──────┘ │ │ └──────┘ │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ └───────────┼───┴───────────┼───┴───────────┼───┘ │ │
│ │ │ │ │ │ │
│ │ └───────────────┴───────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌───────────┐ │ │
│ │ │ RootService│ │ │
│ │ │ (总控服务) │ │ │
│ │ └───────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 核心特性： │
│ ├── 水平扩展: 在线增加节点 │
│ ├── 高可用: 3副本选举协议 │
│ ├── 强一致: Paxos共识协议 │
│ ├── HTAP: OLTP + OLAP一体化 │
│ └── 压缩: 高压缩率，节省存储成本 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
七、异地多活架构
7.1 异地多活设计
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
┌─────────────────────────────────────────────────────────────────┐
│ 异地多活架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 什么是异地多活？ │ │
│ │ │ │
│ │ ├── 多地: 多个地理位置的机房 │ │
│ │ ├── 多活: 每个机房都能承接业务 │ │
│ │ └── 特点: 故障时自动切换，用户无感知 │ │
│ │ │ │
│ │ 好处： │ │
│ │ ├── 容灾: 任意机房故障，其他机房接管 │ │
│ │ ├── 延迟: 就近接入，降低访问延迟 │ │
│ │ └── 扩展: 按需扩展任意机房容量 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 淘宝异地多活架构 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌──────────────┐ │ │
│ │ │ 用户请求 │ │ │
│ │ └──────┬───────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────────────────────────────────────┐ │ │
│ │ │ GSLB 智能DNS │ │ │
│ │ │ (按地域/负载/故障选择最优机房) │ │ │
│ │ └──────────────────┬───────────────────┘ │ │
│ │ │ │ │
│ │ ┌──────────────┼──────────────┐ │ │
│ │ │ │ │ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │ 杭州 │ │ 上海 │ │ 北京 │ │ │
│ │ │ 单元 │ │ 单元 │ │ 单元 │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ ┌────┐ │ │ ┌────┐ │ │ ┌────┐ │ │ │
│ │ │ │ 应 │ │ │ │ 应 │ │ │ │ 应 │ │ │ │
│ │ │ │ 用 │ │ │ │ 用 │ │ │ │ 用 │ │ │ │
│ │ │ │ 服 │ │◀───▶│ │ 服 │ │◀───▶│ │ 服 │ │ │ │
│ │ │ │ 务 │ │同步 │ │ 务 │ │同步 │ │ 务 │ │ │ │
│ │ │ └────┘ │ │ └────┘ │ │ └────┘ │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ ┌────┐ │ │ ┌────┐ │ │ ┌────┐ │ │ │
│ │ │ │ DB │ │◀───▶│ │ DB │ │◀───▶│ │ DB │ │ │ │
│ │ │ └────┘ │同步 │ └────┘ │同步 │ └────┘ │ │ │
│ │ └────────┘ └────────┘ └────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
7.2 单元化架构
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
┌─────────────────────────────────────────────────────────────────┐
│ 单元化架构设计 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 单元化核心概念 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 单元 (Cell): │ │
│ │ ├── 独立的业务处理单元 │ │
│ │ ├── 包含应用+缓存+数据库 │ │
│ │ └── 具备完整的业务能力 │ │
│ │ │ │
│ │ 单元化原则: │ │
│ │ ├── 单元内封闭: 同单元内调用，不跨单元 │ │
│ │ ├── 单元间隔离: 故障不扩散 │ │
│ │ ├── 规则路由: 用户请求按规则路由到单元 │ │
│ │ └── 数据同步: 单元间数据最终一致 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 单元化路由 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 路由规则: │ │
│ │ 用户ID % 单元数 = 单元编号 │ │
│ │ │ │
│ │ 示例 (4单元): │ │
│ │ ├── 用户1234 → 1234 % 4 = 2 → 单元2 │ │
│ │ ├── 用户5678 → 5678 % 4 = 2 → 单元2 │ │
│ │ ├── 用户9012 → 9012 % 4 = 0 → 单元0 │ │
│ │ └── 用户3456 → 3456 % 4 = 0 → 单元0 │ │
│ │ │ │
│ │ 好处: │ │
│ │ ├── 用户请求固定路由到某单元 │ │
│ │ ├── 单元内事务本地化 │ │
│ │ └── 跨单元调用最小化 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 跨单元数据同步 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 需要同步的数据: │ │
│ │ ├── 用户信息 │ │
│ │ ├── 商品信息 (热点) │ │
│ │ └── 订单信息 (可能查询) │ │
│ │ │ │
│ │ 不需要同步的数据: │ │
│ │ ├── 临时会话 │ │
│ │ ├── 本地日志 │ │
│ │ └── 非共享缓存 │ │
│ │ │ │
│ │ 同步方式: │ │
│ │ ├── 同步复制: 强一致，延迟高 │ │
│ │ ├── 异步复制: 最终一致，延迟低 │ │
│ │ └── DTS同步: 阿里数据传输服务 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
7.3 故障切换
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
┌─────────────────────────────────────────────────────────────────┐
│ 故障切换流程 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 故障检测 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 检测手段: │ │
│ │ ├── 健康检查: HTTP/TCP端口检测 │ │
│ │ ├── 心跳检测: 每秒一次 │ │
│ │ ├── 告警触发: 连续N次失败 │ │
│ │ └── 人工确认: 运维介入判断 │ │
│ │ │ │
│ │ 检测层级: │ │
│ │ ├── 进程级: 进程挂掉 │ │
│ │ ├── 机器级: 机器宕机 │ │
│ │ ├── 机柜级: 交换机故障 │ │
│ │ └── 机房级: 整个机房故障 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 切换流程 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 1. 故障检测 (秒级) │ │
│ │ │ 连续3次健康检查失败 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ 2. 流量切换 (分钟级) │ │
│ │ │ ├── DNS切换: GSLB更新路由 │ │
│ │ │ ├── 路由规则: 路由到其他单元 │ │
│ │ │ └── 负载均衡: 剔除故障节点 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ 3. 数据补偿 (分钟级) │ │
│ │ │ ├── 同步积压: 未同步数据追赶 │ │
│ │ │ └── 数据校验: 核对数据完整性 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ 4. 服务恢复 (10-30分钟) │ │
│ │ │ ├── 故障修复 │ │
│ │ │ ├── 数据同步 │ │
│ │ │ └── 验证回切 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ 5. 流量回切 (可选) │ │
│ │ 确认原机房恢复后，逐步切回 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ RTO (恢复时间目标): < 5分钟 │
│ RPO (恢复点目标): < 1分钟 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
八、数据库连接与应用连接
8.1 应用连接数据库
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
┌─────────────────────────────────────────────────────────────────┐
│ 应用连接数据库方式 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 连接方式对比 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 直连模式: │ │
│ │ 应用 ──────────────────▶ MySQL │ │
│ │ │ │ │
│ │ ├── 每个应用实例直连数据库 │ │
│ │ ├── 连接数 = 应用实例 × 每实例连接数 │ │
│ │ └── 问题: 连接数爆炸，难以管理 │ │
│ │ │ │
│ │ 代理模式 (推荐): │ │
│ │ 应用 ──▶ Proxy ──▶ MySQL │ │
│ │ │ │ │
│ │ ├── 统一连接管理 │ │
│ │ ├── 连接复用 │ │
│ │ ├── SQL解析 │ │
│ │ └── 读写分离 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 连接池配置 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ HikariCP 连接池参数: │ │ │
│ │ │ │ │ │
│ │ │ minimum-idle: 5 │ │ │
│ │ │ maximum-pool-size: 50 │ │ │
│ │ │ connection-timeout: 30000 │ │ │
│ │ │ idle-timeout: 600000 │ │ │
│ │ │ max-lifetime: 1800000 │ │ │
│ │ │ │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 连接数计算公式: │ │
│ │ 总连接数 = 应用实例数 × 每个实例连接数 │ │
│ │ │ │
│ │ 示例: │ │
│ │ ├── 100个应用实例 │ │
│ │ ├── 每个实例50个连接 │ │
│ │ └── 总共需要5000个连接 │ │
│ │ │ │
│ │ MySQL最大连接数: max_connections = 10000 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
8.2 DRDS分布式数据库服务
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
┌─────────────────────────────────────────────────────────────────┐
│ DRDS分布式数据库服务 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ DRDS = Distributed Relational Database Service │
│ 阿里云提供的分布式MySQL中间件 │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ DRDS架构 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ 应用层 │ │ │
│ │ └──────────────────┬──────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ DRDS SQL Engine │ │ │
│ │ │ │ │ │
│ │ │ ├── SQL解析与改写 │ │ │
│ │ │ ├── 分片规则计算 │ │ │
│ │ │ ├── 分布式执行计划 │ │ │
│ │ │ └── 结果归并 │ │ │
│ │ └──────────────────┬──────────────────────────┘ │ │
│ │ │ │ │
│ │ ┌───────────┴───────────┐ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ RDS MySQL │ │ RDS MySQL │ │ │
│ │ │ 分片0 │ │ 分片1 │ │ │
│ │ │ (主从) │ │ (主从) │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 核心能力: │
│ ├── 水平扩展: 增加分片即可 │
│ ├── 读写分离: 自动分发读请求 │
│ ├── 全局自增ID: Sequence │
│ ├── 全局唯一索引: 全局索引表 │
│ └── 分布式事务: XA协议 │
│ │
│ 支持分片算法: │
│ ├── 哈希分片 │
│ ├── 范围分片 │
│ ├── 列表分片 │
│ └── 自定义分片 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
8.3 服务注册与发现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
|
┌─────────────────────────────────────────────────────────────────┐
│ 服务注册与发现 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Nacos服务注册发现流程 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 服务启动注册: │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ OrderService 启动 │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ ┌─────────────────────────────────────────┐ │ │ │
│ │ │ │ Nacos Server │ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ ┌─────────────────────────────────┐ │ │ │ │
│ │ │ │ │ Service: order-service │ │ │ │ │
│ │ │ │ │ ├── Instance: 10.0.0.1:8080 │ │ │ │ │
│ │ │ │ │ ├── Instance: 10.0.0.2:8080 │ │ │ │ │
│ │ │ │ │ └── Instance: 10.0.0.3:8080 │ │ │ │ │
│ │ │ │ └─────────────────────────────────┘ │ │ │ │
│ │ │ └─────────────────────────────────────────┘ │ │ │ │
│ │ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 客户端发现: │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ UserService 需要调用 OrderService │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ 查询 Nacos: order-service 的实例列表 │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ 返回: [10.0.0.1:8080, 10.0.0.2:8080, ...] │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ 负载均衡选择一个实例调用 │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 心跳机制: │
│ ├── 客户端每5秒发送心跳 │
│ ├── 15秒无心跳标记不健康 │
│ ├── 30秒无心跳自动下线 │
│ └── 服务列表变更推送到客户端 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
九、高并发处理
9.1 限流策略
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
┌─────────────────────────────────────────────────────────────────┐
│ 限流策略 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 限流层级 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 网关限流 (Nginx) │ │ │
│ │ │ ├── 按IP限流 │ │ │
│ │ │ ├── 按接口限流 │ │ │
│ │ │ └── 限流阈值: QPS 10万+ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 网关限流 (Spring Cloud Gateway) │ │ │
│ │ │ ├── 请求数限流 │ │ │
│ │ │ ├── 响应时间限流 │ │ │
│ │ │ └── 限流阈值: QPS 5万+ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 应用限流 (Sentinel) │ │ │
│ │ │ ├── QPS限流 │ │ │
│ │ │ ├── 并发线程数限流 │ │ │
│ │ │ ├── 热点参数限流 │ │ │
│ │ │ └── 限流阈值: QPS 1万+ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ 数据库限流 (连接池) │ │ │
│ │ │ ├── 最大连接数 │ │ │
│ │ │ └── 等待超时 │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 限流算法: │
│ ├── 计数器: 简单，超过阈值拒绝 │
│ ├── 滑动窗口: 更精确的计数器 │
│ ├── 漏桶算法: 恒定速率，流量平滑 │
│ └── 令牌桶: 允许突发，高性能 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
9.2 削峰填谷
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
┌─────────────────────────────────────────────────────────────────┐
│ 消息队列削峰 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 同步下单 vs 异步下单 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 同步下单 (问题): │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ 用户 ──▶ 订单服务 ──▶ 库存服务 ──▶ 积分服务 │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ ▼ │ │ │
│ │ │ │ 消息通知 │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ ▼ │ │ │
│ │ │ │ 物流服务 │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ ▼ │ │ │
│ │ │ │ 返回结果 │ │ │
│ │ │ │ │ │ │
│ │ │ 问题: 所有服务必须同步完成，用户等待时间长 │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 异步下单 (解决): │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ 用户 ──▶ 订单服务 ──▶ 返回"下单成功" │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ ┌──────────────────────────────────────┐ │ │ │
│ │ │ │ RocketMQ │ │ │ │
│ │ │ │ │ │ │ │
│ │ │ │ ┌─────────┐ ┌─────────┐ ┌────────┐ │ │ │ │
│ │ │ │ │库存消息│ │积分消息│ │物流消息│ │ │ │ │
│ │ │ │ └────┬────┘ └────┬────┘ └───┬───┘ │ │ │ │
│ │ │ │ │ │ │ │ │ │ │
│ │ │ └───────┼──────────┼──────────┼─────┘ │ │ │
│ │ │ ▼ ▼ ▼ │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌────────┐ │ │ │
│ │ │ │库存服务│ │积分服务│ │物流服务│ │ │ │
│ │ │ └─────────┘ └─────────┘ └────────┘ │ │ │
│ │ │ │ │ │
│ │ │ 优点: 用户立即返回，服务异步处理 │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ 削峰效果: │
│ ├── 峰值QPS: 54万 → 消费QPS: 5万 │
│ ├── 数据库压力: 降低90% │
│ └── 用户体验: 无感知延迟 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
9.3 库存扣减
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
┌─────────────────────────────────────────────────────────────────┐
│ 库存扣减方案 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 分布式锁方案 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ Redis分布式锁: │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ // 1. 加锁 │ │ │
│ │ │ SETNX lock:product:10001 "uuid" EX 10 │ │ │
│ │ │ │ │ │
│ │ │ // 2. 扣减库存 │ │ │
│ │ │ DECR stock:10001 │ │ │
│ │ │ │ │ │
│ │ │ // 3. 释放锁 │ │ │
│ │ │ DEL lock:product:10001 │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 问题: 单机QPS有限，高并发瓶颈 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Lua原子操作方案 (推荐) │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ Redis Lua脚本: │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ -- Lua脚本保证原子性 │ │ │
│ │ │ local stock = redis.call('GET', KEYS[1]) │ │ │
│ │ │ if tonumber(stock) >= tonumber(ARGV[1]) then │ │ │
│ │ │ redis.call('DECRBY', KEYS[1], ARGV[1]) │ │ │
│ │ │ return 1 -- 成功 │ │ │
│ │ │ else │ │ │
│ │ │ return 0 -- 库存不足 │ │ │
│ │ │ end │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 优势: │ │
│ │ ├── 单机QPS: 10万+ │
│ │ ├── 原子操作，无并发问题 │ │
│ │ └── 集群模式支持高可用 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 数据库乐观锁方案 │ │
│ ├─────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ UPDATE inventory │ │
│ │ SET stock = stock - #{amount} │ │
│ │ WHERE product_id = #{productId} │ │
│ │ AND stock >= #{amount} │ │
│ │ │ │
│ │ -- 检查影响行数 │ │
│ │ IF affected_rows = 0 THEN │ │
│ │ -- 库存不足 │ │
│ │ END IF │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
十、总结
10.1 核心技术总结
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
┌─────────────────────────────────────────────────────────────────┐
│ 支撑十几亿用户的技术秘密 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 1. 多级缓存 │ │
│ │ ├── CDN → 本地Cache → Redis → 数据库 │ │
│ │ └── 命中率: 99%+ │ │
│ │ │ │
│ │ 2. 水平扩展 │ │
│ │ ├── 分库分表: 解决数据量问题 │ │
│ │ ├── 读写分离: 解决并发问题 │ │
│ │ └── 服务无状态: 支持弹性扩展 │ │
│ │ │ │
│ │ 3. 异步处理 │ │
│ │ ├── 消息队列削峰 │ │
│ │ └── 异步通知解耦 │ │
│ │ │ │
│ │ 4. 容灾架构 │ │
│ │ ├── 异地多活 │ │
│ │ ├── 单元化 │ │
│ │ └── 自动故障切换 │ │
│ │ │ │
│ │ 5. 流量控制 │ │
│ │ ├── 多级限流 │ │
│ │ ├── 熔断降级 │ │
│ │ └── 排队等待 │ │
│ │ │ │
│ │ 6. 极致优化 │ │
│ │ ├── 连接池复用 │ │
│ │ ├── 本地缓存 │ │
│ │ └── 热点数据识别 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
|
10.2 架构演进路线
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
┌─────────────────────────────────────────────────────────────────┐
│ 架构演进路线 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 阶段1: 单机时代 (2003) │
│ 单机 MySQL + Tomcat → 垂直拆分 (按业务) │
│ │
│ 阶段2: 分布式时代 (2006-2010) │
│ 读写分离 + 分库分表 + 本地缓存 │
│ │
│ 阶段3: 服务化时代 (2010-2015) │
│ 微服务 + 消息队列 + 分布式缓存 │
│ │
│ 阶段4: 云原生时代 (2015-至今) │
│ 容器化 + K8s + Service Mesh + 云数据库 │
│ │
└─────────────────────────────────────────────────────────────────┘
|
10.3 关键指标
| 指标 |
数值 |
| 双十一交易峰值 |
54.4万 TPS |
| 接口响应时间 |
< 100ms |
| 系统可用性 |
99.99%+ |
| 数据总量 |
PB级 |
| 服务实例 |
数十万 |
| 单集群Redis |
TB级 |
希望这篇文章能帮助你理解淘宝架构设计背后的核心技术。支撑十几亿用户的秘密不是某一项技术，而是一整套系统化的工程实践。