Docker容器技术核心概念与实战入门指南-编程实验室

1. 从零到一：为什么我们需要重新认识 Docker？

如果你是一名开发者或者运维工程师，最近几年肯定没少听人提起 Docker。它好像无处不在，从个人项目到企业级生产环境，大家都在用。但说实话，我刚开始接触 Docker 的时候，也是一头雾水。虚拟机不是用得好好的吗？为什么又冒出来一个“容器”？它和虚拟机到底有什么区别？直到我自己亲手把一个复杂的、依赖环境极其繁琐的本地开发项目，用几行 Dockerfile 打包成一个镜像，并且在任何一台新机器上都能一键启动、完美运行时，我才真正理解了它的价值。

简单来说，Docker 解决了一个困扰我们多年的核心痛点：环境一致性。你有没有遇到过“在我机器上好好的，怎么到你那就跑不起来了”这种问题？开发、测试、生产环境的不一致，是无数 Bug 和扯皮的根源。Docker 通过将应用及其所有依赖（包括代码、运行时、系统工具、系统库、设置）打包成一个标准化的、轻量级的、可移植的“容器”，从根本上保证了应用在任何地方都能以完全相同的方式运行。这不仅仅是方便，它彻底改变了软件交付和部署的流程。

这本书，也就是yeasy/docker_practice，是我见过的最好的 Docker 中文学习资料之一。它不像官方文档那样冷冰冰，也不像某些快餐教程那样浅尝辄止。它更像是一位经验丰富的导师，从“这玩意儿是什么”开始，手把手带你理解概念、上手操作，再深入到背后的原理和高级玩法，最后还能指导你如何将 Docker 应用到真实的、复杂的生产场景中。无论你是刚听说 Docker 的新手，还是已经用过docker run但想深入了解的进阶用户，这本书都能给你带来实实在在的收获。接下来，我就结合自己多年的使用经验，带你深入拆解这本书的精华，并补充一些官方文档里不会写的实战心得和避坑指南。

2. 核心架构解析：容器、镜像与仓库的三位一体

要玩转 Docker，必须吃透三个最核心的概念：镜像（Image）、容器（Container）和仓库（Registry）。很多人一开始会混淆镜像和容器，其实理解它们的关系，就成功了一大半。

2.1 镜像：不可变的构建模板

你可以把 Docker 镜像理解为一个只读的模板。它包含了运行某个软件所需的所有文件系统结构和内容。比如一个 Ubuntu 镜像，里面就有一个精简的 Ubuntu 文件系统；一个 Nginx 镜像，里面就包含了编译好的 Nginx 程序及其配置。

镜像的核心特性是分层存储和内容寻址。每一个镜像都由一系列只读层（Layer）叠加而成。当你修改镜像（比如在基础镜像上安装一个软件）时，Docker 并不是复制整个文件系统，而是在原有层之上创建一个新的层。这种设计带来了巨大的好处：

共享与复用：不同的镜像可以共享相同的基础层。比如你的应用镜像和同事的应用镜像都基于ubuntu:latest，那么你们本地只需要存储一份ubuntu:latest的基础层。
高效传输：拉取镜像时，如果本地已有某些层，就无需重复下载。
快速构建：构建镜像时，每一层的构建结果都会被缓存。如果 Dockerfile 的某一层及之前的层没有变化，后续构建就可以直接使用缓存，速度极快。

实操心得：在编写 Dockerfile 时，一个重要的优化原则就是尽量减少层数，并且将变化频率低的层放在前面，变化频率高的层（如复制应用代码）放在后面。例如，不要这样写：

RUN apt-get update RUN apt-get install -y package-a RUN apt-get install -y package-b RUN apt-get clean

而应该合并为：

RUN apt-get update && \ apt-get install -y package-a package-b && \ apt-get clean

这样不仅减少了层数，还因为清理操作在同一层，最终镜像的体积会更小。

2.2 容器：镜像的运行实例

容器是镜像的一个可运行的实例。你可以把镜像类比为“类”（Class），而容器则是这个类的“对象”（Object）。当我们执行docker run时，Docker 引擎会基于指定的镜像创建一个可写的容器层（通常称为“容器层”或“读写层”），然后在其上挂载一个进程空间、网络接口等，最终启动应用。

容器层是临时的。所有对运行中容器的文件修改（如写入日志、创建临时文件）都发生在这个可写层。当容器被删除时，这个可写层也会一并被删除，而底层的镜像保持不变。这就是为什么我们说容器是无状态的。持久化数据需要通过“数据卷（Volume）”或“绑定挂载（Bind Mount）”来实现，将主机上的目录映射到容器内。

重要区别：容器 vs. 虚拟机这是初学者最困惑的地方。很多人觉得容器就是一种轻量级虚拟机，这其实是个误解。

特性	虚拟机 (VM)	Docker 容器
虚拟化级别	硬件虚拟化（Hypervisor）	操作系统虚拟化（Docker Engine）
启动速度	慢（分钟级）	快（秒级）
性能损耗	较高（模拟硬件）	极低（直接使用宿主机内核）
隔离性	强（完全隔离的 Guest OS）	较弱（共享宿主机内核，进程/网络/文件系统隔离）
镜像大小	庞大（GB 级，包含完整 OS）	小巧（MB 级，仅包含应用及必要依赖）
部署密度	低	高

简单来说，虚拟机是在物理硬件上虚拟出一套完整的计算机系统（包括虚拟的 CPU、内存、硬盘、网卡，以及一个完整的客户机操作系统）。而容器是直接在宿主机操作系统内核之上，通过 Namespace 实现进程、网络等资源的隔离，通过 Cgroups 实现资源（CPU、内存）的限制，它没有自己的内核，也不需要启动完整的操作系统。因此，容器更轻、更快、资源利用率更高。

2.3 仓库：镜像的集散中心

仓库（Registry）是集中存放镜像的地方。最著名的公共仓库是 Docker Hub，你可以在这里找到几乎所有常见软件的官方镜像（如nginx,mysql,python）。你也可以搭建私有仓库（如 Harbor、Nexus）来存放企业内部镜像。

镜像的名称由三部分组成：[仓库地址]/[用户名/]镜像名:标签。

仓库地址：默认为 Docker Hub (docker.io)，私有仓库则填写其域名或IP。
用户名：在 Docker Hub 上的命名空间，官方镜像省略用户名（如ubuntu）。
标签：通常用于区分版本，如:latest（默认）、:alpine（基于 Alpine Linux 的轻量版本）、:1.21.6。

注意事项：在生产环境中，永远不要使用:latest标签。因为latest是一个浮动标签，今天拉取的nginx:latest和一个月后拉取的可能是完全不同的版本，这会导致环境不可控。务必使用明确的版本标签，如nginx:1.21.6-alpine。

3. 实战入门：五分钟运行你的第一个容器

理论说再多不如动手一试。我们按照书中的“五分钟快速上手”流程，来一次完整的实操。

3.1 安装与验证 Docker Engine

首先，你需要根据操作系统安装 Docker Engine。这里以 Ubuntu 22.04 为例，演示安装过程。其他系统请参考官方文档。

卸载旧版本（如果存在）：

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

设置仓库：

sudo apt-get update sudo apt-get install -y 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 -y docker-ce docker-ce-cli containerd.io docker-compose-plugin

验证安装：
```
sudo docker run hello-world
```
如果看到 “Hello from Docker!” 等欢迎信息，说明安装成功。这个命令做了几件事：从 Docker Hub 拉取hello-world镜像（如果本地没有），然后基于该镜像创建并启动一个容器，容器执行完输出信息后自动退出。

避坑指南：默认情况下，运行docker命令需要sudo权限。为了避免每次输入sudo，可以将当前用户加入docker用户组：

sudo usermod -aG docker $USER

重要：执行此命令后，你需要完全退出当前终端会话并重新登录，或者重启系统，用户组变更才会生效。之后就可以直接使用docker命令了。

3.2 运行一个交互式容器

让我们运行一个更“真实”的容器。执行以下命令：

docker run -it --rm ubuntu:22.04 bash

解释一下参数：

-i：保持标准输入（STDIN）打开，允许我们与容器交互。
-t：分配一个伪终端（pseudo-TTY），让我们感觉像在真正的终端里操作。
--rm：容器退出后自动删除。这对于临时测试非常有用，避免产生大量停止的容器占用空间。
ubuntu:22.04：指定镜像及其标签。
bash：容器启动后要执行的命令。

命令执行后，你会进入一个全新的 Ubuntu 22.04 系统的 bash shell 中。你可以执行ls,cat /etc/os-release等命令。你会发现这个系统非常精简，很多常用工具（如vim,curl）都没有安装。这正是容器的特点：一个最小化的运行环境。

输入exit退出容器。由于使用了--rm参数，这个容器实例会被自动删除，但ubuntu:22.04镜像依然保留在你的本地。

3.3 理解容器生命周期与基本操作

掌握几个最常用的容器管理命令：

docker ps：列出正在运行的容器。加-a参数显示所有容器（包括已停止的）。
docker stop <容器ID或名称>：停止一个运行中的容器。
docker start <容器ID或名称>：启动一个已停止的容器。
docker rm <容器ID或名称>：删除一个已停止的容器（运行中的容器需先停止或加-f强制删除）。
docker logs <容器ID或名称>：查看容器的日志输出。
docker exec -it <容器ID或名称> bash：进入一个正在运行的容器的 shell。这在调试时非常有用。

实操心得：给容器起一个有意义的名字是个好习惯，使用--name参数：

docker run -d --name my_nginx -p 8080:80 nginx:alpine

这样在后续操作（stop,logs,exec）时，就不需要去记冗长的容器ID，直接使用my_nginx即可。-d参数表示后台运行，-p 8080:80表示将主机的 8080 端口映射到容器的 80 端口。

4. 核心技能进阶：编写 Dockerfile 与构建自定义镜像

只会使用现成的镜像是不够的。将你自己的应用容器化，才是 Docker 价值的核心体现。这需要通过编写Dockerfile来实现。

4.1 Dockerfile 指令精讲

Dockerfile 是一个文本文件，包含了一系列构建镜像的指令。每一条指令都会创建一个新的镜像层。以下是几个最关键的指令：

FROM：指定基础镜像。所有 Dockerfile 都必须以 FROM 指令开始。选择合适的基础镜像至关重要，通常推荐 Alpine Linux 版本，因为它体积极小。
```
FROM python:3.9-slim # 使用官方的 Python 轻量版镜像
```
WORKDIR：设置工作目录。相当于cd到这个目录，后续的RUN,COPY,CMD等指令都会在此目录下执行。
```
WORKDIR /app
```
COPY与ADD：将文件从构建上下文复制到镜像中。COPY是更纯粹的选择，只负责复制。ADD功能更多（如自动解压 tar 包，从 URL 下载），但行为不够透明，除非需要解压或从远程拉取，否则一律使用COPY。
```
COPY requirements.txt . # 将宿主的 requirements.txt 复制到镜像的 /app 目录 COPY . . # 将构建上下文的所有文件复制到镜像的 /app 目录（注意排除 .dockerignore 中的文件）
```

RUN：在构建镜像时执行命令。常用于安装软件包、编译代码等。

RUN apt-get update && apt-get install -y --no-install-recommends \ gcc \ && rm -rf /var/lib/apt/lists/* # 安装编译依赖并清理缓存，减少镜像层大小 RUN pip install --no-cache-dir -r requirements.txt # 安装 Python 依赖

ENV：设置环境变量。这些变量在构建阶段和容器运行时都可用。
```
ENV FLASK_APP=app.py ENV FLASK_ENV=production
```
EXPOSE：声明容器运行时监听的端口。这只是一个文档性质的说明，并不会自动进行端口映射。实际的端口映射需要在docker run时通过-p参数指定。
```
EXPOSE 5000
```
CMD与ENTRYPOINT：指定容器启动时执行的命令。这是最容易混淆的一对指令。
- CMD：提供容器默认的执行命令和参数。可以被docker run后面跟的命令覆盖。
```
CMD ["python", "app.py"]
```
- ENTRYPOINT：配置容器启动时执行的固定命令，CMD的内容会作为参数传递给ENTRYPOINT。通常用于将容器设置为一个可执行程序。
```
ENTRYPOINT ["python"] CMD ["app.py"] # 此时 `docker run my-image` 会执行 `python app.py`，而 `docker run my-image test.py` 会执行 `python test.py`
```
最佳实践：对于大多数应用，使用CMD即可。如果需要容器像一个独立的可执行文件（例如docker run my-cli --help），则结合使用ENTRYPOINT和CMD。

4.2 一个完整的 Flask 应用 Dockerfile 示例

假设我们有一个简单的 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.2

Dockerfile内容：

# 使用官方 Python 轻量级镜像作为基础 FROM python:3.9-slim # 设置工作目录 WORKDIR /app # 将依赖文件复制到工作目录 COPY requirements.txt . # 安装依赖，使用 --no-cache-dir 减少 pip 缓存大小 RUN pip install --no-cache-dir -r requirements.txt # 将应用代码复制到工作目录 COPY . . # 声明容器运行时监听的端口 EXPOSE 5000 # 定义环境变量 ENV FLASK_APP=app.py ENV FLASK_ENV=production # 启动应用 CMD ["flask", "run", "--host=0.0.0.0"]

4.3 构建镜像与运行

在my-flask-app目录下，执行构建命令：

docker build -t my-flask-app:1.0 .

-t my-flask-app:1.0：为镜像打上标签（名称:版本）。
.：指定构建上下文为当前目录。Docker 客户端会将这个目录下的所有文件（受.dockerignore影响）打包发送给 Docker 守护进程进行构建。

构建成功后，运行容器：

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

访问http://localhost:5000，你应该能看到 “Hello, Docker!”。

高级技巧：多阶段构建对于需要编译的应用（如 Go、Java），最终的运行环境可能不需要编译工具链。多阶段构建可以极大地减小最终镜像的体积。

# 第一阶段：构建阶段 FROM golang:1.19 AS builder WORKDIR /app COPY . . RUN go build -o myapp . # 第二阶段：运行阶段 FROM alpine:latest RUN apk --no-cache add ca-certificates WORKDIR /root/ # 从 builder 阶段复制编译好的可执行文件，而不是整个 Go 环境 COPY --from=builder /app/myapp . CMD ["./myapp"]

这样，最终生成的镜像只包含轻量的 Alpine Linux 和可执行文件，体积可能从几百 MB 减少到十几 MB。

5. 数据管理与网络互联：让容器变得“有用”

单纯的容器是易失的。要让容器运行有状态的应用（如数据库），或者让多个容器协同工作，就必须掌握数据管理和网络配置。

5.1 数据卷：持久化数据的生命线

数据卷（Volume）是 Docker 推荐的持久化数据方式。它完全由 Docker 管理，独立于容器的生命周期，即使容器被删除，数据卷依然存在。

创建和使用数据卷：

# 创建一个名为 `my-data` 的数据卷 docker volume create my-data # 运行一个容器，并将数据卷挂载到容器内的 `/data` 目录 docker run -d --name mysql-container \ -v my-data:/var/lib/mysql \ # `-v` 或 `--mount` 参数用于挂载 -e MYSQL_ROOT_PASSWORD=secret \ mysql:8.0

这样，MySQL 的数据就持久化在了my-data卷中。以后即使删除并重新创建mysql-container，只要挂载同一个卷，数据就不会丢失。

绑定挂载：直接将主机上的一个目录挂载到容器中。这在开发时非常方便，可以实现主机代码和容器运行环境的实时同步。
```
docker run -d --name dev-flask \ -p 5000:5000 \ -v $(pwd):/app \ # 将当前目录挂载到容器的 /app -w /app \ python:3.9-slim \ bash -c "pip install flask && flask run --host=0.0.0.0"
```
你在主机上修改app.py后，容器内的 Flask 服务会自动重载（如果支持的话）。

注意事项：数据卷的路径在容器内。你需要清楚应用默认的数据存储路径（如 MySQL 的/var/lib/mysql，PostgreSQL 的/var/lib/postgresql/data）。使用绑定挂载时，要注意主机和容器之间的文件权限问题。

5.2 容器网络：从隔离到通信

默认情况下，每个容器都有自己的网络命名空间，拥有独立的网络栈（IP 地址、端口映射等）。Docker 提供了几种网络模式：

bridge（桥接）：默认模式。Docker 会创建一个名为docker0的虚拟网桥，容器会连接到这个网桥，并分配一个私有 IP。容器之间可以通过 IP 通信，对外则需要端口映射（-p）。
host（主机）：容器共享宿主机的网络命名空间，直接使用宿主机的 IP 和端口。性能最好，但隔离性最差。
none（无）：容器没有网络接口，只有lo回环设备。
自定义网络：这是生产环境推荐的方式。你可以创建自己的桥接网络，该网络内的容器可以通过容器名互相访问，无需使用 IP 地址，这得益于 Docker 内置的 DNS 服务。

创建和使用自定义网络：

# 创建一个自定义桥接网络 docker network create my-app-network # 运行两个容器，并加入同一个网络 docker run -d --name web --network my-app-network nginx:alpine docker run -it --rm --network my-app-network alpine:latest # 在 alpine 容器内，可以直接 ping `web` / # ping web PING web (172.19.0.2): 56 data bytes 64 bytes from 172.19.0.2: seq=0 ttl=64 time=0.085 ms

这对于微服务架构特别有用，服务间可以通过服务名直接调用，简化了配置。

6. 生产级工具链：Docker Compose 与容器编排初探

当应用由多个容器组成（例如一个 Web 应用需要 Nginx、Python、Redis、MySQL）时，手动管理每个容器的docker run命令会变得非常繁琐。Docker Compose 就是为解决这个问题而生的。

6.1 使用 Docker Compose 定义多容器应用

Docker Compose 使用一个 YAML 文件（默认docker-compose.yml）来定义和运行多个容器。以上面的 Flask + Redis 为例：

docker-compose.yml:

version: '3.8' # 指定 Compose 文件格式版本 services: web: build: . # 使用当前目录的 Dockerfile 构建镜像 ports: - "5000:5000" environment: - REDIS_HOST=redis depends_on: - redis # 声明依赖，确保 redis 服务先启动 networks: - app-net redis: image: "redis:alpine" # 使用现成的 Redis 镜像 networks: - app-net # 可以在这里定义 Redis 的数据卷挂载 networks: app-net: # 定义一个网络，上面的服务会自动加入 driver: bridge

然后，只需要在项目目录下执行一条命令：

docker-compose up -d

Compose 会自动构建镜像（如果需要）、创建网络、启动所有定义的服务（web和redis），并处理好它们之间的依赖关系。-d表示后台运行。

其他常用命令：

docker-compose down：停止并删除所有容器、网络。
docker-compose logs -f web：查看web服务的日志并跟随输出。
docker-compose ps：查看当前项目下的容器状态。
docker-compose exec web bash：进入web服务的容器。

实操心得：将开发、测试、生产环境的配置分离。可以创建多个 Compose 文件，如docker-compose.yml（基础配置）、docker-compose.override.yml（开发环境覆盖配置，如绑定挂载源代码）、docker-compose.prod.yml（生产环境配置，如指定镜像版本、设置资源限制）。通过-f参数指定文件：docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d。

6.2 迈向生产：Kubernetes 简介

Docker Compose 非常适合单机环境下的多容器编排。但在生产环境中，我们通常需要在多台机器（集群）上部署和管理成千上万的容器，并实现高可用、自动伸缩、滚动更新等高级功能。这时就需要容器编排平台，而Kubernetes (K8s)是当前事实上的标准。

Kubernetes 是一个开源的容器编排系统，可以自动化容器的部署、扩展和管理。它引入了许多抽象概念：

Pod：K8s 的最小调度单元，可以包含一个或多个紧密关联的容器（它们共享网络和存储）。
Deployment：定义 Pod 的期望状态（如副本数、使用的镜像），K8s 会确保实际状态与期望状态一致，实现滚动更新和回滚。
Service：为一组 Pod 提供一个稳定的网络端点（IP 和 DNS 名称），实现负载均衡和服务发现。
Ingress：管理外部访问集群内部服务的 HTTP/HTTPS 路由。

虽然 Kubernetes 的学习曲线陡峭，但它是现代云原生应用的基石。yeasy/docker_practice一书的后半部分对 Kubernetes 有深入的介绍，是很好的入门材料。从 Docker 到 Docker Compose，再到 Kubernetes，是一条自然的进阶路径。

7. 常见问题与排查技巧实录

在实际使用 Docker 的过程中，你一定会遇到各种问题。这里记录一些我踩过的坑和解决方法。

7.1 镜像构建问题

问题1：构建缓慢，特别是RUN apt-get update或pip install步骤。

原因：网络问题或默认源速度慢。
解决：为包管理器更换国内镜像源。
- Ubuntu (apt)：在RUN apt-get update前添加换源命令。
```
RUN sed -i 's/archive.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list && \ sed -i 's/security.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list
```
- Python (pip)：使用-i参数指定镜像。
```
RUN pip install --no-cache-dir -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
```
- 通用：利用 Docker 的构建参数（--build-arg）来传递代理或镜像地址，提高构建环境的灵活性。

问题2：构建上下文过大，导致docker build发送数据慢。

原因：docker build .中的.会将当前目录所有文件发送给 Docker 守护进程。如果目录下有node_modules,.git, 日志等无用文件，会极大拖慢速度。
解决：在构建上下文根目录创建.dockerignore文件，语法类似.gitignore。
```
# .dockerignore .git node_modules *.log Dockerfile* docker-compose* README.md
```

7.2 容器运行时问题

问题3：容器启动后立即退出。

排查：
1. docker logs <container_id>：查看容器退出的原因，通常会有错误信息输出。
2. 检查CMD或ENTRYPOINT指定的命令是否存在且可执行。例如，如果CMD ["python", "app.py"]但app.py文件不存在，容器会立即退出。
3. 检查应用是否在前台运行。Docker 容器需要一个前台进程来保持运行。如果命令是启动一个后台服务（如service nginx start），那么命令执行完（启动了后台服务）后，主进程就结束了，容器也会退出。应该直接运行前台命令，如nginx -g 'daemon off;'。

问题4：容器内应用无法访问外部网络（如apt-get update失败）。

排查：
1. 检查宿主机的网络连接。
2. 检查 Docker 守护进程的 DNS 配置（/etc/docker/daemon.json）。可以配置为国内公共 DNS，如{"dns": ["114.114.114.114", "8.8.8.8"]}，修改后需要重启 Docker 服务。
3. 对于bridge网络模式的容器，检查iptables规则是否被其他软件（如某些防火墙或代理工具）干扰。

问题5：容器时间不正确。

原因：容器默认使用 UTC 时区。

解决：在 Dockerfile 中设置时区，或运行容器时挂载宿主机的时区文件。

# Dockerfile 方案 (Debian/Ubuntu) RUN ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' > /etc/timezone

# 运行容器时挂载 docker run -v /etc/localtime:/etc/localtime:ro -v /etc/timezone:/etc/timezone:ro ...

7.3 资源与性能问题

问题6：容器占用磁盘空间越来越大。

原因：
- 停止的容器、未被使用的镜像（悬空镜像）、构建缓存、数据卷都会占用空间。

清理命令：

docker system prune -a # 清理所有未使用的镜像、容器、网络和构建缓存（谨慎使用，会删除所有未被引用的镜像） docker volume prune # 清理未被任何容器引用的数据卷

定期清理是保持 Docker 环境健康的好习惯。

问题7：如何限制容器使用的资源？

解决：使用docker run的资源限制参数。

docker run -d \ --name my-container \ --memory=512m \ # 限制内存为 512 MB --cpus="1.5" \ # 限制使用 1.5 个 CPU 核心 --cpu-shares=512 \ # CPU 权重（默认 1024） nginx:alpine

在生产环境中，为容器设置合理的资源限制至关重要，可以防止单个容器耗尽主机资源，影响其他服务。

从最初对“容器”概念的模糊认知，到能够熟练地编写 Dockerfile、编排多服务应用，再到理解其背后的原理和生态，这个过程让我深刻体会到 Docker 带来的效率革命。它不仅仅是一个工具，更是一种新的软件交付和运维范式。yeasy/docker_practice这本书系统地串联起了这条学习路径。我个人的体会是，学习 Docker 一定要动手，从运行第一个hello-world容器开始，逐步尝试将自己的项目容器化，在实践中去理解镜像分层、数据卷、网络这些核心概念。遇到问题时，善用docker logs、docker exec进行调试，并查阅官方文档和社区资源。当你习惯了这种“一次构建，到处运行”的模式后，就再也回不去了。最后，记住安全最佳实践：使用非 root 用户运行容器进程、定期更新基础镜像、扫描镜像漏洞，让你的容器化之旅既高效又稳健。