巷口那家张阿姨面馆,汤头熬了十三年,中午永远排长队。起初她只想着换更大的锅,后来发现锅再大也装不下整条街的客人,而且大锅一旦坏了,全员歇业。于是她开了分店、建了中央厨房、按饭点增减桌椅、新菜先在小店试营、换菜单一家一家地换——这套升级路线,和大模型推理服务从单机到集群的部署进化几乎一模一样。 推理服务部署,就是把训练好的大模型稳定送上生产环境的本事:一台 GPU 机器跑不动了,就用容器把服务打包成“标准料理包”,放进由多台机器组成的集群;GPU 像稀缺的灶台一样需要精细排班;客人多时自动加桌、少时收桌;升级服务时先开试营店再挂招牌,或者一家一家分店换菜单。你会发现,运维大模型的底层逻辑,其实就是把“开面馆”的那套稳妥生意经,翻译成 Kubernetes 能听懂的语言。

岗位关联

学完这一篇,你将理解 LLM 从开发环境走向生产环境的完整部署链路,掌握容器化、GPU 调度、弹性扩缩容与安全发布等云原生 AI 核心工程能力——这是大模型应用落地时最稀缺的实战技能。

目录
  1. 可视化演示
  2. 部署架构演进:从一口大锅到三家分店
  3. 容器化镜像:中央厨房的标准料理包
  4. GPU资源调度:大灶台的排班艺术
  5. 弹性扩缩容:饭点加桌,闲时收桌
  6. 蓝绿发布:不开招牌的试营店
  7. 滚动更新:一家一家换菜单
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

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

K8s集群 GPU: A100 80GBGPU资源分配QPS趋势LLM推理服务部署可视化:展示从单机到集群的全链路部署方案GPU: A100 80GBGPU资源分配QPS趋势LLM推理服务部署可视化:展示从单机到集群的全链路部署方案 GPU: A100 80GBGPU资源分配QPS趋势LLM推理服务部署可视化:展示从单机到集群的全链路部署方案GPU: A100 80GBGPU资源分配QPS趋势LLM推理服务部署可视化:展示从单机到集群的全链路部署方案

部署架构演进:从一口大锅到三家分店

张阿姨的面馆最初就在自家厨房,一口大锅、四个灶眼,午市排起长队。她想到的办法是换更大的锅——这就是“纵向扩展”,但锅再大,一天接待的客人也有上限;更怕的是大锅突然坏了,整条街的面都泡汤。单机部署大模型推理服务也是这个道理:把服务装在一台 GPU 服务器上,简单直接,一张显卡搞定。

可当 QPS(每秒请求数,也就是客人进店的频率)涨上去,单机的显存、算力、内存带宽都会见顶;更致命的是单点故障——机器宕机,服务直接中断。于是有了集群部署:把推理服务复制成多个副本,铺到多台机器上,前面架一个负载均衡网关,像餐厅门口的取号机一样把客人分流到不同座位。

集群架构通常包含三个角色:网关层负责路由与转发;工作节点跑推理服务副本;控制节点监控健康状态。副本从 1 个变成 n 个,整体可用性也随之提升。假设每台机器的故障概率为 p,只要有一台存活服务就可用,那么可用性为:

这就是面馆开分店的逻辑:单店再红火也有客流天花板,把店开到三条街,互相备份,客人去哪家都能吃上面。从单机到集群,不是把锅换大,而是把容量铺开、把风险摊薄。

A=1−pnA = \displaystyle 1 - p^{n}
公式含义:n 台服务器中只要任何一台正常运行,集群就不会完全瘫痪;机器越多,整体越稳。
  1. 单台故障概率 p在一段统计周期内,单台服务器不可用的概率。例如运维记录显示某型号机器约有 10% 的时间在检修或宕机。
    p=0.1p = 0.1
  2. n 台同时故障 p^n所有机器同时不可用的概率,每台机器的故障相互独立,概率要连乘。
    p3=0.13=0.001p^{3} = 0.1^{3} = 0.001
  3. 整体可用性 A只要还有一台机器活着,网关就能把请求送过去,所以用 1 减去“全部瘫痪”这个小概率事件。
    A=1−0.001=0.999A = 1 - 0.001 = 0.999

容器化镜像:中央厨房的标准料理包

面馆开分店时发现一个头疼的问题:每家店的厨师都按自己的习惯熬汤,东边咸、西边淡,配方根本没法统一。张阿姨索性在郊区建了中央厨房,把高汤、面条、浇头全部做成标准化料理包,任何一家分店拆包、加热、出餐,口味完全一致。

推理服务部署遇到的正是同样的问题:开发环境里能跑通的模型,到了生产服务器上常常“水土不服”——CUDA 版本不对、Python 依赖缺失、系统库不一致。容器(Docker)就是那份料理包:把操作系统依赖、运行库、Python 环境、模型权重全部打进一个镜像。镜像到哪儿,服务就能在哪儿跑起来,环境一致性彻底解决。

镜像由一层层文件系统叠加而成,体积直接决定拉取和启动成本:一个塞满 CUDA 全家桶的镜像可能超过 8GB,每台机器都要为这份臃肿买单。优化的核心是看清体积构成:

有了标准料理包,任何一家分店、任何一名新厨师,都能在十分钟内端出同一碗面。容器让“环境”本身变成可复制、可版本管理的资产——镜像就是面馆的秘方档案,锁好版本,谁也不许乱改。

Vimg=Lbase+Ldeps+LappV_{\text{img}} = \displaystyle L_{\text{base}} + L_{\text{deps}} + L_{\text{app}}
公式含义:镜像体积 = 基础层 + 依赖层 + 应用层,每一层都做小,整体才小。
  1. 基础层 L_base镜像的底座,一般是精简版操作系统加 CUDA 运行库,选择越小越好的运行时镜像。
    Lbase=min⁡(Lubuntu,Lalpine)L_{\text{base}} = \min(L_{\text{ubuntu}}, L_{\text{alpine}})
  2. 依赖层 L_deps安装 Python 依赖与系统库,用 requirements.txt 锁定精确版本;依赖不变时该层会被缓存复用。
    Ldeps=install(requirements.txt)L_{\text{deps}} = \text{install}(\text{requirements.txt})
  3. 应用层 L_app业务代码、模型权重与启动脚本放在最上层,这部分改动最频繁。
    Lapp=copy(src)L_{\text{app}} = \text{copy}(src)
  4. 多阶段构建编译阶段产生的临时文件不进入最终镜像,只保留运行所需产物。
    Vfinal=Lbase+Ldeps+LappV_{\text{final}} = L_{\text{base}} + L_{\text{deps}} + L_{\text{app}}

GPU资源调度:大灶台的排班艺术

面馆后厨最值钱的家当是那两口大灶,一个灶眼同一时间只能做一个硬菜。分店多了,灶台怎么分?张阿姨定了规矩:硬菜用大灶,煮面用中灶,焯水用小灶,谁也别占着茅坑不拉屎,一切都听调度员安排。

GPU 就是 AI 服务的“大灶”。一块 A100/H100 动辄数万元,显存 40G 到 80G,是集群里最稀缺的资源。Kubernetes 原生不认识 GPU,需要 NVIDIA Device Plugin 这个“调度员”上报每块卡的显存和数量,调度器才知道机器上有几个灶眼、每个灶眼多大。

部署前先算清一份推理服务要吃多少显存。模型权重是显存大头,KV Cache 和激活值还会带来额外开销,单副本显存需求估算为:

调度员把显存需求写进“预约单”:requests 写清最低要多少显存,limits 写明最多能占多少,调度器像排班一样把副本塞进合适的卡。灶台没空位就排队等待,绝不超卖;多卡并行时则把流量分散到多块卡上,摊薄单卡压力。

Mneed=P×b×(1+k)M_{\text{need}} = \displaystyle P \times b \times (1 + k)
公式含义:单副本显存需求 = 参数量 × 每参数字节数 × (1 + 推理开销率)。
  1. 参数量 P模型的参数个数,7B 就是 70 亿个参数。
    P=7×109P = 7 \times 10^{9}
  2. 每参数字节数 bFP16 精度下每个参数占 2 字节。
    b=2b = 2
  3. 推理开销率 kKV Cache、激活值等推理过程产生的额外显存,经验值约 0.2。
    k=0.2k = 0.2
  4. 显存需求 M三项相乘得到单副本的显存底线。
    Mneed=7×109×2×1.2≈16.8 GBM_{\text{need}} = 7 \times 10^{9} \times 2 \times 1.2 \approx 16.8\text{ GB}

弹性扩缩容:饭点加桌,闲时收桌

面馆的客流有明显潮汐:午市十一点半到一点半爆满,下午三点只有三桌客人。张阿姨如果全天摆满三十张桌,下午空着浪费房租;如果只摆十张,午市客人全跑光。她的办法是:高峰加折叠桌,低谷收桌子。

推理服务的流量同样是潮汐——白天用户密集提问,深夜只有零散请求。固定的副本数要么在低谷浪费 GPU,要么在高峰打满队列。弹性扩缩容(Autoscaling)让副本数跟着流量走,Kubernetes 里的 HPA(Horizontal Pod Autoscaler,水平 Pod 自动扩缩器)就是那个自动收放桌子的服务员。

HPA 周期性采集指标(QPS、GPU 利用率、平均首 token 延迟),把它和目标值比较,按比例调整副本数:

但扩缩容不能太敏感,HPA 有冷却时间与稳定窗口:指标必须连续超过阈值一段时间才动手,避免“加一桌撤一桌”的抖动。同时设定最小/最大副本数,就像面馆备好折叠桌,但不会把整条街都占满。

Rdest=⌈Rcurr×UcurUtarget⌉R_{\text{dest}} = \displaystyle \left\lceil R_{\text{curr}} \times \frac{U_{\text{cur}}}{U_{\text{target}}} \right\rceil
公式含义:期望副本数 = 当前副本数 × 当前指标 ÷ 目标指标,结果向上取整。
  1. 当前副本数 R_curr此刻正在运行的推理服务副本数量。
    Rcurr=4R_{\text{curr}} = 4
  2. 当前指标 U_cur最近采样窗口的平均利用率,例如 GPU 利用率 0.9。
    Ucur=0.9U_{\text{cur}} = 0.9
  3. 目标指标 U_target运维设定的目标利用率,例如 0.75,留出缓冲。
    Utarget=0.75U_{\text{target}} = 0.75
  4. 比值与取整4 × 0.9 ÷ 0.75 = 4.8,向上取整为 5,于是扩容到 5 个副本。
    Rdest=⌈4.8⌉=5R_{\text{dest}} = \lceil 4.8 \rceil = 5

蓝绿发布:不开招牌的试营店

张阿姨想试新菜——藤椒牛蛙面。她不敢直接下掉老菜单,而是在隔壁巷子开了一家“试营店”,招牌先不亮,悄悄试菜一个月。老客人回头说好,她才把老店招牌摘下来,换上新的。

模型服务升级最怕“改坏了”。蓝绿发布的思路一模一样:维持两套完全相同的环境,蓝环境跑线上稳定的旧版本,绿环境部署好新版本,两套都接好数据库和依赖,但只有蓝环境在接客。全部验证通过后,负载均衡网关把流量从蓝切到绿,升级完成。

蓝绿发布把“升级”变成了“切换”,关键在于网关切流。故障影响面被压缩到切换前的验证期:

试营店最大的代价是两套环境同时跑,资源占用翻倍。但对核心业务来说,花两份资源的钱买“一键回滚”的保险,这笔账很划算。面馆的招牌,永远只在验证过的那一边亮着。

Sblast=pnew×fswitchS_{\text{blast}} = \displaystyle p_{\text{new}} \times f_{\text{switch}}
公式含义:故障影响面 = 新版本出问题的概率 × 被切换过去的流量比例。
  1. 新版本故障概率 p_new新版本存在致命缺陷的概率,取决于测试与预发验证的充分程度。
    pnew=0.05p_{\text{new}} = 0.05
  2. 流量切换比例 f_switch暴露给新版本的流量占比,蓝绿发布在验证完成前为 0。
    fswitch=0f_{\text{switch}} = 0
  3. 全量切换后f = 1,影响面等于新版本自身的故障率。
    Sblast=0.05×1=0.05S_{\text{blast}} = 0.05 \times 1 = 0.05
  4. 快速回滚一旦发现问题,把网关再拨回蓝环境,回滚只发生了一次路由变更。
    Trollback=TswitchT_{\text{rollback}} = T_{\text{switch}}

滚动更新:一家一家换菜单

中央厨房的连锁店越开越多,一次性全部换新菜单风险太大。张阿姨改成:第一家店先卖一个礼拜,观察复购率没掉,再通知第二家、第三家跟换。每家店更换期间,旁边门店照常营业。

滚动更新就是把副本逐个替换:Kubernetes 先起一个新版本 Pod,等它通过健康检查、能正常接流量后,再下线一个旧版本 Pod,如此反复直到全部替换完成。整个过程中始终有足够多的“老店”在营业,服务不中断,也不需要两倍资源。

滚动更新的关键参数是 maxUnavailable(允许同时不可用的最大副本比例)和 maxSurge(允许超出期望副本数的最大增量)。每批更新的实例越少,单批失败对整体影响越小:

健康检查探针是滚动更新的“试吃员”:readinessProbe 确认新 Pod 能接客才放流量,livenessProbe 发现异常就自动重启,terminationGracePeriodSeconds 给旧实例优雅告别的时间。一家一家换,每一家都确认吃得好,再动下一家。

Pbatch_fail=1−(1−p)bP_{\text{batch\_fail}} = \displaystyle 1 - (1 - p)^{b}
公式含义:一批 b 个实例中只要有一个失败,该批就视为异常;单批实例越多,整批出错的概率越大。
  1. 单实例失败概率 p新实例启动失败的概率,如镜像拉取失败、探针不通过。
    p=0.01p = 0.01
  2. 单实例成功概率 1-p一个实例正常启动并接入流量的概率。
    1−p=0.991 - p = 0.99
  3. b 个全部成功 (1-p)^b这一批 b 个实例全部正常的概率,独立事件连乘。
    (0.99)3=0.9703(0.99)^{3} = 0.9703
  4. 整批失败概率至少一个失败的补集。
    Pbatch_fail=1−0.9703≈0.0297P_{\text{batch\_fail}} = 1 - 0.9703 \approx 0.0297

AI 应用场景

大模型 ChatBot 的夜间削峰填谷

阶段:部署与运维

解决的问题:C 端大模型应用流量潮汐明显——白天密集提问、深夜几乎无人。固定副本要么在白天排队超时,要么在夜间空转烧 GPU 成本。

具体案例:某创业公司的 13B 对话模型服务,白天部署 8 个副本支撑约 600 QPS,夜间通过 HPA 按 QPS 自动缩到 2 个副本,同时把 GPU 利用率目标设为 0.75 留出峰值缓冲。上线后每月 GPU 成本下降约四成,高峰期 P95 首 token 延迟稳定在 1.5 秒以内。

金融企业私有化知识库的蓝绿发布

阶段:发布与上线

解决的问题:券商内网部署的 LLM 知识库问答涉及合规与业务连续性,升级期间不能中断服务,出了问题必须能秒级回滚。

具体案例:架构团队把新版本部署到绿环境,与蓝环境并行运行一周,用真实业务流量旁路验证答案质量与延迟;确认无回归后,网关在业务低峰期一键切流。回滚演练记录显示,切回蓝环境的全过程只需一次配置变更,耗时约 30 秒。

多团队共享 GPU 资源池的调度

阶段:资源分配

解决的问题:多个算法团队共用 GPU 集群,过去靠人工排申请表分配显卡,要么闲置要么抢破头,谁也不知道哪块卡被谁占着。

具体案例:AI 中台将 A100 集群接入 Kubernetes 与 NVIDIA Device Plugin,每个推理任务在部署清单里声明显存 requests/limits;空闲卡自动回收复用,超额任务排队等待。资源利用率从 30% 提升到 70%,新团队的 GPU 申请从两周缩短到半天。

Python 演示

python34 行
import math def estimate_vram(param_gb, overhead=0.2):    """估算单份推理服务的显存需求(GB): 权重 * (1 + 开销率)"""    return param_gb * (1 + overhead) def hpa_desired(current, metric, target):    """HPA 期望副本数: ceil(当前副本数 * 当前指标 / 目标指标)"""    if target <= 0:        return current    return max(1, math.ceil(current * metric / target)) def schedule_per_gpu(model_gb, vram_per_gpu=80.0):    """GPU 调度: 一张显卡最多能放几个推理副本"""    need = estimate_vram(model_gb)    return max(1, int(vram_per_gpu // need)) def simulate_scaling(traffic_curve, capacity_each, target_util):    """跟随流量曲线模拟弹性扩缩容"""    pods = 2    history = []    for rps in traffic_curve:        util = rps / (pods * capacity_each)        pods = hpa_desired(pods, util, target_util)        history.append((rps, pods, round(util, 3)))    return history if __name__ == "__main__":    weight_gb = 26.0  # 13B params * 2 bytes (FP16)    print(f"13B FP16 model needs about {estimate_vram(weight_gb):.1f} GB VRAM per replica")    print(f"An A100-80G can hold {schedule_per_gpu(weight_gb)} replicas at most")    curve = [50, 120, 300, 600, 900, 400, 100, 40]    for rps, pods, util in simulate_scaling(curve, 200, 0.75):        print(f"rps {rps:>3} | replicas {pods} | util {util:.0%}")
目的:一次性跑通“显存估算 → GPU 调度 → 弹性扩缩容”的整条部署计算链路,输入流量曲线即可观察副本数如何自动调整。
  1. def estimate_vram(param_gb, overhead=0.2):定义显存估算函数,参数是模型权重体积和开销率。
  2. return param_gb * (1 + overhead)对应正文公式 M = P × b × (1+k) 的落地实现。
  3. return max(1, math.ceil(current * metric / target))HPA 核心公式,向上取整且至少保留 1 个副本。
  4. int(vram_per_gpu // need)用整除算出一张卡最多塞几个副本,相当于灶台排班。
  5. util = rps / (pods * capacity_each)计算当前利用率,衡量“客人是否坐满了”。
  6. pods = hpa_desired(pods, util, target_util)每个采样周期调用 HPA 决策,副本数动态变化。

常见误区

误区“我把 CUDA 全家桶、编译工具、各种 Python 包全部打进镜像,这样到任何环境都不会缺东西。镜像大一点没关系,机器硬盘够用。”

正解LLM 服务镜像每胖 1GB,集群里每台机器拉取、存储、启动都要为此付出真金白银;依赖越多,漏洞面越大,启动越慢。正确做法是用多阶段构建只保留运行产物、锁定依赖版本、选用精简基础镜像——料理包只装要下锅的食材,不装整间厨房。

为何常见:开发机上装多了没感觉,单机调试时镜像体积的代价被完全掩盖,只有到了生产集群的大规模分发阶段才暴露。

误区“集群里装了 GPU 驱动,Kubernetes 就能自动识别显卡并给容器分配显存,我不用写任何资源声明。”

正解Kubernetes 默认根本不认识 GPU 资源,必须部署 NVIDIA Device Plugin 上报设备信息;Pod 还要显式声明 nvidia.com/gpu 的 requests/limits,调度器才知道该把副本放到哪张卡上。不声明,要么调度不上,要么超卖挤爆显存。

为何常见:单机上显卡即插即用,让人误以为集群里的 GPU 也天然“即插即用”,忽略了多机资源统一调度的复杂度。

误区“蓝绿发布就是滚动更新的另一种叫法,反正都是换新版本,随便选一个配置就行。”

正解两者机制完全不同:蓝绿发布是两套环境共存 + 网关切流,回滚只要一次切换,代价是双倍资源;滚动更新是同一套环境里分批替换 Pod,节省资源,但回滚必须等批次推进。测试方式、回滚速度、资源成本都不一样,选错会直接抬高发布风险。

为何常见:两者都能做到“不停机发布”,表面效果相似,掩盖了底层机制的差异。

误区“反正集群机器多,把推理服务副本开到最大,QPS 一定最高,出了故障还能互相备份。”

正解副本数受资源总量约束:显存有限、调度器有排队开销、每个模型还有并发上限。副本过多会造成 GPU 碎片化、队列膨胀和成本浪费。正确做法是用 HPA 按 QPS 和 GPU 利用率动态伸缩,最小副本兜底、最大副本限顶,中间留出缓冲。

为何常见:直觉上“多副本 = 更稳”,但没意识到集群资源总量和调度开销都是硬约束。

误区“K8s 的 HPA 默认看 CPU,LLM 服务也照用,CPU 没到 80% 就不需要扩容。”

正解LLM 推理的瓶颈在 GPU 算力与显存,经常出现 CPU 空闲但 GPU 已打满的情况。必须为 HPA 配置自定义指标:QPS、GPU 利用率、平均首 token 延迟,才能真实反映推理服务的繁忙程度。

为何常见:HPA 默认指标就是 CPU,初学者不假思索直接照搬默认配置,忽略了推理场景的硬件特征。

面试题

Q1. 从单机部署升级到集群部署,最核心的驱动力是什么?

单选题 · easy

  • A.单机无法横向扩展且有单点故障风险← 正确答案
  • B.集群部署的代码写起来更加美观
  • C.集群部署后无需再做任何监控
  • D.单机部署无法使用 GPU 加速推理

答案:A。单机部署像一口大锅,锅再大也有客流天花板,而且锅坏了全员歇业。集群把副本铺到多台机器,容量可横向扩展、故障可互相备份。B 与工程质量无关,C 说反了,D 是事实错误——单机完全可以插 GPU。

Q2. Dockerfile 使用多阶段构建的主要收益是什么?

单选题 · mid

  • A.让最终镜像体积明显变得更小← 正确答案
  • B.让模型推理的速度持续变快
  • C.让 GPU 显存占用自动降低
  • D.让容器无需再相互通信

答案:A。多阶段构建像中央厨房做预制菜——编译工具用完即弃,最终只送成品进镜像,体积大幅缩小。B 是运行时优化问题,C 是 GPU 调度问题,D 与镜像构建无关。

Q3. 7B 模型以 FP16 精度推理,权重约占 14GB,按 20% 开销率估算单副本显存需求是多少?

单选题 · mid

  • A.约 14.2 GB
  • B.约 16.8 GB← 正确答案
  • C.约 20.0 GB
  • D.约 28.0 GB

答案:B。套用公式 M = P × b × (1+k):14GB × 1.2 = 16.8GB。A 是忽略了开销率,C 是错把开销直接加在结果上,D 是权重的两倍。

Q4. LLM 推理服务弹性扩缩容可以参考哪些指标?

多选题 · mid

  • A.每秒请求数 QPS← 正确答案
  • B.GPU 利用率与显存占用← 正确答案
  • C.平均首 token 生成延迟← 正确答案
  • D.服务器机房的实时温度

答案:ABC。LLM 推理的瓶颈在 GPU 算力与显存,QPS、GPU 利用率和首 token 延迟都是直接反映服务繁忙程度的信号;机房温度不是业务指标,不能驱动扩缩容。

Q5. 当前运行 4 个副本,采样利用率 0.90,目标利用率 0.75,HPA 计算出的期望副本数是多少?

单选题 · hard

  • A.4 个副本
  • B.5 个副本← 正确答案
  • C.6 个副本
  • D.8 个副本

答案:B。按公式 R = ⌈4 × 0.90 ÷ 0.75⌉ = ⌈4.8⌉ = 5。A 是没触发扩容,C 是把目标利用率当除数算错,D 是倍数放大过度。

Q6. 蓝绿发布中“绿环境”通常指什么?

单选题 · easy

  • A.承载全部线上流量的旧版本
  • B.部署好待验证的新版本环境← 正确答案
  • C.用于存储模型参数的数据库
  • D.负责收集服务日志的组件

答案:B。绿环境是部署了新版本但还没接流量的“试营店”,蓝环境才是当前接客的旧版本。验证通过后网关切流,绿转正、蓝待命。

Q7. 关于蓝绿发布,下列说法正确的有哪些?

多选题 · hard

  • A.新旧两个环境同时并行运行← 正确答案
  • B.流量切换由网关统一完成← 正确答案
  • C.回滚只需将流量切回旧环境← 正确答案
  • D.必须逐台替换全部集群节点

答案:ABC。蓝绿发布是两套环境 + 网关切流,回滚天然快,一次切换就完成;D 描述的是滚动更新的分批替换机制,与蓝绿无关。

Q8. readinessProbe 健康探针的主要作用是什么?

单选题 · mid

  • A.判断容器进程是否还在存活
  • B.判断服务是否就绪并可接流量← 正确答案
  • C.判断 GPU 温度是否超出阈值
  • D.判断镜像版本是否为最新

答案:B。readinessProbe 像试营店门口的试吃员,确认“能接客了”才放流量;判断进程还活着的任务是 livenessProbe,两者职责不同。

Q9. 要让 Kubernetes 感知 GPU 显存资源,需要部署什么组件?

单选题 · mid

  • A.NVIDIA 设备插件负责上报显存← 正确答案
  • B.Prometheus 负责采集监控指标
  • C.Redis 负责缓存高频热数据
  • D.Nginx 负责转发外部请求

答案:A。NVIDIA Device Plugin 是 K8s 与 GPU 之间的“翻译官”,上报显存数量和状态后,调度器才知道哪些节点有空灶台。Prometheus 管监控、Redis 管缓存、Nginx 管流量,都不是 GPU 资源感知组件。

Q10. 滚动更新一批 3 个实例,单实例启动失败概率为 1%,该批中至少一个实例失败的概率约为多少?

单选题 · hard

  • A.约 1.0%
  • B.约 3.0%← 正确答案
  • C.约 5.0%
  • D.约 9.7%

答案:B。P = 1 − (1−0.01)³ = 1 − 0.9703 ≈ 0.0297 ≈ 3.0%。A 是单实例失败率,C 是把 1% 直接乘以 5,D 是 10 个实例整批失败的概率。批次越大,整批风险越集中。