What is ABP Framework?

ABP Framework is a complete open-source application development platform built on ASP.NET Core. It provides modular architecture, dependency injection, multi-tenancy, and ready-to-use application templates.

When we containerize an ABP app, we are basically packaging an ASP.NET Core project (with front-end libraries) into a Docker image that can run independently.

Prerequisites

Before you start, make sure you have:

Docker installed on your system
An ABP web project (for example: ChatUapp.Web)
Basic understanding of .NET SDK commands

Project Structure Example

Here’s what a common ABP solution looks like:

ChatUapp/
│
├── src/
│   ├── ChatUapp.Domain/
│   ├── ChatUapp.Application/
│   ├── ChatUapp.EntityFrameworkCore/
│   └── ChatUapp.Web/          ← our main web app
│
├── .dockerignore
├── Dockerfile
└── docker-compose.yml

We’ll focus mainly on the ChatUapp.Web project since it’s the entry point of the application.

Step 1: Start with the Base Image

The base image contains the ASP.NET Core runtime.
We’ll use .NET 9.0 here.

FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
WORKDIR /app
EXPOSE 44361
ENV ASPNETCORE_URLS=http://+:44361

This part defines the environment where your app will run.
It exposes port 44361 and sets up the base working directory.

Step 2: Create the Build Stage

The build stage installs SDK tools, Node.js, and Yarn (required by ABP for client-side assets).

FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /buildprocess

# Install Node.js
ENV NODE_VERSION=24.4.0
ENV NODE_DOWNLOAD_URL=https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.gz
RUN apt-get update && apt-get install -y curl \
    && curl -SL "$NODE_DOWNLOAD_URL" --output nodejs.tar.gz \
    && tar -xzf "nodejs.tar.gz" -C /usr/local --strip-components=1 \
    && rm nodejs.tar.gz \
    && ln -s /usr/local/bin/node /usr/local/bin/nodejs \
    && apt-get purge -y curl && rm -rf /var/lib/apt/lists/*

# Install Yarn
ENV YARN_VERSION=1.22.22
RUN npm install -g yarn@$YARN_VERSION

ABP needs Node.js and Yarn for front-end package management.
We install them only in the build image to keep the final image small.

Step 3: Copy Source Code

Copy the entire project into the build container.

COPY . .
WORKDIR /buildprocess/src/ChatUapp.Web
RUN ls -l

Step 4: Install ABP CLI and Client Libraries

ABP uses its own CLI tool (Volo.Abp.Cli) to install UI libraries under wwwroot/libs.

RUN dotnet tool install -g Volo.Abp.Cli
ENV PATH="${PATH}:/root/.dotnet/tools"
RUN abp install-libs

This step ensures that all client-side dependencies (like jQuery, Bootstrap, etc.) are included inside your Docker image.

Step 5: Build and Publish

Now we compile and publish the web app into a folder called /app/publish.

RUN dotnet publish "/buildprocess/src/ChatUapp.Web/ChatUapp.Web.csproj" -c Release -o /app/publish /p:UseAppHost=false

This command creates a ready-to-run output for your ABP web application.

Step 6: Build the Final Image

The final image only contains the runtime and your published files.

FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "ChatUapp.Web.dll"]

This is the image that will actually run in production.

Step 7: Add a .dockerignore File

To make builds faster, exclude unnecessary files:

**/bin
**/obj
**/.vs
**/.vscode
**/node_modules
**/dist
.git
Dockerfile
docker-compose.yml

This keeps the Docker build context small.

Step 8: Build and Run the Container

Run these commands from your project root:

docker build -t chatuapp-web:latest .
docker run -d -p 8080:44361 chatuapp-web:latest

Then open your browser at:

http://localhost:8080

Your ABP application should be running inside Docker!

Step 9: Using docker-compose (Optional)

You can also create a docker-compose.yml file to run the app easily:

services:
  chatuapp:
    image: chatuapp-web:latest
    container_name: chatuapp-web
    ports:
      - "8080:44361"
    environment:
      ASPNETCORE_ENVIRONMENT: "Production"

Then just run:

docker compose up -d

Step 10: Environment Configuration

ABP supports environment variables automatically.

For example, you can pass database connection strings like this:

-e ConnectionStrings__Default="Server=db;Database=ChatUapp;User Id=sa;Password=StrongPassword;"

ASP.NET Core replaces double underscores (__) with colons (:), so this maps to ConnectionStrings:Default in your appsettings.json.

Step 11: Production Tips

Use multi-stage builds (as shown) to keep images small.
Avoid running ABP CLI inside the final image — only in the build stage.
Use a reverse proxy like Nginx or Traefik for SSL termination.
Always tag your image versions for easy rollback.

Full Dockerfile (Final Version)

Here’s the full Dockerfile you can copy directly:

# Base image
FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
WORKDIR /app
EXPOSE 44361
ENV ASPNETCORE_URLS=http://+:44361

# Build image
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /buildprocess

# Install Node.js
ENV NODE_VERSION=24.4.0
ENV NODE_DOWNLOAD_URL=https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.gz
RUN apt-get update && apt-get install -y curl \
    && curl -SL "$NODE_DOWNLOAD_URL" --output nodejs.tar.gz \
    && tar -xzf "nodejs.tar.gz" -C /usr/local --strip-components=1 \
    && rm nodejs.tar.gz \
    && ln -s /usr/local/bin/node /usr/local/bin/nodejs \
    && apt-get purge -y curl && rm -rf /var/lib/apt/lists/*

# Install Yarn
ENV YARN_VERSION=1.22.22
RUN npm install -g yarn@$YARN_VERSION

# Copy project files
COPY . .
WORKDIR /buildprocess/src/ChatUapp.Web

# Install ABP CLI and libs
RUN dotnet tool install -g Volo.Abp.Cli
ENV PATH="${PATH}:/root/.dotnet/tools"
RUN abp install-libs

# Publish
RUN dotnet publish "/buildprocess/src/ChatUapp.Web/ChatUapp.Web.csproj" -c Release -o /app/publish /p:UseAppHost=false

# Final image
FROM base AS final
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "ChatUapp.Web.dll"]

Conclusion

That’s it! You’ve just learned how to write a complete Dockerfile for an ABP Framework application.

With this setup:

The build process installs Node.js, Yarn, and ABP CLI
Client libraries are bundled automatically
The final Docker image stays lightweight and production-ready

Now your ABP app can run anywhere — whether on local Docker, cloud containers, or Kubernetes.

How to Write a Dockerfile for an ABP Framework Application

Summary

Tags