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

1. 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

2. 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

3. 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>

4. 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();
       });
   }

5. 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);
       }
   }

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

7. 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

8. 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

9. 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);
       }
   }

10. 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