Implementando microserviços em C# com .NET Core: uma abordagem prática usando Docker e Swagger para documentar e testar APIs

Introdução

Neste tutorial, você aprenderá a implementar microserviços utilizando C# e .NET Core, usando Docker para facilitar a contêinerização e Swagger para documentar e testar suas APIs. A arquitetura de microserviços é uma abordagem moderna que divide uma aplicação em partes menores, independentes e facilmente escaláveis. Ao longo deste guia, vamos explorar como criar um microserviço simples, que inclua práticas recomendadas de desenvolvimento, configuração de um ambiente Docker e a integração com o Swagger para documentação e testes de API. Esta é uma ótima oportunidade para desenvolvedores que desejam aprofundar suas habilidades em desenvolvimento de software com .NET Core e microserviços.

Etapas

Configuração do Ambiente de Desenvolvimento
Certifique-se de ter o .NET Core SDK e o Docker instalados em sua máquina. Verifique as versões usando os comandos `dotnet –version` e `docker –version`. Se não os tiver instalados, consulte a documentação oficial da Microsoft e do Docker para instruções de instalação.
commands
```
# Verificar versões instaladas
dotnet --version
docker --version
```
Criação do Projeto .NET Core
Utilize o CLI do .NET para criar um novo projeto de microserviço. Execute o comando a seguir para criar um projeto Web API:
commands
```
dotnet new webapi -n MeuMicroservico
cd MeuMicroservico
```
Adicionando Dependências para Swagger
Abra o arquivo `MeuMicroservico.csproj` e adicione a dependência para Swagger. Essa biblioteca permitirá que sua API seja documentada de maneira automática. Abaixo está um exemplo de como o arquivo deve ficar:
MeuMicroservico.csproj
```
<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net5.0</TargetFramework>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.1.4" />
  </ItemGroup>
</Project>
```

Configuração do Swagger

No arquivo `Startup.cs`, adicione a configuração do Swagger no método `ConfigureServices` e `Configure` para habilitar a documentação da API. Adicione o seguinte código:

Startup.cs

using Microsoft.OpenApi.Models;

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    services.AddSwaggerGen(c =>
    {
        c.SwaggerDoc("v1", new OpenApiInfo { Title = "MeuMicroservico", Version = "v1" });
    });
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    app.UseSwagger();
    app.UseSwaggerUI(c =>
    {
        c.SwaggerEndpoint("/swagger/v1/swagger.json", "MeuMicroservico v1");
    });
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Criando um Modelo e um Controlador

Crie um modelo chamado `Produto` e um controlador `ProdutoController`. Isso representará um recurso em seu microserviço. Adicione o seguinte código aos arquivos correspondentes:

Produto.cs

public class Produto
{
    public int Id { get; set; }
    public string Nome { get; set; }
    public decimal Preco { get; set; }
}

ProdutoController.cs

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;

[ApiController]
[Route("api/[controller]")]
public class ProdutoController : ControllerBase
{
    private static List<Produto> produtos = new List<Produto>();

    [HttpGet]
    public ActionResult<IEnumerable<Produto>> Get()
    {
        return Ok(produtos);
    }

    [HttpPost]
    public ActionResult<Produto> Post([FromBody] Produto produto)
    {
        produtos.Add(produto);
        return CreatedAtAction(nameof(Get), new { id = produto.Id }, produto);
    }
}

Configurando o Docker

Crie um arquivo Dockerfile na raiz do projeto para definir a imagem do Docker. O conteúdo deve ser como abaixo:

Dockerfile

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

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

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

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

Construindo e Executando o Container Docker

Para construir e executar o container docker, use os seguintes comandos:

commands

# Construindo a imagem Docker
docker build -t meumicroservico .
# Executando o container
docker run -d -p 8080:80 meumicroservico

Testando a API com Swagger
Após o container estar em execução, navegue até `http://localhost:8080/swagger/index.html` para acessar a documentação interativa da API e testar os endpoints.
commands
```
# Acesse a documentação do Swagger
http://localhost:8080/swagger/index.html
```

Implementação de Testes Unitários

Implemente testes unitários utilizando o xUnit e Moq. Crie um teste básico para o `ProdutoController` usando o seguinte código:

ProdutoControllerTests.cs

using Microsoft.AspNetCore.Mvc;
using Xunit;

public class ProdutoControllerTests
{
    [Fact]
    public void Get_ReturnsOkResult()
    {
        // Arrange
        var controller = new ProdutoController();

        // Act
        var result = controller.Get();

        // Assert
        Assert.IsType<OkObjectResult>(result.Result);
    }
}

Executando Testes Unitários
Utilize o comando abaixo para executar seus testes unitários e garantir que tudo esteja funcionando como esperado:
commands
```
dotnet test
```

Conclusão

Neste tutorial, você aprendeu a implementar um microserviço utilizando C# e .NET Core, configurar Docker para contêinerização e utilizar Swagger para documentação e teste de APIs. Cada passo foi projetado para fornecer uma compreensão clara do processo de desenvolvimento de microserviços. Agora você pode expandir suas habilidades, praticando com funcionalidades mais avançadas e buscando integrar este microserviço em uma arquitetura de microserviços maior.

Hashtags

#CSharp #DotNetCore #Microservices #Docker #Swagger #APIDocumentation

copycoda.com.br

copycoda.com.br

Implementando microserviços em C# com .NET Core: uma abordagem prática usando Docker e Swagger para documentar e testar APIs

Introdução

Etapas

Configuração do Ambiente de Desenvolvimento

Criação do Projeto .NET Core

Adicionando Dependências para Swagger