What does the multi-stage build option generate?

It splits the Dockerfile into a "builder" stage and a "production" stage from the same base image. The builder installs all dependencies and runs your build, while the production stage reinstalls dependencies in production mode (e.g. npm ci --production) and copies built artifacts such as /app/dist and /app/.next from the builder, yielding a leaner final image.

Which base images and templates are included?

Base images cover Node 18/20 (Alpine and full), Python 3.11/3.12 slim, Go 1.21 Alpine, Rust 1.75 Alpine, PHP 8.2 FPM, Nginx Alpine, Java 17 (Eclipse Temurin), plus Alpine, Ubuntu 22.04, and Debian. Quick-start templates include Node + Express, Next.js, React (Vite), FastAPI, Django, Go, Rust, Nginx static, Laravel, and Spring Boot.

How does it handle different package managers?

The selected package manager determines the COPY line for lockfiles: npm copies package*.json, Yarn copies package.json and yarn.lock, pnpm copies pnpm-lock.yaml, and Bun copies bun.lockb. These files are copied before the rest of the source so dependency installs stay cached across rebuilds.

Can I add environment variables and custom commands?

Yes. The Environment variables field emits one ENV line per entry, the custom COPY field emits a COPY instruction per line (otherwise it defaults to COPY . .), and the Additional RUN commands field emits a RUN per line. A non-root user value adds a USER instruction before the port is exposed.

Are my settings remembered between visits?

Yes. The full configuration is saved to your browser’s local storage and restored on your next visit. Use the Reset button to return to the defaults, and copy or download the result as a file named Dockerfile.

Dockerfile Generator

Generate optimized Dockerfiles for your applications with support for multiple frameworks and base images

About this ToolHow it works, benefits & use cases

Configure a Dockerfile through form fields and watch the instructions assemble live, no Dockerfile syntax recall needed. Pick a base image from a curated list spanning Node, Python, Go, Rust, PHP, Java, Nginx, Alpine, Ubuntu, and Debian; set the working directory, package manager (npm, Yarn, pnpm, or Bun), install and build commands, the start command, exposed port, and a non-root user. Multi-line fields let you add ENV variables, custom COPY instructions, and extra RUN commands. The generator orders instructions for good layer caching — copying package files and installing dependencies before the rest of the source — and a multi-stage toggle produces a builder stage plus a slimmer production stage that installs production dependencies only and copies built artifacts across. Ten quick-start templates (Node + Express, Next.js, React/Vite, FastAPI, Django, Go, Rust, Nginx static, Laravel, Spring Boot) pre-fill sensible defaults. Settings persist locally and the Dockerfile downloads with one click.

How to Use

1Optionally click a quick-start template (Next.js, FastAPI, Go, and others) to pre-fill the configuration.
2Choose a Base image and set the Working directory, Package manager, and Install command.
3Add a Build command, Start command, Expose port, and a non-root user as needed.
4Use the multi-line fields for environment variables, custom COPY instructions, and additional RUN commands.
5Tick "Enable multi-stage build" for a smaller production image, then copy or download the generated Dockerfile.

Key Benefits

Curated base images across Node, Python, Go, Rust, PHP, Java, Nginx, and Linux distros
Ten quick-start templates for popular frameworks that pre-fill the whole config
Instruction order optimised for Docker layer caching (deps before source)
Multi-stage build option that adds a slim production stage with prod-only deps
Package-manager-aware COPY lines for npm, Yarn, pnpm, and Bun lockfiles
Multi-line fields for ENV, custom COPY, and extra RUN instructions
Live preview, local persistence, and one-click download as Dockerfile

Common Use Cases

Scaffolding a Dockerfile for a new Node, Python, or Go service from a template
Producing a multi-stage build to shrink a production image
Standardising base images and non-root users across a team’s services
Learning Dockerfile structure and good caching order by example
Swapping a project’s package manager and seeing the matching COPY/RUN lines

Quick start templates

Configuration

Base image

Working directory

Package manager

Install command

Build command (optional)

Start command

Expose port (optional)

Run as user (optional)

Environment variables (one per line)

Custom COPY instructions (one per line)

Additional RUN commands (one per line)

Enable multi-stage build (smaller image size)

Dockerfile

Updates live as you edit the configuration above

# Generated Dockerfile

FROM node:20-alpine

WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci

# Copy application files
COPY . .

EXPOSE 3000

# Start application
CMD ["npm", "start"]

Dockerfile best practices

Use specific image tags instead of latest for production
Use multi-stage builds to reduce final image size
Order instructions from least to most frequently changing for better cache reuse
Use .dockerignore to exclude unnecessary files
Run as non-root user for better security
Prefer Alpine images when possible for smaller size

Was this tool helpful?

Share Your Experience

Help others discover this tool!

Share on