Why should I use multi-stage builds?

Multi-stage builds let you use a full build environment (with compilers, dev dependencies, etc.) in one stage and then copy only the final artifacts into a minimal runtime image. This dramatically reduces image size and attack surface.

What base image should I use?

Alpine-based images (e.g. node:20-alpine, python:3.12-alpine) are the smallest and most common choice. For applications that require glibc, use Debian slim variants like node:20-slim. Avoid using 'latest' tags since they can change unexpectedly.

How do I reduce my Docker image size?

Use multi-stage builds, choose Alpine or slim base images, combine RUN commands to reduce layers, add a .dockerignore file, and remove caches and temporary files in the same RUN instruction where they are created.

How to Create a Dockerfile

5 min readDevOps

A Dockerfile is a plain-text recipe that tells Docker how to build an image for your application. Getting the instructions right, choosing the correct base image, minimizing layer count, and avoiding security pitfalls, makes the difference between a slim, fast container and a bloated, insecure one. This guide covers the essentials and shows you how to generate a solid Dockerfile in seconds.

Quick Steps

1
Open the Dockerfile Generator
Go to the Dockerfile Generator in Toolin's DevOps category.
2
Select your stack
Pick the language, framework, and runtime version for your project.
3
Set build options
Configure the package manager, build command, and entry point.
4
Review the output
Read through the generated Dockerfile and confirm it matches your project structure.
5
Copy to your repo
Copy the Dockerfile and save it at the root of your project.
6
Build and test
Run 'docker build -t my-app .' and 'docker run -p 3000:3000 my-app' to verify.

Dockerfile Generator

Generate Dockerfiles for various programming languages

Open Tool

Anatomy of a Dockerfile

# 1. Base image
FROM node:20-alpine AS builder

# 2. Set working directory
WORKDIR /app

# 3. Install dependencies (cached layer)
COPY package.json pnpm-lock.yaml ./
RUN corepack enable && pnpm install --frozen-lockfile

# 4. Copy source and build
COPY . .
RUN pnpm build

# 5. Production stage
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules

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

Key Dockerfile Instructions

FROM — sets the base image; always use specific tags like node:20-alpine rather than latest
WORKDIR — sets the working directory inside the container for subsequent instructions
COPY / ADD — copies files from the build context into the image; prefer COPY over ADD for simple file copies
RUN — executes commands during the build, such as installing dependencies or compiling code
EXPOSE — documents which port the container listens on at runtime
CMD / ENTRYPOINT — specifies the default command when the container starts

Using the Dockerfile Generator

Choose your language or framework

Select from options like Node.js, Python, Go, Rust, Java, or static HTML. The generator applies best-practice defaults for each.

Configure build settings

Set options such as the Node version, package manager, build command, and entry point. The form adapts to your chosen stack.

Review the generated Dockerfile

The tool produces a multi-stage Dockerfile with security hardening, layer caching, and slim base images.

Copy and add to your project

Copy the Dockerfile to your project root and build with 'docker build -t my-app .'.

Best Practices for Production Dockerfiles

Use multi-stage builds to keep the final image small by discarding build-time dependencies
Pin base image versions with a specific tag and digest to ensure reproducible builds
Copy dependency manifests before source code so Docker can cache the install layer
Run the application as a non-root user by adding a USER instruction
Add a .dockerignore file to exclude node_modules, .git, and other unnecessary files from the build context

Try Dockerfile Generator Now — Free, No Sign-up

Frequently Asked Questions

Why should I use multi-stage builds?: Multi-stage builds let you use a full build environment (with compilers, dev dependencies, etc.) in one stage and then copy only the final artifacts into a minimal runtime image. This dramatically reduces image size and attack surface.
What base image should I use?: Alpine-based images (e.g. node:20-alpine, python:3.12-alpine) are the smallest and most common choice. For applications that require glibc, use Debian slim variants like node:20-slim. Avoid using 'latest' tags since they can change unexpectedly.
How do I reduce my Docker image size?: Use multi-stage builds, choose Alpine or slim base images, combine RUN commands to reduce layers, add a .dockerignore file, and remove caches and temporary files in the same RUN instruction where they are created.