Dockerfile Generator

How to use it

1. Pick the language and version. For Node.js, choose Alpine (smallest) or Debian slim (when native modules need glibc).
2. Enter the command that starts your app (Node.js, Python), or the package to build (Go). Java builds the jar with Maven.
3. Set the port, and a health check path if your app has one.
4. Save the result as Dockerfile next to your code, add a .dockerignore, and run docker build -t myapp .. If a COPY line then fails with “not found”, see failed to compute cache key.

What you get

• Multi-stage builds. Compilers, dev dependencies and build caches stay in the build stage; the final image gets only what runs. Go ends up on a distroless image with just the binary.
• A non-root user. If the app is ever compromised, the attacker isn’t root in the container — and much further from root on the host.
• Layers in the right order. The dependency files are copied and installed before your code, so a code change doesn’t reinstall every package. BuildKit cache mounts keep downloads between builds.
• Exec-form CMD (["node", "server.js"]), so your app — not a shell — receives SIGTERM and can shut down cleanly. A shell in between is the classic reason for exit code 137 after docker stop.
• A health check that works on slim images, using Node.js or Python itself instead of curl, which those images don’t have.
• A JVM sized for the container: -XX:MaxRAMPercentage=75 sets the heap from the container’s memory limit.

Every combination of options is checked automatically: linted with hadolint, then built and run with a small test app, which must answer on its health path, run as a non-root user, report healthy and stop within a few seconds of docker stop.

Common commands

docker build -t myapp .                       # build (BuildKit is the default since Docker 23)
docker run --rm --init -p 3000:3000 myapp     # run; --init passes signals on (needed for Node.js)
docker ps                                     # STATUS shows (healthy) / (unhealthy)
docker image history myapp                    # which layer is how big
docker image inspect -f '{{.Config.User}}' myapp   # which user it runs as
docker build --no-cache -t myapp .            # rebuild everything, ignoring the cache

FAQ

Why does docker stop take 10 seconds with my Node.js app?

As PID 1, a process gets no default signal handling from the kernel, and Node.js doesn’t install a SIGTERM handler of its own. docker stop sends SIGTERM, nothing happens, and after 10 seconds Docker kills it (exit code 137). Handle the signal in your app (process.on('SIGTERM', …): close the server, then exit), or run the container with --init (init: true in Compose). Gunicorn, Go programs and the JVM handle SIGTERM on their own.

Alpine or slim?

Alpine is smaller but uses musl instead of glibc. Pure JavaScript apps don’t care; npm packages with native code (image processing, some database drivers) may need to compile or may not work. If in doubt, use slim. For Python the generator always uses slim: packages with native code are published for glibc first; on Alpine (musl) some have no ready-made wheel and must be compiled, which needs a compiler and makes builds slow.

Why is npm start a bad CMD?

It starts npm, which starts your app as a child process; SIGTERM reaches npm, which may not pass it on, and npm adds memory and startup time. Run node directly.

My app can’t write files any more. Why?

The code is copied as root and the app runs as a non-root user, so it can read the code but not change it — which is the point. Write to a volume, or create a folder for the app user in the Dockerfile (RUN mkdir /app/data && chown node /app/data before USER).

How do I build it automatically?

The CI/CD Pipeline Generator writes a GitHub Actions or GitLab CI pipeline that tests your code, then builds this Dockerfile and pushes the image on every change.

Can I use this with Docker Compose?

Yes. Use build: . instead of image: for your service in the Docker Compose Generator output, and Compose builds this Dockerfile. If your app can’t reach the database from inside the container, see Docker: connection refused to localhost.

npm fails with EACCES during the build

Usually the Dockerfile switches to a non-root user too early. See npm “EACCES: permission denied”.

The container says “exec format error”

Usually an image built for another CPU architecture, or a script with no #! line. See exec format error. On Alpine, see also not found for a binary that exists.

The container says “executable file not found in $PATH”

The program isn’t in the image, or CMD was written as one string, ["npm start"]. The generator writes the exec form, one string per argument. See executable file not found in $PATH.