Docker 核心概念

本章将深入讲解 Docker 的核心概念，帮助你理解 Docker 的工作原理和架构设计。

Docker 架构概览

整体架构图

┌─────────────────────────────────────────────────────────────┐
│                    Docker 架构                              │
├─────────────────────────────────────────────────────────────┤
│  Docker Client                                              │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐     │
│  │ docker build│    │ docker pull │    │ docker run  │     │
│  └─────────────┘    └─────────────┘    └─────────────┘     │
└─────────────────────┬───────────────────────────────────────┘
                      │ REST API
┌─────────────────────▼───────────────────────────────────────┐
│                Docker Daemon                                │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐     │
│  │   Images    │    │ Containers  │    │  Networks   │     │
│  └─────────────┘    └─────────────┘    └─────────────┘     │
│  ┌─────────────┐    ┌─────────────┐                        │
│  │   Volumes   │    │   Plugins   │                        │
│  └─────────────┘    └─────────────┘                        │
└─────────────────────┬───────────────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────────────┐
│                Docker Registry                              │
│  ┌─────────────────────────────────────────────────────────┐│
│  │                Docker Hub                               ││
│  │  ┌─────────────┐    ┌─────────────┐                    ││
│  │  │   nginx     │    │   ubuntu    │    ...             ││
│  │  └─────────────┘    └─────────────┘                    ││
│  └─────────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────────┘

核心组件

1. Docker Client（客户端）：用户与 Docker 交互的接口
2. Docker Daemon（守护进程）：Docker 的核心服务
3. Docker Registry（仓库）：存储和分发镜像的服务

镜像 (Images)

什么是 Docker 镜像？

Docker 镜像是一个只读的模板，用于创建 Docker 容器。镜像包含运行应用程序所需的所有内容：

• 应用程序代码
• 运行时环境
• 库文件
• 环境变量
• 配置文件

镜像的分层结构

Docker 镜像采用分层存储架构：

┌─────────────────────────────────────┐
│        应用层 (Application)         │  ← 可写层
├─────────────────────────────────────┤
│         依赖层 (Dependencies)       │  ← 只读层
├─────────────────────────────────────┤
│         运行时层 (Runtime)          │  ← 只读层
├─────────────────────────────────────┤
│         基础层 (Base OS)            │  ← 只读层
└─────────────────────────────────────┘

分层的优势：

• 存储效率：相同的层可以被多个镜像共享
• 传输效率：只需传输变化的层
• 构建效率：可以缓存未变化的层

镜像命名规范

[registry_host[:port]/]username/repository[:tag]

示例：

# 官方镜像
nginx:1.21.6
ubuntu:20.04

# 用户镜像
myuser/myapp:v1.0

# 私有仓库镜像
registry.company.com:5000/team/app:latest

镜像操作命令

# 列出本地镜像
docker images
docker image ls

# 查看镜像详细信息
docker image inspect nginx:latest

# 查看镜像历史
docker image history nginx:latest

# 删除镜像
docker image rm nginx:latest
docker rmi nginx:latest

# 清理未使用的镜像
docker image prune

# 导出镜像
docker image save nginx:latest -o nginx.tar

# 导入镜像
docker image load -i nginx.tar

# 标记镜像
docker image tag nginx:latest myregistry/nginx:v1.0

容器 (Containers)

什么是 Docker 容器？

容器是镜像的运行实例，它是一个轻量级、独立的可执行包，包含运行应用程序所需的一切。

容器与镜像的关系

镜像 (Image)     →     容器 (Container)
    ↓                      ↓
  只读模板              运行实例
  静态文件              动态进程
  存储在磁盘            运行在内存

类比：

• 镜像 = 类 (Class)
• 容器 = 对象 (Object)

容器的生命周期

Created → Running → Paused → Stopped → Removed
   ↑         ↓        ↑         ↓         ↓
   └─────────┴────────┴─────────┴─────────┘

状态说明：

• Created：容器已创建但未启动
• Running：容器正在运行
• Paused：容器已暂停
• Stopped：容器已停止
• Removed：容器已删除

容器操作命令

# 创建容器
docker create --name mycontainer nginx

# 启动容器
docker start mycontainer

# 运行容器（创建并启动）
docker run --name mycontainer nginx

# 停止容器
docker stop mycontainer

# 重启容器
docker restart mycontainer

# 暂停容器
docker pause mycontainer

# 恢复容器
docker unpause mycontainer

# 删除容器
docker rm mycontainer

# 强制删除运行中的容器
docker rm -f mycontainer

# 查看容器详细信息
docker inspect mycontainer

# 查看容器日志
docker logs mycontainer

# 进入容器
docker exec -it mycontainer /bin/bash

# 从容器复制文件
docker cp mycontainer:/path/to/file ./local/path

# 向容器复制文件
docker cp ./local/file mycontainer:/path/to/destination

仓库 (Registry)

什么是 Docker 仓库？

Docker 仓库是存储和分发 Docker 镜像的服务。它类似于代码仓库，但存储的是镜像而不是源代码。

仓库的层次结构

Registry (仓库服务)
├── Repository (镜像仓库)
│   ├── Tag 1 (标签/版本)
│   ├── Tag 2
│   └── Tag 3
└── Repository
    ├── Tag 1
    └── Tag 2

常见的仓库服务

1. Docker Hub：官方公共仓库
2. 阿里云容器镜像服务：国内镜像加速
3. 腾讯云容器镜像服务：企业级镜像仓库
4. Harbor：开源企业级仓库
5. 私有仓库：自建仓库服务

仓库操作命令

# 登录仓库
docker login
docker login registry.company.com

# 搜索镜像
docker search nginx

# 拉取镜像
docker pull nginx:latest
docker pull registry.company.com/nginx:latest

# 推送镜像
docker push myuser/myapp:v1.0

# 登出仓库
docker logout

数据管理

数据持久化的挑战

容器是临时的，当容器删除时，容器内的数据也会丢失。Docker 提供了几种数据持久化方案：

1. 数据卷 (Volumes)

数据卷是 Docker 管理的持久化存储，存储在 Docker 的数据目录中。

# 创建数据卷
docker volume create myvolume

# 列出数据卷
docker volume ls

# 查看数据卷详细信息
docker volume inspect myvolume

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

# 删除数据卷
docker volume rm myvolume

# 清理未使用的数据卷
docker volume prune

数据卷的特点：

• 由 Docker 完全管理
• 可以在容器间共享
• 支持数据卷驱动程序
• 可以备份和恢复

2. 绑定挂载 (Bind Mounts)

绑定挂载将主机文件系统的目录或文件挂载到容器中。

# 绑定挂载目录
docker run -v /host/path:/container/path nginx

# 只读挂载
docker run -v /host/path:/container/path:ro nginx

# 使用绝对路径
docker run -v $(pwd)/data:/app/data nginx

绑定挂载的特点：

• 直接访问主机文件系统
• 性能较好
• 依赖主机文件系统结构
• 可能存在安全风险

3. tmpfs 挂载

tmpfs 挂载将数据存储在主机内存中，容器停止时数据消失。

# 创建 tmpfs 挂载
docker run --tmpfs /tmp nginx

# 指定大小和选项
docker run --tmpfs /tmp:rw,size=100m nginx

数据管理最佳实践

# 1. 使用数据卷存储应用数据
docker run -v app-data:/var/lib/app myapp

# 2. 使用绑定挂载开发时的代码
docker run -v $(pwd):/workspace node:16

# 3. 使用 tmpfs 存储临时数据
docker run --tmpfs /tmp myapp

# 4. 备份数据卷
docker run --rm -v app-data:/data -v $(pwd):/backup ubuntu tar czf /backup/backup.tar.gz -C /data .

# 5. 恢复数据卷
docker run --rm -v app-data:/data -v $(pwd):/backup ubuntu tar xzf /backup/backup.tar.gz -C /data

网络管理

Docker 网络模式

Docker 提供了多种网络模式来满足不同的需求：

1. Bridge 网络（默认）

# 查看网络列表
docker network ls

# 创建自定义 bridge 网络
docker network create mynetwork

# 在指定网络中运行容器
docker run --network mynetwork nginx

# 连接容器到网络
docker network connect mynetwork container_name

# 断开容器网络连接
docker network disconnect mynetwork container_name

2. Host 网络

# 使用主机网络
docker run --network host nginx

3. None 网络

# 禁用网络
docker run --network none nginx

4. 容器网络

# 共享另一个容器的网络
docker run --network container:other_container nginx

端口映射

# 映射单个端口
docker run -p 8080:80 nginx

# 映射多个端口
docker run -p 8080:80 -p 8443:443 nginx

# 映射到指定 IP
docker run -p 127.0.0.1:8080:80 nginx

# 映射 UDP 端口
docker run -p 8080:80/udp nginx

# 映射到随机端口
docker run -P nginx

# 查看端口映射
docker port container_name

容器间通信

# 创建自定义网络
docker network create app-network

# 运行数据库容器
docker run -d --name database --network app-network postgres

# 运行应用容器，可以通过容器名访问数据库
docker run -d --name webapp --network app-network myapp

# 在应用中可以使用 "database" 作为主机名连接数据库

资源限制

CPU 限制

# 限制 CPU 使用率（0.5 = 50%）
docker run --cpus="0.5" nginx

# 限制 CPU 核心数
docker run --cpuset-cpus="0,1" nginx

# 设置 CPU 权重
docker run --cpu-shares=512 nginx

内存限制

# 限制内存使用
docker run -m 512m nginx
docker run --memory=1g nginx

# 设置 swap 限制
docker run -m 512m --memory-swap=1g nginx

# 禁用 swap
docker run -m 512m --memory-swap=512m nginx

磁盘 I/O 限制

# 限制读取速度（字节/秒）
docker run --device-read-bps /dev/sda:1mb nginx

# 限制写入速度
docker run --device-write-bps /dev/sda:1mb nginx

# 限制 IOPS
docker run --device-read-iops /dev/sda:1000 nginx

环境变量和配置

环境变量

# 设置单个环境变量
docker run -e NODE_ENV=production node

# 设置多个环境变量
docker run -e NODE_ENV=production -e PORT=3000 node

# 从文件读取环境变量
docker run --env-file .env node

# 传递主机环境变量
docker run -e HOME node

配置文件管理

# 挂载配置文件
docker run -v /host/config.conf:/app/config.conf nginx

# 使用 ConfigMap（在 Kubernetes 中）
docker run -v config-volume:/etc/config nginx

本章小结

本章深入讲解了 Docker 的核心概念：

关键要点：

• 镜像：只读模板，采用分层存储结构
• 容器：镜像的运行实例，有完整的生命周期
• 仓库：存储和分发镜像的服务
• 数据管理：数据卷、绑定挂载、tmpfs 三种方式
• 网络管理：多种网络模式和端口映射
• 资源限制：CPU、内存、磁盘 I/O 控制

理解这些概念的重要性：

• 为后续学习 Dockerfile 和容器编排奠定基础
• 帮助你设计更好的容器化应用架构
• 提高容器使用的效率和安全性

在下一章中，我们将学习容器的基础操作，包括创建、管理和监控容器的详细方法。

延伸阅读

• Docker 存储驱动详解
• Docker 网络详细指南
• Docker 资源限制最佳实践