1
# 传统方式的存储开销
2
base_image_size = 700  # MB, Ubuntu 基础镜像
3
app_size = 50          # MB, 应用程序
4

5
# 10 个基于同一基础镜像的应用
6
traditional_storage = 10 * (base_image_size + app_size)
7
print(f"传统方式存储：{traditional_storage} MB")
8

9
# Docker 分层方式
10
docker_storage = base_image_size + 10 * app_size
11
print(f"Docker 分层存储：{docker_storage} MB")
12
print(f"节省空间：{(1 - docker_storage/traditional_storage)*100:.1f}%")
13

14
# 输出：
15
# 传统方式存储：7500 MB
16
# Docker 分层存储：1200 MB
17
# 节省空间：84.0%

1
# 创建目录结构
2
mkdir -p /tmp/overlay/{lower1,lower2,upper,work,merged}
3

4
# 在下层目录创建测试文件
5
echo "Layer 1 content" > /tmp/overlay/lower1/file1.txt
6
echo "Layer 2 content" > /tmp/overlay/lower2/file2.txt
7

8
# 挂载 OverlayFS
9
mount -t overlay overlay \
10
  -o lowerdir=/tmp/overlay/lower2:/tmp/overlay/lower1 \
11
  -o upperdir=/tmp/overlay/upper \
12
  -o workdir=/tmp/overlay/work \
13
  /tmp/overlay/merged
14

15
# 查看合并视图
16
ls /tmp/overlay/merged/
17
# 输出: file1.txt  file2.txt

1
# Copy-on-Write 的存储效率分析
2
base_layer_size = 700      # MB, Ubuntu 基础镜像
3
modified_files_size = 10   # MB, 实际修改的文件
4

5
# 传统方式：需要复制整个镜像
6
traditional_size = base_layer_size + modified_files_size
7
print(f"传统方式存储：{traditional_size} MB")
8

9
# CoW 方式：只存储修改的部分
10
cow_size = modified_files_size  # 只存储修改的文件
11
print(f"CoW 方式存储：{cow_size} MB")
12

13
# 如果启动 100 个相同容器
14
print(f"\n100 个容器的存储开销：")
15
print(f"传统方式：{100 * traditional_size} MB")
16
print(f"CoW 方式：{base_layer_size + 100 * cow_size} MB")
17

18
# 输出：
19
# 传统方式存储：710 MB
20
# CoW 方式存储：10 MB
21
#
22
# 100 个容器的存储开销：
23
# 传统方式：71000 MB
24
# CoW 方式：1700 MB

1
# 计算分层存储的效率
2
base_images = {
3
    "ubuntu": 72,
4
    "alpine": 5,
5
    "debian": 114,
6
}
7

8
applications = {
9
    "nginx": 5,
10
    "redis": 3,
11
    "nodejs": 10,
12
    "python": 15,
13
}
14

15
# 传统方式：每个应用独立镜像
16
traditional_total = 0
17
for base, base_size in base_images.items():
18
    for app, app_size in applications.items():
19
        traditional_total += base_size + app_size
20

21
# 分层方式：共享基础镜像
22
layered_total = sum(base_images.values()) + sum(applications.values())
23

24
print(f"传统方式总存储：{traditional_total} MB")
25
print(f"分层方式总存储：{layered_total} MB")
26
print(f"存储效率提升：{(1 - layered_total/traditional_total)*100:.1f}%")
27

28
# 输出：
29
# 传统方式总存储：636 MB
30
# 分层方式总存储：224 MB
31
# 存储效率提升：64.8%

1
# Dockerfile 示例
2
FROM ubuntu:20.04
3

4
# 这一层会被缓存
5
RUN apt-get update && apt-get install -y \
6
    nginx \
7
    curl \
8
    && rm -rf /var/lib/apt/lists/*
9

10
# 这一层也会被缓存（依赖文件不变）
11
COPY requirements.txt /app/
12
RUN pip install -r /app/requirements.txt
13

14
# 这层每次构建都会更新（代码经常变化）
15
COPY . /app/
16
CMD ["python", "/app/main.py"]

1
# 镜像分发效率分析
2
layers = {
3
    "ubuntu": {"size": 72, "modified": False},
4
    "nginx": {"size": 5, "modified": False},
5
    "dependencies": {"size": 20, "modified": False},
6
    "app": {"size": 3, "modified": True},  # 只有应用层变化
7
}
8

9
# 首次拉取：传输所有层
10
first_pull = sum(layer["size"] for layer in layers.values())
11

12
# 更新后拉取：只传输变化的层
13
update_pull = sum(
14
    layer["size"] for layer in layers.values() if layer["modified"]
15
)
16

17
print(f"首次拉取：{first_pull} MB")
18
print(f"更新拉取：{update_pull} MB")
19
print(f"传输节省：{(1 - update_pull/first_pull)*100:.1f}%")
20

21
# 输出：
22
# 首次拉取：100 MB
23
# 更新拉取：3 MB
24
# 传输节省：97.0%

1
# 镜像大小对比
2
workloads = ["Ubuntu", "Nginx", "Redis", "Python", "Node.js"]
3
docker_sizes = [72, 77, 75, 87, 82]  # MB
4
vm_sizes = [500, 505, 503, 513, 508]  # MB, 包含完整 Guest OS
5

6
for i, workload in enumerate(workloads):
7
    reduction = (1 - docker_sizes[i]/vm_sizes[i]) * 100
8
    print(f"{workload}: Docker {docker_sizes[i]}MB vs VM {vm_sizes[i]}MB, 节省 {reduction:.1f}%")
9

10
# 输出：
11
# Ubuntu: Docker 72MB vs VM 500MB, 节省 85.6%
12
# Nginx: Docker 77MB vs VM 505MB, 节省 84.8%
13
# Redis: Docker 75MB vs VM 503MB, 节省 85.1%
14
# Python: Docker 87MB vs VM 513MB, 节省 83.0%
15
# Node.js: Docker 82MB vs VM 508MB, 节省 83.9%

1
# 拉取镜像
2
docker pull nginx:latest
3

4
# 查看镜像层
5
docker history nginx:latest
6

7
# 输出示例：
8
# IMAGE          CREATED       CREATED BY                                      SIZE
9
# 605c77e624dd   2 weeks ago   /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon…   0B
10
# <missing>      2 weeks ago   /bin/sh -c #(nop)  EXPOSE 80                    0B
11
# <missing>      2 weeks ago   /bin/sh -c #(nop) COPY file:09a214a3e07c976…   4.62kB
12
# <missing>      2 weeks ago   /bin/sh -c apt-get update && apt-get install…   61.1MB
13
# <missing>      2 weeks ago   /bin/sh -c #(nop)  CMD ["bash"]                 0B
14
# <missing>      2 weeks ago   /bin/sh -c #(nop) ADD file:4060ec96569404d…   138MB

1
# 查看 Docker 存储驱动
2
docker info | grep "Storage Driver"
3

4
# 输出：
5
# Storage Driver: overlay2
6

7
# 查看 OverlayFS 挂载信息
8
mount | grep overlay
9

10
# 输出示例：
11
# overlay on /var/lib/docker/overlay2/.../merged
12
# type overlay (rw,relatime,
13
#   lowerdir=/var/lib/docker/overlay2/l/XXX:/var/lib/docker/overlay2/l/YYY,
14
#   upperdir=/var/lib/docker/overlay2/.../diff,
15
#   workdir=/var/lib/docker/overlay2/.../work)

1
# 不推荐：每条 RUN 创建一层
2
RUN apt-get update
3
RUN apt-get install -y nginx
4
RUN apt-get install -y curl
5
RUN apt-get clean
6

7
# 推荐：合并相关命令
8
RUN apt-get update && apt-get install -y \
9
    nginx \
10
    curl \
11
    && rm -rf /var/lib/apt/lists/*

1
# 推荐：将变化最少的部分放在前面
2
FROM node:18-alpine
3

4
# 安装依赖（变化少）
5
WORKDIR /app
6
COPY package*.json ./
7
RUN npm ci --only=production
8

9
# 复制代码（变化多）
10
COPY . .
11
CMD ["node", "server.js"]

1
# 构建阶段
2
FROM golang:1.21 AS builder
3
WORKDIR /app
4
COPY . .
5
RUN CGO_ENABLED=0 go build -o myapp
6

7
# 运行阶段
8
FROM alpine:latest
9
COPY --from=builder /app/myapp /usr/local/bin/
10
CMD ["myapp"]

1
# 基础镜像选择建议
2
def select_base_image(needs):
3
    if needs.get("static_binary"):
4
        return "scratch"
5
    elif needs.get("minimal_size"):
6
        return "alpine"
7
    elif needs.get("security_critical"):
8
        return "distroless/base"
9
    elif needs.get("development"):
10
        return "ubuntu"
11
    else:
12
        return "debian:slim"

1
# 危险：密码会被永久保存在镜像层中
2
ENV DATABASE_PASSWORD=secret123
3

4
# 推荐：使用运行时挂载或环境变量
5
# docker run -e DATABASE_PASSWORD=secret123 myapp