Docker容器技术从入门到实战：核心概念、原理与应用指南

1. 从“它到底是什么”说起：一个开发者的困惑与顿悟

几年前，当我第一次听说Docker时，我和很多刚入行的朋友一样，脑子里充满了问号。虚拟机我知道，一个物理机上跑几个独立的操作系统嘛。那这个叫“容器”的东西，又是什么新花样？它和虚拟机到底有啥区别？为什么一夜之间，好像所有技术博客、招聘要求里都开始提“容器化”、“Docker”了？直到我自己在一个项目里，被“在我机器上能跑，到你那就报错”这个经典问题折磨得焦头烂额时，我才真正开始认真研究它。今天，我就想用最直白的话，把我对Docker的理解、踩过的坑和实际用法，一次性给你说清楚。这不是一篇照搬官方文档的说明书，而是一个过来人的实战笔记，适合所有被环境配置、依赖冲突、部署一致性等问题困扰的开发者、运维甚至测试同学。

简单来说，你可以把Docker理解为一个超级轻量级的标准化“软件打包箱”。它打包的不仅仅是你的代码，而是代码运行所需要的整个环境：包括操作系统基础库、运行时环境（比如Python 3.9、Node.js 16）、系统工具、配置文件等等。这个打包箱在任何支持Docker的机器上，都能以完全一致的方式打开并运行。这彻底解决了“环境差异”这个软件开发中的顽疾。接下来，我会从核心概念、底层原理到日常实操，带你一步步拆解Docker，让你不仅能明白它是什么，更能立刻上手用它解决实际问题。

2. 核心概念拆解：镜像、容器与仓库

要玩转Docker，必须先吃透三个最核心的概念：镜像（Image）、容器（Container）和仓库（Registry）。它们之间的关系，就像面向对象编程中的“类”和“对象”。

2.1 镜像：可复用的“构建蓝图”

镜像是一个只读的模板。它里面包含了运行某个软件所需的所有文件和配置信息。你可以把它想象成一套精装修房子的设计图纸和所有建材的清单。这个镜像是分层的，每一层代表对文件系统的一次修改（比如安装一个软件包，添加一个配置文件）。这种分层结构是Docker轻量化和高效的关键。

为什么是分层？假设你有一个Ubuntu基础镜像，然后基于它安装Python，再基于Python镜像安装你的应用。那么，Ubuntu层、Python层、应用层就是三个独立的层。当你拉取一个新镜像时，如果本地已有Ubuntu层和Python层，Docker就只会下载你应用的那一层，极大节省了时间和磁盘空间。多个镜像可以共享相同的基础层。

注意：镜像本身是静态的、不可变的。你无法直接“运行”一个镜像，就像你不能住进一张设计图里。你必须通过镜像来创建容器。

2.2 容器：镜像运行时的“实体”

容器是镜像的一个运行实例。继续用房子的比喻，容器就是根据那张设计图纸（镜像）实际建造出来并投入使用的房子。你可以启动、停止、移动、删除容器。每个容器都是相互隔离的，拥有自己的文件系统、网络和进程空间。

关键在于，容器与宿主机共享同一个操作系统内核，但通过Linux的命名空间（Namespace）和控制组（Cgroups）技术，实现了进程、网络、文件系统等资源的隔离。这比虚拟机（需要模拟整个硬件并运行完整的客户机操作系统）要轻量得多，启动速度通常在秒级甚至毫秒级。

一个简单的类比：虚拟机好比在电脑上安装了一个完整的“虚拟电脑”（包括虚拟CPU、内存、硬盘和完整的操作系统）。而Docker容器，则像是在你电脑的操作系统上，用“魔法”隔离开的一个个小房间，每个房间有自己的家具（应用和环境），但共用房子的地基（主机内核）和水电系统（硬件资源）。

2.3 仓库：镜像的“App Store”

仓库是集中存放镜像的地方。最大的公共仓库是 Docker Hub ，你可以在这里找到几乎所有主流软件和系统的官方镜像（如nginx,mysql,python,ubuntu）。就像手机的应用商店一样，你可以从中搜索、拉取（下载）你需要的镜像。

除了公共仓库，你也可以搭建私有的镜像仓库（如Harbor），用于存放企业内部不想公开的镜像，实现更安全、高效的内部镜像分发。

三者关系总结：仓库里存放着镜像，你用docker pull命令把镜像拉到本地，然后用docker run命令根据这个镜像创建并启动一个容器。修改容器后，你可以用docker commit将容器保存为新的镜像（但这不是推荐的做法），或者用Dockerfile重新构建镜像，并推送到仓库。

3. Docker底层原理浅析：它凭什么这么轻？

理解了“是什么”，我们再来简单看看“为什么”。Docker的轻量和高效，主要依赖于Linux内核的两大特性：命名空间（Namespaces）和控制组（Cgroups）。了解这些，能帮助你在遇到一些“诡异”问题时，知道从何下手。

3.1 命名空间：制造“视觉隔离”

命名空间的作用是隔离。它让容器内的进程以为自己运行在一个独立的系统环境中，看不到宿主机或其他容器里的进程、网络、用户ID等。

Docker主要使用了以下几种命名空间：

• PID命名空间：隔离进程ID。容器内PID为1的进程（通常是初始化进程），在宿主机上可能对应一个完全不同的PID。
• Network命名空间：隔离网络设备、IP地址、端口、路由表等。每个容器可以有自己独立的lo环回接口和eth0虚拟网卡。
• Mount命名空间：隔离文件系统挂载点。容器内看到的文件系统目录树是独立的。
• UTS命名空间：隔离主机名和域名。
• IPC命名空间：隔离进程间通信资源（如消息队列、共享内存）。
• User命名空间：隔离用户和用户组ID。这允许容器内的root用户映射到宿主机上的一个非root用户，提升了安全性。

3.2 控制组：实施“资源管制”

控制组的作用是限制和监控。它用来限制一个容器（或一组进程）可以使用的系统资源上限，比如CPU、内存、磁盘I/O、网络带宽等。这保证了单个容器不会耗尽宿主机的所有资源，影响其他容器或宿主机本身。

例如，你可以通过docker run的-m参数限制容器的最大内存使用量，背后就是Cgroups在起作用。

3.3 Union File System：实现“分层与共享”

联合文件系统（如overlay2,aufs）是Docker镜像分层和容器层读写的基础。它允许将多个只读层（镜像层）和一个可写层（容器层）透明地叠加在一起，呈现为一个统一的文件系统视图。

• 镜像层（只读）：多个只读层叠加，构成了镜像的最终内容。这些层是共享的，多个镜像可以引用同一基础层。
• 容器层（可写）：当基于镜像启动容器时，Docker会在所有镜像层之上添加一个薄薄的可写层。所有对容器的文件修改（增、删、改）都只发生在这个可写层。当容器被删除时，这个可写层也会被删除，镜像层保持不变。这就是为什么容器是无状态的、可随意销毁和重建的。

实操心得：理解分层机制对优化Dockerfile至关重要。在Dockerfile中，每一条指令（RUN,COPY,ADD等）都会创建一个新的镜像层。因此，应该将变化频率低的指令（如安装系统依赖）放在前面，变化频率高的指令（如拷贝应用代码）放在后面，并尽量合并RUN指令以减少层数，这样可以充分利用Docker的缓存机制，加速镜像构建。

4. 从零到一：Docker的安装与初体验

理论说再多，不如动手跑一个。这里我以最常用的Linux（Ubuntu/CentOS）和Windows为例，带你走一遍安装和第一个容器的流程，并重点讲解安装中可能遇到的坑。

4.1 Linux系统安装（以Ubuntu 22.04为例）

在Linux上，推荐使用官方仓库安装，而不是用系统自带的旧版本包。

步骤一：卸载旧版本（如果有）

sudo apt-get remove docker docker-engine docker.io containerd runc

步骤二：安装依赖工具并添加Docker官方GPG密钥

sudo apt-get update sudo apt-get install ca-certificates curl gnupg lsb-release sudo mkdir -p /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

步骤三：设置稳定版仓库

echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

步骤四：安装Docker Engine

sudo apt-get update sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

步骤五：验证安装

sudo docker run hello-world

如果看到“Hello from Docker!”等欢迎信息，说明安装成功。

重要提示：默认情况下，运行Docker命令需要sudo权限。为了避免每次输入sudo，可以将当前用户加入docker用户组：sudo usermod -aG docker $USER。操作后需要注销并重新登录才能生效。请注意，这将赋予该用户相当于root的权限（因为容器内的root在默认配置下等同于宿主机的root），因此请仅将受信任的用户加入该组。

4.2 Windows系统安装（Docker Desktop）

对于Windows 10/11专业版、企业版或教育版，Docker Desktop是首选。它依赖于Windows的Hyper-V虚拟化技术。

步骤一：开启虚拟化与Hyper-V

1. 进入BIOS/UEFI设置，确保CPU的虚拟化技术（Intel VT-x或AMD-V）已启用。
2. 在Windows“启用或关闭Windows功能”中，勾选“Hyper-V”和“Windows虚拟机监控程序平台”，重启电脑。

步骤二：下载并安装Docker Desktop

1. 从 Docker官网 下载Docker Desktop for Windows安装包。
2. 运行安装程序，按照提示完成安装。安装过程中会要求重启。

步骤三：启动与验证安装完成后，在开始菜单找到“Docker Desktop”并启动。等待系统托盘出现鲸鱼图标且状态稳定（通常为绿色或白色）。 打开PowerShell或命令提示符，输入：

docker run hello-world

看到成功信息即可。

Windows安装常见问题实录：

• 问题：启动Docker Desktop时提示“Docker Desktop failed to start because virtualisation support wasn't detected”或“Virtualization support not detected”。
• 排查：这是Windows安装中最常见的问题，根本原因是虚拟化支持未开启或与其他虚拟化软件冲突。
• 解决：
  1. 确认BIOS虚拟化已开启：重启进入BIOS，在CPU相关设置中找到“Intel Virtualization Technology”或“AMD SVM Mode”，确保其状态为“Enabled”。
  2. 关闭冲突的Hypervisor：如果你安装了其他虚拟机软件（如VMware Workstation、VirtualBox），它们可能启用了自己的Hypervisor（如Windows Hypervisor Platform, WHP）。在管理员权限的PowerShell中运行以下命令检查并关闭：

  bcdedit /set hypervisorlaunchtype off

  执行后必须重启电脑。这会将Windows的Hyper-V启动类型改为“off”。注意，这会导致依赖Hyper-V的Docker Desktop和Windows沙盒等无法使用。若需恢复，运行bcdedit /set hypervisorlaunchtype auto并重启。 3.使用WSL 2后端（推荐）：对于Windows 10版本2004及更高或Windows 11，强烈建议使用WSL 2作为Docker Desktop的后端。首先在“启用或关闭Windows功能”中启用“适用于Linux的Windows子系统”和“虚拟机平台”，然后从Microsoft Store安装一个Linux发行版（如Ubuntu）。在Docker Desktop设置中，选择“Use WSL 2 based engine”。这种方式性能更好，资源占用更少，且与Hyper-V冲突更小。

4.3 运行你的第一个实用容器：Nginx

现在，让我们运行一个真正有用的容器，而不是简单的hello-world。

docker run -d -p 8080:80 --name my-nginx nginx

这条命令做了以下几件事：

• docker run：创建并运行一个新容器。
• -d：让容器在后台运行（detached mode）。
• -p 8080:80：端口映射。将宿主机的8080端口映射到容器的80端口（Nginx默认监听端口）。
• --name my-nginx：给容器起一个名字，方便后续管理。如果不指定，Docker会随机生成一个名字。
• nginx：指定使用的镜像名。Docker会首先在本地查找，如果找不到，则自动从Docker Hub拉取最新的nginx官方镜像。

现在，打开你的浏览器，访问http://localhost:8080（Linux/macOS）或http://<你的Windows主机IP>:8080，你应该能看到Nginx的欢迎页面。恭喜，你已经成功运行了一个Web服务器容器！

5. Docker日常使用：核心命令与场景解析

掌握了安装和基础运行，我们来系统梳理一下日常开发、测试、部署中最常用的Docker命令和场景。记住，Docker命令的核心逻辑是围绕镜像和容器的生命周期管理的。

5.1 镜像管理：拉取、查看、构建与清理

搜索与拉取镜像

# 在Docker Hub搜索镜像 docker search mysql # 拉取镜像（不指定标签则拉取latest） docker pull mysql # 拉取指定版本的镜像 docker pull mysql:8.0

查看本地镜像

docker images # 或使用更强大的镜像列表命令 docker image ls

删除镜像

# 删除指定镜像（通过IMAGE ID或REPOSITORY:TAG） docker rmi <image_id> # 强制删除（即使有容器基于此镜像） docker rmi -f <image_id> # 清理所有未被使用的镜像（悬空镜像） docker image prune # 清理所有未被容器使用的镜像（谨慎！） docker image prune -a

5.2 容器生命周期：从创建到销毁

创建并启动容器：docker run是最核心的命令，它有大量参数。

# 基础运行 docker run -it ubuntu bash # -i: 交互式操作，-t: 分配一个伪终端。这让你能进入容器内部操作。 # 后台运行并映射端口 docker run -d -p 3306:3306 --name mysql-demo -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0 # -e: 设置环境变量，这里设置了MySQL的root密码。 # 挂载数据卷（将宿主机目录映射到容器内） docker run -d -v /宿主机/数据目录:/容器内/数据目录 --name myapp my-image # -v: 数据卷挂载，实现数据持久化，即使容器删除，宿主机上的数据依然存在。 # 设置容器重启策略 docker run -d --restart=always --name my-service my-image # --restart=always: 容器退出时总是重启，除非手动停止。这对于需要保持常驻的服务非常有用。

查看容器状态

# 查看正在运行的容器 docker ps # 查看所有容器（包括已停止的） docker ps -a # 查看容器详细信息（JSON格式） docker inspect <container_name_or_id> # 查看容器日志（调试神器） docker logs <container_name_or_id> # 实时查看日志（类似 tail -f） docker logs -f <container_name_or_id>

进入运行中的容器

# 方式一：使用docker exec（推荐，不会影响容器内主进程） docker exec -it <container_name_or_id> bash # 方式二：使用docker attach（会连接到主进程的输入输出，退出可能导致容器停止，慎用） docker attach <container_name_or_id>

容器的启动、停止、重启与删除

# 停止容器 docker stop <container_name_or_id> # 强制停止容器（发送SIGKILL信号） docker kill <container_name_or_id> # 启动已停止的容器 docker start <container_name_or_id> # 重启容器 docker restart <container_name_or_id> # 删除已停止的容器 docker rm <container_name_or_id> # 强制删除运行中的容器 docker rm -f <container_name_or_id>

5.3 数据持久化：数据卷与绑定挂载

容器本身是无状态的，删除后其内部产生的所有数据都会丢失。为了持久化数据（如数据库文件、应用程序日志、配置文件），Docker提供了两种主要方式：

1. 数据卷（Volumes）数据卷是由Docker管理的主机文件系统的一部分，存储在/var/lib/docker/volumes/下。它是Docker推荐的数据持久化方式。

# 创建数据卷 docker volume create my-vol # 使用数据卷 docker run -d -v my-vol:/容器内/路径 --name myapp my-image # 查看数据卷列表 docker volume ls # 查看数据卷详情 docker volume inspect my-vol # 删除未使用的数据卷 docker volume prune

优点：与宿主机文件系统解耦，易于备份和迁移，性能通常较好。缺点：位置在Docker管理目录下，不便于直接通过宿主机文件管理器访问。

2. 绑定挂载（Bind Mounts）直接将宿主机的任意目录或文件挂载到容器内。

docker run -d -v /宿主机/绝对路径:/容器内/路径 --name myapp my-image

优点：非常灵活，可以直接使用宿主机上现有的目录结构，方便开发和调试（例如，将本地代码目录挂载到容器中，实现代码热更新）。缺点：依赖于宿主机的目录结构，可移植性差；如果宿主机目录权限设置不当，可能导致容器内应用运行失败。

实操心得：对于生产环境的数据库、文件存储等，优先使用命名数据卷。对于开发环境，需要频繁修改代码时，使用绑定挂载非常方便。记住一个原则：容器内应用进程的用户（如www-data,mysql）必须对挂载的目录有读写权限，否则会出现权限错误。可以在Dockerfile中用USER指令指定非root用户运行，并在宿主机上调整对应目录的权限（如chown -R 1000:1000 /宿主机/路径，其中1000是容器内用户的UID）。

5.4 网络配置：让容器互联互通

Docker提供了几种网络模式，默认会创建bridge、host、none三种网络。

• bridge（桥接模式，默认）：每个容器分配独立的Network Namespace和IP，并通过一个名为docker0的虚拟网桥与宿主机通信。容器之间可以通过IP地址通信，但更推荐使用自定义桥接网络。
• host（主机模式）：容器不会虚拟出自己的网卡，而是直接使用宿主机的IP和端口。性能最好，但端口冲突风险高。
• none（无网络）：容器有独立的Network Namespace，但不进行任何网络配置，需要手动配置。

创建并使用自定义桥接网络

# 创建自定义网络 docker network create my-net # 运行容器并加入该网络 docker run -d --name app1 --network my-net my-app-image docker run -d --name app2 --network my-net my-app-image

加入同一个自定义网络的容器，可以通过容器名直接互相访问（Docker内置了DNS解析），例如在app1中可以直接ping app2。这比使用默认的bridge网络（只能通过IP访问）方便和安全得多。

端口映射：如前所述，-p参数用于将容器端口暴露给宿主机外部访问。格式为-p <宿主机端口>:<容器端口>。

6. Dockerfile实战：定制属于自己的镜像

从公共镜像运行容器很方便，但更多时候我们需要构建包含自己应用的镜像。这就需要编写Dockerfile。Dockerfile是一个文本文件，包含了一系列构建镜像所需的指令。

6.1 一个完整的Dockerfile示例

假设我们有一个简单的Python Flask应用，目录结构如下：

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

app.py内容：

from flask import Flask app = Flask(__name__) @app.route('/') def hello(): return 'Hello, Docker!' if __name__ == '__main__': app.run(host='0.0.0.0', port=5000)

requirements.txt内容：

Flask==2.3.3

现在，我们来编写Dockerfile：

# 第一阶段：构建阶段（可选，用于多阶段构建，此处为单阶段示例） # 使用官方Python运行时作为父镜像 FROM python:3.9-slim AS builder # 设置工作目录 WORKDIR /app # 将当前目录下的requirements.txt复制到容器的/app目录下 COPY requirements.txt . # 安装依赖（使用清华镜像源加速，国内环境推荐） RUN pip install --no-cache-dir -i https://pypi.tuna.tsinghua.edu.cn/simple -r requirements.txt # 第二阶段：运行阶段（如果是多阶段构建，这里可以从builder阶段只拷贝所需文件，如虚拟环境） # 此处我们延续使用同一个镜像 # 将当前目录下的所有文件复制到容器的/app目录下 COPY . . # 声明容器运行时监听的端口（只是一个声明，方便使用者知道） EXPOSE 5000 # 定义环境变量 ENV FLASK_APP=app.py ENV FLASK_ENV=production # 在容器启动时运行app.py CMD ["flask", "run", "--host=0.0.0.0"]

6.2 Dockerfile指令详解与最佳实践

1. FROM：指定基础镜像。必须是第一条非注释指令。尽量使用官方镜像，并选择具体版本标签（如python:3.9-slim），避免使用latest，以保证构建的一致性。-slim版本通常更小。
2. WORKDIR：设置工作目录。后续的RUN、CMD、COPY、ADD等指令都会在这个目录下执行。使用绝对路径。
3. COPY vs ADD：优先使用COPY。COPY仅用于复制本地文件到镜像。ADD功能更多（可以解压tar包，从URL下载），但行为不够清晰透明，除非需要解压或远程下载，否则用COPY。
4. RUN：执行命令并创建新的镜像层。常用于安装软件包、编译代码。
   • 合并RUN指令：为了减少镜像层数，应将多个命令用&&连接放在一个RUN指令中，并在换行时使用反斜杠\保持可读性。
   • 清理缓存：在安装包后，记得清理apt或yum缓存，减小镜像体积。例如：RUN apt-get update && apt-get install -y package && rm -rf /var/lib/apt/lists/*。
5. EXPOSE：声明容器运行时提供的端口。这只是一个文档性质的说明，实际映射端口需要在docker run时用-p参数指定。
6. ENV：设置环境变量。这些变量在构建阶段和运行阶段都可用。对于运行时才需要的变量，可以考虑在docker run时通过-e传入，这样更灵活。
7. CMD：指定容器启动时默认执行的命令。一个Dockerfile中只能有一个CMD指令，如果有多条，只有最后一条生效。CMD有三种格式：
   • exec格式（推荐）：CMD ["executable", "param1", "param2"]，例如CMD ["flask", "run"]。这种格式不会启动shell，进程PID为1，能正确接收Unix信号（如SIGTERM）。
   • shell格式：CMD command param1 param2。它会在/bin/sh -c中执行，PID为1的是shell进程，而不是你的应用进程，可能导致信号无法正确传递。
   • 作为ENTRYPOINT的默认参数。
8. ENTRYPOINT：配置容器启动后始终执行的可执行文件。CMD的内容可以作为ENTRYPOINT的默认参数。通常用于将容器设置为一个固定的“命令”，例如：ENTRYPOINT ["python"]，然后通过CMD指定运行的脚本CMD ["app.py"]。运行时可以通过传递参数覆盖CMD。

6.3 构建与运行自定义镜像

在Dockerfile所在目录执行构建命令：

# -t 参数给镜像打标签，格式为 name:tag # . 表示构建上下文为当前目录 docker build -t my-flask-app:1.0 .

构建过程会逐步执行Dockerfile中的指令。构建成功后，运行容器：

docker run -d -p 5000:5000 --name flask-app my-flask-app:1.0

访问http://localhost:5000即可看到应用。

多阶段构建实战：对于需要编译的应用（如Go、Java），为了减小最终镜像体积，可以使用多阶段构建。在第一阶段（构建阶段）安装编译器、编译代码；在第二阶段（运行阶段）使用一个更小的基础镜像（如alpine），仅从第一阶段拷贝编译好的二进制文件。

# 第一阶段：构建 FROM golang:1.19 AS builder WORKDIR /app COPY . . RUN go build -o myapp . # 第二阶段：运行 FROM alpine:latest WORKDIR /root/ # 从builder阶段只拷贝编译好的可执行文件 COPY --from=builder /app/myapp . CMD ["./myapp"]

这样，最终的镜像只包含轻量的Alpine系统和你的二进制文件，体积可能只有几十MB，而构建镜像可能超过1GB。

7. Docker Compose：驾驭多容器应用的利器

当你的应用由多个服务组成（例如一个Web应用+一个数据库+一个缓存），使用docker run一个个启动和管理会非常繁琐。Docker Compose应运而生。它通过一个docker-compose.yml文件来定义和运行多个相关联的容器，非常适合开发、测试和单机部署环境。

7.1 编写docker-compose.yml

继续上面的Flask例子，假设我们需要一个MySQL数据库。项目结构变为：

my-app/ ├── app/ │ ├── app.py (修改为连接数据库) │ └── requirements.txt (增加mysql-connector-python) ├── docker-compose.yml └── Dockerfile

docker-compose.yml内容：

version: '3.8' # 指定Compose文件格式版本 services: # 定义所有服务 web: # 服务名称：web应用 build: . # 使用当前目录下的Dockerfile构建镜像 ports: - "5000:5000" # 端口映射 environment: # 设置环境变量，用于连接数据库 - DATABASE_HOST=db - DATABASE_USER=root - DATABASE_PASSWORD=secret - DATABASE_NAME=mydb depends_on: # 依赖关系，确保db服务先启动 - db volumes: # 挂载代码目录，实现开发热重载 - ./app:/app # 覆盖Dockerfile中的CMD，在开发时使用调试模式运行 command: flask run --host=0.0.0.0 --reload db: # 服务名称：数据库 image: mysql:8.0 # 使用现成的官方镜像 restart: always # 总是重启 environment: MYSQL_ROOT_PASSWORD: secret # 设置root密码（生产环境应用更安全的方式，如secret） MYSQL_DATABASE: mydb # 初始创建的数据库 volumes: # 使用命名数据卷持久化数据库数据 - db_data:/var/lib/mysql # 暴露端口（仅在Compose网络内访问，不映射到宿主机） expose: - "3306" volumes: # 声明在文件级别使用的数据卷 db_data: # 命名数据卷

7.2 Compose核心命令

在包含docker-compose.yml文件的目录下执行：

# 启动所有服务（后台运行） docker-compose up -d # 启动并重新构建镜像 docker-compose up -d --build # 查看运行状态 docker-compose ps # 查看服务日志（所有服务） docker-compose logs # 查看指定服务日志（-f 实时跟踪） docker-compose logs -f web # 停止所有服务 docker-compose stop # 停止并删除所有容器、网络（不会删除数据卷和镜像） docker-compose down # 停止并删除所有容器、网络、数据卷 docker-compose down -v # 进入某个服务的容器 docker-compose exec web bash

实操心得：depends_on只控制容器的启动顺序，并不保证服务已准备好。例如，web服务启动时，db容器可能已经运行，但MySQL服务可能还未完成初始化。在生产环境中，需要应用层具备重试连接数据库的逻辑，或者使用healthcheck指令和condition选项（Compose v2.1+支持）来等待依赖服务健康。

8. 生产环境考量与进阶话题

将Docker用于生产环境，远不止docker run这么简单。这里提几个关键点，为你进一步深入指明方向。

8.1 镜像仓库与CI/CD

• 私有镜像仓库：生产环境不应直接从Docker Hub拉取镜像。应搭建私有仓库（如Harbor、Nexus Repository）或使用云服务商提供的容器镜像服务，用于存储和管理经过测试的镜像。
• CI/CD集成：在代码提交后，通过Jenkins、GitLab CI、GitHub Actions等工具自动执行docker build、运行测试，并将通过测试的镜像推送到私有仓库，然后触发部署。

8.2 容器编排：Kubernetes (K8s)

当你的服务数量增多，需要跨多台服务器部署、管理、伸缩和保障高可用时，就需要容器编排平台。Kubernetes是当前事实上的标准。它负责：

• 服务发现与负载均衡：自动为容器组分配IP和DNS名称，并实现流量负载均衡。
• 存储编排：自动挂载你选择的存储系统（本地、云存储等）。
• 自动部署和回滚：你可以描述应用的期望状态，K8s会以受控的速率将实际状态变更到期望状态。
• 自动扩缩容：根据CPU利用率等指标，自动增加或减少运行容器的数量。
• 自我修复：重启失败的容器，替换不可用的节点。

学习Docker是进入云原生和Kubernetes世界的第一步。

8.3 安全最佳实践

1. 使用非root用户运行容器：在Dockerfile中使用USER指令，避免容器内应用以root权限运行，即使容器逃逸，危害也相对有限。
2. 定期更新基础镜像：关注基础镜像（如ubuntu,alpine）的安全更新，定期重建你的应用镜像。
3. 扫描镜像漏洞：使用docker scan命令（集成Snyk）或Trivy、Clair等工具扫描镜像中的已知漏洞。
4. 限制容器资源：使用-m,--cpus等参数或通过编排平台限制容器的CPU、内存使用，防止资源耗尽攻击。
5. 避免在镜像中存储敏感信息：密码、密钥等应通过环境变量（-e）、Docker Secrets或配置中心注入，而不是硬编码在Dockerfile或代码中。

8.4 监控与日志

• 日志：确保应用日志输出到标准输出（stdout）和标准错误（stderr），这样可以通过docker logs或日志驱动收集（如配置json-file,syslog, 或fluentd）。
• 监控：使用docker stats命令可以实时查看容器资源使用情况。生产环境通常集成Prometheus、cAdvisor等工具进行更全面的监控和告警。

Docker不仅仅是一个工具，它代表了一种新的软件交付和运行范式。从理解镜像、容器、仓库这三个核心概念开始，到熟练使用命令、编写Dockerfile、编排多服务应用，再到思考生产环境下的安全、编排和监控，每一步都充满了实践的价值。我个人的体会是，初期多动手练习，从搭建一个简单的个人项目开始，遇到问题就去查文档、搜社区，积累下来的经验远比只看理论要扎实得多。当你习惯了这种“一次构建，到处运行”的便利后，就很难再回到过去那种手动配置环境的时代了。