Docker 全面解析：从核心概念到实践应用

[一、Docker 是什么？](#一、Docker 是什么？)

[二、Docker 的核心优势](#二、Docker 的核心优势)

[三、Docker 的核心概念](#三、Docker 的核心概念)

[1. 镜像（Image）](#1. 镜像（Image）)

[2. 容器（Container）](#2. 容器（Container）)

[3. 仓库（Repository）](#3. 仓库（Repository）)

[四、Docker 的工作原理](#四、Docker 的工作原理)

[1. Namespace：实现隔离](#1. Namespace：实现隔离)

[2. CGroup：实现资源限制](#2. CGroup：实现资源限制)

[3. UnionFS：实现分层存储](#3. UnionFS：实现分层存储)

[五、Docker 的核心组件](#五、Docker 的核心组件)

[1. Docker 客户端（Docker Client）](#1. Docker 客户端（Docker Client）)

[2. Docker 守护进程（Docker Daemon）](#2. Docker 守护进程（Docker Daemon）)

[3. Docker 镜像仓库（Docker Registry）](#3. Docker 镜像仓库（Docker Registry）)

[4. Docker 对象（Docker Objects）](#4. Docker 对象（Docker Objects）)

[六、Docker 的基本使用流程](#六、Docker 的基本使用流程)

[1. 环境安装](#1. 环境安装)

[2. 核心命令](#2. 核心命令)

（1）镜像操作

（2）容器操作

（3）其他常用操作

[3. Dockerfile：构建自定义镜像](#3. Dockerfile：构建自定义镜像)

[七、Docker Compose：管理多容器应用](#七、Docker Compose：管理多容器应用)

[1. 示例：Web 应用 + MySQL+Redis](#1. 示例：Web 应用 + MySQL+Redis)

[2. 核心命令](#2. 核心命令)

[八、Docker 的高级特性](#八、Docker 的高级特性)

[1. 数据持久化](#1. 数据持久化)

[2. 网络管理](#2. 网络管理)

[3. 镜像优化](#3. 镜像优化)

[九、Docker 的典型应用场景](#九、Docker 的典型应用场景)

[1. 开发环境一致性](#1. 开发环境一致性)

[2. 微服务部署](#2. 微服务部署)

[3. CI/CD 集成](#3. CI/CD 集成)

[4. 云原生应用](#4. 云原生应用)

[十、Docker 与 Kubernetes 的关系](#十、Docker 与 Kubernetes 的关系)

十一、总结

Docker 是目前最主流的容器化技术，它彻底改变了软件的开发、交付和运行方式，被誉为 "构建、发布和运行分布式应用的开放平台"。以下从核心概念、工作原理、核心组件、使用流程、高级特性、典型场景等维度，全面拆解 Docker。

一、Docker 是什么？

Docker 是一个基于 容器化技术 的开源平台，核心目标是 **"Build, Ship, Run Any App, Anywhere"**（构建、运输、运行任何应用，任何地方）。

简单来说：Docker 将应用程序及其依赖（代码、运行时、库、环境变量、配置文件）打包成一个标准化的 "容器"，这个容器可以在任何支持 Docker 的环境中运行，实现 "一次构建，处处运行"，彻底解决了 "开发环境能跑，生产环境跑不了" 的问题。

二、Docker 的核心优势

相比传统虚拟机（VM），Docker 具有以下核心优势：

特性	Docker 容器	传统虚拟机
架构	共享宿主机内核，仅封装应用及依赖	模拟完整操作系统（内核 + 用户空间）
启动速度	秒级启动（直接复用宿主机资源）	分钟级启动（需加载完整 OS）
资源占用	轻量级（MB 级），资源利用率高	重量级（GB 级），资源冗余大
隔离性	进程级隔离（namespace+cgroup）	硬件级隔离（完全独立 OS）
移植性	容器可在任何 Docker 环境运行	虚拟机镜像与硬件 /hypervisor 绑定
部署效率	秒级部署、弹性伸缩	部署慢，扩容成本高

三、Docker 的核心概念

Docker 有三个最基础且关键的概念，理解它们是掌握 Docker 的前提：

1. 镜像（Image）

定义：Docker 镜像是一个只读的模板，包含运行应用所需的所有依赖（代码、库、环境变量、配置文件），是创建容器的 "蓝图"。
特性：
- 分层存储：镜像由多个只读层叠加而成（如基础层ubuntu:20.04 + 应用层python:3.9 + 代码层），层可复用，减少存储空间。
- 不可修改：镜像一旦构建完成，无法修改，如需更新需构建新镜像。
示例：ubuntu:20.04（Ubuntu 系统镜像）、nginx:latest（Nginx 服务镜像）、mysql:8.0（MySQL 数据库镜像）。

2. 容器（Container）

定义：容器是镜像的运行实例，是一个独立的、可运行的应用环境（可读写）。
特性：
- 可读写层：容器在镜像的只读层之上，新增一个可读写层，所有运行时的修改（如文件写入、配置变更）都保存在这一层。
- 隔离性：通过 Linux Namespace（PID、网络、挂载等）实现进程、网络、文件系统的隔离；通过 CGroup 实现资源限制（CPU、内存）。
- 生命周期：可被创建、启动、停止、暂停、删除。
示例：运行docker run nginx后，会创建并启动一个 Nginx 容器，提供 Web 服务。

3. 仓库（Repository）

定义：Docker 仓库是存储和分发镜像的中心化服务，类似代码仓库（如 GitHub）。
分类：
- 公有仓库：Docker Hub（官方，https://hub.docker.com）、阿里云镜像仓库、腾讯云镜像仓库等，提供海量公共镜像。
- 私有仓库：企业内部搭建的仓库（如 Harbor），用于存储私有镜像（如公司业务应用镜像），保障安全性。
操作：通过docker push将本地镜像推送到仓库，通过docker pull从仓库拉取镜像。

四、Docker 的工作原理

Docker 基于 Linux 内核的三大核心技术实现：Namespace、CGroup、UnionFS。

1. Namespace：实现隔离

Docker 通过 Linux Namespace 为容器创建独立的 "环境空间"，使容器看起来像一个独立的操作系统：

PID Namespace：容器内的进程 ID 与宿主机隔离（容器内 PID=1 的进程是应用本身，而非宿主机的 init）。
Network Namespace：容器拥有独立的网络栈（网卡、IP、端口、路由）。
Mount Namespace：容器拥有独立的文件系统挂载点。
UTS Namespace：容器有独立的主机名和域名。
User Namespace：容器内的用户 ID 与宿主机隔离（容器内 root≠宿主机 root）。

2. CGroup：实现资源限制

Linux Control Group（CGroup）用于限制容器的资源使用（CPU、内存、磁盘 I/O、网络带宽），例如：

限制容器最多使用 1 核 CPU、2GB 内存。
避免单个容器占用宿主机全部资源，导致其他容器或宿主机崩溃。

3. UnionFS：实现分层存储

UnionFS（联合文件系统）是一种 "分层、轻量级、高性能" 的文件系统，支持将多个目录（层）以只读或读写的方式叠加成一个统一的文件系统。Docker 利用 UnionFS 实现镜像的分层存储：

镜像的每一层都是只读的，新层基于上层叠加。
容器启动时，在镜像最上层添加一个可读写层，所有修改都在这一层进行。
分层存储的优势：层可复用（如多个镜像共享ubuntu:20.04基础层）、减少镜像体积、加速镜像构建 / 传输。

五、Docker 的核心组件

Docker 采用客户端 - 服务器（C/S）架构，包含以下核心组件：

1. Docker 客户端（Docker Client）

作用：用户与 Docker 交互的入口，接收用户命令（如docker run、docker build）并发送给 Docker 守护进程。
形式：命令行工具（docker命令）、Docker Desktop（图形化界面，集成客户端 + 守护进程 + Kubernetes）。

2. Docker 守护进程（Docker Daemon）

作用：运行在宿主机的后台进程（dockerd），负责管理镜像、容器、网络、存储等资源，处理客户端发送的命令。
通信方式 ：客户端与守护进程通过 Unix 套接字（/var/run/docker.sock）、TCP 端口或 REST API 通信。

3. Docker 镜像仓库（Docker Registry）

作用：存储和分发 Docker 镜像的服务，如 Docker Hub、Harbor。

4. Docker 对象（Docker Objects）

包括镜像（Image）、容器（Container）、网络（Network）、卷（Volume，持久化存储）等。

六、Docker 的基本使用流程

1. 环境安装

Linux ：直接通过包管理器安装（如apt install docker.io、yum install docker-ce）。
Windows/macOS：安装 Docker Desktop（内置 Docker 引擎、Compose、Kubernetes）。
验证安装：docker --version（查看版本）、docker info（查看系统信息）、docker run hello-world（运行测试容器）。

2. 核心命令

（1）镜像操作

bash

运行

复制代码

# 拉取镜像（从Docker Hub）
docker pull nginx:latest

# 查看本地镜像
docker images

# 构建镜像（基于Dockerfile）
docker build -t myapp:v1 .  # -t指定标签（名称:版本），.指定Dockerfile所在目录

# 删除镜像
docker rmi nginx:latest

# 推送镜像到仓库
docker push myname/myapp:v1

（2）容器操作

bash

运行

复制代码

# 创建并启动容器（最常用）
docker run -d -p 8080:80 --name mynginx nginx:latest
# -d：后台运行；-p：端口映射（宿主机8080→容器80）；--name：指定容器名

# 查看运行中的容器
docker ps

# 查看所有容器（包括停止的）
docker ps -a

# 启动/停止/重启容器
docker start mynginx
docker stop mynginx
docker restart mynginx

# 进入容器（交互模式）
docker exec -it mynginx /bin/bash  # -it：交互式终端

# 删除容器（需先停止）
docker rm mynginx

# 查看容器日志
docker logs mynginx

（3）其他常用操作

bash

运行

复制代码

# 查看容器详情
docker inspect mynginx

# 容器数据卷挂载（持久化数据）
docker run -d -p 3306:3306 -v mysql-data:/var/lib/mysql --name mymysql mysql:8.0
# -v：将宿主机的mysql-data卷挂载到容器的/var/lib/mysql目录

# 查看数据卷
docker volume ls

3. Dockerfile：构建自定义镜像

Dockerfile 是一个文本文件 ，包含构建镜像的 "指令集"，通过docker build命令执行构建。以下是一个简单的 Python 应用 Dockerfile 示例：

dockerfile

复制代码

# 基础镜像（Python 3.9）
FROM python:3.9-slim

# 设置工作目录
WORKDIR /app

# 复制依赖文件到容器
COPY requirements.txt .

# 安装依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码到容器
COPY . .

# 暴露端口（容器内端口）
EXPOSE 5000

# 容器启动命令
CMD ["python", "app.py"]

核心指令说明：

FROM：指定基础镜像（必须是第一条指令）。
WORKDIR：设置容器内的工作目录（后续命令基于此目录）。
COPY/ADD：将宿主机文件复制到容器（ADD 支持自动解压压缩包）。
RUN：构建镜像时执行的命令（如安装依赖）。
EXPOSE：声明容器暴露的端口（仅为文档说明，不实际映射）。
CMD/ENTRYPOINT：容器启动时执行的命令（CMD 可被覆盖，ENTRYPOINT 不可覆盖）。

七、Docker Compose：管理多容器应用

Docker Compose 是 Docker 官方的多容器编排工具 ，用于定义和运行由多个容器组成的应用（如 Web 应用 + 数据库 + 缓存）。通过一个docker-compose.yml文件描述服务依赖关系，一键启动 / 停止所有服务。

1. 示例：Web 应用 + MySQL+Redis

yaml

复制代码

version: '3.8'  # Compose文件版本

services:
  # Web服务
  web:
    build: .  # 基于当前目录的Dockerfile构建镜像
    ports:
      - "8080:5000"  # 端口映射
    depends_on:
      - db
      - redis  # 依赖db和redis服务，启动顺序：db→redis→web
    environment:
      - MYSQL_HOST=db
      - REDIS_HOST=redis

  # MySQL服务
  db:
    image: mysql:8.0
    volumes:
      - mysql-data:/var/lib/mysql  # 数据持久化
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=mydb

  # Redis服务
  redis:
    image: redis:7.0
    ports:
      - "6379:6379"

volumes:
  mysql-data:  # 定义数据卷

2. 核心命令

bash

运行

复制代码

# 启动所有服务（后台运行）
docker-compose up -d

# 查看服务状态
docker-compose ps

# 查看服务日志
docker-compose logs web

# 停止所有服务
docker-compose down

# 构建/重新构建镜像
docker-compose build

八、Docker 的高级特性

1. 数据持久化

容器默认的存储是临时的（容器删除后数据丢失），Docker 提供三种数据持久化方式：

数据卷（Volume） ：Docker 管理的宿主机目录（/var/lib/docker/volumes/），独立于容器生命周期，最推荐的方式。
绑定挂载（Bind Mount） ：将宿主机任意目录挂载到容器（如-v /host/path:/container/path），灵活性高但依赖宿主机路径。
tmpfs 挂载：将数据存储在宿主机内存中，适合临时数据（容器停止后数据丢失）。

2. 网络管理

Docker 提供多种网络模式，实现容器间 / 容器与外部的通信：

桥接网络（bridge）：默认网络模式，容器通过网桥连接到宿主机，可相互通信。
主机网络（host）：容器直接使用宿主机的网络栈（无端口映射，性能高）。
容器网络（container）：多个容器共享同一个网络栈（如容器 A 和容器 B 共享 IP 和端口）。
自定义网络 ：用户创建的桥接网络（如docker network create mynet），容器加入后可通过容器名通信（DNS 解析）。

3. 镜像优化

使用轻量化基础镜像 ：如alpine（几 MB）替代ubuntu（几百 MB）。
多阶段构建 ：通过多个FROM指令，在构建阶段编译代码，运行阶段仅保留运行时依赖（减少镜像体积）。
合并 RUN 指令 ：减少镜像层数（如RUN apt update && apt install -y nginx）。
使用.dockerignore文件 ：排除不需要复制到镜像的文件（如node_modules、.git）。

九、Docker 的典型应用场景

1. 开发环境一致性

开发人员在本地通过 Docker 运行应用及依赖（如 MySQL、Redis），避免 "我本地能跑" 的问题，确保开发、测试、生产环境一致。

2. 微服务部署

每个微服务打包成独立容器，通过 Docker Compose 或 Kubernetes 编排，实现独立部署、扩容和回滚。

3. CI/CD 集成

在持续集成 / 持续部署流程中，用 Docker 打包应用，通过镜像仓库分发，实现自动化测试和部署（如 Jenkins+Docker）。

4. 云原生应用

Docker 是云原生的基础，容器化的应用可无缝部署到 Kubernetes、Docker Swarm 等容器编排平台，实现弹性伸缩、故障自愈。

十、Docker 与 Kubernetes 的关系

Docker 负责容器的创建和运行 ，而 Kubernetes（K8s）负责容器的编排和管理（大规模容器集群的调度、扩容、负载均衡、故障恢复）。简单来说：

Docker 是 "单兵作战" 工具，适合管理少量容器；
Kubernetes 是 "集团军指挥系统"，适合管理成百上千个容器，是云原生的核心编排平台。

注意：Docker 官方已宣布废弃 Docker Swarm（Docker 自带的编排工具），推荐使用 Kubernetes 进行容器编排。

十一、总结

Docker 作为容器化技术的标杆，通过 "镜像 - 容器 - 仓库" 的核心模型，解决了软件交付的 "环境一致性" 问题，是微服务和云原生架构的基础。掌握 Docker 不仅能提升开发效率，更是迈向云原生开发的必经之路。后续可进一步学习 Kubernetes 等容器编排技术，深入云原生生态。