Getting Started with Microservices in ASP.NET Core: Step-by-Step Guide

In this blog, you will learn how to create a simple "Hello World" microservice using ASP.NET Core and deploy it to Docker. This step-by-step guide is designed for beginners who want to understand the basics of microservices and how they can be implemented in ASP.NET Core. By following along, you will gain hands-on experience creating a microservice from scratch, deploying it to Docker, and testing it in a web browser. Whether you are a seasoned developer or just starting out, this guide will provide you with the foundation you need to begin building more complex microservices.

Microservices are a modern software architecture pattern that involves breaking down a monolithic application into smaller, independent services that can be deployed, managed, and scaled separately. This approach provides several benefits, including better scalability, faster development, and improved fault tolerance. In this blog, we will learn how to create a simple "Hello World" microservice using ASP.NET Core.

Prerequisites

• Visual Studio 2019
• .NET Core 3.1 SDK

Step 1. Creating a new ASP.NET Core Web API project

To create a new ASP.NET Core Web API project in Visual Studio 2019, follow these steps:

1. Open Visual Studio 2019 and click on "Create a new project".

2. In the "Create a new project" window, choose "ASP.NET Core Web API" from the list of templates and click the "Next" button.

3. Enter a name for the project, such as "HelloWorldMicroservice", and choose a location for the solution.

4. In the "Create a new project" window, select "API" and click the "Create" button.

Step 2. Adding a new Controller

Now that we have created a new ASP.NET Core Web API project, let's add a new Controller to handle the "Hello World" request.

1. In the "Solution Explorer" window, right-click on the "Controllers" folder and choose "Add" -> "Controller".

2. In the "Add Scaffold" window, choose "API Controller with actions, using Entity Framework" and click the "Add" button.

3. Enter a name for the controller, such as "HelloWorldController", and click the "Add" button.

Step 3. Implementing the Hello World API

With the new Controller in place, let's implement the "Hello World" API.

1. Open the HelloWorldController.cs file and replace its contents with the following code:

   using Microsoft.AspNetCore.Mvc;
   
   namespace HelloWorldMicroservice.Controllers
   {
       [Route("api/[controller]")]
       [ApiController]
       public class HelloWorldController : ControllerBase
       {
           [HttpGet]
           public string Get()
           {
               return "Hello World";
           }
       }
   }
   

   In this code, we have defined a single "Get" action that returns the "Hello World" message. The [Route("api/[controller]")] attribute defines the base URL for the API, and the [ApiController] attribute enables automatic model validation and error handling.

Step 4. Testing the Hello World API

With the Hello World API implemented, let's test it.

1. Press the "F5" key or click on the "Debug" menu and choose "Start Debugging".

2. In a web browser, navigate to "https://localhost:5001/api/helloworld".

You should see the "Hello World" message displayed in the browser.

Step 5. Deploying to Docker

Finally, let's deploy our Hello World microservice to Docker.

1. Right-click on the solution and choose "Add" -> "Docker Support".

2. In the "Add Docker Support" window, choose "Linux" and click the "Add" button.

3. Open the Dockerfile and replace its contents with the following code:

   FROM mcr.microsoft.com/dotnet/core/aspnet:3.1 AS base
   WORKDIR /app
   EXPOSE 80
   
   FROM mcr.microsoft.com/dotnet/core/sdk:3.1 AS build
   WORKDIR /src
   COPY ["HelloWorldMicroservice.csproj", ""]
   RUN dotnet restore "HelloWorldMicroservice.csproj"
   COPY . .
   WORKDIR "/src/."
   RUN dotnet build "HelloWorldMicroservice.csproj" -c Release -o /app/build
   
   FROM build AS publish
   RUN dotnet publish "HelloWorldMicroservice.csproj" -c Release -o /app/publish
   
   FROM base AS final
   WORKDIR /app
   COPY --from=publish /app/publish .
   ENTRYPOINT ["dotnet", "HelloWorldMicroservice.dll"]
   

   In this Dockerfile, we are using the ASP.NET Core 3.1 base image, exposing port 80, and copying the published application to the final image. We are also setting the entry point for the container to be the HelloWorldMicroservice.dll file.

4. Open a command prompt or terminal window and navigate to the solution folder.

5. Run the following command to build the Docker image:

   docker build -t helloworldmicroservice .
   

6. Run the following command to run the Docker container:

   docker run -p 80:80 helloworldmicroservice
   

7. In a web browser, navigate to "http://localhost/api/helloworld".

You should see the "Hello World" message displayed in the browser.

Congratulations! You have successfully created a "Hello World" microservice using ASP.NET Core and deployed it to Docker. With this foundation, you can start building more complex microservices, incorporating additional features such as authentication, authorization, and database access.