想象你经营着一家遍布全国的连锁餐饮品牌。最开始,顾客点菜必须由中央厨房统一做好,再配送到各城市的分店。为了不让顾客久等,你在每个城区都开了分店,并提前把招牌菜装进保温柜——顾客来了直接取走,这就是 CDN 的初心:把内容提前搬到离用户最近的地方。但很快你发现,顾客越来越想「吃点活的」:要少盐、要加辣、要现场定制。于是你给分店配上了小厨房,可以就地炒菜,这就是边缘云。再后来,你为厨房装上了「智能灶台」——平时完全熄火,来了订单才点火,做完自动关,高峰期灶台自动增加,月底按开火次数和用气量付费——这就是边缘 Serverless。 这条「备菜仓库 → 小厨房 → 智能灶台」的进化线,正是 CDN 从传统内容分发走向边缘计算、再走向无服务器架构的真实路径。本文用这条线串起全部核心概念:缓存命中率、回源、边缘计算、弹性伸缩、按量计费与性能优化,让零基础的你也能顺着故事建立起完整的知识地图。

岗位关联

读懂 CDN 演进,你就拿到了边缘计算与云原生架构的「入场券」;无论做架构选型还是性能优化,都能与资深工程师同频对话。

目录
  1. 可视化演示
  2. 一、CDN 基础原理:在家门口建「备菜仓库」
  3. 二、传统 CDN 架构:保温柜没有灶台
  4. 三、边缘云演进:给分店装上小厨房
  5. 四、边缘计算能力:小厨房能现炒的菜
  6. 五、边缘 Serverless:来单才点火的智能灶台
  7. 六、性能优化策略:让出菜更快更稳
  8. 七、应用场景:从火锅店到外卖平台
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

演示传统CDN缓存、边缘云计算与边缘Serverless三阶段,展示CDN向边缘计算演进的能力跃迁。

本节配有交互动效(进入视口后自动加载,约 3KB)。

传统CDN 边缘节点缓存静态内容 命中率=缓存命中请求占比 就近返回内容降低回源延迟。

一、CDN 基础原理:在家门口建「备菜仓库」

假设你经营一家全国连锁餐厅,招牌菜只在总店出品。郊区客人想吃,得穿越整座城市,菜端上桌时早凉了。聪明的做法是在每个城区开分店,提前把招牌菜从总店运来,放进保温柜。用户点餐,分店直接递出——这就是 CDN 的原型:让内容离用户更近,而不是让用户长途跋涉去取。

CDN 全称 Content Delivery Network(内容分发网络),由三部分构成:源站是内容的「中央厨房」;边缘节点是遍布各地的「分店保温柜」;调度系统(DNS/GSLB)则是「导航员」,把用户指向最近且最空闲的那家分店。用户请求先被解析到就近边缘节点,而不是直接打到源站。

判断分店是否合格,核心看一个指标——缓存命中率:用户下单时保温柜里有现成菜,叫「命中」;柜里没有,服务员得回中央厨房取,叫「未命中」。命中率决定了用户等待时间是秒级还是秒加回源耗时。

所以连锁店老板每天盯「保温柜出货率」,CDN 工程师也一样:把命中率做高,用户自然「点到即取」。

H=NhitNhit+Nmiss\displaystyle H=\frac{N_{\text{hit}}}{N_{\text{hit}}+N_{\text{miss}}}
命中率 = 从保温柜直接取走的订单数 ÷ 总订单数。传统 CDN 的命脉,就在于把 H 做得足够高。
  1. 分子 \(N_{\text{hit}}\)(命中请求数)统计一段时间内所有在边缘节点缓存中直接命中的请求次数,相当于「柜里有菜、直接取走」的单量。
    NhitN_{\text{hit}}
  2. 分母 \(N_{\text{hit}}+N_{\text{miss}}\)(总请求数)命中与未命中的和,代表用户发起的全部请求;分母不含任何杂项,保证 H 是一个 0 到 1 之间的比例。
    Nhit+NmissN_{\text{hit}}+N_{\text{miss}}
  3. 比值 \(H\)(缓存命中率)两者相除得到概率值;越接近 1,说明越多请求被边缘「就地解决」,用户等待越短。
    NhitNhit+Nmiss\frac{N_{\text{hit}}}{N_{\text{hit}}+N_{\text{miss}}}

二、传统 CDN 架构:保温柜没有灶台

早期的连锁分店只有一个身份:存货仓库。中央厨房做什么,分店就卖什么,分店完全没有「现场烹饪」能力。对应到技术世界,传统 CDN 只擅长加速静态资源——图片、CSS、JavaScript、视频等「提前做好、内容不变」的文件。

传统架构分三层:源站服务器存放原始内容;边缘缓存节点在各地机房保存热门副本;全局负载均衡(GSLB)结合 DNS 把请求调度到最合适的节点。请求到达边缘节点后先查本地缓存,命中直接返回;未命中则触发「回源」——节点代替用户去源站取内容,转交给用户的同时留一份在缓存里。缓存一致性则依靠 TTL(保质期)与主动刷新机制维持。

平均响应时间可以用一个公式刻画:

这个公式揭示了传统 CDN 的天花板:回源延迟是最大开销,而有些「菜」——比如千人千面的个性化页面——天生无法提前备好。保温柜再大,也变不出现炒的热菜。要突破,必须给分店装上灶台。

Tˉ=H×Tcache+(1−H)×(Tcache+Torigin)\displaystyle \bar{T}=H\times T_{\text{cache}}+(1-H)\times\left(T_{\text{cache}}+T_{\text{origin}}\right)
平均取餐时间 = 命中概率 × 柜内取餐时间 + 未命中概率 ×(柜内取 + 回中央厨房取)的时间。回源延迟 T_origin 是代价大头,H 越低落差越明显。
  1. 命中路径 \(H\times T_{\text{cache}}\)以概率 H 直接从缓存取内容,耗时只有取保温柜的 T_cache。
    H×TcacheH\times T_{\text{cache}}
  2. 未命中路径 \((1-H)\times\left(T_{\text{cache}}+T_{\text{origin}}\right)\)未命中时先查缓存再回源,共花费 T_cache 加回源时间 T_origin。
    (1−H)×(Tcache+Torigin)(1-H)\times\left(T_{\text{cache}}+T_{\text{origin}}\right)
  3. 加权求和得平均响应时间两条路径按概率加权,得到整体平均响应时间,回源越慢、命中率越低,代价越昂贵。
    Tˉ=H×Tcache+(1−H)×(Tcache+Torigin)\bar{T}=H\times T_{\text{cache}}+(1-H)\times\left(T_{\text{cache}}+T_{\text{origin}}\right)

三、边缘云演进:给分店装上小厨房

顾客开始提要求:「我要少盐」「我要加辣」。中央厨房统一加工的模式彻底失灵。连锁总部决定改造分店:每间分店除了保温柜,再配一个小厨房——这就是边缘云的诞生:CDN 节点从「只存不算」升级为「既能存又能算」。

技术上的演进路径清晰可见:边缘节点从专用缓存设备换成通用服务器;操作系统层引入容器化部署,用 Kubernetes 边缘方案统一管理成千上万个节点;业务以容器镜像形式分发,像更新菜谱一样批量滚动升级门店「设备」。智能调度路由会实时感知每个节点的负载与剩余资源,把请求分给「最闲的灶台」。

边缘节点业务量攀升后,怎样衡量「小厨房」到底消化了多少活?看本地消化率:

小厨房建好了,老板却开始对着煤气账单发愁:灶台全天候待命,但凌晨两点根本没有订单。能不能做到「来单才点火」?这正好引出了整条演进线的终点——边缘 Serverless。

Rlocal=Ncache+NcomputeNtotal\displaystyle R_{\text{local}}=\frac{N_{\text{cache}}+N_{\text{compute}}}{N_{\text{total}}}
本地消化率 = 在分店完成(缓存取菜 + 现场炒菜)的单量 ÷ 进店总单量。它比单纯命中率更全面,因为计算也算「就地解决」。
  1. 分子 \(N_{\text{cache}}+N_{\text{compute}}\)缓存直接服务的请求数加上边缘计算完成的请求数,代表一切没回「总部」就地消化的业务。
    Ncache+NcomputeN_{\text{cache}}+N_{\text{compute}}
  2. 分母 \(N_{\text{total}}\)进入该边缘节点的全部请求数,无论命中还是计算、成功还是回源,都算在内。
    NtotalN_{\text{total}}
  3. 比值 \(R_{\text{local}}\)(本地消化率)越接近 1,说明请求几乎都在分店解决;它是边缘云演进成效最直观的指标。
    Rlocal=Ncache+NcomputeNtotalR_{\text{local}}=\frac{N_{\text{cache}}+N_{\text{compute}}}{N_{\text{total}}}

四、边缘计算能力:小厨房能现炒的菜

有了小厨房,分店能接的「活」一下子多了。第一道菜是「就近计算」:游戏对战服的房间匹配、状态同步,原本要绕道中心云,现在在城区分店就地完成,用户体感从「心塞」变成「丝滑」。就近计算把「远水难救近火」变成了「近水楼台先得月」。

第二道菜是「动态内容加速」。页面渲染、接口聚合(BFF)、个性化推荐等动态逻辑,被拆成一段段可在边缘执行的代码,配合本地缓存,把响应时间从百毫秒级压到十几毫秒级。边缘存储(边缘 KV、对象存储)则为这些计算提供了本地数据底座,让「配菜」不用每次回总部拿。

衡量边缘计算优劣的直观公式是总延迟分解:

中心云算得快但「路远」,边缘节点算得「够快」且路近。就像小厨房的大厨虽然没总厨名气大,但菜出锅时锅气还在——对大多数场景,「近」比「强」更关键。

Ttotal=Tnetwork+Tcompute\displaystyle T_{\text{total}}=T_{\text{network}}+T_{\text{compute}}
总延迟 = 网络传输时间 + 计算处理时间。边缘计算的本质,就是把「在路上」的时间压到最短。
  1. 网络传输时间 \(T_{\text{network}}\)数据在用户与服务器之间往返的耗时,与物理距离强相关;绕道中心云相当于让顾客跨城取餐。
    TnetworkT_{\text{network}}
  2. 计算处理时间 \(T_{\text{compute}}\)服务器执行逻辑(渲染、查询、推理)的耗时,取决于节点算力与代码效率。
    TcomputeT_{\text{compute}}
  3. 求和得总延迟网络与计算串行累加;把计算搬到边缘,本质是大幅压缩 T_network 这一项,往往能把延迟砍掉一个数量级。
    Ttotal=Tnetwork+TcomputeT_{\text{total}}=T_{\text{network}}+T_{\text{compute}}

五、边缘 Serverless:来单才点火的智能灶台

老板最终装上了「智能灶台」:平时完全熄火,订单一来自动点火,做完自动关;高峰期灶台自动增加,闲时自动合并。这就是边缘 Serverless——在 CDN 网络上运行「无服务器函数」(Function as a Service,FaaS)。

所谓「无服务器」,不是真的没有服务器,而是服务器由平台托管。开发者只写业务函数(如图片裁剪、参数校验、消息转码),代码被分发到边缘节点;请求到达时,平台按需拉起函数实例执行,用完即释放——这就是事件驱动。实例数量会随流量自动扩缩,不需要人工预估容量。

账单上的费用公式是老板最关心的:

智能灶台完美契合「二八定律」式的流量——大部分时间没什么菜做,饭点瞬间十几桌。Serverless 让你只为开火的瞬间付钱;至于「火苗点着要时间」的冷启动问题,则靠预留并发(温池)来缓解。

Cost=N×Cinvoke+N×D×Ctime\displaystyle \text{Cost}=N\times C_{\text{invoke}}+N\times D\times C_{\text{time}}
月度费用 = 调用次数 × 单次调用单价 + 调用次数 × 单次执行时长 × 资源单价。只为真正「开火的瞬间」付费。
  1. 调用次数 \(N\)函数被事件触发的总次数,相当于一月下来「点了几个菜」。
    NN
  2. 调用费 \(N\times C_{\text{invoke}}\)每次触发收取的固定费用;菜点得再多,每道都有一笔基本服务费。
    N×CinvokeN\times C_{\text{invoke}}
  3. 时长费 \(N\times D\times C_{\text{time}}\)D 为单次执行时长(秒),总执行时长乘以资源单价,对应「用气量」。
    N×D×CtimeN\times D\times C_{\text{time}}
  4. 总成本求和固定调用费与资源时长费相加,便是当月账单;调优方向就是降低 N、D 或单位单价。
    Cost=N×Cinvoke+N×D×Ctime\text{Cost}=N\times C_{\text{invoke}}+N\times D\times C_{\text{time}}

六、性能优化策略:让出菜更快更稳

有了灶台和智能点火,老板还要琢磨怎么让出菜更快更稳。第一招是「预热」:大促前夜,把顾客最可能点的菜全部提前搬运到分店保温柜,避免第二天早上临时回总部取货。技术上叫缓存预热,是提升命中率最直接的手段。

第二招是「保鲜管理」:给每道菜贴保质期(TTL),设计合理的缓存失效策略;源站内容更新时主动推送(缓存刷新),防止用户吃到过期菜。第三招「回源优化」:用专线、长连接、私有回源协议,把「回总部取菜」的时间压缩到极限;再结合链路优化(HTTP/3、连接复用、压缩),让整条取餐路线又快又宽。

命中率每提升一点,收益都清晰可算:

优化策略的本质,就是让老板把每个订单尽量在分店解决——能本地出的本地出,实在不行再回总部,而且回总部的路还要修得又快又宽。

ΔT=(H′−H)×Torigin\displaystyle \Delta T=(H'-H)\times T_{\text{origin}}
响应时间节省量 = 命中率提升幅度 × 回源耗时。回源是「长途运输」,命中率是「本地出货比例」,本地出货越多越省时。
  1. 优化前后的命中率 \(H\) 与 \(H'\)H 是优化前命中率,H' 是优化后命中率,两者差值为正说明改进有效。
    H<H′H < H'
  2. 回源时间 \(T_{\text{origin}}\)每次未命中多付出的一次回源延迟,是公式里被「省掉」的代价。
    ToriginT_{\text{origin}}
  3. 收益 \(\Delta T\)命中率提升差值乘以回源时间,得到平均响应时间的节省量;回源越慢,提升命中率的收益越大。
    ΔT=(H′−H)×Torigin\Delta T=(H'-H)\times T_{\text{origin}}

七、应用场景:从火锅店到外卖平台

这条演进线已经深深嵌入今天的互联网体验。视频直播是最典型的「边缘云」受益者:主播推流上传到最近的边缘节点,转码、合流、混音在节点就地完成,观众从同城节点就近拉流,延迟从数秒压到一秒以内。

电商大促则是「边缘 Serverless」的主战场:整站静态资源提前预热,秒杀校验逻辑写成边缘函数,流量洪峰来时平台自动扩容函数实例,风控审核以事件驱动方式并行执行——大促结束后按量结算,不为闲置买单。这里实例数的估算可以套用并发公式:

IoT 场景同样如此:工厂传感器数据先送到园区级边缘节点做清洗与异常检测,只把结果上报中心;Serverless 函数在检测到异常时即时触发告警与联动控制,让「锅烧干了马上关火」。从备菜仓库到智能厨房,CDN 演进的本质,就是不断把能力推向离用户最近的地方。

k=⌈λ×tˉservice⌉\displaystyle k=\left\lceil \lambda\times\bar{t}_{\text{service}} \right\rceil
所需函数实例数 = 每秒请求数 × 单请求平均服务时长,再向上取整。忙时多开灶,闲时自动合。
  1. 每秒请求数 \(\lambda\)函数面对的流量强度,大促时可能瞬间飙到每秒数万。
    λ\lambda
  2. 单请求平均服务时长 \(\bar{t}_{\text{service}}\)一个函数实例处理单个请求平均耗时(秒),乘以流量得到「同时在途」的请求数。
    λ×tˉservice\lambda\times\bar{t}_{\text{service}}
  3. 向上取整得实例数 \(k\)并发中的请求必须由不同实例并行处理,函数不能服务「半个请求」,所以用向上取整得到所需实例数。
    k=⌈λ×tˉservice⌉k=\left\lceil \lambda\times\bar{t}_{\text{service}} \right\rceil

AI 应用场景

场景一:直播平台的转码与弹幕风控

阶段:实时音视频处理与内容审核推理

解决的问题:传统 CDN 只能分发直播流,转码和合流必须回中心机房,机房距离用户远导致明显延迟;弹幕与礼物消息突增时,中心化处理容易过载。边缘云把转码放到用户同城节点,边缘 Serverless 以事件驱动处理弹幕审核。就像直播间的「中央厨房」搬到了每个城市的分店,菜出锅就上桌。

具体案例:某在线教育平台把直播转码下沉到 CDN 边缘节点,弹幕内容审核编写为边缘函数,由消息队列事件触发;实测首帧延迟降低 40%,审核并发扩容从分钟级缩短到秒级。

场景二:电商大促的流量洪峰与成本平衡

阶段:流量预测与弹性伸缩决策

解决的问题:大促流量是平日的几十倍,固定容量要么浪费要么宕机;AI 依据历史流量与库存热度预测扩容窗口,边缘 Serverless 按预测结果自动伸缩秒杀校验与风控函数,大促结束后自动缩容。好比智能灶台在饭点前自动排班加灶,深夜自动熄火,月底只按实际开火结算。

具体案例:某电商平台在大促前 2 小时对商品详情页全量预热,秒杀校验逻辑部署为边缘函数,峰值期函数实例自动扩容到数千个,活动结束按量结算,成本比包年方案节省约 55%。

场景三:工厂 IoT 的异常检测就地处理

阶段:边缘端模型推理

解决的问题:海量传感器每秒产生百万级数据点,全部回传中心云既不现实也浪费带宽;把异常检测模型部署到园区边缘云,数据就近推理,只有异常结果才上报中心,Serverless 函数触发告警与设备联动。这就好比每间分店自己盯着灶台,闻到糊味立刻关火,而不是等总部远程巡检。

具体案例:某汽车工厂在产线边缘节点部署振动异常检测模型,推理延迟低于 10ms,告警联动函数在 1 秒内完成设备停机保护,月度无效回传数据量下降 90%。

Python 演示

python68 行
#!/usr/bin/env python3"""Edge Serverless simulator: cache hit rate + auto scaling."""import timeimport random  class EdgeNode:    """Edge node with static cache and on-demand function pool."""     def __init__(self, capacity=10, origin_latency=0.05):        self.cache_map = {}        self.capacity = capacity        self.origin_latency = origin_latency        self.hit_count = 0        self.miss_count = 0        self.pool_map = {}        self.cold_count = 0     def get_item(self, key):        """Serve a request: cache hit returns directly, miss goes origin."""        if key in self.cache_map:            self.hit_count += 1            return self.cache_map[key], 'hit'        self.miss_count += 1        time.sleep(self.origin_latency)        value = 'source:' + key        if len(self.cache_map) >= self.capacity:            self.cache_map.pop(next(iter(self.cache_map)))        self.cache_map[key] = value        return value, 'miss'     def run_function(self, name, payload):        """Invoke an edge function, reuse warm instance if possible."""        slots = self.pool_map.setdefault(name, [])        if slots:            handler = slots.pop()        else:            handler = name + '#new'            self.cold_count += 1        result = name + '(' + str(payload) + ') ok'        time.sleep(0.02)        if len(slots) < 3:            slots.append(handler)        return result, handler     def hit_rate(self):        total = self.hit_count + self.miss_count        return round(self.hit_count / total, 4) if total else 0.0  def simulate():    node = EdgeNode(capacity=8, origin_latency=0.05)    hot = ['/img/logo.png', '/js/app.js', '/css/main.css']    cold = ['/api/user/1', '/api/order/99']    random.seed(42)    for i in range(60):        key = random.choice(hot) if i % 5 else random.choice(cold)        node.get_item(key)    print('缓存命中率:', node.hit_rate())    print('未命中次数:', node.miss_count)    for i in range(6):        out, handler = node.run_function('thumbnail', i)        print(out, '| 实例:', handler)    print('冷启动次数:', node.cold_count)  if __name__ == '__main__':    simulate()
目的:模拟一个边缘节点在混合流量下「缓存 + 边缘函数」的工作过程,输出缓存命中率并观察 Serverless 函数实例的冷启动与复用情况。
  1. if key in self.cache_map:命中判断:保温柜里有菜就直接取走,命中计数加一;否则走未命中分支回源。
  2. value = 'source:' + key模拟回源:到「中央厨房」取原始内容,真实工程里这里是一次源站 HTTP 请求。
  3. self.cache_map.pop(next(iter(self.cache_map)))缓存满时淘汰最早写入的一项,是近似 LRU 的简洁实现。
  4. slots = self.pool_map.setdefault(name, [])给每个函数名维护空闲实例池,对应边缘 Serverless 的「温池保活」机制。
  5. handler = name + '#new'; self.cold_count += 1池里没有可用实例就必须冷启动,冷启动是 Serverless 的最大敌人。
  6. key = random.choice(hot) if i % 5 else random.choice(cold)每 5 个请求插入一个冷门 key,模拟真实流量的「二八倾斜」。
  7. node.run_function('thumbnail', i)事件驱动触发边缘函数执行,好比智能灶台「来单点火」。

常见误区

误区我一直以为 CDN 就是一层缓存,只能分发图片和视频,凡是动态请求都必须回源站计算。

正解传统 CDN 确实只擅长静态内容,但演进到边缘云后,边缘节点已经具备计算能力,可以在节点上执行业务逻辑——动态页面渲染、接口聚合、安全防护都能在边缘完成。用比喻说,分店不只是保温柜,如今还配备了小厨房,能现炒热菜。

为何常见:多数入门资料都从「缓存加速」讲 CDN,导致大家把「CDN=缓存」当成了全部,忽视了近十年的边缘化演进。

误区我以为边缘节点背后是一整个机房,想部署多少容器、跑多少函数都行,和中心云没有区别。

正解边缘节点往往散落在城域网机房甚至基站,CPU、内存、带宽、电力都有限,规格远小于中心云。因此调度系统必须感知每台节点的剩余资源,按需分配;Serverless 的「弹性」也有上限,不能拿中心云的容量心智去套边缘。

为何常见:云厂商宣传常强调「无限扩展」,用户容易把边缘节点想象成无穷资源池,忽略了物理节点的分布约束。

误区既然叫无服务器,那服务器相关的运维肯定都不用我管,只要写函数就行,出问题都是平台的责任。

正解无服务器指的是「不用管理服务器硬件与集群」,但函数本身的代码质量、依赖版本、冷启动优化、配置的环境变量、日志与监控仍然由开发者负责。智能灶台虽然自动点火熄火,但用什么锅、放什么料、火候是否合适,依然是厨师的事。

为何常见:「无服务器」这个翻译容易让人望文生义,忽略了「平台代管基础设施」这层真实含义。

误区边缘 Serverless 用多少付多少,肯定比买固定资源便宜,所以我应该把所有服务都改成函数。

正解按量计费适合突发性强、均值低的流量;如果流量稳定且持续很高,预留实例或固定资源的单价反而更低。自家开餐厅,灶台天天满负荷,不如直接雇长工;偶尔来一桌客人,才适合「来单点火」的共享厨房。

为何常见:厂商宣传「按量付费更省」时通常拿低流量场景举例,用户没算清自己的长期用量曲线,容易被单点印象带偏。

面试题

Q1. CDN 的核心目标是?

单选题 · easy

  • A.让用户就近获取内容降低访问延迟← 正确答案
  • B.替换源站数据库提升查询性能
  • C.压缩源站代码减少开发工作量
  • D.取代负载均衡器实现流量管理

答案:A。CDN 通过把内容分发到边缘节点,让用户「就近取餐」降低访问延迟。它不负责数据库性能、代码压缩,也不是负载均衡器的替代品。就像开分店是为了让顾客少跑路,而不是把中央厨房的菜谱改掉。

Q2. 传统 CDN 最适合加速哪类内容?

单选题 · easy

  • A.用户个性化生成的动态页面
  • B.图片、CSS、JS 等静态资源← 正确答案
  • C.实时音视频通话的媒体流
  • D.数据库写入操作的执行结果

答案:B。传统 CDN 只「备熟食」,最擅长图片、CSS、JS 这类提前生成好、可缓存的静态资源。个性化动态页面需要边缘计算,实时音视频涉及特殊协议,数据库写入结果不可缓存,都不是传统 CDN 的强项。

Q3. CDN 中 DNS 调度的主要作用是?

单选题 · easy

  • A.加密用户与源站之间的通信
  • B.压缩静态图片与视频文件
  • C.引导用户到最近的边缘节点← 正确答案
  • D.自动更新源站的业务代码

答案:C。DNS/GSLB 调度承担「导航员」角色,把用户请求解析到就近且可用的边缘节点。加密是 HTTPS/TLS 的事,压缩是边缘节点的处理能力,更新代码与 DNS 无关。

Q4. 边缘节点缓存未命中时,通常会发生什么?

单选题 · mid

  • A.直接丢弃请求并返回一个错误页
  • B.向源站发起回源请求拉取内容← 正确答案
  • C.随机选择其他用户的缓存内容
  • D.关闭节点清除全部缓存数据

答案:B。未命中时节点会代替用户「回中央厨房取菜」——向源站发起回源请求,拉取内容后返回给用户并留一份缓存。直接丢请求、随机返回别人内容、清空缓存都是错误行为,会造成用户请求失败或数据错乱。

Q5. 提高缓存命中率最直接的手段是?

单选题 · mid

  • A.缩短 DNS 解析服务器的 TTL 数值
  • B.提前把热点内容预热到边缘节点← 正确答案
  • C.加大源站服务器的磁盘存储空间
  • D.关闭边缘节点的访问日志记录

答案:B。预热相当于大促前把热门菜品提前送到各分店保温柜,是最直接的提升命中率手段。DNS TTL 影响解析而非缓存,源站磁盘与命中率无直接关系,关闭日志只是减少了记录,并不会提高命中率。

Q6. 边缘云相较传统 CDN 的核心新增能力是?

单选题 · mid

  • A.增加边缘缓存节点的磁盘数量
  • B.把缓存存储统一搬到源站
  • C.让用户直接连接源站服务器
  • D.在边缘节点执行业务计算逻辑← 正确答案

答案:D。边缘云的核心突破是在边缘节点「开灶台」——执行计算逻辑,而不是只做缓存。增加磁盘只是扩容缓存,把存储搬回源站是倒退,让用户直连源站就等于放弃了 CDN 的全部意义。

Q7. 下列哪些属于边缘 Serverless 的特征?

多选题 · mid

  • A.事件驱动触发函数执行← 正确答案
  • B.按照实际调用量来计费← 正确答案
  • C.需提前购买固定规格虚拟机
  • D.平台自动扩展函数实例← 正确答案

答案:ABD。边缘 Serverless 是「智能灶台」:事件驱动点火、按调用量计费、平台自动扩缩实例,这些都是核心特征。而提前购买固定规格虚拟机是传统 IaaS 的做法,与 Serverless 理念相反。

Q8. 某 CDN 缓存命中率 H=0.9,缓存命中响应时间 10ms,回源响应时间 90ms,平均响应时间约为?

单选题 · hard

  • A.平均响应时间约为 19ms← 正确答案
  • B.平均响应时间约为 90ms
  • C.平均响应时间约为 10ms
  • D.平均响应时间约为 100ms

答案:A。代入公式 T_avg = T_cache + (1-H)×T_origin = 10 + 0.1×90 = 19ms。90ms 是未命中路径的原生耗时,10ms 是理想纯命中耗时,100ms 是把两条路径简单相加,都不符合加权平均的逻辑。

Q9. 关于边缘 Serverless 的冷启动问题,下列理解正确的有?

多选题 · hard

  • A.冷启动主要消耗在初始化运行环境← 正确答案
  • B.合理设置预留并发可以缓解冷启动← 正确答案
  • C.冷启动问题只存在于边缘场景
  • D.高频热函数通常可复用已有实例← 正确答案

答案:ABD。冷启动指函数首次拉起新实例时,要下载代码、初始化运行时,所以 A 正确;预留并发相当于保持几个「温灶」,能显著缓解,B 正确;高频函数实例常被复用,D 正确。冷启动在中心云 Serverless 同样存在,并非边缘独有,C 错误。

Q10. 下列哪些做法能降低边缘 Serverless 的成本?

多选题 · hard

  • A.合理设置函数超时与内存规格← 正确答案
  • B.对平稳大流量使用预留实例← 正确答案
  • C.优化代码缩短单次执行时长← 正确答案
  • D.把函数迁移到常驻虚拟机部署

答案:ABC。费用公式 Cost = N×C_invoke + N×D×C_time 告诉我们:调低内存规格、缩短执行时长 D、减少不必要的调用 N,都能降本;平稳大流量用预留实例可享受更低单价。而迁回常驻虚拟机等于放弃 Serverless 的弹性优势,成本通常更高。