Streamlining Build Process using Multi Stage Docker Builds

4 min readSep 3, 2024

What are Multi-Stage Docker Builds?

Multi-stage builds in Docker allow you to use multiple FROM statements within a single Dockerfile, enabling you to create different stages in the build process. Each stage can use a different base image, and you can selectively copy artifacts from one stage to another. This approach is particularly useful for optimizing the final Docker image, as it allows you to keep only the necessary files and dependencies in the production image, resulting in a smaller, more efficient image.

A single docker file can help you create multi stage images. Image by Nex Softsys.

Why use Multi-Stage Builds?

Reduce Image Size: By separating the build environment from the runtime environment, you can exclude unnecessary files and dependencies from the final image, significantly reducing its size.
Improve Security: Smaller images with fewer depende ncies reduce the attack surface, making your containers more secure.
Simplify CI/CD Pipelines: Multi-stage builds can streamline your CI/CD process by combining multiple build steps into a single Dockerfile, reducing complexity.

How Multi Stage Docker Impacts the Workflow. Image by Jatin S.

How Multi-Stage Builds work?

In a multi-stage Dockerfile, you define multiple stages using FROM statements. Each stage can have its own base image and perform specific tasks, such as compiling code, running tests, or packaging the application. You can then copy the required artifacts from one stage to the next using the COPY --from=<stage> directive.

Step by Step Example using a Simple Go Application

Let’s walk through an example of using a multi-stage build to create a Docker image for a simple Go application.

Please note that the following code for the program and the Dockerfile is generated using ChatGPT.

1. Creating a simple Go Application

Let’s start by creating a simple helloworld program and name the file main.go:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

2. Writing a Multi Stage Docker file:

Next, create a Dockerfile that uses multi-stage builds to compile the Go application and create a lean, production-ready image.

# Stage 1: Build the Go application
FROM golang:1.19 AS builder

# Set the working directory inside the container
WORKDIR /app

# Copy the Go source code to the container
COPY . .

# Build the Go application
RUN go build -o myapp

# Stage 2: Create a smaller image for production
FROM alpine:latest

# Set the working directory inside the container
WORKDIR /app

# Copy the built binary from the builder stage
COPY --from=builder /app/myapp .

# Command to run the application
CMD ["./myapp"]

Explanation:

Stage 1 (Builder): This stage uses the official Go image (golang:1.19) to compile the application. The RUN go build -o myapp command compiles the Go code into a binary named myapp.
Stage 2 (Production): This stage uses a minimal base image (alpine:latest) to create a lean production image. The compiled binary is copied from the builder stage to this final stage using COPY --from=builder. The final image only contains the binary and the necessary runtime dependencies.

3. Build the Docker Image:

To build the Docker image, navigate to the directory containing your Dockerfile and run the following command:

docker build -t myapp:latest .

4. Run the Container

Once the image is built, you can run it using the following command:

docker run --rm myapp:latest

This will start a container that runs your Go application, and you should see the following output:

Hello, World!

Benefits of This Approach

Smaller Image Size: The final Docker image only includes the compiled Go binary and the minimal dependencies from the Alpine image, reducing the image size significantly compared to including the entire Go build environment.
Isolating Build and Runtime Environments: By using separate stages for building and running the application, we ensure that the runtime environment is clean and free from unnecessary build tools and libraries. This reduces the risk of potential vulnerabilities and keeps the production environment lightweight.
Efficient Build Process: By separating the build and runtime environments, you ensure that only the necessary artifacts are included in the final image, leading to faster deployments and reduced resource usage.

Conclusion

Multi-stage Docker builds are a powerful tool for creating optimized, production-ready Docker images. By splitting the build process into multiple stages, you can keep your images lean, secure, and efficient. This approach is particularly valuable for projects where minimizing image size and complexity is crucial, such as in CI/CD pipelines and cloud deployments.