Skip to content

实验一:容器运行时解剖与 Pod 全生命周期深度实操 ​

0. 实验目标与环境基线 ​

本实验紧密贴合你的 Mac mini M4 + Lima (Rocky Linux 9 ARM64) 三节点集群,从宿主机 Linux 内核(PID、Cgroup v2、Namespace)与 containerd 底座出发,完整走通 Static Pod 自恢复、Pause 共享底座、Init/Sidecar/Hooks、三大健康探针、QoS/OOM 限制以及宿主机异常 PID 反查 Pod 的全链路。

节点角色Lima 实例名Linux 主机名节点 IP核心实验组件
Control Planemasterlima-master192.168.104.1kubelet、containerd、Static Pods (/etc/kubernetes/manifests)
Worker 1node01lima-node01192.168.104.3ctr、crictl、nsenter、业务 Pod 运行与 Cgroup 观测
Worker 2node02lima-node02192.168.104.4业务 Pod 对比节点

包含的 7 个核心实操点 ​

  1. 实验点 1.1:Static Pod 控制面自恢复与 Mirror Pod 机制验证
  2. 实验点 1.2:Containerd 双工具链(crictl vs ctr -n k8s.io)与 nsenter 无 Shell 容器穿透排障
  3. 实验点 1.3:Pod 内部世界解剖——验证 pause 容器、Init 容器、Sidecar 共享存储与共享网络
  4. 实验点 1.4:三大探针(startupProbe / readinessProbe / livenessProbe)状态切换与流量摘除实验
  5. 实验点 1.5:Lifecycle Hooks(postStart / preStop)优雅停机与 30s 信号机制验证
  6. 实验点 1.6:资源配额(requests/limits)、QoS 等级判定、底层 Cgroup 参数核对与 OOMKilled 复现
  7. 实验点 1.7:Downward API 元数据注入 + 宿主机 top/ps 异常高负载 PID 逆向定位 Pod 实战

1. 实验前准备:创建独立实验命名空间 ​

在 lima-master 上执行(或在 macOS 终端通过 limactl shell master 进入):

bash
limactl shell master

# 创建实验一专属命名空间并切换默认上下文命名空间
kubectl create namespace lab1-pod
kubectl config set-context --current --namespace=lab1-pod

# 确认三台节点状态均为 Ready
kubectl get nodes -o wide

2. 实验点 1.1:Static Pod 控制面自恢复与 Mirror Pod 验证 ​

原理回顾:Master 上的 etcd、kube-apiserver、kube-controller-manager、kube-scheduler 是由本机 kubelet 直接监控 /etc/kubernetes/manifests/ 启动的静态 Pod。API Server 中看到的同名 Pod 只是只读的 Mirror Pod(影子 Pod)。

步骤 1:对比 API 视角与 CRI 容器视角 ​

在 lima-master 执行:

bash
# 1. 查看静态 Pod YAML 目录
sudo ls -l /etc/kubernetes/manifests/

# 2. 从 API Server 视角查看 Mirror Pod
kubectl get pods -n kube-system -l tier=control-plane -o wide

# 3. 从 containerd CRI 视角查看真实的 kube-scheduler 容器 ID
sudo crictl ps --name kube-scheduler

步骤 2:模拟进程崩溃(停止容器)并观察 Kubelet 秒级自恢复 ​

bash
# 获取 kube-scheduler 的容器 ID 并强制停止它
SCHED_CID=$(sudo crictl ps --name kube-scheduler -q)
echo "Stopping container: $SCHED_CID"
sudo crictl stop "$SCHED_CID"

# 立即再次查看 kube-scheduler 容器状态(观察 STATE、CREATED 时间与 ATTEMPT 计数 +1)
sleep 3
sudo crictl ps -a --name kube-scheduler

预期现象:旧容器状态变为 Exited,而 kubelet 在 1~2 秒内自动拉起了一个全新的 kube-scheduler 容器,ATTEMPT 计数加 1。

步骤 3:尝试通过 kubectl delete pod 删除 Mirror Pod ​

bash
kubectl delete pod -n kube-system kube-scheduler-lima-master
kubectl get pod -n kube-system kube-scheduler-lima-master

预期现象:虽然提示 deleted,但 Mirror Pod 瞬间重新出现,且底层容器根本未被重启(因为 /etc/kubernetes/manifests/kube-scheduler.yaml 文件未变)。

步骤 4:通过移出 Manifest 文件彻底停止与恢复 Static Pod ​

bash
# 将 kube-scheduler.yaml 移到 /tmp(切勿移出 apiserver 或 etcd 以免断连)
sudo mv /etc/kubernetes/manifests/kube-scheduler.yaml /tmp/
sleep 5
sudo crictl ps --name kube-scheduler
kubectl get pod -n kube-system kube-scheduler-lima-master

# 恢复静态 Pod 文件
sudo mv /tmp/kube-scheduler.yaml /etc/kubernetes/manifests/
sleep 5
kubectl get pod -n kube-system kube-scheduler-lima-master

3. 实验点 1.2:Containerd 工具链 (crictl vs ctr) 与 nsenter 穿透排障 ​

原理回顾:

  • ctr 是 containerd 自带的底层 CLI,由于 containerd 支持多命名空间,K8s 创建的所有容器都位于 k8s.io 命名空间下,因此必须带 -n k8s.io。
  • crictl 是专门面向 Kubernetes CRI 的排障工具,原生理解 Pod(Sandbox)概念。
  • 当业务容器没有安装 sh/bash 或 ip/ss/tcpdump 时,可在宿主机找到容器真实 PID,使用 nsenter -t <PID> -n 借用宿主机工具进入容器 Network Namespace 排障。

步骤 1:在 lima-node01 部署一个测试 Pod ​

在 lima-master 执行:

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: runtime-demo
spec:
  nodeName: lima-node01
  containers:
  - name: web
    image: nginx:stable-alpine
    ports:
    - containerPort: 80
EOF

kubectl wait --for=condition=Ready pod/runtime-demo --timeout=60s
kubectl get pod runtime-demo -o wide

步骤 2:登录 lima-node01 对比 crictl 与 ctr ​

新开一个终端进入 node01(limactl shell node01):

bash
# 1. 使用 crictl 查看 Pod Sandbox 和容器
sudo crictl pods --name runtime-demo
sudo crictl ps --name web

# 2. 使用 ctr 查看(注意:不加 -n k8s.io 什么都看不到!)
sudo ctr containers ls
sudo ctr -n k8s.io containers ls | grep runtime-demo
sudo ctr -n k8s.io tasks ls | grep runtime-demo

步骤 3:使用 nsenter 从宿主机直接穿透进容器网络命名空间 ​

仍在 lima-node01 执行:

bash

# 1. 获取 runtime-demo Pod 中 web 容器的 ID
# 注意:--name web 是模糊匹配,也会匹配 webhook 容器
# 因此通过 Pod 名称和容器名称精确筛选
CID=$(sudo crictl ps -o json | jq -r '
  .containers[]
  | select(
      .metadata.name == "web"
      and .labels["io.kubernetes.pod.name"] == "runtime-demo"
    )
  | .id
')

echo "Container ID: $CID"

# 2. 提取容器主进程在宿主机上的真实 PID
# 旧方法:grep -m1 '"pid":'
# 错误原因:inspect JSON 中存在多个 pid 字段
# 第一个 pid 可能是容器内部的 PID 1,而不是宿主机 PID
# 新方法:jq 精确读取 .info.pid,避免错误匹配
PID=$(sudo crictl inspect "$CID" | jq -r '.info.pid')

echo "Container Host PID: $PID"

# 3. 进入容器的 Network Namespace,查看 Pod IP
sudo nsenter -t "$PID" -n ip -4 addr

# 4. 查看容器网络命名空间中的监听端口
sudo nsenter -t "$PID" -n ss -tulpn

核心收获:即使容器是极简的 scratch / distroless 镜像(连 sh 都没有),只要在宿主机拿到 PID,通过 sudo nsenter -t $PID -n tcpdump -i eth0 -nn 就能直接在容器网卡上抓包!


4. 实验点 1.3:解剖 Pod 内部——Pause 底座、Init 容器与 Sidecar 模式 ​

原理回顾:

  1. Init 容器在业务容器启动前串行执行,常用于等待依赖就绪或初始化配置。
  2. 业务容器与 Sidecar 容器并行运行,且与 pause 容器共享同一个 Network Namespace(可通过 localhost 互通)和同一个 emptyDir 存储卷。

步骤 1:部署包含 Init 容器 + 主容器 + Sidecar 容器的综合 Pod ​

回到 lima-master 执行:

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: pod-anatomy
spec:
  nodeName: lima-node01

  volumes:
    - name: shared-logs
      emptyDir: {}

  initContainers:
    - name: init-step1-config
      image: busybox:1.36
      command:
        - sh
        - -c
        - |
          echo 'Init Step 1: Preparing environment...'
          sleep 2
          echo 'Initialized by InitContainer' > /data/init.txt
      volumeMounts:
        - name: shared-logs
          mountPath: /data

  containers:
    - name: main-app
      image: nginx:stable-alpine
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/nginx

    - name: log-sidecar
      image: busybox:1.36
      command:
        - sh
        - -c
        - tail -F /logs/access.log /logs/init.txt
      volumeMounts:
        - name: shared-logs
          mountPath: /logs
          readOnly: true
EOF


kubectl wait --for=condition=Ready pod/pod-anatomy --timeout=90s

步骤 2:验证共享网络(Localhost)与共享存储(Sidecar 采集日志) ​

bash
# 1. 从 log-sidecar 容器内通过 127.0.0.1 访问 main-app 的 80 端口(验证共享 Network Namespace)
kubectl exec pod-anatomy -c log-sidecar -- wget -qO- http://127.0.0.1:80 | head -n 5

# 查看 Init Container 日志
kubectl logs pod-anatomy -c init-step1-config

# 查看共享文件
kubectl exec pod-anatomy -c log-sidecar -- cat /logs/init.txt

# 查看 Sidecar 日志
kubectl logs pod-anatomy -c log-sidecar

步骤 3:验证 Pod 容器共享 Network Namespace ​

在 lima-node01 执行:

shell
# 查看 Pause、Nginx、Sidecar 进程
ps -ef | grep -E 'pause|nginx|tail -F' | grep -v grep

# 比较三个进程的网络命名空间
for pid in 2853816 2853925 2853970; do
  sudo readlink /proc/$pid/ns/net
done

结果: 三个 net:[编号] 相同,证明共享同一个网络命名空间。PID 需按实际结果调整。


5. 实验点 1.4:三大探针(Startup / Readiness / Liveness)状态联动与流量摘除 ​

原理回顾:

  • startupProbe:保护慢启动应用;未通过前,livenessProbe 和 readinessProbe 不会开始。
  • readinessProbe:失败时不重启容器,但会将 Pod Ready 置为 False 并从 Service EndpointSlice 中移除,切断流量。
  • livenessProbe:失败时直接杀掉容器并按 restartPolicy 重启(RESTARTS 计数 +1)。

步骤 1:部署带三类探针的 Pod 与对应的 Service ​

在 lima-master 执行:

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: probe-demo
  labels:
    app: probe-demo
spec:
  containers:
  - name: web
    image: nginx:stable-alpine
    lifecycle:
      postStart:
        exec:
          command: ["sh", "-c", "echo 'Healthy' > /usr/share/nginx/html/ready && echo 'Alive' > /usr/share/nginx/html/live"]
    startupProbe:
      httpGet:
        path: /live
        port: 80
      periodSeconds: 2
      failureThreshold: 10
    readinessProbe:
      httpGet:
        path: /ready
        port: 80
      periodSeconds: 3
      failureThreshold: 1
    livenessProbe:
      httpGet:
        path: /live
        port: 80
      periodSeconds: 3
      failureThreshold: 2
---
apiVersion: v1
kind: Service
metadata:
  name: probe-svc
spec:
  selector:
    app: probe-demo
  ports:
  - port: 80
    targetPort: 80
EOF

kubectl wait --for=condition=Ready pod/probe-demo --timeout=60s

步骤 2:破坏 readinessProbe,观察 Service 自动摘除 Endpoint(不重启容器) ​

bash
# 1. 确认当前 EndpointSlice 包含 probe-demo 的 IP 且 ready=true
kubectl get endpointslice -l kubernetes.io/service-name=probe-svc

# 2. 删除容器内的 /ready 文件,使 readinessProbe 返回 404
kubectl exec probe-demo -- rm -f /usr/share/nginx/html/ready
sleep 5

# 3. 观察 Pod 状态(STATUS 仍是 Running,RESTARTS=0,但 READY 变成 0/1!)
kubectl get pod probe-demo

# 4. 再次查看 EndpointSlice(ready 已变为 false,流量已被切断!)
"kubectl get endpointslice -l kubernetes.io/service-name=probe-svc -o yaml | grep -A 5 conditions"

# 5. 恢复 /ready 文件,观察 3 秒后自动恢复 Ready 1/1
kubectl exec probe-demo -- sh -c "echo 'Healthy' > /usr/share/nginx/html/ready"
sleep 4
kubectl get pod probe-demo

步骤 3:破坏 livenessProbe,观察容器自动重启自愈 ​

bash
# 删除 /live 文件,触发 livenessProbe 连续 2 次 404 失败
kubectl exec probe-demo -- rm -f /usr/share/nginx/html/live

# 等待 8 秒后查看 Pod,观察 RESTARTS 变为 1,且重启后因 postStart 重新生成了文件而恢复 1/1 Running!
sleep 8
kubectl get pod probe-demo
kubectl describe pod probe-demo | tail -n 15

6. 实验点 1.5:PreStop 优雅停机钩子验证 ​

原理回顾:删除 Pod 时,Kubelet 会先同步执行 preStop 钩子,再向容器 PID 1 发送 SIGTERM,总时间受 terminationGracePeriodSeconds(默认 30s)限制。

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: graceful-demo
spec:
  terminationGracePeriodSeconds: 15
  containers:
  - name: app
    image: busybox:1.36
    command: ["sh", "-c", "echo 'App running...' && tail -f /dev/null"]
    lifecycle:
      preStop:
        exec:
          command: ["sh", "-c", "echo '>>> [PreStop] Deregistering from service mesh, draining connections for 5s...' > /proc/1/fd/1 && sleep 5 && echo '>>> [PreStop] Cleanup done!' > /proc/1/fd/1"]
EOF

kubectl wait --for=condition=Ready pod/graceful-demo --timeout=60s

# 在后台触发删除,同时前台实时跟踪容器日志,亲眼看到 PreStop 输出!
kubectl delete pod graceful-demo --wait=false
kubectl logs -f graceful-demo

7. 实验点 1.6:Requests/Limits、QoS 等级、底层 Cgroup v2 核对与 OOMKilled 复现 ​

原理回顾:

  • requests = limits(CPU 和内存均相等)→ Guaranteed
  • 设了部分 requests 或 requests < limits → Burstable
  • 什么都不设 → BestEffort
  • Rocky Linux 9 默认使用 Cgroup v2,容器的 CPU 与内存限制直接映射在 /sys/fs/cgroup/kubepods.slice/ 下。

步骤 1:一键创建三个不同 QoS 等级的 Pod 并核对 qosClass ​

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: qos-guaranteed
spec:
  nodeName: lima-node01
  containers:
  - name: app
    image: busybox:1.36
    command: ["sleep", "3600"]
    resources:
      requests:
        cpu: "200m"
        memory: "64Mi"
      limits:
        cpu: "200m"
        memory: "64Mi"
---
apiVersion: v1
kind: Pod
metadata:
  name: qos-burstable
spec:
  nodeName: lima-node01
  containers:
  - name: app
    image: busybox:1.36
    command: ["sleep", "3600"]
    resources:
      requests:
        cpu: "100m"
        memory: "32Mi"
      limits:
        cpu: "500m"
        memory: "128Mi"
---
apiVersion: v1
kind: Pod
metadata:
  name: qos-besteffort
spec:
  nodeName: lima-node01
  containers:
  - name: app
    image: busybox:1.36
    command: ["sleep", "3600"]
EOF

kubectl wait --for=condition=Ready pod/qos-guaranteed pod/qos-burstable pod/qos-besteffort --timeout=60s

# 打印三个 Pod 的实际 QoS 等级
kubectl get pod qos-guaranteed qos-burstable qos-besteffort \
  -o custom-columns=NAME:.metadata.name,QOS:.status.qosClass

步骤 2:在 lima-node01 宿主机查看容器对应的 Linux Cgroup 真实限制值 ​

在 lima-node01 执行:

bash

# 1. 根据 Pod 名称精确获取容器 ID
CID=$(sudo crictl ps -o json | jq -r '
  .containers[]
  | select(.labels["io.kubernetes.pod.name"] == "qos-guaranteed")
  | .id
')

echo "Container ID: $CID"

# 2. 获取容器主进程在宿主机上的真实 PID
# 不能用 grep -m1 '"pid":',可能错误匹配容器内部 PID 1
PID=$(sudo crictl inspect "$CID" | jq -r '.info.pid')

echo "Host PID: $PID"

# 3. 获取容器实际的 Cgroup v2 路径
CGROUP_PATH="/sys/fs/cgroup$(awk -F: '$1=="0" {print $3}' /proc/"$PID"/cgroup)"

echo "Cgroup Path: $CGROUP_PATH"

# 4. 查看内存硬限制
cat "$CGROUP_PATH/memory.max"

# 5. 查看 CPU 配额和周期
cat "$CGROUP_PATH/cpu.max"

步骤 3:触发容器内存超限 OOMKilled ​

回到 lima-master 执行(限制内存 32Mi,但让 dd 在内存盘 /dev/shm 写入 60M 数据):

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: oom-test
spec:
  restartPolicy: Never
  containers:
  - name: mem-hog
    image: busybox:1.36
    command: ["sh", "-c", "dd if=/dev/zero of=/dev/shm/fill bs=1M count=60"]
    resources:
      requests:
        memory: "16Mi"
      limits:
        memory: "32Mi"
EOF

sleep 6
kubectl get pod oom-test
kubectl describe pod oom-test | grep -A 6 "Last State\|State:"

预期现象:Pod 状态变为 OOMKilled(Exit Code: 137),清晰展示了不可压缩资源超限被 Cgroup OOM Killer 强杀的行为。


8. 实验点 1.7:Downward API 注入与宿主机异常 PID 逆向反查 Pod ​

步骤 1:部署带 Downward API 注入并模拟 CPU 消耗的 Pod ​

在 lima-master 执行:

bash
cat <<'EOF' | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: downward-and-cpu-hog
  labels:
    team: ai-platform
spec:
  nodeName: lima-node01
  containers:
  - name: worker
    image: busybox:1.36
    # 启动一个后台死循环消耗少量 CPU 便于 ps 定位,同时打印 Downward API 注入的信息
    command:
    - sh
    - -c
    - |
      echo "=== Downward API Env ==="
      echo "MY_POD_NAME=$MY_POD_NAME"
      echo "MY_POD_IP=$MY_POD_IP"
      echo "MY_NODE_NAME=$MY_NODE_NAME"
      echo "MY_MEM_LIMIT=$MY_MEM_LIMIT"
      echo "=== Downward API Volume ==="
      cat /etc/podinfo/labels
      echo ""
      # 启动一个特征进程模拟业务计算
      sha256sum /dev/zero
    env:
    - name: MY_POD_NAME
      valueFrom:
        fieldRef:
          fieldPath: metadata.name
    - name: MY_POD_IP
      valueFrom:
        fieldRef:
          fieldPath: status.podIP
    - name: MY_NODE_NAME
      valueFrom:
        fieldRef:
          fieldPath: spec.nodeName
    - name: MY_MEM_LIMIT
      valueFrom:
        resourceFieldRef:
          containerName: worker
          resource: limits.memory
    resources:
      requests:
        cpu: "100m"
        memory: "32Mi"
      limits:
        cpu: "200m"
        memory: "64Mi"
    volumeMounts:
    - name: podinfo
      mountPath: /etc/podinfo
  volumes:
  - name: podinfo
    downwardAPI:
      items:
      - path: "labels"
        fieldRef:
          fieldPath: metadata.labels
EOF

kubectl wait --for=condition=Ready pod/downward-and-cpu-hog --timeout=60s
kubectl logs downward-and-cpu-hog

步骤 2:在 lima-node01 模拟 SRE 从宿主机异常 PID 反查到具体 K8s Pod ​

切换到 lima-node01 终端执行完整反查三步曲:

bash
# 第一步:查找 CPU 占用较高的 sha256sum 进程
ROGUE_PID=$(ps -eo pid,pcpu,comm --sort=-pcpu |
  awk '$3=="sha256sum" {print $1; exit}')

echo "1. 异常进程 PID: $ROGUE_PID"

# 第二步:查看进程及其父进程
PPID_TARGET=$(ps -o ppid= -p "$ROGUE_PID" | tr -d ' ')
ps -fp "$ROGUE_PID" -p "$PPID_TARGET"

# 查看进程所属的 Cgroup
cat "/proc/$ROGUE_PID/cgroup"

# 从 Cgroup 路径提取完整的 64 位 Container ID
CONTAINER_ID=$(grep -oE 'cri-containerd-[0-9a-f]{64}' \
  "/proc/$ROGUE_PID/cgroup" |
  head -n1 | sed 's/cri-containerd-//')

echo "2. Container ID: $CONTAINER_ID"

# 第三步:通过 CRI 查询容器所属的 Pod
sudo crictl ps --id "$CONTAINER_ID"

# 使用 jq 精确提取 Pod Sandbox ID
POD_ID=$(sudo crictl ps -o json |
  jq -r --arg cid "$CONTAINER_ID" '
    .containers[]
    | select(.id == $cid)
    | .podSandboxId
  ')

echo "3. Pod Sandbox ID: $POD_ID"

# 第四步:查看 Pod 名称和 Namespace
sudo crictl pods --id "$POD_ID"

9. 实验一环境清理(保持集群干净) ​

在 lima-master 执行:

bash
kubectl config set-context --current --namespace=default
kubectl delete namespace labl-pod