Clientes y servicios gRPC mediante Code First con .NET

Por James Newton-King y Marc Gravell

gRPC mediante Code First usa tipos .NET para definir contratos de servicio y de mensajes.

Code First es una buena opción cuando un sistema completo usa .NET:

• El servidor y los clientes de .NET pueden compartir los tipos de contratos de datos y servicio de .NET.
• Esto evita la necesidad de definir contratos en la generación de código y los archivos .proto.

Code First no se recomienda en sistemas políglotas con varios idiomas. Los tipos de contratos de datos y servicio de .NET no se pueden usar con plataformas que no son de .NET. Para llamar a un servicio gRPC escrito mediante Code First, otras plataformas deben crear un contrato de .proto que coincida con el servicio.

protobuf-net.Grpc

Important

Para obtener ayuda con protobuf-net.Grpc, visite el sitio web de protobuf-net.Grpc o cree una incidencia en el repositorio de GitHub de protobuf-net.Grpc.

protobuf-net.Grpc es un proyecto de la comunidad y no es compatible con Microsoft. Agrega compatibilidad con Code First a Grpc.AspNetCore y Grpc.Net.Client. Usa tipos de .NET anotados con atributos para definir los mensajes y servicios de gRPC de una aplicación.

El primer paso para crear un servicio gRPC mediante Code First es definir el contrato de código:

• Cree un proyecto que compartirán el servidor y el cliente.
• Agregue una referencia al paquete protobuf-net.Grpc.
• Cree tipos de contratos de datos y de servicio.

using ProtoBuf.Grpc;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Threading.Tasks;

namespace Shared.Contracts;

[DataContract]
public class HelloReply
{
    [DataMember(Order = 1)]
    public string Message { get; set; }
}

[DataContract]
public class HelloRequest
{
    [DataMember(Order = 1)]
    public string Name { get; set; }
}

[ServiceContract]
public interface IGreeterService
{
    [OperationContract]
    Task<HelloReply> SayHelloAsync(HelloRequest request,
        CallContext context = default);
}

El código anterior:

• Define los mensajes HelloRequest y HelloReply.
• Define la interfaz del contrato de IGreeterService con el método de gRPC SayHelloAsync unario.

El contrato de servicio se implementa en el servidor y se invoca desde el cliente.

Los métodos definidos en las interfaces de servicio deben coincidir con ciertas firmas dependiendo de si son:

• Unary
• Streaming del servidor
• Streaming de cliente
• Streaming bidireccional

Para más información sobre la definición de contratos de servicio, vea la documentación de introducción de protobuf-net.Grpc.

Creación de un servicio gRPC mediante Code First

Para agregar un servicio gRPC mediante Code First a una aplicación de ASP.NET Core:

• Agregue una referencia al paquete protobuf-net.Grpc.AspNetCore.

• Agregue una referencia al proyecto de contrato de código compartido.

  <Project Sdk="Microsoft.NET.Sdk.Web">
  
    <PropertyGroup>
      <TargetFramework>net6.0</TargetFramework>
      <Nullable>enable</Nullable>
      <ImplicitUsings>enable</ImplicitUsings>
    </PropertyGroup>
  
    <ItemGroup>
      <PackageReference Include="protobuf-net.Grpc.AspNetCore" Version="1.0.152" />
    </ItemGroup>
  
    <ItemGroup>
        <ProjectReference Include="..\Shared\Shared.Contracts.csproj" />
    </ItemGroup>
  
  </Project>
  

• Cree un archivo GreeterService.cs e implemente la interfaz de servicio de IGreeterService:

  using Shared.Contracts;
  using ProtoBuf.Grpc;
  
  public class GreeterService : IGreeterService
  {
      public Task<HelloReply> SayHelloAsync(HelloRequest request, CallContext context = default)
      {
          return Task.FromResult(
                  new HelloReply
                  {
                      Message = $"Hello {request.Name}"
                  });
      }
  }
  

• Actualice el archivo Program.cs:

  using ProtoBuf.Grpc.Server;
  
  var builder = WebApplication.CreateBuilder(args);
  
  // Additional configuration is required to successfully run gRPC on macOS.
  // For instructions on how to configure Kestrel and gRPC clients on macOS, visit https://go.microsoft.com/fwlink/?linkid=2099682
  
  // Add services to the container.
  builder.Services.AddCodeFirstGrpc();
  
  var app = builder.Build();
  
  // Configure the HTTP request pipeline.
  app.MapGrpcService<GreeterService>();
  app.MapGet("/", () => "Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
  
  app.Run();
  

  El código resaltado anterior actualiza lo siguiente:

  • AddCodeFirstGrpc registra servicios que habilitan Code First.
  • MapGrpcService<GreeterService> agrega el punto de conexión de servicio de Code First.

Los servicios gRPC implementados con Code First y archivos .proto pueden coexistir en la misma aplicación. Todos los servicios gRPC usan la configuración del servicio gRPC.

Creación de un cliente de gRPC mediante Code First

Un cliente de gRPC mediante Code First usa el contrato de servicio para llamar a los servicios gRPC.

• En el archivo .csproj de cliente de gRPC:

  • Agregue una referencia al paquete protobuf-net.Grpc.
  • Agregue una referencia de paquete Grpc.Net.Client.
  • Agregue una referencia al proyecto de contrato de código compartido.

  <Project Sdk="Microsoft.NET.Sdk">
  
    <PropertyGroup>
      <OutputType>Exe</OutputType>
      <TargetFramework>net6.0</TargetFramework>
      <ImplicitUsings>enable</ImplicitUsings>
      <Nullable>enable</Nullable>
    </PropertyGroup>
  
    <ItemGroup>
      <PackageReference Include="Grpc.Net.Client" Version="2.52.0" />
      <PackageReference Include="protobuf-net.Grpc" Version="1.0.152" />
    </ItemGroup>
      
    <ItemGroup>
      <ProjectReference Include="..\Shared\Shared.Contracts.csproj" />
    </ItemGroup>
  
  </Project>
  

• Actualice el cliente program.cs.

  // See https://aka.ms/new-console-template for more information
  using Grpc.Net.Client;
  using ProtoBuf.Grpc.Client;
  using Shared.Contracts;
  
  namespace GrpcGreeterClient;
  
  internal class Program
  {
      private static async Task Main(string[] args)
      {
          using var channel = GrpcChannel.ForAddress("https://localhost:7184");
          var client = channel.CreateGrpcService<IGreeterService>();
  
          var reply = await client.SayHelloAsync(
              new HelloRequest { Name = "GreeterClient" });
  
          Console.WriteLine($"Greeting: {reply.Message}");
          Console.WriteLine("Press any key to exit...");
          Console.ReadKey();
      }
  }
  
  
  

El código Program.cs del cliente de gRPC anterior:

• Crea un canal gRPC.
• Crea un cliente Code First a partir del canal con el método de extensión CreateGrpcService<IGreeterService>.
• Llama al servicio gRPC con SayHelloAsync.

Un cliente gRPC mediante Code First se crea a partir de un canal. Al igual que un cliente normal, un cliente Code First usa su configuración de canal.

Vea o descargue el código de ejemplo (cómo descargarlo)

Recursos adicionales

• protobuf-net. Sitio web de Grpc
• Repositorio de GitHub de protobuf-net.Grpc