Docker Best Practices: Multi-stage Docker build

Utilizing multi-stage Docker builds represents a pinnacle best practice in the domain of containerization, revolutionizing the way developers craft and optimize Docker images. This innovative approach to building container images offers an array of benefits, ranging from enhancing image efficiency and reducing overhead to streamlining development workflows and minimizing security risks.

What is a multi-stage build?

At its essence, the multi-stage build process enables developers to create optimized Docker images by segregating the build into multiple stages, each serving a specific purpose. This approach allows for the creation of intermediate images, where each stage focuses on specific tasks, such as compiling code, installing dependencies, and building the application. Consequently, the final image produced contains only the essential artifacts, excluding unnecessary build dependencies and intermediate files.

Why should we use a multi-stage Docker build

One of the key advantages of multi-stage builds lies in optimizing image size and reducing bloat. By discarding unnecessary build artifacts and dependencies in the final stage, developers create leaner, smaller Docker images. This reduction in image size not only accelerates image pull and deployment times but also minimizes the attack surface, bolstering the image's security posture. Moreover, the multi-stage build process significantly streamlines the development workflow. It facilitates a more organized and efficient development pipeline by separating the build stages, making the process more modular and maintainable. This modularity simplifies debugging, testing, and iterative development, enabling developers to iterate and refine code more rapidly. Furthermore, multi-stage builds promote better resource utilization. The elimination of redundant dependencies and intermediate artifacts optimizes resource allocation during the build process, reducing the overall resource overhead required for image creation. This efficiency in resource utilization not only speeds up the build process but also contributes to a more sustainable and scalable development environment.

Example

FROM node:18.13.0 AS angular-build
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm i
COPY . .
RUN npm run build -- --configuration production
FROM nginx:alpine
COPY --from=angular-build /usr/src/app/dist angular-client/* /usr/share/nginx/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]</p>

I’ve chosen to dockerize a simple Angular application. A very important part of the Dockerfile is the angular-build segment we see on the first line. The first part (line 1-6) handles the way we build our Angular app - provided we have installed all required dependencies, we run a production build of the product. Now the first part is complete, we don’t really need to use the bloated node image, we could copy the artifacts produced by the build and place them in a more optimized “environment” - a container that’s spun off from the nginx:alpine image. Why do we need more optimized images, you will ask? Well check out my other article and find out! The COPY instruction takes the artifacts from the angular-build and places them in a folder that could be utilized by Nginx. The EXPOSE 80 instruction lets the Docker engine know that the corresponding port will be utilized for the internal communication. </p>

To sum up

In conclusion, the adoption of multi-stage Docker builds is a cornerstone in modern containerization practices. Its ability to streamline the build process, reduce image size, enhance security, and improve resource utilization makes it an indispensable best practice for developers aiming to optimize their Docker workflows and create efficient, agile, and secure containerized applications.