Container Runtime 入門(上):原理篇

「Container runtime」是雲原生領域極易混淆的名詞。有人用它指 Docker,有人指 containerd,也有人指 runc。在不同的討論情境下,這些說法都算對。原因在於:「把容器跑起來」這件事,是由多個不同層級的元件分工協作,而每一層往往都被冠上 runtime 的名稱。

作為上下集系列的上篇,本篇聚焦三個核心心智模型:

  1. 容器不是虛擬機器,而是被 Linux 核心限制的普通 process:隔離靠 namespaces,資源限制靠 cgroups,權限收斂則由 capabilities 與 seccomp 把關。
  2. Runtime 明確劃分為高階與低階兩層:高階 runtime(如 containerd、CRI-O)負責映像拉取與生命週期管理;低階 runtime(如 runc、crun、gVisor、Kata)負責遵循 OCI 標準呼叫核心建立 process。
  3. Kubernetes 透過 CRI 與高階 runtime 溝通:kubelet(Kubernetes 安裝在每個節點上的管理代理)透過標準的 gRPC 介面操作容器,不關心底層實際是 containerd 或 CRI-O。

搞懂這三項底層機制,後續面對 cgroup driver 設定、OOMKilled 查修與 crictl 節點診斷等實務問題時,會更容易精準定位問題根源。


容器本質:受核心約束的 Process

先打破「輕量虛擬機器」的迷思

許多人入門容器時,常接觸到「輕量級虛擬機器」的比喻。這個比喻雖然易於初學者建立印象,但在架構除錯時卻容易造成誤導。

虛擬機器(VM)擁有自己專屬的作業系統(Guest OS)與核心(Kernel),並由 Hypervisor(虛擬機器監管程式)模擬出一整台硬體電腦;容器則沒有獨立的核心,它與主機上的所有 process 完全共用同一個 Linux 核心。

換言之,容器本質上就是普通的 Linux process,只是 Linux 核心為它套上了四道防線:

機制核心職責白話比喻
namespaces決定它「看得到什麼」幫它戴上濾光眼鏡,只看得到自己所屬的 process、網路卡與掛載點
cgroups決定它「能用多少」給予額度卡,嚴格限制 CPU、記憶體與 process 數量上限
capabilities決定它「能做哪些特權操作」將 root 的無上權限拆解為數十項細部權限,僅發放必要項目
seccomp決定它「能呼叫哪些 system call」在核心入口設置白名單,不在清單上的系統呼叫一律攔截拒絕

Namespaces:決定視野邊界

Linux 核心目前提供多種 namespace(參考 namespaces(7)),其中最關鍵的五大機制包括:

Namespace隔離對象容器內的實際效果
PIDProcess ID容器內的主程式成為 PID 1,無法看見主機與其他容器的 process
Mount檔案掛載點容器擁有獨立的根檔案系統,看不到主機上的 /home 等目錄
Network網路卡、路由表、連接埠容器擁有專屬的 eth0 與 IP,可各自監聽 80 port
UserUID 與 GID容器內的 root 使用者可映射至主機上的一般無特權使用者
UTSHostname 與網域名稱容器可設定獨立的主機名稱

其餘如 IPC(行程間通訊)、Cgroup(讓 process 只看到自己所屬的 cgroup)與 Time(獨立的單調時鐘與開機時鐘,主要用於熱遷移,也就是把執行中的容器搬到另一台機器)等 namespace,也各自提供輔助性的隔離。

Namespace 只是改變 process 的「視野」,背後並不會另外造出一顆新的核心。在主機執行 ps -ef,依然能看見所有容器內執行的 process。這意味著核心漏洞可能波及主機上的所有容器。

Cgroups:限制資源額度

Namespace 無法限制資源消耗。若無額外限制,單一容器仍可能耗盡主機的所有記憶體。Control Groups(cgroups)負責將 process 分組,並為各組配置 CPU、記憶體、I/O 與 process 數量上限(參考 cgroups(7))。

Cgroup 的操作介面是虛擬檔案系統,通常掛載於 /sys/fs/cgroup。調整配額即是寫入檔案。

例如在 cgroup v2 中,把 268435456 寫入 memory.max,就代表該群組的記憶體上限為 256 MiB;一旦超過上限,核心便會在該 cgroup 內觸發 OOM Killer,強制終止 process 以釋放記憶體(參考 Linux Kernel cgroup v2 文件)。

Kubernetes YAML 中定義的 resources.limits,最終即是透過 runtime 寫入這些檔案中。

Capabilities 與 Seccomp:收斂執行權限

傳統 Linux 僅區分 root 與非 root。Linux capabilities 將 root 特權拆為數十種獨立能力(如 CAP_NET_BIND_SERVICE 與 CAP_SYS_ADMIN,參考 capabilities(7))。容器內的 root 預設僅取得極少數權限,因此無法任意載入核心模組。

Seccomp 則在 system call 層級把關。Docker 的預設 seccomp profile 從 300 多個系統呼叫中攔下約 44 個,也就是絕大多數呼叫照常放行,只擋掉 reboot、mount 這類高危險呼叫(參考 Docker seccomp 文件)。

Kubernetes 預設並不啟用嚴格的 seccomp 限制。除非在 kubelet 設定中開啟 seccompDefault,或在 Pod 的 securityContext 明確指定 RuntimeDefault,否則 Pod 將以 Unconfined 模式執行(參考 Kubernetes seccomp 教學)。

動手實作:不靠 Runtime 手動組裝簡易容器

以下範例僅使用 unshare 工具(為 process 建立新 namespace 並在其中執行程式;參考 unshare(1))與 cgroup v2 檔案系統。請在拋棄式 Linux 測試機上以 root 權限操作:

# 1. 準備 Alpine 根檔案系統
mkdir rootfs
docker export "$(docker create alpine)" | tar -C rootfs -xf -

# 2. 建立 namespaces 並以 chroot 切換根目錄
sudo unshare --uts --ipc --net --pid --mount --fork \
  chroot rootfs /bin/sh -c 'mount -t proc proc /proc && hostname demo && exec /bin/sh'

進入容器 shell 後可驗證:

開啟另一個終端機,將該 process 加入自建的 cgroup:

# 查詢該 shell 在主機上的實際 PID
ps -ef --forest | rg -A3 unshare

# 建立 cgroup 並限制 CPU 為 0.5 核(每 100,000 微秒最多使用 50,000 微秒)、記憶體 64 MiB
sudo mkdir /sys/fs/cgroup/demo
echo "50000 100000" | sudo tee /sys/fs/cgroup/demo/cpu.max
echo $((64*1024*1024)) | sudo tee /sys/fs/cgroup/demo/memory.max
echo <主機上的 PID> | sudo tee /sys/fs/cgroup/demo/cgroup.procs

# 檢視該 process 的 namespace 與 cgroup
sudo ls -l /proc/<主機上的 PID>/ns
cat /proc/<主機上的 PID>/cgroup

測試完成後在容器內輸入 exit,再以 sudo rmdir /sys/fs/cgroup/demo 清理目錄。

手動示範為求簡化,使用的是傳統的 chroot;而生產環境使用的低階 runtime(如 runc)為了避免 process 繞過根目錄限制逃出,會改用更嚴密的 pivot_root 切換根目錄,並把上述整段流程以標準化、更安全的方式自動執行。


高階 Runtime 與低階 Runtime 的分工

為了避免容器生態被單一廠商綁定,業界成立了 OCI(Open Container Initiative),制定了兩份核心標準:

這兩份標準將 Runtime 生態劃分為兩大層級:

比較面向高階 Runtime(High-level)低階 Runtime(Low-level)
代表專案containerd、CRI-Orunc、crun、gVisor、Kata
常駐狀態是(常駐 Daemon 服務)否(容器啟動完成後即退出)
向上介面gRPC API、Kubernetes CRIOCI Runtime Spec(CLI 搭配 config.json)
映像解析完整支援(拉取、解壓、快取)不支援(僅處理已就位的目錄)
網路管理協調 CNI Plugin 設定網路僅負責加入指定 Network Namespace
直接操作偶爾(透過 crictl、nerdctl)極少由人類直接呼叫

有了 OCI Runtime Spec 這份共同標準,高階與低階 runtime 可以自由搭配,底層實作隨時能夠抽換。


容器啟動流程:從 docker run 到 Process

從指令下達到容器執行的完整呼叫鏈如下:

  1. docker CLI
  2. REST API (/var/run/docker.sock)dockerd
  3. gRPCcontainerd高階 Runtime
  4. ttRPCcontainerd-shim-runc-v2一容器或一 Pod 一個
  5. CLI invocation (runc create/start)runc低階 Runtime
  6. clone(), pivot_root, cgroup, seccompLinux Kernel
  7. 產生 PID 1Your Containershim 是容器的 parent process

分層職責說明:

  1. docker CLI:純 API 客戶端,將使用者的輸入轉為 HTTP 請求送往 Unix Socket /var/run/docker.sock。
  2. dockerd:Docker Engine 主體,負責映像建置(Build)、Volume 與網路管理。自 Docker 1.11 起,執行容器的底層工作全面拆分並委派給 containerd(參考 Docker 官方部落格)。
  3. containerd:高階 runtime。負責拉取映像、解開映像層、建立 OCI config.json 設定檔並啟動 shim。它不直接啟動容器,而是作為上層協調者(參考 containerd runtime-v2 文件)。
  4. containerd-shim-runc-v2:常駐代理 process(Docker 環境下一容器一 shim;Kubernetes 則最佳化為一 Pod 一 shim)。
    • 擔任 Parent Process:runc 建立容器後即退出,改由 shim 擔任容器的父 process,負責接收容器結束時的 exit code,並維持其標準輸入輸出(stdio)暢通。因此 containerd 重新啟動時,容器不會被迫終止。
    • 解耦 Runtime 實作:更換底層 runtime 僅需更換對應的 shim(如 Kata 的 containerd-shim-kata-v2),containerd 主體無需修改。
  5. runc:低階 runtime。讀取 OCI Bundle,完成 namespaces 建立、cgroup 設定、pivot_root 切換與 seccomp 套用,最後啟動目標程式並結束自身。
  6. 目標程式:成為主機上的標準 process,受核心機制隔離與限制。

在 Kubernetes 節點上,呼叫鏈更為精簡:由 kubelet 透過 CRI 直接連線 containerd,省略了 docker CLI 與 dockerd 兩層轉接。

節點實機觀察 Process 樹

在執行 containerd 的 Kubernetes 節點上,可透過以下指令觀察 process 階層:

# 觀察 process 樹
ps -ef --forest | rg -A3 containerd-shim

# 查看 containerd 管理的 tasks
sudo ctr -n k8s.io tasks ls

典型 process 樹輸出如下:

  PID  PPID  CMD
 1234     1  /usr/bin/containerd-shim-runc-v2
                -namespace k8s.io -id 9f3c...
 1250  1234   \_ /pause
 1302  1234   \_ nginx: master process nginx -g daemon off;
 1330  1302       \_ nginx: worker process

可清楚觀察到:


CRI:kubelet 如何操作 Runtime

CRI 的誕生背景與解耦價值

早期 Kubernetes 將 Docker 的支援邏輯(即 dockershim 轉接層)直接寫在 kubelet 原始碼中。隨著各類容器 runtime 陸續出現,每增加一種 runtime 支援,kubelet 就需維護一套特化程式碼。

2016 年 Kubernetes 1.5 正式推出 CRI(Container Runtime Interface),將節點操作收斂為一套標準的 gRPC 介面(參考 Kubernetes 官方公告)。這也奠定了日後 Kubernetes 官方移除內嵌 dockershim、全面轉向標準 CRI 的架構基石。

CRI 服務架構與 Pod 啟動流程

CRI 定義於 kubernetes/cri-api 中的 api.proto,主要包含兩大 gRPC 服務:

CRI 服務核心 RPC 呼叫主要功能
RuntimeServiceRunPodSandbox、CreateContainer、StartContainer、ContainerStatus、RuntimeConfig管理 Pod Sandbox 與容器生命週期
ImageServicePullImage、ListImages、RemoveImage管理節點上的映像拉取與快取

當一個 Pod 排程至節點時,kubelet 依序執行以下呼叫:

 kubelet                     High-level Runtime
    |                           |
    |---- 1. RunPodSandbox----->|
    |                           |  建立 Network Namespace /
    |                           |  pause 容器 / CNI IP
    |                           |
    |---- 2. PullImage--------->|
    |                           |  下載業務容器映像
    |                           |
    |---- 3. CreateContainer--->|
    |                           |  依據 OCI Spec 建立容器
    |                           |
    |---- 4. StartContainer---->|
    |                           |  啟動容器業務 process
    v                           v

其中 RuntimeConfig 允許 kubelet 向 runtime 查詢設定值(如 cgroup driver),讓雙方在啟動階段就自動對齊同一套設定。這項自動對齊自 Kubernetes 1.31 起預設啟用(KubeletCgroupDriverFromCRI,1.34 成為正式功能),且需 runtime 支援該呼叫(containerd v2.0、CRI-O v1.28 以上),否則 kubelet 會回退使用自身的 cgroup driver 設定。


常見 Runtime 生態一覽

在現代雲原生生態中,各主流 runtime 依據架構定位與隔離需求分工如下:

元件名稱層級分類維護組織與治理狀態適用典型情境
containerd高階CNCF 畢業專案託管 K8s(EKS / GKE / AKS)預設;Docker Engine 底層
CRI-O高階CNCF 畢業專案Red Hat OpenShift;專注於 K8s 的輕量節點
runc低階OCI 標準參考實作containerd 的預設低階執行引擎(CRI-O 已改以 crun 為預設)
crun低階GitHub containers 組織追求極致啟動速度與低記憶體消耗;Podman 與 CRI-O 生態
gVisor低階(沙盒)Google執行不受信任的多租戶程式碼;GKE Sandbox
Kata Containers低階(輕量 VM)OpenInfra 基金會需要硬體虛擬化等級強隔離的多租戶環境

低階 runtime 的三種核心隔離模式:


常見迷思與觀念澄清

  1. 「Kubernetes 移除 dockershim 後,Docker 映像就不能用了」:錯。移除的只是 kubelet 內嵌的轉接層;Docker 建置的映像完全符合 OCI 規範,containerd 與 CRI-O 可直接執行。
  2. 「節點沒有 docker 指令就無法除錯」:錯。改用專為 CRI 設計的 crictl 工具即可直接檢視與診斷 Pod/容器狀態。
  3. 「容器內的 root 等同於主機 root」:不完全正確。容器 root 的 capabilities 已大幅收斂;但在未啟用 User Namespace 的情況下,一旦發生核心逃逸(容器內的 process 突破核心隔離、觸及主機),其在主機上的身分仍是 UID 0,也就是 root。
  4. 「在 macOS 上跑 Docker,容器是直接跑在 macOS 核心上」:錯。macOS 缺乏 Linux 原生 namespaces 與 cgroups,皆是透過微型 Linux VM 轉接執行。

結語與下篇預告

本篇原理篇梳理了 Container Runtime 的本質與架構分工。下一篇「Part 2 實戰篇」將進一步深入維運現場,探討: