A Beginner’s Guide to a Multistage Docker Build

Docker multi-stage build is the process of specifying a series of builds in a Dockerfile. In other words, the Dockerfile contains multiple “FROM” statements in a single file, and the new from statement utilizes different or previous base instructions. The multistage build enables developers to break down the development process into multistage. Moreover, the base instruction is referred to as installation or setup instructions, and other instructions use dependencies of base instruction to function properly.

This write-up will provide a guide to a multistage Docker build.

A Beginner’s Guide to a Multistage Docker Build

In order to create a Docker image through simple Dockerfile, and multistage Dockerfile builds, take a look at the listed methods:

How to Build a Simple Docker Image?
How to Build a Docker Image From Multistage Dockerfile?

How to Build a Simple Docker Image?

To create a simple Docker image using a simple Dockerfile, go through the given instructions.

Step 1: Open Terminal
From the Windows “Startup” menu, open the Git terminal:

Step 2: Create New Directory
Next, create a new project directory using the given command:

$ mkdir Multistage

After that, open the project directory with the help of the “cd” command:

$ cd Multistage

Step 3: Create Program File
Create and open a new program file to implement the “golang” program. For instance, we have created a “main.go” file:

$ nano main.go

Paste the provided code in the “main.go” file. This program will print the simple output “Hello! Welcome to LinuxHint Tutorial” on the local host:

import (
"fmt"
"log"
"net/http"
)

func handler (w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello! Welcome to LinuxHint Tutorial")
}
func main () {
http.HandleFunc("/", handler)
log.Fatal(http.ListenAndServe("0.0.0.0:8080", nil))
}

Press “CTRL+O” to save the changes and “CTRL+X” to exit.

Step 4: Create DockerFile
Create and open a new Dockerfile in the Nano text editor using the “nano Dockerfile” command:

$ nano Dockerfile

Paste the following code inside the “Dockerfile” that will instruct the container on how to deploy the project:

FROM golang:1.8
WORKDIR /go/src/app
COPY main.go .
RUN go build -o webserver .

CMD ["./webserver"]

Press “CTRL+O” to save the file and “CTRL+X” to exit the editor:

Step 5: Create Docker Image
With the help of Dockerfile, create a new Docker image through the “docker build” command. The “-t” tag is used to specify the image tag/name:

$ docker build -t new-web-image .

Step 6: Run Docker Image
After creating the Docker image, utilize the below-mentioned command to run the Docker image. The “-p” option is used to specify the port number where the Docker container will execute the program:

$ docker run -p 8080:8080 new-web-image

After that, navigate to “http://localhost:8080” to check whether the application is running or not:

From the above output, you can see that we have successfully deployed the application on localhost:

Step 7: Check Docker Images
Lastly, execute the “docker images <image-name>” command to check the additional information about the newly created Docker image:

$ docker images new-web-image

It can be observed that the size of the Docker image is too huge to execute the small project. In such a scenario, the multi-stage build can be utilized to reduce the Docker image size:

How to Build a Docker Image From Multistage Dockerfile?

To create a multistage Dockerfile to break down the development processes into stages and to reduce the image size, take a look at provided steps.

Step 1: Open Dockerfile
First, open the Dockerfile in the “Nano text editor” through the mentioned command:

$ nano Dockerfile

Step 2: Create Multistage Dockerfile
Paste the following code in Dockerfile. It can be noticed that the Docker file contains more than one “FROM” statement, which means we are creating a multi-stage Dockerfile:

FROM golang:1.8 AS base
WORKDIR /go/src/app
COPY main.go .
RUN go build -o webserver .

FROM alpine
WORKDIR /app
COPY --from=base /go/src/app /app/
CMD ["./webserver"]

Press “CTRL+O” to save changes and “CTRL+X” to exit the editor.

Step 3: Create Docker Image
Now, build the new Docker image with the help of a multistage build. For this purpose, execute the given command:

$ docker build -t new-web-image .

Again, check the additional information about the Docker image through the “docker images” command:

$ docker images new-web-image

The output shows that we have successfully created a docker file and the size of the Docker file is reduced to only “12.9MB”:

Step 4: Run Docker Image
Lastly, run the Docker image to execute the container to verify whether the Docker image is working properly or not:

$ docker run -p 8080:8080 new-web-image

Open the local host server by navigating to the “http://localhost:8080” on the browser:

The output shows that we have successfully deployed the program through a multistage build.

Conclusion

The Docker multistage build specifies the series of builds into stages. To create a multistage Dockerfile, specify more than one “FROM” statement and refer to the first “FROM” statement as the base build. After that, create a new Docker image using the “docker build -t <image-name> .” command. The post has elaborated a complete guide to a multistage Docker build.

A Beginner’s Guide to a Multistage Docker Build