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:

• Docker Documentation

• Microsoft .NET Documentation

---

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