The Problem Multi-stage Docker build solves: Guideline on how to reduce Docker images size.

Simeon Amiase — Sun, 04 Aug 2024 07:00:42 GMT

Introduction

A multistage Docker build is a technique used to optimize Docker images by reducing their size and complexity. In a multistage build, a Dockerfile contains multiple FROM statements, each representing a separate stage. The stages are used to build and compile the application in one or more intermediate containers, and then copy only the necessary artifacts into a final, minimal image. This approach helps to exclude build-time dependencies and files from the final image, resulting in smaller, more efficient images that are easier to deploy and maintain.

In this article, we will learn how to write a multistage Dockerfile and also without a multistage Dockerfile and build the images respectively.

This project will help visualize the size in images when they are built with multistage and also without multistage.

Prerequisites

Go (version 1.17 or higher)
Docker installed
A code editor (E.g Visual studio Code)

Setting up the project locally

clone the repo to your local machine

git clone https://github.com/SESUGH-OPS/Multistage-Docker-Build

After cloning the repo, you will have to remove the .git directory inorder for you to add your own .git directory

To remove the .git directory use the commands below

Linux and Mac users
```
  cd /path/to/your/repository
  rm -rf .git
```
Windows users
```
  cd C:\path\to\your\repository
  rmdir /s /q .git
```

Building the image without multibuild

First off we try building the docker image without multibuild

Navigate to the folder called Docker-without-multibuild
```
  cd Docker-without-multibuild
```
Create a dockerfile within the directory, you just navigated to
```
  touch Dockerfile
```
paste this code block within the dockerfile you created
```
  ###########################################
  # BASE IMAGE
  ###########################################

  FROM ubuntu 

  RUN apt-get update && apt-get install -y golang-go

  ENV GO111MODULE=off

  COPY . .

  RUN CGO_ENABLED=0 go build -o /app .

  ENTRYPOINT ["/app"]
```
Let us go over the commands

FROM ubuntu: This command sets the base image to the official ubuntu image. It means that the Docker image being built will start with an Ubuntu Linux environment. The absence of a tag means it uses the latest version available at the time of building.

RUN apt-get update: This command updates the package lists from the repositories, ensuring that the latest package versions are available for installation.

apt-get install -y golang-go: This installs the Go programming language and its dependencies in the container. The -y flag automatically confirms the installation, avoiding prompts.

ENV GO111MODULE=off: This sets the GO111MODULE environment variable to off. This configuration disables the Go module system, opting for the traditional GOPATH approach for dependency management.

COPY . .: This copies all files and directories from the context directory on the host machine (the directory containing the Dockerfile) into the current working directory inside the container. The first . refers to the source (the context directory), and the second . refers to the destination inside the container.

RUN: This command executes the following command inside the Docker container.

CGO_ENABLED=0: This sets the environment variable CGO_ENABLED to 0, which disables CGO (C Go). Disabling CGO ensures that the resulting Go binary is statically linked and doesn't rely on any C libraries, which can be beneficial for deployment.

go build -o /app .: This compiles the Go application. The -o /app option specifies that the output binary should be saved as /app in the container. The . specifies that the Go compiler should look for the main package in the current directory, which is where the application's source code is copied.

ENTRYPOINT: This sets the default command that will be executed when a container created from this image is started. The command is specified in execution form (using an array), which is preferred because it avoids issues with shell interpretation. In this case, it specifies that the compiled Go application binary located at /app should be executed when the container starts.
Run the command to build your image

docker build -t : .
e.g docker build -t webapp:v1 .

After building the image lets see the size of the image built by running the command

docker images

This brings out a display such as the picture below

From the image above we can see the size of the image to be over 600MB. The size on your end might be even higher.

Building the image with multibuild

Navigate to the folder called Docker-with-multibuild

cd Docker-with-multibuild

Create a dockerfile within the directory, you just navigated to

touch Dockerfile

paste this code block within the dockerfile you created

###########################################
# BASE IMAGE
###########################################

FROM ubuntu AS build

RUN apt-get update && apt-get install -y golang-go

ENV GO111MODULE=off

COPY . .

RUN CGO_ENABLED=0 go build -o /app .

##############################
## THE MAGIC OF MULTIBUILD
##############################

FROM scratch

# Copy the compiled binary from the build stage
COPY --from=build /app /app

# Set the entrypoint for the container to run the binary
ENTRYPOINT ["/app"]

Lets go over the commands

FROM ubuntu AS build: This specifies that the base image for this stage will be ubuntu, and it names this stage build. The alias (build) is going to be used later to reference this stage.

RUN apt-get update: This command updates the package lists to ensure that the latest versions of the packages are available.

apt-get install -y golang-go: This installs the Go programming language and its dependencies in the container. The -y flag automatically confirms the installation prompts.

ENV GO111MODULE=off: This sets the GO111MODULE environment variable to off. This disables the Go module system, opting for the traditional GOPATH approach for dependency management.

COPY . .: This copies all files and directories from the current directory on the host machine (the directory containing the Dockerfile) into the current working directory inside the container.

RUN: This command executes the following command inside the Docker container.

CGO_ENABLED=0: This sets the environment variable CGO_ENABLED to 0, which disables CGO (C Go). Disabling CGO ensures that the resulting Go binary is statically linked and doesn't rely on any C libraries.

go build -o /app .: This compiles the Go application. The -o /app option specifies that the output binary should be saved as /app in the container. The . specifies that the Go compiler should look for the main package in the current directory.

FROM scratch: This starts a new build stage using the scratch image, which is an empty image or a distroless image. This stage is used to create a minimal final image that only contains the compiled Go binary. Checkout distroless images here.

COPY --from=build /app /app: This copies the compiled binary from the build stage into the new image. The --from=build part specifies that the source of the copy is the build stage, and /app specifies the file to copy. The second /app is the destination path in the new image.

ENTRYPOINT ["/app"]: This sets the default command that will be executed when a container created from this image is started. The command is specified in execution form (using an array), which is preferred because it avoids issues with shell interpretation. In this case, it specifies that the compiled Go application binary located at /app should be executed when the container starts.

Run the command to build your image

docker build -t : .
e.g docker build -t webapp:v1 .

The result is a minimal Docker image that contains only the compiled Go application, reducing the image size and eliminating unnecessary dependencies.
Run the command below to see the size of the new image built

docker images

The display should have a minimalist image size such as the size below

This multibuild image ensures that the final deployed image is lean, secure, and contains only what is necessary to run the application, thus reducing potential vulnerabilities and resource consumption.

Conclusion

It's been a long ride. Congratulations on making it to the end and successfully building a docker image without multibuild and also with multibuild to see the difference in image size reduction and the use case. In this article, we covered the following:

Setup the project locally for build phase of the project
Create a dockerfile for docker-without-multibuild and build the image
Create a dockerfile for docker-with-multibuild and build the image
Compare the size of images between multibuild and without mulitbuild

hasta la próxima!!!!!!!