All Dockerizers

.NET Dockerfile generator

Generate a production Dockerfile for an ASP.NET Core app — published framework-dependent, cross-compiled without emulation, running as the built-in app user.

Configure

Used for the image tag, the compose service and the OCI labels.
The port the app listens on inside the container. Keep it above 1024 so the process can bind it without root.
The .csproj that produces the web application.
The DLL the runtime image executes — usually <ProjectName>.dll.
Adds the database to docker-compose.yml with a healthcheck, a named volume and a DATABASE_URL wired into the app.
Adds Redis to docker-compose.yml and exposes REDIS_URL to the app.

Loading...

What this Dockerfile does

Nothing flagged

  • Good practice: Multi-stage build (2 stages)

    Compilers, dev dependencies and source files stay in the build stages. Only the runtime artefacts are copied into the final image.

  • Good practice: Runs as $APP_UID, not root

    A container escape from a root process is a host root process. Dropping privileges is the cheapest hardening step there is.

  • Good practice: .dockerignore keeps secrets out of the build context

    `.git`, `.env` and local dependency folders never reach the daemon, so they cannot end up in a layer or in `docker history`.

  • Good practice: Dependency cache persists across builds

    BuildKit cache mounts keep the package manager store outside the image. Rebuilds after a lockfile change reuse everything already downloaded, and the cache adds nothing to the final size.

  • Good practice: Healthcheck defined

    Docker, Compose and Easypanel can tell the difference between a running process and a working app, and restart it when it wedges.

  • Good practice: Uses the image's built-in non-root user

    Microsoft's .NET 8+ images define $APP_UID (1654), so there is no user to create and the default HTTP port is already 8080 rather than 80.

  • Good practice: Cross-compiles rather than emulating

    `-a $TARGETARCH` makes the SDK produce output for the target architecture while running natively on the builder. Emulating the SDK under QEMU is many times slower.

  • Note: Requires BuildKit

    BuildKit is the default builder in Docker 23 and later. On anything older, export `DOCKER_BUILDKIT=1` before building.

  • Note: The healthcheck expects a /health endpoint

    Map one with `app.MapHealthChecks("/health")`, or point the probe somewhere that already responds.

How to use it

Everything runs locally. Nothing is uploaded, and no account is needed.

  1. Drop the files into your project root

    Every generated file belongs next to your package manifest — the Dockerfile references paths relative to the build context, so nesting them in a subfolder breaks the COPY lines.

  2. Build the image

    docker build -t dotnet-app .

  3. Run it

    docker run --rm -p 8080:8080 dotnet-app

.NET in Docker

Related generators

Spring Boot

JVM & .NET

Go

Go & Rust

Rust

Go & Rust

Node.js

JavaScript
map illustration

Join 145,000+ self-hosters.

Free plan available. No credit card required.

Install Easypanel