2. Separating Application Build and Execution with Multi-Stage Builds

Question 1

What extra step do we need to specify in the Dockerfile when using compiled languages?

Answer 1

Compile the source code into a binary artifact before it can be defined as an executable for the derived container.

When it comes to Golang, it looks like this:

RUN go build -o mini
# before
ENTRYPOINT [”./mini”]
~~~
~~~

Question 2

What are the two main problems with using compiled languages to develop our app in a Docker container?

Answer 2

1. Increased complexity — not trivial to code and hot reload with a bind mount.
2. Larger image size — development tools (eg. SDKs) are captured inside the container image.

Question 3

What is a common solution for accommodating compiled languages while maintaining the benefits of developing inside a Docker container?

Answer 3

Using the Builder Pattern.

Question 4

What is the Builder Pattern?

Answer 4

A Docker development pattern that splits out the build step sequence from the run step sequence using separate Dockerfiles for each task.

Question 5

How do you specify the name and the tag while building a Docker image using docker build?

Answer 5

By using the --tag option.

docker build --tag mini .

Question 6

How do you automatically remove the container if it already exists when running docker run?

Answer 6

By using the --rm option.

Question 7

How do you specify which Dockerfile to build an image from while running docker build?

Answer 7

By using the --file option.

docker build --tag my-builder --file Dockerfile.build .

Question 8

What is a better solution for separating our build step than using separate Dockerfiles?

Answer 8

Using a multi-stage Dockerfile.

Question 9

What makes a Dockerfile a multi-stage Dockerfile?

Answer 9

Using multiple FROM instructions to logically separate the different parts of a container image — each FROM instruction delineates a different stage.

Question 10

What does an image built by using a multi-stage Dockerfile contain?

Answer 10

Only the content of the final stage.

Question 11

How does Docker help us reference a build stage?

Answer 11

By numbering each stage starting from zero.

Question 12

How do we name stages of a multi-stage Dockerfile?

Answer 12

By using the AS keyword when defining a build stage using FROM.

FROM node:14 AS builder

Question 13

In a Dockerfile build stage, how do you instruct to copy files from a preceding stage?

Answer 13

By using the COPY instruction and specifying the build stage to copy the content from using the --from option.

COPY --from=builder /deps /app

Question 14

How do you specify which build stage to use when running docker build?

Answer 14

By using the --target option with the build stage name or number.

docker build --tag app-builder --target builder .

Question 15

What are the benefits of a multi-stage Dockerfile?

Answer 15

1. Smaller image sizes are attained by selective inclusion of content.
2. Smaller surface area open to intentional or accidental compromise.
3. Logical separation of build steps according to purpose.
4. Easier and more reliable maintenance of Dockerfile instructions.

Question 16

What are the three principles that we can use as a good starting point for structuring multi-stage Dockerfiles?

Answer 16

1. Stage functions — establish the purpose of the different stages.
2. Shared content — identify any common stage content.
3. Size matters — optimize for size, but maintain readability (balance is key).

Question 17

How do you enable BuildKit for Docker builds?

Answer 17

By defining the DOCKER_BUILDKIT environment variable and setting it to 1.

export DOCKER_BUILDKIT=1

Question 18

What is the advantage of using BuildKit?

Answer 18

BuildKit enables higher performance docker builds and caching possibility to decrease build times and increase productivity for free.