Skip to main content

资源配额:资源算术 / LimitRange / ResourceQuota

覆盖考纲 Workloads and Scheduling(15%) 中「Understand how resource limits can affect Pod scheduling」的资源维度。 Part1 讲的是"怎么用标签/污点/亲和性约束落点",本篇讲的是"资源本身怎么变成一道门槛"。 实验环境:v1.36.3,三节点(master 带 control-plane:NoSchedule),node01/node02 各 4 核 / 7.6Gi


核心认知​

调度器只看 requests,一生都不看 limits。 这句话衍生出三条边界:

字段谁在用什么时候
requestskube-scheduler创建时算账,决定节点能不能进候选池
limitskubelet + cgroup运行中封顶(超内存 OOMKill、超 CPU 节流)
QoS classkubelet 驱逐器节点压力大时决定先杀谁

一句话收口:

requests 管「能不能落地」,limits 管「落地后能不能活」,QoS 管「资源紧张时先杀谁」。

由此可得两个高频误判:

  • limits.cpu: "8" 在 4 核节点上照样调度成功 —— 它只会把节点推到 200% 超卖,风险在运行时不在调度
  • requests 写大了直接 Pending,且 Events 里的原因是 Insufficient cpu,不是"资源不够用"

一、资源算术​

1.1 describe node 三个区块​

Capacity:            物理资源总量(虚拟机看到的值)
Allocatable: 扣掉 kubelet 预留后的可调度量
Allocated resources: 已分配 —— Requests 列才是调度器关心的

调度器算账公式只有一行:

节点剩余 = Allocatable − Σ(该节点所有 Pod 的 requests)

Limits 列不参与这个减法,它只是给人看的超卖风险指标。

1.2 本集群实测​

节点Capacity cpuAllocatable cpu已用 Requests已用 Limits
k8s-master441 (25%)0 (0%)
k8s-node0144550m (13%)200m (5%)
k8s-node0244950m (23%)900m (22%)

两个值得注意的点:

  1. CPU 的 Capacity == Allocatable(4 = 4) → 这台机器的 kubelet 没配任何系统预留(--kube-reserved / --system-reserved 全空),裸装 kubeadm 的默认行为。生产上必须配,否则系统进程和 Pod 抢 CPU 会把节点拖死。
  2. 内存 Capacity 与 Allocatable 差 100Mi → 来自 eviction-hard: memory.available<100Mi,不是预留。

1.3 单位​

CPU:1 核 = 1000m,0.1 = 100m(整数核不写 m)
内存:1Gi = 1024Mi,1G = 1000M

describe node 的百分比分母是 Allocatable,不是 1 核、也不是 Capacity。


二、requests 与 limits 的补齐规则​

这是最容易背错的一节。规则按资源逐个判定(cpu 和 memory 各算各的),不是整体判定。

显式 requests显式 limits结果
✗✗两者都取 LimitRange 默认;无 LimitRange 则为空 → BestEffort
✗✓ 500mrequests := limits = 500m,LimitRange 的 defaultRequest 被绕过
✓ 100m✓ 500m原样保留,校验 requests ≤ limits
✓ 100m✗核心 API 不补 limits(若无 LimitRange 则 limits 为空);有 default 时注入默认值 —— 本次未实测,以官方文档为准

2.1 实测铁证:同一份 resources 走两条规则​

kubectl run pod-d --image=nginx:alpine \
--overrides='{"spec":{"containers":[{"name":"pod-d","image":"nginx:alpine","resources":{"limits":{"cpu":"500m"}}}]}}'

当时命名空间已有 LimitRange(defaultRequest.cpu: 100m、default.memory: 128Mi),实测结果:

{"limits":{"cpu":"500m","memory":"128Mi"},
"requests":{"cpu":"500m","memory":"64Mi"}}
资源你写了什么补出的 requests走哪条规则
cpu只写 limits 500m500mlimit 复制成 request
memory什么都没写64MiLimitRange 的 defaultRequest

官方原文的关键限定词是末尾三个词:

If you specify a limit for a resource, but do not specify any request, and no admission-time mechanism has applied a default request for that resource, then Kubernetes copies the limit you specified and uses it as the requested value.

for that resource —— 逐资源判定,所以 cpu 和 memory 可以走不同的分支。

2.2 QoS 判定​

Guaranteed:每个资源的 requests == limits,且都显式设置
Burstable :至少一个资源设置了 requests/limits,但不满足 Guaranteed
BestEffort:所有资源都没设 requests 和 limits

上例 pod-d 是 Burstable —— 因为 memory 的 64Mi ≠ 128Mi。只要有一个资源不等,整体就不是 Guaranteed。


三、LimitRange:命名空间级的「默认值注入器 + 闸门」​

解决的实际问题:开发者忘写 resources → Pod 变 BestEffort → 大流量时第一个被杀。LimitRange 让管理员在 namespace 层强制兜底。

字段作用
defaultPod 没写 limits 时注入
defaultRequestPod 没写 requests 时注入
max / min闸门:超出直接拒绝创建
maxLimitRequestRatio限制 limits/requests 的比值(防止 requests 写 1m、limits 写 4 核)

3.1 三条行为​

  1. 只在创建时注入,不追溯 —— 加 LimitRange 之前就在跑的 Pod 永远不会被补
  2. 注入会改变 QoS —— 裸 Pod 从 BestEffort 变 Burstable
  3. 由准入控制器 LimitRanger 执行,与调度器无关;Pod 对象压根进不了 etcd

3.2 撞 max 的报错原文​

kubectl run pod-c --image=nginx:alpine \
--overrides='{"spec":{"containers":[{"name":"pod-c","image":"nginx:alpine","resources":{"requests":{"cpu":"100m"},"limits":{"cpu":"2"}}}]}}'
Error from server (Forbidden): pods "pod-c" is forbidden: maximum cpu usage per Container is 1, but limit is 2

句式固定:maximum <资源> usage per Container is <max>, but limit is <写的值>。看到 Forbidden + maximum ... per Container 就是 LimitRange 的 max 拦的,不要去查配额。


四、ResourceQuota:命名空间级总量账簿​

4.1 两类配额​

类型例子记账单位
计算资源requests.cpu / limits.memory资源量(m / Mi / 个数)
对象数量pods / services / pvc个数(每次 +1)

同一个对象里的多种配额各自独立拦截,谁先超谁报错。

4.2 硬绑定:配额要求 Pod 必须写 requests/limits​

这是最容易被忽略的副作用 —— 配额里写了几个计算资源键,就要求 Pod 补几个字段,否则连创建都不允许。

spec:
hard:
requests.cpu: "1"
requests.memory: 1Gi
limits.cpu: "2"
limits.memory: 2Gi
pods: "3"

此时建一个不写 resources 的 Pod:

Error from server (Forbidden): pods "naked" is forbidden:
failed quota: rq-lab: must specify limits.cpu for: naked;
limits.memory for: naked;
requests.cpu for: naked;
requests.memory for: naked

逐段读:

片段含义
Forbidden准入阶段被拒,Pod 没进 etcd,不是调度失败
failed quota: rq-lab拦你的是哪个 ResourceQuota 对象
must specify ... × 4配额写了 4 个计算资源 → 4 个字段全要
for: naked容器名(kubectl run 时等于 Pod 名);多容器会每个列一遍

设计意图很直白:没有 requests 就没法记账,索性拒绝。所以"总量限额"和"逼你写 requests"是同一机制的两面。

4.3 超限额的三段式报错​

pods "pod-big" is forbidden: exceeded quota: rq-lab,
requested: requests.cpu=900m,
used: requests.cpu=200m,
limited: requests.cpu=1
字段含义注意
requested这次 Pod 申请的量保留你写的单位(900m)
used当前已记账的量实时账本,删 Pod 立刻回落
limitedhard 上限显示归一化值(1 而非 1000m),不是单位错

判定条件:used + requested > limited → 拒绝。

对象数量配额报同样的格式:

exceeded quota: rq-lab, requested: pods=1, used: pods=3, limited: pods=3

两个细节:

  • 报错只列真正超限的资源。本例 limits.cpu 没超(400m + 1000m = 1400m ≤ 2),所以一个字都不提
  • describe quota 的 Used 是实时账本,requests.* 和 limits.* 两列各记各的账:
删除 pod-q1 前: limits.cpu 600m  requests.cpu 300m  pods 3
删除 pod-q1 后: limits.cpu 400m requests.cpu 200m pods 2

五、准入链顺序:LimitRange 为什么能和 Quota 配合​

同一句 kubectl run --image=nginx:alpine,两种结果:

无 LimitRange有 LimitRange
结果Forbidden: must specify ...pod created
resources无注入 100m/64Mi + 200m/128Mi

这说明准入链的固定顺序:

Pod 请求 → LimitRanger(补默认值)→ ResourceQuota(拿补好的值记账)→ 写 etcd

反过来不成立 —— 若 Quota 先检查,naked2 一样会被拒。

生产结论:Quota 与 LimitRange 必须成对部署。 只有 Quota 的命名空间,任何忘记写 resources 的 Pod 都建不出来。


六、limits 不参与调度:204% 超卖实测​

kubectl run over-cpu --image=nginx:alpine \
--overrides='{"spec":{"containers":[{"name":"over-cpu","image":"nginx:alpine","resources":{"requests":{"cpu":"100m"},"limits":{"cpu":"8"}}}]}}'

4 核节点上给 8 核 limits,结果:

  • 调度成功,落在 node01,Running
  • QoS = Burstable
  • node01 的 Allocated resources:
cpu   650m (16%)   8200m (204%)

8200m 的来源:8000m(这个 Pod)+ 200m(原有 limits),分母是 allocatable 4000m。

这个值超过 100% 不报错 —— describe node 顶部那句 Total limits may be over 100 percent, i.e., overcommitted. 就是在提示节点级超卖。后果是运行时被 cgroup 节流,不是调度失败。


七、多个候选节点时:打分阶段的两个意外​

实验设计:node01 剩 3350m、node02 剩 3050m,建一个 requests.cpu: 3000m 的 Pod。

直觉:node01 资源更空,应该落 node01。 实测:落在 node02。

原因在于默认打分插件是叠加的,且权重不同:

插件默认权重node01(9 个 Pod)node02(6 个 Pod)
NodeResourcesFit(LeastAllocated)1剩余 CPU 更优剩余 CPU 仅 1.25%
PodTopologySpread2skew 触顶,0 分最空,接近满分

PodTopologySpread 在 Pod 没写任何 topologySpreadConstraints 时也会生效 —— 它有一套默认约束:

maxSkew: 3
topologyKey: kubernetes.io/hostname
whenUnsatisfiable: ScheduleAnyway

三台节点的 Pod 数是 node01=9 / node02=6 / master=8,差值正好撞上 maxSkew: 3。归一化后 spread 的分差(× 权重 2)远超资源分差(× 权重 1),于是 node02 胜出。

这是推断,依据是 Pod 计数差正好等于 maxSkew、以及默认插件权重表。直接观测需要把调度器日志开到 --v=5 以上(要重启调度器),未做。

可操作结论:默认调度器不会把 Pod 放到"资源最空"的节点。 要指定落点必须用 nodeSelector / nodeAffinity / nodeName。

7.1 硬门槛优先于打分​

同一实验把 requests 改成 3100m(node02 剩 3050m 放不下,node01 剩 3350m 放得下):

  • 结果必然落 node01
  • 不是因为 node01 打分高,而是 node02 在 Filtering 阶段就出局,只剩一个候选
Filtering(资源硬门槛) → 决定谁能进候选池
Scoring(多个候选时) → 决定最终去哪

7.2 Insufficient cpu 的报错原文​

requests.cpu: 3600m,两个 worker 都放不下:

0/3 nodes are available:
1 node(s) had untolerated taint(s), ← k8s-master
2 Insufficient cpu. ← node01 剩 3450m、node02 剩 3050m
no new claims to deallocate,
preemption: 0/3 nodes are available:
1 Preemption is not helpful for scheduling,
2 No preemption victims found for incoming pod.
  • 1 + 2 = 3,各项相加必须等于节点总数
  • preemption: 段是抢占也失败:master 上抢占绕不过污点;worker 上找不到"优先级更低可被驱逐"的受害者
  • 默认调度器不会为了普通 Pod 杀别人的 Pod

八、QoS 与调度的边界​

QoS 不参与调度决策,只决定节点资源紧张时的驱逐顺序:

BestEffort(最先被杀)→ Burstable(超 requests 的部分)→ Guaranteed(最后)

所以"设了 limits 就安全"是错的 —— requests == limits 的 Guaranteed 才是最后被驱逐的那档,而它是否被调度上去,仍然由 requests 决定。


踩坑实录​

① patch sc 式的假验证:kubectl patch 返回 no change 说明没发请求 同类问题:验证 LimitRange 是否追溯时,不要只看新 Pod —— 必须对比"加之前建的"和"加之后建的"两个 Pod。

② 把"limit 复制成 request"当成全局规则 实测打脸:同一份 resources 里 cpu 走复制、memory 走 LimitRange 默认值。规则是逐资源的。

③ limited: requests.cpu=1 被误读成单位错误 limited 显示的是归一化后的数值(1 核),不是 1000m。不要以为报错把单位弄丢了。

④ 只看 Type: Warning 会漏配额错误 Forbidden 是 apiserver 直接返回的 HTTP 错误,不是 Event —— 在 kubectl get events 里根本找不到。配额/LimitRange 类问题只能看命令输出,不能看 Events。这是它和"PVC Pending"最大的区别。

⑤ 用 kubectl run 建带 resources 的 Pod,容器名对不上 --overrides 会整个替换 containers 数组,所以里面的 name 必须和 Pod 名一致,否则 kubectl run pod-x 会变成两个容器(一个无 resources、一个有)。

⑥ 计算 limits 百分比时分母搞错 cpu: 8 在 4 核节点上是 8000m / 4000m = 200%,不是 800%。分母永远是 allocatable。


复习自测题(答案)​

Q1:Pod 只写了 limits.cpu: 500m,命名空间有 defaultRequest.cpu: 100m,最终 requests.cpu 是多少?

500m。limit 复制成 request 的规则优先于 LimitRange 的 defaultRequest,且只对 cpu 这一个资源生效;同一 Pod 里没写过的 memory 才会走 defaultRequest。

Q2:为什么加了 ResourceQuota 之后,原本能建的裸 Pod 建不了了?

配额里包含 requests.cpu / limits.cpu 等计算资源键时,K8s 要求 Pod 显式声明对应字段 —— 否则无法记账。报错是 must specify <字段> for: <容器名>。

Q3:describe node 显示 cpu 8200m (204%) 意味着什么?会有什么后果?

节点级超卖:所有 Pod 的 limits 之和是 allocatable 的 2 倍。调度不受影响(limits 不参与),后果是 CPU 竞争时被 cgroup 节流,延迟升高。

Q4:两个节点都能放下 Pod,一个资源更空、一个 Pod 数更少,默认会选哪个?

多半是 Pod 数更少的那个。PodTopologySpread 的默认软约束(maxSkew 3 / hostname / ScheduleAnyway)权重为 2,高于 NodeResourcesFit 的 1。

Q5:requests.cpu: 3600m 的 Pod Pending,Events 说 2 Insufficient cpu,能不能靠调低 limits 解决?

不能。limits 不参与 Filtering。要么调低 requests,要么腾出节点资源,要么加节点。

Q6:LimitRange 能改掉已经在跑的 Pod 的 resources 吗?

不能。注入只发生在创建时的准入阶段,对已存在对象无追溯能力。

Q7:Forbidden: maximum cpu usage per Container is 1, but limit is 2 是谁拦的?

LimitRange 的 max,由准入控制器 LimitRanger 执行。与 ResourceQuota 无关 —— 配额超限的措辞是 exceeded quota。


速记卡片​

# ── 资源算术 ──────────────────────────────
kubectl describe node <node> | sed -n '/Allocated resources:/,/Events:/p'
kubectl get node <node> -o custom-columns=\
'NAME:.metadata.name,CPU:.status.allocatable.cpu,MEM:.status.allocatable.memory'

# 剩余 = Allocatable − Σ requests(Limits 列不参与)

# ── LimitRange ──────────────────────────
kubectl get limitrange -n <ns> -o yaml
kubectl describe limitrange -n <ns> <name>

# 报错特征
# maximum <res> usage per Container is <max>, but limit is <val>

# ── ResourceQuota ───────────────────────
kubectl get resourcequota -n <ns>
kubectl describe quota -n <ns> <name> # Used / Hard 实时账本
kubectl get quota -n <ns> -o json | jq '.items[].status'

# 报错特征
# must specify <字段> for: <容器名> ← 硬绑定
# exceeded quota: <name>, requested: ... used: ... limited: ... ← 超限三段式

# ── 带 resources 的 kubectl run ─────────
kubectl run p --image=nginx:alpine --overrides='
{"spec":{"containers":[{"name":"p","image":"nginx:alpine",
"resources":{"requests":{"cpu":"100m","memory":"64Mi"},
"limits":{"cpu":"200m","memory":"128Mi"}}}]}}'

# ── 判定口径 ────────────────────────────
# 调度只看 requests
# 超卖只看 limits(>100% 也合法)
# QoS 决定驱逐顺序,不决定落点
# 准入链:LimitRanger → ResourceQuota → etcd