Nrthugu

Let's say I decided to make following multistage build:

FROM node:8.6-alpine AS build1

#some other commands

FROM node:8.5-alpine AS build2

# yet another commands

definitely there are some layers which will be common between build1 and build2. Will docker duplicate layers, or append somehow reference already built layers?

Next is the result of your dockerfile build on a fresh machine:

# docker build -t test:1 .

Sending build context to Docker daemon  2.048kB

Step 1/2 : FROM node:8.6-alpine AS build1

8.6-alpine: Pulling from library/node

88286f41530e: Pull complete

d0e8a23136b3: Pull complete

5ad5b12a980e: Pull complete

Digest: sha256:60cd58a7a2bd9fec161f53f8886e451f92db06b91f4f72d9188eeea040d195eb

Status: Downloaded newer image for node:8.6-alpine

 ---> b7e15c83cdaf

Step 2/2 : FROM node:8.5-alpine AS build2

8.5-alpine: Pulling from library/node

88286f41530e: Already exists

aa0be12c5610: Pull complete

719d346e6de2: Pull complete

Digest: sha256:945cf56668d3e58a3b045291564963ccde29a68da9c1483e19d8a0b06749db06

Status: Downloaded newer image for node:8.5-alpine

 ---> 7a779c246a41

Successfully built 7a779c246a41

Successfully tagged test:1

From the output you can see image id 88286f41530e was reused as Already exists.

And docker images output:

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE

node                8.6-alpine          b7e15c83cdaf        13 months ago       67.2MB

node                8.5-alpine          7a779c246a41        14 months ago       67MB

So, the base image of first stage in the multibuild also reserve in cache.

And from this post:

Since Docker v1.10, generally, images and layers are no longer synonymous.
Instead, an image directly references one or more layers that eventually contribute to a derived container's filesystem.

So, as some image reused, the layers surely be reused.

Of course, this depends on the base images you used in multibuild, they need have something to reuse.

Anyway, I think multibuild just add some trick compared to traditional build, but layer reuse mechanism is the same.

I believe ordinary docker build layer caching will apply, but there are other better answers.

FROM ubuntu:18.04 AS first

RUN apt-get update 

 && DEBIAN_FRONTEND=noninteractive 

    apt-get install -y --no-install-recommends 

      python3

RUN echo first



FROM ubuntu:18.04 AS second

RUN apt-get update 

 && DEBIAN_FRONTEND=noninteractive 

    apt-get install -y --no-install-recommends 

      python3

RUN echo second

The rules are that you must start from the exact same base image (in your example nothing is shared) and you must repeat the exact same commands (or COPY the exact same file content); as soon as you stray from this path nothing is shared, including in any later identical commands.

You can use the AS alias in later FROM directives so if you really want to share some base layer it's better to do it explicitly

FROM ubuntu:18.04 AS base

RUN apt-get update 

 && DEBIAN_FRONTEND=noninteractive 

    apt-get install -y --no-install-recommends 

      python3



FROM base AS first

RUN echo first



FROM base AS second

RUN echo second

The more common case with a multi-stage build as to have very different "build" and "runtime" images so this doesn't often apply.

FROM golang:1.11 AS build

WORKDIR /go/src/github.com/me/myapp

COPY ./ ./

RUN go install .



FROM alpine

COPY --from=build /go/bin/myapp /usr/bin

CMD ["myapp"]