How to Run a .NET Project Manually and in Docker

How to Run a .NET Project Manually and in Docker

In this guide, we’ll walk through two methods to run a .NET 6.0 application:

  1. Running the application manually on your local machine.

  2. Using Docker to containerize and run the application efficiently.

By the end, you’ll have a clear understanding of how to set up and run the application in both environments.


Part 1: Running the Application Manually

Running a .NET application manually involves installing necessary tools, building the project, and running it locally. Let’s break this down step-by-step.


Step 1: Install Prerequisites

Ensure you have the following installed:

  • .NET SDK 6.0 to build and run the application.

  • A terminal or command prompt (e.g., PowerShell, Bash).


Step 2: Navigate to the Project Directory

Assume the project structure is as follows:

QRCode_CoreMvc/
├── QRCode_UI/
│   ├── QRCode_UI.csproj
├── QRCode_CoreMvc.sln
├── Dockerfile

Navigate to the project directory:

cd QRCode_CoreMvc

Step 3: Restore Dependencies

Run the following command to restore the project dependencies:

dotnet restore

Explanation:
This command:

  • Downloads the required NuGet packages.

  • Resolves dependencies defined in the .csproj file.


Step 4: Build the Project

Compile the project using:

dotnet build

Explanation:
This step:

  • Compiles the source code.

  • Generates binaries for your application.


Step 5: Publish the Application

Prepare the application for deployment:

dotnet publish -c Release -o ./publish

Explanation:
This command:

  • Builds the application (if not already built).

  • Packages all necessary files into the ./publish directory.


Step 6: Run the Application

Navigate to the publish directory and start the application:cd publish

dotnet QRCode_UI.dll

Explanation:
This starts the .NET runtime to execute the application.


Step 7: Access the Application

Open a browser and visit the following URLs to access the application:

  • http://localhost:5000 (HTTP)

  • http://localhost:5001 (HTTPS)

You’ve successfully run the application manually!


Part 2: Running the Application in Docker

Now let’s containerize the application using Docker. This approach ensures portability and simplifies deployment across different environments.


Dockerfile Overview

The Dockerfile defines how the application is built and run in a container. Here’s the Dockerfile we’ll use:

# Stage 1: Build the application
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build-env
WORKDIR /app

# Restore dependencies
COPY *.sln ./
COPY QRCode_UI/*.csproj ./QRCode_UI/
RUN dotnet restore

# Build and publish the application
COPY . ./
WORKDIR /app/QRCode_UI
RUN dotnet publish -c Release -o /out

# Stage 2: Run the application
FROM mcr.microsoft.com/dotnet/aspnet:6.0
WORKDIR /app

# Copy the published output from the build stage
COPY --from=build-env /out .

# Expose the ports used by the application
EXPOSE 5000
EXPOSE 5001

# Configure the application to listen on all network interfaces
ENV ASPNETCORE_URLS="http://0.0.0.0:5000;http://0.0.0.0:5001"

# Run the application
ENTRYPOINT ["dotnet", "QRCode_UI.dll"]

This Dockerfile has two stages:

  1. Build Stage: Compiles and publishes the application.

  2. Runtime Stage: Runs the published application in a lightweight container.


Step 1: Build the Docker Image

Run the following command in the directory containing the Dockerfile:

docker build -t my-dotnet-app .

Explanation:

  • docker build: Builds a Docker image.

  • -t my-dotnet-app: Tags the image as my-dotnet-app.

  • .: Specifies the current directory as the build context.


Step 2: Run the Docker Container

Start a container from the built image:

docker run -d -p 5000:5000 -p 5001:5001 --name my-dotnet-container my-dotnet-app

Explanation:

  • docker run: Creates and starts a container.

  • -d: Runs the container in detached mode (in the background).

  • -p 5000:5000 -p 5001:5001: Maps container ports to your machine.

  • --name my-dotnet-container: Names the container my-dotnet-container.

  • my-dotnet-app: Specifies the image to use.


Step 3: Access the Application

Open a browser and navigate to:

  • http://localhost:5000

  • https://localhost:5001

The application is now running inside a Docker container!


Step 4: Manage the Container

To view the running containers:

docker ps

To stop the container:

docker stop my-dotnet-container

To remove the container:

docker rm my-dotnet-container

To delete the image:

docker rmi my-dotnet-app

Conclusion

We’ve demonstrated how to run a .NET application both manually and using Docker. The manual approach is straightforward for development and testing, while Docker simplifies deployment and ensures portability.

Key Benefits of Docker:

  • Consistency across environments.

  • Easy scaling and deployment.

With this knowledge, you can confidently run .NET applications in any environment. Happy coding!


Additional Resources:


This blog provides a complete and well-structured guide for both manual and Docker-based application deployment.