1
// dockerd 检查本地镜像（简化）
2
func (daemon *Daemon) CreateContainer(params CreateParams) (*Container, error) {
3
    // 1. 解析镜像名称
4
    ref, err := reference.ParseNormalizedNamed(params.Image)
5

6
    // 2. 查找本地镜像
7
    image, err := daemon.imageStore.Get(ref)
8
    if err != nil {
9
        // 本地不存在，拉取镜像
10
        image, err = daemon.PullImage(ref)
11
    }
12

13
    // 3. 创建容器配置
14
    container, err := daemon.newContainer(image, params)
15
    return container, nil
16
}

1
# docker pull nginx:latest 的底层操作
2

3
# 1. 解析镜像名称
4
# nginx:latest → docker.io/library/nginx:latest
5

6
# 2. 获取 Manifest
7
# GET https://registry-1.docker.io/v2/library/nginx/manifests/latest
8

9
# 3. 下载 Config blob
10
# GET https://registry-1.docker.io/v2/library/nginx/blobs/sha256:abc123...
11

12
# 4. 下载 Layer blob（按需，跳过已有层）
13
# GET https://registry-1.docker.io/v2/library/nginx/blobs/sha256:def456...
14

15
# 5. 解压 Layer 到 OverlayFS
16
# tar -xzf layer1.tar.gz -C /var/lib/docker/overlay2/l1/diff
17
# tar -xzf layer2.tar.gz -C /var/lib/docker/overlay2/l2/diff

1
# 查看 nginx 镜像的层
2
docker inspect nginx --format '{{json .RootFS.Layers}}' | python3 -m json.tool
3

4
# 输出示例（6 层）：
5
# "sha256:a1b2c3d4..."
6
# "sha256:e5f6g7h8..."
7
# "sha256:i9j0k1l2..."
8
# "sha256:m3n4o5p6..."
9
# "sha256:q7r8s9t0..."
10
# "sha256:u1v2w3x4..."
11

12
# 每层对应 OverlayFS 的一个 lowerdir
13
ls /var/lib/docker/overlay2/l/
14
# 每个短链接指向一个层的 diff 目录

1
// dockerd 生成容器配置（简化）
2
func (daemon *Daemon) createContainerSpec(container *Container) (*specs.Spec, error) {
3
    spec := &specs.Spec{
4
        Version: specs.Version,
5
        Process: &specs.Process{
6
            Args:   container.Config.Entrypoint + container.Config.Cmd,
7
            Env:    container.Config.Env,
8
            Cwd:    container.Config.WorkingDir,
9
            User:   container.Config.User,
10
            Terminal: container.Config.Tty,
11
        },
12
        Root: &specs.Root{
13
            Path:     "rootfs",
14
            Readonly: container.HostConfig.ReadonlyRootfs,
15
        },
16
        Hostname: container.Config.Hostname,
17
        Mounts:   daemon.generateMounts(container),
18
        Linux: &specs.Linux{
19
            Namespaces: daemon.generateNamespaces(container),
20
            Resources:  daemon.generateResources(container),
21
            Seccomp:    daemon.generateSeccomp(container),
22
        },
23
    }
24
    return spec, nil
25
}

1
// containerd 创建容器（简化）
2
func (m *TaskManager) Create(ctx context.Context, id string, spec *specs.Spec) error {
3
    // 1. 准备 rootfs 快照
4
    mounts, err := m.snapshotter.Prepare(ctx, id, parentSnapshot)
5
    // 这一步创建 OverlayFS 的 upperdir
6

7
    // 2. 写入 config.json
8
    if err := writeConfig(bundlePath, spec); err != nil {
9
        return err
10
    }
11

12
    // 3. 启动 shim
13
    shim, err := m.startShim(ctx, bundle, id)
14
    // shim 进程启动后，通过 gRPC 与 containerd 通信
15

16
    // 4. 通过 shim 创建容器
17
    _, err = shim.Create(ctx, &task.CreateRequest{
18
        ID:       id,
19
        Bundle:   bundlePath,
20
        Rootfs:   mounts,
21
        Terminal: spec.Process.Terminal,
22
    })
23

24
    return err
25
}

1
# 用 strace 追踪 runc create 的关键系统调用
2
sudo strace -f -e trace=clone,unshare,mount,pivot_root,prctl,capset,write \
3
  -o /tmp/runc-create.log runc create --bundle /tmp/bundle mycontainer
4

5
# 关键系统调用序列（简化）：
6
# 1. clone(CLONE_NEWPID|CLONE_NEWNS|CLONE_NEWUTS|CLONE_NEWIPC|CLONE_NEWNET)
7
#    → 创建新 Namespace 中的子进程
8
# 2. mount("overlay", "/var/lib/docker/overlay2/.../merged", "overlay", ...)
9
#    → 挂载 OverlayFS
10
# 3. mount("proc", "/proc", "proc", ...)
11
#    → 挂载 procfs
12
# 4. pivot_root("/var/lib/docker/overlay2/.../merged", ...)
13
#    → 切换根文件系统
14
# 5. write(5, "200000 100000", ..., "cpu.max")
15
#    → 设置 CPU Cgroup
16
# 6. write(5, "536870912", ..., "memory.max")
17
#    → 设置内存 Cgroup
18
# 7. capset(CAP_SETPCAP, {CAP_AUDIT_WRITE, CAP_KILL, ...})
19
#    → 设置 Capabilities
20
# 8. prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, ...)
21
#    → 设置 seccomp 过滤
22
# 9. execve("/docker-entrypoint.sh", ["nginx", "-g", "daemon off;"], ...)
23
#    → 执行用户命令

1
# runc start 发送信号让 runc init 执行用户命令
2
runc start mycontainer
3

4
# 底层操作：
5
# 1. 通过管道通知 runc init 执行用户命令
6
# 2. runc init 调用 execve() 替换为用户进程
7
# 3. 容器进程开始运行

1
# dockerd 配置端口映射（-p 80:80）
2
# 1. 创建 iptables DNAT 规则
3
sudo iptables -t nat -A DOCKER -p tcp --dport 80 -j DNAT --to-destination 172.17.0.2:80
4

5
# 2. 创建 iptables MASQUERADE 规则
6
sudo iptables -t nat -A POSTROUTING -s 172.17.0.2 -j MASQUERADE
7

8
# 3. 创建 iptables ALLOW 规则
9
sudo iptables -A DOCKER -d 172.17.0.2 -p tcp --dport 80 -j ACCEPT
10

11
# 查看 Docker 的 iptables 规则
12
sudo iptables -t nat -L DOCKER -n -v

1
# Docker 的网络配置流程
2
# 1. 创建 veth pair
3
sudo ip link add veth123 type veth peer name veth456
4

5
# 2. 将一端放入容器 Network Namespace
6
sudo ip link set veth456 netns <container-pid>
7

8
# 3. 将另一端连接到 docker0 bridge
9
sudo ip link set veth123 master docker0
10

11
# 4. 在容器内配置 IP 地址
12
sudo nsenter -t <container-pid> -n ip addr add 172.17.0.2/16 dev eth0
13

14
# 5. 在容器内设置默认路由
15
sudo nsenter -t <container-pid> -n ip route add default via 172.17.0.1

1
# 查看容器的完整状态
2
docker inspect mynginx | python3 -m json.tool
3

4
# 关键信息：
5
# - State.Pid: 容器进程在宿主机上的 PID
6
# - State.Running: 是否运行中
7
# - NetworkSettings.IPAddress: 容器 IP
8
# - HostConfig.PortBindings: 端口映射
9
# - HostConfig.Memory: 内存限制
10
# - HostConfig.NanoCpus: CPU 限制

1
# 查看容器进程的所有 Namespace
2
PID=$(docker inspect -f '{{.State.Pid}}' mynginx)
3
ls -la /proc/$PID/ns/
4

5
# 输出：
6
# cgroup -> 'cgroup:[4026532700]'  ← 独立 Cgroup NS
7
# ipc    -> 'ipc:[4026532698]'     ← 独立 IPC NS
8
# mnt    -> 'mnt:[4026532696]'     ← 独立 Mount NS
9
# net    -> 'net:[4026532699]'     ← 独立 Network NS
10
# pid    -> 'pid:[4026532697]'     ← 独立 PID NS
11
# user   -> 'user:[4026531837]'    ← 共享宿主 User NS
12
# uts    -> 'uts:[4026532695]'     ← 独立 UTS NS

1
# 查看容器的 Cgroup 路径
2
cat /proc/$PID/cgroup
3

4
# 输出（Cgroup v2）：
5
# 0::/system.slice/docker-abc123.scope
6

7
# 查看容器的资源限制
8
cat /sys/fs/cgroup/system.slice/docker-abc123.scope/cpu.max
9
cat /sys/fs/cgroup/system.slice/docker-abc123.scope/memory.max
10
cat /sys/fs/cgroup/system.slice/docker-abc123.scope/pids.max

1
package main
2

3
import (
4
    "context"
5
    "fmt"
6
    "log"
7
    "os"
8
    "syscall"
9

10
    containerd "github.com/containerd/containerd/v2/client"
11
    "github.com/containerd/containerd/v2/pkg/namespaces"
12
    specs "github.com/opencontainers/runtime-spec/specs-go"
13
)
14

15
func main() {
16
    ctx := namespaces.WithNamespace(context.Background(), "default")
17

18
    // 1. 连接 containerd
19
    client, err := containerd.New("/run/containerd/containerd.sock")
20
    if err != nil {
21
        log.Fatal(err)
22
    }
23
    defer client.Close()
24

25
    // 2. 拉取镜像
26
    fmt.Println("Pulling image...")
27
    image, err := client.Pull(ctx, "docker.io/library/nginx:alpine",
28
        containerd.WithPullUnpack)
29
    if err != nil {
30
        log.Fatal(err)
31
    }
32

33
    // 3. 创建容器
34
    fmt.Println("Creating container...")
35
    container, err := client.NewContainer(ctx, "my-nginx",
36
        containerd.WithImage(image),
37
        containerd.WithNewSnapshot("nginx-snapshot", image),
38
        containerd.WithNewSpec(
39
            containerd.WithImageConfig(image),
40
            withResourceLimits(),
41
        ),
42
    )
43
    if err != nil {
44
        log.Fatal(err)
45
    }
46
    defer container.Delete(ctx, containerd.WithSnapshotCleanup)
47

48
    // 4. 创建并启动任务
49
    fmt.Println("Starting container...")
50
    task, err := container.NewTask(ctx,
51
        containerd.NewIO(os.Stdin, os.Stdout, os.Stderr))
52
    if err != nil {
53
        log.Fatal(err)
54
    }
55
    defer task.Delete(ctx)
56

57
    if err := task.Start(ctx); err != nil {
58
        log.Fatal(err)
59
    }
60

61
    // 5. 等待退出
62
    statusC, err := task.Wait(ctx)
63
    if err != nil {
64
        log.Fatal(err)
65
    }
66

67
    fmt.Printf("Container running with PID %d\n", task.Pid())
68
    status := <-statusC
69
    fmt.Printf("Container exited with code %d\n", status.ExitCode())
70
}
71

72
func withResourceLimits() containerd.SpecOpts {
73
    return func(_ context.Context, _ *containerd.Client, c *specs.Spec) error {
74
        c.Linux.Resources = &specs.LinuxResources{
75
            Memory: &specs.LinuxMemory{Limit: int64Ptr(512 * 1024 * 1024)},
76
            CPU: &specs.LinuxCPU{
77
                Quota:  int64Ptr(200000),
78
                Period: uint64Ptr(100000),
79
            },
80
        }
81
        return nil
82
    }
83
}
84

85
func int64Ptr(v int64) *int64    { return &v }
86
func uint64Ptr(v uint64) *uint64 { return &v }

1
# 1. 使用更小的基础镜像
2
docker run -d alpine-based-image  # 比 Ubuntu 镜像快 5-10x
3

4
# 2. 预拉取镜像
5
docker pull nginx:latest  # 提前拉取，避免运行时等待
6

7
# 3. 使用 --init 避免 PID 1 问题
8
docker run --init nginx  # 使用 tini 作为 PID 1
9

10
# 4. 使用 host 网络模式（跳过网络配置）
11
docker run --network=host nginx  # 省去 veth/bridge 配置
12

13
# 5. 限制日志大小
14
docker run --log-driver=json-file --log-opt max-size=10m nginx