Blog Logo

20-Jun-2023 ~ 4 min read

How to create a multi-stage docker builds

docker

How to Create a Multi-Stage Dockerfile

Docker has revolutionized the way we build, ship, and run applications. One powerful feature of Docker is the ability to create multi-stage builds, which allow you to optimize the size and performance of your Docker images. In this article, we will explore how to create a multi-stage Dockerfile and leverage its benefits. Let’s dive in!

Table of contents

Understanding Multi-Stage Builds

In traditional Docker builds, each instruction in the Dockerfile results in a new layer being added to the image. This can lead to bloated images with unnecessary dependencies and files. Multi-stage builds solve this problem by allowing you to create intermediate stages within a single Dockerfile.

Each stage in a multi-stage build represents a separate build environment with its own set of instructions. You can selectively copy files and artifacts from one stage to another, discarding any unnecessary dependencies. This enables you to create lean and optimized images for production while still benefiting from a more feature-rich build environment during development.

The Syntax of a Multi-Stage Dockerfile

A multi-stage Dockerfile consists of multiple FROM instructions, each defining a separate build stage. Here’s the basic syntax:

# Stage 1: Build stage
FROM base-image as build-stage
# Add build instructions

# Stage 2: Production stage
FROM base-image as production-stage
# Add production instructions

In this example, we define two stages: the build stage and the production stage. Each stage has its own set of instructions, allowing us to control the contents of the resulting image.

Building an Example Multi-Stage Dockerfile

Let’s walk through an example to understand how multi-stage builds work. Suppose we have a Node.js application that needs to be built and then run in a production environment. Here’s a sample multi-stage Dockerfile for this scenario:

# Stage 1: Build stage
FROM node:18-alpine as build-stage

# Set working directory
WORKDIR /app

# Copy package.json and package-lock.json
COPY package*.json ./

# Install dependencies
RUN npm install

# Copy application code
COPY . .

# Build the application
RUN npm run build

# Stage 2: Production stage
FROM nginx:alpine as production-stage

# Copy the built artifacts from the build stage to the production stage
COPY --from=build-stage /app/dist /usr/share/nginx/html

# Expose the container's port
EXPOSE 80

# Start Nginx
CMD ["nginx", "-g", "daemon off;"]

In this example, the build stage uses the node:18-alpine base image and performs the necessary steps to build our Node.js application. It installs dependencies, copies the application code, and builds the application using the npm run build command.

The production stage uses the nginx:alpine base image and copies the built artifacts from the build stage into the /usr/share/nginx/html directory. It then exposes port 80 and starts the Nginx server.

By separating the build and production stages, we ensure that only the necessary artifacts are included in the final production image, resulting in a smaller and more secure image.

Building the Multi-Stage Docker Image

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

docker build -t my-app .

This command builds the Docker image based on the instructions in the Dockerfile and tags it with the name my-app. You can replace my-app with the desired name for your image.

Once the image is built, you can run a container based on this image using the docker run command:

docker run -p 80:80 my-app

This command starts a container based on the my-app image and maps port 80 of the container to port 80 of the host machine. You can access the running application by opening a web browser and navigating to http://localhost.

Conclusion

Multi-stage builds in Docker provide a powerful mechanism to optimize the size and performance of your Docker images. By separating the build and production stages, you can create lean and efficient images without sacrificing development convenience. Leveraging multi-stage builds helps streamline your Docker workflow and improves the overall efficiency of your application deployment. Experiment with multi-stage builds in your Docker projects and experience the benefits firsthand!