How to Reduce Docker Image Size by Up to 90%

When it comes to Docker images, size matters. A smaller image size can lead to faster deployments, reduced storage costs, and improved overall performance. However, creating a Docker image that is both functional and lightweight can be a daunting task. In this article, we'll explore four effective methods to reduce the size of a Docker image created from a Dockerfile, and provide a step-by-step guide on how to achieve this.

Method 1: Modifying Dependencies

One of the most significant contributors to a large Docker image size is the number of dependencies installed in the image. To reduce the size of your Docker image, it's essential to minimize the number of dependencies and only include the ones that are absolutely necessary for your application to run.

Here are some tips to modify dependencies and reduce image size:

Identify unnecessary dependencies by analyzing the RUN commands in your Dockerfile.
Remove or replace dependencies that are not essential for your application's functionality.
Use a RUN command to install only the required dependencies, rather than installing entire software packages.
Consider using a Layers concept, where you install necessary packages in separate layers, making it easier to remove unwanted packages in the final layer.

Method 2: Using a Smaller Base Image

The base image used in your Dockerfile can significantly impact the overall size of your Docker image. Using a lightweight base image can help reduce the size of your Docker image.

Here are some tips to choose a smaller base image:

Use Alpine Linux as your base image, which is a lightweight Linux distribution that is only 5MB in size.
Consider using other lightweight base images, such asbusybox orscratch, depending on your application's requirements.
Avoid using large base images, such as Ubuntu or CentOS, unless absolutely necessary.

Method 3: Using Multi-Stage Builds

Multi-stage builds are a powerful feature in Docker that allows you to separate the build environment from the runtime environment. This approach can help reduce the size of your Docker image by removing unnecessary build artifacts from the final image.

Here's an example of how to use multi-stage builds:

Create a build stage in your Dockerfile, where you install all the necessary dependencies required for building your application.
Create a runtime stage, where you copy only the necessary files from the build stage, and remove any unnecessary dependencies.
Use the --from flag to specify the build stage as the source for the runtime stage.

Method 4: Using Webservers (e.g. Nginx)

Using a webserver, such as Nginx, as a reverse proxy can help reduce the size of your Docker image. By serving your application through a webserver, you can remove unnecessary dependencies and reduce the overall size of your image.

Here's an example of how to use Nginx as a reverse proxy:

Install Nginx in your Dockerfile, using a lightweight package manager like apk.
Configure Nginx to serve your application, by creating a configuration file and copying it to the correct location.
Remove any unnecessary dependencies, such as httpd or lighttpd, from your Docker image.

Step-by-Step Guide

Now that we've discussed the four methods to reduce Docker image size, let's create a Docker image using these techniques. Here's a step-by-step guide to get you started:

Step 1: Set up an EC2 instance

Create an EC2 instance on AWS, using a lightweight Linux distribution like Ubuntu or CentOS.
Ensure that the instance has a sufficient amount of storage and memory, depending on your application's requirements.

Step 2: Update the system and install Docker

Connect to your EC2 instance using SSH, and update the system using the following command: sudo yum update -y.
Install Docker on your EC2 instance, using the following command: sudo yum install docker -y.
Start the Docker service, using the following command: sudo systemctl start docker.
Enable the Docker service to start automatically on boot, using the following command: sudo systemctl enable docker.

Step 3: Create a Dockerfile

Create a new file, called Dockerfile, in a text editor like Vim or Emacs.
Add the following lines to the Dockerfile, to create a basic Docker image using Alpine Linux as the base image:

# Stage 1: Build the React app
FROM node:alpine AS build
WORKDIR /app

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

# Install only production dependencies
RUN npm ci --production

# Copy the rest of the application code
COPY . .

# Build the app
RUN npm run build

# Stage 2: Serve the app with Nginx
FROM nginx:alpine
RUN rm -rf /usr/share/nginx/html/*

# Copy the built React app from the previous stage
COPY --from=build /app/build /usr/share/nginx/html

Modify the Dockerfile to include the necessary dependencies and configurations for your application.

Conclusion

Reducing Docker image size is crucial for faster deployments, reduced storage costs, and improved overall performance. By using the four methods discussed in this article – modifying dependencies, using a smaller base image, using multi-stage builds, and using webservers like Nginx – you can create a lightweight and efficient Docker image. Follow the step-by-step guide to create a Docker image using these techniques, and optimize your application's performance today!