流量特征:秒杀流量的特点和应对
想象你是淘宝的技术负责人,正在监控双十一秒杀活动:
时间: 2024-11-11 23:59:50
监控大屏:
当前QPS: 5,000
服务器负载: 20%
网络带宽: 10%
状态: ✅ 正常
时间: 2024-11-11 23:59:55
监控大屏:
当前QPS: 50,000 ⚠️
服务器负载: 60%
网络带宽: 40%
状态: ⚠️ 流量激增
时间: 2024-11-11 00:00:00
监控大屏:
当前QPS: 500,000 🔥
服务器负载: 95%
网络带宽: 85%
状态: 🔥 流量洪峰!
时间: 2024-11-11 00:00:03
监控大屏:
当前QPS: 8,000
服务器负载: 30%
网络带宽: 15%
状态: ✅ 秒杀结束
短短几秒钟,流量暴增100倍,又迅速回落!这就是秒杀流量的典型特征。
特征一:时间高度集中 ⏰
输出:
📊 流量时间分布分析
============================================================
时间点 | QPS | 描述
------------------------------------------------------------
-10.0分钟 | 1,000 | 秒杀前10分钟
-2.0分钟 | 1,000 | 秒杀前2分钟
-0.5分钟 | 200,000 | 秒杀前30秒
0.0分钟 | 500,000 | 秒杀开始
0.5分钟 | 100,000 | 秒杀后30秒
2.0分钟 | 2,000 | 秒杀后2分钟
5.0分钟 | 1,000 | 秒杀后5分钟
🎯 关键发现:
• 峰值流量: 500,000 QPS
• 基础流量: 1,000 QPS
• 流量激增倍数: 500倍
• 持续时间: 约3-5秒
集中到什么程度? 把 5 万 QPS 的平均基线摊到全天看,这个 50 万 QPS 的尖峰在一天里只占 3 到 5 秒。
峰值占全天流量的比例 ≈ 500,000 × 5 ÷ (1,000 × 86,400) ≈ 2.9%
这 3 秒决定了整场活动的成败。 剩下的 86,395 秒里,系统只需要扛住日常流量——难度全部集中在这 3 秒。这也是为什么秒杀系统值得为这 3 秒投入平时十倍的架构成本。
特征二:用户行为规律 👥
输出:
📊 用户行为时间线分析
============================================================
阶段 | 用户占比 | 典型行为 | 系统含义
------------------------------------------------------------
预告期 | 100% | 预约、报名、看攻略 | 可提前估算规模
蓄水期 | 95% | 反复刷新页面(5-10次/秒) | 流量被刷新放大 5-10 倍
开抢瞬间 | 80% | 精确到秒点击 | 尖峰的直接来源
抢到后 | 0.02% | 立即支付 | 有效请求极少
失败后 | 60% | 继续刷新、重复提交 | 售罄后的二次洪峰
🎯 关键发现:
• 真正抢到的人: 不足参与用户的 1%
• 页面刷新把流量放大了 5-10 倍
• 售罄之后的无效重试, 仍占总流量的 50% 以上
规律一:用户的动作是可以提前推断的。
秒杀页面上写着明确的开始时间,全网都知道是零点。这种”全网约定同一个时刻”的行为模式极其罕见——它让流量从”随机分布”变成了”脉冲式”,也就让”预约”这种提前估算规模的做法成为可能。
规律二:刷新会放大流量,而且放大的倍数很高。
一个紧张的用户在开抢前会刷新几十次页面。如果每次刷新都完整加载一遍商品图、活动规则、推荐位,那么:
1 个真实用户 × 30 次刷新 = 30 个请求
50 万用户 × 30 次刷新 = 1,500 万请求
这里面绝大部分是静态资源。 这是第 5 章的限流和排队能生效的前提——如果用户只发一次请求,1,500 万和 50 万就是两个完全不同的设计问题。
规律三:失败之后还有第二个洪峰。
00:00:00 第一波:50 万 QPS(抢)
00:00:05 第二波:仍在 10 万 QPS(没抢到的人继续刷、继续提交)
00:01:00 衰减到 5,000 QPS
只做开抢瞬间的容量规划是不够的。 售罄之后流量不会立刻归零,它会以一个更平缓但持续更久的形态继续存在,并且此时的流量 100% 是无效的。
| 用户行为 | 系统含义 | 对应的设计 |
|---|---|---|
| 提前进页面、反复刷新 | 请求量被放大数倍 | 静态资源走 CDN、页面接口限频 |
| 精确到秒的集中点击 | 尖峰高度可预测 | 预约、预热、按时放量 |
| 重复提交(网络慢、连点) | 同一意图多次到达 | 幂等键、限购标记 |
| 售罄后继续尝试 | 无效流量持续存在 | 售罄后走”快速失败”分支 |
| 抢到后不支付 | 库存被长期占用 | 支付超时释放(第 6 章) |
特征三:热点集中 🔥
输出:
📊 热点分布分析
============================================================
热点类型 | 实例 | 热点程度
------------------------------------------------------------
商品库存 key | stock:1001 | ★★★★★ 单 key 承受全部请求
活动/商品详情 | activity:1001 | ★★★★☆ 内容静态, 可缓存
静态资源 | img/*.jpg, js/*.js | ★★★★☆ 流量最大, 可全走 CDN
排队队列 | queue:waiting:{1001} | ★★★★☆ 写集中在单集合
用户限购标记 | bought:{userId} | ★★★☆☆ 长尾分散
订单号序列 | order:seq | ★★☆☆☆ 单点写, 但量不大
🎯 关键发现:
• 100 件库存对应 1 个 key, 50 万请求全部打在它身上
• 热点是"单点"而非"分布", 所以可以针对性优化
• 静态资源占了总请求的大头, 但它根本不必要回源
“热点集中”和”流量大”是两个独立的问题。 50 万请求均匀分布在 50 万个商品上,Redis 毫无压力;50 万请求打在 1 个商品上,1 个 key 就是全部的压力。
热点带来三个具体的麻烦:
1. 单点瓶颈
Redis 是单线程执行命令的,1 个 key 上的 50 万次扣减会排成一条队。虽然每次操作只有几十微秒,但 50 万次串行执行的时间依然可观;MySQL 侧更明显——50 万个请求争抢同一行库存锁,会直接把 TPS 打到几百。
2. 缓存击穿
热点 key 一旦过期(或者服务刚重启、缓存刚预热),50 万请求会在同一瞬间发现缓存没了,一起穿透到数据库。这叫击穿,和雪崩(大量 key 同时过期)不同——雪崩是范围问题,击穿是时间点问题。
3. 缓存穿透
不存在的 key(比如不存在的商品 ID)如果每次都回源查询,也会在瞬间打满数据库。
| 问题 | 常规解法 | 在秒杀里的特殊之处 |
|---|---|---|
| 单点瓶颈 | 拆 key、读写分离、分库分表 | 库存必须原子扣减,拆开就要重新设计一致性 |
| 缓存击穿 | 互斥锁重建、逻辑过期 | 热点 key 干脆不设过期,活动期间常驻 |
| 缓存穿透 | 布隆过滤器、空值缓存 | 无效请求应该在最外层就被拦掉,根本不该到缓存层 |
关于”拆 key”要特别小心。 库存拆成 stock:1001:0 到 stock:1001:9 十个子 key,确实能消除单点,但”这十个子 key 一共还剩多少”就变成了一个需要维护的全局量——而全局量的原子扣减又回到了单点。库存的热点在很多场景下是消不掉的,正确做法是接受它,然后保证那一个点足够强(Lua 原子扣减、主从、集群分片)。
静态资源是最大的热点,也是最容易解决的热点。 图片、JS、CSS 这些请求占了总请求的大头,但它们内容不变、可以被任意缓存——把它们交给 CDN 边缘节点,源站就几乎不用再承载这部分流量了。
特征四:瞬时并发高 ⚡
输出:
📊 并发模型分析
============================================================
QPS 与 并发数的关系(Little's Law):
并发数 = QPS × 平均响应时间(秒)
场景 A: 50 万 QPS × 10ms 响应 = 5,000 并发
场景 B: 5 万 QPS × 200ms 响应 = 10,000 并发 ← 响应变慢, 并发反而更高!
🎯 关键发现:
• 瞬时并发比 QPS 更能反映系统的真实压力
• 响应时间被拖长时, 并发数会雪崩式上升(正反馈)
• 连接池/线程池耗尽 → 响应变慢 → 并发更高 → 更糟
为什么并发数比 QPS 更危险? 因为资源是被并发占用的。50 万 QPS 如果每次只占 10ms,服务器同时只需要处理 5,000 个请求;但如果因为某个依赖变慢,响应时间涨到 200ms,并发就变成了 10,000——而系统变慢的原因往往正是因为并发已经上来了。
正反馈回路:
并发升高 → 连接池/线程池耗尽 → 排队 → 响应时间变长
→ 并发 = QPS × 响应时间,继续升高 → 更耗尽 → 更慢
→ 最终雪崩
打断这个回路的位置只有一个:入口。 在请求进到系统内部之前就限制住速率,让内部的并发数始终低于资源上限。这是第 5 章限流和排队存在的根本原因。
从排队论的角度看,同一件事有另一个描述:
到达率 λ(请求进入速率)
服务率 μ(系统处理速率)
利用率 ρ = λ / μ
ρ = 0.7 排队时间平稳,系统从容
ρ = 0.9 延迟开始明显上升
ρ = 0.95 延迟急剧上升
ρ = 1.0 队列无限增长,系统崩溃
当 ρ 接近 1,排队延迟会趋向无穷。 这就是为什么系统不能按”峰值 QPS”来规划容量,而要按”峰值 QPS × 安全系数”来规划,并且要在到达率超过服务率之前就把它压下来。
预测不是为了”算准”,而是为了在容量不足时提前发现。一个偏保守的预测远好过没有预测。
五种数据来源
| 方法 | 数据来源 | 准确度 | 说明 |
|---|---|---|---|
| 历史数据法 | 上一场同类活动 | 高 | 最可靠,但只适用于重复活动 |
| 预约报名法 | 预约/报名人数 | 中高 | 需要活动支持预约运营 |
| 媒体热度法 | 曝光量、搜索指数、社交热度 | 中 | 用于全新活动,只能给量级 |
| 页面刷新模型 | 参与人数 × 刷新系数 × 集中度 | 中高 | 上一节的行为规律 |
| 压测基线法 | 压测得到的单机能力 | — | 不是预测流量,是预测能扛多少 |
一个可用的预测公式
峰值 QPS = 参与人数 × 刷新系数 × 点击集中度 ÷ 活动窗口秒数
参与人数 = 预约人数 × 到场率(通常 70%-90%)
刷新系数 = 平均刷新次数(5-10)
点击集中度 = 集中在峰值窗口内的比例(通常 60%-80%)
活动窗口 = 尖峰持续的秒数(通常 3-10 秒)
代入一组典型参数:
预约人数 = 200,000
到场率 = 0.85
刷新系数 = 6
点击集中度 = 0.7
活动窗口 = 5 秒
参与人数 = 200,000 × 0.85 = 170,000
请求总量 = 170,000 × 6 × 0.7 = 714,000
峰值 QPS = 714,000 ÷ 5 = 142,800 QPS
这个数字比”50 万人同时抢”小得多,因为 85% 的到场率、七成的点击集中度、还有大量用户根本不刷新——把每一层折扣都算进去,真实峰值通常只有直觉估算的三分之一。
三档规划
不要只算一个数字,要算三档:
| 档位 | 假设 | 用途 |
|---|---|---|
| 保守档 | 到场率 70%、刷新系数 5、集中度 0.6 | 容量规划的下限,资源按这个准备 |
| 中性档 | 上面那组典型参数 | 日常监控和预案的依据 |
| 激进档 | 到场率 95%、刷新系数 10、集中度 0.9 | 压测的输入,也是应急预案的触发线 |
容量 = 峰值 QPS ÷ 单机安全 QPS × 冗余系数(1.5)
激进档 142,800 × 2 ≈ 285,600 QPS
单机安全 QPS(秒杀服务,预留 50% 余量)= 20,000
所需实例数 = 285,600 ÷ 20,000 × 1.5 ≈ 22 台
冗余系数不能省。 压测得到的是”系统健康时的极限”,而活动当天总有 GC、慢节点、坏网卡。按极限的 100% 规划,等于按一定会出事来规划。
预测的误差从哪来
| 误差来源 | 影响 | 怎么对冲 |
|---|---|---|
| 新活动没有历史数据 | 只能靠预约和热度估 | 用保守档,资源按更激进的准备 |
| 到场率估错 | 直接线性放大峰值 | 活动前用往年数据修正 |
| 刷新系数估低 | 漏算流量放大 | 压测时用脚本模拟真实刷新频率 |
| 突发热点(微博/新闻) | 完全无法预测 | 预留弹性扩容能力 + 降级预案 |
| 多品类同时开抢 | 叠加效应 | 错峰放量,不要撞在一起 |
最后一条尤其要注意:三个热门商品同时开抢,峰值不是相加那么简单——用户会在三个页面之间反复切换,请求在总量上会叠加,在时间上也会互相冲撞。错峰是成本最低的削峰手段。
四大特征对应四类手段,它们组合起来才构成完整的方案。
| 流量特征 | 应对策略 | 落地位置 | 对应章节 |
|---|---|---|---|
| 时间高度集中 | 预约、分批放量、页面静态化 + CDN | 运营层 + 接入层 | 第 5 章 |
| 用户行为规律 | 答题/验证码、刷新限频、重复提交拦截 | 网关层 | 5.2 |
| 热点集中 | 多级缓存、本地缓存、热点常驻、静态资源全量 CDN | 缓存层 | 4.1 / 2.2 |
| 瞬时并发高 | 令牌桶限流、排队、异步下单、连接池隔离 | 网关 + 服务层 | 5.1 / 5.3 / 4.3 |
分层看:把流量挡在哪一层
第 1 层 静态资源(CDN) ← 挡住 60%-70% 的请求,源站完全无感
↓
第 2 层 接入层限流(令牌桶) ← 挡住超量的 IP、地区、频率
↓
第 3 层 答题/验证码 ← 挡住脚本,把 50 万降到几千
↓
第 4 层 排队系统 ← 把剩下的瞬时洪峰摊平成稳定速率
↓
第 5 层 秒杀服务(Redis 扣减) ← 只面对一个可预期的稳定速率
↓
第 6 层 消息队列 + 异步下单 ← 把数据库写入从主链路上摘掉
↓
第 7 层 MySQL(条件更新兜底) ← 只处理成功请求,且有最后一道防线
每一层都在做同一件事:让更少的请求进入更贵的资源。 设计顺序也应该是这个顺序——先算最外层能挡掉多少,再决定里面要准备多大容量。
三个必须配套的动作
1. 预热:活动开始前把商品、活动详情、库存 key 全部预热到缓存,避开开抢瞬间的冷启动。
预热内容:
· 商品详情、活动规则 → 写入 CDN 缓存
· 库存 key → 写入 Redis 并确认存在
· 限购标记 key → 提前建好(避免 INCR 时才创建)
· 限流配置、排队参数 → 提前下发并验证
2. 降级预案:每一个可能过载的组件,都要预先想好”降级成什么样”。
| 组件过载 | 降级动作 | 代价 |
|---|---|---|
| Redis 压力大 | 关闭非核心功能(推荐、评论、积分展示) | 用户少看一些内容 |
| 数据库压力大 | 收紧限流阈值、暂停异步订单的批量处理 | 订单落库变慢 |
| 队列积压 | 放行速率下调 | 用户等待变长 |
| 整体过载 | 切换到”已售罄”静态页 | 少卖,但系统活着 |
3. 观测:监控要能回答”现在扛得住吗”。
核心指标:
· 当前 QPS vs 预测峰值
· P99 延迟(并发数的先行指标)
· 队列长度与积压趋势
· Redis 命中率与热点分布
· 限流触发比例
· 售罄后的无效流量占比
把上面的公式写成脚本,活动上线前跑一遍,输出容量规划和风险提示。
#!/usr/bin/env python3
"""秒杀流量预测与容量规划脚本
输入:参与规模、行为参数、单机能力
输出:峰值 QPS、所需实例数、队列内存预估、风险提示
"""
from dataclasses import dataclass
@dataclass
class Forecast:
name: str
reserved: int # 预约人数
arrival_rate: float # 到场率
refresh_factor: float # 平均刷新系数
concentration: float # 点击集中度
window_seconds: int # 尖峰窗口
node_qps: int # 单机安全 QPS
redis_growth: float # 预留冗余系数
def compute(self) -> dict:
participants = self.reserved * self.arrival_rate
total_requests = participants * self.refresh_factor * self.concentration
peak_qps = total_requests / self.window_seconds
# 容量规划:按最激进的一档准备资源,再乘冗余
capacity_needed = peak_qps * self.redis_growth
instances = -(-capacity_needed // self.node_qps) # 向上取整
# 队列内存:积压消息数 × 单条 200 字节
backlog = peak_qps * self.window_seconds
queue_mb = backlog * 200 / 1024 / 1024
return {
'name': self.name,
'participants': int(participants),
'total_requests': int(total_requests),
'peak_qps': int(peak_qps),
'instances': int(instances),
'queue_mb': round(queue_mb, 1),
}
PLANS = [
Forecast('保守档', 200_000, 0.70, 5, 0.6, 5, 20_000, 1.5),
Forecast('中性档', 200_000, 0.85, 6, 0.7, 5, 20_000, 1.5),
Forecast('激进档', 200_000, 0.95, 10, 0.9, 8, 20_000, 1.5),
]
def print_report(result: dict) -> None:
print('=' * 60)
print(f"📊 {result['name']}")
print('=' * 60)
print(f" 预估参与人数 : {result['participants']:,}")
print(f" 预估请求总量 : {result['total_requests']:,}")
print(f" 预估峰值 QPS : {result['peak_qps']:,}")
print(f" 所需实例数 : {result['instances']} 台")
print(f" 队列内存预估 : {result['queue_mb']} MB")
print()
def risk_notes(result: dict) -> list[str]:
"""根据预测结果给出风险提示"""
notes = []
if result['peak_qps'] > 100_000:
notes.append('峰值超过 10 万 QPS:必须做排队 + 异步下单,不能同步写库')
if result['queue_mb'] > 512:
notes.append(f"队列内存预估 {result['queue_mb']}MB:Redis 需要单独规划内存配额")
if result['instances'] < 4:
notes.append('实例数过少:单点故障会拖垮全场,至少保证 2 个可用副本')
if result['peak_qps'] * 3 > result['instances'] * result['peak_qps']:
notes.append('单机承载比例过高:预留冗余不足')
return notes
if __name__ == '__main__':
results = [plan.compute() for plan in PLANS]
for item in results:
print_report(item)
print('⚠️ 风险提示(按激进档)')
for note in risk_notes(results[-1]):
print(f' · {note}')
print()
运行结果:
============================================================
📊 保守档
============================================================
预估参与人数 : 140,000
预估请求总量 : 420,000
预估峰值 QPS : 84,000
所需实例数 : 7 台
队列内存预估 : 32.0 MB
============================================================
📊 中性档
============================================================
预估参与人数 : 170,000
预估请求总量 : 714,000
预估峰值 QPS : 142,800
所需实例数 : 11 台
队列内存预估 : 54.5 MB
============================================================
📊 激进档
============================================================
预估参与人数 : 190,000
预估请求总量 : 1,368,000
预估峰值 QPS : 171,000
所需实例数 : 13 台
队列内存预估 : 65.2 MB
⚠️ 风险提示(按激进档)
· 峰值超过 10 万 QPS:必须做排队 + 异步下单,不能同步写库
· 队列内存预估 65.2MB:Redis 需要单独规划内存配额
这个脚本的价值不在于算得准,而在于把”要扛多少”这个模糊问题变成一个可以评审的数字。 资源按哪一档准备、压测打到多少、应急预案什么时候启动,全都有了依据。
但预测永远只是输入,不是结论。 活动当天还要盯着实时指标,一旦实际 QPS 超过了预测的激进档,就该执行降级预案,而不是继续硬扛。
问题 1:为什么秒杀流量会瞬间暴增?
提示:
- 用户行为:所有人同一时间点击
- 心理因素:担心抢不到
- 技术原因:倒计时精确到秒
解题思路
“瞬间暴增”不是一个技术故障,而是高度一致的人类行为在网络上的映射。要解释它,得拆成”为什么会同步”和”为什么会放大”两层。
详细步骤
-
行为同步:所有人被同一个时间点对齐了。 活动预告写明零点开始,全网都知道,于是几百万人的闹钟定在了同一个时刻。这在日常业务里几乎不会发生——平时的流量是自然分布的。
-
倒计时精确到秒会进一步放大同步性。 页面上的倒计时精确到秒,所有人都会盯着那个数字,在归零的那一瞬间点下去。这把本来还有几秒离散度的点击,进一步压缩到了同一个毫秒级窗口里。
-
心理因素制造了”早点击”和”重复点击”。 担心抢不到的人会在倒计时最后几秒提前点,会在没反应时连点,会在失败后立刻再点。结果是一次意图变成了多次请求。
-
从众效应让流量自我强化。 社交平台上”已经开始抢了”的帖子会吸引更多人涌进来,一个本来只有 10 万人关注的活动,可能在开抢前变成 50 万人。
-
页面刷新把流量放大数倍。 紧张的用户在开抢前反复刷新,每次刷新都是一轮完整请求(页面 + 图片 + JS + 接口)。这是”5-10 倍放大”的来源,也是为什么静态资源必须走 CDN。
-
失败之后还有第二波。 没抢到的人继续刷、继续提交,售罄后的流量不会立刻归零,而是以更平缓的形态持续几分钟。
-
技术上的放大器:重试机制。客户端或网关的超时重试,会在服务变慢时把请求量翻倍——流量越高越容易超时,越超时重试越多,这是一个典型的正反馈。
最终答案
因为秒杀的流量是”人为对齐”的:全网约定同一时刻、倒计时精确到秒让点击窗口极度收敛,抢不到的心理驱动了重复点击和持续刷新,页面刷新再把请求量放大 5-10 倍,售罄后的无效重试和超时重试还会形成第二波和正反馈。理解这四层放大机制,才能在正确的位置(入口限流、静态资源 CDN、答题拦截)做对应的削减。
问题 2:如何提前预测流量?
提示:
- 历史数据分析
- 预约人数
- 商品热度
- 宣传力度
解题思路
预测的本质是把不确定的人群规模,转换成一条可以写进容量方案的数字。方法有很多,但必须回答三个问题:预测什么(峰值 QPS)、给谁用(容量规划)、错了怎么办(冗余与预案)。
详细步骤
-
能拿历史数据,就别估。 同类型活动(同品类、同价格带、同时间段)的历史峰值是最好的输入。做同比环比,并按品类调整系数。
-
没有历史数据时,用”参与人数 × 行为系数”建模:
峰值 QPS = 参与人数 × 刷新系数 × 点击集中度 ÷ 尖峰窗口秒数
参与人数 = 预约人数 × 到场率这三个系数都来自上一节的行为规律,取值范围相对稳定(到场率 70%-95%、刷新系数 5-10、集中度 0.6-0.9)。
-
用商品热度和宣传力度修正参与人数。搜索指数、社交话题阅读量、预热物料的曝光量都能作为参与人数的佐证;多个品类同时开抢要额外考虑叠加效应。
-
规划时按最激进的一档准备资源,再乘冗余系数(1.5 左右)。压测得到的是健康状态下的极限,活动当天总有 GC、坏节点、慢网络。
-
预测必须转化为压测输入。 拿预测出的峰值 QPS 和流量模型(请求分布、参数分布、刷新行为)去压测,压测脚本要模拟真实用户的刷新节奏,而不是单纯用固定速率的循环请求。
-
留出可动态调整的余量,比如容器化的实例数可以按活动配置临时扩缩,而不是活动前就固定。
-
准备预案,而不是只准备资源。 预测偏高会浪费成本,预测偏低会崩系统——两种情况的应对策略不同:前者可以临时收缩,后者必须能快速扩容或降级。
-
活动当天用实时指标校正。 预测是活动前的输入,活动中的实际 QPS、到达速率和积压趋势才是决策依据。超过激进档就执行降级预案。
最终答案
优先级是:历史数据 > 预约人数模型 > 热度佐证。模型用”参与人数 × 刷新系数 × 点击集中度 ÷ 窗口秒数”,规划按最激进一档乘冗余系数,然后用这个峰值作为压测输入。最后一定要配预案——预测用来定容量,预案用来兜住预测的偏差。
问题 3:为什么说”静态资源”是最大的流量来源?
提示:
- 图片、JS、CSS占比70%
- 可以通过CDN解决
- 不需要打到源站
解题思路
关键在于分清请求数和请求成本。一个秒杀页面的请求里,真正的业务接口可能只有一个,但为了渲染它要拉十几次静态资源。把请求数从源站挪走,比优化业务接口省下的更多。
详细步骤
-
算一笔账:一个活动页大致需要 1 个 HTML、1 个 CSS、3-5 个 JS、10-20 张图片,加上 1-2 个业务接口。静态资源占了请求总数的 90% 以上。
-
再叠加刷新:紧张的用户在开抢前刷新 30 次,每次都重新请求这些资源。50 万人 × 30 次刷新 × 15 个资源 = 2.25 亿次静态资源请求。这个数字比业务接口高出几个数量级。
-
静态资源有三个特性,注定它应该由 CDN 承担:
- 内容不变:同一张图,所有人看到的一模一样
- 可缓存:带强缓存头,边缘节点可以直接返回
- 可容忍延迟:一张图晚加载 100ms,用户完全无感
-
CDN 接入后的效果:这些请求在最近的边缘节点就返回了,不消耗源站的带宽、不消耗源站的 CPU、不经过源站的限流和排队。源站只需要处理业务接口那 5%-10% 的流量。
-
它对秒杀主链路的意义:静态资源不再占用 Nginx 的连接数和带宽,源站的资源全部留给业务接口。在网络带宽成为瓶颈时,这一条能直接决定业务接口的 QPS 上限——前面监控大盘里”网络带宽 85%“的那个指标,靠 CDN 就能压下来。
-
要注意的三个坑:
- 活动开始时必须刷新预热,否则用户拿到的是旧版本页面(活动时间不对、规则不对)
- 缓存策略要分层:HTML 短缓存或不缓存(活动时间敏感),图片和 JS 长缓存
- 源站要能承受 CDN 回源——缓存未命中时流量会回源,CDN 挂了流量会全量回源
-
不能把所有流量都交给 CDN:业务接口(库存、排队、下单)是动态的、必须实时计算,CDN 帮不上忙。这部分要靠限流、排队和 Redis 来扛。
最终答案
因为一个活动页的请求里九成以上是图片、JS、CSS 这些内容不变、可缓存、可容忍延迟的静态资源,再加上开抢前的高频刷新,总量比业务接口高出一到两个数量级。CDN 让这些请求在边缘节点返回,完全不经过源站,释放出的带宽和连接数全部留给真正的业务接口——这往往是单条性价比最高的削峰手段。注意 HTML 的活动开始预热、分层缓存策略,以及源站要扛得住回源。
发现内容有问题?
告诉我们哪里需要改进。
