Implementing Microservices with .NET 8 and Docker: A Complete Guide

Introduction

Microservices have become a popular architectural pattern in modern software development due to their scalability, maintainability, and flexibility. By breaking down large applications into smaller, independent services, teams can develop, deploy, and scale components independently. In this tutorial, we'll explore how to implement microservices using .NET 8, one of the latest versions of the .NET platform, and Docker, a tool that enables containerization for easier deployment and scalability.

The following diagram illustrates secure authentication with JWT and Identityserver:

In this step-by-step guide, you will learn how to:

Create microservices with .NET 8
Containerize your application using Docker
Set up communication between microservices via REST APIs
Deploy your solution to a cloud-based infrastructure

By the end of this blog post, you'll have a robust, scalable microservices application ready for production use.

Prerequisites

Before diving into the implementation, ensure you have the following prerequisites:

Visual Studio 2022 or later or any preferred IDE for .NET development
Docker Desktop installed on your local machine
Basic knowledge of .NET, ASP.NET Core, and REST APIs
Basic understanding of Docker and containerization

If you're new to Docker or microservices, this tutorial will help you get up to speed with the basics and advanced concepts of both.

Setting Up Microservices Project

We will start by creating a simple microservices project with multiple services. Each service will be a standalone ASP.NET Core application, responsible for its own functionality.

Step 1: Create Microservices Projects

Open Visual Studio and create three separate projects for our microservices:

ProductService - Handles product data (CRUD operations).
OrderService - Manages customer orders.
NotificationService - Sends notifications for order statuses.

Each of these services will expose REST APIs to interact with other services. Start by creating a new ASP.NET Core Web API project for each service.

Step 2: Implement ProductService

Let's first implement the ProductService that will manage product-related data. Here’s a basic example of a controller in the ProductService:

using Microsoft.AspNetCore.Mvc;

namespace ProductService.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ProductsController : ControllerBase
    {
        [HttpGet]
        public IActionResult GetAllProducts()
        {
            var products = new List<string> { "Product 1", "Product 2", "Product 3" };
            return Ok(products);
        }
    }
}

This simple controller exposes an endpoint to fetch a list of products. You can expand this service to include CRUD operations using Entity Framework Core or other database solutions.

Step 3: Implement OrderService

The OrderService will manage orders placed by customers. The implementation will be similar to the ProductService but will include functionality to store and retrieve orders:

using Microsoft.AspNetCore.Mvc;

namespace OrderService.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class OrdersController : ControllerBase
    {
        [HttpGet]
        public IActionResult GetAllOrders()
        {
            var orders = new List<string> { "Order 1", "Order 2", "Order 3" };
            return Ok(orders);
        }
    }
}

Step 4: Implement NotificationService

The NotificationService is responsible for notifying customers when their orders are placed or shipped. Here's an example of the NotificationService implementation:

using Microsoft.AspNetCore.Mvc;

namespace NotificationService.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class NotificationsController : ControllerBase
    {
        [HttpGet]
        public IActionResult GetNotifications()
        {
            var notifications = new List<string> { "Your order is shipped", "Your order is delivered" };
            return Ok(notifications);
        }
    }
}

This service will later send notifications based on orders processed by the OrderService.

Dockerizing the Microservices

Now that we have our basic microservices set up, it’s time to containerize them using Docker. Docker allows us to package each microservice into containers, making them portable, scalable, and easier to deploy.

Step 1: Create Dockerfile for Each Service

In each of the services (ProductService, OrderService, NotificationService), you need to create a Dockerfile to build the Docker image. Below is an example Dockerfile for the ProductService:

# Use official .NET 8 runtime image as the base
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

# Use .NET SDK image to build the app
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["ProductService/ProductService.csproj", "ProductService/"]
RUN dotnet restore "ProductService/ProductService.csproj"
COPY . .
WORKDIR "/src/ProductService"
RUN dotnet build "ProductService.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "ProductService.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "ProductService.dll"]

This Dockerfile builds and publishes the .NET application, and then prepares it to run in a container. You need to create similar Dockerfiles for the other two services as well.

Step 2: Build Docker Images

Once the Dockerfiles are created, use the following commands to build the Docker images:

docker build -t productservice .
docker build -t orderservice .
docker build -t notificationservice .

Step 3: Run Docker Containers

After building the images, you can run the containers locally:

docker run -d -p 8081:80 --name productservice productservice
docker run -d -p 8082:80 --name orderservice orderservice
docker run -d -p 8083:80 --name notificationservice notificationservice

Your microservices are now running inside Docker containers, and you can access them on the respective ports.

Deploying to Cloud Infrastructure

Now that our microservices are containerized, we can deploy them to a cloud infrastructure like Microsoft Azure, AWS, or Google Cloud. For simplicity, we'll focus on deploying to Azure using Azure Kubernetes Service (AKS) for orchestrating the containers.

Step 1: Create AKS Cluster

In Azure, you can create a Kubernetes cluster through the Azure portal. Once your cluster is set up, you can deploy your Docker containers there.

Step 2: Push Docker Images to Docker Hub

Before deploying to AKS, you need to push your Docker images to a container registry like Docker Hub or Azure Container Registry (ACR). Use the following commands to push the images:

docker tag productservice <your_dockerhub_username>/productservice
docker push <your_dockerhub_username>/productservice

Step 3: Deploy to AKS

Using kubectl, you can deploy your containers to AKS:

kubectl apply -f productservice-deployment.yaml
kubectl apply -f orderservice-deployment.yaml
kubectl apply -f notificationservice-deployment.yaml

After the deployment is successful, your microservices will be running in a highly available cloud infrastructure.

Conclusion

In this comprehensive guide, we've covered how to build a microservices architecture using .NET 8 and Docker. From creating the services and implementing REST APIs to containerizing them and deploying to the cloud, we've provided the necessary steps to get your microservices-based application running.

Microservices architecture allows for scalability, fault tolerance, and flexibility in your applications. By using Docker for containerization and cloud platforms like Azure for deployment, you can ensure that your services are resilient and scalable in production environments.

With the knowledge gained from this tutorial, you can now start building more complex microservices applications and explore advanced topics such as service discovery, API gateways, and fault tolerance mechanisms.