01简介

Docker 是目前最流行的**开源容器化平台**，旨在解决 “软件在不同环境下运行不一致” 的核心痛点，实现  “一次构建，到处运行”（Build once, run anywhere）的目标。

通过轻量级的 “容器”  技术，将应用及其依赖（库、配置、环境变量等）打包成标准化单元，确保应用在开发、测试、生产等任意环境中都能以相同方式运行，极大简化了应用的部署、迁移和运维流程。

## 概念

要理解 Docker，必须先掌握其三大核心组件：**镜像（Image）**、**容器（Container）**、**仓库（Repository）**，以及支撑它们的 **Docker 引擎（Engine）**。

### 1. Docker 引擎（Docker Engine）

Docker 引擎是 Docker 的核心运行环境，采用 **C/S（客户端 - 服务器）架构**，包含三个部分：

1. **Docker 守护进程（dockerd）**：运行在宿主机后台的服务进程，负责管理镜像、容器的生命周期（创建、启动、停止、删除等），并监听客户端请求。
2. **Docker REST API**：守护进程与客户端（或其他工具）的通信接口，客户端通过 API 向守护进程发送指令。
3. **Docker 客户端（docker CLI）**：用户交互的命令行工具（如 docker run、docker pull），本质是向守护进程发送 API 请求的 “入口”。

**工作流程**：用户通过 docker 命令（客户端）发送指令 → 指令通过 REST API 传递给守护进程 → 守护进程执行操作（如启动容器）→ 结果返回给客户端。

### 2. 镜像（Image）：容器的 “模板”

镜像是一个**只读的二进制文件**，包含运行应用所需的完整环境：操作系统内核依赖、应用代码、库文件、配置文件、环境变量等。可以理解为 “容器的模板”—— 容器是镜像的**运行实例**。

镜像的核心特性：

分层存储（UnionFS 支撑）：镜像采用 “分层” 结构构建（类似 “叠汉堡”），每一层对应一个构建步骤（如 “安装 Nginx”“复制配置文件”）。分层的优势在于：

- **复用性**：不同镜像可共享相同底层（如 Ubuntu 基础层），减少存储空间占用。
- **增量构建**：修改某一层时，仅重新构建该层及上层，加速构建过程。

**不可修改（只读）**：镜像一旦构建完成，其内容无法修改；若需更新，需基于原镜像新增一层（或修改 Dockerfile 重新构建）。

**轻量级**：镜像仅包含应用运行必需的文件（不含完整操作系统内核），体积远小于虚拟机镜像（如 Nginx 镜像仅几十 MB，而 Ubuntu 虚拟机镜像需数 GB）。

镜像的来源：

**官方镜像**：Docker Hub 提供的官方维护镜像（如 nginx、ubuntu、mysql），安全性高、稳定性强。

**第三方镜像**：开发者或组织上传的镜像（需注意安全性，建议优先选择官方或高星镜像）。

**自定义镜像**：通过 Dockerfile 编写构建规则，手动构建符合自身需求的镜像（如 “基于 Ubuntu 安装 Python + Flask 应用”）。

### 3. 容器（Container）：镜像的 “运行实例”

容器是镜像的**动态运行实例**，本质是 “在宿主机内核中隔离的一组进程”—— 它在镜像的只读层之上添加了一层**可读写层**，所有对容器内文件的修改（如创建日志、修改配置）都仅存在于这一层（容器删除后，可读写层也会消失）。

容器的核心特性：

**进程级隔离**：容器通过 Linux 内核技术（Namespace、Cgroups）实现资源隔离和限制，与宿主机及其他容器互不干扰，但**共享宿主机内核**（区别于虚拟机的独立内核）。

**生命周期可控**：容器有明确的生命周期（创建 → 启动 → 运行 → 停止 → 删除），可通过命令或 API 灵活管理。

**可移植性**：容器可导出为 “容器镜像”（docker commit）或直接打包为归档文件（docker export），迁移到其他 Docker 环境后可直接运行。

**资源可限制**：可指定容器的 CPU 使用率、内存上限（如 docker run --memory=1G --cpus=0.5 nginx），避免单个容器占用过多宿主机资源。

## 容器与虚拟机（VM）

| 对比维度 | Docker 容器                         | 传统虚拟机（VMware/VirtualBox）           |
| -------- | ----------------------------------- | ----------------------------------------- |
| 架构     | 共享宿主机内核，无独立 OS           | 包含独立 OS 内核，需 Hypervisor 虚拟化    |
| 资源占用 | 轻量（MB 级内存，秒级启动）         | 重量级（GB 级内存，分钟级启动）           |
| 隔离级别 | 进程级隔离（隔离性较弱）            | 硬件级隔离（隔离性强）                    |
| 镜像大小 | 小（几十～几百 MB）                 | 大（几～几十 GB）                         |
| 移植性   | 强（跨 Linux 发行版，依赖内核版本） | 弱（需适配 Hypervisor，镜像难移植）       |
| 适用场景 | 微服务、高频部署、DevOps 流程       | 强隔离需求（如运行不同 OS、测试高危应用） |

## 仓库

仓库是**集中存储和分发镜像的平台**，类似 “代码仓库（GitHub）”，用于管理镜像的版本（标签，Tag）和权限。

仓库的分类：

按公开性分：

- **公有仓库**：所有人可访问，如官方的 **Docker Hub**（全球最大的 Docker 镜像仓库，包含数百万公开镜像）、阿里云容器镜像服务（国内访问更快）。
- **私有仓库**：仅授权用户可访问，用于企业内部镜像管理，常见工具如 **Harbor**（VMware 开源的企业级私有仓库）、Docker Registry（Docker 官方轻量私有仓库）。

按功能分：

- **官方仓库**：由软件官方维护（如 Docker Hub 上的 nginx、mysql 仓库），标签对应软件版本（如 nginx:1.24）。
- **用户仓库**：个人或组织创建的仓库，命名格式为 用户名/仓库名（如 ubuntu:22.04 是官方仓库，myuser/ubuntu:22.04 是用户仓库）。

镜像标签（Tag）：标签是镜像的 “版本标识”，如 nginx:1.24（指定 1.24 版本）、nginx:latest（默认最新版本）。建议使用明确标签（而非 latest），避免版本不一致问题。

## 工作原理

Docker 能实现 “轻量级隔离”，依赖 Linux 内核的三大核心技术：**Namespace**（资源隔离）、**Cgroups**（资源限制）、**UnionFS**（分层存储）。

### 1. Namespace：实现 “资源隔离”

Namespace 是 Linux 内核的隔离机制，通过为进程分配独立的 “命名空间”，让进程只能看到自己命名空间内的资源，从而实现**进程、网络、文件系统等维度的隔离**。

Docker 主要使用 6 种 Namespace：

| Namespace 类型    | 隔离内容                           | 作用示例                                                 |
| ----------------- | ---------------------------------- | -------------------------------------------------------- |
| PID Namespace     | 进程 ID（PID）                     | 容器内的 PID=1 进程（如 nginx），在宿主机中是另一个 PID  |
| Network Namespace | 网络设备、IP、端口、路由表         | 容器有独立的网卡和 IP（如 172.17.0.2），与宿主机网络隔离 |
| Mount Namespace   | 文件系统挂载点                     | 容器内的 / 目录是独立的，与宿主机 / 不冲突               |
| UTS Namespace     | 主机名（hostname）和域名（domain） | 容器可设置独立主机名（如 my-nginx）                      |
| User Namespace    | 用户 ID（UID）和组 ID（GID）       | 容器内的 root 用户（UID=0），在宿主机中可能是普通用户    |
| IPC Namespace     | 进程间通信（如信号、共享内存）     | 容器内进程仅能与容器内其他进程通信                       |

### 2. Cgroups：实现 “资源限制”

Cgroups（Control Groups）是 Linux 内核的资源管理机制，用于**限制、统计和隔离进程组的资源使用**（如 CPU、内存、磁盘 I/O、网络带宽），避免单个容器 “抢占” 过多宿主机资源。

Docker 中 Cgroups 的典型应用：

- 限制 CPU 使用率：docker run --cpus=0.5 nginx（容器最多使用 0.5 个 CPU 核心）。
- 限制内存上限：docker run --memory=1G nginx（容器最多使用 1GB 内存，超出会被 OOM 杀死）。
- 限制磁盘 I/O：docker run --device-read-bps /dev/sda:10M nginx（容器读取 /dev/sda 的速度不超过 10MB/s）。

### 3. UnionFS：实现 “分层存储”

UnionFS（联合文件系统）是一种 “将多个目录（层）合并为一个虚拟文件系统” 的技术，Docker 利用 UnionFS 实现镜像的分层存储和容器的可读写层。

**工作流程**：

1. 镜像的每一层都是一个 “只读目录”，UnionFS 将这些层按顺序叠加，对外呈现为一个统一的 “只读文件系统”。
2. 启动容器时，UnionFS 在镜像顶层添加一个 “可读写层”，容器内的所有写操作（如创建文件、修改配置）都仅作用于这一层。
3. 若需修改镜像底层的文件，UnionFS 会先将该文件 “复制” 到可读写层，再修改（即 “写时复制”，Copy-on-Write），避免修改原镜像层。

## 优势

Docker 之所以广泛普及，核心在于它解决了传统应用部署的多个痛点：

### 1. 环境一致性：解决 “我这能跑” 问题

开发环境（Windows/Mac）、测试环境（Linux 服务器）、生产环境（云服务器）的配置差异，是导致 “开发时正常，部署后报错” 的主要原因。Docker 通过将应用与依赖打包为镜像，确保所有环境使用**完全相同的运行环境**，从根本上消除环境不一致问题。

### 2. 轻量级：高效利用资源

容器共享宿主机内核，无需启动独立 OS，因此：

- **启动快**：容器启动时间通常在秒级（如 docker run nginx 可在 1 秒内启动），远快于虚拟机的分钟级。
- **资源省**：单个宿主机可运行数百个容器（如 4GB 内存的服务器可运行 20+ 个轻量应用容器），而虚拟机通常只能运行几个。

### 3. 可移植性：跨平台无缝迁移

Docker 镜像可在任意支持 Docker 的环境中运行（Linux、Windows、Mac、云服务器、K8s 集群），无需修改配置。例如：

- 开发者在本地（Mac）构建 my-app:v1 镜像 → 上传到 Docker Hub → 测试环境（Linux 服务器）拉取镜像运行 → 生产环境（云服务器）拉取相同镜像运行，全程无适配成本。

### 4. 隔离性：安全且互不干扰

每个容器都是独立的 “沙箱”，进程、网络、文件系统与其他容器和宿主机隔离，避免了 “一个应用崩溃影响其他应用” 的问题。虽然隔离性弱于虚拟机，但足以满足绝大多数业务场景（如微服务）。

### 5. DevOps 友好：加速自动化流程

Docker 与 CI/CD（持续集成 / 持续部署）工具（Jenkins、GitLab CI、GitHub Actions）无缝集成，可实现 “代码提交 → 自动构建镜像 → 自动测试容器 → 自动部署到生产” 的全流程自动化，极大缩短开发到上线的周期。

## 生态系统

Docker 不仅是一个工具，更是一个完整的生态体系，包含多个配套工具以满足不同场景需求：

### 1. Docker Compose：单机多容器编排

当应用依赖多个组件（如 “Web 服务 + 数据库 + Redis”）时，手动启动多个容器并配置网络、挂载目录会非常繁琐。**Docker Compose** 通过一个 docker-compose.yml 配置文件，定义多个容器的关系（网络、依赖、资源限制），实现 “一键启动 / 停止所有容器”。

核心功能：

- 用 YAML 文件声明式配置多容器服务。
- 自动创建共享网络，实现容器间通信（如 Web 容器可通过容器名访问数据库容器）。
- 支持容器依赖管理（如 “先启动数据库，再启动 Web 服务”）。

示例场景：

一个 Flask 应用依赖 MySQL 和 Redis，docker-compose.yml 配置片段：

```yaml
version: '3'
services:
  web:
    build: .  # 本地构建 Flask 镜像
    ports:
      - "5000:5000"
    depends_on:  # 依赖 db 和 redis
      - db
      - redis
  db:
    image: mysql:8.0
    environment:
      - MYSQL_ROOT_PASSWORD=123456
  redis:
    image: redis:7.0

```

执行 docker-compose up -d 即可启动所有服务，docker-compose down 停止并删除容器。

### 2. Docker Swarm：Docker 原生集群编排

当需要管理多台服务器（节点）上的容器时，**Docker Swarm** 是 Docker 官方提供的集群编排工具，可将多个 Docker 节点组成 “Swarm 集群”，实现容器的**分布式部署、负载均衡、故障恢复**。

核心功能：

- 集群管理：将多个节点划分为 “管理节点”（负责集群调度）和 “工作节点”（负责运行容器）。
- 服务编排：通过 “服务（Service）” 定义容器的运行规则（如副本数、资源限制、网络模式），Swarm 自动在节点间分配容器。
- 负载均衡：内置负载均衡器，可将外部请求分发到多个容器实例（如 3 个 Nginx 容器，请求自动分摊）。

局限性：

功能不如 Kubernetes（K8s）强大，目前更多企业选择 K8s 作为集群编排工具，但 Swarm 胜在配置简单、与 Docker 原生兼容，适合中小规模集群。

### 3. 容器仓库：镜像存储与分发

- **Docker Hub**：官方公有仓库，提供数百万公开镜像，支持自动构建（从 GitHub 代码自动构建镜像）。
- **Harbor**：VMware 开源的企业级私有仓库，支持镜像签名、权限管理、漏洞扫描，适合企业内部镜像管理。
- **云厂商仓库**：阿里云容器镜像服务、AWS ECR、腾讯云 TCR 等，提供高可用、低延迟的镜像存储（国内用户优先选择）。

### 4. 其他工具

- **Docker Desktop**：Windows 和 Mac 平台的 Docker 桌面客户端，内置 Docker Engine、Docker Compose、Kubernetes（简化本地开发环境搭建）。
- **containerd**：Docker 公司捐给 CNCF（云原生计算基金会）的容器运行时，负责容器的创建、启动、停止等底层操作，目前是 K8s 的默认运行时之一。
- **Docker Buildx**：增强版镜像构建工具，支持多平台镜像构建（如同时构建 Linux/ARM、Linux/AMD64 镜像）、并行构建等。

## 常用命令

Docker 命令是操作镜像、容器、仓库的核心方式，以下是最常用的命令分类及示例：

### 1. 镜像相关命令

| 命令                                    | 功能描述                                 | 示例                                      |
| --------------------------------------- | ---------------------------------------- | ----------------------------------------- |
| docker pull <镜像名>                    | 从仓库拉取镜像                           | docker pull nginx:1.24                    |
| docker build -t <标签> <Dockerfile路径> | 基于 Dockerfile 构建镜像                 | docker build -t my-flask:v1 .（当前目录） |
| docker images                           | 查看本地所有镜像                         | docker images（或 docker image ls）       |
| docker rmi <镜像名>                     | 删除本地镜像（需先删除依赖该镜像的容器） | docker rmi nginx:1.24                     |
| docker tag <原镜像> <新标签>            | 为镜像添加新标签（如重命名）             | docker tag nginx:1.24 my-nginx:v1         |
| docker push <镜像名>                    | 将本地镜像推送到仓库（需先登录）         | docker push myuser/my-nginx:v1            |

### 2. 容器相关命令

| 命令                               | 功能描述                                  | 示例                                                         |
| ---------------------------------- | ----------------------------------------- | ------------------------------------------------------------ |
| docker run <参数> <镜像名>         | 基于镜像创建并启动容器                    | docker run -d -p 80:80 nginx（-d 后台运行，-p 端口映射）     |
| docker ps                          | 查看正在运行的容器                        | docker ps -a（-a 查看所有容器，包括停止的）                  |
| docker stop <容器ID/名>            | 停止运行中的容器                          | docker stop my-nginx                                         |
| docker start <容器ID/名>           | 启动已停止的容器                          | docker start my-nginx                                        |
| docker rm <容器ID/名>              | 删除已停止的容器（-f 强制删除运行中容器） | docker rm my-nginx 或 docker rm -f my-nginx                  |
| docker exec -it <容器ID/名> <命令> | 进入运行中的容器（交互式）                | docker exec -it my-nginx /bin/bash（进入 Nginx 容器的命令行） |
| docker logs <容器ID/名>            | 查看容器日志（-f 实时跟踪日志）           | docker logs -f my-nginx                                      |
| docker inspect <容器ID/名>         | 查看容器详细信息（IP、挂载、网络等）      | docker inspect my-nginx                                      |

### 3. 仓库与系统命令

| 命令           | 功能描述                                       | 示例                           |
| -------------- | ---------------------------------------------- | ------------------------------ |
| docker login   | 登录 Docker 仓库（如 Docker Hub）              | docker login（输入用户名密码） |
| docker logout  | 退出 Docker 仓库                               | docker logout                  |
| docker info    | 查看 Docker 系统信息（版本、镜像数、容器数等） | docker info                    |
| docker version | 查看 Docker 版本（客户端 + 守护进程）          | docker version                 |