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

Day1-容器隔离的本质

容器隔离的本质:用unshare手搓一个迷你容器

unshare

unshare系统调用会创建新的namespace,使当前进程与父进程在指定维度上隔离。下面组合三个最常用的Namespace:

Namespace隔离内容对应的Docker概念
PID进程号空间容器内PID从1开始
NET网络栈(网卡/IP/路由/iptables)容器独立网络
MNT挂载点(文件系统视图)容器独立根文件系统

Namespace回答的是「进程能看到什么」,但它不限制进程能用多少CPU、内存和PID。资源限制由cgroup完成:

机制解决的问题典型能力
Namespace资源视图和名称空间隔离隔离进程号、网络栈、挂载点
cgroup资源使用限制与统计CPU配额、内存上限、PID上限

实操

Step 1: 创建三合一Namespace并进入Shell

# --pid:    新PID namespace
# --net:    新NET namespace
# --mount:  新MNT namespace
# --fork:   fork子进程执行后续命令(PID ns要求)
# --mount-proc: 在新ns中重新挂载/proc(否则ps看到的是宿主机进程)
sudo unshare --pid --net --mount --fork --mount-proc /bin/bash

Step 2: 验证PID隔离

# 在新ns的shell中执行
echo $$     # 输出应该是1,这个ns里的init进程号
ps aux      # 只能看到自己和ps本身,看不到宿主机任何进程
cat /proc/1/cmdline | tr '\0' ' '   # 确认PID 1就是/bin/bash

对比实验: 另外再打开一个宿主机终端,执行ps aux | grep bash,会发现宿主机能看到这个bash进程,但该PID不是1,而且ns内部看不到宿主机的任何进程

Step 3: 验证NET隔离

# 在新ns的shell中执行:
ip addr show    # 只有lo(回环),且lo是DOWN状态
ip link show    # 没有任何的veth/eth0
ping 8.8.8.8    # 失败,ping: connect: Network is unreachable

此时,这个Namespace是 完全断网的。需要手动连接网络。

Step 4: 手动搭建网络连通性

这一步模拟K8S CNI插件做的事情,需要在宿主机操作:

# ====== 宿主机终端 ======

# 1. 找到新ns的PID,即unshare fork出来的bash进程
NS_PID=$(pgrep -f "unshare.*--pid.*--net.*--mount" | head -1)
echo "Namespace PID: $NS_PID"

# 2. 创建一对veth设备(虚拟网卡)
sudo ip link add veth-host type veth peer name veth-ns

# 3. 把一端塞进新namespace
sudo ip link set veth-ns netns $NS_PID

# 4. 配置宿主机端
sudo ip addr add 10.10.1.1/24 dev veth-host
sudo ip link set veth-host up

# 5. 配置namespace端(通过nsenter进入该ns执行命令)
sudo nsenter -t $NS_PID -n ip addr add 10.10.1.2/24 dev veth-ns
sudo nsenter -t $NS_PID -n ip link set veth-ns up
sudo nsenter -t $NS_PID -n ip link set lo up
sudo nsenter -t $NS_PID -n ip route add default via 10.10.1.1

回到 unshare的shell中验证

# ====== unshare shell ======
ip addr show    # 应该看到 veth-ns 10.10.1.2/24
ping 10.10.1.1  # 应该能ping通宿主机veth-host端
ping 8.8.8.8    # 无法通信,缺少NAT转发

Step 5: 让Namespace访问外网

# ====== host shell ======
sudo sysctl -w net.ipv4.ip_forward=1
sudo iptables -t nat -A POSTROUTING -s 10.10.1.0/24 ! -o veth-host -j MASQUERADE

回到unshare shell

ping 8.8.8.8 # 可以访问

这里模拟的是CNI bridge类型网络和Pod出站SNAT的基本思路。kube-proxy的主要职责是Service虚拟IP和后端负载均衡,并不负责所有Pod的公网出口。实际Kubernetes网络还可能使用纯路由、overlay或eBPF数据面,不一定经过Linux bridge。

Step 6: 验证MNT隔离

# ====== unshare shell ======
# 创建一个只在当前ns可见的挂载
mkdir /tmp/isolated-test
mount -t tmpfs tmpfs /tmp/isolated-test
echo "hello from isolated ns" > /tmp/isolated-test/file.txt
cat /tmp/isolated-test/file.txt   # 可正常读取
ls /tmp/isolated-test/            # 有文件显示

在 宿主终端验证:

ls /tmp/isolated-test/    # 目录不存在或为空
# 即使宿主机也有/tmp/isolated-test,内容也完全不同

Step 7: 用cgroup v2限制容器资源

7.1 确认当前使用cgroup v2

在宿主机终端执行:

# 输出cgroup2fs表示当前使用统一层级的cgroup v2
stat -fc %T /sys/fs/cgroup

# 查看内核支持的控制器
cat /sys/fs/cgroup/cgroup.controllers

# 查看根cgroup已为子层级启用的控制器
cat /sys/fs/cgroup/cgroup.subtree_control

本实验需要看到 cpu、memory 和 pids。如果它们没有出现在 cgroup.subtree_control 中,可在专用测试虚拟机中启用:

echo "+cpu +memory +pids" | sudo tee /sys/fs/cgroup/cgroup.subtree_control

不建议在生产机器上直接修改systemd管理的cgroup层级。本实验应在可丢弃的Linux虚拟机中进行;如果系统不允许委托controller,应改用 systemd-run 或容器运行时创建cgroup。

7.2 找到Namespace内Shell对应的宿主机PID

PID Namespace内看到的PID 1,在宿主机上有另一个PID。cgroup接口使用宿主机视角的PID:

# NS_PID是前面找到的unshare进程
NS_PID=$(pgrep -f "unshare.*--pid.*--net.*--mount" | head -1)

# --fork创建的子进程才是Namespace内的/bin/bash
CONTAINER_HOST_PID=$(pgrep -P "$NS_PID" | head -1)

ps -o pid,ppid,cmd -p "$NS_PID" -p "$CONTAINER_HOST_PID"
sudo nsenter -t "$CONTAINER_HOST_PID" -p -m ps -o pid,ppid,cmd

最后一条命令中,同一个Shell应该在PID Namespace内显示为PID 1。

7.3 创建cgroup并设置限制

CGROUP_PATH=/sys/fs/cgroup/mini-container
sudo mkdir "$CGROUP_PATH"

# CPU:每100 ms周期最多运行50 ms,约等于0.5个CPU核的时间
echo "50000 100000" | sudo tee "$CGROUP_PATH/cpu.max"

# 内存:80 MiB开始回收,100 MiB为硬上限
echo $((80 * 1024 * 1024)) | sudo tee "$CGROUP_PATH/memory.high"
echo $((100 * 1024 * 1024)) | sudo tee "$CGROUP_PATH/memory.max"

# 最多允许64个进程/线程
echo 64 | sudo tee "$CGROUP_PATH/pids.max"

# 将Namespace内的Shell加入cgroup;它后续创建的子进程会自动继承
echo "$CONTAINER_HOST_PID" | sudo tee "$CGROUP_PATH/cgroup.procs"

cgroup.procs 实现的是「将进程加入资源管理组」。cgroup不创建进程,也不改变进程看到的网络或文件系统,只是对该组进程进行资源计量和控制。

7.4 验证CPU限制

回到unshare Shell执行:

# 创建一个持续消耗CPU的子进程
yes > /dev/null &
CPU_PID=$!

在宿主机终端观察:

watch -n 1 "cat $CGROUP_PATH/cpu.stat"

cpu.max 中的两个数分别是quota和period。当该cgroup在100 ms周期内用完50 ms CPU时间后,内核会暂停其中可运行任务,等到下一周期再恢复。cpu.stat 中的 nr_throttled 和 throttled_usec 会持续增长。

验证后停止压力进程:

kill "$CPU_PID"

7.5 验证内存限制

先在宿主机中持续观察:

watch -n 1 "cat $CGROUP_PATH/memory.current; cat $CGROUP_PATH/memory.events"

再在unshare Shell中运行一个超过上限的子进程:

python3 -c 'a = bytearray(150 * 1024 * 1024); input()'

内存用量超过 memory.high 后,内核会对该cgroup加大回收和限速压力;无法将用量控制在 memory.max 以内时,内核会在该cgroup内触发OOM处理。memory.events 中的 high、max、oom 或 oom_kill 计数会反映这个过程。

请勿直接把容器Shell本身的内存上限设得过低,否则Shell也可能被终止。在可丢弃的测试虚拟机中执行该实验。

7.6 验证PID限制

在unshare Shell中逐步创建后台进程:

for i in $(seq 1 80); do
  sleep 300 &
done

当cgroup中的任务数达到 pids.max 后,新的 fork/clone 会失败。可在宿主机上查看:

cat "$CGROUP_PATH/pids.current"
cat "$CGROUP_PATH/pids.events"

PID限制可防止容器内的进程无限创建子进程或线程,耗尽整台宿主机的PID空间。实验完成后在宿主机终端清理后台 sleep 进程,但保留容器Shell:

for pid in $(cat "$CGROUP_PATH/cgroup.procs"); do
  if [ "$pid" != "$CONTAINER_HOST_PID" ]; then
    sudo kill "$pid"
  fi
done

7.7 查看当前资源使用和限制

cat "$CGROUP_PATH/cgroup.procs"
cat "$CGROUP_PATH/cpu.max"
cat "$CGROUP_PATH/cpu.stat"
cat "$CGROUP_PATH/memory.current"
# 较新内核可查看历史峰值;文件不存在时可跳过
cat "$CGROUP_PATH/memory.peak"
cat "$CGROUP_PATH/memory.events"
cat "$CGROUP_PATH/pids.current"
cat "$CGROUP_PATH/pids.events"

cgroup同时是限制机制和可观测数据源。容器运行时、kubelet以及监控组件都会从这些接口获得用量、限流和OOM信息。

7.8 清理cgroup

先退出unshare Shell,确认cgroup内已经没有进程:

cat "$CGROUP_PATH/cgroup.procs"
sudo rmdir "$CGROUP_PATH"

cgroup v2目录由内核虚拟文件系统管理,不需要、也不应该逐个删除其中的控制文件。只有当其中没有进程和子cgroup时,才能用 rmdir 删除该cgroup。

cgroup v1与cgroup v2的核心区别

对比项cgroup v1cgroup v2
层级结构不同controller可使用不同层级所有controller使用统一层级
进程归属同一进程在不同controller中可不一致同一进程在统一层级中只有一个归属位置
CPU接口cpu.cfs_quota_us/cpu.cfs_period_uscpu.max、cpu.weight
内存接口memory.limit_in_bytesmemory.max、memory.high、memory.events
资源控制语义多套子系统,管理与监控较分散接口和层级更统一,是现代Linux容器的主要方向

cgroup与Kubernetes requests/limits的对应

Kubernetes配置节点上cgroup v2的关键机制运行时效果
CPU requestcpu.weightCPU竞争时影响相对分配权重,不是独占或预留一颗CPU
CPU limitcpu.max超出配额后发生CPU throttling
Memory requestQoS、调度和内存保护策略的输入主要影响调度与节点内存压力下的优先级,不是简单的硬预留
Memory limitmemory.max用量无法压回上限内时,可触发cgroup OOM
Pod PID limitpids.max达到上限后,新进程或线程创建失败

Kubernetes不是自己发明了CPU和内存隔离。它通过kubelet和容器运行时,把Pod/Container定义的资源策略翻译成Linux cgroup配置,再由内核负责实际计量、限流和OOM处理。

对照K8S的理解映射

做完上述试验后,对照下面这张表:

上述操作K8S中等价的操作相关组件
unshare --pid --net --mountkubelet调用CRI创建Pod sandboxcontainerd/runc
创建veth pair + 移入nsCNI插件为Pod分配网络Calico/Cilium/Flannel
配置ns内IP + 默认路由CNI写入Pod网络配置loopback/cni-result
iptables MASQUERADEPod出站SNAT/节点伪装CNI/IP masquerade agent
mount tmpfs隔离Pod的emptyDir volumekubelet volume manager
/proc重新挂载容器看到自己PID Namespace的进程runc/kubelet
创建cgroup并加入进程kubelet/运行时创建Pod与Container cgroupsystemd/containerd/runc
cpu.max/memory.max/pids.max应用CPU、内存和PID限制Linux cgroup v2

常用调试指令

# ====== host shell ======

# 查看当前活跃的namespace
lsns -t pid
lsns -t net
lsns -t mnt

# 进入到已有ns调试
nsenter -t <PID> -p -n -m /bin/bash

# 查看某个进程的namespace inode(判断两个进程是否在同一ns)
ls -la /proc/<PID>/ns/{pid,net,mnt}

# 清理实验残留
ip link del veth-host 2>/dev/null
iptables -t nat -D POSTROUTING -s 10.10.1.0/24 ! -o veth-host -j MASQUERADE 2>/dev/null

Comment