第12章 Docker存储机制（重要）

在前面章节中，我们已经多次使用数据卷来持久化数据。本章将深入探讨Docker的存储机制，理解容器存储的底层原理，以及为什么需要数据持久化。

12.1 容器存储层原理

12.1.1 分层文件系统

Docker使用联合文件系统（UnionFS）来构建镜像，每个镜像由多个只读层组成。

text 复制代码

容器文件系统结构：

┌─────────────────────────────┐
│   容器层（可读写）             │  ← 容器运行时的修改
├─────────────────────────────┤
│   镜像层N（只读）             │
├─────────────────────────────┤
│   镜像层N-1（只读）           │
├─────────────────────────────┤
│   ...                       │
├─────────────────────────────┤
│   镜像层1（只读）             │
├─────────────────────────────┤
│   基础层（只读）              │
└─────────────────────────────┘

查看镜像层：

bash 复制代码

# 查看镜像的层结构
docker history nginx:alpine

# 输出示例：
# IMAGE          CREATED BY                                      SIZE
# a99a39d070bf   /bin/sh -c #(nop)  CMD ["nginx" "-g" "daemon...   0B
# <missing>      /bin/sh -c #(nop)  STOPSIGNAL SIGQUIT           0B
# <missing>      /bin/sh -c #(nop)  EXPOSE 80                    0B
# <missing>      /bin/sh -c apk add --no-cache nginx             9.76MB
# <missing>      /bin/sh -c #(nop)  CMD ["/bin/sh"]              0B
# <missing>      /bin/sh -c #(nop) ADD file:1f4eb46669b5b6275...   7.05MB

# 查看镜像的层ID
docker inspect nginx:alpine --format='{{json .RootFS.Layers}}' | jq

12.1.2 写时复制（Copy-on-Write）

text 复制代码

CoW机制工作原理：

1. 读取文件：
   容器 → 检查容器层 → 未找到 → 向下查找镜像层 → 返回文件

2. 修改文件：
   容器 → 检查容器层 → 未找到 → 从镜像层复制到容器层 → 修改 → 保存

3. 删除文件：
   容器 → 在容器层创建删除标记（whiteout）→ 隐藏底层文件

实践演示：

bash 复制代码

# 启动容器
docker run -d --name test nginx:alpine

# 查看容器的文件系统变更
docker diff test

# 输出示例：
# C /var
# C /var/cache
# C /var/cache/nginx
# A /var/run/nginx.pid

# C = Changed（修改）
# A = Added（新增）
# D = Deleted（删除）

# 在容器内修改文件
docker exec test sh -c "echo 'test' > /usr/share/nginx/html/index.html"

# 再次查看变更
docker diff test
# C /usr/share/nginx/html/index.html

12.1.3 容器层的特点

bash 复制代码

# 容器层特点：
# 1. 可读写
# 2. 容器删除时，容器层也会删除
# 3. 每个容器都有独立的容器层
# 4. 容器层相对较小

# 验证容器层大小
docker ps -s

# 输出示例：
# CONTAINER ID   IMAGE    SIZE
# a1b2c3d4e5f6   nginx    1.09kB (virtual 142MB)
#                         ↑ 容器层   ↑ 镜像+容器层总大小

12.1.4 存储驱动

Docker支持多种存储驱动，每种驱动实现CoW的方式不同。

bash 复制代码

# 查看当前存储驱动
docker info | grep "Storage Driver"

# 常见存储驱动：
# - overlay2 (推荐，Linux kernel 4.0+)
# - aufs (旧版Ubuntu)
# - devicemapper (CentOS/RHEL 7)
# - btrfs (需要btrfs文件系统)
# - zfs (需要ZFS文件系统)

overlay2工作原理：

text 复制代码

overlay2结构：

宿主机文件系统
    └── /var/lib/docker/overlay2/
        ├── l/                      # 符号链接
        ├── <layer-id>/
        │   ├── diff/               # 层的内容
        │   ├── link               # 层的短ID
        │   ├── lower              # 下层引用
        │   └── work/              # 工作目录
        └── <container-id>/
            ├── diff/               # 容器层
            ├── merged/             # 挂载点（容器看到的文件系统）
            └── work/

查看存储驱动详情：

bash 复制代码

# 查看容器的存储信息
docker inspect test --format='{{json .GraphDriver}}' | jq

# 输出示例：
# {
#   "Data": {
#     "LowerDir": "/var/lib/docker/overlay2/xxx/diff:...",
#     "MergedDir": "/var/lib/docker/overlay2/yyy/merged",
#     "UpperDir": "/var/lib/docker/overlay2/yyy/diff",
#     "WorkDir": "/var/lib/docker/overlay2/yyy/work"
#   },
#   "Name": "overlay2"
# }

12.2 数据持久化的必要性

12.2.1 容器层的问题

bash 复制代码

# 问题1：数据易失性
docker run -d --name web nginx
docker exec web sh -c "echo 'important data' > /data/file.txt"
docker rm -f web
# 数据丢失！

# 问题2：性能问题
# 容器层的I/O性能比直接访问主机文件系统慢
# 频繁的写操作会影响性能

# 问题3：容器间数据共享困难
docker run -d --name app1 myapp
docker run -d --name app2 myapp
# app1和app2无法共享数据

# 问题4：备份和迁移困难
# 需要使用docker commit或docker export
# 不适合频繁备份

12.2.2 数据持久化的需求场景

bash 复制代码

# 场景1：数据库数据持久化
docker run -d \
  --name mysql \
  -v mysql-data:/var/lib/mysql \
  mysql:8.0
# 容器删除后，数据仍然保留

# 场景2：日志持久化
docker run -d \
  --name web \
  -v /var/log/nginx:/var/log/nginx \
  nginx
# 便于日志分析和审计

# 场景3：配置文件管理
docker run -d \
  --name app \
  -v $(pwd)/config.yaml:/app/config.yaml:ro \
  myapp
# 便于配置更新

# 场景4：开发环境代码同步
docker run -d \
  --name dev \
  -v $(pwd):/app \
  node:18
# 代码修改实时生效

# 场景5：容器间数据共享
docker volume create shared-data
docker run -d --name producer -v shared-data:/data producer-app
docker run -d --name consumer -v shared-data:/data consumer-app
# 生产者和消费者共享数据

12.3 三种数据管理方式

Docker提供三种数据持久化方式：Volumes、Bind Mounts和tmpfs。

12.3.1 数据卷（Volumes）

特点：

由Docker管理（存储在/var/lib/docker/volumes/）
完全独立于容器生命周期
可以在多个容器间共享
支持使用卷驱动程序（如网络卷）
可以安全备份和迁移
推荐用于生产环境

text 复制代码

Volumes架构：

宿主机
├── /var/lib/docker/volumes/
│   ├── mydata/
│   │   └── _data/          ← 实际数据存储位置
│   │       └── file.txt
│   └── logs/
│       └── _data/
│           └── app.log
│
容器
└── /data → 挂载到 → /var/lib/docker/volumes/mydata/_data

基本操作：

bash 复制代码

# 创建数据卷
docker volume create mydata

# 查看数据卷
docker volume ls

# 查看数据卷详情
docker volume inspect mydata

# 输出：
# [
#     {
#         "CreatedAt": "2024-02-10T10:00:00Z",
#         "Driver": "local",
#         "Labels": {},
#         "Mountpoint": "/var/lib/docker/volumes/mydata/_data",
#         "Name": "mydata",
#         "Options": {},
#         "Scope": "local"
#     }
# ]

# 使用数据卷
docker run -d -v mydata:/data nginx

# 删除数据卷
docker volume rm mydata

# 删除未使用的数据卷
docker volume prune

命名卷 vs 匿名卷：

bash 复制代码

# 命名卷（推荐）
docker run -d -v mydata:/data nginx
# 卷名：mydata，便于管理

# 匿名卷
docker run -d -v /data nginx
# 卷名：随机生成（如：a1b2c3d4e5f6...）

# 查看匿名卷
docker volume ls --filter dangling=true

# 自动删除匿名卷
docker run -d --rm -v /data nginx
# 容器删除时，匿名卷也会删除

12.3.2 绑定挂载（Bind Mounts）

特点：

挂载主机的任意目录或文件
性能优秀（直接访问主机文件系统）
依赖主机的目录结构
可以被主机上的进程修改（风险）
适合开发环境

text 复制代码

Bind Mounts架构：

宿主机
├── /home/user/project/
│   ├── src/
│   │   └── app.py
│   └── config.yaml
│
容器
├── /app → 挂载到 → /home/user/project

基本操作：

bash 复制代码

# 挂载目录
docker run -d -v /host/path:/container/path nginx
docker run -d -v $(pwd):/app node:18

# 只读挂载
docker run -d -v $(pwd):/app:ro node:18

# 挂载单个文件
docker run -d -v /host/config.json:/app/config.json nginx

# 使用--mount（推荐，更明确）
docker run -d \
  --mount type=bind,source=/host/path,target=/container/path \
  nginx

# 只读挂载
docker run -d \
  --mount type=bind,source=/host/path,target=/container/path,readonly \
  nginx

注意事项：

bash 复制代码

# 1. 路径必须是绝对路径
docker run -v /absolute/path:/data nginx  # ✅
docker run -v relative/path:/data nginx  # ❌

# 2. 目录不存在时的行为
# Bind Mount: Docker会自动创建目录（但可能权限不对）
# Volume: Docker会创建并设置合适的权限

# 3. 挂载后会覆盖容器内的目录
docker run -v /empty:/usr/share/nginx/html nginx
# nginx默认页面被覆盖，显示空目录

# 4. 权限问题
# 容器内的用户ID和主机用户ID需要匹配
docker run -u $(id -u):$(id -g) -v $(pwd):/app node:18

12.3.3 tmpfs挂载

特点：

存储在主机内存中
容器停止时数据丢失
不写入主机文件系统
高性能（内存速度）
适合临时数据、敏感数据

text 复制代码

tmpfs架构：

宿主机内存
├── tmpfs mount
│   └── 临时数据
│
容器
└── /tmp → 挂载到 → 内存

基本操作：

bash 复制代码

# 使用--tmpfs
docker run -d --tmpfs /tmp nginx

# 使用--mount（推荐）
docker run -d \
  --mount type=tmpfs,target=/tmp,tmpfs-size=100m \
  nginx

# 多个tmpfs挂载
docker run -d \
  --mount type=tmpfs,target=/tmp,tmpfs-size=100m \
  --mount type=tmpfs,target=/cache,tmpfs-size=50m \
  myapp

使用场景：

bash 复制代码

# 场景1：临时缓存
docker run -d \
  --mount type=tmpfs,target=/cache,tmpfs-size=500m \
  redis:7.0

# 场景2：敏感数据处理
docker run -d \
  --mount type=tmpfs,target=/secrets,tmpfs-size=10m \
  crypto-app

# 场景3：高性能临时存储
docker run -d \
  --mount type=tmpfs,target=/tmp,tmpfs-size=1g \
  build-app

12.3.4 三种方式对比

特性	Volume	Bind Mount	tmpfs
存储位置	Docker管理目录	主机任意位置	内存
管理工具	docker volume	无	无
持久化	是	是	否
性能	好	优秀	最佳
共享	容器间	容器+主机	无
备份	简单	需手动	不适用
迁移	简单	复杂	不适用
安全性	高	中	高
跨平台	是	否	Linux only
推荐场景	生产环境	开发环境	临时数据

12.3.5 选择指南

bash 复制代码

# ✅ 使用Volumes的场景
# - 生产环境数据库
# - 需要备份的数据
# - 多个容器共享数据
# - 需要使用卷驱动程序（如NFS）
docker run -d -v db-data:/var/lib/mysql mysql:8.0

# ✅ 使用Bind Mounts的场景
# - 开发环境代码同步
# - 配置文件注入
# - 日志收集
# - 需要主机和容器双向同步
docker run -d -v $(pwd):/app node:18

# ✅ 使用tmpfs的场景
# - 临时缓存
# - 会话数据
# - 敏感信息（密码、密钥）
# - 不需要持久化的高性能存储
docker run -d --tmpfs /tmp:size=100m nginx

12.4 存储性能考虑

12.4.1 性能对比

bash 复制代码

# 性能测试脚本
#!/bin/bash

# 1. 容器层写入（最慢）
docker run --rm alpine sh -c "
  time dd if=/dev/zero of=/test.file bs=1M count=1000
"

# 2. Volume写入（快）
docker run --rm -v test-vol:/data alpine sh -c "
  time dd if=/dev/zero of=/data/test.file bs=1M count=1000
"

# 3. Bind Mount写入（很快）
docker run --rm -v /tmp:/data alpine sh -c "
  time dd if=/dev/zero of=/data/test.file bs=1M count=1000
"

# 4. tmpfs写入（最快）
docker run --rm --tmpfs /data alpine sh -c "
  time dd if=/dev/zero of=/data/test.file bs=1M count=1000
"

性能排序：

text 复制代码

性能：tmpfs > Bind Mount ≈ Volume >> 容器层

推荐：
- 频繁读写：使用Volume或Bind Mount
- 极高性能要求：使用tmpfs
- 避免：在容器层频繁写入大文件

12.4.2 优化建议

bash 复制代码

# 1. 避免在容器层写入大文件
# ❌ 不好
docker run -d nginx
docker exec nginx dd if=/dev/zero of=/bigfile bs=1M count=10000

# ✅ 好
docker run -d -v data:/data nginx
docker exec nginx dd if=/dev/zero of=/data/bigfile bs=1M count=10000

# 2. 使用Volume而不是Bind Mount（生产环境）
# Volume有更好的隔离性和一致性

# 3. 合理使用tmpfs
# 临时文件、缓存使用tmpfs可以显著提升性能
docker run -d --tmpfs /tmp:size=1g myapp

# 4. 选择合适的存储驱动
# overlay2（推荐）> aufs > devicemapper

# 5. 定期清理未使用的卷
docker volume prune

12.5 存储最佳实践

12.5.1 数据备份策略

bash 复制代码

# Volume备份
# 方法1：使用临时容器
docker run --rm \
  -v mydata:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/mydata-backup.tar.gz /data

# 方法2：直接复制
sudo cp -r /var/lib/docker/volumes/mydata/_data ./backup/

# 恢复数据
docker run --rm \
  -v mydata:/data \
  -v $(pwd):/backup \
  alpine sh -c "cd /data && tar xzf /backup/mydata-backup.tar.gz --strip 1"

12.5.2 数据迁移

bash 复制代码

# 迁移到另一台主机
# 1. 在源主机备份
docker run --rm -v mydata:/data -v $(pwd):/backup alpine \
  tar czf /backup/data.tar.gz /data

# 2. 传输到目标主机
scp data.tar.gz user@target-host:/tmp/

# 3. 在目标主机恢复
docker volume create mydata
docker run --rm -v mydata:/data -v /tmp:/backup alpine \
  sh -c "cd /data && tar xzf /backup/data.tar.gz --strip 1"

12.5.3 权限管理

bash 复制代码

# 设置Volume权限
docker run --rm -v mydata:/data alpine \
  sh -c "chown -R 1000:1000 /data && chmod -R 755 /data"

# 以特定用户运行容器
docker run -d \
  --user 1000:1000 \
  -v mydata:/data \
  myapp

# 检查权限
docker run --rm -v mydata:/data alpine ls -la /data

12.5.4 命名规范

bash 复制代码

# ✅ 好的命名（描述性强）
docker volume create mysql-prod-data
docker volume create redis-cache-data
docker volume create app-logs-2024

# ❌ 不好的命名
docker volume create vol1
docker volume create data
docker volume create temp

# 使用标签组织
docker volume create \
  --label env=production \
  --label app=mysql \
  --label version=8.0 \
  mysql-prod-8.0-data

12.5.5 监控和维护

bash 复制代码

# 查看卷使用情况
docker system df -v

# 输出：
# Volumes space usage:
# VOLUME NAME              LINKS     SIZE
# mysql-data               1         2.5GB
# redis-data               1         100MB
# logs                     2         500MB

# 查找大体积卷
docker volume ls --format "{{.Name}}" | \
  xargs -I {} sh -c 'echo -n "{}: "; \
  docker run --rm -v {}:/data alpine du -sh /data | cut -f1'

# 定期清理
# 1. 删除未使用的卷
docker volume prune

# 2. 删除特定卷（确认后）
docker volume rm $(docker volume ls -q --filter dangling=true)

# 3. 自动化清理脚本
cat > cleanup-volumes.sh <<'EOF'
#!/bin/bash
# 删除30天未使用的卷
for vol in $(docker volume ls -q); do
    last_used=$(docker volume inspect $vol \
        --format '{{.CreatedAt}}' | date -d - +%s)
    now=$(date +%s)
    days_old=$(( ($now - $last_used) / 86400 ))
    
    if [ $days_old -gt 30 ]; then
        echo "Removing old volume: $vol (${days_old} days old)"
        docker volume rm $vol
    fi
done
EOF
chmod +x cleanup-volumes.sh

12.6 实战案例

12.6.1 完整的应用栈存储配置

bash 复制代码

# 创建网络
docker network create app-net

# 数据库（Volume）
docker run -d \
  --name postgres \
  --network app-net \
  --restart unless-stopped \
  -e POSTGRES_PASSWORD=secret \
  -v postgres-data:/var/lib/postgresql/data \
  -v postgres-logs:/var/log/postgresql \
  postgres:13

# 缓存（Volume）
docker run -d \
  --name redis \
  --network app-net \
  --restart unless-stopped \
  -v redis-data:/data \
  redis:7.0 redis-server --appendonly yes

# 应用（Bind Mount配置，Volume日志）
docker run -d \
  --name app \
  --network app-net \
  --restart unless-stopped \
  -v $(pwd)/config:/app/config:ro \
  -v app-uploads:/app/uploads \
  -v app-logs:/var/log/app \
  --tmpfs /tmp:size=500m \
  myapp:latest

# Nginx（Bind Mount配置，Volume日志）
docker run -d \
  --name nginx \
  --network app-net \
  --restart unless-stopped \
  -p 80:80 \
  -p 443:443 \
  -v $(pwd)/nginx.conf:/etc/nginx/nginx.conf:ro \
  -v $(pwd)/ssl:/etc/nginx/ssl:ro \
  -v nginx-logs:/var/log/nginx \
  nginx:alpine

12.6.2 开发环境配置

bash 复制代码

# 开发环境：使用Bind Mount实现热重载
docker run -d \
  --name dev-app \
  -v $(pwd):/app \
  -v /app/node_modules \
  -p 3000:3000 \
  --tmpfs /tmp \
  node:18 \
  npm run dev

12.7 小结

通过本章学习，我们深入理解了Docker的存储机制：

✅ 容器存储层原理

分层文件系统和UnionFS
写时复制（CoW）机制
存储驱动（overlay2等）

✅ 数据持久化必要性

容器层的限制
数据持久化的场景

✅ 三种数据管理方式

Volumes：生产环境首选
Bind Mounts：开发环境利器
tmpfs：临时高性能存储

✅ 性能和最佳实践

性能对比和优化
备份和迁移策略
权限和命名规范
监控和维护

存储方式选择决策树

text 复制代码

需要数据持久化？
├─ 否 → 使用tmpfs（临时数据、高性能）
└─ 是 → 生产环境？
    ├─ 是 → 使用Volume（易管理、可备份）
    └─ 否 → 需要主机访问？
        ├─ 是 → 使用Bind Mount（开发、配置）
        └─ 否 → 使用Volume（最佳选择）

下一步

在第13章中，我们将详细学习数据卷（Volume）的高级用法：

卷的创建和管理
卷的备份和恢复
卷驱动程序
多容器数据共享

本章思考题：

为什么容器层使用CoW机制？有什么优缺点？
在什么场景下应该使用Volume，什么场景使用Bind Mount？
如何诊断和解决容器存储性能问题？
如何安全地备份和迁移Docker卷中的数据？
tmpfs适合存储什么类型的数据？为什么？

相关资源：

Docker存储概述：https://docs.docker.com/storage/
存储驱动选择：https://docs.docker.com/storage/storagedriver/select-storage-driver/
Volume管理：https://docs.docker.com/storage/volumes/
Bind Mounts：https://docs.docker.com/storage/bind-mounts/