使用构建缓存

解释

请考虑您为入门应用程序创建的以下 Dockerfile。

FROM node:20-alpine
WORKDIR /app
COPY . .
RUN yarn install --production
CMD ["node", "./src/index.js"]

当您运行docker build命令创建新镜像,Docker 会执行 Dockerfile 中的每个指令,并按指定的顺序为每个命令创建一个层。对于每个指令,Docker 会检查它是否可以重用先前构建的指令。如果它发现您之前已经执行了类似的指令,Docker 不需要重做它。相反,它将使用缓存的结果。这样,您的构建过程会变得更快、更高效,从而节省您宝贵的时间和资源。

有效地使用构建缓存,您可以通过重用以前构建的结果并跳过不必要的工作来实现更快的构建。 为了最大限度地提高缓存利用率并避免资源密集型和耗时的重新构建,了解缓存失效的工作原理非常重要。 以下是可能导致缓存失效的一些情况示例:

  • 对 命令的任何更改RUN指令使该层无效。Docker 会检测更改,如果对RUN命令。

  • 对复制到镜像中的文件所做的任何更改都会显示COPYADD指示。Docker 会密切关注项目目录中文件的任何更改。无论是内容更改还是权限等属性的更改,Docker 都会将这些修改视为使缓存失效的触发器。

  • 一旦一个图层失效,所有后续图层也失效。如果任何先前的层(包括基础镜像或中间层)因更改而失效,Docker 会确保依赖它的后续层也失效。这样可以保持构建过程同步并防止不一致。

在编写或编辑 Dockerfile 时,请留意不必要的缓存未命中,以确保构建尽可能快速高效地运行。

试用

在本实践指南中,您将学习如何有效地将 Docker 构建缓存用于 Node.js 应用程序。

构建应用程序

  1. 下载并安装Docker 桌面。

  2. 打开终端并克隆此示例应用程序

    $ git clone https://github.com/dockersamples/todo-list-app
    
  3. 导航到todo-list-app目录:

    $ cd todo-list-app
    

    在此目录中,您将找到一个名为Dockerfile包含以下内容:

    FROM node:20-alpine
    WORKDIR /app
    COPY . .
    RUN yarn install --production
    EXPOSE 3000
    CMD ["node", "./src/index.js"]
  4. 执行以下命令以构建 Docker 镜像。

    $ docker build .
    

    下面是生成过程的结果:

    [+] Building 20.0s (10/10) FINISHED
    

    第一行表示整个构建过程花费了 20.0 秒。第一个版本可能需要一些时间,因为它会安装依赖项。

  5. 重建家园而不进行更改。

    现在,重新运行docker build命令,而无需对源代码或 Dockerfile 进行任何更改,如下所示:

    $ docker build .
    

    由于缓存机制,只要命令和上下文保持不变,初始之后的后续构建速度会更快。Docker 缓存在构建过程中生成的中间层。当您在不对 Dockerfile 或源代码进行任何更改的情况下重新构建镜像时,Docker 可以重用缓存的层,从而显著加快构建过程。

    [+] Building 1.0s (9/9) FINISHED                                                                            docker:desktop-linux
     => [internal] load build definition from Dockerfile                                                                        0.0s
     => => transferring dockerfile: 187B                                                                                        0.0s
     ...
     => [internal] load build context                                                                                           0.0s
     => => transferring context: 8.16kB                                                                                         0.0s
     => CACHED [2/4] WORKDIR /app                                                                                               0.0s
     => CACHED [3/4] COPY . .                                                                                                   0.0s
     => CACHED [4/4] RUN yarn install --production                                                                              0.0s
     => exporting to image                                                                                                      0.0s
     => => exporting layers                                                                                                     0.0s
     => => exporting manifest
    

    利用缓存层,后续构建仅需 1.0 秒即可完成。无需重复耗时的步骤,例如安装依赖项。

    步骤描述Time Taken(第 1 次运行)Time Taken (第 2 次运行)
    1从 Dockerfile 加载构建定义0.0 秒0.0 秒
    2加载元数据以进行 docker.io/library/node:20-alpine2.7 秒0.9 秒
    3加载 .dockerignore0.0 秒0.0 秒
    4加载生成上下文

    (上下文大小:4.60MB)

    0.1 秒0.0 秒
    5设置工作目录 (WORKDIR)0.1 秒0.0 秒
    6将本地代码复制到容器中0.0 秒0.0 秒
    7运行 yarn install --production10.0 秒0.0 秒
    8导出图层2.2 秒0.0 秒
    9导出最终镜像3.0 秒0.0 秒

    回到docker image historyoutput,您会看到 Dockerfile 中的每个命令都成为镜像中的一个新层。您可能还记得,当您对镜像进行更改时,yarn依赖项必须重新安装。有没有办法解决这个问题?每次构建时重新安装相同的依赖项没有多大意义,对吧?

    要解决此问题,请重新构建 Dockerfile,以便依赖项缓存保持有效,除非它确实需要失效。对于基于节点的应用程序,依赖项在package.json文件。如果该文件发生更改,您将需要重新安装依赖项,但如果文件未更改,则需要使用缓存的依赖项。因此,首先只复制该文件,然后安装依赖项,最后复制其他所有内容。然后,如果package.json文件。

  6. 更新要在package.jsonfile 先安装依赖项,然后复制其他所有内容。

    FROM node:20-alpine
    WORKDIR /app
    COPY package.json yarn.lock ./
    RUN yarn install --production 
    COPY . . 
    EXPOSE 3000
    CMD ["node", "src/index.js"]
  7. 创建一个名为.dockerignore与 Dockerfile 位于同一文件夹中,其中包含以下内容。

    node_modules
  8. 构建新镜像:

    $ docker build .
    

    然后,您将看到类似于以下内容的输出:

    [+] Building 16.1s (10/10) FINISHED
    => [internal] load build definition from Dockerfile                                               0.0s
    => => transferring dockerfile: 175B                                                               0.0s
    => [internal] load .dockerignore                                                                  0.0s
    => => transferring context: 2B                                                                    0.0s
    => [internal] load metadata for docker.io/library/node:21-alpine                                  0.0s
    => [internal] load build context                                                                  0.8s
    => => transferring context: 53.37MB                                                               0.8s
    => [1/5] FROM docker.io/library/node:21-alpine                                                    0.0s
    => CACHED [2/5] WORKDIR /app                                                                      0.0s
    => [3/5] COPY package.json yarn.lock ./                                                           0.2s
    => [4/5] RUN yarn install --production                                                           14.0s
    => [5/5] COPY . .                                                                                 0.5s
    => exporting to image                                                                             0.6s
    => => exporting layers                                                                            0.6s
    => => writing image     
    sha256:d6f819013566c54c50124ed94d5e66c452325327217f4f04399b45f94e37d25        0.0s
    => => naming to docker.io/library/node-app:2.0                                                 0.0s
    

    您将看到所有图层都已重新构建。非常好,因为你对 Dockerfile 进行了很多更改。

  9. 现在,对src/static/index.html文件(例如,将标题更改为“The Awesome Todo App”)。

  10. 构建 Docker 镜像。这一次,您的输出看起来应该有点不同。

    $ docker build -t node-app:3.0 .
    

    然后,您将看到类似于以下内容的输出:

    [+] Building 1.2s (10/10) FINISHED 
    => [internal] load build definition from Dockerfile                                               0.0s
    => => transferring dockerfile: 37B                                                                0.0s
    => [internal] load .dockerignore                                                                  0.0s
    => => transferring context: 2B                                                                    0.0s
    => [internal] load metadata for docker.io/library/node:21-alpine                                  0.0s 
    => [internal] load build context                                                                  0.2s
    => => transferring context: 450.43kB                                                              0.2s
    => [1/5] FROM docker.io/library/node:21-alpine                                                    0.0s
    => CACHED [2/5] WORKDIR /app                                                                      0.0s
    => CACHED [3/5] COPY package.json yarn.lock ./                                                    0.0s
    => CACHED [4/5] RUN yarn install --production                                                     0.0s
    => [5/5] COPY . .                                                                                 0.5s 
    => exporting to image                                                                             0.3s
    => => exporting layers                                                                            0.3s
    => => writing image     
    sha256:91790c87bcb096a83c2bd4eb512bc8b134c757cda0bdee4038187f98148e2eda       0.0s
    => => naming to docker.io/library/node-app:3.0                                                 0.0s
    

    首先,您应该注意到构建速度要快得多。您将看到几个步骤正在使用以前缓存的图层。这是个好消息;您正在使用 Build Cache。推送和拉取此镜像并对其进行更新也会快得多。

通过遵循这些优化技术,您可以使 Docker 构建更快、更高效,从而加快迭代周期并提高开发效率。

其他资源

后续步骤

现在,您已经了解了如何有效地使用 Docker 构建缓存,您可以了解多阶段构建。