integración de gRPC Client Factory en .NET CoregRPC client factory integration in .NET Core

la integración de gRPC con HttpClientFactory ofrece una manera centralizada de crear clientes de gRPC.gRPC integration with HttpClientFactory offers a centralized way to create gRPC clients. Se puede usar como alternativa a la configuración de instancias de cliente de gRPC independientes.It can be used as an alternative to configuring stand-alone gRPC client instances. La integración de fábrica está disponible en el paquete NuGet GRPC .net. ClientFactory .Factory integration is available in the Grpc.Net.ClientFactory NuGet package.

El generador ofrece las siguientes ventajas:The factory offers the following benefits:

  • Proporciona una ubicación central para configurar las instancias de cliente gRPC lógicasProvides a central location for configuring logical gRPC client instances
  • Administra la duración del HttpClientMessageHandler subyacenteManages the lifetime of the underlying HttpClientMessageHandler
  • Propagación automática de fecha límite y cancelación en un servicio de gRPC de ASP.NET CoreAutomatic propagation of deadline and cancellation in an ASP.NET Core gRPC service

Registro de clientes de gRPCRegister gRPC clients

Para registrar un cliente de gRPC, se puede usar el método de extensión Generic AddGrpcClient en Startup.ConfigureServices, especificando la clase de cliente con tipo gRPC y la dirección de servicio:To register a gRPC client, the generic AddGrpcClient extension method can be used within Startup.ConfigureServices, specifying the gRPC typed client class and service address:

services.AddGrpcClient<Greeter.GreeterClient>(o =>
{
    o.Address = new Uri("https://localhost:5001");
});

El tipo de cliente gRPC se registra como transitorio con la inserción de dependencias (DI).The gRPC client type is registered as transient with dependency injection (DI). Ahora el cliente se puede insertar y consumir directamente en los tipos creados por DI.The client can now be injected and consumed directly in types created by DI. ASP.NET Core controladores MVC, SignalR hubs y gRPC Services son lugares en los que se pueden insertar automáticamente los clientes de gRPC:ASP.NET Core MVC controllers, SignalR hubs and gRPC services are places where gRPC clients can automatically be injected:

public class AggregatorService : Aggregator.AggregatorBase
{
    private readonly Greeter.GreeterClient _client;

    public AggregatorService(Greeter.GreeterClient client)
    {
        _client = client;
    }

    public override async Task SayHellos(HelloRequest request,
        IServerStreamWriter<HelloReply> responseStream, ServerCallContext context)
    {
        // Forward the call on to the greeter service
        using (var call = _client.SayHellos(request))
        {
            await foreach (var response in call.ResponseStream.ReadAllAsync())
            {
                await responseStream.WriteAsync(response);
            }
        }
    }
}

Configuración de HttpClientConfigure HttpClient

HttpClientFactory crea el HttpClient que usa el cliente de gRPC.HttpClientFactory creates the HttpClient used by the gRPC client. Los métodos de HttpClientFactory estándar se pueden usar para agregar middleware de solicitud de salida o para configurar el HttpClientHandler subyacente del HttpClient:Standard HttpClientFactory methods can be used to add outgoing request middleware or to configure the underlying HttpClientHandler of the HttpClient:

services
    .AddGrpcClient<Greeter.GreeterClient>(o =>
    {
        o.Address = new Uri("https://localhost:5001");
    })
    .ConfigurePrimaryHttpMessageHandler(() =>
    {
        var handler = new HttpClientHandler();
        handler.ClientCertificates.Add(LoadCertificate());
        return handler;
    });

Para obtener más información, consulte Make HTTP requests Using IHttpClientFactory.For more information, see Make HTTP requests using IHttpClientFactory.

Configurar el canal y los interceptoresConfigure Channel and Interceptors

los métodos específicos de gRPC están disponibles para:gRPC-specific methods are available to:

  • Configure el canal subyacente de un cliente de gRPC.Configure a gRPC client's underlying channel.
  • Agregue Interceptor instancias que el cliente usará al realizar llamadas a gRPC.Add Interceptor instances that the client will use when making gRPC calls.
services
    .AddGrpcClient<Greeter.GreeterClient>(o =>
    {
        o.Address = new Uri("https://localhost:5001");
    })
    .AddInterceptor(() => new LoggingInterceptor())
    .ConfigureChannel(o =>
    {
        o.Credentials = new CustomCredentials();
    });

Fecha límite y propagación de cancelaciónDeadline and cancellation propagation

los clientes de gRPC creados por el generador en un servicio de gRPC se pueden configurar con EnableCallContextPropagation() para propagar automáticamente la fecha límite y el token de cancelación a las llamadas secundarias.gRPC clients created by the factory in a gRPC service can be configured with EnableCallContextPropagation() to automatically propagate the deadline and cancellation token to child calls. El método de extensión EnableCallContextPropagation() está disponible en el paquete NuGet GRPC. AspNetCore. Server. ClientFactory .The EnableCallContextPropagation() extension method is available in the Grpc.AspNetCore.Server.ClientFactory NuGet package.

La propagación de contexto de llamada funciona mediante la lectura de la fecha límite y el token de cancelación del contexto de solicitud gRPC actual y su propagación automática a las llamadas salientes realizadas por el cliente de gRPC.Call context propagation works by reading the deadline and cancellation token from the current gRPC request context and automatically propagating them to outgoing calls made by the gRPC client. La propagación de contexto de llamada es una excelente manera de garantizar que los escenarios complejos de gRPC anidados siempre propagan la fecha límite y la cancelación.Call context propagation is an excellent way of ensuring that complex, nested gRPC scenarios always propagate the deadline and cancellation.

services
    .AddGrpcClient<Greeter.GreeterClient>(o =>
    {
        o.Address = new Uri("https://localhost:5001");
    })
    .EnableCallContextPropagation();

Para obtener más información acerca de las fechas límite y la cancelación de RPC, consulte ciclo de vida de RPC.For more information about deadlines and RPC cancellation, see RPC life cycle.

Recursos adicionalesAdditional resources