Docker镜像定制实战：配置Yum源加速构建与Nginx服务部署

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

这次我们来看一个 Docker 基础实战主题：如何定制一个简单的镜像，并在容器内部配置 Yum 仓库，最终完成服务的安装与部署。这听起来像是基础操作，但很多人在实际构建时，往往会卡在“镜像构建慢”、“容器内软件安装失败”或“服务部署后无法访问”这几个环节。这篇文章的核心就是解决这些问题，让你能快速构建一个稳定、高效且可复用的 Docker 服务镜像。

我们将重点关注三个核心环节： 定制镜像 、 容器内配置 Yum 源 、 服务部署 。整个过程不依赖复杂的编排工具，只用最基础的 Docker 命令和 Dockerfile，目标是让你在本地或服务器上，从零开始跑通一个可用的服务容器。无论你是想部署一个简单的 Web 应用、一个数据库，还是一个自定义的后台服务，这套流程都是通用的基础。

本文会带你完成从环境准备、编写 Dockerfile、配置加速 Yum 源、安装服务到最终运行和验证的全过程。我们会使用一个具体的示例（例如部署一个 Nginx 服务）来演示，但方法适用于绝大多数基于 CentOS/RHEL 系镜像的服务。如果你关心如何提升 Docker 镜像构建速度、如何确保容器内环境一致性，或者如何将本地服务容器化，那么这篇文章可以直接收藏备用。

1. 核心能力速览

在深入细节之前，我们先快速了解通过本文你将掌握的核心技能和所需条件。

2. 适用场景与使用边界

这个教程适合谁？

• Docker 初学者 ：想通过一个完整案例理解 Dockerfile 编写、镜像构建和容器运行的整个流程。
• 运维与开发人员 ：需要为项目制作一个包含特定服务和配置的基础镜像，确保开发、测试、生产环境的一致性。
• 遇到构建慢问题的用户 ：在构建基于 CentOS/RHEL 的镜像时，受限于默认海外源速度，希望切换到国内镜像源加速。
• 需要快速部署简单服务的人 ：例如想在容器内快速启动一个 Nginx 来做反向代理测试，或者运行一个简单的 Python Flask 应用。

能解决什么问题？

1. 环境标准化 ：通过 Dockerfile 定义环境，避免“在我机器上是好的”问题。
2. 构建提速 ：通过配置国内 Yum 源，显著减少 yum install 的等待时间。
3. 一键部署 ：将复杂的安装配置步骤固化到镜像中，实现 docker run 即可获得一个运行中的服务。
4. 资源隔离 ：服务运行在容器中，与宿主机环境隔离，便于管理和清理。

不适合什么场景？

• 超复杂应用 ：涉及多个服务紧密耦合、需要特殊内核模块或特定硬件直通的复杂系统，可能需要 Docker Compose 或 Kubernetes。
• 对镜像体积极度敏感 ：本文使用 CentOS 基础镜像，体积较大。如果追求极致小体积，应考虑 Alpine Linux 等基础镜像。
• Windows 专属应用 ：教程以 Linux 容器为核心，不涉及 Windows 容器内的 MSI 安装等操作。

安全与合规边界：

• 确保从官方或可信源获取基础镜像（如 centos:7 ）。
• 在 Dockerfile 中安装软件时，注意软件包的来源可信。
• 如果部署的服务涉及网络端口，请注意宿主机防火墙规则，避免不必要的端口暴露。
• 容器内服务的数据如需持久化，应使用 Docker 卷（Volume）绑定到宿主机，避免数据丢失。

3. 环境准备与前置条件

开始之前，请确保你的操作环境满足以下要求。这是后续所有操作能成功的基础。

1. 操作系统

• 推荐 ：任何安装了 Docker 的 Linux 发行版（如 Ubuntu, CentOS, Debian）。
• 也可用 ： macOS（通过 Docker Desktop）， Windows 10/11（通过 Docker Desktop WSL 2 后端）。
• 本文命令示例在 Linux 环境下演示，macOS/Windows 在终端或 PowerShell 中操作逻辑一致。

2. Docker 环境

• 必须已安装 Docker Engine 或 Docker Desktop。可通过以下命令验证：

docker --version

• 确保 Docker 服务正在运行：

sudo systemctl status docker  # Linux systemd
# 或
docker info

3. 网络连接

• 构建镜像时需要从 Docker Hub 拉取基础镜像（如 centos:7 ），需要网络通畅。
• 后续配置 Yum 源时，需要能访问你选择的国内镜像站（如阿里云、腾讯云镜像源）。

4. 磁盘空间

• 预留至少 1-2 GB 的可用磁盘空间，用于存放基础镜像、安装的软件包及生成的镜像层。

5. 权限

• 在 Linux 上，非 root 用户需要将自身加入 docker 用户组，或使用 sudo 来执行 Docker 命令。
• 在 macOS/Windows 的 Docker Desktop 中，通常已配置好权限。

检查清单：

• [ ] Docker 已安装且版本大于 18.06。
• [ ] Docker 服务状态为 active (running) 。
• [ ] 可以正常执行 docker run hello-world 并看到欢迎信息。
• [ ] 当前用户有权限执行 Docker 命令（非 Permission denied ）。

4. 安装部署与启动方式

我们的目标不是安装 Docker，而是从零开始创建一个自定义镜像并运行容器。整个过程分为三步： 编写 Dockerfile -> 构建镜像 -> 运行容器 。

4.1 创建项目目录与 Dockerfile

首先，创建一个干净的工作目录，用于存放所有构建文件。

mkdir docker-custom-image-demo && cd docker-custom-image-demo

接下来，创建最重要的文件 Dockerfile 。这个文件定义了镜像的构建步骤。

# Dockerfile
# 使用 CentOS 7 作为基础镜像
FROM centos:7

# 维护者信息（可选）
LABEL maintainer="your-email@example.com"

# 1. 备份默认的 yum 源配置文件
RUN mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup

# 2. 配置阿里云 yum 源（国内加速）
# 注意：这里直接使用 curl 下载，如果容器内没有 curl，可以先安装或使用 wget
RUN curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo

# 3. 清理缓存并生成新缓存（可选，但推荐）
RUN yum clean all && yum makecache

# 4. 安装我们需要的服务，这里以 nginx 为例
RUN yum install -y nginx

# 5. 暴露服务端口（nginx 默认使用 80 端口）
EXPOSE 80

# 6. 设置容器启动时执行的命令
# 这里以前台方式启动 nginx，保证容器不会立即退出
CMD ["nginx", "-g", "daemon off;"]

关键步骤解析：

• FROM centos:7 ：指定基础镜像。这是所有操作的起点。
• RUN mv ... 和 RUN curl ... ：这两个命令完成了 Yum 源的替换。将官方源备份，然后下载阿里云的 CentOS 7 源配置文件。这是 加速构建的关键 。
• RUN yum clean all && yum makecache ：清理旧缓存并从新源生成缓存，确保后续安装使用新源。
• RUN yum install -y nginx ：使用配置好的 Yum 源安装 Nginx 服务。“-y”参数表示自动确认安装。
• EXPOSE 80 ：声明容器运行时监听的端口。这只是一个元数据，方便使用者知道端口信息。
• CMD ["nginx", "-g", "daemon off;"] ：指定容器启动后默认执行的命令。 daemon off; 让 Nginx 在前台运行，这是保持容器存活的标准做法。

4.2 构建自定义镜像

在包含 Dockerfile 的目录下，执行构建命令。

# -t 参数为镜像打标签，格式为 name:tag
# 最后的 . 表示使用当前目录下的 Dockerfile
docker build -t my-custom-nginx:1.0 .

构建过程观察： 执行命令后，Docker 引擎会逐行执行 Dockerfile 中的指令，每一行指令都会生成一个临时的中间容器，执行命令后提交为一个镜像层。你会看到类似下面的输出：

Sending build context to Docker daemon  2.048kB
Step 1/8 : FROM centos:7
 ---> eeb6ee3f44bd
Step 2/8 : LABEL maintainer="your-email@example.com"
 ---> Running in xxxxx
 ---> yyyyy
Step 3/8 : RUN mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup
 ---> Running in zzzzz
 ---> aaaaa
...
Step 7/8 : EXPOSE 80
 ---> Running in bbbbb
 ---> ccccc
Step 8/8 : CMD ["nginx", "-g", "daemon off;"]
 ---> Running in ddddd
 ---> 123456789abc
Successfully built 123456789abc
Successfully tagged my-custom-nginx:1.0

重点看 ：如果 Step 4 （ RUN curl ... ）和 Step 6 （ RUN yum install ... ）执行速度明显快于你之前的体验，说明国内 Yum 源配置生效了。

4.3 运行容器并访问服务

镜像构建成功后，就可以基于它创建并运行容器了。

# 运行容器
# -d: 后台运行
# -p 8080:80: 将宿主机的 8080 端口映射到容器的 80 端口
# --name: 给容器起一个名字，便于管理
docker run -d -p 8080:80 --name my-nginx-container my-custom-nginx:1.0

运行后，使用以下命令检查容器状态：

docker ps

你应该能看到名为 my-nginx-container 的容器处于 Up 状态。

现在，打开你的浏览器，访问 http://localhost:8080 （如果宿主机是 Linux 服务器，则访问 http://<服务器IP>:8080 ）。如果看到 Nginx 的欢迎页面，恭喜你，一个定制了 Yum 源并安装了 Nginx 服务的 Docker 容器已经成功运行！

5. 功能测试与效果验证

构建和运行只是第一步，我们需要验证镜像的功能是否符合预期，并测试其在实际使用中的效果。

5.1 验证 Yum 源是否生效

我们可以在容器内执行命令，验证 Yum 源是否已成功替换为阿里云源。

# 进入正在运行的容器内部执行命令
docker exec -it my-nginx-container bash

# 进入容器后，查看 yum 源配置文件
cat /etc/yum.repos.d/CentOS-Base.repo | head -20

# 你应该能看到文件中包含 mirrors.aliyun.com 的 URL
# 例如：baseurl=http://mirrors.aliyun.com/centos/$releasever/os/$basearch/

# 可以尝试更新一下包列表（在容器内）
yum check-update
# 观察速度，理论上应该比默认源快很多。

# 退出容器
exit

5.2 验证服务安装与运行

我们已经通过浏览器访问验证了 Nginx 服务。也可以通过命令行验证：

# 查看容器内 nginx 进程
docker exec my-nginx-container ps aux | grep nginx
# 应该能看到 nginx: master process 和 worker processes。

# 查看容器日志，确认启动无报错
docker logs my-nginx-container
# 输出应包含 “started” 或类似成功信息，没有 “ERROR” 或 “failed”。

5.3 测试镜像的可复用性

Docker 镜像的核心价值在于可复用。我们可以停止并删除当前容器，然后用同一个镜像重新启动一个全新的容器。

# 停止并删除旧容器
docker stop my-nginx-container
docker rm my-nginx-container

# 用同一个镜像启动一个新容器，映射到不同端口
docker run -d -p 8081:80 --name another-nginx my-custom-nginx:1.0

# 访问 http://localhost:8081，应该看到同样的 Nginx 欢迎页。

这个测试证明了 my-custom-nginx:1.0 这个镜像是一个稳定的模板，可以随时创建出环境完全一致的新容器。

5.4 验证构建速度提升（对比测试）

为了直观感受配置国内源带来的速度提升，我们可以做一个简单的对比实验。

1. 创建另一个不使用国内源的 Dockerfile ，命名为 Dockerfile.slow ：

   FROM centos:7
   RUN yum install -y nginx
   EXPOSE 80
   CMD ["nginx", "-g", "daemon off;"]
   

2. 分别构建两个镜像并计时 （使用 time 命令）：

   # 构建使用国内源的镜像（已构建过，有缓存，可能很快）
   # 为了公平，先删除旧镜像和构建缓存
   docker rmi my-custom-nginx:1.0
   docker builder prune -f
   time docker build -t my-custom-nginx:1.0 -f Dockerfile .
   
   # 构建使用默认源的镜像
   time docker build -t nginx-slow:1.0 -f Dockerfile.slow .
   

   对比两个 time 命令输出的 real （实际花费时间）字段。在网络条件一般的情况下，使用国内源的构建时间通常会显著缩短，尤其是在 yum install 步骤。

6. 接口 API 与批量任务

虽然本文示例部署的是 Nginx（一个 Web 服务器），但此模式适用于任何可以通过包管理器安装的服务。这里我们扩展一下，看看如何部署一个提供 HTTP API 的简单服务（例如 Python Flask 应用），以及如何实现“批量”创建同类容器。

6.1 部署一个简单的 Python Flask API 服务

我们创建一个新的 Dockerfile，用于部署一个 Python Flask 应用。

1. 创建应用文件 app.py ：

   # app.py
   from flask import Flask
   app = Flask(__name__)
   
   @app.route('/')
   def hello():
       return 'Hello, Docker with custom Yum repo!'
   
   @app.route('/api/health')
   def health():
       return {'status': 'ok'}, 200
   
   if __name__ == '__main__':
       app.run(host='0.0.0.0', port=5000)
   

2. 创建新的 Dockerfile Dockerfile.flask ：

   FROM centos:7
   LABEL maintainer="dev@example.com"
   
   # 1. 配置阿里云 yum 源
   RUN mv /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup && \
       curl -o /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo && \
       yum clean all && yum makecache
   
   # 2. 安装 Python3 和 pip
   RUN yum install -y python3 python3-pip
   
   # 3. 将应用代码复制到容器内
   COPY app.py /opt/app.py
   
   # 4. 安装 Python 依赖（这里只有 Flask）
   RUN pip3 install flask -i https://pypi.tuna.tsinghua.edu.cn/simple
   
   # 5. 暴露 Flask 默认端口
   EXPOSE 5000
   
   # 6. 设置工作目录和启动命令
   WORKDIR /opt
   CMD ["python3", "app.py"]
   

   注意：这里也使用了清华 PyPI 源加速 pip 安装，这是另一个加速技巧。

3. 构建并运行 Flask 镜像 ：

   docker build -t my-flask-app:1.0 -f Dockerfile.flask .
   docker run -d -p 5000:5000 --name flask-api my-flask-app:1.0
   

4. 测试 API ：

   curl http://localhost:5000/
   # 输出：Hello, Docker with custom Yum repo!
   curl http://localhost:5000/api/health
   # 输出：{"status":"ok"}
   

   这样，我们就拥有了一个提供简单 API 的容器化服务。

6.2 批量任务：基于同一镜像启动多个容器

“批量任务”在 Docker 语境下，通常指基于同一个镜像快速创建多个独立运行的容器实例。这在负载测试、微服务多实例部署时很有用。

假设我们需要启动 3 个独立的 Nginx 容器，每个监听不同的宿主机端口。

# 使用一个简单的 Shell 循环
for i in {1..3}; do
  docker run -d \
    -p 808${i}:80 \
    --name nginx-instance-${i} \
    my-custom-nginx:1.0
done

# 验证
docker ps --filter "name=nginx-instance"
# 应该看到 3 个容器在运行。

# 分别访问它们
curl -I http://localhost:8081
curl -I http://localhost:8082
curl -I http://localhost:8083
# 都应返回 200 OK。

关键点 ：批量创建的核心是镜像要足够“干净”和“标准化”。我们的 my-custom-nginx:1.0 镜像已经包含了全部依赖和配置，所以启动新容器时只需映射不同端口即可，无需重复安装步骤，速度极快。

7. 资源占用与性能观察

了解容器运行时的资源消耗，对于评估和优化部署很重要。

7.1 观察容器资源占用

使用 docker stats 命令可以实时查看所有运行中容器的资源使用情况。

docker stats

输出示例：

CONTAINER ID   NAME                 CPU %     MEM USAGE / LIMIT     MEM %     NET I/O           BLOCK I/O   PIDS
a1b2c3d4e5f6   my-nginx-container   0.00%     5.5MiB / 1.94GiB     0.28%     1.05kB / 0B       0B / 0B     2

• MEM USAGE ：容器内存使用量。一个简单的 Nginx 容器通常只占用几 MB 到几十 MB。
• CPU % ：CPU 使用率。空闲时接近 0%。
• PIDS ：容器内的进程数。Nginx 通常有 1 个 master 进程和 1 个或多个 worker 进程。

7.2 镜像体积分析

镜像体积影响拉取速度和磁盘占用。使用 docker images 查看。

docker images my-custom-nginx

你会看到 my-custom-nginx:1.0 的体积。由于基于 centos:7 （约 200MB），加上 Nginx 及其依赖，最终镜像可能在 250MB - 300MB 左右。相比 Alpine 镜像（~5MB）大很多，但 CentOS 镜像兼容性更好，更适合企业内部使用。

优化体积的建议：

1. 合并 RUN 指令 ：将多个 RUN 命令用 && 连接，减少镜像层数。

   # 优于分开写
   RUN yum update -y && \
       yum install -y nginx && \
       yum clean all
   

2. 清理缓存 ：在安装软件包的同一条 RUN 指令中执行 yum clean all ，避免缓存文件被保存到镜像层。
3. 使用更小的基础镜像 ：如果应用兼容，考虑使用 centos:7-slim 或 alpine:latest 。

7.3 网络性能

容器内配置了国内 Yum 源， 这仅影响镜像构建阶段 （ docker build ）的下载速度。容器运行时的网络性能（如 Nginx 处理请求、Flask API 响应）取决于宿主机网络和容器网络配置（如 bridge , host 模式），与构建时的 Yum 源无关。

8. 常见问题与排查方法

在实践过程中，你可能会遇到以下问题。这里提供排查思路和解决方案。

9. 最佳实践与使用建议

基于以上实践，总结几条在定制 Docker 镜像和部署服务时的最佳实践：

1. 始终指定镜像标签 ：在 FROM 指令中，不要使用 latest 标签，而应使用具体版本，如 centos:7 。这能保证构建环境的一致性。
2. 构建加速是必须项 ：在 Dockerfile 开头就配置国内软件源（Yum, Apt, Pip, Npm 等），这能极大提升团队协作和 CI/CD 的效率。
3. 合并与清理 ：将相关的 RUN 指令合并，并在同一层中清理包管理器的缓存，以减小最终镜像体积。

   RUN yum install -y nginx httpd-tools && \
       yum clean all && \
       rm -rf /var/cache/yum/*
   

4. 使用非 root 用户运行 （安全性）：在安装完软件后，创建并切换到一个非 root 用户来运行应用。

   RUN groupadd -r appuser && useradd -r -g appuser appuser
   USER appuser
   CMD ["nginx", "-g", "daemon off;"]
   

5. 明确暴露端口 ：使用 EXPOSE 指令声明容器监听的端口，这是良好的文档习惯。
6. 利用 .dockerignore 文件 ：在构建上下文目录创建 .dockerignore 文件，排除不需要的文件（如 .git , __pycache__ , node_modules ），加速构建和避免敏感信息泄露。
7. 分层构建与缓存利用 ：Docker 会缓存每一层。将变化频率低的层（如配置源、安装系统工具）放在 Dockerfile 前面，变化频率高的层（如复制应用代码）放在后面，可以充分利用缓存加速构建。
8. 日志与健康检查 ：对于服务类容器，确保应用日志输出到标准输出（stdout/stderr），便于 docker logs 查看。复杂的服务可以考虑添加 HEALTHCHECK 指令。
9. 数据持久化 ：容器内产生的需要持久化的数据（如数据库文件、上传内容），务必通过 -v 参数挂载宿主机目录或使用 Docker Volume，避免容器删除后数据丢失。
10. 先本地测试，再上传仓库 ：在本地完成完整的构建、运行、功能测试后，再将镜像推送到 Docker Hub 或私有仓库。

10. 总结与下一步

通过这个完整的流程，我们掌握了 Docker 镜像定制的核心： 从基础镜像出发，通过 Dockerfile 固化环境配置（如换源），安装所需服务，并定义启动方式 。配置国内 Yum 源这个看似简单的步骤，是提升团队开发效率和构建稳定性的关键一环。

最值得尝试的下一步：

1. 替换其他服务 ：将示例中的 Nginx 换成你实际需要的服务，如 MySQL、Redis、Tomcat 或一个自定义的 Go/Java 应用，重复此流程。
2. 尝试多阶段构建 ：如果你的应用是编译型语言（如 Go），研究如何使用多阶段构建来生成更小、更安全的最终镜像。
3. 集成到 CI/CD ：将这份 Dockerfile 提交到 Git，并在 Jenkins、GitLab CI 或 GitHub Actions 中配置自动化构建和推送，实现镜像的持续集成。
4. 使用 Docker Compose ：当你需要同时运行多个关联容器（如 Web 应用 + 数据库）时，学习使用 docker-compose.yml 来定义和启动整个服务栈，这是从单容器迈向服务编排的第一步。

最容易踩的坑回顾：

• 网络问题 ：构建时下载慢或失败，首要检查 Yum/Pip 源配置。
• 容器退出 ：服务启动后容器立刻退出，检查 CMD 命令是否为前台持久运行。
• 端口访问不通 ：先确保容器内服务能 curl localhost 访问，再排查宿主机端口映射和防火墙。

把这个定制镜像、配置源、部署服务的流程跑通，你就拥有了将任何传统应用“容器化”的基础能力。建议将本文中的 Dockerfile 作为模板保存，以后遇到新服务时，在此基础上修改，能节省大量摸索时间。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度