# 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**](https://dotnet.microsoft.com/download/dotnet/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: ```plaintext QRCode_CoreMvc/ ├── QRCode_UI/ │ ├── QRCode_UI.csproj ├── QRCode_CoreMvc.sln ├── Dockerfile ``` Navigate to the project directory: ```plaintext cd QRCode_CoreMvc ``` --- ### **Step 3: Restore Dependencies** Run the following command to restore the project dependencies: ```plaintext 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: ```plaintext dotnet build ``` **Explanation:** This step: * Compiles the source code. * Generates binaries for your application. --- ### **Step 5: Publish the Application** Prepare the application for deployment: ```plaintext 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 ```plaintext 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: ```plaintext # 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`: ```plaintext 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: ```plaintext 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: ```plaintext docker ps ``` To stop the container: ```plaintext docker stop my-dotnet-container ``` To remove the container: ```plaintext docker rm my-dotnet-container ``` To delete the image: ```plaintext 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**](https://learn.microsoft.com/en-us/dotnet/) --- This blog provides a complete and well-structured guide for both manual and Docker-based application deployment.