Dockerizing .NET Applications: Step-by-Step Tutorial

Docker has transformed modern application development by enabling developers to package software and its dependencies into lightweight, portable containers. Dockerizing .NET applications simplifies deployment, improves scalability, and ensures consistency across different environments.

In this tutorial, we will walk through the process of Dockerizing .NET applications, starting with the basics and gradually covering advanced topics. By the end, you will have a production-ready .NET application running in a Docker container.

Table of Contents

• What is Docker and Why Use It for .NET Applications?
  • Benefits of Dockerizing .NET Applications
• Prerequisites
• Step 1: Creating a Simple .NET Application
  • Create a New .NET Web API Project
• Step 2: Writing a Dockerfile
  • Explanation of the Dockerfile
• Step 3: Building and Running the Docker Container
  • Build the Docker Image
  • Run the Docker Container
• Step 4: Using Docker Compose for Multi-Container Applications
  • Create a docker-compose.yml File
  • Running Multiple Containers
• Step 5: Optimizing Dockerized .NET Applications
  • Reduce Docker Image Size
  • Secure Your Containers
  • Implement CI/CD for Dockerized .NET Applications
• Conclusion

What is Docker and Why Use It for .NET Applications?

Docker is a containerization platform that allows applications to run in isolated environments. Unlike virtual machines, Docker containers share the host OS kernel, making them lightweight and efficient.

Benefits of Dockerizing .NET Applications

1. Consistency – Works the same across development, testing, and production.
2. Portability – Run your .NET application anywhere Docker is supported.
3. Scalability – Easily scale applications by running multiple containers.
4. Faster Deployment – Containers start quickly compared to traditional VM-based deployments.
5. Resource Efficiency – Uses fewer system resources than virtual machines.

Prerequisites

Before we begin, make sure you have:

• .NET SDK installed (Download here)
• Docker Desktop installed (Download here)
• Basic understanding of .NET and command-line tools

If you’re passionate about .NET and love diving into development tips and insights, check out our latest articles at WireFuture’s .NET blog.

Step 1: Creating a Simple .NET Application

First, let’s create a basic .NET application that we will later containerize.

Create a New .NET Web API Project

Open a terminal and run:

dotnet new webapi -n DockerizedApp
cd DockerizedApp

This command creates a new ASP.NET Core Web API project named DockerizedApp.

Now, test the application by running:

dotnet run


You should see the application running at https://localhost:5001.

Step 2: Writing a Dockerfile

A Dockerfile is a script that defines how to build a Docker image for your application. Create a file named Dockerfile in the project root and add the following content:

# Use the official .NET SDK image for building the application
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /app

# Copy the project files and restore dependencies
COPY *.csproj ./
RUN dotnet restore

# Copy remaining files and build the application
COPY . ./
RUN dotnet publish -c Release -o out

# Use the runtime image to run the application
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Expose the port and define the entry point
EXPOSE 80
CMD ["dotnet", "DockerizedApp.dll"]

Explanation of the Dockerfile

• Multi-Stage Build – First, we build the application (build stage) and then copy only the necessary files to a smaller runtime image (runtime stage).
• Optimized Image – Using the runtime image reduces the final image size.
• Port Exposure – The application will run on port 80 inside the container.

Step 3: Building and Running the Docker Container

Build the Docker Image

Run the following command to build the Docker image:

docker build -t dockerizedapp .

This command creates a Docker image named dockerizedapp.

Run the Docker Container

Once the image is built, start a container:

docker run -d -p 8080:80 --name mycontainer dockerizedapp

• -d runs the container in detached mode.
• -p 8080:80 maps port 80 in the container to port 8080 on the host.
• --name mycontainer assigns a name to the container.

Now, open a browser and go to http://localhost:8080 to see your running application.

Step 4: Using Docker Compose for Multi-Container Applications

If your application depends on a database or other services, managing multiple containers manually can be difficult. Docker Compose simplifies this process.

Create a docker-compose.yml File

In the project root, create a docker-compose.yml file:

version: '3.8'

services:
  app:
    image: dockerizedapp
    build: .
    ports:
      - "8080:80"
    depends_on:
      - db

  db:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      SA_PASSWORD: "YourStrongPassword!"
      ACCEPT_EULA: "Y"
    ports:
      - "1433:1433"

🚀 Boost Your Business with Expert .NET Development! 💻

Looking for scalable, secure, and high-performance .NET solutions? WireFuture specializes in custom .NET development, from enterprise applications to cloud solutions.

✅ Robust & Scalable Apps
✅ Cloud & API Development
✅ Seamless Integration & Maintenance

💡 Let’s build the future together with cutting-edge .NET development!

📩 Contact us today: https://wirefuture.com

Running Multiple Containers

Run the application and database together:

docker-compose up -d

This will start both the .NET application and SQL Server in containers.

Step 5: Optimizing Dockerized .NET Applications

Reduce Docker Image Size

• Use Alpine-based images:

FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine

• Remove unnecessary dependencies after build steps.
• Use .dockerignore to exclude unnecessary files.

Secure Your Containers

• Use non-root users inside containers.
• Enable network segmentation to restrict access.
• Keep dependencies and base images up to date.

Implement CI/CD for Dockerized .NET Applications

Use GitHub Actions, Azure DevOps, or GitLab CI/CD to automate builds and deployments. Example GitHub Actions workflow:

name: Build and Push Docker Image

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v2

    - name: Build Docker image
      run: docker build -t myapp:latest .

    - name: Push Docker image
      run: docker push mydockerhubusername/myapp:latest

This automates the building and pushing of Docker images on every commit.

Conclusion

Dockerizing .NET applications simplifies deployment, improves scalability, and ensures consistency across different environments. In this tutorial, we covered:

• Creating a basic .NET application
• Writing an optimized Dockerfile
• Building and running a Docker container
• Using Docker Compose for multi-container applications
• Advanced optimizations for production environments

By following these steps, you can efficiently containerize your .NET applications and deploy them anywhere. Start experimenting with Docker today and take your .NET projects to the next level!

Share