Use Microsoft's .NET SDK image as the build environment

In the previous article, we explored how to publish an ASP.NET Core application to IIS—a traditional deployment approach for Windows server environments. In this article, we’ll discuss deploying applications using Docker. Compared to conventional deployment methods, Docker offers greater flexibility and portability for your applications.

What Is Docker?

Docker is an open platform for developing, shipping, and running applications. It enables developers to package an application along with all its dependencies into a standardized unit called a “container.” This ensures consistent behavior across any environment where the container runs.

Why Use Docker?

1. Environment Consistency: Docker containers behave identically across development, testing, and production environments—anywhere they run.
2. Rapid Deployment: With Docker, you can quickly start and stop applications, significantly improving development and testing efficiency.
3. Resource Isolation: Each container operates independently, preventing dependency conflicts between different applications.
4. Scalability: Docker simplifies horizontal scaling—you can rapidly increase or decrease the number of containers to meet changing demand.

Creating a Dockerfile

Before deploying, we need to create a Dockerfile. A Dockerfile is a plain-text file containing all instructions required to build a Docker image.

Below is a simple Dockerfile example for an ASP.NET Core application:

# Use Microsoft's .NET SDK image as the build environment
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build

# Set the working directory
WORKDIR /app

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

# Copy project files and publish
COPY . ./
RUN dotnet publish -c Release -o out

# Use the lightweight ASP.NET Core runtime image to run the app
FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Specify the default startup command
ENTRYPOINT ["dotnet", "YourAppName.dll"]

In this Dockerfile, we first use the dotnet/sdk image to build the application, then copy the published output into a leaner runtime image. Be sure to replace YourAppName.dll with the actual name of your project’s compiled assembly.

Building the Docker Image

In an environment with Docker installed, run the following command to build the Docker image:

docker build -t yourappname .

This command builds a Docker image named yourappname, following the instructions in the Dockerfile.

Running the Docker Container

After building the image, launch the container with:

docker run -d -p 8080:80 --name yourappname yourappname

Here, -d runs the container in detached (background) mode; -p 8080:80 maps port 80 inside the container to port 8080 on the host machine. You can access your application at http://localhost:8080.

Managing Docker Containers

To list currently running containers:

docker ps

To stop or remove a container:

# Stop the container
docker stop yourappname

# Remove the container
docker rm yourappname

Conclusion

Deploying ASP.NET Core applications with Docker delivers significant advantages—including environment consistency and rapid deployment. In this article, we walked through creating a Dockerfile, building and running a container, and managing its lifecycle.

In the next article, we’ll introduce cloud deployment fundamentals. Integrating cloud technologies will further enhance your application’s scalability and high availability—stay tuned!