使用构建缓存

解释

请看您为入门应用创建的以下 Dockerfile。

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

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

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

对 RUN 指令的命令进行任何更改都会使该层失效。如果 Dockerfile 中的 RUN 命令有任何修改，Docker 会检测到更改并使构建缓存失效。
使用 COPY 或 ADD 指令复制到镜像中的文件发生任何更改。Docker 会监视您项目目录中文件的任何变动。无论是内容更改还是权限等属性的更改，Docker 都会将这些修改视为触发缓存失效的因素。
一旦某一层失效，其后所有层也会失效。如果任何先前的层，包括基础镜像或中间层，因更改而失效，Docker 会确保依赖于它的后续层也失效。这可以保持构建过程的同步并防止不一致。

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

试一试

在这个实践指南中，您将学习如何为一个 Node.js 应用程序有效地使用 Docker 构建缓存。

构建应用程序

下载并安装 Docker Desktop。

打开一个终端并克隆这个示例应用程序。

$ git clone https://github.com/dockersamples/todo-list-app

导航到 todo-list-app 目录

$ cd todo-list-app

在这个目录中，您会找到一个名为 Dockerfile 的文件，其内容如下：

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

执行以下命令来构建 Docker 镜像
$ docker build .
以下是构建过程的结果：
[+] Building 20.0s (10/10) FINISHED
第一行显示整个构建过程耗时 20.0 秒。第一次构建可能需要一些时间，因为它需要安装依赖项。

在不作任何更改的情况下重新构建。

现在，在不更改源代码或 Dockerfile 的情况下，重新运行 docker build 命令，如下所示：

$ 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 秒就完成了。无需重复像安装依赖项这样耗时的步骤。

步骤	描述	耗时（第一次运行）	耗时（第二次运行）
1	`从 Dockerfile 加载构建定义`	0.0 秒	0.0 秒
2	`加载 docker.io/library/node:22-alpine 的元数据`	2.7 秒	0.9 秒
3	`加载 .dockerignore`	0.0 秒	0.0 秒
4	`加载构建上下文` （上下文大小：4.60MB）	0.1 秒	0.0 秒
5	`设置工作目录 (WORKDIR)`	0.1 秒	0.0 秒
6	`将本地代码复制到容器中`	0.0 秒	0.0 秒
7	`运行 yarn install --production`	10.0 秒	0.0 秒
8	`导出层`	2.2 秒	0.0 秒
9	`导出最终镜像`	3.0 秒	0.0 秒

回到 docker image history 的输出，您会看到 Dockerfile 中的每个命令都成为镜像中的一个新层。您可能还记得，当您对镜像进行更改时，必须重新安装 yarn 依赖项。有没有办法解决这个问题？每次构建时都重新安装相同的依赖项，这似乎不太合理，对吧？

为了解决这个问题，请重构您的 Dockerfile，以便依赖项缓存保持有效，除非它确实需要被无效化。对于基于 Node 的应用程序，依赖项在 package.json 文件中定义。如果该文件发生变化，您会希望重新安装依赖项，但如果文件未变，则使用缓存的依赖项。所以，首先只复制那个文件，然后安装依赖项，最后再复制其他所有内容。这样，只有在 package.json 文件发生更改时，您才需要重新创建 yarn 依赖项。

更新 Dockerfile，先复制 package.json 文件，安装依赖项，然后再复制其他所有内容。

FROM node:22-alpine
WORKDIR /app
COPY package.json yarn.lock ./
RUN yarn install --production 
COPY . . 
EXPOSE 3000
CMD ["node", "src/index.js"]

在与 Dockerfile 相同的文件夹中创建一个名为 .dockerignore 的文件，其内容如下。
node_modules

构建新镜像

$ 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:22-alpine                                  0.0s
=> [internal] load build context                                                                  0.8s
=> => transferring context: 53.37MB                                                               0.8s
=> [1/5] FROM docker.io/library/node:22-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 做了相当大的改动。

现在，对 src/static/index.html 文件做一个更改（比如将标题改为“超棒的待办事项应用”）。

构建 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:22-alpine                                  0.0s 
=> [internal] load build context                                                                  0.2s
=> => transferring context: 450.43kB                                                              0.2s
=> [1/5] FROM docker.io/library/node:22-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

首先，您应该注意到构建速度快了很多。您会看到有几个步骤正在使用之前缓存的层。这是个好消息；您正在使用构建缓存。推送和拉取这个镜像及其更新也会快得多。

通过遵循这些优化技巧，您可以使您的 Docker 构建更快、更高效，从而加快迭代周期并提高开发生产力。

其他资源

后续步骤

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

多阶段构建