Docker has revolutionized how applications are developed, tested, and deployed in modern DevOps pipelines. By providing a standardized environment for running applications, Docker ensures that software behaves the same across development, staging, and production environments, minimizing the infamous “it works on my machine” problem.

An unoptimized docker image can lead to bloated containers, slower deployment times, increased security vulnerabilities, and higher resource usage, all of which can affect performance and scalability.

In this blog, we will dive into best practices for optimizing Docker images for production.

Firstly, understand the structure of Docker images and how Docker image layers function =>
👉 Docker Image Layers and How They Work

Best Practices for Building Efficient Docker Images

  1. Use Minimal Base Images
  2. Leverage Multi-Stage Builds
  3. Optimize Layer Caching
  4. Avoid Excessive Layers
  5. Use .dockerignore Effectively
  6. Keep Your Dockerfile Clean

1. Use Minimal Base Images

When it comes to Docker images, size matters—a lot! A smaller image has several key advantages that directly impact your production environment.

The base image you choose plays a critical role in the overall size of your Docker image. For production, it’s best to use lightweight, minimal images like alpine, scratch, or distroless. These images are slim, containing only the essential tools and libraries, which drastically reduces the image size.

FROM node:alpine  

# Instead of using large images like ubuntu
# Alpine is ~5 MB compared to hundreds of MB in larger images

2. Leverage Multi-Stage Builds

Multi-stage builds allow you to separate the build and runtime environments within a single Dockerfile. This helps keep your final image small by only including the necessary binaries or executables.

# Stage 1: Build the React app
FROM node:18-alpine AS builder
WORKDIR /app

COPY package.json package-lock.json ./
RUN npm install --frozen-lockfile


COPY . .
RUN npm run build

# Stage 2: Serve the app using an Nginx server
FROM nginx:alpine

RUN rm -rf /usr/share/nginx/html/*

COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Explanation of the Multi-Stage Build:

  • Stage 1 (Build Stage):
    • Base Image: The node:18-alpine image is a lightweight Node.js environment based on Alpine Linux, suitable for running the build process.
    • Caching Dependencies: Copying package.json and package-lock.json before the rest of the application files allows Docker to cache the dependency installation step if package.json hasn’t changed.
    • Building the App: The command npm run build compiles the React application into static files (/build directory) that can be served by any web server.
  • Stage 2 (Runtime Stage):
    • Base Image: The nginx:alpine image is used to serve the static files generated in Stage 1. Nginx is an efficient and lightweight server well-suited for production.
    • Copying Static Files: The built React app from Stage 1 is copied from /app/build into Nginx’s default serving directory.
    • Exposing Port: Nginx serves content on port 80, which is exposed for external access.
    • CMD: This command keeps Nginx running, ensuring it serves your React app.

Benefits of Multi-Stage Build for React:

  • Smaller Image Size: By using multi-stage builds, only the static files required to serve the React app are included in the final image. The Node.js build environment and development dependencies are discarded.
  • Efficient Caching: Docker can cache dependencies between builds, speeding up the build process when the application or dependencies change.
  • Security: By using the Nginx image in the second stage, no unnecessary tools or dependencies from Node.js are included in the final production image, reducing the attack surface.

3. Optimize Layer Caching

Docker caches layers, which allows for faster rebuilds if the layer hasn’t changed. To take advantage of this, ensure that you place frequently changing commands (like COPY) towards the end of the Dockerfile.

# Install dependencies first to take advantage of caching
RUN apt-get update && apt-get install -y curl

# Copy application files later
COPY . /app

4. Avoid Excessive Layers

Each RUN, COPY, and ADD instruction in your Dockerfile creates a new layer. Too many layers can unnecessarily bloat your image. Wherever possible, combine commands to reduce the layer count.

# Bad practice
RUN apt-get update
RUN apt-get install -y curl

# Good practice
RUN apt-get update && apt-get install -y curl

5. Use .dockerignore Effectively

Like .gitignore, a .dockerignore file helps exclude unnecessary files and directories (e.g., node_modules, test directories) from being copied into the image, reducing the overall size.

node_modules
tests
.git

6. Keep Your Dockerfile Clean

Keeping your Dockerfile clean and organized not only enhances readability but also ensures efficiency. This includes removing temporary files created during build processes and minimizing layers.

RUN apt-get install -y build-essential && rm -rf /var/lib/apt/lists/*

👉 Optimizing Docker Images for Security

Stay secure and build better! 😉