Administrator
Administrator
Published on 2026-09-04 / 22 Visits
0
0

Day2-容器运行时

容器运行时:从runc、gVisor到Kata与microVM

学习目标

完成本篇实操后,应该能够:

  • 说清kubelet、CRI、containerd、shim和runc的职责边界。
  • 解释为什么containerd不直接长期托管容器进程。
  • 区分Image、Container、Task和Pod Sandbox。
  • 理解OCI Image Spec、Runtime Spec和Distribution Spec分别规范什么。
  • 区分runc、gVisor、Kata Containers、Firecracker和KVM所在的技术层次。
  • 理解共享内核、用户态内核与microVM三种隔离模型的安全边界。
  • 使用RuntimeClass为不同Pod选择合适的运行时。
  • 使用 crictl 从Pod定位到Sandbox、Container、宿主机PID、Namespace和cgroup。
  • 画出一个Pod从提交到容器主进程运行的完整链路。

一、先建立正确的分层模型

一句话概括这条链路:

kubelet通过CRI请求containerd管理Pod和容器,containerd通过shim调用runc,最终由runc使用Linux Namespace、cgroup、mount等内核机制创建容器进程。

flowchart LR
    A[kubelet] -->|CRI gRPC| B[containerd CRI plugin]
    B --> C[Image Service]
    B --> D[Snapshotter]
    B -->|Task API / ttrpc| E[containerd-shim-runc-v2]
    E -->|fork / exec| F[runc]
    F --> G[Linux kernel]
    G --> H[Namespace]
    G --> I[cgroup v2]
    G --> J[Mount / Rootfs]
    G --> K[Capabilities / Seccomp / LSM]

各组件的职责

组件核心职责不负责什么
kubelet调和节点上Pod的期望状态,通过CRI管理Sandbox、镜像和容器不直接调用runc,不自己解压镜像
CRIkubelet与容器运行时之间的gRPC接口契约不是一个独立守护进程
containerd镜像拉取、内容存储、镜像展开、Snapshot、容器元数据和Task生命周期不直接实现最底层Namespace/cgroup创建
containerd-shim-runc-v2承接containerd的Task请求,调用runc,持有IO,监视退出并回收子进程不负责镜像分发和Kubernetes调度
runc读取OCI Runtime Bundle,创建/启动/删除Linux容器进程不长期常驻,不承担高层容器管理
Linux内核真正执行进程隔离、资源限制、文件系统挂载和安全策略不理解Pod、Deployment等Kubernetes概念

CRI、containerd API和OCI Runtime Spec是不同层次的契约,不能混为一个“容器运行时接口”。

本文先以最常见的containerd+runc路径建立主线,再讨论gVisor和Kata如何替换这条链路的下半部分。Firecracker与KVM位于更底层,不能与runc简单并列。


二、containerd、shim和runc到底是什么

2.1 containerd:高层容器管理守护进程

containerd是长期运行的守护进程。在Kubernetes节点上,它通常通过内置CRI插件为kubelet提供Runtime Service和Image Service。

containerd的关键子系统包括:

子系统作用
Content Store按digest保存manifest、config和layer blob
Metadata Store保存镜像、容器、Snapshot等元数据
Snapshotter展开镜像层,为容器准备可写rootfs,如overlayfs
Image Service拉取、解析、校验和管理镜像
Runtime/Task管理容器执行进程的create、start、kill、delete和exec
Events发布Task启动、退出等事件
Namespaces隔离containerd对象;Kubernetes通常使用 k8s.io namespace

Container与Task不是一回事

概念含义
Image只读镜像元数据和内容层
Containercontainerd中的元数据对象,关联镜像、Snapshot和运行时配置
Task真正正在运行的进程,拥有PID、IO和退出状态
SandboxPod级运行边界,承载共享网络等Namespace;Linux上常由infra/pause容器实现

因此,“容器已创建”不一定意味着应用进程已经运行。在containerd语义中,先有Container元数据对象,再为它创建并启动Task。

2.2 shim:为什么中间还需要一层

containerd不直接长期作为所有容器进程的父进程。Runtime v2模型中,containerd启动shim,然后通过Unix Socket上的ttrpc向shim发送Task操作。

shim主要解决以下问题:

  1. 解耦containerd与容器进程。 containerd重启时,已运行容器不必因此退出。
  2. 持有容器IO。 继续维持stdin/stdout/stderr或PTY。
  3. 收集退出状态。 等待容器进程并向containerd上报事件。
  4. 回收孤儿子进程。 避免Zombie进程堆积。
  5. 屏蔽不同底层runtime的差异。 shim负责适配containerd Task API和具体runtime engine。

io.containerd.runc.v2 对应的可执行文件通常是 containerd-shim-runc-v2。对Kubernetes工作负载,containerd可根据 io.kubernetes.cri.sandbox-id 标签将同一Pod的容器分组给同一shim管理。

2.3 runc:将OCI配置变成Linux进程

runc是OCI Runtime Spec的主流实现。它更像一个低层容器执行工具,而不是长期管理所有容器的中心守护进程。

runc根据OCI config.json 中的配置,通过libcontainer和Linux系统调用完成:

  • 创建/加入PID、NET、MNT、IPC、UTS、USER等Namespace。
  • 创建或加入cgroup,应用CPU、内存、PID等资源限制。
  • 挂载rootfs、/proc、/dev、绑定挂载和只读路径。
  • 设置UID/GID、Capabilities、Seccomp、SELinux/AppArmor等安全属性。
  • 设置环境变量、工作目录和入口命令。
  • 最终通过 execve 启动容器主进程。

OCI将create和start分开:

runc create
    ↓
创建运行环境,但用户程序尚未开始执行
    ↓
runc start
    ↓
放行容器init进程,execve用户命令

shim会多次调用runc完成create、start、kill和delete等操作;runc命令结束后,容器主进程和shim仍可继续运行。


三、containerd → shim → runc调用链

以启动一个已经准备好镜像和配置的容器为例:

sequenceDiagram
    autonumber
    participant K as kubelet
    participant C as containerd/CRI
    participant S as snapshotter
    participant H as containerd-shim-runc-v2
    participant R as runc
    participant L as Linux kernel

    K->>C: CreateContainer(CRI)
    C->>S: Prepare writable snapshot
    S-->>C: rootfs mounts
    C->>C: Generate runtime config and metadata
    C->>H: Create task via ttrpc
    H->>H: Mount rootfs into OCI bundle
    H->>R: runc create container-id
    R->>L: clone/unshare, cgroup, mount, security
    L-->>R: Container init created
    R-->>H: created
    H-->>C: task created
    C-->>K: container created
    K->>C: StartContainer(CRI)
    C->>H: Start task
    H->>R: runc start container-id
    R->>L: Release init process / execve
    L-->>H: Application process running
    H-->>C: TaskStart event
    C-->>K: container started

这条链路中的三类配置

层次典型内容谁消费
Kubernetes PodSpecimage、command、resources、volume、securityContextkubelet和CRI实现
CRI请求PodSandboxConfig、ContainerConfig、ImageSpeccontainerd CRI plugin
OCI config.jsonprocess、root、mounts、linux.namespaces/resourcesshim/runc

PodSpec不会原样传给runc。containerd CRI插件会结合Pod配置、镜像信息、RuntimeClass和节点配置,生成更低层的OCI Runtime配置。


四、理解OCI规范

OCI解决的问题是“不同工具产生的镜像,能否由不同引擎分发并由不同runtime运行”。最需要理解的是三份规范:

OCI规范规范对象核心关键字
Image Spec镜像的内容与元数据格式manifest、config、layers、descriptor、digest
Distribution Spec镜像与Registry之间如何上传、下载pull/push、blob、manifest、HTTP API
Runtime Spec解包后的rootfs和运行配置如何被执行bundle、config.json、create/start/delete

4.1 OCI Image Spec

一个镜像不是单一tar包,而是一组通过digest引用的内容对象:

Image Index(可选,多架构)
    └── Manifest
          ├── Image Config
          │     ├── Entrypoint / Cmd
          │     ├── Env
          │     └── RootFS diff_ids
          ├── Layer 1
          ├── Layer 2
          └── Layer N

Descriptor通常包含 mediaType、digest 和 size。digest使内容可校验、可去重,也是使用镜像digest锁定不可变制品的基础。

4.2 OCI Runtime Bundle

OCI Runtime Bundle是一个目录,核心包含:

bundle/
├── config.json
└── rootfs/
  • rootfs/ 是容器将看到的根文件系统。
  • config.json 描述进程、环境变量、挂载、Namespace、cgroup资源和安全策略。

简化的 config.json 示例:

{
  "ociVersion": "1.2.0",
  "process": {
    "terminal": false,
    "args": ["/bin/sh", "-c", "sleep 3600"],
    "cwd": "/",
    "env": ["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"]
  },
  "root": {
    "path": "rootfs",
    "readonly": false
  },
  "linux": {
    "namespaces": [
      { "type": "pid" },
      { "type": "mount" },
      { "type": "network" }
    ],
    "resources": {
      "memory": { "limit": 104857600 },
      "cpu": { "quota": 50000, "period": 100000 }
    }
  }
}

这里使用固定 ociVersion 只是为了展示字段结构。实际Bundle中的版本和字段应以本机runtime生成的配置及其支持的OCI版本为准。

4.3 OCI没有规定什么

OCI Runtime Spec关注的是“如何运行一个容器”,它不负责:

  • Kubernetes Pod调度和控制器调和。
  • CNI IP地址分配和集群网络策略。
  • CRI Pod Sandbox语义。
  • 镜像构建流水线和漏洞扫描策略。
  • Service发现、负载均衡和Ingress。

这也是为什么Kubernetes仍然需要CRI、CNI、CSI等更高层接口。


五、安全容器、gVisor与microVM

5.1 为什么需要更强的隔离边界

runc容器通过Namespace、cgroup、Capabilities、Seccomp和LSM隔离进程,但所有容器仍共享宿主机内核。对于可信的内部服务,这种模型通常能提供最佳密度和启动速度;对于多租户、Serverless、在线代码执行、CI构建等不可信负载,宿主机内核暴露面可能仍然过大。

安全容器的目标不是替代Kubernetes安全配置,而是在容器与宿主机内核之间增加一道边界。常见方案有两类:

  • 系统调用沙箱: gVisor用用户态应用内核拦截并实现大部分Linux系统调用。
  • 轻量虚拟机: Kata Containers让Pod运行在带有独立Guest Kernel的VM或microVM中。

5.2 五个组件分别位于哪一层

技术技术角色主要隔离边界是否共享Host Kernel是否依赖KVM
runcOCI低层容器runtimeNamespace、cgroup及Linux安全机制是否
gVisor / runscOCI兼容的沙箱runtime用户态Sentry应用内核不直接执行应用系统调用可选;也可使用默认systrap
Kata Containers安全容器runtime与containerd shim每个Sandbox内的Guest Kernel和轻量VM否通常是
Firecracker面向microVM的VMM精简虚拟硬件和Guest Kernel否是
KVMLinux内核中的硬件虚拟化基础设施CPU与内存虚拟化能力不适用它本身就是底层能力

VMM是Virtual Machine Monitor。KVM向用户态VMM提供 /dev/kvm 等接口;Firecracker、QEMU和Cloud Hypervisor负责构造和管理VM。KVM本身不是OCI runtime,也不直接理解Pod或容器镜像。

5.3 三种隔离模型

flowchart TB
    subgraph R[runc: 共享宿主机内核]
        R1[Container Process] --> R2[Namespace / cgroup / Seccomp]
        R2 --> HK1[Host Linux Kernel]
    end

    subgraph G[gVisor: 用户态应用内核]
        G1[Container Process] --> G2[Sentry]
        G2 --> G3[systrap或KVM Platform]
        G2 --> G4[Gofer / Host I/O]
        G3 --> HK2[Host Linux Kernel]
        G4 --> HK2
    end

    subgraph K[Kata: 轻量VM]
        K1[Container Process] --> K2[Guest Linux Kernel]
        K2 --> K3[kata-agent]
        K3 --> K4[VMM: Firecracker / QEMU / Cloud Hypervisor]
        K4 --> K5[KVM]
        K5 --> HK3[Host Linux Kernel]
    end

三者最关键的差异不是命令名称,而是应用系统调用最终由谁处理:

  • runc容器的系统调用直接进入Host Kernel。
  • gVisor的 runsc 在Sentry中实现应用可见的内核接口,只把受控的请求交给Host Kernel。默认systrap平台通过seccomp机制截获系统调用;也可选择KVM平台,但这仍不是一台拥有完整虚拟硬件的传统VM。
  • Kata中的应用进入Guest Kernel,再由VMM与KVM运行轻量VM;Host Kernel不会直接充当应用的内核。

5.4 containerd下的三条调用链

RuntimeClass改变的是containerd选择的runtime handler以及后续隔离实现,而不是让kubelet绕过CRI。

flowchart LR
    K[kubelet] -->|CRI| C[containerd CRI plugin]
    C --> RC{runtime handler}

    RC -->|runc| R1[containerd-shim-runc-v2]
    R1 --> R2[runc]
    R2 --> HK[Host Kernel]

    RC -->|runsc| G1[containerd-shim-runsc-v1]
    G1 --> G2[runsc / Sentry]
    G2 --> HK

    RC -->|kata| K1[containerd-shim-kata-v2]
    K1 --> K2[VMM]
    K2 --> K3[KVM]
    K2 --> K4[Guest Kernel + kata-agent]
    K4 --> KP[Container Process]

Kata的典型启动过程是:

  1. containerd根据runtime handler调用 containerd-shim-kata-v2。
  2. Kata shim准备Guest Kernel、rootfs/镜像共享、虚拟设备和网络配置。
  3. VMM通过KVM创建VM或microVM并启动Guest Kernel。
  4. Guest中的 kata-agent 与宿主机shim通信,在Guest内创建容器进程。
  5. 对kubelet而言,它仍然在操作标准CRI Pod Sandbox和Container。

Kata支持多种VMM,Firecracker只是其中一种。另一条独立路径是firecracker-containerd:宿主机shim管理microVM,Guest中的agent/shim再调用runc创建Guest内的容器。两条路径都可能出现“Firecracker+KVM”,但控制组件和部署方式并不相同。

5.5 Firecracker与microVM

microVM并不是一种新的CPU虚拟化原理,而是针对高密度、快速启动场景精简设备模型和管理面的虚拟机。Firecracker进程作为VMM:

  • 使用KVM运行Guest vCPU和隔离内存。
  • 只提供必要的虚拟设备,缩小设备模型和攻击面。
  • 通过API配置vCPU、内存、Guest Kernel、根磁盘和网络接口。
  • 可由Kata Containers或firecracker-containerd等上层项目接入容器编排系统。

不要把“使用Firecracker”直接等同于“使用Kata”:Kata是安全容器runtime框架,Firecracker是它可选择的VMM之一;同样,Firecracker也能通过其他控制路径运行microVM。

5.6 使用RuntimeClass选择运行时

节点必须先安装对应runtime并在containerd中配置handler。下面的handler名称是常见示例,实际名称以节点的containerd配置为准。

apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: gvisor
handler: runsc
---
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: kata
handler: kata

Pod通过 runtimeClassName 选择运行时:

apiVersion: v1
kind: Pod
metadata:
  name: sandbox-demo
spec:
  runtimeClassName: kata
  containers:
    - name: app
      image: registry.k8s.io/pause:3.10

修改已有Pod的RuntimeClass不是原地切换隔离边界,而是需要重建Pod。生产集群还应在RuntimeClass中配置适当的 overhead 与 scheduling,让调度器计入VM或沙箱开销并只调度到已安装该runtime的节点。

5.7 如何选型

维度runcgVisor / runscKata Containers + microVM
典型边界Linux进程隔离用户态应用内核独立Guest Kernel与虚拟机
启动与资源开销最低低至中通常最高
系统调用兼容性最高需验证未实现或行为不同的接口通常接近完整Linux
硬件虚拟化不需要systrap不需要,KVM平台需要通常需要KVM或等价能力
运维复杂度最低需要安装runsc并验证兼容性需要管理Guest Kernel、镜像、VMM和KVM
适合场景可信服务、高密度通用工作负载多租户、代码执行、Serverless沙箱强租户隔离、合规场景、不可信工作负载

选型可以按以下顺序判断:

  1. 工作负载是否可信,是否需要抵御容器逃逸后的横向影响。
  2. 是否必须使用完整Linux系统调用、内核模块、eBPF、特定设备或性能特性。
  3. 节点是否暴露KVM;如果节点本身是VM,是否支持且适合Nested Virtualization。
  4. 能否接受额外的启动时延、内存开销、Guest镜像维护和可观测性复杂度。
  5. 用真实工作负载做兼容性、安全与性能测试,而不是仅凭“沙箱”或“microVM”标签决策。

安全容器也不是免配置方案。Seccomp、Capabilities、只读根文件系统、非root用户、镜像签名、网络策略和及时升级runtime仍然有效;VMM、Guest Kernel、共享文件系统、vsock和控制面本身也需要纳入威胁模型。


六、Pod启动完整链路图

下面从 kubectl apply 开始,画出一个典型Linux节点上使用containerd+runc时的主链路。不同Kubernetes、containerd版本和RuntimeClass实现会有细节差异,但职责边界基本一致。

sequenceDiagram
    autonumber
    actor U as User/kubectl
    participant A as kube-apiserver
    participant E as etcd
    participant S as kube-scheduler
    participant K as kubelet
    participant C as containerd CRI
    participant N as CNI plugin
    participant P as Snapshotter
    participant H as shim
    participant R as runc
    participant L as Linux kernel

    U->>A: Apply Pod/Deployment
    A->>E: Persist desired state
    S->>A: Watch unscheduled Pod
    S->>A: Bind Pod to Node
    K->>A: Watch Pod assigned to this Node
    K->>C: RunPodSandbox
    C->>H: Create sandbox task
    H->>R: runc create/start sandbox
    R->>L: Create Pod-level namespaces/cgroup
    C->>N: CNI ADD for sandbox network
    N->>L: veth/IP/route/network policy
    N-->>C: Network result
    C-->>K: Sandbox ready

    loop Each init/app container
        K->>C: PullImage if needed
        C->>C: Fetch manifest/config/layers and verify digest
        C->>P: Unpack layers / prepare snapshot
        K->>C: CreateContainer
        C->>H: Create task with OCI config and rootfs mounts
        H->>R: runc create
        R->>L: Namespace/cgroup/mount/security setup
        K->>C: StartContainer
        C->>H: Start task
        H->>R: runc start
        R->>L: execve application process
    end

    K->>C: ContainerStatus / PodSandboxStatus
    C-->>K: PID, state, timestamps, reason
    K->>A: Update PodStatus

按阶段拆解

  1. 声明与调度。 API Server持久化Pod,Scheduler选择节点并写入绑定结果。
  2. 节点调和。 目标节点kubelet观察到Pod,进入Pod同步流程。
  3. 创建Sandbox。 kubelet调用CRI RunPodSandbox,运行时准备Pod级边界。
  4. 配置网络。 CRI实现调用CNI,为Sandbox配置接口、IP、路由和网络策略。
  5. 准备镜像。 containerd从Registry获取OCI内容,校验digest并由Snapshotter展开layer。
  6. 创建容器。 kubelet调用 CreateContainer,containerd生成运行时配置并准备rootfs。
  7. 创建Task。 containerd通过shim调用 runc create,内核建立Namespace、cgroup、mount和安全策略。
  8. 启动进程。 kubelet调用 StartContainer,shim调用 runc start,容器执行入口命令。
  9. 状态回传。 shim/containerd收集进程状态,kubelet更新PodStatus并执行Probe。

Init Container和应用容器的顺序

Sandbox Ready
    ↓
按顺序运行initContainers
    ↓
所有initContainers成功
    ↓
启动普通containers
    ↓
执行startup/readiness/liveness probe
    ↓
Pod Ready

如果配置了Sidecar Container、RuntimeClass、用户Namespace或特殊Sandbox runtime,调用细节可能变化。面试中应先声明运行环境和假设,再描述主链路。


上图展示默认runc路径。Pod指定RuntimeClass后,Create sandbox task → shim → runc → Host Kernel 这一段会替换为runsc沙箱或Kata microVM链路,API Server、调度、kubelet、CRI、镜像和CNI等上层阶段仍然存在。


七、用crictl调试一个Pod

crictl 是面向CRI的节点调试工具。它看到的是Pod Sandbox和Container,不是Deployment、ReplicaSet等控制器对象。

7.1 前置检查

crictl --version
sudo crictl info
sudo crictl version

建议显式配置endpoint,避免工具依次探测多个默认Socket:

# /etc/crictl.yaml
runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
debug: false
pull-image-on-create: false

临时调试也可以显式传参:

sudo crictl \
  --runtime-endpoint unix:///run/containerd/containerd.sock \
  info

crictl 应尽量与Kubernetes版本保持一致。不同发行版可能使用不同Socket路径,应以kubelet的 containerRuntimeEndpoint 和运行时服务配置为准。

7.2 创建测试Pod

kubectl run runtime-demo \
  --image=registry.k8s.io/busybox:1.36.1 \
  --restart=Never \
  --command -- sleep 3600

kubectl get pod runtime-demo -o wide

记录 NODE 列,然后登录该节点。后续 crictl 命令必须在这个节点执行。

7.3 从Pod定位Sandbox

sudo crictl pods --name runtime-demo

POD_ID=$(sudo crictl pods \
  --name runtime-demo \
  --quiet | head -1)

sudo crictl inspectp "$POD_ID"

重点观察Sandbox状态、Pod UID标签、创建时间、网络IP和runtime handler。如果Pod卡在 ContainerCreating 但找不到Sandbox,应优先检查kubelet和containerd日志;如果Sandbox存在但没有IP,重点检查CNI。

7.4 从Sandbox定位业务容器

sudo crictl ps -a --pod "$POD_ID"

CONTAINER_ID=$(sudo crictl ps -a \
  --pod "$POD_ID" \
  --name runtime-demo \
  --quiet | head -1)

sudo crictl inspect "$CONTAINER_ID"
字段/现象含义
stateCreated、Running或Exited
reason运行时给出的退出或失败原因
exitCode容器主进程退出码
startedAt进程真正启动时间
finishedAt进程退出时间
mounts传入容器的Volume和文件挂载
runtimeSpec运行时扩展信息中可能包含转换后的OCI配置
info.pid部分CRI实现会在扩展信息中提供宿主机PID

inspect 返回的 info 属于运行时扩展字段,不同运行时和版本可能不同,脚本不能无条件依赖固定JSON路径。

7.5 查看日志、执行命令和资源统计

sudo crictl logs "$CONTAINER_ID"
sudo crictl exec -it "$CONTAINER_ID" /bin/sh
sudo crictl stats "$CONTAINER_ID"
sudo crictl statsp "$POD_ID"
sudo crictl events

如果容器已经退出,exec 无法使用,但仍可通过 crictl ps -a、inspect 和 logs 获取退出证据。

7.6 关联到宿主机进程、Namespace和cgroup

sudo crictl inspect "$CONTAINER_ID" | jq '.info.pid, .status'

如果该runtime没有暴露 .info.pid,可以结合容器ID查询shim和宿主机进程:

ps -ef | grep '[c]ontainerd-shim-runc-v2'
sudo ctr -n k8s.io tasks list

ctr 是containerd的低层调试客户端,不应作为稳定的生产自动化API。日常Kubernetes节点排障优先使用 crictl。

获得宿主机PID后继续检查:

CONTAINER_PID=<host-pid>

sudo ls -l "/proc/$CONTAINER_PID/ns/"
sudo cat "/proc/$CONTAINER_PID/cgroup"
sudo nsenter -t "$CONTAINER_PID" -n ip addr
sudo nsenter -t "$CONTAINER_PID" -n ip route
sudo nsenter -t "$CONTAINER_PID" -m mount
Kubernetes Pod
    ↓
CRI Pod Sandbox / Container
    ↓
containerd Container / Task
    ↓
shim管理的宿主机进程
    ↓
/proc/<pid>/ns/* + /proc/<pid>/cgroup

7.7 确认实际使用的runtime

先从Pod声明和CRI Sandbox确认runtime handler:

kubectl get pod sandbox-demo \
  -o jsonpath='{.spec.runtimeClassName}{"\n"}'

sudo crictl pods --name sandbox-demo
sudo crictl inspectp <sandbox-id>

再观察节点上的实现进程:

ps -ef | grep -E \
  '[c]ontainerd-shim-(runc|runsc|kata)|[r]unsc|[f]irecracker'

容器内 uname 不能单独证明底层runtime。gVisor可结合容器内 dmesg 是否显示gVisor启动信息判断;Kata应结合runtime handler、Kata shim、VMM进程和Guest信息交叉验证。

Kata或Firecracker启动失败时,先检查硬件虚拟化入口:

test -r /dev/kvm && test -w /dev/kvm
lsmod | grep '^kvm'
grep -E -m1 'vmx|svm' /proc/cpuinfo

/dev/kvm 不存在或当前进程无权限时,继续检查BIOS虚拟化开关、KVM内核模块、设备权限,以及云主机是否提供Nested Virtualization。gVisor默认systrap平台不依赖KVM,因此不能把缺少 /dev/kvm 一概判断为gVisor不可用。

7.8 查看各层日志

# kubelet:为什么发起或没有发起CRI请求
sudo journalctl -u kubelet --since "15 min ago"

# containerd:CRI、镜像、Snapshot和Task执行错误
sudo journalctl -u containerd --since "15 min ago"

# Kata、gVisor和VMM通常也会通过containerd或各自shim输出日志
sudo journalctl -u containerd --since "15 min ago" | \
  grep -Ei 'kata|runsc|gvisor|firecracker|kvm|vsock'

sudo crictl logs "$CONTAINER_ID"
kubectl describe pod runtime-demo
kubectl get events --sort-by=.lastTimestamp

排障时要按层收集证据,不要看到 ContainerCreating 就直接认定是containerd故障。

7.9 清理实验Pod

kubectl delete pod runtime-demo

删除过程中可以在节点上观察:

sudo crictl events
watch sudo crictl ps -a --pod "$POD_ID"

你会看到kubelet请求停止和删除容器,containerd通过shim/runc终止进程并清理Task、Snapshot挂载和Sandbox网络。具体垃圾回收时机可能由kubelet和containerd策略决定,并非所有对象都会在Pod API删除的瞬间同步消失。


八、常见故障如何沿调用链定位

Kubernetes现象首先检查可能所在层次
ErrImagePullPod Events、crictl imagesRegistry认证、DNS、网络、镜像名、digest
ImagePullBackOffEvents与containerd日志Image Service退避,不等于runc失败
ContainerCreatingcrictl pods/inspectp、CNI日志Sandbox、CNI、CSI、Snapshot或Mount
CreateContainerErrorcrictl inspectp、kubelet日志CRI配置转换、Volume、SecurityContext
RunContainerErrorcontainerd日志、shim日志OCI配置、runc create/start、内核能力
CrashLoopBackOffcrictl ps -a/inspect/logs应用进程退出、探针、配置或资源限制
OOMKilledinspect、cgroup memory.eventsMemory limit、节点压力、应用内存行为
Pod有IP但网络不通inspectp、nsenter、CNI日志路由、策略、MTU、conntrack或数据面
Kata Sandbox启动失败handler、shim日志、/dev/kvmKVM权限、VMM、Guest镜像、vsock或agent
gVisor容器启动失败runsc/containerd日志、应用行为handler配置、平台选择或系统调用兼容性

推荐排障顺序

PodSpec / Events
    ↓
kubelet是否发出了正确CRI请求
    ↓
Sandbox是否存在且Ready
    ↓
Image是否拉取并解包成功
    ↓
Container是否Created
    ↓
Task是否Running或Exited
    ↓
shim/runc是否返回错误
    ↓
宿主机Namespace、cgroup、mount和内核日志

一个容易混淆的判断

  • crictl pods 查看Pod Sandbox。
  • crictl ps 查看CRI容器。
  • ctr -n k8s.io containers list 查看containerd Container元数据。
  • ctr -n k8s.io tasks list 查看containerd Task进程。
  • ps 查看宿主机实际进程。

这些对象有关联,但不是同一个对象,也不保证生命周期完全同步。


九、自测清单

  • 能在白板上画出 kubelet → CRI → containerd → shim → runc → kernel。
  • 能解释CRI、OCI Runtime Spec和containerd Task API的区别。
  • 能解释为什么需要shim,以及containerd重启时shim的价值。
  • 能说明Image、Container、Task和Pod Sandbox的差异。
  • 能从Pod名称查到Sandbox ID、Container ID和宿主机PID。
  • 能从宿主机PID找到Network Namespace和cgroup路径。
  • 能解释 CreateContainer 与 StartContainer 为什么分开。
  • 能说明OCI Bundle中 config.json 和 rootfs 的作用。
  • 能画出runc、gVisor与Kata三种路径的隔离边界。
  • 能解释Firecracker是VMM、KVM是内核虚拟化基础,而不是CRI runtime。
  • 能使用RuntimeClass让Pod选择runsc或Kata handler。
  • 能检查Kata/Firecracker所需的 /dev/kvm、VMM、Guest Kernel和agent。
  • 面对 ContainerCreating,能按Sandbox、CNI、CSI、Snapshot、runc逐层排查。
  • 面对 CrashLoopBackOff,能区分创建失败、启动失败和应用启动后退出。

十、面试高频问题

1. containerd和runc有什么区别

containerd负责镜像、Snapshot、容器元数据和Task生命周期等高层管理;runc根据OCI Runtime Bundle创建和启动单个Linux容器。containerd是长期运行的管理面,runc通常按操作被shim调用。

2. 为什么需要containerd-shim

shim解耦containerd与容器进程,持有IO、监视退出、回收子进程并适配底层runtime。这样containerd可以升级或重启,而已运行容器不必被直接终止。

3. kubelet会直接调用runc吗

不会。典型链路是kubelet通过CRI gRPC调用containerd,containerd通过Runtime v2 Task API与shim通信,shim再调用runc。

4. pause容器有什么作用

在典型Linux CRI实现中,pause/infra容器为Pod提供稳定的Sandbox进程,并持有Pod级网络等Namespace。业务容器加入这些共享Namespace,因此业务容器重启时,Pod IP和Sandbox边界可以保持稳定。具体实现会随runtime和Sandbox机制变化,不应把pause镜像本身当成CRI规范。

5. OCI镜像和OCI Runtime Bundle有什么区别

OCI镜像是适合存储和分发的manifest、config和压缩layer集合;Runtime Bundle是节点上供低层runtime消费的 config.json + rootfs。containerd负责从前者准备出后者所需的文件系统和运行配置。

6. runc、gVisor和Kata的核心区别是什么

runc依靠宿主机Linux内核隔离容器;gVisor用Sentry用户态应用内核拦截并实现系统调用,减少应用直接接触Host Kernel的机会;Kata把Pod Sandbox放入拥有独立Guest Kernel的轻量VM。一般来说,隔离边界越强,启动、资源和运维成本也越高,但最终结论必须通过具体威胁模型和工作负载测试得出。

7. Firecracker、Kata Containers和KVM是什么关系

KVM提供Linux内核级硬件虚拟化接口,Firecracker是使用KVM创建microVM的用户态VMM,Kata Containers是向containerd/Kubernetes提供安全容器体验的runtime框架。Kata可以使用Firecracker,也可使用QEMU或Cloud Hypervisor,因此三者不是同义词。

8. gVisor使用KVM后是否就等同于Kata

不等同。gVisor的KVM platform利用KVM隔离地址空间并截获页错误,Sentry同时承担应用内核角色,仍保持沙箱进程模型;Kata则启动带独立Guest Kernel和虚拟设备的轻量VM。二者的内核边界、兼容性和运维模型不同。

9. 如何为一个Pod选择安全runtime

先在节点上安装并配置runtime handler,再创建对应RuntimeClass,最后在Pod中设置 runtimeClassName。调度、CRI和containerd主链路不变,containerd根据handler选择runc、runsc或Kata shim。生产环境还要设置RuntimeClass的调度约束和资源开销。


十一、官方参考资料

containerd、CRI和OCI仍在演进。实际排障前应确认Kubernetes、cri-tools、containerd、runc及所用CNI/CSI的版本,并优先查看对应版本的官方文档。


Comment