《Docker 简易速速上手小册》第3章 Dockerfile 与镜像构建（2024 最新版）

在这里插入图片描述

文章目录

  • 3.1 编写 Dockerfile
    • 3.1.1 重点基础知识
    • 3.1.2 重点案例：创建简单 Python 应用的 Docker 镜像
    • 3.1.3 拓展案例 1：Dockerfile 优化
    • 3.1.4 拓展案例 2：多阶段构建
  • 3.2 构建流程深入解析
    • 3.2.1 重点基础知识
    • 3.2.2 重点案例：构建 Python 应用的 Docker 镜像
    • 3.2.3 拓展案例 1：优化 Docker 构建上下文
    • 3.2.4 拓展案例 2：利用多阶段构建优化镜像
  • 3.3 镜像构建的最佳实践
    • 3.3.1 重点基础知识
    • 3.3.2 重点案例：构建轻量级的 Python Web 应用镜像
    • 3.3.3 拓展案例 1：优化 Dockerfile 结构
    • 3.3.4 拓展案例 2：多阶段构建的复杂 Python 应用

3.1 编写 Dockerfile

Dockerfile 是 Docker 镜像构建的核心，它就像是制作美食的食谱，告诉 Docker 如何一步步构建出你需要的镜像。让我们深入了解 Dockerfile 的基础知识，并通过一些实际案例来展示它的强大功能。

3.1.1 重点基础知识

深入理解 Dockerfile 的构成和最佳实践对于高效创建和管理 Docker 镜像非常重要。以下是 Dockerfile 编写的一些关键概念和技巧：

  1. 精简基础镜像:

    • 选择适当的基础镜像是关键。例如，对于 Python 应用，python:3.8-slim 或 python:3.8-alpine 是比 python:3.8 更轻量级的选择。

  2. 避免不必要的层:

    • 每个 Dockerfile 指令都会创建一个新的镜像层。过多的层会增加镜像的大小。通过合并指令和清理不必要的文件，可以减少镜像层的数量。

  3. 使用 .dockerignore 文件:

    • 类似于 .gitignore，.dockerignore 文件可以指定在构建过程中忽略的文件和目录，减少构建上下文的大小，加快构建速度。

  4. 多阶段构建:

    • 多阶段构建允许你在一个 Dockerfile 中使用多个 FROM 指令，每个阶段可以使用不同的基础镜像。这对于优化镜像大小和构建速度非常有效。

  5. 利用缓存机制:

    • Docker 会缓存每一步的结果，如果 Dockerfile 的某一部分没有更改，Docker 将重用这一部分的缓存。合理安排 Dockerfile 中指令的顺序，可以最大化地利用缓存。

  6. 参数化 Dockerfile:

    • 使用 ARG 和 ENV 指令可以使 Dockerfile 更灵活。ARG 用于构建时设置变量，ENV 用于设置容器运行时的环境变量。

  7. 健康检查:

    • 使用 HEALTHCHECK 指令可以让 Docker 定期检查容器的健康状态，这对于确保长时间运行的服务稳定性非常重要。

通过掌握这些基础知识，你将能够编写更高效、更专业的 Dockerfile，从而构建出性能更优、更安全且易于维护的 Docker 镜像。这些技巧对于任何使用 Docker 进行应用部署和管理的开发者或系统管理员来说都是非常宝贵的。

3.1.2 重点案例：创建简单 Python 应用的 Docker 镜像

让我们通过一个实际案例来学习如何为一个简单的 Python 应用创建 Docker 镜像。我们将从编写一个基本的 Python 脚本开始，然后创建一个 Dockerfile，并最终构建并运行该镜像。

步骤 1: 创建 Python 脚本

首先，我们需要一个简单的 Python 脚本作为我们应用的核心。在你的工作目录中，创建一个名为 hello.py 的文件，并添加以下内容：

# hello.py
def main():print("Hello, Docker World!")if __name__ == "__main__":main()

这个脚本定义了一个打印欢迎信息的 main 函数。

步骤 2: 编写 Dockerfile

接下来，我们需要创建一个 Dockerfile 来定义如何在 Docker 容器中运行这个脚本。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方 Python 运行时作为基础镜像
FROM python:3.8-slim# 将工作目录设置为 /app
WORKDIR /app# 将当前目录中的文件复制到容器的 /app 目录
COPY hello.py /app/# 定义容器启动时执行的命令
CMD ["python", "./hello.py"]

这个 Dockerfile 从 Python 3.8 官方镜像开始，创建了一个工作目录 /app，然后将我们的 hello.py 脚本复制到这个目录中。最后，它定义了容器启动时执行的命令。

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t hello-python-app .

这个命令会根据 Dockerfile 构建一个名为 hello-python-app 的镜像。

步骤 4: 运行 Docker 容器

一旦镜像构建完成，我们可以运行一个基于该镜像的容器：

docker run hello-python-app

执行这个命令后，Docker 会启动一个新的容器实例，容器会运行 hello.py 脚本，并在控制台输出 “Hello, Docker World!”。

通过这个案例，你学会了如何为一个简单的 Python 应用创建 Docker 镜像，并运行它。这个过程展示了从编写应用代码、创建 Dockerfile 到构建和运行 Docker 镜像的完整流程，是理解 Docker 容器化应用的基础。

3.1.3 拓展案例 1：Dockerfile 优化

在这个案例中，我们将通过优化一个现有的 Dockerfile 来减小 Python 应用的 Docker 镜像大小，并提高构建效率。这个过程是 Dockerfile 编写的重要部分，它可以确保你的镜像尽可能高效和轻量。

步骤 1: 创建初始 Python 应用

假设我们有一个简单的 Python 应用，它使用了几个外部库。在你的工作目录中，创建一个 app.py 和 requirements.txt：

  • app.py:

    # app.py
import flask
import pandas as pdprint("Hello, optimized Docker World!")

  • requirements.txt:

    flask
pandas

步骤 2: 编写初始 Dockerfile

创建一个初始的 Dockerfile，未进行优化：

# 初始 Dockerfile
FROM python:3.8COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txtCOPY app.py .CMD ["python", "./app.py"]

步骤 3: 优化 Dockerfile

接下来，我们对 Dockerfile 进行优化，以减少镜像大小和提高构建速度：

# 优化后的 Dockerfile
FROM python:3.8-slim# 安装依赖时一并清理缓存，减少镜像层大小
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt && \rm -rf /var/lib/apt/lists/*# 仅复制所需文件
COPY app.py .CMD ["python", "./app.py"]

在这个优化后的 Dockerfile 中，我们做了以下几点改进：

  • 切换到更轻量级的基础镜像 python:3.8-slim。
  • 在安装依赖后清理不必要的文件，如 APT 缓存。
  • 确保仅复制所需的文件到镜像中。

步骤 4: 重新构建并运行优化后的镜像

使用以下命令重新构建镜像，并观察大小的变化：

docker build -t optimized-python-app .

运行优化后的镜像：

docker run optimized-python-app

通过这个案例，你可以看到 Dockerfile 优化的重要性，以及如何通过简单的调整减小镜像大小并提升构建效率。这种优化对于提升应用的部署和运行效率至关重要，尤其是在生产环境中。

3.1.4 拓展案例 2：多阶段构建

在这个案例中，我们将使用 Docker 的多阶段构建来优化一个稍微复杂的 Python 应用的 Docker 镜像。多阶段构建可以帮助我们构建出更小、更安全的生产级镜像。

步骤 1: 准备 Python 应用

假设我们有一个 Python 应用，它不仅需要运行时依赖，还需要编译时依赖。在你的工作目录中，创建以下文件：

  • app.py:

    # app.py
import pandas as pdprint("Hello from a multi-stage Dockerized Python App!")

  • requirements.txt:

    pandas

步骤 2: 编写多阶段 Dockerfile

我们将创建一个 Dockerfile，它包含两个阶段：构建阶段和最终阶段。

# 第一阶段：构建阶段
FROM python:3.8 as builderWORKDIR /appCOPY requirements.txt .# 安装所有依赖
RUN pip install --user -r requirements.txt# 第二阶段：最终阶段
FROM python:3.8-slimWORKDIR /app# 从构建阶段复制已安装的 Python 依赖
COPY --from=builder /root/.local /root/.localCOPY app.py .# 确保在运行时使用的是用户安装的库
ENV PATH=/root/.local:$PATHCMD ["python", "./app.py"]

在这个 Dockerfile 中，第一阶段使用了完整的 Python 镜像来安装所有依赖。第二阶段则基于更轻量级的 python:3.8-slim 镜像，并从第一阶段复制了已安装的依赖。

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t multi-stage-python-app .

这个命令会根据多阶段 Dockerfile 构建一个名为 multi-stage-python-app 的镜像。

步骤 4: 运行 Docker 容器

运行以下命令来启动 Python 应用：

docker run multi-stage-python-app

这个命令启动了一个基于新构建的镜像的容器。

通过这个案例，你可以看到多阶段构建在优化 Docker 镜像大小方面的巨大优势。这对于减少生产环境中的资源占用、加快镜像下载和部署速度非常关键。同时，它也提高了安全性，因为最终的镜像中不包含仅用于构建阶段的工具和文件。

通过这些案例，你不仅会学会编写基本的 Dockerfile，还会掌握如何优化和提高 Docker 镜像的效率，这对于提高应用的部署速度和安全性至关重要。

3.2 构建流程深入解析

探究 Docker 镜像构建流程的细节不仅是一项技术挑战，更像是解开神秘盒子的过程。在这一节中，我们将深入探索 Docker 镜像构建的内在机制，从而有效地掌握和优化构建过程。

3.2.1 重点基础知识

深入了解 Docker 镜像构建流程的细节对于有效地创建高质量的 Docker 镜像至关重要。下面是一些关于 Docker 镜像构建过程的进一步基础知识：

  1. Dockerfile 指令详解:

    • FROM: 指定基础镜像，是构建过程的起点。
    • RUN: 执行命令并创建新的镜像层，用于安装软件、修改配置等。
    • COPY 和 ADD: 用于将文件从宿主机复制到镜像。ADD 具有自动解压缩功能，但通常推荐使用更简单的 COPY。
    • CMD 和 ENTRYPOINT: 指定容器启动时默认执行的命令。CMD 可被 docker run 后的命令行参数覆盖，而 ENTRYPOINT 则不会。

  2. 层的合并与优化:

    • 虽然每个指令都会创建一个新的层，但 Docker 在最终镜像中会尽可能合并层来减少总大小。
    • 通过合并多个 RUN 指令来减少层的数量，例如使用 && 连接多个命令。

  3. 利用 ONBUILD 指令:

    • ONBUILD 指令用于设置当镜像作为另一个构建的基础时将执行的操作。这对于创建基础镜像非常有用。

  4. 避免安装不必要的包:

    • 只安装应用运行所必需的包和库，避免不必要的额外安装，可以显著减少镜像大小。

  5. 使用 ARG 和 ENV:

    • ARG 用于定义构建阶段的变量，而 ENV 用于设置容器环境变量。适当使用这些指令可以增加 Dockerfile 的灵活性和可配置性。

通过掌握这些高级技巧和最佳实践，你将能够创建出更加高效、安全且易于维护的 Docker 镜像。这些知识不仅有助于优化你的开发和部署流程，还能提升整个团队的工作效率和产品质量。

3.2.2 重点案例：构建 Python 应用的 Docker 镜像

让我们通过一个具体的案例来学习如何为一个 Python 应用构建 Docker 镜像。我们将从编写一个简单的 Python 应用开始，然后创建一个 Dockerfile，并最终构建并运行该镜像。

步骤 1: 创建 Python 应用

首先，我们创建一个 Python 应用。在你的工作目录中，创建一个名为 app.py 的文件，并添加以下内容：

# app.py
import flask
from flask import Flaskapp = Flask(__name__)@app.route('/')
def hello_world():return 'Hello, Dockerized World!'if __name__ == '__main__':app.run(host='0.0.0.0', port=5000)

这段代码创建了一个简单的 Flask 应用，它在根 URL (/) 上返回一条欢迎消息。

步骤 2: 编写 Dockerfile

接下来，创建一个 Dockerfile 来定义如何在 Docker 容器中运行这个 Flask 应用。在你的工作目录中，创建一个名为 Dockerfile 的文件，并添加以下内容：

# 使用官方 Python 镜像作为基础镜像
FROM python:3.8-slim# 将工作目录设置为 /app
WORKDIR /app# 复制 requirements.txt 文件，并安装 Python 依赖
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt# 将当前目录中的文件复制到容器的 /app 目录
COPY . /app# 定义容器启动时执行的命令
CMD ["python", "app.py"]

在 requirements.txt 文件中，添加 Flask 的依赖：

flask

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t python-flask-app .

这个命令会根据 Dockerfile 构建一个名为 python-flask-app 的镜像。

步骤 4: 运行 Docker 容器

一旦镜像构建完成，我们可以运行一个基于该镜像的容器：

docker run -p 5000:5000 python-flask-app

执行这个命令后，Docker 会启动一个新的容器实例，容器会运行 Flask 应用，并在端口 5000 上侦听。

通过访问 http://localhost:5000，你可以看到 Flask 应用的输出。

通过这个案例，你学会了如何为一个 Python Flask 应用创建 Docker 镜像，并运行它。这个过程展示了从编写应用代码、创建 Dockerfile 到构建和运行 Docker 镜像的完整流程。这种技能在现代软件开发中极为重要，尤其是在构建和部署微服务架构时。

3.2.3 拓展案例 1：优化 Docker 构建上下文

在这个案例中，我们将探讨如何优化 Docker 构建上下文，以加快 Python 应用的 Docker 镜像构建速度。优化构建上下文是提高 Docker 镜像构建效率的关键步骤之一。

步骤 1: 准备 Python 应用

假设我们的 Python 应用包含多个文件，其中一些文件对构建镜像并不必要。在你的工作目录中，创建以下文件：

  • app.py (必需)
  • requirements.txt (必需)
  • test.py (不必要的测试脚本)
  • data.csv (大型数据文件，构建时不需要)

app.py 和 requirements.txt 文件的内容同前面案例。

步骤 2: 创建初始 Dockerfile

编写一个简单的 Dockerfile：

FROM python:3.8-slim
WORKDIR /app
COPY . /app
RUN pip install --no-cache-dir -r requirements.txt
CMD ["python", "app.py"]

步骤 3: 添加 .dockerignore 文件

创建 .dockerignore 文件来排除不必要的文件，减少构建上下文的大小：

test.py
data.csv

步骤 4: 重新构建 Docker 镜像

使用优化后的构建上下文重新构建 Docker 镜像：

docker build -t optimized-context-python-app .

步骤 5: 观察构建速度的变化

比较使用 .dockerignore 前后的构建速度。你会发现排除了不必要的文件后，构建速度有了明显的提升。

通过这个案例，你可以看到优化 Docker 构建上下文对提高构建效率的重要性。在实际开发中，通过精心管理构建上下文，可以显著减少构建时间，尤其是在持续集成/持续部署（CI/CD）的环境中。

3.2.4 拓展案例 2：利用多阶段构建优化镜像

在这个案例中，我们将演示如何使用 Docker 的多阶段构建来优化一个 Python 应用的 Docker 镜像。多阶段构建是一种有效的方法，可以帮助我们构建更小、更安全的镜像，特别适合于需要编译或有复杂依赖的应用。

步骤 1: 准备 Python 应用

假设我们的 Python 应用需要一些编译工作。在你的工作目录中，创建以下文件：

  • app.py:

    # app.py
import pandas as pdprint("Hello from a multi-stage Dockerized Python App!")

  • requirements.txt:

    pandas

步骤 2: 编写多阶段 Dockerfile

我们将创建一个包含两个阶段的 Dockerfile，其中第一阶段用于安装和编译依赖，第二阶段用于创建最终的运行时镜像。

# 第一阶段：构建阶段
FROM python:3.8 as builderWORKDIR /appCOPY requirements.txt .# 安装依赖
RUN pip install --user -r requirements.txt# 第二阶段：运行阶段
FROM python:3.8-slimWORKDIR /app# 从构建阶段复制已安装的 Python 依赖
COPY --from=builder /root/.local /root/.localCOPY app.py .# 确保在运行时使用的是用户安装的库
ENV PATH=/root/.local:$PATHCMD ["python", "./app.py"]

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t multi-stage-optimized-python-app .

这个命令会根据多阶段 Dockerfile 构建一个名为 multi-stage-optimized-python-app 的镜像。

步骤 4: 运行 Docker 容器

运行以下命令来启动 Python 应用：

docker run multi-stage-optimized-python-app

这个命令启动了一个基于新构建的镜像的容器。

通过这个案例，你可以看到多阶段构建如何帮助我们创建了一个更加精简且功能完整的 Docker 镜像。这种方法对于减少生产环境中的资源占用、加快镜像下载和部署速度具有重要意义。同时，它也增加了安全性，因为最终的镜像中不包含仅用于构建阶段的工具和文件。

通过深入了解 Docker 构建流程的这些知识和案例，你将能够更有效地构建高质量的 Docker 镜像，优化构建过程，提高开发效率。掌握这些技能，你将在 Docker 镜像构建方面更加游刃有余。

3.3 镜像构建的最佳实践

在 Docker 镜像构建中遵循最佳实践是确保镜像高效、安全且易于维护的关键。让我们深入了解这些实践，并通过具体案例加深理解。

3.3.1 重点基础知识

在 Docker 镜像构建过程中，遵循一系列最佳实践可以帮助你创建出更高效、更安全且易于维护的镜像。这些实践不仅适用于简单的应用，也适用于复杂的生产级应用。让我们进一步深入这些最佳实践。

  1. 使用特定版本的基础镜像:

    • 指定基础镜像的具体版本，而不是使用标签如 latest，以确保构建的一致性和可预测性。

  2. 利用 Docker 缓存机制:

    • 将不经常变更的指令放在 Dockerfile 的顶部，如安装软件包，以最大化利用 Docker 的层缓存。

  3. 避免在运行时使用 root 用户:

    • 出于安全考虑，创建并使用非 root 用户运行你的应用。这可以减少容器内部发生的潜在安全风险。

  4. 使用 COPY 而非 ADD:

    • 除非需要自动解压缩功能，否则优先使用 COPY。COPY 更简单、更透明。

  5. 精简命令和层:

    • 尽量使用链式命令和逻辑运算符（如 &&）来合并 RUN 指令，减少镜像层的数量。

  6. 避免安装不必要的软件:

    • 仅安装运行应用所必需的软件包，避免增加不必要的额外负担。

  7. 定期更新和维护:

    • 定期更新镜像以包含安全修复和更新。及时删除不再使用的旧镜像和层，以节省存储空间。

  8. 多阶段构建中的目标阶段:

    • 在多阶段构建中，明确标记目标阶段，以便只构建最终所需的镜像部分，减少构建时间和资源消耗。

遵循这些高级技巧和最佳实践，将帮助你构建出更优质的 Docker 镜像。这些实践不仅提高了镜像的性能和安全性，还确保了你的镜像在部署和维护过程中更加高效和可靠。

3.3.2 重点案例：构建轻量级的 Python Web 应用镜像

在这个案例中，我们将构建一个轻量级的 Python Flask Web 应用的 Docker 镜像。我们将应用 Docker 镜像构建的最佳实践，以创建一个高效且易于维护的镜像。

步骤 1: 创建 Flask 应用

首先，我们需要创建 Flask 应用的基本代码。在你的工作目录中，创建一个名为 app.py 的文件，并添加以下内容：

# app.py
from flask import Flaskapp = Flask(__name__)@app.route('/')
def hello_world():return 'Hello, Dockerized Flask!'if __name__ == '__main__':app.run(debug=False, host='0.0.0.0', port=5000)

同时，创建一个 requirements.txt 文件，包含 Flask 依赖：

flask

步骤 2: 编写 Dockerfile

接下来，我们编写 Dockerfile 来优化镜像大小和构建速度：

# 使用官方 Python Slim 镜像
FROM python:3.8-slim# 设置工作目录
WORKDIR /app# 复制仅构建所需的文件
COPY requirements.txt /app/# 安装依赖，利用 Docker 层缓存
RUN pip install --no-cache-dir -r requirements.txt# 复制应用代码
COPY app.py /app/# 指定非 root 用户运行容器
RUN useradd appuser && chown -R appuser /app
USER appuser# 定义容器启动时执行的命令
CMD ["python", "app.py"]

步骤 3: 构建 Docker 镜像

使用以下命令来构建 Docker 镜像：

docker build -t lightweight-python-flask-app .

步骤 4: 运行 Docker 容器

一旦镜像构建完成，我们可以运行一个基于该镜像的容器：

docker run -p 5000:5000 lightweight-python-flask-app

这个命令启动了一个基于新构建镜像的容器，并将容器的 5000 端口映射到了你的主机的 5000 端口。

通过访问 http://localhost:5000，你可以看到 Flask 应用的输出。

通过这个案例，你学会了如何构建一个轻量级的 Python Flask Web 应用的 Docker 镜像。这种方法不仅优化了镜像的大小，还提高了构建速度和安全性。这对于在生产环境中部署 Web 应用是非常重要的。

3.3.3 拓展案例 1：优化 Dockerfile 结构

在这个案例中，我们将优化一个 Python 应用的 Dockerfile 结构，以提高构建效率和提升安全性。我们的目标是优化构建过程，并确保应用在容器中以非 root 用户运行。

步骤 1: 准备 Python 应用

假设我们已有一个基本的 Python Flask 应用。在你的工作目录中，创建 app.py 和 requirements.txt：

  • app.py:

    # app.py
from flask import Flaskapp = Flask(__name__)@app.route('/')
def hello():return 'Hello, Optimized Docker World!'if __name__ == '__main__':app.run(debug=False, host='0.0.0.0')

  • requirements.txt:

    flask

步骤 2: 编写初始 Dockerfile

创建一个未优化的 Dockerfile：

FROM python:3.8
COPY . /app
WORKDIR /app
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

步骤 3: 优化 Dockerfile

现在，我们将对 Dockerfile 进行优化，包括重新排序命令以利用 Docker 缓存，使用 python:3.8-slim 作为基础镜像，并设置非 root 用户运行：

# 使用更轻量级的基础镜像
FROM python:3.8-slim# 先复制 requirements.txt 文件并安装依赖
# 这一步可以利用 Docker 缓存，如果依赖没有变更，不需要重新安装
COPY requirements.txt /app/
WORKDIR /app
RUN pip install --no-cache-dir -r requirements.txt# 然后复制应用代码
COPY . /app# 创建非 root 用户并切换，提升容器安全性
RUN useradd -m appuser
USER appuserCMD ["python", "app.py"]

步骤 4: 重新构建 Docker 镜像

使用优化后的 Dockerfile 重新构建 Docker 镜像：

docker build -t optimized-structure-python-app .

步骤 5: 运行 Docker 容器

运行优化后的容器：

docker run -p 5000:5000 optimized-structure-python-app

通过这个案例，你可以看到 Dockerfile 结构的优化如何影响构建效率和容器的安全性。通过合理地组织 Dockerfile 指令和使用轻量级的基础镜像，我们不仅提高了镜像的构建速度，还增强了应用的安全性。

3.3.4 拓展案例 2：多阶段构建的复杂 Python 应用

在这个案例中，我们将展示如何使用 Docker 的多阶段构建为一个包含复杂依赖的 Python 应用创建优化的 Docker 镜像。这种方法特别适用于那些需要编译步骤或具有多个依赖层的应用。

步骤 1: 准备 Python 应用

我们的 Python 应用将使用 Pandas 库进行数据处理。在你的工作目录中，创建以下文件：

  • app.py:

    # app.py
import pandas as pddef main():print("Pandas version:", pd.__version__)print("Hello from a multi-stage Dockerized Python App!")if __name__ == "__main__":main()

  • requirements.txt:

    pandas

步骤 2: 编写多阶段 Dockerfile

为了优化镜像大小和构建时间，我们使用多阶段构建：

# 第一阶段：构建阶段
FROM python:3.8 as builderWORKDIR /appCOPY requirements.txt .# 安装依赖
RUN pip install --user -r requirements.txt# 第二阶段：运行阶段
FROM python:3.8-slimWORKDIR /app# 从构建阶段复制已安装的 Python 依赖
COPY --from=builder /root/.local /root/.local# 复制应用代码
COPY app.py .# 确保在运行时使用的是用户安装的库
ENV PATH=/root/.local:$PATHCMD ["python", "./app.py"]

步骤 3: 构建 Docker 镜像

使用以下命令来构建多阶段的 Docker 镜像：

docker build -t multi-stage-complex-python-app .

步骤 4: 运行 Docker 容器

运行以下命令来启动 Python 应用：

docker run multi-stage-complex-python-app

这个命令启动了一个基于新构建的镜像的容器。

通过这个案例，你可以看到多阶段构建如何帮助创建一个更小、更高效的 Docker 镜像，尤其是对于那些依赖较重的应用。多阶段构建使得我们可以在构建阶段安装和准备一切所需，而在最终的镜像中只包含运行应用所必需的组件，这样既优化了镜像大小，也提升了安全性。

遵循这些最佳实践可以显著提高 Docker 镜像的质量，使其更适合在生产环境中使用。这些技巧不仅有助于提高开发和部署的效率，还能增强应用的安全性。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/701046.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

港科夜闻｜香港科大计划建立北部都会区卫星校园完善科大创新带,发展未来创新科技 未来医药发展及跨学科教育...

港科夜闻｜香港科大计划建立北部都会区卫星校园完善科大创新带,发展未来创新科技 未来医药发展及跨学科教育...

关注并星标 每周阅读港科夜闻 建立新视野 开启新思维 1、香港科大计划建立北部都会区卫星校园完善“科大创新带”，发展未来创新科技、未来医药发展及跨学科教育。香港科大校长叶玉如教授在2月22日的媒体会议上表示，香港科大将在北部都会区建立卫星校园&a…
阅读更多...
open3d KD-Tree K近邻点搜索

open3d KD-Tree K近邻点搜索

open3d KD-Tree K近邻点搜索 一、算法原理1.KD-Tree 介绍2.原理 二、代码三、结果1.原点云2.k近邻点搜索后的点云 四、相关数据 一、算法原理 1.KD-Tree 介绍 kd 树或 k 维树是计算机科学中使用的一种数据结构，用于在具有 k 维的空间中组织一定数量的点。它是一个…
阅读更多...
【Spring MVC】处理器映射器：AbstractHandlerMethodMapping源码分析

【Spring MVC】处理器映射器：AbstractHandlerMethodMapping源码分析

目录 一、继承体系 二、HandlerMapping 三、AbstractHandlerMapping 四、AbstractHandlerMethodMapping 4.1 成员属性 4.1.1 MappingRegistry内部类 4.2 AbstractHandlerMethodMapping的初始化 4.3 getHandlerInternal()方法：根据当前的请求url，…
阅读更多...
从git上clone项目到本地后启动时的一种报错

从git上clone项目到本地后启动时的一种报错

当我们从git上拉项目到本地之后，先install,但启动时可能会出现报错，例如上面这种报错，这时候我们需要把package.json里的vite改一下，例如改成2.6.13，之后删掉node_modules,重新install,再启动一下，就好了。…
阅读更多...
OT 安全解决方案：探索技术

OT 安全解决方案：探索技术

IT 和 OT 安全的融合：更好的防御方法 OT 安全解决方案下一个时代： 为了应对不断升级的威胁形势，组织认识到迫切需要采用统一的信息技术 (IT) 和运营技术 (OT) 安全方法。IT 和 OT 安全的融合代表了一种范式转变，承认这些传统孤立领…
阅读更多...
音频smmu问题之smmu学习

音频smmu问题之smmu学习

一、音频smmu 内存访问问题 在工作中，遇到一个smmu问题，主要log信息如下： arm-smmu 15000000.apps-smmu: Unhandled arm-smmu context fault from soc:spf_core_platform:qcom,msm-audio-ion! arm-smmu 15000000.apps-smmu: FAR 0x0000000…
阅读更多...
什么是负载均衡集群？

什么是负载均衡集群？

目录 1、集群是什么？ 2、负载均衡集群技术 3、负载均衡集群技术的实现 4、实现效果如图 5、负载均衡分类 6、四层负载均衡（基于IP端口的负载均衡） 7、七层的负载均衡（基于虚拟的URL或主机IP的负载均衡) 8、四层负载与七层…
阅读更多...
（3）(3.6) 用于OpenTX的Yaapu遥测脚本

（3）(3.6) 用于OpenTX的Yaapu遥测脚本

文章目录 前言 1 安装和操作 2 参数说明 前言 这是一个开源 LUA 脚本，用于在使用 OpenTX 2.2.3 的 Horus X10、X12、Jumper T16、T18、Radiomaster TX16S、Taranis X9D、X9E、QX7 和 Jumper T12 无线电设备上显示 FrSky 的直通遥测数据(FrSky passthrough telem…
阅读更多...
Linux配置jdk、tomcat、mysql离线安装与启动

Linux配置jdk、tomcat、mysql离线安装与启动

目录 1.jdk安装 2.tomcat的安装（开机自启动） 3.MySQL的安装 4.连接项目 1.jdk安装 上传jdk安装包 jdk-8u151-linux-x64.tar.gz 进入opt目录，将安装包拖进去 解压安装包 这里需要解压到usr/local目录下，在这里我新建一个文件夹…
阅读更多...
【Vue3】学习computed计算属性

【Vue3】学习computed计算属性

💗💗💗欢迎来到我的博客，你将找到有关如何使用技术解决问题的文章，也会找到某个技术的学习路线。无论你是何种职业，我都希望我的博客对你有所帮助。最后不要忘记订阅我的博客以获取最新文章，也欢…
阅读更多...
NXP实战笔记（十）：S32K3xx基于RTD-SDK在S32DS上配置CAN通信

NXP实战笔记（十）：S32K3xx基于RTD-SDK在S32DS上配置CAN通信

目录 1、概述 2、SDK配置 2.1、配置目标 2.2、CAN配置 3、代码实现 4、测试结果 1、概述 S32K3xx的FlexCan与之前的S32K1xx很相似，Can的中断掩码寄存器（IMASK3）与中断标志位寄存器（IFLAG3）依赖于邮箱数。 FlexCan配置实例如下 FlexCan的整体图示如下 Protocol Engine…
阅读更多...
PyTorch概述（六）---View

PyTorch概述（六）---View

Tensor.view(*shape)-->Tensor 返回一个新的张量同之前的张量具有相同的数据，但是具有不同的形状；返回的张量同之前的张量共享相同的数据，必须具有相同数目的元素，可能具有不同的形状；对于经过view操作的张量&…
阅读更多...
Python中操作MySQL和SQL Server数据库的基础与实战【第97篇—MySQL数据库】

Python中操作MySQL和SQL Server数据库的基础与实战【第97篇—MySQL数据库】

Python中操作MySQL和SQL Server数据库的基础与实战 在Python中，我们经常需要与各种数据库进行交互，其中MySQL和SQL Server是两个常见的选择。本文将介绍如何使用pymysql和pymssql库进行基本的数据库操作，并通过实际代码示例来展示这些操作。…
阅读更多...
Visual Studio：Entity设置表之间的关联关系

Visual Studio：Entity设置表之间的关联关系

1、选择表并右键-》新增-》关联 2、设置关联的表及关联关系并“确定”即可
阅读更多...
真的是性能优化（压测）-纯思想

真的是性能优化（压测）-纯思想

文章目录 概要优化指标-MD都是文字看看就行性能优化操作1、代码优化：2、系统配置与环境优化：3、架构与设计：4、~~实施与监控：~~5、~~开发流程和环境管理：~~ 总结 概要 性能优化是一个持续的过程，需要监控、…
阅读更多...
神经网络系列---感知机(Neuron)

神经网络系列---感知机(Neuron)

文章目录 感知机(Neuron)感知机(Neuron)的决策函数可以表示为：感知机(Neuron)的学习算法主要包括以下步骤：感知机可以实现逻辑运算中的AND、OR、NOT和异或(XOR)运算。 感知机(Neuron) 感知机(Neuron)是一种简单而有效的二分类算法，用于将输入…
阅读更多...
android input命令支持多指触摸成果展示-千里马framework实战开发

android input命令支持多指触摸成果展示-千里马framework实战开发

hi input命令扩展提示部分 generic_x86_64:/ # input -h Error: Unknown command: -h Usage: input [<source>] <command> [<arg>...]The source…
阅读更多...
数智化转型的三大关键点

数智化转型的三大关键点

一、重新认识数智化转型 消费红利时代&#xff0c;伴随中国宏观经济向好发展&#xff0c;相当一部分企业可以轻松实现快速增长&#xff0c;如同搭乘了一架高速运转的电梯一路飞升。然而&#xff0c;随着宏观经济增速放缓&#xff0c;时代的电梯逐渐失去效力&#xff0c;中国商…
阅读更多...
python3 Flask jwt 简易token认证实例

python3 Flask jwt 简易token认证实例

直接上代码 from flask import Flask, jsonify, request, make_response import jwt import datetime from functools import wrapsapp Flask(__name__)# 这是一个示例密钥&#xff0c;实际应用中应该使用一个复杂且随机的密钥 app.config[SECRET_KEY] your_secret_keydef t…
阅读更多...
第九节HarmonyOS 常用基础组件24-Navigation

第九节HarmonyOS 常用基础组件24-Navigation

1、描述 Navigation组件一般作为Page页面的根容器&#xff0c;通过属性设置来展示的标题栏、工具栏、导航栏等。 2、子组件 可以包含子组件&#xff0c;推荐与NavRouter组件搭配使用。 3、接口 Navigation() 4、属性 名称 参数类型 描述 title string|NavigationComm…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023