How To Optimize Dockerfile Instructions for Faster Build Times

Image by Editor | Midjourney & Canva

You can optimize Dockerfiles for faster build times by leveraging the build cache, reducing the build context, and more. This tutorial goes over these best practices to follow when creating Dockerfiles.

Prerequisites

You should have Docker installed. Get Docker for your operating system if you haven’t already.

1. Use a Smaller Base Image

First, you can start with a smaller base image to create minimal images. This reduces the overall size of the Docker image and speeds up the build process.

For example, when containerizing Python apps, you can start with a python:3.x-slim image, a smaller version of python:3.x, containing only the essential components needed to run Python instead of the default python:3.x.

Read How To Create Minimal Docker Images for Python Applications to learn more.

2. Leverage Docker Build Cache

The order of instructions in a Dockerfile influences the build times due to how Docker leverages its build cache.

Docker builds images by executing instructions in the Dockerfile sequentially—creating a new image layer for each instruction. If a layer hasn’t changed since the last build, Docker can reuse the cached layer, speeding up the build process.

So it’s important to optimize the order of instructions to maximize cache hits:

• Place frequently changing instructions last: Place instructions that change often, such as copying the application code towards the end of the Dockerfile. This reduces the chances of invalidating the cache for the entire build.
• Place less frequently changing instructions early: Instructions like installing OS packages, setting environment variables, and installing dependencies (if dependencies don’t change often) should be placed early to maximize cache hits.

Let’s take an example Dockerfile:

# Suboptimal ordering
FROM python:3.11-slim

# Set the working directory
WORKDIR /app

# Copy the entire application code
COPY . .

# Install the required Python packages
RUN pip install --no-cache-dir -r requirements.txt

# Expose the port on which the app runs
EXPOSE 5000

# Run the application
CMD ["python3", "app.py"]

In this initial Dockerfile, any change in the application code will invalidate the cache for the entire build process, including the installation of dependencies.

Here’s the optimized version:

# Better ordering of instructions
FROM python:3.11-slim

# Set the working directory
WORKDIR /app

# Install dependencies
COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Copy the current directory contents into the container at /app
COPY . .

# Expose the port on which the app runs
EXPOSE 5000

# Run the application
CMD ["python3", "app.py"]

In this optimized Dockerfile, if there’s a change in the application code, Docker can still use the cached layers for installing dependencies. This way, changes to application code do not unnecessarily trigger reinstallation of dependencies.

3. Use Multi-Stage Builds

Multi-stage builds allow you to separate the build environment from the final runtime environment, which can reduce the size of the final image by only including necessary runtime dependencies.

Consider the following Dokcerfile with multi-stage build:

# Build stage
FROM python:3.11 AS builder
RUN apt-get update && apt-get install -y build-essential
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Final stage
FROM python:3.11-slim
COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin
COPY . /app
WORKDIR /app
CMD ["python3", "app.py"]

In this example, the build dependencies are installed in the builder stage, and only the necessary runtime dependencies are copied to the final image.

4. Minimize Build Context with .dockerignore Files

Ensure you have a .dockerignore file to exclude unnecessary files from being copied into the Docker context, reducing the build time. Similar to .gitignore, this file tells Docker which files to ignore during the build process, reducing the context size.

In the .dockerignore file, you can include temporary files, virtual environments, IDE settings, and other unnecessary files that you do not want included in the build context.

From reducing the base image size to optimizing the build context, these optimizations should help you make your Docker builds more efficient.

Additional Resources

 
The following resources should learn more:

Bala Priya C is a developer and technical writer from India. She likes working at the intersection of math, programming, data science, and content creation. Her areas of interest and expertise include DevOps, data science, and natural language processing. She enjoys reading, writing, coding, and coffee! Currently, she’s working on learning and sharing her knowledge with the developer community by authoring tutorials, how-to guides, opinion pieces, and more. Bala also creates engaging resource overviews and coding tutorials.