Criando um serviço híbrido REST e gRPC em .NET Core

Fonte: unsplash

O gRPC é uma maneira moderna de comunicação entre aplicativos, uma evolução do protocolo RPC (chamada de procedimento remoto) antigo. Ele usa o protocolo HTTP/2 e mensagens serializadas em Protobuf para criar serviços de alto desempenho. O suporte ao gRPC no ASP.NET Core foi adicionado no .NET Core 3.0.

Um dos principais benefícios do gRPC é o alto desempenho. As mensagens são serializadas em Protobuf, um formato de mensagem binária que serializa rapidamente no cliente e no servidor. Uma mensagem gRPC é sempre menor do que uma mensagem JSON equivalente. Além disso, o arquivo .proto define o contrato de serviços e mensagens, ao compartilhar o arquivo do servidor as definições são geradas no cliente, eliminando retrabalho no desenvolvimento.

O gRPC é recomendado em serviços de back-end, em micro serviços leves em que a eficiência é fundamental, em cenários de largura de banda limitada, como aplicativos móveis e também em ambientes com várias linguagens de programação. Os navegadores não são totalmente compatíveis com HTTP/2, tornando REST e JSON a principal forma de obter dados em aplicativos web.

Mesmo com os benefícios que o gRPC traz, o REST e o JSON tem lugar importante nos aplicativos modernos. Vale refletir para que a criação de serviços REST e gRPC não adicione complexidade no desenvolvimento de aplicativos.

Existe uma alternativa para migrar APIs REST para o gRPC ou ter um serviço híbrido com os dois. Para ter um serviço híbrido é possível expor portas separadas para os protocolos HTTP e HTTP/2. Para uma ideia relativamente simples eu esperava que houvesse várias documentações a respeito, mas depois de pesquisar bastante resolvi compartilhar alguns dos aprendizados que obtive utilizando estas tecnologias na Acesso Digital.

O código fonte da demonstração está aqui.

* Pré-requisitos: Visual Studio Code, extensão do C# no Visual Studio Code e .NET Core 3.1 SDK ou posterior.

Vamos ao passo a passo:

1) O primeiro passo é criar um serviço gRPC com .NET Core. No terminal do Visual Studio Code execute os comandos abaixo.

• Altere os diretórios para a pasta que conterá o projeto.
• Para criar o serviço:

dotnet new grpc -o GrpcGreeter

• Para abrir a pasta GrpcGreeter em uma nova instância do Visual Studio Code:

code -r GrpcGreeter

• Para confiar no certificado de desenvolvimento HTTPS:

dotnet dev-certs https — trust

• Ao exibir a caixa de diálogo, selecione Sim para confiar.
• Pressione Ctrl-F5 para executar o serviço.

2) No arquivo Program.cs, após chamar ConfigureWebHostDefaults, use o ConfigureKestrel e adicione a referência ao pacote Microsoft.AspNetCore.Server.Kestrel.Core.

Host.CreateDefaultBuilder(args)
  .ConfigureWebHostDefaults(webBuilder =>
  {
      webBuilder.ConfigureKestrel(options =>
      {
            options.ListenAnyIP(5001, o => o.Protocols = HttpProtocols.Http1);
            options.ListenAnyIP(5002, o => o.Protocols = HttpProtocols.Http2);
      });
      
      webBuilder.UseStartup<Startup>();
   });

Com a configuração ListenAnyIP o serviço irá executar as chamadas HTTP na porta 5001 e HTTP/2 na porta 5002.

3) Adicione o Controller e as configurações no arquivo Startup.cs para que API REST possa ser executada. Alterações no arquivo Startup.cs estão em negrito.

public void ConfigureServices(IServiceCollection services)
{
      services.AddControllers();
      services.AddGrpc();
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
....
      app.UseEndpoints(endpoints => {
           endpoints.MapControllers();
           ...
      }
....
}

4) Ao executar o projeto a chamada REST estará disponível em http://localhost:5001/weatherforecast e a do serviço gRPC em http://localhost:5002.

5) Para realizar o build e executar o serviço no Docker:

• Adicione o arquivo Dockerfile.
• Execute os comandos:

docker build -t netcore-grpc-rest-image .
docker run -it --rm -p 9001:5001 -p 9002:5002 netcore-grpc-rest-image

O argumento -t indica o nome da imagem que será criada.

O argumento -p mapeia as portas 9001 e 9002 para as respectivas portas 5001 e 5002 do container. Desta forma o serviço REST será exposto em http://localhost:9001/weatherforecast e o gRPC em http://localhost:9002.

Este é o exemplo de um serviço híbrido REST e gRPC. Clique aqui para acessar um benchmark que possibilita a comparação entre o desempenho do gRPC e do REST.

Espero que a leitura tenha sido útil. Até mais!

Caso você seja apaixonado por tecnologia, a Acesso Digital está contratando engenheir@s. Basta conferir as vagas aqui. 😄 🚀

* Agradeço aos amigos Arnaldo De Moraes Pereira, Jonathan Moser e Rodrigo Fernando Tazima pela leitura cuidadosa dos rascunhos deste artigo e pelas sugestões valiosas.

Leituras Adicionais

Alto Desempenho com gRPC
Kestrel no .NET Core
Documentação do Docker
Tutorial Microsoft: criar um cliente gRPC e um servidor no ASP.NET Core
Tutorial Microsoft: criar uma API Web com .Net Core
.Proto Language Guide

Letícia Silva é desenvolvedora na Acesso Digital.