Sebastian Drozd
Blog Projects About Me

Docker Optimization for Node.js Applications

Docker is an essential tool for deploying and running applications in a consistent environment. However, improperly optimized Docker images can lead to large sizes, slow builds, and inefficient resource usage. In this post, we'll explore best practices for optimizing Docker containers specifically for Node.js applications.

1. Use the Right Base Image

Choosing the right base image significantly impacts the size and security of your container.

Recommended Base Images:

  • node:alpine – A minimal image (~5MB) that is great for production.
  • node:slim – A smaller version of the full Node.js image, excluding unnecessary tools.

Example:

FROM node:18-alpine

Alpine-based images reduce size but may require additional dependencies.

2. Leverage Multi-Stage Builds

Multi-stage builds help reduce the final image size by separating build dependencies from the runtime.

Example:

# Stage 1: Build
FROM node:18-alpine AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
CMD ["node", "dist/index.js"]

This ensures that only the essential files are included in the final image.

3. Minimize Layers and Reduce Image Size

Every RUN, COPY, or ADD creates a new layer. Merging commands into a single RUN helps reduce layers.

Before:

RUN apt-get update
RUN apt-get install -y curl
RUN rm -rf /var/lib/apt/lists/*

Optimized:

RUN apt-get update && 
    apt-get install -y curl && 
    rm -rf /var/lib/apt/lists/*

4. Use .dockerignore to Reduce Build Context

Avoid copying unnecessary files into the image by defining a .dockerignore file:

node_modules
npm-debug.log
dist
.env
.git

This prevents large or sensitive files from being included in the build.

5. Optimize Caching with Layer Ordering

Docker caches layers, so placing frequently changing files later in the Dockerfile helps optimize builds.

Example:

# Copy dependencies first (cached if unchanged)
COPY package.json package-lock.json ./
RUN npm ci --only=production

# Copy application code last (changes often)
COPY . .

This ensures that the dependencies are not reinstalled unless package.json changes.

6. Run as a Non-Root User

Running containers as root is a security risk. Create a non-root user:

RUN addgroup -S app && adduser -S app -G app
USER app

7. Use CMD Instead of ENTRYPOINT

For most applications, CMD is preferable as it allows for easier command overrides.

CMD ["node", "dist/index.js"]

Use ENTRYPOINT only when you want to enforce a specific command behavior.

Conclusion

By following these Docker optimization techniques, you can reduce image size, improve build efficiency, and enhance security for your Node.js applications. Implement these best practices in your workflow and enjoy faster, leaner, and more secure deployments!

Happy coding! 🚀