《Kubernetes 分布式系统原理深入解析》8.1 requests/limits:CPU 可压缩、内存不可压缩

requests 是调度保证,limits 是运行上限:CPU 超限被节流(可压缩),内存超限被 OOM 杀进程(不可压缩)。本节讲清二者的语义差异、单位换算,以及『调度只看 requests、限制由 kubelet 强加』的两阶段契约。lab 用 resmodel 包验证 CPU 可压缩、内存不可压缩与装不下的判定。

8.1 requests/limits:CPU 可压缩、内存不可压缩

把 Pod 的资源声明拆成两个词,是理解整个第 8 章的关键:requests 是『保证』,limits 是『上限』。二者语义不同、执行主体不同、后果不同。本节先讲清两个契约,再聚焦那条最本质的分水岭——CPU 可压缩、内存不可压缩——最后给出调度与运行的两阶段模型。

顺着这条主线先立一个结论:分布式系统的资源管理,本质是回答三个问题——把工作放哪(调度)、允许它用多少(上限)、用超了怎么办(后果)。requests 回答第一个,limits 回答后两个。第 8 章后续的超额分配、装箱、PodOverhead,都是围绕这三个问题展开的取舍。

requests:调度器的保证契约

requests 回答的是「调度器该给这个 Pod 留多少位置」。调度器在 Filter 阶段把 Pod 的 requests 当作最低需求:节点 allocatable 减去已调度 Pod 的 requests 之和,剩余必须装得下新 Pod 的 requests,否则拒绝。

requests 的四个下游消费方值得记牢:

消费方用 requests 做什么
调度器Fit 检查、Score 评分(LeastRequested/MostRequested)
kubelet设置 cgroup CPU 权重(cpu.weight / cpu.shares)
驱逐管理器计算内存超用(usage > requests 才按顺序驱逐)
HPA/VPA目标利用率、资源画像的基准

requests 是保证:调度器承诺节点上至少有这么多资源可被这个 Pod 使用。它不代表实际用量,实际用量可能远低于或偶尔超过它。

调度数学很简单,但含义很深:设节点 allocatable 为 A,已调度 Pod 的 requests 之和为 R,新 Pod requests 为 r,则必须满足 R + r ≤ A。注意这里是 requests 的加和,不是实际用量的加和——这正是 8.2 节超额分配得以成立的前提:多个 Pod 的保证可以叠加在同一个物理容量上,因为它们的实际用量通常不会同时打满。

limits:kubelet 的上限契约

limits 回答的是「这个 Pod 最多能用多少」。它由 kubelet 在运行时强加:kubelet 把 limits 写入容器 cgroup 的配额字段,内核据此执行上限。

  • CPU limits → CFS 配额:cgroup 内 cpu.max(cgroup v2)或 cpu.cfs_quota_us / cpu.cfs_period_us(v1),超过配额的调度时间被节流。
  • 内存 limits → cgroup 内存上限:cgroup v2 的 memory.max,容器内进程内存总量超过上限后,内核在该 cgroup 内挑进程杀掉(OOM)。

limits 是上限:它不保证有这么多可用,只保证不能超。requests 与 limits 可相等(Guaranteed QoS)、可留差(Burstable),也可都不设(BestEffort)。第 9 章会展开这三类 QoS。

limits 的另一个角色是保护邻居:一个内存泄漏的容器若没有 limits,可能吃光节点内存、连累同节点的其他 Pod 甚至 kubelet。limits 把故障半径圈在一个 cgroup 内——超限最多杀这个 cgroup 里的进程,不让它拖垮整台机器。从这个角度,limits 是集群级安全网在节点上的落地。

CPU 可压缩:CFS 配额与节流

可压缩资源(compressible resource)的含义:超过 limits 时,系统能把它「压缩」——降低供给、让请求排队,而不是销毁工作。CPU 就是这样:

  • 内核 CFS 保证:节点上所有可运行线程按权重共享 CPU;单个 Pod 的 cpu.max 配额限制其最大可用时间片。
  • 一个 2 核 limit 的容器,cgroup 配额为「每 100ms 周期最多 200ms」;实际需求超过配额时,线程被节流(throttled),进程不会死,只是变慢。
  • cpu.stat 里 nr_throttled 与 throttled_time 累计节流次数与时长,是排查「明明有 CPU 却跑得慢」的第一手证据。

关键推论:CPU 超限的代价是性能降级,不是可用性丧失。这为 8.2 节的 CPU 超卖提供了安全垫——即使全部 Pod 同时打满,也不过是大家一起被节流,谁都不会被杀。

举一个具体数字:一个容器 limits.cpu: 2,cgroup v2 里表现为 cpu.max 为 200000 100000(每 100ms 周期最多 200ms 运行时间)。当容器实际需要 3 核时,内核把它压到 2 核的配额,cpu.stat 的 throttled_time 持续增长。观察到 throttled_time 大,说明容器正在被限流,通常意味着 requests 估低了或该扩容副本数——这是性能问题的第一排查点。

CPU 配额还有个容易被忽略的细节:limits 不设(quota 无限)时,容器最多能用满整个节点的 CPU。若一个节点上所有 Pod 都不设 CPU limits,抢 CPU 就退化成内核 CFS 按权重分配——权重又由 requests 决定。所以即使不设 limits,requests 依然在起作用。

内存不可压缩:超限即 OOM

不可压缩资源(incompressible resource)的含义:超过上限时没有东西可回收来「压缩」,只能销毁申请者。内存就是这样:

  • 容器 cgroup 内存达到 memory.max 后,内核先尝试回收页缓存;回收不掉时,内存控制器在该 cgroup 内按 oom_score 选择一个进程,发 SIGKILL。
  • 被杀的容器以 OOMKilled 退出,exitCode 通常为 137(128 + SIGKILL 的 9),kubectl describe pod 的 Last State 里 reason: OOMKilled。
  • 与 CPU 节流不同,内存超限是进程死亡——无宽限、无优雅终止、不给你处理完手头请求的机会。

所以内存 limits 是「硬边界」:宁可在 8.2 节把 CPU 分得紧一点,也不要让内存 requests 之和超过节点容量。

要区分两种内存压力来源,排障方向完全不同:

压力来源触发受害者信号
容器超自己的 limitscgroup memory.max 超限该 cgroup 内进程OOMKilled,节点内存可能还充裕
节点内存耗尽节点整体不足任意进程(按 oom_score)系统 OOM,可能波及非容器进程

第一种是「自找的」,限制收得太紧或真实需求超过声明;第二种是「共担的」,节点整体容量规划失当。kubectl describe pod 看 OOMKilled 判第一种,kubectl top node 看内存水位判第二种。9.3 节会把这种区分讲成主动驱逐与内核 OOM 的协同。

单位与换算

资源声明用 resource.Quantity 字符串,Kubernetes 内部按整数纳核/字节处理:

资源写法换算
CPU1000m = 1 核;500m = 0.5 核1 与 1000m 等价,m 表示毫核
内存128Mi、1Gi、256Ki二进制:Mi = 2²⁰,Gi = 2³⁰
内存(十进制)1MB、1GB十进制:MB = 10⁶,注意与 Mi 相差约 4.8%
ephemeral-storage1Gi与内存同套 Quantity 解析

容易踩的坑:128Mi = 134217728 字节,而 128MB = 128000000 字节,两者不是一回事。二进制单位用 Ki/Mi/Gi,十进制用 K/M/G。CPU 只认核/毫核,没有二进制一说;0.5 即 500m。写错单位(如把 Gi 写成 GB)不会报错,但会让调度与运行对「有多少」的认知错位一整截。

一个典型声明示例:

resources:
  requests:
    cpu: "500m"        # 0.5 核保证
    memory: "128Mi"    # 134217728 字节保证
  limits:
    cpu: "2"           # 2 核上限,超过则节流
    memory: "1Gi"      # 1073741824 字节上限,超过则 OOM

换算练习:1Gi / 128Mi = 8,说明这个容器的内存上限是请求保证的 8 倍。ratio = limits / requests 越大,运行时能临时借用的余量越多,但被 OOM 的落差也越大——第 9 章会看到这个比值直接影响 QoS 分类与 OOM 得分。

为什么调度只看 requests

调度器 Filter/Score 只把 requests(加上 PodOverhead,见 8.3 节)计入节点占用,不看 limits。这不是实现偷懒,而是三个必然:

  1. 语义不匹配:调度要回答「有没有位置放」,这由保证量决定;limits 是上限,说明「最多用多少」,不回答「占多少位置」。
  2. 信息不可得:调度器是全局组件,不知道节点上每个 Pod 的实时用量;按 limits 调度意味着假设所有 Pod 同时打满,集群会被巨大的上限撑爆。
  3. 执行主体分离:limits 的强制执行发生在节点上的 kubelet(写 cgroup),不是调度器。调度管「放不放」,kubelet 管「跑不跑得过」。

这也解释了为什么 requests 改变会触发重调度/驱逐,而只改 limits 一般不会——请求量改变的是契约本身。

还有一层:requests 决定 QoS 分类,进而决定驱逐顺序与 OOM 得分(第 9 章)。一个 requests == limits 的 Pod 是 Guaranteed,另一个 requests: 0 的 Pod 是 BestEffort;节点压力来临时,后者的命运显著更脆。同一个 limits 值,配不配 requests,产生的是两种完全不同的运行保证——这也是为什么「只设 limits」常是事故源头。

CPU 可压 + 内存不可压:一张对比表

维度CPU内存
压缩性可压缩不可压缩
超限后果CFS 节流,变慢内核 OOM,杀进程
是否死亡否,性能降级是,容器重启/失败
内核机制cpu.max(配额)memory.max(硬上限)
可回收物无(时间片共享)页缓存可先回收
调度依据requestsrequests
运行强制限流兜底OOM 兜底
超卖可行性可以(8.2 节)不可以(会死)

这张表是资源模型的心理模型:CPU 给你三次机会(节流、等待、降级),内存只给一次(死)。

两阶段契约:调度决策与运行强制的分工

把第 8 章的资源模型收成一个两阶段模型:

阶段一:调度(Scheduler)——声明式、静态、基于保证。

  • 输入:Pod requests + overhead。
  • 输出:绑定到某节点。
  • 判定:allocatable ≥ Σ已调度 requests + 新 Pod requests。

阶段二:运行(Kubelet/内核)——命令式、动态、基于实际用量。

  • 输入:Pod limits、实时用量。
  • 输出:节流、驱逐、OOM。
  • 判定:用量与 cgroup 配额比对。

两阶段通过同一份 YAML 耦合:调度器读 requests 定位置,kubelet 读 limits 定边界。理解这层分工,就能解释 9.3 节的「主动驱逐 vs 内核 OOM」——那是阶段二的两种失败处理。

两阶段还有一个不对称:阶段一是原子的,阶段二是渐进的。调度决定一次性做出(绑定即生效);运行期则是持续的、按秒观察的——kubelet 周期性检查节点压力、cgroup 配额随时被内核强制执行。设计上把「一次性放行」和「持续执法」拆开,正是为了给中间层(8.2 的超额分配、8.3 的 PodOverhead)留出可控的空间。

实战决策清单:怎么定 requests 与 limits

把前面的语义落到操作,一份可照抄的决策流程:

工作负载形态requests 建议limits 建议
无状态在线 API基线用量的 1.2–1.5 倍基线用量的 3–4 倍,留突发
批处理/离线任务接近峰值(反正按保证调度)等于 requests,防串扰
内存密集计算峰值内存 + 余量峰值 + 余量(不能超卖)
你还没画像的工作先不设 limits,用 VPA 画像后续按第 12 章补齐

决策要点:requests 决定你给调度器的承诺,设高了浪费节点、设低了自找驱逐;limits 决定你给自己圈的上限,设低了天天 OOM、设高了等于没设。没有监控数据时,先用 VPA 的 Recommender 画像(第 12 章),再人工复核,而不是拍脑袋。

三个常见误解

  • 「requests 设得越低越省资源」——错误。requests 是保证契约,设低会让调度器把更多 Pod 塞进同一节点;真实负载一上来,节点内存先到 OOM、CPU 先被节流,驱逐与重启反而浪费更多。正确姿势:requests 按「峰值稳定用量」设,limits 按「可容忍的突发上限」设,而不是反过来。
  • 「limits 超了只是给个警告」——错误。CPU 超限直接节流(性能掉下去),内存超限直接 OOMKilled——没有警告,只有后果。正确姿势:把 limits 当故障保险来设,当「推荐值」来设必然两头落空。
  • 「设了 limits 就等于有保障」——错误。limits 是上限不是预留。一个 limits: 8Gi 但 requests: 0 的 Pod 随时可能被调到一个没有 8Gi 余量的节点,然后因为别人占满内存而被驱逐。正确姿势:要保障就用 requests(并配上 QoS),limits 只回答「最多多少」。

一句话总结本节

requests/limits 的分工就是资源模型的核心:requests 管「保证多少、调度依据」由调度器消费,limits 管「最多多少、强制边界」由 kubelet/内核执行;CPU 可压缩(超限节流不杀),内存不可压缩(超限 OOM 必杀),这决定了后两节的策略:CPU 可以超卖装箱,内存必须留够。

本节 lab

本节把「CPU 可压缩、内存不可压缩、装不下」落到 resmodel/resmodel.go 的 Compressible 与 Fit:

cd private/labs/k8s-sched-lab
go test ./resmodel -run 'TestCompressibleOnlyCPU|TestMemIncompressibleBlocksFit' -v

TestCompressibleOnlyCPU 验证只有 CPU 可压缩;TestMemIncompressibleBlocksFit 验证内存 Allocated+requests 超容量时 Fit 返回假——正是「内存不可超卖、必须留够」的可运行证明。resmodel 包共 6 个用例,全部通过。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图