Dockerfile generator

Pick a language and get a Dockerfile you can start from: dependencies installed before the source is copied so the cache works, a small final image, and an unprivileged user. Edit the result to fit your project.

Language

Version tagLeave empty for the default: Node 22, Python 3.13, Go 1.24, Java 21. Check which versions are current.

Entry pointNode: start file (server.js). Python: script (app.py). Go: package to build (. or ./cmd/server). Java: jar name in target/ (app.jar). Empty uses the default.

Port to expose

Multi-stage build Run as a non-root user

Dockerfile

# syntax=docker/dockerfile:1

FROM node:22-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build --if-present

FROM node:22-alpine
ENV NODE_ENV=production
WORKDIR /app
COPY --from=build --chown=node:node /app ./
RUN npm prune --omit=dev
EXPOSE 3000
USER node
CMD ["node", "server.js"]

A starting point, not a finished file: check the base image tags, the commands against your project layout, and add a .dockerignore (for example node_modules, .git, target).

Runs in your browser: nothing you enter is sent anywhere.

How to use it

Choose the language and, if you need one, a version tag.
Set the entry point and port, or leave them empty for the defaults.
Choose multi-stage and non-root options.
Copy the file to Dockerfile in your project root and build with docker build -t myapp ..

What the templates do

Each template copies the dependency manifest first and installs dependencies, then copies the source. That way Docker reuses the cached dependency layer while only your code changes.

Node runs npm ci, builds if a build script exists, and prunes dev dependencies in the final stage.
Python builds a virtual environment in the first stage and copies it into a slim image.
Go builds a static binary with CGO_ENABLED=0.
Java builds with Maven and runs the jar on a JRE image.

Example

Node with defaults gives a two-stage file based on node:22-alpine that exposes port 3000, switches to the node user and runs node server.js.

Tips

Pin versions more precisely for reproducible builds.
Never copy secrets into the image; pass them at run time.

Frequently asked questions

What does the multi-stage option do?

The first stage installs build tools and compiles or installs dependencies. The last stage starts from a clean image and copies in only what is needed to run. The final image is smaller and carries fewer tools for an attacker to use. For Go it ends in a distroless static image, for Java in a JRE image.

Why run as a non-root user?

If the app is compromised, the attacker has the rights of that user instead of root inside the container. The templates use the built-in node user, or create an app user. The Go multi-stage image uses distroless's nonroot variant.

Do I need to change anything before building?

Probably. The Node template expects package.json and a lockfile, Python a requirements.txt, Go go.mod and go.sum, Java a Maven pom.xml and a jar in target/. Adjust the commands if your project is laid out differently.

Are the image versions up to date?

The defaults are examples of widely used tags and may not be the newest. Check Docker Hub for the current ones and set the version field.

Does this send my settings anywhere?

No. The file is generated in your browser.

More in Developer

All tools in this category: Developer ·Updated November 3, 2026