Building Scalable Microservices with .NET 8.0 and Kubernetes

Introduction

Microservices architecture has revolutionized the way we design and develop large-scale applications. By breaking down applications into smaller, manageable services, we achieve better scalability, maintainability, and flexibility. In this blog, we'll explore how to build scalable microservices using .NET 8.0 and deploy them to Kubernetes, a powerful container orchestration platform.

Setting Up Your Development Environment

Before we dive into coding, let's set up our development environment.
Install .NET 8.0 SDK
Download and install the .NET 8.0 SDK from the official .NET website.
Install Docker
Download and install Docker Desktop from Docker's website.
Set Up Kubernetes
Enable Kubernetes in Docker Desktop or install Minikube from Minikube's website.

Designing Microservices

For this example, we'll create a simple application with two microservices: `OrderService` and `ProductService`.

Developing Microservices with .NET 8.0

Create a New ASP.NET Core Web API Project

dotnet new webapi -n OrderService
dotnet new webapi -n ProductService

OrderService Implementation

OrderService/Controllers/OrderController.cs:

using Microsoft.AspNetCore.Mvc;

namespace OrderService.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class OrderController : ControllerBase
    {
        [HttpGet]
        public IActionResult GetOrders()
        {
            var orders = new List<string> { "Order1", "Order2", "Order3" };
            return Ok(orders);
        }
    }
}

ProductService Implementation

ProductService/Controllers/ProductController.cs:

using Microsoft.AspNetCore.Mvc;

namespace ProductService.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class ProductController : ControllerBase
    {
        [HttpGet]
        public IActionResult GetProducts()
        {
            var products = new List<string> { "Product1", "Product2", "Product3" };
            return Ok(products);
        }
    }
}

Containerizing Your Microservices

Create Dockerfiles

OrderService/Dockerfile:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["OrderService/OrderService.csproj", "OrderService/"]
RUN dotnet restore "OrderService/OrderService.csproj"
COPY . .
WORKDIR "/src/OrderService"
RUN dotnet build "OrderService.csproj" -c Release -o /app/build

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

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

ProductService/Dockerfile:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

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"]

Build Docker Images

docker build -t orderservice:latest -f OrderService/Dockerfile .
docker build -t productservice:latest -f ProductService/Dockerfile .

Deploying Microservices to Kubernetes

Create Kubernetes Manifests

OrderService/k8s-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: orderservice-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: orderservice
  template:
    metadata:
      labels:
        app: orderservice
    spec:
      containers:
      - name: orderservice
        image: orderservice:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: orderservice
spec:
  selector:
    app: orderservice
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

ProductService/k8s-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: productservice-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: productservice
  template:
    metadata:
      labels:
        app: productservice
    spec:
      containers:
      - name: productservice
        image: productservice:latest
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: productservice
spec:
  selector:
    app: productservice
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Deploy to Kubernetes

kubectl apply -f OrderService/k8s-deployment.yaml
kubectl apply -f ProductService/k8s-deployment.yaml

Service Discovery and Load Balancing

Kubernetes provides built-in service discovery and load balancing. By creating services for your microservices, Kubernetes automatically load balances traffic across the pods.

Monitoring and Logging

Prometheus and Grafana for Monitoring
Deploy Prometheus and Grafana to your Kubernetes cluster using Helm charts or manifests.
Configure Prometheus to scrape metrics from your microservices.
ELK Stack for Logging
Deploy Elasticsearch, Logstash, and Kibana to your Kubernetes cluster.
Configure your microservices to send logs to Logstash, which will then index them in Elasticsearch. Visualize logs using Kibana.

Handling Data with Microservices

For database access, each microservice should manage its own database. This approach ensures loose coupling and independent scalability.

Example of database access in .NET 8.0:

OrderService/Models/Order.cs:

public class Order
{
    public int Id { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
}

OrderService/Data/OrderContext.cs:

using Microsoft.EntityFrameworkCore;

public class OrderContext : DbContext
{
    public DbSet<Order> Orders { get; set; }

    public OrderContext(DbContextOptions<OrderContext> options) : base(options)
    {
    }
}

OrderService/Program.cs:

using Microsoft.EntityFrameworkCore;
using OrderService.Data;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddDbContext<OrderContext>(options =>
    options.UseInMemoryDatabase("OrderDB"));
builder.Services.AddControllers();

var app = builder.Build();

app.UseAuthorization();
app.MapControllers();

app.Run();

Security Best Practices

Implement Authentication and Authorization
Use OAuth2 or JWT tokens for securing your microservices.
Use HTTPS
Configure your services to use HTTPS for secure communication.

CI/CD for Microservices

Set Up CI/CD Pipelines

Use tools like GitHub Actions, Jenkins, or Azure DevOps to automate the build, test, and deployment process.

Sample GitHub Actions Workflow

name: CI/CD Pipeline

on:
  push:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Set up .NET
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: 8.0.x
    - name: Build and test
      run: dotnet build --configuration Release && dotnet test
    - name: Build Docker image
      run: docker build -t orderservice:latest -f OrderService/Dockerfile .
    - name: Push Docker image
      run: |
        echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
        docker push orderservice:latest
    - name: Deploy to Kubernetes
      run: kubectl apply -f OrderService/k8s-deployment.yaml

Real-World Examples

Case studies of companies successfully using .NET 8.0 and Kubernetes for microservices can provide valuable insights and best practices. Research and include relevant examples to add depth to your blog.

Conclusion

In this blog, we explored how to build scalable microservices with .NET 8.0 and deploy them to Kubernetes. By leveraging the power of .NET 8.0 and
Kubernetes, you can create robust, scalable, and maintainable applications. Start experimenting with these technologies and take your applications to the next level.