限额 2 GB,free 却报出整台机器:容器隔离的两套账本

容器常被当成一台小虚拟机,其实它是两套互不替代的内核机制叠出来的:namespace 重映射进程能看见的视图,cgroup 记账并限制它能消耗的资源。少了前者,容器里的进程会看见宿主机上所有进程和网卡;少了后者,一个容器就能吃光整台机器的 CPU 和内存。最常见的误读是拿容器里的 free、nproc 判断可用资源,这些文件并没有按 cgroup 限额重写,报出的往往还是宿主机的数字;同样常见的还有把 cpu-shares 和 Kubernetes 的 request 当成硬上限。读完你能分清两套账本各自的边界,用 cgroup v2 文件核对真实用量,并把内存、CPU 与 OOM 排查落到具体指标上。

是什么

容器不是一台缩小版的虚拟机,而是两套内核机制叠出来的一组进程:namespace 把进程能看见的系统资源重新映射成一份私有视图,cgroup 把这组进程的消耗记在一本账上并设定上限。一句话直觉:namespace 决定“你看得见谁”,cgroup 决定“你能用多少”。前者管隔离,后者管配额,谁也替代不了谁。

典型场景就在一条 docker run 里:-m 2g 写的是内存上限,--cpus 1.5 写的是 CPU 带宽,而容器里为什么只有一个 1 号进程、为什么有自己的 eth0,答案在 namespace。线上最常见的两个症状——容器被 OOMKilled(退出码 137)、接口 p99 周期性抖动——几乎都能追到 cgroup 这本账上。把两者混为一谈,就会在排查时找错方向:看到 free 还有很多内存,却不知道为什么进程被杀了。

核心原理

Linux 目前有八类 namespace:mount、PID、network、IPC、UTS、user、cgroup、time(清单与创建方式见 namespaces(7))。它们做的事本质相同:把一份全局名字空间换成每个 namespace 一份。mount namespace 配上 pivot_root,让容器看到自己的根文件系统;PID namespace 是层级结构,宿主机看得见所有进程,容器只看得见自己这棵子树,进去的第一个进程成为 PID 1;network namespace 给容器独立的网卡、路由表和 iptables,靠一对 veth 接到宿主机网桥;UTS 管主机名,IPC 管共享内存与消息队列,user 管 UID/GID 映射,cgroup 把 /proc/self/cgroup 的根截到容器自己(容器里通常只看到 0::/,而不是宿主机那串带容器 ID 的路径),time 则偏移启动时间与单调时钟。

关键在于,namespace 改的是“名字解析的结果”,不是内核本身。系统调用仍然进同一个内核,页缓存、调度器、协议栈实现都是共享的;所以 namespace 提供的是视图隔离,不是虚拟化边界。user namespace 默认并不启用(Docker 要配 userns-remap,或者用 rootless 模式),这正是“容器里的 root 约等于宿主 root”的根源。

cgroup 则是一棵挂在 /sys/fs/cgroup 的树,进程挂在节点上,每一层可以设控制器限额。v2 把 v1 的多个层级合并成单一层级,内存与 swap 都由 memory 控制器统一记账。树上的计费是累加的:父节点的 memory.current 包含所有子孙,Kubernetes 的 Pod 级 cgroup 正是这样把几个容器的账合在一起。几个必须记住的文件(语义见内核文档):

  • memory.max 是硬上限,回收不掉就触发 cgroup 级 OOM;memory.high 是节流线,超了会限流并施加强制回收压力,但不杀进程;memory.current 是当前计费总量,包含 page cache 与内核对象,所以它贴近 max 不代表马上要炸。
  • cpu.max 是硬带宽,格式为 $MAX $PERIOD,默认 max 100000;配额按周期结算,一个周期内提前用完就得等下一周期,所以即使整分钟的平均利用率不到一半,也可能出现毫秒级停顿。cpu.weight 是相对权重(1–10000,默认 100),只在 CPU 争抢时按比例分配,空闲时 weight=1 的容器也能跑满整机。
  • pids.max 限制进程与线程总数,用来兜住 fork 炸弹;cpu.stat 里的 nr_throttled、throttled_usec 才是判断限流的指标,而不是平均利用率。

运行时负责把参数翻译成这些文件:--memory 写 memory.max,--cpus 1.5 写成 150000 100000(等价于周期 100ms、配额 150ms,见 Docker 文档),--cpu-shares 写 cpu.weight。Kubernetes 再包一层语义:CPU limit 是硬顶,CPU request 折算成权重;内存 request 主要用于调度,内存 limit 才落成 memory.max(官方说明)。很多人以为 request 也会限流,其实它只在节点争抢时决定谁多拿一点。

两套机制的交界处有一道裂缝:cgroup 限额只被写进 /sys/fs/cgroup,并没有改写 /proc/meminfo、/proc/cpuinfo、/proc/stat 这些全局文件。于是 free -h、nproc、top 在容器里读到的仍是宿主机数字,而 docker stats 读的是 cgroup,两边天然对不上。lxcfs 这类工具用 FUSE 覆盖 /proc/meminfo 等文件,让容器“看起来像虚拟机”(项目说明),但它改的只是显示,不改内核的计费与限额。

运行时也会踩这个坑:HotSpot 从 JDK 10 起默认开启容器支持,会读 cgroup 限额折算堆大小;Go 直到 1.25 才默认按 CPU 带宽上限设置 GOMAXPROCS(Go 博客)。同一个 Pod 里,一个按 2 核算线程池、一个按 64 核算,就是这么来的。

from pathlib import Path
import os

cg = Path("/sys/fs/cgroup")
def val(name):
    return (cg / name).read_text().split()

stat = dict(zip(*[iter((cg / "memory.stat").read_text().split())] * 2))
limit = val("memory.max")[0]
print("cgroup 限额 MiB:", "max" if limit == "max" else int(limit) // 2**20)
print("cgroup 当前 MiB:", int(val("memory.current")[0]) // 2**20)
print("其中 anon/file MiB:", int(stat["anon"]) // 2**20, int(stat["file"]) // 2**20)
print("CPU 配额 max/period:", val("cpu.max"))       # 如 ['150000', '100000']
host = next(l.split()[1] for l in open("/proc/meminfo") if l.startswith("MemTotal"))
print("宿主 MemTotal MiB:", int(host) // 1024)
print("Python 看到的核数:", os.cpu_count())

同一台机器上,这段代码往往会打印出一个很小的 cgroup 限额、一个很大的宿主 MemTotal,以及一个远大于配额的核心数——三个数字各自都是真的,只是回答的问题不同。

常见考点与误区

  • “容器就是轻量虚拟机”:错在边界。虚拟机靠硬件虚拟化隔出独立内核,容器共享同一个内核,namespace 只改视图;内核漏洞、错误挂载的宿主目录、--privileged 都能把隔离打穿。面试问容器安全,答“namespace + cgroup”只算一半,还要提 capability、seccomp、LSM 与 user namespace。
  • “容器里 free 显示多少就能用多少”:/proc/meminfo 不按 cgroup 重写,报的是宿主总量;应用若按它算堆或线程数,启动就会超限。判断可用量要读 memory.max 与 cpu.max,或者明确知道 lxcfs 只是把显示改对了。
  • “cpu-shares 和 request 是 CPU 上限”:它们是权重,只在争抢时生效,空闲时容器可以吃满整机;硬顶是 quota(--cpus、CPU limit)。反过来,把 limit 压到平均利用率附近,就会频繁 throttle,平均 CPU 看起来不高,p99 却很难看。
  • “memory.current 快到 max 就要 OOM”:它包含可回收的 page cache,内核会先回收再决定是否 OOM;该看的是 memory.stat 里 anon 与 file 各占多少,以及 memory.events 的 oom_kill 是否增长。只读大文件把缓存撑高,和堆真泄漏,是两件事。
  • “cgroup v1 的调优经验可以直接搬”:v2 是单层级,memory.memsw.limit_in_bytes 这类文件不存在,swap 单独由 memory.swap.max 管;仍按 v1 路径写脚本,轻则读不到数,重则限额根本没生效。
  • “容器里的 root 就是宿主机的 root”:在没有 user namespace 时,UID 0 确实是宿主机的 0,只是 capability 被裁掉大半;一旦给了 --privileged 或挂进 docker.sock,这层裁剪也没了。

实践建议

  • 让应用读 cgroup,而不是 /proc:JVM 用 -XX:MaxRAMPercentage,Go 用 1.25 及以上版本或显式设 GOMAXPROCS,Node 设 --max-old-space-size;线程池、连接池的默认大小也按限额折算,别信 nproc。
  • 内存 limit 留出堆外余量:堆只是一部分,元空间、直接内存、线程栈、tmpfs 的 emptyDir 都记在同一本账上(K8s 文档明确把 tmpfs 计入容器内存)。按稳定态 working set 加 20%–30% 设 limit,request 按实际需要写,不要一律 request=limit。
  • CPU 先保权重再谈上限:用 request/weight 保证争抢时的份额;limit 不要贴着平均利用率,给突发留余量,观察 nr_throttled 与 throttled_usec 再决定是否调大 quota 或启用 cpu.max.burst。
  • OOM 排查按三步走:先看退出码 137 与 memory.events 的 oom_kill,确认是 cgroup OOM 还是节点级 OOM;再看 memory.stat 的 anon/file 判断是堆增长还是缓存;最后对照 limit 与进程实际 RSS,别一上来就加内存。
  • 把 cgroupfs 当只读边界:容器内只读挂载,避免进程自己改限额或逃到别的 cgroup;同时用 pids.max 兜住 fork 炸弹,非 root、只读根文件系统、drop capabilities、seccomp 一起上。多租户的不可信负载,再考虑 user namespace 或沙箱运行时。
  • 让驱动保持一致:cgroup v2 主机上,kubelet 与容器运行时都该用 systemd 驱动;一边用 cgroupfs 一边用 systemd,常见现象就是“限额建了,但没人按它管”。

一句话总结:namespace 管看得见什么,cgroup 管用得了多少;容器是两套机制叠出的视图与额度,不是一台小机器。

相关阅读

← 返回文章志