切换语言

多阶段构建

目录

解释

在传统构建中，所有构建指令都按顺序执行，并且在单个构建容器中执行：下载依赖项、编译代码和打包应用程序。所有这些图层最终都会出现在您的最终镜像中。这种方法有效，但会导致笨重的镜像带有不必要的重量并增加您的安全风险。这就是多阶段构建的用武之地。

多阶段构建在 Dockerfile 中引入了多个阶段，每个阶段都有特定的用途。可以将其视为在多个不同环境中同时运行构建的不同部分的能力。通过将构建环境与最终运行时环境分离，您可以显著减小镜像大小和攻击面。这对于具有大量构建依赖项的应用程序尤其有益。

建议对所有类型的应用程序进行多阶段构建。

  • 对于解释型语言，如 JavaScript、Ruby 或 Python，您可以在一个阶段中构建和缩小代码，并将生产就绪文件复制到较小的运行时镜像。这将优化您的镜像以进行部署。
  • 对于编译语言（如 C、Go 或 Rust），多阶段构建允许您在一个阶段中进行编译，并将编译后的二进制文件复制到最终的运行时镜像中。无需将整个编译器捆绑在最终镜像中。

下面是使用伪代码的多阶段构建结构的简化示例。请注意，有多个语句和一个新的 .此外，第二阶段的语句是复制上一阶段。FROMAS <stage-name>COPY--from

# Stage 1: Build Environment
FROM builder-image AS build-stage 
# Install build tools (e.g., Maven, Gradle)
# Copy source code
# Build commands (e.g., compile, package)

# Stage 2: Runtime environment
FROM runtime-image AS final-stage  
#  Copy application artifacts from the build stage (e.g., JAR file)
COPY --from=build-stage /path/in/build/stage /path/to/place/in/final/stage
# Define runtime configuration (e.g., CMD, ENTRYPOINT)

此 Dockerfile 使用两个阶段：

  • 构建阶段使用包含编译应用程序所需的构建工具的基础镜像。它包括用于安装构建工具、复制源代码和执行构建命令的命令。
  • 最后阶段使用适合运行应用程序的较小基础镜像。它从构建阶段复制已编译的工件（例如 JAR 文件）。最后，它定义用于启动应用程序的运行时配置（使用 或 ）。CMDENTRYPOINT

试用

在本实践指南中，您将解锁多阶段构建的强大功能，为示例 Java 应用程序创建精简高效的 Docker 镜像。您将使用一个简单的基于 Spring Boot 的 “Hello World” 应用程序作为示例。

  1. 下载并安装Docker 桌面。

  2. 打开此预初始化的项目以生成 ZIP 文件。这是它的样子：

    使用 Java 21、Spring Web 和 Spring Boot 3.4.0 选择的 Spring Initializr 工具的屏幕截图

    Spring Initializr 是 Spring 项目的快速入门生成器。它提供了一个可扩展的 API，用于生成基于 JVM 的项目，其中包含多个常见概念的实现，例如 Java、Kotlin 和 Groovy 的基本语言生成。

    选择 Generate （生成） 以创建并下载此项目的 zip 文件。

    在本演示中，您已将 Maven 构建自动化与 Java、Spring Web 依赖项和 Java 21 配对用于元数据。

  3. 导航项目目录。解压缩文件后，您将看到以下项目目录结构：

    spring-boot-docker
├── HELP.md
├── mvnw
├── mvnw.cmd
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── example
    │   │           └── spring_boot_docker
    │   │               └── SpringBootDockerApplication.java
    │   └── resources
    │       ├── application.properties
    │       ├── static
    │       └── templates
    └── test
        └── java
            └── com
                └── example
                    └── spring_boot_docker
                        └── SpringBootDockerApplicationTests.java

15 directories, 7 files

    该目录包含项目的源代码，该目录
    包含测试源，文件是项目的项目对象模型 （POM）。    src/main/javasrc/test/javapom.xml

    该文件是 Maven 项目配置的核心。它是一个配置文件，
    其中包含构建自定义项目所需的大部分信息。POM 很大，似乎
    令人生畏。值得庆幸的是，您还不需要了解每一个复杂性即可有效地使用它。    pom.xml

  4. 创建显示 “Hello World！” 的 RESTful Web 服务。

    在该目录下，您可以使用以下内容修改您的
    文件：    src/main/java/com/example/spring_boot_docker/SpringBootDockerApplication.java

    package com.example.spring_boot_docker;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@SpringBootApplication
public class SpringBootDockerApplication {

    @RequestMapping("/")
        public String home() {
        return "Hello World";
    }

	public static void main(String[] args) {
		SpringApplication.run(SpringBootDockerApplication.class, args);
	}

}

    该文件首先声明您的包并导入必要的 Spring 框架。此 Java 文件创建一个简单的 Spring Boot Web 应用程序，当用户访问其主页时，该应用程序以“Hello World”响应。SpringbootDockerApplication.javacom.example.spring_boot_docker

创建 Dockerfile

现在您拥有了项目，可以创建 .Dockerfile

  1. 在包含所有其他文件夹和文件（如 src、pom.xml 等）的同一文件夹中创建一个命名的文件。Dockerfile

  2. 在 中，通过添加以下行来定义您的基本镜像：Dockerfile

    FROM eclipse-temurin:21.0.2_13-jdk-jammy

  3. 现在，使用 指令定义工作目录。这将指定将来命令的运行位置，并将目录文件复制到容器镜像中。WORKDIR

    WORKDIR /app

  4. 将 Maven 包装器脚本和项目文件复制到 Docker 容器内的当前工作目录中。pom.xml/app

    COPY .mvn/ .mvn
COPY mvnw pom.xml ./

  5. 在容器内执行命令。它运行命令，该命令使用 Maven 包装器 （） 下载项目的所有依赖项，而无需构建最终的 JAR 文件（对于更快的构建很有用）。./mvnw dependency:go-offline./mvnw

    RUN ./mvnw dependency:go-offline

  6. 将目录从主机上的项目复制到容器内的目录。src/app

    COPY src ./src

  7. 设置容器启动时执行的默认命令。此命令指示容器运行具有目标的 Maven 包装器 （），它将构建并执行您的 Spring Boot 应用程序。./mvnwspring-boot:run

    CMD ["./mvnw", "spring-boot:run"]

    这样，您应该有以下 Dockerfile：

    FROM eclipse-temurin:21.0.2_13-jdk-jammy
WORKDIR /app
COPY .mvn/ .mvn
COPY mvnw pom.xml ./
RUN ./mvnw dependency:go-offline
COPY src ./src
CMD ["./mvnw", "spring-boot:run"]

构建容器镜像

  1. 执行以下命令以构建 Docker 镜像。

    $ docker build -t spring-helloworld .

  2. 使用以下命令检查 Docker 镜像的大小：docker images

    $ docker images

    这样做将产生如下所示的输出：

    REPOSITORY          TAG       IMAGE ID       CREATED          SIZE
spring-helloworld   latest    ff708d5ee194   3 minutes ago    880MB

    此输出显示您的镜像大小为 880MB。它包含完整的 JDK、Maven 工具链等。在生产中，您在最终镜像中不需要它。

运行 Spring Boot 应用程序

  1. 现在您已经构建了一个镜像，是时候运行容器了。

    $ docker run -d -p 8080:8080 spring-helloworld

    然后，您将在容器日志中看到类似于以下内容的输出：

    [INFO] --- spring-boot:3.3.4:run (default-cli) @ spring-boot-docker ---
[INFO] Attaching agents: []

     .   ____          _            __ _ _
    /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
   ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
    \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
     '  |____| .__|_| |_|_| |_\__, | / / / /
    =========|_|==============|___/=/_/_/_/

    :: Spring Boot ::                (v3.3.4)

2024-09-29T23:54:07.157Z  INFO 159 --- [spring-boot-docker] [           main]
c.e.s.SpringBootDockerApplication        : Starting SpringBootDockerApplication using Java
21.0.2 with PID 159 (/app/target/classes started by root in /app)
 ….

  2. 通过 Web 浏览器 http://localhost:8080 访问您的 “Hello World” 页面，或通过以下 curl 命令访问：

    $ curl localhost:8080
Hello World

使用多阶段构建

  1. 请考虑以下 Dockerfile：

    FROM eclipse-temurin:21.0.2_13-jdk-jammy AS builder
WORKDIR /opt/app
COPY .mvn/ .mvn
COPY mvnw pom.xml ./
RUN ./mvnw dependency:go-offline
COPY ./src ./src
RUN ./mvnw clean install

FROM eclipse-temurin:21.0.2_13-jre-jammy AS final
WORKDIR /opt/app
EXPOSE 8080
COPY --from=builder /opt/app/target/*.jar /opt/app/*.jar
ENTRYPOINT ["java", "-jar", "/opt/app/*.jar"]

    请注意，此 Dockerfile 已拆分为两个阶段。

    • 第一阶段与之前的 Dockerfile 相同，提供用于构建应用程序的 Java 开发工具包 （JDK） 环境。此阶段的名称为 builder。

    • 第二个阶段是名为 的新阶段。它使用更精简的镜像，仅包含运行应用程序所需的 Java 运行时环境 （JRE）。此镜像提供了一个 Java 运行时环境 （JRE），足以运行已编译的应用程序（JAR 文件）。finaleclipse-temurin:21.0.2_13-jre-jammy

    对于生产用途，强烈建议您使用 jlink 生成类似 JRE 的自定义运行时。JRE 镜像可用于 Eclipse Temurin 的所有版本，但允许您创建一个仅包含应用程序所需的 Java 模块的最小运行时。这可以显著减小最终镜像的大小并提高其安全性。有关更多信息，请参阅此页面。jlink

    对于多阶段构建，Docker 构建使用一个基础镜像进行编译、打包和单元测试，然后使用一个单独的镜像进行应用程序运行时。因此，最终镜像的大小更小，因为它不包含任何开发或调试工具。通过将构建环境与最终运行时环境分离，您可以显著减小镜像大小并提高最终镜像的安全性。

  2. 现在，重新构建您的镜像并运行现成的生产版本。

    $ docker build -t spring-helloworld-builder .

    此命令使用位于当前目录中的文件的 final stage 构建一个名为 Docker 镜像。spring-helloworld-builderDockerfile

    注意

    在多阶段 Dockerfile 中，最后阶段 （final） 是构建的默认目标。这意味着，如果您未使用命令中的标志显式指定目标阶段，Docker 将默认自动生成最后一个阶段。您只能使用 JDK 环境构建构建器阶段。--targetdocker builddocker build -t spring-helloworld-builder --target builder .

  3. 使用以下命令查看镜像大小差异：docker images

    $ docker images

    您将获得类似于以下内容的输出：

    spring-helloworld-builder latest    c5c76cb815c0   24 minutes ago      428MB
spring-helloworld         latest    ff708d5ee194   About an hour ago   880MB

    您的最终镜像只有 428 MB，而原始构建大小为 880 MB。

    通过优化每个阶段并仅包含必要的内容，您能够显著减小
    整体镜像大小，同时仍能实现相同的功能。这不仅可以提高性能，还可以
    使您的 Docker 镜像更轻量级、更安全、更易于管理。

其他资源