Kubernetes 架构与核心概念深度解析
你在白板上给新同事讲 K8s 架构,画了 apiserver、etcd、scheduler 几个方框和箭头。同事问:"当我执行 kubectl apply 之后,这个 YAML 到底经过了哪些组件、每一步做了什么?" 你发现自己只能说出"apiserver 收到请求,存到 etcd,scheduler 调度,kubelet 拉起容器"——但中间的 Watch 怎么工作、Informer 为什么存在、iptables 规则怎么生成,全是模糊的。
本篇的目标:读完后你能在白板上画出 K8s 的完整架构,并向任何人解释清楚一个 Pod 从创建到接收流量的每一步。
1. Kubernetes 架构全景
1.1 整体架构:Control Plane vs Data Plane
Kubernetes 采用经典的 主从架构(Master-Worker),在逻辑上分为两大平面:
graph TB
subgraph CP["Control Plane"]
etcd
apiserver["kube-apiserver"]
cm["controller-manager"]
scheduler["kube-scheduler"]
ccm["cloud-controller-mgr"]
end
subgraph DP["Data Plane (Node 1 / Node 2 / Node 3 / ...)"]
kubelet
kproxy["kube-proxy"]
runtime["Container Runtime"]
end
apiserver <-->|"Watch / API"| kubelet
kubelet -->|"CRI"| runtime
apiserver --> etcd
cm --> apiserver
scheduler --> apiserver
ccm --> apiserver
kproxy --> apiserverControl Plane(控制平面) 负责集群的全局决策——哪些 Pod 应该运行、运行在哪里、什么状态是期望的。
Data Plane(数据平面) 负责实际执行——运行容器、转发网络流量、挂载存储。
一个关键的架构约束:所有组件都只与 apiserver 通信,不会直接互相调用。这是一个典型的 Hub-and-Spoke(轴辐式)架构,apiserver 是唯一的"真相之源(Source of Truth)"。为什么这样设计?因为如果 scheduler 直接告诉 kubelet "启动这个 Pod",那么当 scheduler 挂了、或者消息丢了,这个指令就丢失了,没人知道它曾经存在过。但如果 scheduler 只是往 apiserver 写一条记录"Pod X 应该跑在 Node Y 上",那么这条信息被持久化在 etcd 里,即使 scheduler 重启,kubelet 重启,这条记录依然在,系统最终会收敛到正确状态。
1.2 声明式 API 与控制循环的设计哲学
Kubernetes 最核心的设计哲学可以归结为一句话:声明式(Declarative)而非命令式(Imperative)。
用户不会告诉 K8s "启动一个容器",而是告诉它 "我期望有 3 个 nginx Pod 在运行"。这个区别看似微小,但在分布式系统中意义深远。
想象一个命令式的场景:你告诉系统"启动 3 个容器"。系统执行了,但其中一个容器 OOM 被杀了。系统不知道你的意图是"始终保持 3 个",它只知道你说过"启动 3 个"——这个命令已经执行完了。要修复,你得再发一条"启动 1 个"的命令。谁来发?什么时候发?如果发命令的人也挂了呢?
声明式彻底解决了这个问题:你的意图"我要 3 个 nginx Pod"被持久化在系统中。任何时刻,系统都可以比较"当前有几个"和"期望有几个",自动修复差异。这带来三个根本性的优势:
- 幂等性(Idempotency):同一声明提交多次,系统状态不变。你可以放心地重复
kubectl apply,不用担心副作用 - 自愈能力(Self-healing):系统持续将实际状态向期望状态收敛。容器崩了会重启,Node 挂了会迁移
- 可组合性(Composability):多个 Controller 可以独立工作,各自负责一类资源,互不干扰
这通过 Reconciliation Loop(调和循环) 实现:
for {
desired := getDesiredState() // 从 apiserver 获取期望状态
current := getCurrentState() // 观察实际状态
diff := compare(desired, current)
if diff != nil {
reconcile(diff) // 执行动作使 current → desired
}
}
这个模式在 K8s 源码中被称为 Level-triggered(电平触发),与 Edge-triggered(边沿触发)相对。两者的区别用一个类比:
- Edge-triggered:你的手机收到一条推送通知。如果你没看到这条通知(比如手机静音了),这个事件就丢失了。系统只在"状态变化的瞬间"触发一次。
- Level-triggered:你打开手机看未读消息列表。不管之前发生了什么,你总能看到当前的全部未读消息。系统根据"当前状态"做决策,不依赖历史事件。
K8s 选择 Level-triggered 的原因很直接:在分布式系统中,消息丢失、网络分区、进程重启是家常便饭。如果你的 Controller 依赖"每个事件都不能错过",那它迟早会出问题。但如果 Controller 每次都看"当前状态是什么,期望状态是什么",那即使错过了 100 个事件,下次循环时依然能发现差异并修复。
1.3 端到端场景:一个 Deployment 从创建到接收流量
理论讲完了,我们用一个完整的场景把所有组件串起来。当你执行 kubectl apply -f deployment.yaml(3 个 nginx 副本)后,从按下回车到 Pod 开始接收流量,中间到底发生了什么?
graph TB kubectl["kubectl apply"] -->|"1. POST /apis/apps/v1/.../deployments"| apiserver apiserver -->|"2. 认证→授权→准入→持久化"| etcd["etcd"] apiserver -->|"3. Watch 通知"| dc["Deployment Controller"] dc -->|"4. 创建 ReplicaSet"| apiserver apiserver -->|"5. Watch 通知"| rsc["ReplicaSet Controller"] rsc -->|"6. 创建 3 个 Pod"| apiserver apiserver -->|"7. Watch 通知"| sched["Scheduler"] sched -->|"8. 绑定 Pod 到 Node"| apiserver apiserver -->|"9. Watch 通知"| kubelet["kubelet"] kubelet -->|"10. CRI: 创建容器"| runtime["Container Runtime"] kubelet -->|"11. 上报 Pod Ready"| apiserver apiserver -->|"12. Watch 通知"| ep["Endpoint Controller"] ep -->|"13. 更新 EndpointSlice"| apiserver apiserver -->|"14. Watch 通知"| kproxy["kube-proxy"] kproxy -->|"15. 更新 iptables/IPVS 规则"| iptables["网络规则生效"]
逐步拆解:
第 1 步:kubectl 发送请求。kubectl 读取你的 YAML,通过 kubeconfig 中的认证信息,向 apiserver 发送一个 HTTP POST 请求。
第 2 步:apiserver 处理请求。请求经过认证(你是谁?)→ 授权(你能创建 Deployment 吗?)→ Mutating Admission(自动填充默认值,比如未指定的 strategy 设为 RollingUpdate)→ Schema 校验(字段合法吗?)→ Validating Admission(策略检查)→ 写入 etcd。至此,一个 Deployment 对象诞生了。
第 3-4 步:Deployment Controller 被唤醒。它通过 Watch 机制实时监听 Deployment 的变化。收到新 Deployment 后,它检查是否已有匹配的 ReplicaSet。没有,于是创建一个 ReplicaSet(replicas=3,Pod template 来自 Deployment)。注意:Deployment Controller 不创建 Pod,它只管 ReplicaSet。
第 5-6 步:ReplicaSet Controller 被唤醒。它发现这个 ReplicaSet 期望 3 个 Pod,但当前有 0 个。于是创建 3 个 Pod 对象(此时 Pod 的 spec.nodeName 为空——还没被调度)。
第 7-8 步:Scheduler 被唤醒。它发现 3 个 nodeName 为空的 Pod。对每个 Pod,Scheduler 执行 Filter(排除不满足条件的 Node)→ Score(给候选 Node 打分)→ 选出最优 Node → 写入 Pod 的 spec.nodeName。
第 9-10 步:kubelet 被唤醒。每个 Node 上的 kubelet 只 Watch 分配给自己 Node 的 Pod。当它发现有新 Pod 绑定到自己时,开始实际工作:创建 Pod Sandbox(Pause 容器 + Network Namespace)→ 拉取镜像 → 通过 CRI 启动容器 → 运行 Startup Probe → Readiness Probe 通过后标记 Pod 为 Ready。
第 11-13 步:Pod Ready,加入 Service 后端。kubelet 将 Pod Status 更新为 Ready。Endpoint Controller 监听 Pod 变化,发现有新的 Ready Pod 匹配了某个 Service 的 Label Selector,于是将这个 Pod 的 IP 加入对应的 EndpointSlice。
第 14-15 步:网络规则更新。kube-proxy 监听 EndpointSlice 变化,更新本 Node 的 iptables/IPVS 规则。至此,发往 Service ClusterIP 的流量可以被转发到新 Pod。
整个过程大约 2-5 秒(取决于镜像是否需要拉取)。注意一个关键特征:没有任何组件直接"指挥"另一个组件。每个组件都只是:Watch apiserver → 发现差异 → 采取行动 → 写回 apiserver。这就是声明式 + 控制循环的威力。
2. Control Plane 组件深度解析
2.1 kube-apiserver
kube-apiserver 是整个 K8s 集群的神经中枢。它是唯一直接读写 etcd 的组件,所有其他组件都通过它来获取和修改集群状态。
2.1.1 RESTful API 设计与资源模型
K8s 的 API 遵循 RESTful 规范,每个资源由两套坐标系定位:
- GVR(Group / Version / Resource):API 路径维度,如
apps/v1/deployments - GVK(Group / Version / Kind):对象类型维度,如
apps/v1/Deployment
为什么需要两套坐标?因为它们解决不同的问题。GVR 告诉你"API 端点在哪"——你要往哪个 URL 发请求。GVK 告诉你"这个对象是什么类型"——当你拿到一个 JSON/YAML 对象,它的 apiVersion + kind 字段就是 GVK。两者通过 RESTMapper 映射。
实际例子:当你输入 kubectl get deploy,kubectl 需要把 deploy 这个缩写转换成完整的 API 路径。过程是:
- kubectl 向 apiserver 的
/apis发现端点查询所有已注册的 API 资源 - RESTMapper 找到
deploy→deployments→ GVRapps/v1/deployments(namespaced 资源) - 构造完整路径:
GET /apis/apps/v1/namespaces/{ns}/deployments
一个典型的 API 路径结构:
/apis/{group}/{version}/namespaces/{namespace}/{resource}/{name}
/apis/apps/v1/namespaces/default/deployments/nginx
核心资源组(Core Group,如 Pod、Service、ConfigMap)有特殊的路径——不含 group 前缀:
/api/v1/namespaces/default/pods/nginx
这是历史原因:K8s 最早只有一个 API 组,后来才引入了 API Group 的概念来组织不断增长的资源类型。
Discovery Cache:kubectl 会把 API 发现信息缓存到 ~/.kube/cache/discovery/。如果你刚安装了一个 CRD 但 kubectl get 报 "resource not found",可能是缓存过期了,删掉缓存目录即可。
2.1.2 请求处理链路
每个到达 apiserver 的请求都经历一条精心设计的处理链路。我们用一个具体场景来走一遍:你执行 kubectl apply -f pod.yaml 创建一个 Pod,这个请求在 apiserver 内部会经历什么?
graph TB Request --> authn["Authentication(认证)
X.509 / Token / OIDC / Webhook"] authn --> authz["Authorization(授权)
RBAC / ABAC / Node / Webhook"] authz --> mutating["Mutating Admission(变更准入)
注入 sidecar / 设置默认值"] mutating --> validation["Schema Validation(Schema 校验)
OpenAPI v3 校验"] validation --> validating["Validating Admission(验证准入)
策略检查 / 安全检查"] validating --> etcd["etcd Write(持久化)"]
第 1 关:Authentication(认证)——"你是谁?"
apiserver 支持多种认证方式,按顺序依次尝试,任何一种通过即可:
- X.509 客户端证书:kubectl 默认方式,证书中的 CN 字段是用户名,O 字段是组名
- Bearer Token:ServiceAccount 的 JWT Token,Pod 内访问 apiserver 用这种方式
- OIDC:对接企业身份系统(如 Google、Azure AD),适合多人团队
- Webhook Token Review:自定义认证服务,apiserver 将 token 转发给外部服务验证
认证通过后,请求被标记为某个用户身份(如 system:serviceaccount:default:my-app 或 jane@company.com)。
第 2 关:Authorization(授权)——"你能做这个操作吗?"
apiserver 检查"用户 X 能否对资源 Y 执行操作 Z"。最常用的是 RBAC(Role-Based Access Control):
# "developer" 角色可以在 default namespace 中 get/list/watch pods
kind: Role
rules:
- apiGroups: [""]
resources: ["pods"]
verbs: ["get", "list", "watch"]
其他授权模式包括 ABAC(基于属性)、Node(专门限制 kubelet 权限)、Webhook(外部授权服务)。
第 3 关:Mutating Admission——"让我改改你的请求"
这是 K8s 可扩展性的关键入口。Mutating Admission Webhook 可以在资源写入 etcd 之前修改它。最经典的例子是 Istio 的 sidecar 注入:你提交一个只有 1 个容器的 Pod,经过 Istio 的 Mutating Webhook 后,Pod 被自动注入了 Envoy sidecar 容器——你甚至不用改自己的 YAML。
其他常见用途:
- 自动添加 Label/Annotation(如注入环境标识)
- 为没有设置
resources.requests的容器自动填充默认值 - 将
latest镜像标签替换为具体 digest
第 4 关:Schema Validation——"你的字段都合法吗?"
基于 OpenAPI v3 Schema 校验资源对象的结构。比如 spec.replicas 必须是非负整数,spec.containers 不能为空。
第 5 关:Validating Admission——"策略允许吗?"
与 Mutating 不同,Validating Webhook 只能拒绝或放行,不能修改资源。典型用途:
- 禁止使用
latest镜像标签 - 强制所有容器设置 resource limits
- 禁止创建 LoadBalancer 类型的 Service(成本控制)
为什么 Mutating 在前、Validating 在后? 因为 Validating 需要看到最终的资源状态。如果顺序反了,Validating 可能放行了一个 Pod,但随后 Mutating 往里面注入了一个不合规的 sidecar——这就绕过了策略检查。
全部通过后,资源对象被序列化为 Protocol Buffers 格式写入 etcd,同时 apiserver 的 Watch Cache 被更新,所有 Watch 这个资源的客户端会收到通知。
2.1.3 API 聚合层(Aggregation Layer)
apiserver 支持通过 APIService 注册扩展 API,将某些 API 路径的请求代理到外部服务器处理。这让你可以在不修改 apiserver 代码的情况下扩展 K8s API。
最典型的案例是 metrics-server。当你执行 kubectl top pods 时,kubectl 请求的是 /apis/metrics.k8s.io/v1beta1/pods。但这个 API 不是 apiserver 自己实现的——它通过 APIService 注册后,请求被代理到 metrics-server Pod:
apiVersion: apiregistration.k8s.io/v1
kind: APIService
metadata:
name: v1beta1.metrics.k8s.io
spec:
service:
name: metrics-server
namespace: kube-system
group: metrics.k8s.io
version: v1beta1
对客户端来说完全透明——它以为自己在跟 apiserver 通信,实际请求被转发了。
2.1.4 Watch 机制深度解析
Watch 是 K8s 响应速度的基石。但为什么需要 Watch?它是怎么工作的?让我们从问题开始。
问题起点:Controller 需要感知资源变化
假设你写了一个 Controller,需要在 Pod 创建/更新/删除时做出反应。最直觉的方案是轮询:
for {
pods := apiserver.GET("/api/v1/pods")
processChanges(pods)
sleep(1s)
}
这在 10 个 Pod 的开发环境里完全可以工作。但在生产环境中,问题立刻暴露:
- 延迟:轮询间隔 1 秒意味着最坏情况下变化要 1 秒后才被发现。缩短间隔?apiserver 扛不住
- 带宽浪费:每次轮询都返回全量数据。如果集群有 10000 个 Pod,每秒传输 10000 个 Pod 的完整 JSON,即使大部分 Pod 根本没变化
- apiserver 负载:如果集群中有 50 个 Controller 都在轮询 Pod,apiserver 每秒要处理 50 次全量查询
进化方案:HTTP Long Polling → Watch(HTTP Streaming)
K8s 选择了 Watch 机制:客户端与 apiserver 建立一个 HTTP 长连接(HTTP/1.1 Chunked Transfer 或 HTTP/2 Server Push),apiserver 只在资源发生变化时才推送增量事件。
GET /api/v1/pods?watch=true&resourceVersion=1234
--- 连接保持打开 ---
{"type":"ADDED", "object":{"metadata":{"name":"pod-a","resourceVersion":"1235"},...}}
{"type":"MODIFIED","object":{"metadata":{"name":"pod-b","resourceVersion":"1236"},...}}
{"type":"DELETED", "object":{"metadata":{"name":"pod-c","resourceVersion":"1237"},...}}
... (持续推送,直到连接断开)
每个事件都携带一个 resourceVersion,这是一个由 etcd 维护的全局递增版本号(实际是 etcd 的 revision)。客户端在建立 Watch 时可以指定 resourceVersion,表示"从这个版本之后的变化我都要"。
resourceVersion 的关键语义:
| Watch 参数 | 含义 |
|---|---|
resourceVersion="" |
从最新版本开始 Watch(可能错过之前的事件) |
resourceVersion="0" |
从任意版本开始(通常是缓存中最旧的版本) |
resourceVersion="1234" |
从 1234 之后的事件开始(精确续传) |
Watch 断线怎么办?——410 Gone 问题
Watch 连接不可能永远存活——网络抖动、apiserver 重启、连接超时都会导致断线。断线后客户端需要重连,用上次收到的最后一个 resourceVersion 续传。但如果断线时间太长,apiserver 的 Watch Cache 中已经不保留那么久远的事件了,这时 apiserver 会返回 410 Gone,意思是"你要的版本太旧了,我已经不记得了"。
收到 410 Gone 后,客户端必须重新执行一次完整的 List(全量查询),拿到当前所有资源和最新的 resourceVersion,然后用这个新版本号重新建立 Watch。这就是 List & Watch 模式的来源——不是因为设计者觉得"先 List 再 Watch 很优雅",而是因为 Watch 断线重连时必须有这个兜底机制。
Watch Cache:apiserver 端的缓冲层
如果没有 Watch Cache,会发生什么?假设集群中有 100 个 Controller(Deployment Controller、ReplicaSet Controller、各种 Operator...)都在 Watch Pod 资源。每个 Watch 请求都直接连到 etcd,那 etcd 需要同时维护 100 条 Watch 连接。etcd 不是为这个吞吐量设计的——它是一个一致性存储,不是消息队列。
所以 apiserver 在中间加了一层 Watch Cache:
etcd ──(1条Watch)──> apiserver Watch Cache ──(100条Watch)──> 各个 Controller
apiserver 只跟 etcd 维护 1 条 Watch 连接(每种资源类型 1 条)。收到事件后存入 Watch Cache(一个 Ring Buffer,默认保留 1000 个事件),再分发给所有 Watch 客户端。
Ring Buffer 的大小直接影响 410 Gone 的频率:如果 Buffer 太小,事件很快被覆盖,断线稍久就 410。生产环境中可以通过 apiserver 的 --watch-cache-sizes 参数调整热门资源的缓存大小。
Watch Bookmark 事件
还有一个微妙的问题:如果某个资源类型很久没有变化(比如一个冷门的 CRD),Watch 连接上长时间没有事件推送。这时如果连接断开重连,客户端持有的 resourceVersion 可能已经过期(被 etcd 压缩掉了),又会 410 Gone,又要重新 List。
为了解决这个问题,apiserver 会定期发送 Bookmark 事件——一个不包含资源对象、只包含最新 resourceVersion 的特殊事件。客户端收到后更新自己记录的版本号,这样即使长时间没有实际变化,重连时也不会 410。
2.1.5 Informer 架构深度解析
Watch 机制解决了"如何实时感知变化"的问题,但直接使用 Watch API 写 Controller 还是很痛苦。让我们从一个 Controller 开发者的视角看看问题在哪。
从裸 Watch 开始,看看有多少坑
假设你要写一个最简单的 Controller:监控所有 Pod,当 Pod 的某个 annotation 变化时做一些处理。用裸 Watch API 的伪代码:
func main() {
// 第 1 步:先 List 获取当前所有 Pod
pods := apiserver.List("/api/v1/pods")
lastVersion := pods.resourceVersion
// 第 2 步:从 lastVersion 开始 Watch
watcher := apiserver.Watch("/api/v1/pods?resourceVersion=" + lastVersion)
for event := range watcher.Events() {
switch event.Type {
case ADDED:
handleAdd(event.Pod)
case MODIFIED:
handleUpdate(event.Pod)
case DELETED:
handleDelete(event.Pod)
}
}
}
看起来很简洁?但这段代码在生产中活不过一天。问题有:
-
Watch 断线了怎么办? 你需要记住最后的
resourceVersion,重新 Watch。如果 410 Gone,要重新 List。这个重连逻辑你得自己写,还得处理各种边界情况。 -
每次 Reconcile 都要查 apiserver? 你的 Handler 里可能需要查"这个 Pod 所属的 ReplicaSet 是什么",直接调 apiserver 的 GET。如果你的 Controller 每秒处理 100 个事件,那就是每秒 100 次 API 调用。集群里 50 个 Controller 都这么干,apiserver 直接被打爆。
-
事件风暴怎么办? 如果某次批量操作触发了 1000 个 Pod 的变化,你的 Handler 被调用 1000 次。其中可能 500 次是对同一个 Pod 的连续更新(比如 Status 字段被多次修改),但你的 Handler 不知道,每次都执行完整的 Reconcile 逻辑。
-
Handler 失败了怎么办? 如果 handleUpdate 报错了,这个事件就丢了。你需要某种重试机制。
-
连接数爆炸:如果你的进程里有 10 个 Controller 都需要 Watch Pod,就会建立 10 条 Watch 连接。每种资源类型都乘以 10。
Informer 就是为解决这些问题而生的。它不是一个"优雅的抽象",而是一个"活过生产环境所必需的基础设施"。
client-go 库实现的 Informer 架构:
graph TB apiserver["apiserver"] reflector["Reflector
List & Watch"] deltafifo["DeltaFIFO
事件队列(Added/Updated/Deleted)"] indexer["Indexer
(本地缓存 + 索引)"] handler["EventHandler
(OnAdd/OnUpdate/OnDelete)"] workqueue["Work Queue
(限速 + 去重 + 重试)"] reconciler["Reconciler
(你的业务逻辑)"] apiserver -->|"Watch (HTTP Streaming)"| reflector reflector --> deltafifo deltafifo --> indexer deltafifo --> handler handler --> workqueue workqueue --> reconciler reconciler -.->|"读取缓存,不请求 apiserver"| indexer
下面逐个组件解释它为什么存在、解决了什么问题。
Reflector:自动化的 List & Watch
Reflector 封装了 List & Watch 的全部复杂性,包括:
- 启动时先执行 List 获取全量数据和
resourceVersion - 然后用该
resourceVersion建立 Watch - Watch 断线时自动重连
- 收到 410 Gone 时自动重新 List
- 将收到的事件(Added/Modified/Deleted)推入 DeltaFIFO
作为 Controller 开发者,你不需要关心任何连接管理的细节,Reflector 全部替你处理。
为什么先 List 再 Watch? 因为 Watch 只推送"变化",不推送"当前全量"。如果你上来就 Watch,你不知道集群里已经有哪些资源——你只能看到之后新增/修改/删除的。所以必须先 List 拿到"初始快照",再 Watch 增量变化。
DeltaFIFO:为什么存增量而不是最新状态?
DeltaFIFO 是一个特殊的队列,它存储的不是资源对象本身,而是变更增量——"Pod X 被 Added"、"Pod X 被 Modified"、"Pod X 被 Deleted"。
为什么不直接存最新状态?考虑这个场景:Pod X 在 100ms 内被连续更新了 3 次(比如先更新 Label,再更新 Annotation,最后更新 Status)。如果只存最新状态,EventHandler 只会看到"Pod X 现在长这样",不知道它之前发生了什么变化。对于某些 Controller 来说,"知道发生了什么变化"很重要——比如你可能只关心 Label 变化,不关心 Status 变化。
DeltaFIFO 为每个对象维护一个 Delta 列表:
key: "default/pod-x"
deltas: [
{Type: Updated, Object: <pod-x version 101>},
{Type: Updated, Object: <pod-x version 102>},
{Type: Updated, Object: <pod-x version 103>},
]
当这些 Delta 被消费时,EventHandler 可以看到每一次变化。同时,最新版本的对象会被存入 Indexer 缓存。
Indexer:本地缓存,避免请求 apiserver
Indexer 是一个带索引的内存缓存,存储了 Watch 资源的最新状态。它解决的问题很直接:你的 Reconcile 函数需要查询相关资源时,从本地缓存读取,不需要请求 apiserver。
例如,ReplicaSet Controller 在处理一个 ReplicaSet 时,需要知道"当前有哪些 Pod 属于这个 ReplicaSet"。如果每次都调 apiserver 的 GET /api/v1/pods?labelSelector=...,性能无法接受。Indexer 支持按 Namespace、Label 等维度建立索引,查询是纯内存操作,微秒级完成。
默认的索引是按 Namespace 索引,你也可以自定义索引函数。比如按 spec.nodeName 索引所有 Pod,这样查"Node X 上有哪些 Pod"就是 O(1) 操作。
一个关键约束:Indexer 里的数据可能有微小的延迟——它反映的是"最近一次 Watch 事件到达时"的状态,不是 etcd 中"此刻"的状态。这在绝大多数场景下不是问题,因为 Reconcile Loop 本身就是最终一致的。但如果你需要强一致读(比如在创建资源前检查是否已存在),应该直接调 apiserver 的 GET(不走缓存)。
Work Queue:为什么不直接从 EventHandler 调 Reconcile?
这是很多初学者的疑问。EventHandler 收到事件后,为什么不直接调用 Reconcile 函数,而是往 Work Queue 里放一个 key,让另一个 goroutine 来处理?
原因有三:
1. 去重(Deduplication):假设 Pod X 在 1 秒内被更新了 10 次。如果直接从 EventHandler 调 Reconcile,你会执行 10 次 Reconcile。但 Reconcile 是 Level-triggered 的——它看的是"当前状态 vs 期望状态",不关心中间经历了几次变化。所以执行 1 次就够了。Work Queue 通过 key(如 namespace/name)去重:队列里已经有 default/pod-x 了,新来的直接丢弃。
2. 限速(Rate Limiting):如果一次批量操作触发了 10000 个事件,你不希望 10000 个 Reconcile 同时执行把系统打爆。Work Queue 内置了限速器,控制出队速度。
3. 重试与退避(Retry with Backoff):Reconcile 可能失败(比如临时网络问题导致 API 调用失败)。Work Queue 支持 AddRateLimited(key)——将 key 重新入队,但带有指数退避延迟(1s → 2s → 4s → ... → 最大 16min)。如果直接在 EventHandler 里重试,你会阻塞整个事件处理流水线。
EventHandler 的职责被刻意设计得很轻:
// EventHandler 只做一件事:提取 key,扔进队列
func (h *Handler) OnUpdate(oldObj, newObj interface{}) {
key, _ := cache.MetaNamespaceKeyFunc(newObj)
h.queue.Add(key) // 只放 key,不放对象
}
// Reconciler 从队列取 key,从 Indexer 读最新状态,执行逻辑
func (r *Reconciler) processItem(key string) error {
obj, exists, _ := r.indexer.GetByKey(key)
if !exists {
// 对象已被删除,做清理
return nil
}
// 执行 Reconcile 逻辑
return r.reconcile(obj)
}
注意:EventHandler 放进队列的是 key(如 default/pod-x),不是对象本身。因为放入队列和取出处理之间可能有延迟,对象可能已经被更新了多次。Reconciler 取到 key 后,从 Indexer 读最新状态——这又是 Level-triggered 的体现。
SharedInformerFactory:一个进程只需要一组 Informer
kube-controller-manager 进程内运行着几十个 Controller。Deployment Controller 需要 Watch Pod,ReplicaSet Controller 也需要 Watch Pod,Node Controller 也需要 Watch Pod... 如果每个 Controller 各自创建一个 Pod Informer,就会建立几十条 Watch 连接,浪费大量资源。
SharedInformerFactory 确保同一类资源在同一进程中只有一个 Informer 实例。多个 Controller 共享这个 Informer,各自注册自己的 EventHandler。一条 Watch 连接,多个消费者。
factory := informers.NewSharedInformerFactory(client, 30*time.Second)
// 不管调用几次,返回的是同一个 Informer 实例
podInformer := factory.Core().V1().Pods().Informer()
// 多个 Controller 各自注册 EventHandler
podInformer.AddEventHandler(deploymentControllerHandler)
podInformer.AddEventHandler(replicaSetControllerHandler)
// 启动所有 Informer
factory.Start(stopCh)
30*time.Second 这个参数是 Resync Period:每隔 30 秒,Informer 会对缓存中的所有对象重新触发一次 OnUpdate 事件,即使它们没有真的变化。这是一个额外的安全网——万一某个事件被漏掉了(理论上不应该,但防御性编程),Resync 会把它补回来。
完整场景:Node 宕机后发生了什么
让我们用一个真实场景把 Watch + Informer + Controller 的整个链条走一遍。
假设集群中有一个 Node-3 突然宕机(比如内核 panic),上面跑着 5 个 Pod。
-
kubelet 心跳中断:每个 Node 上的 kubelet 每 10 秒通过更新
Lease对象向 apiserver 汇报心跳。Node-3 宕机后,它的 Lease 不再更新。 -
Node Controller 感知到异常:kube-controller-manager 中的 Node Controller 通过 Informer Watch 所有 Node 的 Lease 对象。当它发现 Node-3 的 Lease 超过 40 秒(
node-monitor-grace-period默认值)未更新时,将 Node-3 的ReadyCondition 设为Unknown。 -
打 Taint:Node Controller 在将 Node 状态设为
Unknown后,随即给 Node-3 打上 Taint:node.kubernetes.io/unreachable:NoExecute。 -
Pod 容忍期后被驱逐:Kubernetes 会自动为每个 Pod 添加
tolerationSeconds: 300的容忍(即容忍unreachable和not-readyTaint 5 分钟)。5 分钟后,如果 Taint 仍然存在,没有自定义 Toleration 的 Pod 会被驱逐删除。 -
ReplicaSet Controller 发现副本不足:Pod 被删除后,ReplicaSet Controller 的 Informer 收到 Pod Deleted 事件。它检查 ReplicaSet 的期望副本数(比如 3),发现当前只剩 2 个 Running 的 Pod。于是创建 1 个新 Pod。
-
Scheduler 调度新 Pod:新 Pod 的
nodeName为空,Scheduler 将其调度到其他健康 Node 上。 -
kubelet 启动新容器:目标 Node 的 kubelet 收到新 Pod,启动容器,Pod 恢复 Ready。
整个自愈过程没有任何人工干预,也没有任何组件"指挥"另一个组件。每个 Controller 都只是观察状态、发现差异、采取行动。这就是声明式 + 控制循环的自愈能力。
2.2 etcd
2.2.1 在 K8s 中的角色与数据模型
etcd 是 K8s 唯一的持久化存储后端。为什么选择 etcd 而不是 MySQL 或 Redis?
- 强一致性:etcd 使用 Raft 协议,保证在网络分区时不会出现脑裂(split-brain)。K8s 不能容忍两个 Controller 看到不同的集群状态——这会导致资源冲突
- Watch 支持:etcd 原生支持 Watch API,这是 K8s Watch 机制的底层基础
- MVCC(多版本并发控制):etcd 保留所有历史版本,通过全局递增的 revision 号追踪变化。这使得 Watch 可以从任意历史版本开始"回放"事件
所有资源对象以 key-value 的形式存储:
/registry/{resource}/{namespace}/{name}
/registry/pods/default/nginx-7bf8c77b5b-x2j9k
Value 是资源对象的 Protocol Buffers 编码(非 JSON,出于性能考虑——Protobuf 序列化/反序列化比 JSON 快 5-10 倍,体积小 3-5 倍)。
关键约束:etcd 的 value 大小限制默认为 1.5MB。这意味着单个资源对象(如一个塞满数据的 ConfigMap 或 Secret)不能超过这个限制。曾经有团队把整个配置文件打包成 ConfigMap 然后踩到这个坑。
2.2.2 Raft 一致性协议:一个写请求的完整路径
Raft 的核心思想用三句话概括:
- 集群中只有一个 Leader,所有写请求都由 Leader 处理
- Leader 将写操作复制到 Follower,等到多数节点确认后才算成功
- 如果 Leader 挂了,剩余节点自动选出新 Leader
但"只有一个 Leader"和"多数节点确认"到底意味着什么?让我们用一个写请求走一遍完整路径:
当你创建一个 Pod 时,apiserver 将 Pod 对象发给 etcd。假设 etcd 是 3 节点集群(etcd-1 是 Leader,etcd-2 和 etcd-3 是 Follower):
apiserver → etcd-1 (Leader)
1. Leader 将写操作追加到自己的 WAL(Write-Ahead Log)
2. Leader 发送 AppendEntries RPC 给 etcd-2 和 etcd-3
3. etcd-2 收到,写入自己的 WAL,回复 OK
4. etcd-3 收到,写入自己的 WAL,回复 OK
5. Leader 收到 2 个确认(加上自己共 3 个,满足 Quorum = 3/2+1 = 2)
6. Leader 将数据 Apply 到本地状态机(BoltDB)
7. Leader 回复 apiserver:写入成功
Quorum(多数派) 是 Raft 的核心安全保证。3 节点需要 2 个确认,5 节点需要 3 个确认。这意味着:
- 3 节点集群容忍 1 节点故障(2 个存活节点仍满足 Quorum)
- 5 节点容忍 2 节点故障(3 个存活节点仍满足 Quorum)
- 节点数必须是奇数:4 节点集群的 Quorum 也是 3(4/2+1=3),和 3 节点一样只能容忍 1 个故障——多一台机器没有额外收益,反而增加了复制开销
MVCC 与 Watch 的关系
etcd 3 使用 MVCC 存储引擎,每次写操作都会递增一个全局 revision 号。旧版本不会被覆盖,而是保留在存储中(直到被 Compaction 清理)。
这正是 Watch 能工作的基础:当客户端说"从 revision 1234 开始 Watch",etcd 可以从存储中找到 revision 1234 之后的所有变更,逐条推送。如果 revision 1234 已经被 Compaction 清理了,etcd 返回一个错误,客户端需要重新 List——这就是 apiserver 层面 410 Gone 的底层原因。
2.2.3 etcd 性能调优与运维关键点
etcd 的性能直接决定了 K8s 集群的响应速度——apiserver 的每个写操作都要等 etcd 确认,etcd 慢则整个集群慢。
-
磁盘 I/O:etcd 是 I/O 密集型服务。每次写操作都要 fsync WAL 到磁盘(保证持久性)。必须使用 SSD,fdatasync 延迟应低于 10ms。etcd 官方建议 99th percentile fsync 延迟 < 10ms。用 HDD?Raft 心跳超时,Leader 频繁切换,集群不稳定。
-
定期压缩(Compaction):etcd 保留所有历史版本。不压缩的话,存储空间会无限增长。K8s 默认每 5 分钟自动压缩(通过 apiserver 的
--etcd-compaction-interval参数)。 -
碎片整理(Defragmentation):压缩只是标记旧版本为"可回收",实际空间要通过碎片整理才能释放。需要定期手动执行
etcdctl defrag(注意:碎片整理会短暂阻塞请求,建议在低峰期执行)。 -
DB 大小监控:默认配额 2GB(
--quota-backend-bytes),超过后 etcd 进入只读模式(触发 alarm),apiserver 无法写入任何资源。应急处理:etcdctl alarm disarm→etcdctl compact→etcdctl defrag。生产环境建议配额设为 8GB 并监控使用量。 -
备份策略:
etcdctl snapshot save backup.db定期备份。etcd 数据丢失 = 整个集群状态丢失,这是灾难级事件。
2.3 kube-scheduler
Scheduler 的职责看起来很简单:为每个未调度的 Pod 选择一个 Node。但"选哪个 Node"这个决策涉及大量因素——资源容量、亲和性、拓扑分布、数据局部性... 让我们通过一个具体场景看 Scheduler 是怎么工作的。
2.3.1 调度框架(Scheduling Framework)
Kubernetes v1.15 引入了 Scheduling Framework(Alpha,v1.20 GA),将调度过程分解为多个扩展点(Plugin)。你可以把它想象成一条流水线,Pod 在上面经过层层筛选和评分:
Pod 进入调度队列
│
├─→ PreFilter ── 前置检查(Pod 的前提条件是否满足)
├─→ Filter ── 过滤不可用 Node
├─→ PostFilter ── 当 Filter 全部过滤完了,一个 Node 都不剩时触发(抢占)
├─→ PreScore ── 评分前预处理
├─→ Score ── 对候选 Node 打分
├─→ NormalizeScore── 归一化分数到 0-100
├─→ Reserve ── 预留资源(乐观假设调度成功)
├─→ Permit ── 最终批准(可延迟、可拒绝)
├─→ PreBind ── 绑定前操作(如挂载 Volume)
├─→ Bind ── 将 Pod 绑定到 Node(写 spec.nodeName)
└─→ PostBind ── 绑定后清理
2.3.2 一个调度决策的完整 Walkthrough
假设你要调度一个 Pod,它的要求是:
- 资源:requests 2 CPU、4Gi Memory
- 亲和性:
nodeAffinity要求 Node 有标签zone=us-east-1a - 拓扑分布:
topologySpreadConstraints要求 Pod 在不同 Node 上均匀分布
集群有 5 个 Node:
| Node | CPU 剩余 | Memory 剩余 | 标签 | 已有同类 Pod 数 |
|---|---|---|---|---|
| Node-1 | 4 CPU | 8Gi | zone=us-east-1a | 3 |
| Node-2 | 1 CPU | 16Gi | zone=us-east-1a | 1 |
| Node-3 | 8 CPU | 16Gi | zone=us-east-1b | 0 |
| Node-4 | 4 CPU | 2Gi | zone=us-east-1a | 2 |
| Node-5 | 4 CPU | 8Gi | zone=us-east-1a, taint: dedicated=gpu:NoSchedule | 0 |
Filter 阶段(淘汰赛):
| 过滤器 | 淘汰了谁? | 原因 |
|---|---|---|
NodeResourcesFit |
Node-2(CPU 不足), Node-4(Memory 不足) | Node-2 只剩 1 CPU,Pod 要 2 CPU;Node-4 只剩 2Gi,Pod 要 4Gi |
NodeAffinity |
Node-3 | 标签是 zone=us-east-1b,Pod 要求 us-east-1a |
TaintToleration |
Node-5 | 有 dedicated=gpu:NoSchedule Taint,Pod 没有 Toleration |
Filter 后只剩 Node-1。只有 1 个候选,直接绑定。
但如果 Filter 后剩了多个候选呢?假设 Node-4 有 8Gi Memory(没被淘汰),Filter 后剩 Node-1 和 Node-4,进入 Score 阶段。
Score 阶段(评分赛):
每个评分插件给每个候选 Node 打 0-100 分,乘以权重后求和:
| 评分器 | Node-1 得分 | Node-4 得分 | 逻辑 |
|---|---|---|---|
LeastAllocated(权重 1) |
50 | 50 | 两者 CPU 剩余相同 |
BalancedAllocation(权重 1) |
70 | 40 | Node-1 的 CPU/Memory 利用率更均衡 |
PodTopologySpread(权重 2) |
30 | 60 | Node-1 已有 3 个同类 Pod,Node-4 只有 2 个 |
加权总分:
- Node-1:50×1 + 70×1 + 30×2 = 180
- Node-4:50×1 + 40×1 + 60×2 = 210
Node-4 胜出。原因是拓扑分布权重最高(×2),Node-4 上同类 Pod 更少,更有利于均匀分布。
2.3.3 抢占(Preemption):所有 Node 都不够资源怎么办?
当 Filter 阶段把所有 Node 都淘汰了——没有任何 Node 满足 Pod 的资源需求。这时 Scheduler 不会直接放弃,而是进入 PostFilter 阶段,尝试抢占:
- Scheduler 遍历每个 Node,模拟"如果驱逐这个 Node 上的某些低优先级 Pod,能否腾出足够资源?"
- 找到一个"牺牲品最少"的 Node
- 给该 Node 上被选中的低优先级 Pod 设置
deletionTimestamp(开始优雅终止) - 给待调度的 Pod 设置
status.nominatedNodeName(预提名,等待腾出空间后正式绑定)
抢占的前提是 Pod 设置了 PriorityClass。高优先级 Pod 可以抢占低优先级 Pod 的资源。没设置 PriorityClass 的 Pod 默认优先级为 0。
2.3.4 调度扩展
可以通过 KubeSchedulerConfiguration 配置调度插件的启用/禁用/权重:
apiVersion: kubescheduler.config.k8s.io/v1
kind: KubeSchedulerConfiguration
profiles:
- schedulerName: default-scheduler
plugins:
score:
enabled:
- name: NodeResourcesBalancedAllocation
weight: 1
- name: ImageLocality
weight: 2
你也可以运行多个 Scheduler(通过不同的 schedulerName),让特定 Pod 使用特定的调度策略。比如 AI/ML 工作负载可以用一个专门的 GPU-aware Scheduler。
2.4 kube-controller-manager
2.4.1 为什么需要 Controller Manager?
回到声明式设计:你创建了一个 Deployment(期望 3 个副本),谁来确保真的有 3 个 Pod 在运行?不是 apiserver(它只是存储),不是 scheduler(它只管把 Pod 放到 Node 上),不是 kubelet(它只管自己 Node 上的容器)。
答案是 Controller——专门负责"观察期望状态和实际状态的差异,并采取行动消除差异"的组件。
kube-controller-manager 是一个进程,内部运行着数十个独立的 Controller。为什么不把每个 Controller 做成独立进程?因为它们共享大量基础设施(Informer、Work Queue、apiserver 连接),放在一个进程里可以通过 SharedInformerFactory 共享连接和缓存。
2.4.2 Controller 代码模式
每个 Controller 都遵循同样的骨架:
// 简化的 Controller 主循环
func (c *Controller) Run(stopCh <-chan struct{}) {
defer c.queue.ShutDown()
// 等待 Informer 缓存同步——确保本地缓存已包含全量数据
if !cache.WaitForCacheSync(stopCh, c.hasSynced) {
return
}
// 启动多个 worker goroutine 并发处理
for i := 0; i < c.workers; i++ {
go wait.Until(c.worker, time.Second, stopCh)
}
<-stopCh
}
func (c *Controller) worker() {
for c.processNextWorkItem() {}
}
func (c *Controller) processNextWorkItem() bool {
key, quit := c.queue.Get()
if quit { return false }
defer c.queue.Done(key)
err := c.syncHandler(key.(string)) // 核心 Reconcile 逻辑
if err != nil {
c.queue.AddRateLimited(key) // 失败:指数退避重试
} else {
c.queue.Forget(key) // 成功:从限速器移除
}
return true
}
WaitForCacheSync 这一步很关键:Controller 必须等 Informer 完成初始 List 并填充好本地缓存后才能开始工作。否则 Controller 一启动就发现"一个 Pod 都没有"(因为缓存还是空的),然后疯狂创建 Pod——灾难。
2.4.3 Deployment Controller 的 Reconcile 逻辑
不是所有 Controller 都一样复杂。Deployment Controller 是最有代表性的一个,让我们看看它收到一个 Deployment 更新事件后做了什么。
假设你更新了 Deployment 的镜像版本(从 nginx:1.24 改为 nginx:1.25),且 strategy 是 RollingUpdate,maxSurge=1,maxUnavailable=0,replicas=3。
Deployment Controller 的 syncHandler 大致逻辑:
- 从 Indexer 读取 Deployment 最新状态
- 列出所有属于这个 Deployment 的 ReplicaSet(通过 OwnerReference)
- 发现 Pod template 变了(Hash 不匹配),需要创建新 ReplicaSet
- 创建新 ReplicaSet(
nginx-1.25),初始 replicas=0 - 开始滚动更新,遵循 maxSurge 和 maxUnavailable 约束:
初始状态:old-RS replicas=3, new-RS replicas=0, 总共 Running=3
第 1 轮:
- maxSurge=1,允许总 Pod 数 = 3+1 = 4
- new-RS replicas 从 0 → 1(总 Pod = 4,不超 maxSurge)
- 等待 new-RS 的 Pod Ready...
- maxUnavailable=0,要求最少 3 个 Available
- new Pod Ready 后,Available=4,可以缩 old-RS
- old-RS replicas 从 3 → 2
第 2 轮:
- new-RS replicas 从 1 → 2(总 Pod = 4)
- 等 Ready... old-RS 从 2 → 1
第 3 轮:
- new-RS replicas 从 2 → 3(总 Pod = 4)
- 等 Ready... old-RS 从 1 → 0
最终状态:old-RS replicas=0, new-RS replicas=3
注意:Deployment Controller 不直接操作 Pod,它只调整 ReplicaSet 的 replicas 数字。实际的 Pod 创建/删除由 ReplicaSet Controller 负责。这就是 K8s 的可组合性——每个 Controller 只管一层抽象。
2.4.4 Node Controller 与 Node 健康检测
Node Controller 负责监控 Node 健康状态。它怎么判断一个 Node 是否健康?
心跳机制:每个 Node 上的 kubelet 每 10 秒更新一个 Lease 对象(coordination.k8s.io/v1 Lease,存在 kube-node-lease namespace 中)。这比直接更新 Node Status 对象轻量得多——Lease 对象很小,更新频率高但不会给 etcd 造成太大压力。
Node Controller 的检测逻辑:
- Lease 超过 40 秒未更新:将 Node 的
ReadyCondition 设为Unknown - 随即打 Taint:Node Controller 在状态变为
Unknown后,给 Node 打上node.kubernetes.io/unreachable:NoExecuteTaint - Pod 容忍期后被驱逐:Kubernetes 为每个 Pod 自动添加
tolerationSeconds: 300(5 分钟)的容忍。超时后,没有自定义 Toleration 的 Pod 被删除
为什么不是立即驱逐? 因为短暂的网络抖动不应该触发大规模 Pod 迁移。Taint 虽然很快打上,但 Pod 的默认 5 分钟容忍期提供了缓冲窗口,避免"抖一下就全部重调度"。在大规模集群中,Node Controller 还会控制驱逐速率(--node-eviction-rate),避免同时驱逐太多 Pod 导致雪崩。
2.4.5 Leader Election:为什么只能有一个 Leader?
在 HA 部署中,通常有 3 个 control plane 节点,各跑一个 kube-controller-manager 实例。但只有一个实例在真正运行 Controller,其他都在 standby。
为什么?想象两个 Deployment Controller 同时运行:
- 两个都发现 ReplicaSet 只有 2 个 Pod(期望 3 个)
- 两个都创建 1 个 Pod
- 结果:4 个 Pod,超出期望
虽然 Level-triggered 设计最终会收敛(下次循环发现多了 1 个,删掉),但这种振荡是不必要的开销。通过 Leader Election 确保只有一个实例运行,避免了这个问题。
Leader Election 通过 Lease 对象实现:
apiVersion: coordination.k8s.io/v1
kind: Lease
metadata:
name: kube-controller-manager
namespace: kube-system
spec:
holderIdentity: master-1_xxxx
leaseDurationSeconds: 15
renewTime: "2024-01-01T00:00:00Z"
持有 Lease 的实例每隔几秒续期(更新 renewTime)。如果续期超时(15 秒没更新),其他实例会尝试获取 Lease——通过 etcd 的原子 CAS(Compare-And-Swap)操作竞争,只有一个能成功,成为新的 Leader。
2.5 cloud-controller-manager
cloud-controller-manager(CCM)是从 kube-controller-manager 中拆分出来的组件,专门负责与云厂商 API 交互。
为什么要拆分?在 K8s 早期,所有云厂商的代码都在 kube-controller-manager 中(称为 in-tree cloud provider)。这意味着每次云厂商更新 API,都要修改 K8s 核心代码并等待下一个 K8s 版本发布。拆分后,云厂商可以独立发布自己的 CCM,按自己的节奏迭代。
CCM 内部运行三类 Controller:
| Controller | 职责 | 具体场景 |
|---|---|---|
| Node Controller | 检查云上节点实例是否仍然存在 | Node NotReady 后,从云 API 确认 VM 是否已被删除。如果 VM 确实不存在了,从 K8s 中移除 Node 对象 |
| Route Controller | 在云 VPC 中配置路由表 | 新 Node 加入集群时,在 VPC 路由表中添加"Pod CIDR → Node IP"的路由,使跨 Node 的 Pod 网络互通 |
| Service Controller | 管理 LoadBalancer 类型 Service | 创建 type: LoadBalancer 的 Service 时,调用云 API 创建负载均衡器(如 AWS ALB/NLB),并将 LB 的外部 IP 写回 Service 的 status.loadBalancer.ingress |
关键点:
- 自建集群(bare metal / 非云环境)不需要 CCM
- 每个云厂商提供自己的 CCM 实现(如
aws-cloud-controller-manager、gcp-cloud-controller-manager) - CCM 与 kube-controller-manager 一样通过 Lease 进行 Leader Election
3. Data Plane 组件深度解析
3.1 kubelet
kubelet 是运行在每个 Node 上的"Node Agent",是 Control Plane 意志在 Node 上的执行者。
3.1.1 Pod 生命周期管理
kubelet 通过 Watch apiserver 获取分配到本节点的 Pod Spec(spec.nodeName 等于自己的 Node),然后执行以下流程:
graph TB spec["Pod Spec 到达"] --> sandbox["创建 Pod Sandbox
(网络命名空间 + Pause 容器)"] sandbox --> init["运行 Init Containers(按顺序、串行)"] init --> main["运行主 Containers(并行)"] main --> probe["运行 Startup Probe → Readiness Probe → Liveness Probe"] probe --> running["运行期间"] running --> status["持续上报 Pod Status"] running --> probing["执行 Readiness/Liveness Probe"] running --> term["终止时"] term --> sigterm["发送 SIGTERM"] sigterm --> prestop["运行 PreStop Hook"] prestop --> grace["等待 terminationGracePeriodSeconds"] grace --> sigkill["发送 SIGKILL"]
Pause 容器为什么存在?——不只是"持有 Namespace"这么简单
每个 Pod 的第一个容器不是你的应用容器,而是一个叫 pause 的极简容器(几百 KB,代码只有 20 行,功能就是 pause() 系统调用——永远挂起,什么都不做)。
它存在的原因:Pod 内的所有容器需要共享 Network Namespace(相同 IP、相同端口空间)。如果没有 Pause 容器,Network Namespace 会绑定在你的应用容器上。当你的应用容器崩溃重启时,Network Namespace 被销毁重建——这意味着 IP 地址可能变化,Pod 内其他 Sidecar 容器的网络连接全部断开。
Pause 容器解决了这个问题:Network Namespace 绑定在 Pause 容器上,Pause 容器几乎不可能崩溃(它什么都不做)。你的应用容器重启时,只是重新加入 Pause 容器持有的 Namespace,IP 地址不变,Sidecar 的网络连接不受影响。
本质上,Pause 容器把 Pod 的网络身份和容器的生命周期解耦了。
3.1.2 CRI(Container Runtime Interface)
kubelet 通过 CRI gRPC 接口与容器运行时通信。这个接口的存在是一段历史演进的结果。
早期:kubelet 硬编码 Docker。K8s 最初只支持 Docker 作为容器运行时,kubelet 中大量代码直接调用 Docker API。
问题:其他容器运行时(如 rkt、containerd)也想接入 K8s,但没法——kubelet 和 Docker 绑死了。而且 Docker 本身是一个完整的开发者工具链(构建、推送、运行、编排),K8s 只需要其中"运行容器"的能力,拉着一个巨大的 Docker daemon 是浪费。
解决方案:定义一个标准接口 CRI。任何实现了 CRI 的运行时都能接入 kubelet:
graph LR kubelet1["kubelet"] -->|"CRI gRPC"| containerd --> runc1["runc"] kubelet2["kubelet"] -->|"CRI gRPC"| crio["CRI-O"] --> runc2["runc/crun"]
CRI 定义了两大类接口:
- RuntimeService:Pod Sandbox 管理(创建网络命名空间)、容器生命周期管理(创建/启动/停止/删除容器)
- ImageService:镜像拉取、删除、列表
dockershim 的终结:K8s 1.24 之前,kubelet 中内置了一个 dockershim 模块,将 CRI 调用翻译成 Docker API 调用,充当 Docker 的兼容层。1.24 起 dockershim 被移除——Docker 需要通过 cri-dockerd(社区维护的外部适配器)才能与 kubelet 通信。但大多数生产环境已迁移到 containerd 或 CRI-O,它们原生支持 CRI,更轻量、更稳定。
3.1.3 CSI 与设备插件
kubelet 还负责:
- 通过 CSI Node Plugin 在本地执行 Volume 的 Mount/Unmount(将云磁盘挂载到容器的文件系统路径)
- 通过 Device Plugin Framework 管理 GPU、FPGA 等特殊硬件资源。GPU 厂商(如 NVIDIA)提供 Device Plugin,向 kubelet 注册"这个 Node 有 4 张 GPU 可用",Scheduler 据此做调度决策
3.2 kube-proxy
kube-proxy 运行在每个 Node 上,负责实现 Service 的网络转发规则。当你访问一个 Service 的 ClusterIP 时,是 kube-proxy 维护的规则把流量转发到后端 Pod。
3.2.1 三种模式对比
| 模式 | 实现方式 | 性能 | 适用场景 |
|---|---|---|---|
| iptables | 为每个 Service/Endpoint 创建 iptables 规则 | O(n) 规则匹配,Service 数多时性能下降 | 小中型集群(<1000 Service) |
| IPVS | 使用 Linux IPVS 内核模块 | O(1) 哈希查找,支持多种负载均衡算法 | 大型集群 |
| nftables | K8s 1.29+ 新增,使用 nftables 替代 iptables | 更高效的规则编译 | 新版本集群 |
3.2.2 iptables 模式:为什么 O(n) 是问题?
以一个 ClusterIP Service(2 个后端 Pod)为例,kube-proxy 创建如下 iptables 规则链:
KUBE-SERVICES(入口链)
→ 匹配目标 IP=10.96.0.100, Port=80?跳转到 KUBE-SVC-XXXXX
KUBE-SVC-XXXXX(Service 链)
→ 50% 概率跳转到 KUBE-SEP-AAAA
→ 50% 概率跳转到 KUBE-SEP-BBBB
KUBE-SEP-AAAA(Endpoint 链)
→ DNAT 到 10.244.1.5:8080(Pod1 的实际 IP:Port)
KUBE-SEP-BBBB(Endpoint 链)
→ DNAT 到 10.244.2.9:8080(Pod2 的实际 IP:Port)
通过 iptables 的 --probability 实现随机负载均衡。
性能问题:iptables 规则是线性匹配的。一个 Service 大约需要 5-10 条规则。如果集群有 5000 个 Service,就有 25000-50000 条规则。每个数据包进入时都要从头遍历规则链,匹配到目标 Service 的规则。当规则数达到数万条时,延迟显著增加(几毫秒级),规则更新也变慢(每次全量刷新)。
3.2.3 IPVS:为什么是 O(1)?
IPVS(IP Virtual Server)是 Linux 内核内置的四层负载均衡器。它使用哈希表存储 Service → Endpoint 的映射关系:
Hash(ClusterIP:Port) → [Pod1-IP:Port, Pod2-IP:Port, Pod3-IP:Port]
查找一个 Service 的后端是 O(1) 的哈希查找,不管集群里有多少 Service。而且 IPVS 支持多种负载均衡算法:轮询(rr)、最少连接(lc)、加权轮询(wrr)等,比 iptables 的随机概率更灵活。
3.2.4 从 kube-proxy 到 eBPF
Cilium 等基于 eBPF 的网络方案可以完全替代 kube-proxy:
- 直接在内核数据路径中执行负载均衡,跳过 iptables/IPVS 的开销
- 在 XDP(eXpress Data Path)层处理数据包,甚至在 socket 层短路(socket-level LB),避免数据包经过完整的内核网络栈
- 支持更精细的流量控制和可观测性(Hubble)
- 在大规模集群中性能优势显著
4. 核心资源对象的设计哲学
4.1 Pod
4.1.1 为什么 Pod 是最小调度单位,而不是 Container?
如果 K8s 直接调度 Container,会发生什么?考虑一个 Istio service mesh 场景:你的应用容器(nginx)和 Envoy sidecar 代理必须在同一台机器上、共享同一个网络栈(通过 localhost 通信)。如果分别调度两个 Container:
- Scheduler 可能把 nginx 放在 Node-1,Envoy 放在 Node-2——它们无法通过 localhost 通信
- 你需要手动添加"这两个容器必须在同一个 Node"的约束,但 Scheduler 没有"容器组"的概念来保证原子调度
Pod 就是这个"容器组"的抽象。它保证:
- 原子调度:Pod 内的所有容器一起被调度到同一个 Node,不存在"一半调度成功、一半失败"的中间状态
- 共享环境:Pod 内容器共享 Network Namespace(相同 IP,通过 localhost 通信)、IPC Namespace(共享 System V IPC 和 POSIX 消息队列)、Volume(通过共享挂载点交换文件)
三种经典的多容器 Pod 模式:
- Sidecar 模式(最常见):Istio 的 Envoy 代理、日志收集器(Fluentd/Filebeat)、监控 Agent——它们需要和应用容器共享网络或文件系统
- Ambassador 模式:一个本地代理容器,将应用的外部请求重定向到正确的后端(如本地 Redis proxy,应用只连 localhost:6379)
- Adapter 模式:格式转换容器,将应用的非标准输出转换为标准格式(如将应用日志从自定义格式转为 JSON)
4.1.2 容器类型
| 类型 | 运行时机 | 典型用途 |
|---|---|---|
| Init Container | 在主容器之前,按顺序串行运行 | 等待依赖服务就绪、数据迁移、权限初始化 |
| Regular Container | Pod 主生命周期,并行运行 | 应用主进程 |
| Sidecar Container(K8s 1.28+) | 与主容器同时运行,但在主容器之前启动、之后终止 | 原生 sidecar 支持。之前的 hack 是用 Init Container + 永远不退出的命令模拟 sidecar,导致 Job/CronJob 无法正确完成(sidecar 不退出,Job 永远 Running) |
| Ephemeral Container | 按需注入,用于调试 | kubectl debug 使用。针对 distroless 镜像(没有 shell 和调试工具),注入一个有工具的临时容器 |
4.1.3 Pod 生命周期与状态机
graph LR Pending -->|"调度成功 + 容器启动"| Running Running -->|"所有容器正常退出(exit 0)"| Succeeded Running -->|"容器异常退出"| Failed
Pending:Pod 已被 apiserver 接受但尚未运行。常见原因:
- Unschedulable:没有 Node 满足资源/亲和性要求 → 检查 Node 资源、Taint/Toleration
- ImagePullBackOff:镜像拉取失败 → 检查镜像名、Tag、Registry 认证
- Pending PVC:Volume 未就绪 → 检查 StorageClass、PV 是否可用
CrashLoopBackOff 不是 Phase,而是 Container State。它表示容器反复崩溃重启,kubelet 的退避策略:10s → 20s → 40s → 80s → 160s → 300s(最大 5 分钟)。查看 kubectl logs --previous 可以看到前一次崩溃的日志。
4.1.4 QoS 等级
K8s 根据 Pod 的 requests/limits 配置自动划分 QoS 等级,决定节点内存压力时的驱逐优先级:
| QoS 等级 | 条件 | 含义 |
|---|---|---|
| Guaranteed | 所有容器的 requests = limits(CPU + Memory 都设置且相等) | 资源预留完全确定,最后被驱逐 |
| Burstable | 至少一个容器设置了 requests,但不满足 Guaranteed 条件 | 资源有保底但可弹性使用,中间被驱逐 |
| BestEffort | 没有任何容器设置 requests/limits | "尽力而为",最先被驱逐 |
当 Node 内存不足时,kubelet 按 BestEffort → Burstable → Guaranteed 的顺序驱逐 Pod。生产建议:关键服务务必设置 requests 和 memory limits,确保至少是 Burstable(推荐 Guaranteed)。
4.2 Service 与服务发现
4.2.1 Service 为什么存在?——从问题出发
Pod 的 IP 是动态的:Pod 重建后 IP 会变。如果你的前端应用硬编码了后端 Pod 的 IP,一旦后端 Pod 重启,前端就连不上了。
Service 就是为了解决这个问题:它提供一个稳定的虚拟 IP(ClusterIP),作为一组 Pod 的统一访问入口。不管后端 Pod 怎么变化(扩缩容、重建、迁移),Service 的 ClusterIP 永远不变。
4.2.2 四种类型:逐层递进
ClusterIP(默认) 解决了集群内部的服务发现:
前端 Pod → Service ClusterIP (10.96.0.100:80) → 后端 Pod (10.244.x.x:8080)
但 ClusterIP 只在集群内部可达,集群外的用户访问不了。
NodePort 在 ClusterIP 基础上增加了外部可达性:在每个 Node 上开放一个固定端口(30000-32767 范围),外部流量可以通过 <任意NodeIP>:<NodePort> 进入集群。
外部用户 → Node-1:30080 → Service ClusterIP → 后端 Pod
但直接暴露 NodePort 有问题:用户需要知道 Node 的 IP,而且如果 Node 故障了,这个入口就断了。
LoadBalancer 在 NodePort 基础上增加了云负载均衡器:cloud-controller-manager 调用云 API 创建一个 LB(如 AWS NLB),将外部流量分发到各个 Node 的 NodePort 上。用户只需访问 LB 的公网 IP/域名。
外部用户 → 云 LB (公网IP) → Node-1:30080 / Node-2:30080 → Service → 后端 Pod
ExternalName 是特殊的:它不做代理,只返回一个 CNAME DNS 记录,将 Service 名映射到外部域名。用于集群内服务访问集群外的服务(如外部数据库),提供一层间接性。
4.2.3 Endpoints 与 EndpointSlice
Service 通过 Label Selector 匹配后端 Pod。匹配到的 Pod IP 存储在哪?
早期是 Endpoints 对象:一个 Endpoints 对象包含该 Service 所有后端 Pod 的 IP 列表。问题是:当 Service 后端有数千个 Pod 时,单个 Endpoints 对象变得非常大(可能几百 KB),每次 Pod 变化都触发全量更新——改了 1 个 Pod 的 IP,整个 Endpoints 对象都要重新推送给所有 Watch 客户端。
EndpointSlice(K8s 1.21 GA)将后端分片存储,每个 slice 默认最多 100 个 endpoint。更新时只推送受影响的 slice,带宽消耗大幅降低。
apiVersion: discovery.k8s.io/v1
kind: EndpointSlice
metadata:
name: my-service-abc12
labels:
kubernetes.io/service-name: my-service
endpoints:
- addresses: ["10.1.2.3"]
conditions:
ready: true
nodeName: node-1
4.2.4 DNS 解析机制
CoreDNS 为每个 Service 创建 DNS 记录,这是集群内服务发现的基础:
{service}.{namespace}.svc.cluster.local → ClusterIP
应用代码中只需要用 Service 名(如 http://backend:8080)访问后端,DNS 会自动解析为 ClusterIP。
对于 Headless Service(clusterIP: None),DNS 行为不同:
{service}.{namespace}.svc.cluster.local → 所有 Pod IP(A 记录)
{pod-name}.{service}.{namespace}.svc.cluster.local → 特定 Pod IP
Headless Service 不分配 ClusterIP,DNS 直接返回后端 Pod 的 IP 列表。这是 StatefulSet 实现稳定网络标识的基础——每个 StatefulSet Pod 有一个稳定的 DNS 名(如 mysql-0.mysql-headless.default.svc.cluster.local),即使 Pod 重建,这个 DNS 名指向的始终是同一个逻辑实例。
4.3 Namespace 与多租户
Namespace 提供的是 逻辑隔离,不是安全隔离:
- 资源隔离:通过 ResourceQuota(限制 Namespace 内资源总量)/ LimitRange(限制单个容器资源范围)
- 网络隔离:通过 NetworkPolicy(需 CNI 支持,如 Calico/Cilium)。默认不隔离——任何 Namespace 的 Pod 都能访问任何其他 Namespace 的 Pod
- 访问控制:通过 RBAC(RoleBinding 限定到 Namespace),不同团队只能操作自己 Namespace 的资源
- 不隔离的:Node、PersistentVolume、ClusterRole 等集群级资源是所有 Namespace 共享的
真正的多租户安全隔离需要额外方案。Namespace 只是一个逻辑分组,恶意租户可以通过消耗 Node 资源、利用内核漏洞等方式影响其他租户。硬隔离方案包括 vCluster(虚拟集群)、Kata Containers(VM 级隔离)、或直接用独立集群。
5. 网络模型
5.1 三大基本要求
K8s 网络模型有三个不可协商的要求:
- Pod-to-Pod:所有 Pod 可以不通过 NAT 直接互相访问
- Node-to-Pod:所有 Node 可以不通过 NAT 直接访问所有 Pod
- Pod 看到的自身 IP 与其他 Pod 看到的一致
为什么要这么设计?因为 NAT 会让分布式系统的网络编程变得极其复杂。如果 Pod 的"内部 IP"和"外部可见 IP"不同,每个应用都要处理地址转换逻辑。K8s 的网络模型让每个 Pod 都有一个"真实的、全集群唯一的 IP",应用代码可以像在同一个局域网里一样直接通信。
5.2 CNI 插件架构
CNI(Container Network Interface) 定义了容器网络的标准接口。当 kubelet 创建 Pod 时,通过 CRI 调用容器运行时,运行时再调用 CNI 插件为 Pod 配置网络(分配 IP、设置路由、连接网桥等)。
graph TB kubelet --> cri["CRI Runtime"] cri --> cni["CNI Plugin"] cni --> flannel["Flannel"] cni --> calico["Calico"] cni --> cilium["Cilium"]
常见 CNI 选型对比:
| 特性 | Flannel | Calico | Cilium |
|---|---|---|---|
| 数据平面 | VXLAN/host-gw | BGP/VXLAN/eBPF | eBPF |
| NetworkPolicy | 不支持 | 支持 | 支持(增强版) |
| 性能 | 一般 | 好 | 最优 |
| 复杂度 | 低 | 中 | 高 |
| 适用场景 | 开发/测试 | 生产环境主流 | 大规模/高性能/安全要求高 |
5.3 通信路径
Pod-to-Pod(同 Node)——通过 Linux 网桥:
graph LR A["Pod A"] --> veth1["veth pair"] --> bridge["cbr0 bridge"] --> veth2["veth pair"] --> B["Pod B"]
每个 Pod 有一对 veth(虚拟以太网设备),一端在 Pod 的 Network Namespace 中,另一端连接到 Node 上的网桥。同 Node 的 Pod 通过网桥直接二层转发。
Pod-to-Pod(跨 Node)——通过 Overlay/路由:
graph LR A["Pod A"] --> veth --> NA["Node A"] -->|"VXLAN/BGP/..."| NB["Node B"] --> veth2["veth"] --> B["Pod B"]
跨 Node 通信需要 CNI 插件来解决。VXLAN 方案将 Pod 的二层帧封装在 UDP 中传输(Overlay),BGP 方案直接通过路由协议让 Node 之间互相学习 Pod 网段的路由(Underlay)。
Pod-to-Service——通过 iptables/IPVS DNAT:
graph LR Pod -->|"ClusterIP(虚拟IP)"| iptables["iptables/IPVS DNAT"] --> Backend["Pod(后端)"]
6. 存储模型
6.1 抽象层次
K8s 存储的设计体现了关注点分离:开发者不需要知道底层是 NFS 还是 AWS EBS,运维不需要知道应用怎么用存储,基础设施团队不需要知道业务逻辑。
graph TB
subgraph 开发者视角
Volume --> PVC
end
subgraph 运维视角
StorageClass --> PV
end
subgraph 基础设施视角
CSIDriver["CSI Driver"] --> Storage["实际存储
(NFS/Ceph/EBS...)"]
end
PVC <-->|"绑定"| PV- 开发者只需声明 PVC:
"我需要 10Gi 的 ReadWriteOnce 存储"——不关心底层实现 - 运维定义 StorageClass:
"用 AWS gp3 类型,IOPS 3000"——定义存储"套餐" - CSI Driver 负责与实际存储系统对接——屏蔽各存储厂商的 API 差异
6.2 动态供给(Dynamic Provisioning)
在没有动态供给的年代,运维需要手动创建 PV,开发者再创建 PVC 去绑定——效率极低。动态供给让这个过程自动化:
当 PVC 引用一个 StorageClass 时,CSI Driver 自动创建 PV:
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: data-mysql-0
spec:
storageClassName: fast-ssd # 引用 StorageClass
accessModes: [ReadWriteOnce]
resources:
requests:
storage: 50Gi
CSI Driver 收到请求后:
- 调用云 API 创建磁盘(如 AWS EBS gp3 50Gi)
- 创建对应的 PV 对象
- 将 PV 与 PVC 绑定
6.3 CSI 驱动架构
graph LR
subgraph controller["CSI Controller Plugin"]
cv["CreateVolume"]
dv["DeleteVolume"]
cp["ControllerPublish"]
cu["ControllerUnpublish"]
end
subgraph node["CSI Node Plugin(每个 Node 一个)"]
ns["NodeStageVolume"]
np["NodePublishVolume"]
nc["NodeGetCapabilities"]
endController Plugin(通常以 Deployment 部署,集群中只需一个)负责卷的全局操作——调用云 API 创建/删除磁盘、将磁盘挂接到指定 Node。
Node Plugin(通常以 DaemonSet 部署,每个 Node 一个)负责卷在 Node 本地的操作——格式化磁盘、将磁盘挂载到 Pod 的容器目录。
7. 参考资料
| 资源 | 链接 | 说明 |
|---|---|---|
| Kubernetes 官方文档 | kubernetes.io/docs | 最权威的一手资料 |
| Kubernetes API Reference | API 规范 | API 详细规范 |
| KEPs(设计提案) | GitHub | 每个功能背后的设计决策 |
| Kubernetes 源码 | GitHub | 重点看 pkg/controller/、pkg/scheduler/、pkg/kubelet/ |
| client-go | GitHub | Informer 和 Work Queue 的源码 |
| Kubernetes in Action (2nd Ed) | Marko Lukša | 最全面的 K8s 技术书 |
| Programming Kubernetes | Hausenblas & Schimanski | 深入 client-go 与 Operator 开发 |
| Kubernetes: Up and Running (3rd Ed) | Burns, Beda, Hightower | K8s 创始人写的入门到进阶 |
| Managing Kubernetes | Burns & Tracey | 集群运维与管理 |
| "The Global Control Plane" | YouTube | Tim Hockin — K8s 网络核心开发者 |
| K8s Certificates 图解 | jvns.ca | Julia Evans 通俗易懂技术图解 |
| Container Design Patterns | USENIX | Brendan Burns — Pod 设计模式学术论文 |
| 揭秘 K8s 调度器 | 阿里云 | 调度器源码级分析 |
| CNCF Blog | cncf.io/blog | 云原生生态官方博客 |
| Learnk8s Blog | learnk8s.io | 高质量 K8s 深度技术文章 |
| Arthur Chiao | arthurchiao.art | 中文 K8s 网络/eBPF 技术博客 |
| Jimmy Song | jimmysong.io | 云原生中文社区活跃贡献者 |
| KubeCon 录像 | CNCF YouTube | 历年演讲录像 |
| Life of a Packet | Michael Rubin | 深入理解 K8s 网络数据路径 |
本文基于 Kubernetes v1.30+ 版本撰写。K8s 迭代速度快,部分细节可能随版本更新而变化,建议对照官方文档验证。