Microsserviços em C#: arquitetura e prática do A ao Z

Introdução aos microsserviços em C#

A arquitetura de microsserviços (MSA) é uma abordagem de desenvolvimento de software onde a aplicação é construída como um conjunto de pequenos serviços implantados de forma independente. Cada serviço implementa uma capacidade de negócio, possui seu próprio banco de dados e pode ser escrito em diferentes linguagens. No entanto, no ecossistema .NET, a plataforma C# e o ASP.NET Core fornecem algumas das melhores ferramentas para construir microsserviços robustos.

Neste artigo, abordaremos o ciclo completo de criação de microsserviços em C#: desde o design da arquitetura até a implantação em contêineres. Você aprenderá como organizar a comunicação entre serviços, garantir sua tolerância a falhas e escalabilidade.

1. Design da arquitetura de microsserviços em .NET

O primeiro passo é dividir corretamente a aplicação monolítica em serviços. Uma boa prática é seguir o princípio Domain-Driven Design (DDD) e identificar os Bounded Contexts (contextos delimitados).

1.1. Definição dos limites dos serviços

Cada microsserviço deve ser responsável por uma entidade ou processo de negócio. Por exemplo, para um e-commerce, podemos definir:

• Catalog Service — gerenciamento de produtos
• Order Service — processamento de pedidos
• Payment Service — pagamentos
• Notification Service — notificações

Importante: cada serviço possui seu próprio banco de dados. Isso evita acoplamento e permite escalar os serviços de forma independente.

1.2. Estrutura do projeto ASP.NET Core

Um microsserviço típico em C# consiste em várias camadas:

• API Layer — controladores e middleware
• Application Layer — CQRS, MediatR, comandos e consultas
• Domain Layer — entidades, value objects, agregados
• Infrastructure Layer — repositórios, DbContext, serviços externos

Exemplo de estrutura mínima de diretório:

MyMicroservice/├── MyMicroservice.Api/│   └── Controllers/├── MyMicroservice.Application/│   └── Commands/├── MyMicroservice.Domain/│   └── Entities/└── MyMicroservice.Infrastructure/    └── Data/

2. Implementação de um microsserviço em C#: exemplo prático

Vamos criar um serviço simples para gerenciar o catálogo de produtos usando ASP.NET Core 8 e Entity Framework Core.

2.1. Configuração do WebApplication

No arquivo Program.cs, configuramos a API mínima:

var builder = WebApplication.CreateBuilder(args);

// Adiciona serviçosbuilder.Services.AddDbContext<CatalogDbContext>(options =>    options.UseSqlServer(builder.Configuration.GetConnectionString("CatalogDb")));

builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Program).Assembly));

builder.Services.AddEndpointsApiExplorer();builder.Services.AddSwaggerGen();

var app = builder.Build();

// Middlewareif (app.Environment.IsDevelopment()){    app.UseSwagger();    app.UseSwaggerUI();}

app.UseHttpsRedirection();

// Endpoint da API mínimaapp.MapGet("/api/products", async (IMediator mediator) =>{    var products = await mediator.Send(new GetProductsQuery());    return Results.Ok(products);});

app.Run();

2.2. Modelo de dados e CQRS

Criamos a entidade Product:

public class Product{    public Guid Id { get; set; }    public string Name { get; set; } = string.Empty;    public decimal Price { get; set; }    public string Category { get; set; } = string.Empty;}

Usamos o padrão CQRS com MediatR para separar comandos e consultas:

public record GetProductsQuery() : IRequest<List<Product>>;

public class GetProductsHandler : IRequestHandler<GetProduc