Docker 从入门到精通全体系学习指南

本指南遵循零基础入门→核心能力进阶→企业级精通→生产落地实战的渐进式路径，覆盖Docker全生命周期知识点，兼顾理论深度与可落地实操，适配2026年最新稳定版Docker规范。

一、入门篇：零基础上手 Docker

核心目标：理解Docker核心价值，完成环境搭建，掌握基础命令，跑通第一个容器化应用

1.1 Docker 核心认知

Docker是一个开源的容器化引擎，核心解决应用环境一致性问题，实现“一次构建，到处运行”，彻底告别“在我电脑上能跑，线上跑不了”的痛点。

核心本质：容器不是轻量级虚拟机，而是宿主机上一组被隔离和资源受限的进程，共享宿主机Linux内核，启动秒级，资源占用极低。

三大核心概念（必记）

概念	通俗类比	核心定义
镜像Image	程序安装包/系统ISO	只读的文件模板，包含应用运行所需的代码、依赖、环境变量、配置文件，是容器的基础
容器Container	运行的程序实例	镜像的运行时实体，是一个独立的沙箱环境，拥有自己的进程、网络、文件系统，与其他容器和宿主机相互隔离
仓库Registry	应用商店/软件仓库	集中存储和分发Docker镜像的服务，公共仓库如Docker Hub，私有仓库如Harbor、Registry

与传统虚拟机的核心区别
虚拟机需要完整的Guest OS，资源占用大、启动分钟级；Docker共享宿主机内核，仅隔离应用运行环境，资源占用极小、启动秒级，单机可轻松运行数百个容器。

1.2 全平台Docker安装与环境配置

Docker 分为 CE 社区版（免费，日常使用）和 EE 企业版（付费，企业级支持），以下为2026年最新稳定版安装方案。

1.2.1 Linux（生产环境首选，Ubuntu/CentOS）

Ubuntu 22.04 LTS 官方仓库安装（最稳定）

# 1. 更新系统并安装依赖
sudo apt update && sudo apt install -y ca-certificates curl gnupg lsb-release

# 2. 添加Docker官方GPG密钥
curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 3. 添加Docker软件源（阿里云国内源，速度更快）
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 4. 安装Docker核心组件
sudo apt update && sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 5. 启动Docker并设置开机自启
sudo systemctl enable --now docker

# 6. 验证安装
docker --version  # 输出版本号即成功
docker run hello-world  # 拉取测试镜像并运行，输出欢迎信息即环境就绪

CentOS/RHEL 安装

# 1. 卸载旧版本
sudo yum remove -y docker docker-client docker-common docker-engine

# 2. 安装依赖
sudo yum install -y yum-utils device-mapper-persistent-data lvm2

# 3. 添加阿里云源
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# 4. 安装并启动
sudo yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl enable --now docker

# 5. 验证
docker run hello-world

权限优化（必做）
避免每次执行docker命令都需要sudo，将当前用户加入docker组：

sudo usermod -aG docker $USER && newgrp docker
# 注销重登录后永久生效

国内镜像加速配置（必做）

解决官方镜像源拉取慢的问题，修改Docker daemon配置：

# 编辑配置文件
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com",
    "https://mirror.baidubce.com"
  ],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3"
  }
}
EOF

# 重启Docker生效
sudo systemctl daemon-reload && sudo systemctl restart docker

# 验证配置
docker info | grep "Registry Mirrors"

1.2.2 Windows/Mac（开发环境）

直接下载 Docker Desktop 官方安装包：Docker Desktop官网
- Windows需开启WSL2（安装包默认勾选，需BIOS开启CPU虚拟化），仅支持Windows 10/11专业版/家庭版
- Mac需区分Intel芯片和Apple Silicon芯片，下载对应架构安装包
安装完成后启动Docker Desktop，在设置中可直接切换中文、配置镜像加速、开启WSL集成
打开终端执行docker run hello-world验证安装成功

1.3 核心基础命令（必学必会）

所有命令均可通过docker 命令 --help查看详细用法，以下为高频核心命令，按功能分类。

1.3.1 镜像操作命令

# 1. 拉取镜像（从仓库下载到本地）
docker pull nginx:1.27.0-alpine  # 推荐指定版本，避免latest标签
docker pull ubuntu:22.04

# 2. 查看本地镜像列表
docker images
docker images -q  # 仅输出镜像ID，批量操作常用

# 3. 查看镜像详情/历史
docker inspect nginx:1.27.0-alpine  # 查看镜像完整元数据
docker history nginx:1.27.0-alpine  # 查看镜像构建分层历史

# 4. 给镜像打标签（用于推送到仓库）
docker tag nginx:1.27.0-alpine my-registry.com/my-nginx:v1.0.0

# 5. 删除镜像
docker rmi nginx:1.27.0-alpine  # 删除指定镜像
docker rmi $(docker images -q)  # 批量删除所有本地镜像
docker image prune -af  # 清理无用的悬空镜像（无标签、无容器引用）

1.3.2 容器生命周期核心命令

# 1. 核心：创建并启动容器（最常用，必掌握所有参数）
docker run -d --name my-nginx -p 8080:80 -v /local/html:/usr/share/nginx/html nginx:1.27.0-alpine
# 核心参数详解：
# -d：后台守护进程运行
# --name：给容器指定唯一名称，替代随机名称
# -p 宿主机端口:容器端口：端口映射，宿主机端口访问容器内服务
# -v 宿主机路径:容器路径：目录挂载，实现数据持久化
# --restart=always：容器退出时自动重启，生产环境必加
# -e 环境变量名=值：给容器注入环境变量
# --cpus=1 --memory=512m：限制容器CPU和内存使用，生产环境必加

# 2. 查看容器列表
docker ps  # 查看运行中的容器
docker ps -a  # 查看所有容器（包括停止的）
docker ps -q  # 仅输出容器ID，批量操作常用

# 3. 停止/启动/重启容器
docker stop my-nginx  # 停止运行中的容器
docker start my-nginx  # 启动已停止的容器
docker restart my-nginx  # 重启容器

# 4. 进入运行中的容器（调试必备）
docker exec -it my-nginx /bin/sh  # alpine镜像用sh，ubuntu/centos用bash
# -it：交互式终端，必加，否则无法正常输入命令

# 5. 查看容器日志（排障必备）
docker logs my-nginx  # 输出容器完整日志
docker logs -f --tail 100 my-nginx  # 实时滚动查看最新100行日志，高频使用

# 6. 删除容器
docker rm my-nginx  # 删除已停止的容器
docker rm -f my-nginx  # 强制删除运行中的容器
docker rm $(docker ps -aq)  # 批量删除所有容器
docker container prune -f  # 清理所有已停止的容器

1.3.3 仓库操作命令

# 登录仓库
docker login  # 登录Docker Hub，输入用户名密码
docker login my-registry.com  # 登录私有仓库

# 推送镜像到仓库（需先打对应仓库的标签）
docker push my-registry.com/my-nginx:v1.0.0

# 登出仓库
docker logout my-registry.com

1.4 第一个容器化应用实战

目标：用 Docker 启动一个Nginx服务，挂载本地网页，通过宿主机浏览器访问

创建本地网页目录和文件

mkdir -p ~/docker-nginx/html && cd ~/docker-nginx/html
echo "<h1>Hello Docker! 我的第一个容器化应用</h1>" > index.html

启动 Nginx 容器，完成端口映射和目录挂载

docker run -d \
  --name my-first-nginx \
  --restart=always \
  -p 8080:80 \
  -v ~/docker-nginx/html:/usr/share/nginx/html \
  nginx:1.27.0-alpine

验证效果：浏览器访问http://宿主机IP:8080，即可看到自定义的网页内容

常用调试操作

docker ps  # 查看容器是否正常运行
docker logs my-first-nginx  # 查看Nginx访问日志
docker exec -it my-first-nginx /bin/sh  # 进入容器内部调试

二、进阶篇：核心能力全面掌握

核心目标：掌握镜像自定义构建、数据持久化、容器网络、多容器编排，能独立完成中小型应用的容器化部署

2.1 Dockerfile：自定义镜像构建核心

Dockerfile是一个文本文件，包含一系列构建镜像的指令，Docker通过读取该文件自动构建自定义镜像，是容器化的核心技能。

2.1.1 核心指令与规范

指令	作用	最佳实践
FROM	指定基础镜像，所有Dockerfile必须以FROM开头	优先使用官方精简镜像（alpine/slim），必须锁定版本，禁止使用latest
WORKDIR	设置容器内的工作目录，后续RUN/CMD/COPY/ADD指令均在此目录执行	绝对路径，避免频繁cd，禁止使用相对路径
COPY	将宿主机的文件/目录复制到镜像内	优先使用COPY，仅在需要自动解压tar包时用ADD
ADD	复制文件到镜像，支持远程URL、自动解压tar包	禁止用ADD下载远程文件（会残留镜像层），仅用于本地tar包解压
RUN	构建镜像时执行的shell命令，每一条RUN会生成一个新的镜像层	合并多条RUN指令，用&&连接，执行完清理缓存（apt clean/yum clean）
ENV	设置容器运行时的环境变量	用于配置应用环境，避免硬编码，区分构建参数ARG
ARG	构建镜像时的临时参数，仅在构建过程中有效，不会保留到最终镜像	用于传递版本号、构建密钥等临时信息，避免敏感信息残留
EXPOSE	声明容器运行时监听的端口，仅做文档说明，不做实际端口映射	声明应用默认端口，提升Dockerfile可读性
CMD	容器启动时默认执行的命令，一个Dockerfile只有最后一个CMD生效	用于启动主进程，可被docker run命令行参数覆盖
ENTRYPOINT	容器启动时的入口命令，与CMD配合使用	固定容器启动的核心命令，CMD作为默认参数，实现容器“即开即用”
VOLUME	声明容器内的持久化目录，自动创建匿名卷	声明数据库、日志等需要持久化的目录，避免数据丢失
USER	指定容器运行时的用户和用户组	生产环境必须使用非root用户，提升安全性
HEALTHCHECK	容器健康检查指令，Docker自动检测容器运行状态	配置健康检查，实现故障自动重启，生产环境必加

2.1.2 实战：构建一个Python Flask应用镜像

项目目录结构

flask-demo/
├── Dockerfile
├── requirements.txt
└── app.py

编写应用代码app.py

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello Docker! 这是我构建的第一个Python镜像"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

编写依赖文件requirements.txt
```
Flask==2.3.3
```

编写Dockerfile

# 1. 指定基础镜像，官方python精简版，锁定版本
FROM python:3.11-slim-bookworm

# 2. 设置工作目录
WORKDIR /app

# 3. 先复制依赖文件，利用Docker缓存机制，避免每次修改代码都重新安装依赖
COPY requirements.txt .

# 4. 安装依赖，合并命令，清理缓存，减少镜像层
RUN pip install --no-cache-dir -r requirements.txt

# 5. 复制应用代码
COPY app.py .

# 6. 声明监听端口
EXPOSE 5000

# 7. 健康检查，每30秒检测一次，超时3秒，重试3次则标记为不健康
HEALTHCHECK --interval=30s --timeout=3s --retries=3 \
  CMD curl -f http://localhost:5000/ || exit 1

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

构建镜像

# -t 指定镜像名称和标签，. 表示Dockerfile所在的当前目录
docker build -t flask-demo:v1.0.0 .

启动容器验证

docker run -d --name flask-app -p 5000:5000 flask-demo:v1.0.0
# 访问 http://宿主机IP:5000 验证应用正常运行

2.1.3 镜像优化核心技巧

多阶段构建：将编译环境和运行环境分离，只把最终的运行产物复制到最终镜像，剔除编译工具、源码等无用文件，镜像体积可减少90%以上。

示例：Go应用多阶段构建

# 构建阶段：包含完整编译环境
FROM golang:1.22 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp main.go

# 运行阶段：仅保留运行所需的最小环境
FROM alpine:3.20
WORKDIR /app
# 从构建阶段复制编译好的二进制文件，其他内容全部丢弃
COPY --from=builder /app/myapp .
EXPOSE 8080
CMD ["./myapp"]

基础镜像选择：优先使用alpine（5M左右）、slim系列镜像，避免使用ubuntu/centos等完整系统镜像，减少镜像体积和攻击面。
优化镜像层：合并多条RUN指令，用&&连接，减少镜像层数量；执行完安装命令后立即清理缓存（apt clean && rm -rf /var/lib/apt/lists/*、yum clean all）。
使用 .dockerignore 文件：排除不需要复制到镜像的文件（.git、node_modules、日志、临时文件），减少构建上下文大小，提升构建速度。

2.2 数据持久化：Volume 核心详解

容器的文件系统是临时的，容器删除后数据会全部丢失，Docker提供了三种数据持久化方案，实现数据与容器生命周期解耦。

2.2.1 三种挂载方式对比与适用场景

挂载类型	核心特点	适用场景	命令示例
匿名卷/命名卷Volume	Docker管理，宿主机无需关心存储路径，支持卷驱动、备份迁移，生命周期独立于容器	生产环境数据库、持久化数据存储，推荐首选	`docker run -v mysql-data:/var/lib/mysql mysql:8.0`
绑定挂载Bind Mount	直接绑定宿主机指定目录，容器可直接读写宿主机文件，性能最高	开发环境（代码热更新）、配置文件挂载、宿主机与容器文件共享	`docker run -v /local/nginx.conf:/etc/nginx/nginx.conf nginx`
临时文件系统tmpfs	挂载到宿主机内存，容器停止后数据立即删除，不写入磁盘，性能极致	敏感临时文件、缓存数据，无需持久化的场景	`docker run --tmpfs /tmp nginx`

2.2.2 Volume核心操作命令

# 1. 创建命名卷
docker volume create mysql-data

# 2. 查看所有卷
docker volume ls

# 3. 查看卷详情（存储路径等）
docker volume inspect mysql-data

# 4. 清理无用卷
docker volume prune -f

# 5. 删除卷
docker volume rm mysql-data

2.2.3 生产环境最佳实践

数据库、消息队列等IO密集型应用，必须使用Volume挂载数据目录，绕过overlay2可写层，IO性能提升50%以上。
配置文件使用Bind Mount只读挂载（添加:ro后缀），避免容器内修改配置，提升安全性：docker run -v /local/nginx.conf:/etc/nginx/nginx.conf:ro nginx。
禁止在容器内存储持久化数据，所有需要保留的数据必须通过Volume/Bind Mount挂载到宿主机，避免容器删除导致数据丢失。

2.3 Docker网络全解

Docker为容器提供了完整的网络栈，实现容器间、容器与宿主机、容器与外网的通信，核心分为5种网络模式。

2.3.1 五大网络模式详解

网络模式	核心特点	隔离性	适用场景
bridge（默认桥接）	Docker默认网络，所有容器接入docker0网桥，通过端口映射对外提供服务，容器间通过IP/容器名通信	中	单机多容器通信，绝大多数常规场景，默认首选
host（主机网络）	容器与宿主机共享网络栈，容器内端口直接绑定宿主机端口，无需端口映射，网络性能无损耗	低	高并发网络服务，网络性能要求极高的场景，如Nginx、网关
none（无网络）	容器禁用所有网络，只有lo回环接口，完全无法与外界通信	极高	高安全要求的离线计算、敏感数据处理，禁止网络访问的场景
container（容器共享网络）	多个容器共享同一个网络栈，共享IP和端口，容器间通过lo回环接口通信	中	边车模式（Sidecar），如日志采集、监控代理与主应用共享网络
macvlan	给容器分配独立的MAC地址和IP地址，像物理机一样直接接入局域网，可被其他设备直接访问	高	物联网、传统应用迁移，需要容器拥有独立局域网IP的场景

2.3.2 核心网络操作命令

# 1. 查看所有Docker网络
docker network ls

# 2. 创建自定义桥接网络（生产环境推荐，比默认bridge网络功能更强）
docker network create my-network

# 3. 查看网络详情
docker network inspect my-network

# 4. 容器接入网络
docker network connect my-network my-nginx

# 5. 容器断开网络
docker network disconnect my-network my-nginx

# 6. 删除网络
docker network rm my-network

# 7. 清理无用网络
docker network prune -f

2.3.3 容器通信最佳实践

生产环境必须使用自定义桥接网络，而非默认bridge网络：自定义网络支持容器间通过容器名/服务名DNS解析通信，无需固定容器IP；提供更好的隔离性和网络控制。
示例：两个容器通过自定义网络通信

# 1. 创建自定义网络
docker network create app-network
# 2. 启动MySQL容器，接入自定义网络
docker run -d --name mysql --network app-network -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0
# 3. 启动Web应用容器，接入同一个网络，可直接通过容器名mysql访问数据库
docker run -d --name web-app --network app-network my-web-app:v1.0.0

仅对外暴露必要的端口，禁止将容器所有端口映射到宿主机，减少攻击面。
高并发场景优先使用host网络模式，避免桥接网络的转发损耗，提升网络性能。

2.4 Docker Compose：多容器编排利器

Docker Compose 是 Docker 官方的多容器编排工具，通过一个docker-compose.ymlYAML文件，定义和管理多个关联的服务，实现一键启动/停止/更新所有容器，彻底告别逐个手动启动容器的繁琐操作。

2.4.1 安装与核心配置

Docker Desktop Windows/Mac 版本已自带 Docker Compose，无需额外安装
Linux环境安装：已在前面的 Docker 安装步骤中通过docker-compose-plugin安装，验证命令：docker compose version（注意新版是空格，不是横杠，旧版docker-compose已弃用）

docker-compose.yml核心结构分为四大顶级字段：

version：Compose文件版本，推荐3.8+
services：核心，定义所有服务（容器），每个服务对应一个容器
networks：自定义网络，供服务间通信
volumes：数据卷，实现数据持久化

2.4.2 实战：一键部署LNMP环境（Nginx+MySQL+PHP）

创建项目目录

mkdir -p ~/lnmp-docker && cd ~/lnmp-docker
# 创建子目录
mkdir -p nginx/conf html mysql/data php/conf

编写docker-compose.yml核心文件

version: '3.8'

# 服务定义
services:
  # Nginx服务
  nginx:
    image: nginx:1.27.0-alpine
    container_name: lnmp-nginx
    restart: always
    ports:
      - "80:80"
    volumes:
      # 挂载网站根目录
      - ./html:/usr/share/nginx/html
      # 挂载Nginx配置文件
      - ./nginx/conf:/etc/nginx/conf.d
      # 挂载日志目录
      - ./nginx/logs:/var/log/nginx
    networks:
      - lnmp-network
    depends_on:
      - php
      - mysql

  # PHP服务
  php:
    image: php:8.2-fpm-alpine
    container_name: lnmp-php
    restart: always
    volumes:
      - ./html:/usr/share/nginx/html
      - ./php/conf:/usr/local/etc/php/conf.d
    networks:
      - lnmp-network
    depends_on:
      - mysql

  # MySQL数据库服务
  mysql:
    image: mysql:8.0
    container_name: lnmp-mysql
    restart: always
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: 123456  # root用户密码
      MYSQL_DATABASE: lnmp_db       # 初始化创建的数据库
    volumes:
      # 数据库数据持久化
      - ./mysql/data:/var/lib/mysql
      # 初始化脚本目录，.sql文件会自动执行
      - ./mysql/init:/docker-entrypoint-initdb.d
    networks:
      - lnmp-network
    # 资源限制，生产环境必加
    deploy:
      resources:
        limits:
          cpus: '1'
          memory: 1G

# 自定义网络
networks:
  lnmp-network:
    driver: bridge

# 数据卷（如需使用Docker管理的卷，可在此定义）
volumes:
  mysql-data:

编写Nginx配置文件nginx/conf/default.conf

server {
    listen 80;
    server_name localhost;
    root /usr/share/nginx/html;
    index index.html index.htm index.php;

    location ~ \.php$ {
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;
    }
}

编写PHP测试文件html/index.php
```
<?php
phpinfo();
?>
```

一键启动所有服务

# 后台启动所有服务
docker compose up -d
# 查看服务运行状态
docker compose ps

验证效果：浏览器访问http://宿主机IP，即可看到phpinfo页面；通过Navicat等工具可连接宿主机3306端口的MySQL数据库。

2.4.3 Docker Compose高频核心命令

# 1. 启动所有服务（核心）
docker compose up -d  # -d 后台运行
docker compose up -d --build  # 启动前重新构建自定义镜像

# 2. 停止并删除所有服务、网络、卷
docker compose down  # 保留数据卷
docker compose down -v  # 同时删除数据卷，谨慎使用

# 3. 查看服务运行状态
docker compose ps

# 4. 查看服务日志
docker compose logs  # 输出所有服务日志
docker compose logs -f --tail 100 nginx  # 实时查看指定服务的最新日志

# 5. 重启/停止/启动服务
docker compose restart nginx  # 重启指定服务
docker compose stop  # 停止所有服务
docker compose start  # 启动已停止的所有服务

# 6. 进入指定服务的容器
docker compose exec php /bin/sh

2.5 私有镜像仓库搭建

企业生产环境中，不能直接使用公共仓库，需要搭建私有镜像仓库，实现镜像的内部存储、分发和权限管理。主流方案分为两种：

Docker Registry：Docker官方轻量级仓库，无UI界面，适合简单场景、测试环境
Harbor：VMware开源的企业级仓库，提供UI界面、权限管理、安全扫描、镜像复制、高可用等功能，生产环境首选

2.5.1 轻量级Registry快速搭建

# 一键启动Registry容器
docker run -d \
  --name registry \
  --restart=always \
  -p 5000:5000 \
  -v registry-data:/var/lib/registry \
  registry:2.8

# 验证：推送镜像到私有仓库
# 1. 给镜像打标签，格式为 仓库地址/镜像名:标签
docker tag nginx:1.27.0-alpine localhost:5000/my-nginx:v1.0.0
# 2. 推送镜像
docker push localhost:5000/my-nginx:v1.0.0
# 3. 拉取镜像
docker pull localhost:5000/my-nginx:v1.0.0

2.5.2 Harbor企业级仓库搭建

参考官方文档，通过Docker Compose一键部署，核心步骤：

下载Harbor安装包：Harbor官方发布页
修改harbor.yml配置文件，设置主机名、管理员密码、HTTPS证书等
执行./install.sh脚本，自动生成Docker Compose文件并启动服务
访问https://主机名，登录Harbor UI界面，创建项目、管理用户和权限
配置Docker daemon信任Harbor仓库地址，即可进行镜像的推送和拉取

三、精通篇：底层原理与企业级能力

核心目标：吃透Docker底层原理，掌握企业级安全加固、监控运维、性能调优、CI/CD集成，具备生产环境Docker全生命周期管理能力

3.1 Docker底层核心原理

3.1.1 Docker整体架构

Docker采用客户端-服务端（C/S）架构，核心组件及调用链路如下：

docker run 命令 → Docker Client（客户端） → REST API → Docker Daemon（dockerd，守护进程） → containerd（容器生命周期管理） → runc（OCI运行时标准实现） → 调用Linux内核接口创建容器

Docker Client：命令行工具，用户与Docker交互的入口，将用户命令发送给Docker Daemon
Docker Daemon：宿主机后台常驻进程，负责接收客户端请求，管理镜像、容器、网络、存储等核心资源
containerd：从Docker中剥离的容器运行时管理组件，负责容器生命周期、镜像传输、存储管理，现已成为CNCF毕业项目，K8s也可直接使用
runc：OCI容器运行时标准的参考实现，是一个轻量级工具，实际负责调用Linux内核的Namespace和Cgroups接口，创建和销毁容器，不常驻后台，容器创建完成后即退出

3.1.2 容器隔离的基石：Namespace

Namespace是Linux内核提供的资源视图隔离机制，核心作用是让容器内的进程“看不见”宿主机和其他容器的资源，营造一个独立的操作系统环境，Docker默认启用6大核心Namespace：

Namespace类型	隔离能力	容器场景价值
PID Namespace	隔离进程ID，容器内进程PID从1开始编号，看不到宿主机和其他容器的进程	容器内拥有独立的进程树，实现进程隔离，避免容器内进程影响宿主机
NET Namespace	隔离完整的网络栈，包括独立的网卡、IP地址、端口、路由表、iptables规则	每个容器拥有独立的网络环境，端口互不冲突，实现网络层面的完全解耦
MNT Namespace	隔离文件系统挂载点，容器拥有独立的根文件系统视图	容器内只能看到自己的文件系统，无法访问宿主机的其他目录，实现文件系统隔离
UTS Namespace	隔离主机名和域名	容器可以拥有自己独立的主机名，像一台独立的服务器
IPC Namespace	隔离进程间通信资源，包括信号量、消息队列、共享内存	容器内进程只能与同容器内的进程通信，无法跨容器进行IPC通信
User Namespace	隔离用户和用户组ID，实现宿主机root用户与容器内非root用户的映射	容器内的root用户仅在容器内拥有权限，在宿主机上仅为普通用户权限，大幅提升安全性

3.1.3 资源管控的核心：Cgroups

Cgroups（Control Groups）是Linux内核提供的进程组资源限制、调度、统计机制，核心解决“隔离不限制”的问题，规定一个容器能用多少系统资源，防止单个容器耗尽宿主机资源导致系统崩溃。

核心管控能力：CPU使用率、内存使用上限、磁盘IO带宽、进程数量、网络带宽等
核心原理：当执行docker run -m 512m --cpus=1 nginx时，Docker会在宿主机/sys/fs/cgroup/目录下，为该容器创建独立的控制组，写入对应的资源限制规则，并将容器进程加入该控制组，内核会严格按照规则限制进程的资源使用
生产环境必做：所有容器必须设置CPU和内存资源限制，避免资源抢占，保障宿主机和其他容器的稳定性

3.1.4 存储驱动：Overlay2

Docker默认使用Overlay2存储驱动，基于Linux内核的OverlayFS文件系统，实现镜像的分层存储和写时复制（CoW）机制。

分层存储：Docker镜像由多个只读层叠加而成，每一条Dockerfile指令都会生成一个新的镜像层，镜像层可被多个镜像共享，大幅减少存储空间占用和镜像拉取时间。
写时复制（CoW）：容器启动时，会在所有只读镜像层之上，添加一个可写层；容器内所有的修改操作都只会发生在可写层，不会修改底层的只读镜像层，多个容器可共享同一个基础镜像，仅维护自己的可写层，极大提升了存储效率。
容器删除时，对应的可写层会被一并删除，只读镜像层保持不变，这也是容器内数据不持久化的根本原因。

3.2 企业级安全加固最佳实践

Docker容器的安全风险主要来自：默认root权限运行、镜像漏洞、容器逃逸、权限过大等，以下为生产环境必须落地的安全加固措施。

最小权限原则：禁止使用root用户运行容器
容器默认以root用户运行，一旦容器被入侵，攻击者可利用root权限实现容器逃逸，控制宿主机。必须在Dockerfile中创建非root用户，并指定该用户运行容器：
```
# 创建非root用户和用户组
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
# 切换到非root用户
USER appuser
```
镜像安全管控
- 禁止使用未经验证的第三方镜像，优先使用官方镜像，锁定镜像版本和哈希值，避免latest标签导致的版本漂移和恶意镜像。
- 构建镜像时禁止内置密钥、凭证、配置文件，通过运行时环境变量、配置中心、BuildKit的--secret参数传递敏感信息，避免敏感信息残留到镜像历史中。
- 镜像构建完成后必须进行安全扫描，使用Trivy、Clair等工具，扫描镜像中的CVE漏洞、恶意代码，仅通过扫描的镜像才能部署到生产环境。
运行时安全加固
- 启用User Namespace，将容器内的root用户映射到宿主机的普通用户，即使容器被突破，也无法获得宿主机root权限。
- 限制容器的系统调用，使用Seccomp、AppArmor/SELinux配置安全策略，禁止容器执行不必要的系统调用，减少攻击面。
- 对无状态应用启用只读文件系统（--read-only），禁止容器修改根文件系统，仅给必要的目录挂载写入权限，防止恶意代码写入和执行。
- 禁止容器挂载宿主机敏感目录（/etc、/root、/proc、/dev/sock等），禁止使用--privileged特权模式，除非绝对必要，特权模式可直接突破容器隔离。
- 禁止容器使用host网络模式，除非有明确的性能需求，减少网络攻击面。
平台与宿主机安全
- 保持Docker版本为最新稳定版，及时修复内核和Docker引擎的安全漏洞。
- 宿主机最小化安装，仅运行必要的服务，关闭不必要的端口和服务。
- 严格管控Docker daemon的访问权限，禁止非授权用户访问Docker API，远程访问必须启用TLS双向认证。

3.3 容器监控与日志体系

生产环境中，必须建立完善的监控和日志体系，实时掌握容器运行状态，快速定位和排查故障。

3.3.1 基础监控命令（快速排障必备）

# 1. 查看容器资源使用情况（CPU、内存、IO、网络）
docker stats  # 实时查看所有容器的资源占用
docker stats my-nginx  # 查看指定容器的资源占用

# 2. 查看容器内运行的进程
docker top my-nginx

# 3. 查看容器详细信息，包括IP地址、挂载、环境变量、状态等
docker inspect my-nginx

# 4. 查看容器端口映射
docker port my-nginx

# 5. 查看容器启动事件
docker events

3.3.2 企业级监控方案

主流方案：Prometheus + Grafana + cAdvisor，实现容器指标的采集、存储、可视化告警，是生产环境的标准方案。

cAdvisor：Google开源的容器指标采集工具，运行在宿主机上，实时采集所有容器的CPU、内存、磁盘IO、网络IO、文件系统等核心指标，暴露给Prometheus。
Prometheus：时序数据库，定时拉取cAdvisor暴露的指标，进行存储和聚合计算，支持配置告警规则。
Grafana：可视化面板，对接Prometheus数据源，通过开箱即用的Docker监控大盘，实现容器指标的可视化展示、趋势分析、告警通知。

核心部署方式：通过Docker Compose一键部署整套监控系统，配置好Prometheus采集规则和Grafana大盘，即可实现全容器监控。

3.3.3 容器日志管理

日志配置最佳实践
- 容器应用必须将日志输出到标准输出stdout和标准错误stderr，禁止将日志写入容器内的文件，避免日志文件占用容器存储空间，导致磁盘占满。
- 配置Docker日志轮转，限制单个日志文件大小和数量，防止日志无限增长耗尽宿主机磁盘空间，前面daemon.json配置中已包含该配置。
企业级日志收集方案
主流方案：ELK/EFK栈，实现容器日志的集中收集、存储、检索、分析。
- Filebeat/Fluentd：日志采集器，部署在宿主机上，采集容器的标准输出日志，发送到Elasticsearch。
- Elasticsearch：分布式搜索引擎，存储和索引日志数据。
- Kibana：日志可视化平台，实现日志的检索、筛选、可视化分析、告警。

3.4 Docker性能调优核心技巧

3.4.1 镜像与构建优化

极致精简镜像体积，使用多阶段构建、alpine基础镜像，剔除无用文件，减少镜像拉取时间和存储占用，降低攻击面。
优化Dockerfile镜像层，利用Docker构建缓存，将不变的指令（依赖安装）放在前面，频繁变化的指令（代码复制）放在后面，大幅提升构建速度。

3.4.2 存储性能优化

生产环境必须使用overlay2存储驱动，搭配xfs文件系统，开启pquota挂载选项，支持容器级磁盘配额限制。
Docker数据目录（/var/lib/docker）必须使用SSD/NVMe磁盘，大幅提升镜像拉取、容器启动、IO读写性能。
IO密集型应用（数据库、消息队列、ELK），必须通过数据卷挂载宿主机目录，直接写入宿主机文件系统，完全绕过overlay2可写层，避免CoW机制带来的性能损耗。
临时文件、缓存数据使用tmpfs挂载内存文件系统，完全不写入磁盘，极致提升IO性能，同时避免临时数据泄露。

3.4.3 网络性能优化

高并发场景优先使用host网络模式，消除桥接网络的转发和NAT损耗，网络性能可接近宿主机原生水平。
自定义桥接网络优化内核参数，通过--sysctl参数给容器设置独立的TCP内核参数（tcp_tw_reuse、tcp_max_syn_backlog等），优化高并发场景下的网络性能。
避免频繁的端口映射和大量的iptables规则，减少网络转发开销。

3.4.4 资源调度优化

所有容器必须设置合理的CPU和内存资源限制（requests和limits），避免资源抢占和OOM（内存溢出）。
对于CPU密集型应用，绑定CPU核心，减少CPU上下文切换，提升性能：docker run --cpuset-cpus="0,1" my-app。
合理设置容器的OOM评分，避免核心业务容器被宿主机OOM killer优先杀死。

3.5 CI/CD与云原生集成

Docker是CI/CD和云原生架构的核心基石，通过Docker可实现“代码提交→自动构建→自动测试→镜像推送→自动部署”的全流程自动化，彻底打通开发、测试、生产环境的一致性。

3.5.1 典型CI/CD流水线（GitHub Actions示例）

核心流程：

开发者提交代码到GitHub仓库
触发GitHub Actions流水线，拉取代码
执行单元测试、代码扫描
通过Dockerfile构建应用镜像
镜像安全扫描，通过后推送到私有镜像仓库
自动部署到测试/生产环境的Docker主机或K8s集群

示例流水线配置文件.github/workflows/ci-cd.yml

name: Docker CI/CD Pipeline
on:
  push:
    branches: [ main ]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      # 拉取代码
      - name: Checkout code
        uses: actions/checkout@v4

      # 登录私有镜像仓库
      - name: Login to Docker Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ secrets.REGISTRY_URL }}
          username: ${{ secrets.REGISTRY_USERNAME }}
          password: ${{ secrets.REGISTRY_PASSWORD }}

      # 构建并推送镜像
      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: ${{ secrets.REGISTRY_URL }}/my-app:${{ github.sha }}

      # 自动部署到生产服务器
      - name: Deploy to production
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            docker pull ${{ secrets.REGISTRY_URL }}/my-app:${{ github.sha }}
            docker stop my-app || true
            docker rm my-app || true
            docker run -d --name my-app -p 80:80 --restart=always ${{ secrets.REGISTRY_URL }}/my-app:${{ github.sha }}

3.5.2 云原生进阶：Docker与K8s的关系

Docker是容器运行时，解决单个容器的构建、运行、管理问题；Kubernetes（K8s）是容器编排平台，解决大规模集群环境下多容器的调度、服务发现、自动扩缩容、故障自愈、滚动更新等问题。
随着容器技术的发展，K8s已废弃Docker作为容器运行时，转而使用符合CRI标准的containerd，但Docker构建的镜像完全符合OCI标准，可无缝在K8s集群中运行。
精通Docker是学习K8s的前提，掌握Docker核心能力后，可平滑过渡到K8s学习，进入云原生领域。

四、企业级实战篇：落地场景全覆盖

前后端分离项目容器化实战：Vue前端+SpringBoot后端+MySQL数据库，通过Docker Compose实现一键部署，包含多阶段构建、环境隔离、配置管理、日志持久化全流程。
微服务项目容器化部署：SpringCloud/Dubbo微服务体系，每个服务独立构建镜像，通过Docker Compose实现本地开发环境一键启动，通过K8s实现生产环境集群部署。
AI应用容器化部署：Stable Diffusion、LLM大模型等AI应用，通过Docker封装复杂的依赖环境，实现一键启动，解决环境配置繁琐的问题。
容器化故障排查全流程实战：覆盖容器启动失败、网络不通、数据丢失、性能瓶颈、OOM崩溃、日志异常等高频故障，提供标准化的排查思路和解决方案。
Docker高可用集群部署：基于Docker Swarm实现Docker集群的高可用，实现服务的多副本部署、故障自愈、滚动更新，适合中小型集群场景，比K8s更轻量、更易上手。

五、高频避坑指南

latest标签的坑：使用latest标签会导致镜像版本漂移，每次构建/拉取都可能获取到最新版本，引发兼容性问题，生产环境必须锁定镜像版本，甚至镜像哈希值。
数据丢失的坑：未挂载数据卷，容器删除后数据全部丢失，所有需要持久化的数据必须通过Volume挂载，禁止在容器可写层存储重要数据。
资源耗尽的坑：未给容器设置资源限制，单个容器耗尽宿主机CPU/内存，导致宿主机和其他容器崩溃，生产环境所有容器必须设置CPU和内存limits。
容器时区不一致的坑：容器内默认UTC时区，与宿主机CST时区相差8小时，导致日志、业务时间异常，启动容器时需挂载宿主机时区文件：-v /etc/localtime:/etc/localtime:ro。
日志磁盘占满的坑：未配置日志轮转，容器日志文件无限增长，耗尽宿主机磁盘空间，必须在daemon.json中配置日志大小和数量限制，生产环境必须集中收集日志。
容器逃逸的安全坑：使用--privileged特权模式、挂载宿主机敏感目录、以root用户运行容器，导致容器被入侵后攻击者可控制宿主机，必须严格遵循安全加固最佳实践。
镜像体积过大的坑：未使用多阶段构建，将编译环境、源码、依赖缓存都打包到镜像中，导致镜像体积高达几个G，拉取和部署速度极慢，镜像优化是生产环境必备技能。

六、学习资源与进阶路线

核心学习资源

官方文档：Docker官方文档，最权威、最新的学习资料，所有知识点的源头。
推荐书籍：《Docker实战》《Docker容器与容器云》《Docker进阶与实战》。
开源项目：GitHub上的awesome-docker项目，包含大量Docker优秀工具、实战案例、最佳实践。
社区：Docker官方社区、Stack Overflow、掘金、InfoQ等平台，可解决日常遇到的问题，学习行业最佳实践。

进阶学习路线

吃透本指南所有知识点，完成所有实战案例，熟练掌握Docker核心命令、Dockerfile编写、Docker Compose编排。
深入学习Linux内核相关知识，Namespace、Cgroups、OverlayFS、网络协议栈，彻底吃透容器底层原理。
学习Shell脚本编写、Linux运维知识，提升容器化部署和故障排查能力。
学习企业级监控、日志体系，掌握Prometheus、Grafana、ELK等工具的使用。
学习CI/CD相关知识，掌握GitLab CI、GitHub Actions、Jenkins等流水线工具，实现容器化应用的自动化部署。
进阶学习Kubernetes，掌握云原生容器编排技术，进入大规模集群管理、微服务架构、云原生开发领域。