Kubernetes:声明意图,控制器维持世界

一、引言

容器解决了”可重复交付”——固定镜像内容,缩小了不同机器之间用户态依赖的差异;内核、架构、配置和外部数据仍要单独管理。但它没有回答一个更大的问题:一百个容器,谁来管?

容器崩了谁来重启?流量该发给哪个容器?版本升级时怎么做到不停服?新机器加入时怎么把容器分配过去?这些问题,docker run 一条命令回答不了。

Kubernetes 是这个问题的系统性回答。但要真正理解它,需要先理解它翻转了什么。

二、为什么:容器编排是状态管理问题

脚本的天花板

手写脚本是第一反应。启动脚本、监控脚本、重启脚本——每家公司都写过这套东西。但脚本有一个根本性的局限:它描述的是步骤序列,不是期望状态。

# 典型的运维脚本
docker run -d --name app myapp:v1
if ! docker inspect app; then
  docker restart app
fi

步骤执行完了,系统不一定在你期望的状态。容器在跑,但应用 crash loop 了怎么办?节点宕机了,谁来在另一台机器上把容器重新拉起来?脚本只能覆盖你预见到的场景,而分布式系统的失败模式是无穷的。

脚本当然可以继续加入重试、状态记录和对账;但走到这里,你实际上开始编写自己的控制器。规模下的难题,是这些责任由每个团队重复承担,还是交给一个可以共同维护的机制。

核心矛盾:期望状态与现实状态的持续偏差

大规模运行容器的核心矛盾是:你想要的状态和系统实际处于的状态,会持续产生偏差。

节点会宕机,容器会 OOM,镜像会拉取失败,网络会抖动。每一次偏差,如果靠人工介入纠正,人就会不断被拉回已经解决过的问题。增长速度因系统而异,但这类重复工作很难靠增加注意力长期承受。

解法不是”更快地发现偏差然后人工修复”,而是让系统自己持续地把偏差收敛回去。

声明式翻转:谁承担复杂性

Kubernetes 的回答是一个认知翻转:不要告诉系统做什么,告诉系统世界应该是什么样子。

命令式思维:
启动 3 个 myapp:v1 容器
如果某个容器挂了,重启它
把流量分配到可用容器
# 声明副本;稳定流量入口还需要单独的 Service
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:v1

你提交 YAML,描述的是期望状态(desired state)。Kubernetes 观察现实状态(observed state),发现偏差就采取行动。容器退出,按策略重启;节点故障,在检测、驱逐和资源条件满足后创建替代 Pod;副本数不够,尝试补足——自愈不是魔法,是这个收敛循环在运行。

复杂性没有消失,而是从”运维工程师脑子里的步骤序列”转移到了”控制器里的收敛逻辑”——这个转移让复杂性变得可复用、可测试、可扩展。

持续收敛为什么适合这类问题

kubectl apply 成功返回,不代表 pod 在跑,只代表 API Server 接受了你的声明。这看起来像是缺陷,实际上是大规模系统的必然选择。

跨节点工作负载的启动、网络和存储很难被包进一个全局原子事务。Kubernetes 把 API 对象的持久化与后续动作分开:局部失败可以重试,不必等整个世界一起完成。但持续收敛不等于承诺一定到达——镜像不存在、容量不足或依赖损坏时,系统会一直停在中间。etcd 的一致性机制与工作负载的异步收敛属于不同层,不能用其中一层的保证替代另一层。

代价是你必须接受一个新的心智模型:提交声明之后,你观察的不是”成功还是失败”,而是”收敛到了哪里”。

三、怎么设计:控制面与数据面

Kubernetes 的架构核心是一个分离:控制面负责决策,数据面负责执行。两者通过 API 解耦。控制面短时不可用时,健康节点上的已有容器和已编程网络规则通常还能工作;但更新、调度和部分服务发现会停滞,依赖 API 的应用也可能受影响。

控制面——决策的大脑

API Server:集群的唯一入口。在 Kubernetes 核心对象的读写路径上,kubectl、控制器、Scheduler 和 kubelet 主要通过 API Server 协调;这不代表所有网络通信都经过它,例如 kubelet 会直接调用本机容器运行时。API Server 负责认证、授权、准入控制,然后把状态持久化到 etcd。它是无状态的,可以水平扩展。

etcd:核心 Kubernetes API 对象的持久化存储,保存声明与组件上报的状态;它不是应用数据库或全部运行证据。Raft 提供一致的提交顺序,但客户端缓存和 watch 进度仍可能不同。失去可用 quorum 后,可靠读写受阻,控制面无法正常推进;已有工作负载能维持多久,要看其依赖与节点健康。

Controller Manager:控制循环的集合体。它运行着数十个控制器(Deployment 控制器、ReplicaSet 控制器、Node 控制器……),每个控制器持续 watch 自己关心的资源,发现现实状态和期望状态不一致就采取行动。控制器通过 API Server 读取对象,并维护本地缓存和队列;权威状态不依赖某个控制器进程的内存。重启后可以重新列举和对账,而非直接读写 etcd。

Scheduler:做一件事:把还没有分配节点的 pod 分配到合适的节点上。它观察未调度的 pod,根据 pod 的资源需求(requests)、亲和性规则、污点/容忍,计算出最合适的节点,然后把绑定关系写回 API Server。Scheduler 只负责”分配到哪”,不负责”怎么跑起来”。

数据面——执行的手脚

kubelet:每个节点上的代理,Kubernetes 在节点上的”手”。它 watch API Server,一旦发现有 pod 被调度到本节点,就负责把这个 pod 的容器真正跑起来(通过 CRI 调用容器运行时)。它还持续上报节点状态和 pod 状态,让控制面知道数据面的实际情况。

kube-proxy:实现 Service 抽象的网络组件。它在节点上维护 Service 转发规则,具体可使用 iptables、nftables 等模式。Cilium 的 eBPF kube-proxy replacement 是另一种实现,需要明确启用与匹配环境;不是 kube-proxy 本身自动变成 eBPF。

容器运行时:通过 CRI(Container Runtime Interface)接入,实际负责创建和管理容器。常见的有 containerd 和 CRI-O。kubelet 不关心具体用哪个运行时,只要符合 CRI 接口即可——这是 01-Container-隔离是手段,交付是目的 里 OCI 标准化的延伸。

reconciliation loop: watch → diff → act

reconciliation loop 是 Kubernetes 里最重要的设计范式,所有控制器都在跑同一个结构:

loop:
    current = 观察现实状态(从 API Server watch)
    desired = 读取期望状态(从 etcd via API Server)
    if current != desired:
        act()   # 采取行动缩小差距
    sleep(一小会儿)

这个循环的关键性质:

  • 幂等与重试:重复对账应避免重复创建等不必要副作用;具体动作仍需处理超时、部分成功和并发。
  • 自愈:在控制器识别并拥有的范围内尝试修复偏差。坏配置、数据损坏、容量耗尽不会仅因存在循环就被治好。
  • 可扩展:你可以写自己的控制器,监听自己定义的资源类型——这是 Operator 模式的基础

从 kubectl apply 到 pod 运行:请求的完整旅程

sequenceDiagram
    autonumber
    participant Dev as 开发者 (kubectl)
    participant API as API Server
    participant etcd as etcd
    participant CM as Controller Manager
    participant Sched as Scheduler
    participant KL as kubelet (节点)

    Dev->>API: kubectl apply -f deployment.yaml
    API->>API: 认证 → 授权 → 准入控制
    API->>etcd: 写入 Deployment 对象
    CM->>API: Watch 到新 Deployment
    CM->>API: 请求创建 ReplicaSet
    API->>etcd: 持久化 ReplicaSet
    CM->>API: 请求创建 3 个 Pod(尚未绑定节点)
    API->>etcd: 持久化 Pod
    Sched->>API: Watch 到未调度 Pod
    Sched->>API: 提交 Pod 绑定
    API->>etcd: 持久化绑定结果
    KL->>API: Watch 到分配给本节点的 Pod
    KL->>KL: 通过 CRI 启动容器
    KL->>API: 上报容器状态与就绪条件

这张图展示的是声明与对象状态的协调路径:控制器、调度器和 kubelet 通过 API Server 读写核心对象,不直接写 etcd。图外还有镜像拉取、CRI 调用、网络与存储等执行链路。这是 Kubernetes 能水平扩展且故障隔离的关键。

四、上手:在集群里把第一个应用跑起来

准备集群:kind / k3s / minikube 怎么选

本地开发和学习阶段,不需要真正的多节点集群:

工具适合场景特点
kindCI 环境、本地测试用容器运行 Kubernetes 节点,支持多节点拓扑,需可用容器运行时
k3s边缘 / 低资源环境、也适合本地轻量化 K8s,组件与默认配置较精简,适合 Linux 环境
minikube本地开发、需要插件生态提供多种驱动与插件,实际占用随配置变化

本文用 kind 做可丢弃实验,它运行真正的 Kubernetes 组件,但不代表生产网络、存储或故障域。先准备 Docker 等受支持的运行时,并记录 kind 与节点镜像版本:

# 安装 kind(macOS)
brew install kind kubectl
 
# 创建一个单节点集群
kind create cluster --name my-cluster
 
# 验证集群正常
kubectl cluster-info
kubectl get nodes

第一个 Deployment:写 YAML,apply,查状态

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
  namespace: default
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: nginx:1.25-alpine    # 用 nginx 做示例
        ports:
        - containerPort: 80
# 提交声明
kubectl apply -f deployment.yaml
 
# 观察 Deployment 状态(READY 显示几个副本就绪)
kubectl get deployment myapp
# NAME    READY   UP-TO-DATE   AVAILABLE
# myapp   3/3     3            3
 
# 查看 Pod 列表
kubectl get pods -l app=myapp
# NAME                     READY   STATUS    RESTARTS
# myapp-7d6b9c8f4-2xk9p   1/1     Running   0
# myapp-7d6b9c8f4-5nvml   1/1     Running   0
# myapp-7d6b9c8f4-r8qwt   1/1     Running   0

基础四件套:get / describe / logs / exec

这四个命令构成日常操作的基本入口:

# get:看资源的当前状态(快速概览)
kubectl get pods                          # 列出所有 Pod
kubectl get pods -o wide                  # 加上节点 IP、所在节点
kubectl get all                           # 列出 all 类别的常用资源,并非所有类型
 
# describe:看资源的详细信息和事件(排查问题的第一步)
kubectl describe pod myapp-7d6b9c8f4-2xk9p
# 输出包含:容器状态、资源限制、挂载的卷、最近的 Events
# Events 部分是排查问题最有价值的信息
 
# logs:看容器日志
kubectl logs myapp-7d6b9c8f4-2xk9p        # 当前日志
kubectl logs -f myapp-7d6b9c8f4-2xk9p     # 实时追踪
kubectl logs myapp-7d6b9c8f4-2xk9p -p     # 查看上一个容器的日志(容器重启后)
 
# exec:进入容器执行命令
kubectl exec -it myapp-7d6b9c8f4-2xk9p -- /bin/sh
kubectl exec myapp-7d6b9c8f4-2xk9p -- env   # 查看环境变量

暴露服务:ClusterIP / NodePort / LoadBalancer 各自的场景

Pod 有 IP,但 Pod 的 IP 是不稳定的——同一 Pod 内容器重启不一定换 IP,但替代 Pod 的 IP 可能变化。Service 提供稳定的访问入口,把流量路由到匹配 label 的 Pod。

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: myapp-svc
spec:
  selector:
    app: myapp          # 匹配带这个 label 的所有 Pod
  ports:
  - port: 80
    targetPort: 80
  type: ClusterIP       # 默认类型

三种 Service 类型的使用场景:

类型访问范围典型场景
ClusterIP只能集群内部访问服务间调用(后端调数据库、服务 A 调服务 B)
NodePort通过节点 IP + 端口从外部访问开发测试、没有云负载均衡器的环境
LoadBalancer由已安装的云或本地控制器提供负载均衡入口需要稳定外部入口;裸集群不保证自动得到地址
kubectl apply -f service.yaml
kubectl get svc myapp-svc
 
# 本地测试访问(kind 环境)
kubectl port-forward svc/myapp-svc 8080:80
# 保持上面的进程运行,在另一个终端执行
curl http://localhost:8080

验证自愈:delete pod,看控制器重建

# 记下当前 Pod 名称
kubectl get pods -l app=myapp
 
# 删掉一个 Pod
kubectl delete pod myapp-7d6b9c8f4-2xk9p
 
# 立刻再看——新的 Pod 已经在创建中
kubectl get pods -l app=myapp
# NAME                     READY   STATUS              RESTARTS
# myapp-7d6b9c8f4-5nvml   1/1     Running             0
# myapp-7d6b9c8f4-r8qwt   1/1     Running             0
# myapp-7d6b9c8f4-xk2mp   0/1     ContainerCreating   0   ← 新 Pod

这就是 reconciliation loop 最直观的体现:你删了一个 Pod,ReplicaSet 控制器在下一次循环里发现”现在只有 2 个副本,期望是 3 个”,立刻创建新 Pod 来补足。这里的自愈来自已经实现的 ReplicaSet 控制器。 新 Pod 仍要经过调度、镜像拉取和就绪检查,补足对象数量不等于服务已经恢复。

五、走向生产:让应用跑得稳

配置与密钥:ConfigMap vs Secret

应用的配置(数据库地址、日志级别)和密钥(数据库密码、API Token)不能硬编码在镜像里——镜像要在不同环境复用,密钥更不能进镜像或普通源码仓库;即使后来删除,制品层和 Git 历史仍可能保留它。

ConfigMap 存非敏感配置:

apiVersion: v1
kind: ConfigMap
metadata:
  name: myapp-config
data:
  APP_ENV: "production"
  LOG_LEVEL: "info"
  DATABASE_HOST: "postgres-svc:5432"

Secret 是敏感数据的专用 API 对象,但 base64 只是编码。需要结合最小权限、API 传输保护、etcd 静态加密及密钥生命周期管理;Vault/KMS 是可选组成,不是一个名称就能补齐安全。下例密码仅用于说明编码:

apiVersion: v1
kind: Secret
metadata:
  name: myapp-secret
data:
  DATABASE_PASSWORD: cGFzc3dvcmQxMjM=   # base64("password123")

注入方式有两种,各有适用场景:

# 方式一:环境变量注入(适合少量配置,启动时读取)
env:
- name: APP_ENV
  valueFrom:
    configMapKeyRef:
      name: myapp-config
      key: APP_ENV
- name: DATABASE_PASSWORD
  valueFrom:
    secretKeyRef:
      name: myapp-secret
      key: DATABASE_PASSWORD
 
# 方式二:独立示意片段;volumeMounts 属于 container,volumes 属于 Pod spec
volumeMounts:
- name: config-vol
  mountPath: /app/config
volumes:
- name: config-vol
  configMap:
    name: myapp-config

环境变量注入简单直接,但 ConfigMap 更新后需要重启 Pod 才能生效;普通 ConfigMap 卷会延迟同步新内容,应用仍要自行热加载;使用 subPath 挂载时不会自动接收更新。

健康检查:liveness / readiness / startup 的区别

三种探针解决三个不同的问题,混淆它们是生产事故的常见来源:

探针失败时的动作解决的问题
livenessProbe重启容器应用死锁、进程卡死——容器进程还活着但应用已经无响应
readinessProbe标记未就绪,通常从 Service 可用后端集合移除应用还没准备好接流量——启动中、热身中、依赖不可用
startupProbe成功前抑制 liveness 和 readiness;持续失败后按策略重启启动慢的应用——避免被 liveness 在启动期间误杀

下例是业务容器的配置片段,需放入 containers[];端口和接口必须由应用实现,不能原样套到前面的 nginx 示例。

livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 10
  failureThreshold: 3       # 连续失败 3 次才重启,避免抖动误杀
 
readinessProbe:
  httpGet:
    path: /ready
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5
  failureThreshold: 3       # 失败时从 Service 摘除,成功后重新加入
 
startupProbe:
  httpGet:
    path: /healthz
    port: 8080
  failureThreshold: 30      # 约 300s 的探测预算;实际时序还受延迟与超时影响
  periodSeconds: 10

典型事故:把 readinessProbe 路径指向一个有副作用的接口,导致探针每次调用都触发业务逻辑。或者 livenessProbe 的 initialDelaySeconds 设得太短,应用还在启动就被探针判定为失败,触发无限重启循环(CrashLoopBackOff 的常见原因之一)。

资源管理:requests vs limits

resources:
  requests:
    memory: "128Mi"   # Scheduler 看这个来决定调度到哪个节点
    cpu: "250m"       # 250 毫核 = 0.25 个 CPU
  limits:
    memory: "512Mi"   # 内存限制;回收不足可能触发 OOM,需结合状态判因
    cpu: "500m"       # CPU 超过这个值,内核限速(throttle),不杀容器

核心区别:

  • requests 是调度与资源分配依据——调度器主要比较节点可分配容量与已承诺 requests,不是实时“空闲资源”。CPU request 也影响竞争时的权重。
  • limits 是运行时约束——CPU 配额会节流;内存限制由内核回收与 OOM 机制执行,不应把某个瞬间的超限直接等同于退出。
  • 限额未显式填写时,仍可能由 LimitRange、准入策略或其他默认规则补入;缺少有效约束的工作负载会扩大相互干扰。

生产上先测工作集、峰值与节流情况,再设置 requests 和限制策略。CPU limits 是否设置及设多大,应结合延迟目标和多租户隔离要求判断;过低会放大尾延迟。调度主要看 requests,不能把“limit 设大”直接解释成预留了同样大的资源。Kubernetes 资源管理

滚动更新与回滚

Deployment 默认采用滚动更新(RollingUpdate):逐步增加新 ReplicaSet、减少旧 ReplicaSet。它提供控制更新并发的机制;足够容量、可靠 readiness、连接排空和前后版本兼容,才让不中断成为可检验的目标。

spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1           # 允许的 surge 数;终止中 Pod 的额外资源占用另计
      maxUnavailable: 0     # 不主动让可用副本低于期望值;不保证端到端零错误
# 更新镜像版本
# 将 image 替换成实验可拉取的实际版本,不能把占位名字直接当制品
kubectl set image deployment/myapp myapp=nginx:1.26-alpine
 
# 观察滚动更新过程
kubectl rollout status deployment/myapp --timeout=180s
 
# 查看发布历史
kubectl rollout history deployment/myapp
 
# 回滚到上一个版本
kubectl rollout undo deployment/myapp
 
# 回滚到指定版本
kubectl rollout undo deployment/myapp --to-revision=2

回滚的本质是声明式的:rollout undo 把 Deployment 的 spec 改回之前的版本,控制器重新执行一次滚动更新流程,重新向旧 Pod 模板收敛。它不恢复数据库、卷数据,也不是 Deployment 所有字段的历史快照;应用回退还要检查 schema 与配置兼容性。

终止中的 Pod 可能仍在排空连接并占用资源,实际容量需求可暂时超过 replicas + maxSurge。容量预算要覆盖 terminationGracePeriodSeconds 内的新旧实例重叠。Deployment 更新语义

水平扩缩容

# 手动扩缩容
kubectl scale deployment myapp --replicas=5
 
# 查看当前副本数
kubectl get deployment myapp

HPA(Horizontal Pod Autoscaler) 根据指标自动扩缩:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70    # 相对 CPU requests 的平均利用率目标为 70%

这个 CPU 示例依赖资源指标 API(通常由 metrics-server 提供),并要求相关容器配置 CPU requests。70% 是相对 requests 的利用率目标,不是节点总 CPU 的 70%;控制器还会考虑缺失指标、未就绪 Pod、容差和稳定窗口。自定义与外部指标则需要对应适配器。启用 HPA 后,要避免 GitOps、人工和 HPA 同时争写 replicas。HPA 算法

六、故障剧场:亲手把它弄坏

以下只在可丢弃的 kind 实验集群进行。先确认 kubectl context、正常副本与请求基线;一次只做一个故障,记录时间、事件、实际结果和恢复结果。超出预先约定的观察时间或出现非目标组件故障,就恢复并分析,不为“看见结论”继续破坏。

实验一:kill pod,自愈现形

# 开一个终端持续观察
kubectl get pods -l app=myapp -w
 
# 另一个终端删掉一个 Pod
kubectl delete pod <pod-name>
 
# 观察第一个终端的输出:
# pod-xxx   1/1   Running   0   → Terminating → (消失)
# pod-yyy   0/1   Pending   0   → ContainerCreating → Running

记录替代 Pod 从创建到 Ready 的时间,并把调度、拉镜像和启动阶段分开。Watch 能及时传递变化,但重试、队列与系统负载都会影响反应时间。恢复检查是副本恢复且请求基线恢复,而不只是看到 Running。

实验二:停掉 controller-manager,观察哪一层停止收敛

kind 的控制面组件由 kubelet 按本地 manifest 作为 static Pod 管理。kubectl delete 删除的是 API 中的镜像对象,不会停止底层 static Pod,因此不能用“快速删一下”来模拟控制器停机。Static Pods

下面只针对本文创建的单控制面、Docker 驱动 kind 集群,先确认节点容器名和 manifest 路径。高可用集群还会有其他 leader 候选,这个实验条件不成立。

# 基线:应用 3 个副本 Ready,API Server 与 kubelet 都正常
kubectl config current-context
kubectl get pods -l app=myapp -o wide
docker exec my-cluster-control-plane ls /etc/kubernetes/manifests
 
# 将 manifest 移出 kubelet 监视目录;不要留 .bak 在原目录
# 先检查备份目录不存在同名文件,操作只发生在可丢弃的节点容器内
docker exec my-cluster-control-plane sh -c '
  mkdir -p /tmp/controller-lab &&
  test ! -e /tmp/controller-lab/kube-controller-manager.yaml &&
  mv /etc/kubernetes/manifests/kube-controller-manager.yaml /tmp/controller-lab/
'
 
# 等 kubelet 真正停止它,用节点运行时核对,不只依赖 API 镜像对象
docker exec my-cluster-control-plane crictl ps --name kube-controller-manager
# 确认没有运行中的 controller-manager 后,记录并删除一个应用 Pod
kubectl get pods -l app=myapp
kubectl delete pod <app-pod-name>
kubectl get pods -l app=myapp
 
# 无论是否看到预期现象,都恢复 manifest
docker exec my-cluster-control-plane mv /tmp/controller-lab/kube-controller-manager.yaml /etc/kubernetes/manifests/
kubectl rollout status deployment/myapp --timeout=180s

预期观察是:API 仍接受删除,但 ReplicaSet 控制器缺位时不再补 Pod;恢复控制器后再尝试补齐。要同时记录对应用的请求,检验已有实例究竟是否继续服务。若没有发生预期停机,先检查是否还有控制器实例,不要据此宣称“控制面故障不影响业务”。

实验三:破坏 etcd quorum,单一真相消失

etcd 用 Raft 协议,需要超过半数节点(quorum)才能继续服务写请求。三节点集群允许 1 个节点失败,五节点集群允许 2 个节点失败。

在本地环境模拟 quorum 损失比较复杂,但理解现象比实操更重要:

  • etcd quorum 丢失后,API Server 无法写入新的状态变更——kubectl apply 会挂起或报错
  • 健康节点上的已有容器通常继续运行,但应用依赖、网络与存储仍可能影响服务
  • 控制器无法更新状态——新的 Pod 创建、Service Endpoint 更新全部停止
  • kubectl get 可能因缓存和一致性要求呈现不同结果,也可能阻塞或报错;不能把它解释成可靠读取 etcd 快照

etcd 是集群的”记忆”——记忆丢了,集群失去了判断过去发生了什么的能力,但身体(数据面)还在继续运作。 因此要备份并演练控制面状态恢复,同时另备应用数据、证书与必要凭据。etcd 备份不是全部服务数据的备份。

实验四:手动 kubectl edit,看控制器把你改回去

# 直接编辑 Deployment,把 replicas 改成 1
kubectl edit deployment myapp
# 在编辑器里把 replicas: 3 改成 replicas: 1,保存
 
# 立刻观察——Pod 数量减少到 1
 
# 现在再把它改成 5
kubectl edit deployment myapp
# replicas: 5,保存
 
# Pod 数量扩展到 5
kubectl get pods -l app=myapp

先恢复 kubectl scale deployment myapp --replicas=3,等待 3 个副本 Ready,再反过来做:如果直接改的是 ReplicaSet 而不是 Deployment,会发生什么?

# 找到 ReplicaSet
kubectl get replicaset
 
# 编辑 ReplicaSet 的 replicas(比如改成 1)
kubectl edit replicaset <rs-name>
 
# Pod 数可能短暂变化,也可能中间状态来不及出现;观察最终是否回到 3 个
# 因为 Deployment 控制器在 watch ReplicaSet——
# 它发现 ReplicaSet 的 replicas 和 Deployment spec 不一致,把它改回去了

声明即法律,控制器是执法者——你手动改了 ReplicaSet,Deployment 控制器把它改回来。这是 Kubernetes 最直接的哲学体现:期望状态存在 Deployment 里,由它拥有、且纳入对账的字段会被上层控制器纠正;不是集群里所有字段都受同一个控制器管理。

七、日常排障:K8s 坏了怎么查

Pod 起不来:状态速查

# 第一步:看 Pod 处于什么状态
kubectl get pods
kubectl describe pod <pod-name>    # Events 部分是排查起点

Pending:Pod 已被接受,但容器尚未全部准备好;可能在等待调度,也可能已经绑定节点、正在准备镜像或卷。先看 PodScheduled、节点字段与 Events。

kubectl describe pod <pod-name> | grep -A 10 "Events"

常见原因:

  • Insufficient cpu/memory:没有节点有足够资源满足 requests
  • node(s) had untolerated taint:所有节点都有 Pod 不容忍的污点
  • 0/3 nodes are available:集群没有可用节点

ImagePullBackOff / ErrImagePull:镜像拉取失败。

kubectl describe pod <pod-name> | grep -A 5 "Failed"

常见原因:镜像名字/标签拼错;私有 Registry 未配置 imagePullSecret;网络无法访问 Registry。

# 配置私有 Registry 认证
kubectl create secret docker-registry regcred \
  --docker-server=registry.example.com \
  --docker-username=user \
  --docker-password=pass

创建 Secret 还没有完成关联:它必须与 Pod 位于同一 Namespace,并由工作负载的 Pod spec 引用。把下面片段合并进 Deployment,再观察新 Pod 的拉取事件;Secret 存在不等于镜像名称、权限与网络都正确。私有镜像拉取

spec:
  template:
    spec:
      imagePullSecrets:
        - name: regcred

CrashLoopBackOff:容器反复崩溃重启。默认退避常见为 10s、20s、40s,最高 5 分钟;节点配置和版本特性可能改变这些值,不把这个时钟当恢复保证。

# 看当前容器的日志
kubectl logs <pod-name>
 
# 看上一次崩溃的日志(最有用——崩溃时的最后输出)
kubectl logs <pod-name> --previous
 
# 看容器退出码
kubectl describe pod <pod-name> | grep "Exit Code"

常见原因:应用启动报错(看日志);CMD 命令不存在;livenessProbe 设置太激进导致健康检查启动期间失败;OOMKilled(内存 limit 太小)。

OOMKilled:容器因内存超限被内核杀死。

kubectl describe pod <pod-name> | grep -i "OOMKilled\|exit code\|last state"
# Last State: Terminated  Reason: OOMKilled  Exit Code: 137

先分清容器上限与节点内存压力,核对工作集和最近变更;可能需要调整限额,也可能是泄漏、突发分配或节点容量问题。

服务不通:逐层排查

# 第一层:Pod 本身是通的吗?
kubectl exec <pod-name> -- curl -s http://localhost:8080/health
 
# 第二层:EndpointSlice 中有匹配且就绪的后端吗?
kubectl get endpointslices -l kubernetes.io/service-name=myapp-svc -o yaml
# 无可用后端还可能是未就绪、正在终止或控制器未完成更新,不能只归因 selector
 
# 检查 selector 是否和 Pod 的 label 一致
kubectl get svc myapp-svc -o yaml | grep selector -A 5
kubectl get pods --show-labels
 
# 第三层:集群内 DNS 是否正常?
kubectl exec <any-pod> -- nslookup myapp-svc
kubectl exec <any-pod> -- curl http://myapp-svc/health
 
# 第四层:如果有 Ingress,检查 Ingress 规则和 Controller 状态
kubectl describe ingress <ingress-name>
kubectl get pods -n ingress-nginx    # 检查 Ingress Controller 是否正常

常见原因:Service selector 和 Pod label 不匹配(最常见);Pod 的 readinessProbe 失败导致从可用后端集合移除;容器监听的是 127.0.0.1 而不是 0.0.0.0。

节点异常:NotReady 的处理

# 查看节点状态
kubectl get nodes
# NAME                      STATUS     ROLES
# my-cluster-control-plane  Ready      control-plane
# my-cluster-worker         NotReady   <none>        ← 异常
 
# 查看节点详情
kubectl describe node my-cluster-worker | grep -A 20 "Conditions"
# 关注 MemoryPressure / DiskPressure / PIDPressure / Ready 四个条件
 
# 常见压力信号
# MemoryPressure: True   → 节点内存不足,kubelet 开始驱逐 Pod
# DiskPressure: True     → 磁盘空间不足,清理镜像或日志

节点故障路径包括心跳/Lease 检测、Ready 条件更新、not-ready 或 unreachable 污点,以及 Pod 的 NoExecute 容忍时间。普通 Pod 默认会获得这两类污点的 300 秒容忍,但显式配置、DaemonSet 和控制器速率限制会改变结果。旧的 pod-eviction-timeout 不能概括当前机制。替代 Pod 也不是“原 Pod 搬家”,还要有健康控制面、可调度容量和可用存储。Taints and Tolerations

第一现场:kubectl get events

describe 命令里的 Events 只显示特定资源的事件。kubectl get events 显示整个 namespace 里的所有事件——出了问题先看这里:

# 按时间升序查看事件,最近的在末尾
kubectl get events --sort-by='.lastTimestamp'
 
# 只看 Warning 级别
kubectl get events --field-selector type=Warning
 
# 看特定 Pod 的事件
kubectl get events --field-selector involvedObject.name=<pod-name>

Events 是 Kubernetes 的”系统日志”——调度失败、镜像拉取失败、探针失败、OOM kill,可能在这里留下线索。事件保留有限、也可能聚合或丢失;容器与控制面日志、指标仍需另查。

八、往哪走

Operator 模式:reconciliation loop 带给你自己的领域

Kubernetes 内置的控制器管理 Deployment、Service、ConfigMap 这些通用资源。但如果你要管理一个 PostgreSQL 集群的主从切换,或者一个 Kafka 的 topic 配置——这些业务特定的运维逻辑,内置控制器不懂。

Operator 模式的回答是:用 CRD(Custom Resource Definition)扩展 Kubernetes 的 API,定义你自己的资源类型(比如 PostgresCluster),再写一个自定义控制器 watch 这个资源,执行你的业务运维逻辑。reconciliation loop 这个范式不只是 Kubernetes 内部的实现细节,是一个可以被任何人复用的设计模式。

AI/GPU 工作负载与 DRA

Kubernetes 正在从”微服务编排器”固化为”分布式系统的内核”,而当前最大的压力来自 AI 工作负载。

GPU 和其他加速器的调度问题远比 CPU 复杂:一块 GPU 不能被任意切分;不同型号的 GPU 对模型推理有不同影响;训练任务需要多卡通信拓扑感知。DRA(Dynamic Resource Allocation)是 Kubernetes 对这个问题的系统性回答——用 ResourceClaim 等对象表达设备需求,由驱动参与分配,由驱动实现者定义具体的分配语义。DRA 的核心能力已在 Kubernetes 1.34 达到稳定,后续子特性仍按各自版本演进,也是理解”K8s 如何接管 AI 基础设施”的入口。

这条线的终点:Kubernetes 是本系列实验路线的一块共同地基——IaC 管理 K8s 集群本身,GitOps 把变更同步到 K8s,平台工程在 K8s 之上建 IDP,服务网格运行在 K8s 上,eBPF 优化 K8s 的数据平面。理解 K8s 的控制循环和声明式 API,有助于读懂后续机制;IaC、平台工程与 Serverless 本身并不以 Kubernetes 为必要前提。

关联

参考资料与实践边界

本篇核验日期:2026-10-14。上述命令和故障剧场本轮未部署执行;Pod 名、镜像版本和输出均需按实际实验替换、记录。生产前还要验证工作负载、存储、网络、权限和恢复路径,不能把 YAML 被接受等同于服务验收。