Python 与 Docker 强强联合：从零开始容器化部署你的 Python 应用

3次阅读

共计 8973 个字符，预计需要花费 23 分钟才能阅读完成。

在当今快速发展的软件世界中，部署应用程序往往面临诸多挑战：环境依赖冲突、不同服务器配置差异、扩展性问题等。对于 Python 开发者而言，虚拟环境（venv、conda）虽然能在一定程度上解决依赖隔离，但当应用需要部署到生产环境时，这些问题会再次浮现。此时，容器化技术，尤其是 Docker，便成为了解决这些痛点的理想方案。

Python 以其简洁高效的特性，在 Web 开发、数据科学、机器学习等领域占据重要地位。而 Docker 则以其“构建一次，处处运行”的理念，彻底改变了应用打包、分发和运行的方式。当 Python 与 Docker 结合时，我们不仅能享受到 Python 开发的敏捷性，还能获得 Docker 带来的环境一致性、资源隔离、快速部署和轻松扩展等巨大优势。

本教程旨在为 Python 开发者提供一份全面、实用的指南，从基础概念入手，逐步深入，带你亲手将一个 Python 应用容器化，并利用 Docker Compose 管理多服务应用。无论你是初次接触 Docker，还是希望提升 Python 应用的部署效率，本文都将为你提供清晰的路径和可操作的步骤。让我们一起开启 Python 应用容器化的旅程吧！

Python 的强大在于其庞大的库生态系统，但这也带来了管理依赖的复杂性。不同的项目可能需要不同版本的 Python 解释器或特定库版本，这在本地开发环境或部署服务器上很容易引发“依赖地狱”问题。例如，一个项目需要 numpy==1.20.0，而另一个需要 numpy==1.22.0，在同一台机器上管理这些往往非常困难。

Docker 通过以下方式完美解决了这些问题：

环境一致性 ：Docker 容器包含应用运行所需的一切（代码、运行时、系统工具、库和配置）。这意味着无论在开发、测试还是生产环境，应用都运行在完全相同的环境中，极大地减少了“在我机器上能跑”的尴尬。
隔离性 ：每个 Docker 容器都是一个独立的、轻量级的运行环境。容器之间相互隔离，互不影响，即使一个容器出现问题，也不会影响其他容器的正常运行。
可移植性 ：Docker 镜像是一个自包含的可执行包，可以在任何安装了 Docker 的机器上运行，无需关心底层操作系统的差异。
快速部署与扩展 ：Docker 镜像的构建和启动速度非常快，结合容器编排工具（如 Docker Compose、Kubernetes），可以轻松实现应用的快速部署、水平扩展和滚动更新。
资源效率 ：相比于传统虚拟机，Docker 容器共享宿主机的操作系统内核，更加轻量级，启动更快，占用的系统资源更少。

对于 Python 应用，这意味着我们可以将 Python 解释器、所有 requirements.txt 中定义的依赖、应用代码以及任何必要的系统级库全部打包进一个 Docker 镜像。这样，我们的 Python 应用就能在一个“干净”且完全受控的环境中运行，极大地简化了开发、测试和部署的流程。

在开始容器化你的 Python 应用之前，首先需要安装 Docker。

Windows/macOS 用户 ：
- 访问 Docker 官方网站 (docker.com/products/docker-desktop) 下载并安装 Docker Desktop。Docker Desktop 包含了 Docker Engine、Docker CLI、Docker Compose 以及 Kitematic（GUI 工具）等所有你需要的东西。安装过程通常是图形界面的，遵循提示即可。
- 安装完成后，启动 Docker Desktop，确保 Docker 图标在系统托盘中显示为运行状态。
Linux 用户 ：
- 访问 Docker 官方文档 (docs.docker.com/engine/install)，选择你的 Linux 发行版（如 Ubuntu、CentOS 等），按照官方教程安装 Docker Engine。
- 安装完成后，你可以通过运行 docker run hello-world 来测试 Docker 是否成功安装并正常运行。如果看到“Hello from Docker!”的消息，说明一切正常。

此外，你还需要一个文本编辑器（如 VS Code、Sublime Text）和一个命令行终端。

为了演示容器化过程，我们先创建一个最简单的 Flask Web 应用。在你的项目目录下，创建以下文件：

1. app.py

# app.py
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return "Hello from Python Flask App in a Docker Container!"

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

这个 Flask 应用非常简单，它在根路径 / 上返回一个字符串。host='0.0.0.0' 是为了让应用能够监听来自容器外部的所有网络接口。

2. requirements.txt

Flask==2.3.2

这个文件列出了我们的应用所需的 Python 依赖及其版本。在实际项目中，你可能会有很多依赖。

现在，你的项目目录结构应该是这样的：

my-python-app/
├── app.py
└── requirements.txt

你可以在本地通过 pip install -r requirements.txt 和 python app.py 运行这个应用，然后在浏览器中访问 http://127.0.0.1:5000 验证其功能。

现在，我们有了 Python 应用，接下来是将其打包成一个 Docker 镜像。这个过程主要通过一个名为 Dockerfile 的文件来定义。

Dockerfile 是一个包含一系列指令的文本文件，Docker 引擎会按照这些指令一步步构建镜像。理解这些指令是编写高效 Dockerfile 的关键。

FROM <image>[:<tag>]：指定基础镜像。这是你构建镜像的起点。对于 Python 应用，通常会选择官方的 Python 镜像，例如 python:3.9-slim-buster。slim 版本更小，而 buster 指的是 Debian 操作系统版本。
WORKDIR /path/to/workdir：设置工作目录。后续的所有 RUN, CMD, ENTRYPOINT, COPY, ADD 指令都将在这个目录下执行。这有助于保持镜像的整洁和一致性。
COPY <source> <destination>：将本地文件或目录复制到镜像中。例如，COPY . . 会将当前构建上下文的所有内容复制到镜像的工作目录中。
RUN <command>：在镜像构建过程中执行命令。通常用于安装软件包、创建目录、设置权限等。每个 RUN 命令都会在镜像中创建一个新的层。
EXPOSE <port>：声明容器将监听的网络端口。这仅仅是文档性质的声明，并不会实际发布端口。要发布端口，需要在运行容器时使用 -p 或 --publish 标志。
ENV <key>=<value>：设置环境变量。这些环境变量在容器运行时可用。
CMD ["executable","param1","param2"]：提供容器启动时的默认命令。当容器启动时，如果未指定其他命令，CMD 命令将被执行。Dockerfile 中只能有一个 CMD。
ENTRYPOINT ["executable", "param1", "param2"]：提供容器启动时的入口点。ENTRYPOINT 也可以定义默认命令，但与 CMD 不同的是，ENTRYPOINT 定义的命令不会被 docker run 后面的参数覆盖，而是将 docker run 后面的参数作为其参数。在实际应用中，ENTRYPOINT 常用作执行脚本，CMD 则提供默认参数。
.dockerignore：类似于 .gitignore，用于指定在构建镜像时应忽略的文件和目录，避免将不必要的文件（如 .git 目录、__pycache__、venv 等）复制到镜像中，从而减小镜像大小，提高构建速度。

在 my-python-app 目录下，创建一个名为 Dockerfile 的文件（注意没有文件扩展名），并添加以下内容：

# Dockerfile

# 1. 选择一个官方的 Python 基础镜像
FROM python:3.9-slim-buster

# 2. 设置工作目录。所有后续操作都将在此目录中进行
WORKDIR /app

# 3. 将 requirements.txt 复制到工作目录
# 优先复制 requirements.txt 以利用 Docker 缓存层
COPY requirements.txt .

# 4. 安装 Python 依赖
# 使用 --no-cache-dir 和 --upgrade pip 优化安装
RUN pip install --no-cache-dir -r requirements.txt

# 5. 将当前目录（应用代码）复制到容器的工作目录
COPY . .

# 6. 暴露应用将监听的端口
EXPOSE 5000

# 7. 定义容器启动时执行的命令
# 这里使用 gunicorn 作为生产环境的 WSGI 服务器，更健壮
# CMD ["python", "app.py"] # 开发环境可以直接用 python app.py
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

注意：为了在生产环境中更好地运行 Flask 应用，我们通常会使用 Gunicorn 或 uWSGI 这样的 WSGI 服务器，而不是 Flask 自带的开发服务器。因此，如果你打算使用 Gunicorn，你需要将 Flask 的版本更新为 Flask==2.3.2 并在 requirements.txt 中添加 gunicorn==20.1.0。

更新后的 requirements.txt:

Flask==2.3.2
gunicorn==20.1.0

更新后的 Dockerfile 考虑了 Gunicorn，这对于生产环境来说是更好的实践。

有了 Dockerfile，我们就可以构建镜像了。在 my-python-app 目录（即 Dockerfile 所在的目录）中打开终端，执行以下命令：

docker build -t my-python-app:latest .

docker build：构建 Docker 镜像的命令。
-t my-python-app:latest：给构建的镜像打标签（tag）。my-python-app 是镜像的名称，latest 是标签（版本号）。你可以使用任何你喜欢的名称和标签。
.：表示 Dockerfile 所在的路径。. 代表当前目录。

执行命令后，Docker 会逐行执行 Dockerfile 中的指令，并在终端输出构建过程。如果一切顺利，你将看到成功构建的消息。

你可以通过 docker images 命令查看所有本地镜像，确认 my-python-app 镜像已经创建。

镜像构建成功后，我们就可以基于这个镜像创建并运行一个 Docker 容器了。

docker run -p 5000:5000 my-python-app:latest

docker run：运行 Docker 容器的命令。
-p 5000:5000：端口映射（ 宿主机端口: 容器端口 ）。这表示将宿主机的 5000 端口映射到容器内部的 5000 端口。这样，我们就可以通过访问宿主机的 5000 端口来访问容器中运行的应用程序。
my-python-app:latest：指定要运行的镜像名称和标签。

现在，在你的浏览器中访问 http://localhost:5000 (或 http://127.0.0.1:5000)，你应该能看到应用返回的 “Hello from Python Flask App in a Docker Container!” 消息。恭喜你，你的第一个 Python 应用已经在 Docker 容器中成功运行了！

要停止容器，可以在终端中按 Ctrl+C。如果想在后台运行容器，可以加上 -d 参数（docker run -d -p 5000:5000 my-python-app）。

实际的 Python 应用往往不止一个服务。例如，一个 Web 应用可能还需要一个数据库（如 PostgreSQL、MySQL）、一个缓存服务（如 Redis）或消息队列（如 RabbitMQ）。手动管理这些独立的容器会变得非常繁琐。

Docker Compose 是一个用于定义和运行多容器 Docker 应用程序的工具。通过一个 YAML 文件来配置所有应用的服务，然后只需一个命令，即可启动或停止所有服务。

简化多服务管理 ：在一个文件中定义所有服务，统一管理。
服务发现 ：Compose 会为所有服务创建一个网络，服务之间可以通过服务名互相通信。
环境隔离 ：每个 Compose 项目可以有自己的网络和卷，确保项目之间不冲突。

编写 `docker-compose.yml`

让我们扩展之前的 Flask 应用，加入一个 Redis 缓存服务，并使用 docker-compose.yml 来管理它们。

首先，更新 app.py 以使用 Redis：

更新 app.py

# app.py
from flask import Flask
from redis import Redis
import os

app = Flask(__name__)
# 从环境变量获取 Redis 主机名，默认为 'localhost'
# 在 Docker Compose 网络中，可以通过服务名直接访问
redis_host = os.getenv('REDIS_HOST', 'localhost')
redis = Redis(host=redis_host, port=6379)

@app.route('/')
def hello():
    # 每次访问增加计数
    count = redis.incr('hits')
    return f"Hello from Python Flask App in a Docker Container! I have been seen {count} times."

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

更新 requirements.txt

Flask==2.3.2
gunicorn==20.1.0
redis==4.6.0 # 添加 redis 库

现在，创建或修改项目根目录下的 docker-compose.yml 文件：

# docker-compose.yml
version: '3.8' # Docker Compose 文件格式版本

services:
  web:
    build: . # 指示 Docker Compose 在当前目录寻找 Dockerfile 并构建镜像
    ports:
      - "5000:5000" # 端口映射：宿主机 5000 端口映射到容器 5000 端口
    environment:
      - REDIS_HOST=redis # 设置环境变量，让 Flask 应用知道 Redis 服务的主机名
    depends_on:
      - redis # 声明 web 服务依赖于 redis 服务，redis 会在 web 之前启动

  redis:
    image: "redis:latest" # 使用官方的 Redis 镜像
    ports:
      - "6379:6379" # 暴露 Redis 端口，非必须，但方便调试
    volumes:
      - redis_data:/data # 持久化 Redis 数据到宿主机的命名卷

volumes:
  redis_data: # 定义一个命名卷用于 Redis 数据持久化

在 docker-compose.yml 所在的目录下，执行以下命令：

docker-compose up -d

docker-compose up：启动 docker-compose.yml 中定义的所有服务。
-d：在后台（detached mode）运行容器。

Docker Compose 会自动构建 web 服务的镜像（如果尚未构建或 Dockerfile 有更新），然后启动 redis 服务，最后启动 web 服务。

访问 http://localhost:5000，每次刷新页面，你都会看到访问计数器递增，这证明 Flask 应用已成功连接到 Redis 服务。

要停止并移除所有由 Docker Compose 创建的容器、网络和卷（如果未指定 volumes 则不会删除），执行：

docker-compose down

为了减小最终镜像的大小和提高安全性，推荐使用多阶段构建。在一个 Dockerfile 中使用多个 FROM 指令，将构建环境和运行时环境分离。

# Dockerfile (Multi-stage build example)

# --- 阶段 1: 构建阶段 ---
FROM python:3.9-slim-buster as builder

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# --- 阶段 2: 运行时阶段 ---
FROM python:3.9-slim-buster

WORKDIR /app

# 从构建阶段复制安装好的依赖和应用代码
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY --from=builder /app .

EXPOSE 5000
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "app:app"]

这样，最终的镜像中将只包含运行时所需的依赖和代码，构建工具和中间文件都不会被包含进来。

敏感信息（如数据库密码、API 密钥）不应硬编码在 Dockerfile 或代码中。应使用环境变量在运行时注入。

Dockerfile 中 ：使用 ENV 指令设置非敏感的默认环境变量。
docker run 时 ：使用 -e KEY=VALUE 参数。
docker-compose.yml 中 ：使用 environment 字段。
Docker Secrets/Vault：对于生产环境的敏感数据，推荐使用 Docker Secrets 或 HashiCorp Vault 等更安全的解决方案。

容器是短暂的，如果容器被删除，其内部的数据也会丢失。为了持久化数据，可以使用：

卷 (Volumes)：Docker 管理宿主机文件系统上的数据存储。这是推荐的持久化方式。
- 命名卷 (Named Volumes)：如 redis_data，由 Docker 管理。
- 绑定挂载 (Bind Mounts)：将宿主机的特定目录直接挂载到容器中，方便开发调试。例如：-v /path/to/host/data:/path/to/container/data。

容器的日志默认会输出到标准输出 (stdout) 和标准错误 (stderr)，Docker 会捕获这些日志。你可以使用 docker logs <container_id_or_name> 命令查看容器日志。在生产环境中，通常会将 Docker 日志收集到集中式日志管理系统（如 ELK Stack、Splunk）。

非 root 用户运行 ：默认情况下，容器以 root 用户运行。为提高安全性，可以在 Dockerfile 中创建一个非 root 用户并切换到该用户 (USER <username>)。
最小化镜像 ：使用 slim 或 alpine 版本的基础镜像，减少攻击面。
定期更新基础镜像 ：及时修补安全漏洞。
限制资源 ：为容器设置 CPU、内存等资源限制，防止单个容器耗尽宿主机资源。

Docker 容器化是 CI/CD 流程的理想选择。你可以将 Docker 镜像构建集成到你的 CI 工具（如 Jenkins、GitLab CI、GitHub Actions）中。每次代码提交时，自动构建新镜像，推送到镜像仓库（如 Docker Hub、阿里云容器镜像服务），然后由 CD 工具自动部署新版本的容器。

镜像构建失败 ：
- 检查 Dockerfile 语法错误。
- 查看 RUN 命令的输出，确认是否是依赖安装失败。
- 确保 requirements.txt 和其他复制的文件存在且路径正确。
容器启动失败 ：
- docker logs <container_id> 查看容器的启动日志，查找错误信息。
- 检查 CMD 或 ENTRYPOINT 命令是否正确。
- 确认应用监听的端口与 EXPOSE 和 -p 映射的端口是否一致。
端口冲突 ：
- 确保宿主机上没有其他进程占用你要映射的端口。可以使用 netstat -tulnp (Linux) 或 netstat -ano (Windows) 检查端口占用情况。
依赖安装问题 ：
- pip install 失败通常是由于网络问题或 Python 包本身的编译依赖（如 C 库）缺失。确保基础镜像包含必要的构建工具（如果不是 slim 版，通常会有）。
- 对于 slim 镜像，可能需要额外安装一些系统包，如 apt-get update && apt-get install -y build-essential。

通过本教程，你已经掌握了 Python 应用与 Docker 结合的核心方法。从基础的 Dockerfile 编写、镜像构建、容器运行，到使用 Docker Compose 管理多服务应用，你已经拥有了将 Python 应用带入容器化世界的基本技能。

容器化部署不仅解决了环境依赖和部署一致性问题，更为你的应用带来了前所未有的可移植性、可扩展性和效率。随着你对 Docker 和容器化技术的深入了解，你将能够更好地利用多阶段构建、数据持久化、安全性最佳实践等高级功能，构建更加健壮、高效和易于维护的 Python 应用。

未来，容器化技术与 Kubernetes 等容器编排平台的结合将是主流。掌握 Docker 容器化是迈向云原生应用开发的第一步。继续探索，你将在 DevOps 的道路上走得更远！

正文完

发表至： Python

近一天内

0

Python基础入门 Day96 单元测试与unittest模块

Python基础入门 Day65：字典的合并与更新技巧

Playwright 处理 iframe 元素详解：深入解析网页嵌套交互

了解 Playwright：Python 自动化测试与爬虫的新工具

基于 Django 搭建博客系统：深度实现用户认证与文章评论功能

Python 与 Docker 强强联合：从零开始容器化部署你的 Python 应用

引言：拥抱容器化，提升 Python 应用部署效率

Python 与 Docker 为何是天作之合？

准备工作：安装 Docker

构建一个简单的 Python 应用

核心步骤：容器化 Python 应用

Dockerfile 深度解析

编写你的第一个 Dockerfile

构建 Docker 镜像

运行你的容器

使用 Docker Compose 管理多服务应用

为何需要 Docker Compose？

编写 `docker-compose.yml`

运行多服务应用

进阶主题与最佳实践

1. 多阶段构建 (Multi-stage Builds)

2. 环境变量管理

3. 数据持久化 (Data Persistence)

4. 日志管理 (Logging)

5. 安全性考量 (Security Considerations)

6. CI/CD 集成 (CI/CD Integration)

常见问题排查

总结与展望

Playwright page.goto(url) 详解：深入解析网页导航的最佳实践

深度解析：基于 PyTorch 实现图像分类——从数据集构建到模型训练部署全攻略

Linux VPS 下 SSH 常用命令大集合，一文带你全掌握！

Python 基础入门 Day32

了解 Playwright：Python 自动化测试与爬虫的新工具

Playwright：现代 Web 自动化测试的终极方案

提升 Playwright 测试效率的 10 大技巧

Playwright 实战：模拟自动登录并抓取数据（以 GitHub 为例）

Python await 详解：从入门到精通

Python with 详解：从入门到精通

Python 与 Docker 强强联合：从零开始容器化部署你的 Python 应用

引言：拥抱容器化，提升 Python 应用部署效率

Python 与 Docker 为何是天作之合？

准备工作：安装 Docker

构建一个简单的 Python 应用

核心步骤：容器化 Python 应用

Dockerfile 深度解析

编写你的第一个 Dockerfile

构建 Docker 镜像

运行你的容器

使用 Docker Compose 管理多服务应用

为何需要 Docker Compose？

编写 docker-compose.yml

运行多服务应用

进阶主题与最佳实践

1. 多阶段构建 (Multi-stage Builds)

2. 环境变量管理

3. 数据持久化 (Data Persistence)

4. 日志管理 (Logging)

5. 安全性考量 (Security Considerations)

6. CI/CD 集成 (CI/CD Integration)

常见问题排查

总结与展望

编写 `docker-compose.yml`