Building Scalable Microservices with .NET Core: A Step-by-Step Guide

In the ever-evolving world of software development, microservices architecture has emerged as a game-changer. Unlike monolithic applications, microservices allow you to build modular, scalable, and maintainable systems. If you’re a .NET developer, you’re in luck — .NET Core is perfectly suited for developing robust microservices.

This guide walks you through the journey of creating scalable microservices using .NET Core, from setup to deployment. Whether you’re a seasoned developer or just getting started, this guide has something for everyone.

Why Choose .NET Core for Microservices?

.NET Core is a powerful, open-source, cross-platform framework known for its performance and flexibility. Here are some reasons why it’s a great choice for microservices:

• Cross-Platform Compatibility: Build once, run anywhere — on Windows, macOS, or Linux.
• High Performance: Optimized for modern cloud environments, .NET Core is fast and efficient.
• Modular Design: Its lightweight architecture allows you to pick and choose components, perfect for microservices.
• Rich Ecosystem: Leverage ASP.NET Core, Entity Framework Core, and a plethora of libraries to accelerate development.
• Community Support: With a vibrant community and consistent updates from Microsoft, developers have access to extensive resources and tools.
• Built-in Security Features: Out-of-the-box support for HTTPS, authentication, and data protection ensures your services are secure.

Step 1: Setting Up Your Environment

Before diving into development, ensure your environment is ready. Here’s what you’ll need:

• .NET Core SDK: Download and install the latest version from the official site.
• IDE: Visual Studio or Visual Studio Code, both of which provide excellent support for .NET Core development.
• Docker: For containerizing and deploying your services.
• Postman or Curl: Useful for testing your APIs.

Once installed, verify your setup by running:

$ dotnet --version

Ensure you’re using a version compatible with your project requirements.

Step 2: Creating Your First Microservice

Let’s start by creating a simple product catalog microservice:

1. Open a terminal or IDE and create a new project:

dotnet new webapi -n ProductCatalogService 
cd ProductCatalogService

2. Define your product model in the Models folder:

public class Product {     

  public int Id { get; set; }     
  public string Name { get; set; }     
  public string Description { get; set; }     
  public decimal Price { get; set; }     
  public int Stock { get; set; } 
}

Including fields like Description and Stock ensures a richer data model.

3. Create a controller to manage your products:

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase {
  private static List<Product> Products = new List<Product>();
  [HttpGet]
  public IActionResult GetAll() => Ok(Products);
  [HttpGet("{id}")]
  public IActionResult GetById(int id) {
    var product = Products.FirstOrDefault(p => p.Id == id);
    if (product == null)
      return NotFound();
    return Ok(product);
  }
  [HttpPost]
  public IActionResult Add(Product product) {
    Products.Add(product);
    return CreatedAtAction(nameof(GetById), new { id = product.Id }, product);
  }
  [HttpDelete("{id}")]
  public IActionResult Delete(int id) {
    var product = Products.FirstOrDefault(p => p.Id == id);
    if (product == null)
      return NotFound();
    Products.Remove(product);
    return NoContent();
  }
}

4. Run the application:

dotnet run

Visit http://localhost:5000/api/products to test your endpoints using Postman or Curl.

Step 3: Adding Database Integration

To persist data, integrate a database:

1. Add the Entity Framework Core package:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer

2. Configure the database context in the Data folder:

public class ProductContext
 : DbContext {
  public DbSet<Product> Products { get; set; }
  protected override void OnConfiguring(DbContextOptionsBuilder options) {
    options.UseSqlServer("Your_Connection_String");
  }
}

3. Update your controller to use the database:

private readonly ProductContext _context;
public ProductsController(ProductContext context) {
  _context = context;
}
[HttpGet]
public IActionResult GetAll() => Ok(_context.Products.ToList());
[HttpPost]
public IActionResult Add(Product product) {
  _context.Products.Add(product);
  _context.SaveChanges();
  return CreatedAtAction(nameof(GetAll), product);
}

4. Run migrations to create the database schema:

dotnet ef migrations add InitialCreate $ dotnet ef database update

Step 4: Service Communication

Microservices often need to communicate with each other. You can use HTTP or messaging protocols like RabbitMQ.

HTTP Communication:

Use HttpClient for synchronous communication between services. Here’s an example:

var client = new HttpClient();
var response = await client.GetAsync("http://orderservice/api/orders");
if (response.IsSuccessStatusCode) {
    var orders = await response.Content.ReadAsStringAsync();
}

Message Brokers:

Implement RabbitMQ or Kafka for asynchronous communication. Here’s an example using RabbitMQ:

1. Install the RabbitMQ.Client package:

dotnet add package RabbitMQ.Client

2. Publish a message:

var factory = new ConnectionFactory { HostName = "localhost" };
using var connection = factory.CreateConnection();
using var channel = connection.CreateModel();

channel.QueueDeclare(queue: "productQueue", durable: false, exclusive: false, autoDelete: false, arguments: null);

string message = "New product added";
var body = Encoding.UTF8.GetBytes(message);

channel.BasicPublish(exchange: "", routingKey: "productQueue", basicProperties: null, body: body);

Step 5: Securing Your Microservices

Security is paramount. Use JSON Web Tokens (JWT) for authentication:

1. Add the Microsoft.AspNetCore.Authentication.JwtBearer package.
2. Configure authentication in Program.cs:

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options => {
        options.TokenValidationParameters = new TokenValidationParameters {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("Your_Secret_Key"))
        };
    });

3. Protect your endpoints:

[Authorize]
[HttpGet]
public IActionResult GetAll() => Ok(_context.Products.ToList());

4. Use a service like Azure AD or IdentityServer for enterprise-grade security solutions.

Step 6: Deploying Your Microservices

Use Docker for containerizing your microservices:

1. Create a Dockerfile:

FROM mcr.microsoft.com/dotnet/aspnet:7.0
WORKDIR /app
COPY . .
ENTRYPOINT ["dotnet", "ProductCatalogService.dll"]

2. Build and run the Docker image:

$ docker build -t product-catalog-service .
$ docker run -p 5000:80 product-catalog-service

Kubernetes for Orchestration:

Use Kubernetes for managing your microservices in production:

1. Create a deployment YAML file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: product-catalog-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: product-catalog-service
  template:
    metadata:
      labels:
        app: product-catalog-service
    spec:
      containers:
      - name: product-catalog-service
        image: product-catalog-service:latest
        ports:
        - containerPort: 80

1. Deploy to your Kubernetes cluster:

kubectl apply -f deployment.yaml

Conclusion

Building microservices with .NET Core is a rewarding experience that equips you with the tools to create scalable, maintainable, and efficient systems. By following this guide, you’ve taken the first steps toward mastering microservices architecture.

The possibilities are endless — now it’s your turn to innovate! Explore additional concepts like event-driven architectures, CI/CD pipelines, and advanced monitoring to take your applications to the next level.