integração do gRPC Client Factory no .NET CoregRPC client factory integration in .NET Core

a integração do gRPC com HttpClientFactory o oferece uma maneira centralizada de criar clientes do gRPC.gRPC integration with HttpClientFactory offers a centralized way to create gRPC clients. Ele pode ser usado como uma alternativa para configurar instâncias de cliente gRPCautônomas.It can be used as an alternative to configuring stand-alone gRPC client instances. A integração de fábrica está disponível no pacote NuGet do .net. ClientFactory do Grpc .Factory integration is available in the Grpc.Net.ClientFactory NuGet package.

A fábrica oferece os seguintes benefícios:The factory offers the following benefits:

  • Fornece um local central para configurar instâncias de cliente gRPC lógicasProvides a central location for configuring logical gRPC client instances
  • Gerencia o tempo de vida do subjacente HttpClientMessageHandlerManages the lifetime of the underlying HttpClientMessageHandler
  • Propagação automática de prazo e cancelamento em um serviço de ASP.NET Core gRPCAutomatic propagation of deadline and cancellation in an ASP.NET Core gRPC service

Registrar clientes gRPCRegister gRPC clients

Para registrar um cliente gRPC, o AddGrpcClient método de extensão genérico pode ser usado no Startup.ConfigureServices , especificando a classe de cliente tipada gRPC e o endereço de serviço: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");
});

O tipo de cliente gRPC é registrado como transitório com injeção de dependência (DI).The gRPC client type is registered as transient with dependency injection (DI). Agora, o cliente pode ser injetado e consumido diretamente em tipos criados por DI.The client can now be injected and consumed directly in types created by DI. ASP.NET Core controladores MVC, SignalR hubs e serviços gRPCs são locais onde os clientes gRPC podem ser injetados automaticamente: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);
            }
        }
    }
}

Configurar o HttpClientConfigure HttpClient

HttpClientFactory cria o HttpClient usado pelo cliente gRPC.HttpClientFactory creates the HttpClient used by the gRPC client. Os HttpClientFactory métodos padrão podem ser usados para adicionar middleware de solicitação de saída ou para configurar o subjacente HttpClientHandler do 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 obter mais informações, consulte fazer solicitações HTTP usando IHttpClientFactory.For more information, see Make HTTP requests using IHttpClientFactory.

Configurar canal e interceptoresConfigure Channel and Interceptors

os métodos específicos do gRPC estão disponíveis para:gRPC-specific methods are available to:

  • Configure um canal subjacente do cliente gRPC.Configure a gRPC client's underlying channel.
  • Adicione Interceptor instâncias que o cliente usará ao fazer chamadas 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();
    });

Data limite e propagação de cancelamentoDeadline and cancellation propagation

Os clientes gRPC criados pela fábrica em um serviço gRPC podem ser configurados com EnableCallContextPropagation() o para propagar automaticamente o token de prazo e cancelamento para chamadas filhas.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. O EnableCallContextPropagation() método de extensão está disponível no pacote NuGet Grpc. AspNetCore. Server. ClientFactory .The EnableCallContextPropagation() extension method is available in the Grpc.AspNetCore.Server.ClientFactory NuGet package.

A propagação de contexto de chamada funciona lendo o data limite e o token de cancelamento do contexto de solicitação gRPC atual e propagando-os automaticamente para chamadas de saída feitas pelo cliente 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. A propagação de contexto de chamada é uma maneira excelente de garantir que cenários gRPC complexos e aninhados sempre propaguem o prazo e o cancelamento.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();

Por padrão, EnableCallContextPropagation o gerará um erro se o cliente for usado fora do contexto de uma chamada gRPC.By default, EnableCallContextPropagation raises an error if the client is used outside the context of a gRPC call. O erro foi projetado para alertá-lo de que não há um contexto de chamada a ser propagado.The error is designed to alert you that there isn't a call context to propagate. Se você quiser usar o cliente fora de um contexto de chamada, suprimir o erro quando o cliente for configurado com SuppressContextNotFoundErrors :If you want to use the client outside of a call context, suppress the error when the client is configured with SuppressContextNotFoundErrors:

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

Para obter mais informações sobre prazos e cancelamento de RPC, consulte ciclo de vida RPC.For more information about deadlines and RPC cancellation, see RPC life cycle.

Recursos adicionaisAdditional resources