Dockerizing a Node.js Application with Multi-Stage Builds#

Step 1: Clone the Repository#

First, let’s clone a simple Node.js application from GitHub:

1
git clone https://github.com/yourusername/nodejs-express-app.git
2
cd nodejs-express-app

Step 2: Explore docker init#

Before we create our Dockerfile, let’s explore the docker init command:

1
docker init

This command initiates an interactive session to help set up a new Docker project. For our Node.js app, we might answer:

• Application platform: Node.js
• Application entrypoint: node src/index.js
• Port to expose: 3000

Docker will generate a Dockerfile, .dockerignore, and compose.yaml based on these answers.

Step 3: Create a Multi-Stage Dockerfile#

While docker init provides a good starting point, let’s create a more optimized Dockerfile using multi-stage builds:

1
# Stage 1: Build
2
FROM node:18-alpine AS build
3

4
WORKDIR /app
5

6
COPY package*.json ./
7
RUN npm ci
8

9
COPY . .
10
RUN npm run build
11

12
# Stage 2: Production
13
FROM node:18-alpine
14

15
WORKDIR /app
16

17
COPY --from=build /app/dist ./dist
18
COPY --from=build /app/package*.json ./
19
RUN npm ci --only=production
20

21
EXPOSE 3000
22
CMD ["node", "dist/index.js"]

Let’s break down this Dockerfile:

1. We use two stages: build and production.
2. In the build stage, we install all dependencies and build the application.
3. In the production stage, we only copy the built artifacts and production dependencies.

Step 4: Build the Docker Image#

Now, let’s build our Docker image:

1
docker build -t nodejs-express-app .

This command builds a Docker image tagged as nodejs-express-app using the Dockerfile in the current directory.

Step 5: Run the Docker Container#

With our image built, we can now run a container:

1
docker run -p 3000:3000 nodejs-express-app

This command runs a container from our image, mapping port 3000 in the container to port 3000 on our host machine.

Benefits of Multi-Stage Builds#

Multi-stage builds offer several advantages:

1. Smaller final image: By only copying necessary files from the build stage, we reduce the final image size.
2. Improved security: Build dependencies and sensitive data don’t make it into the final image.
3. Faster builds: Subsequent builds can leverage Docker’s layer caching more effectively.
4. Easier maintenance: Separating build and runtime environments makes the Dockerfile easier to understand and maintain.

Best Practices for Writing Dockerfiles#

After reviewing the Docker documentation on best practices, here are some key points:

1. Use official base images: They’re maintained and typically more secure.
2. Minimize the number of layers: Combine commands where it makes sense (e.g., using && in RUN instructions).
3. Use .dockerignore: Exclude unnecessary files from the build context.
4. Use specific tags: Instead of latest, use specific version tags for base images.
5. Use multi-stage builds: As we’ve done, to optimize image size and build process.
6. Order instructions from least to most frequently changing: This optimizes caching.
7. Use environment variables: For values that might change between environments.

Conclusion#

We’ve successfully dockerized a Node.js application using multi-stage builds! Here’s a quick recap of the commands we used:

• git clone: Clone the repository
• docker init: Initialize a new Docker project
• docker build: Build a Docker image
• docker run: Run a Docker container

By following these steps and best practices, you can create efficient, secure, and maintainable Docker images for your applications.

You can find the complete code for this project, including the Dockerfile, in my GitHub repository: https://github.com/yourusername/nodejs-express-app

Happy Dockerizing!