Linux内核中的容器技术详解-程序员充电站

Linux内核中的容器技术详解

引言

容器技术是现代云计算和DevOps的基础，Linux内核通过namespace和cgroups等机制实现了容器化隔离。本文将深入探讨Linux容器技术的底层实现原理，包括资源隔离、容器编排和容器安全等方面。

容器技术概述

1. 容器 vs 虚拟机

特性	容器	虚拟机
启动时间	秒级	分钟级
资源占用	低	高
隔离级别	进程级	硬件级
性能	接近原生	有损耗

2. 容器生态

Docker：最流行的容器平台
Podman：Docker的无守护进程替代品
containerd：容器运行时
runc：容器运行器
Kubernetes：容器编排平台

Linux内核支持

1. 必需的内核配置

# 检查内核支持 grep -E "CONFIG_NAMESPACES|CONFIG_CGROOPS|CONFIG_OVERLAY_FS" /boot/config-$(uname -r) # 必需的配置选项 CONFIG_NAMESPACES=y CONFIG_UTS_NS=y CONFIG_IPC_NS=y CONFIG_PID_NS=y CONFIG_NET_NS=y CONFIG_CGROUPS=y CONFIG_CGROUP_NS=y CONFIG_OVERLAY_FS=y

2. 内核模块

# 加载必要的模块 modprobe overlay modprobe br_netfilter # 检查已加载的模块 lsmod | grep -E "overlay|bridge|iptable"

namespace隔离

1. namespace类型

#define CLONE_NEWNS 0x00020000 // Mount namespace #define CLONE_NEWUTS 0x04000000 // UTS namespace #define CLONE_NEWIPC 0x08000000 // IPC namespace #define CLONE_NEWPID 0x20000000 // PID namespace #define CLONE_NEWNET 0x40000000 // Network namespace #define CLONE_NEWUSER 0x10000000 // User namespace

2. 创建namespace

#define _GNU_SOURCE #include <sched.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/wait.h> int child(void *arg) { printf("I'm in child namespace\n"); printf("PID in namespace: %d\n", getpid()); // 执行shell execl("/bin/bash", "/bin/bash", NULL); return 0; } int main() { char *stack; pid_t pid; // 分配栈空间 stack = malloc(4096 * 1024); if (!stack) return 1; // 创建PID namespace pid = clone(child, stack + 4096 * 1024, CLONE_NEWPID | CLONE_NEWUTS | SIGCHLD, NULL); if (pid < 0) { perror("clone"); return 1; } printf("Parent: child PID = %d\n", pid); waitpid(pid, NULL, 0); return 0; }

3. Network namespace

# 创建network namespace ip netns add myns # 在namespace中执行命令 ip netns exec myns ip link list # 添加网络接口到namespace ip link add veth0 type veth peer name veth1 ip link set veth1 netns myns # 配置namespace中的接口 ip netns exec myns ip addr add 10.0.0.2/24 dev veth1 ip netns exec myns ip link set veth1 up # 删除namespace ip netns del myns # 查看所有namespace ip netns list ls /var/run/netns

4. Mount namespace

# 创建mount namespace unshare --mount # 挂载proc mount -t proc proc /proc # 挂载sys mount -t sysfs sys /sys # 创建新的挂载点 mount -t tmpfs tmpfs /tmp # 查看挂载 mount cat /proc/self/mountinfo

cgroups资源控制

1. cgroups层次结构

cgroup root ├── system.slice ├── user.slice └── docker.slice ├── abc123.service └── def456.service

2. cgroups v1

# 创建cgroup mkdir /sys/fs/cgroup/cpu/mycontainer # 设置CPU限制 echo 50000 > /sys/fs/cgroup/cpu/mycontainer/cpu.cfs_quota_us # 50% CPU echo 100000 > /sys/fs/cgroup/cpu/mycontainer/cpu.cfs_period_us # 设置内存限制 echo 512M > /sys/fs/cgroup/memory/mycontainer/memory.limit_in_bytes echo 256M > /sys/fs/cgroup/memory/mycontainer/memory.soft_limit_in_bytes # 设置IO限制 echo "8:0 wbps=10485760" > /sys/fs/cgroup/blkio/mycontainer/blkio.throttle.write_bps_device # 添加进程 echo <pid> > /sys/fs/cgroup/cpu/mycontainer/tasks # 查看统计 cat /sys/fs/cgroup/cpu/mycontainer/cpu.stat

3. cgroups v2

# 检查cgroups v2 mount | grep cgroup2 # 创建cgroup mkdir /sys/fs/cgroup/mycontainer # 设置CPU限制 echo "max 50000 100000" > /sys/fs/cgroup/mycontainer/cpu.max # 设置内存限制 echo "max 512M" > /sys/fs/cgroup/mycontainer/memory.max # 设置IO限制 echo "8:0 rbps=max wbps=max" > /sys/fs/cgroup/mycontainer/io.max # 添加进程 echo <pid> > /sys/fs/cgroup/mycontainer/cgroup.procs

4. libcgoup编程

#include <libcgroup.h> int main() { struct cgroup *cgroup; struct cgroup_controller *cgc; int ret; cgroup_init(); // 创建cgroup cgroup = cgroup_new_cgroup("mycontainer"); if (!cgroup) return 1; // 添加CPU控制器 cgc = cgroup_add_controller(cgroup, "cpu"); cgroup_controller_set_uint64(cgc, "cpu.cfs_quota_us", 50000); cgroup_controller_set_uint64(cgc, "cpu.cfs_period_us", 100000); // 添加内存控制器 cgc = cgroup_add_controller(cgroup, "memory"); cgroup_controller_set_uint64(cgc, "memory.limit_in_bytes", 512 * 1024 * 1024); // 创建cgroup ret = cgroup_create_cgroup(cgroup, 0); if (ret) { fprintf(stderr, "Failed to create cgroup\n"); return 1; } // 添加进程 ret = cgroup_add_task(cgroup, getpid()); // 清理 cgroup_free(cgroup); return 0; }

Union文件系统

1. OverlayFS

OverlayFS将多个目录合并成单一的视图。

overlay ├── lower (只读) │ └── usr/ │ └── bin/ ├── upper (读写) │ └── var/ └── work (工作目录)

2. OverlayFS挂载

# 创建目录 mkdir -p /mnt/overlay/{lower,upper,work,mnt} # lower层（镜像内容） mount -t overlay overlay -o lowerdir=/var/lib/docker/overlay2/lower,\ upperdir=/var/lib/docker/overlay2/upper,\ workdir=/var/lib/docker/overlay2/work \ /mnt/overlay/mnt

3. OverlayFS在内核中

#include <linux/overlayfs.h> // OverlayFS通过VFS实现，不需要额外的系统调用 // 容器使用overlay存储驱动时，Docker自动处理挂载

容器网络

1. 网络模型

bridge：默认网络模式
host：共享主机网络
overlay：跨主机网络
macvlan：为容器分配MAC地址
none：禁用网络

2. Bridge网络

# 创建网桥 ip link add br0 type bridge ip addr add 172.17.0.1/16 dev br0 ip link set br0 up # 创建veth对 ip link add veth0 type veth peer name veth1 # 一端连接到网桥 ip link set veth0 master br0 ip link set veth0 up # 另一端移到容器namespace ip link set veth1 netns <container_pid> ip netns exec <container_pid> ip addr add 172.17.0.2/16 dev veth1 ip netns exec <container_pid> ip link set veth1 up

3. iptables规则

# NAT规则 iptables -t nat -A POSTROUTING -s 172.17.0.0/16 ! -o docker0 -j MASQUERADE # 端口映射 iptables -t nat -A PREROUTING -p tcp --dport 8080 -j DNAT --to-destination 172.17.0.2:80 # 过滤规则 iptables -A FORWARD -i docker0 -o docker0 -j ACCEPT

容器存储

1. 存储驱动

overlay2：当前推荐，性能好
aufs：早期Docker使用
devicemapper：块级存储
btrfs：文件系统级存储
zfs：高级存储功能

2. 数据卷

# 创建volume docker volume create myvolume # 挂载volume docker run -v myvolume:/data debian # 绑定挂载主机目录 docker run -v /host/path:/container/path debian # tmpfs挂载 docker run --tmpfs /run debian

3. 存储驱动切换

# 查看当前存储驱动 docker info | grep "Storage Driver" # 修改存储驱动（编辑/etc/docker/daemon.json） { "storage-driver": "overlay2" }

容器安全

1. Seccomp

# Docker默认seccomp配置 docker run --security-opt seccomp=default.json debian # 自定义seccomp docker run --security-opt seccomp=/path/to/profile.json debian # 无seccomp限制 docker run --security-opt seccomp=unconfined debian

2. Capabilities限制

# 查看默认能力 docker run --rm debian cat /proc/self/status | grep Cap # 删除能力 docker run --cap-drop=NET_RAW debian # 添加能力 docker run --cap-add=NET_ADMIN debian # 完全删除能力 docker run --privileged debian

3. AppArmor/SELinux

# AppArmor docker run --security-opt "apparmor=profile" debian # SELinux docker run --security-opt "label=type:container_file_t" debian # 禁用安全标签 docker run --security-opt "label=disable" debian

runc容器运行

1. runc概述

runc是OCI容器运行时的参考实现。

# 创建spec runc spec # 运行容器 runc run mycontainer # 列出容器 runc list # 停止容器 runc kill mycontainer # 删除容器 runc delete mycontainer

2. spec文件

{ "ociVersion": "1.0.2", "process": { "terminal": true, "user": { "uid": 0, "gid": 0 }, "args": ["/bin/bash"], "cwd": "/" }, "root": { "path": "rootfs", "readonly": true }, "hostname": "container", "mounts": [ { "destination": "/proc", "type": "proc", "source": "proc" } ], "linux": { "namespaces": [ {"type": "pid"}, {"type": "network"}, {"type": "ipc"}, {"type": "uts"}, {"type": "mount"} ] } }

容器编排

1. Kubernetes架构

Control Plane：
- kube-apiserver
- etcd
- kube-controller-manager
- kube-scheduler
Node：
- kubelet
- kube-proxy
- container runtime

2. Pod

Pod是Kubernetes最小的调度单位。

apiVersion: v1 kind: Pod metadata: name: nginx spec: containers: - name: nginx image: nginx:1.21 ports: - containerPort: 80 resources: limits: memory: "128Mi" cpu: "500m" requests: memory: "64Mi" cpu: "250m"

3. Deployment

apiVersion: apps/v1 kind: Deployment metadata: name: nginx-deployment spec: replicas: 3 selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: containers: - name: nginx image: nginx:1.21 ports: - containerPort: 80

结论

Linux容器技术通过namespace实现资源隔离，通过cgroups实现资源限制，通过overlayfs实现高效的镜像管理。这些内核机制共同构成了现代容器技术的基础。理解这些底层原理对于容器开发、运维和安全加固都有重要意义。