gRPC para configuração do .NET

Artigo
11/30/2023

Configurar opções de serviços

Os serviços gRPC são configurados com AddGrpc no Startup.cs. As opções de configuração estão no pacote Grpc.AspNetCore.Server.

A tabela a seguir descreve as opções para configurar os serviços gRPC:

Opção	Valor padrão	Descrição
`MaxSendMessageSize`	`null`	O tamanho máximo em bytes da mensagem que pode ser enviada a partir do servidor. Tentar enviar uma mensagem que exceda o tamanho máximo de mensagem configurado resultará em uma exceção. Quando definido como `null`, o tamanho da mensagem será ilimitado.
`MaxReceiveMessageSize`	4 MB	O tamanho máximo em bytes da mensagem que pode ser recebida pelo servidor. Se o servidor receber uma mensagem que exceda esse limite, ele gerará uma exceção. Aumentar esse valor permite que o servidor receba mensagens maiores, mas pode afetar o consumo de memória negativamente. Quando definido como `null`, o tamanho da mensagem será ilimitado.
`EnableDetailedErrors`	`false`	Se for `true`, as mensagens de exceção detalhadas serão retornadas aos clientes quando uma exceção for gerada em um método de serviço. O padrão é `false`. Configurar `EnableDetailedErrors` como `true` pode vazar informações confidenciais.
`CompressionProviders`	gzip	Uma coleção dos provedores de compactação usados para compactar e descompactar mensagens. Provedores de compactação personalizados podem ser criados e adicionados à coleção. Os provedores padrão configurados dão suporte à compactação gzip.
`ResponseCompressionAlgorithm`	`null`	O algoritmo de compactação usado para compactar mensagens enviadas a partir do servidor. O algoritmo deve corresponder a um provedor de compactação em `CompressionProviders`. Para que o algoritmo compacte uma resposta, o cliente deve indicar que dá suporte ao algoritmo enviando-o no cabeçalho grpc-accept-encoding.
`ResponseCompressionLevel`	`null`	O nível de compactação usado para compactar mensagens enviadas a partir do servidor.
`Interceptors`	Nenhum	Uma coleção de interceptadores que são executados com cada chamada de gRPC. Os interceptadores são executados na ordem em que estão registrados. Os interceptadores configurados globalmente são executados antes dos interceptadores configurados para um único serviço. Por padrão, os interceptadores têm um tempo de vida por solicitação. O construtor do interceptador é chamado, e os parâmetros são resolvidos com base na DI (injeção de dependência). Um tipo de interceptador também pode ser registrado com a DI para substituir a forma como ele é criado e seu tempo de vida. Em comparação com ASP.NET Core middleware, os interceptadores oferecem funcionalidades semelhantes. Para obter mais informações, confira Interceptadores gRPC vs. middleware.
`IgnoreUnknownServices`	`false`	Se for `true`, as chamadas para serviços e métodos desconhecidos não retornarão um status UNIMPLEMENTED e a solicitação passará para o próximo middleware registrado no ASP.NET Core.

As opções podem ser configuradas para todos os serviços por meio do fornecimento de um delegado de opções para a chamada AddGrpc em Startup.ConfigureServices:

public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc(options =>
    {
        options.EnableDetailedErrors = true;
        options.MaxReceiveMessageSize = 2 * 1024 * 1024; // 2 MB
        options.MaxSendMessageSize = 5 * 1024 * 1024; // 5 MB
    });
}

As opções para um único serviço substituem as opções globais fornecidas em AddGrpc e podem ser configuradas usando AddServiceOptions<TService>:

public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc().AddServiceOptions<MyService>(options =>
    {
        options.MaxReceiveMessageSize = 2 * 1024 * 1024; // 2 MB
        options.MaxSendMessageSize = 5 * 1024 * 1024; // 5 MB
    });
}

Por padrão, os interceptadores de serviço têm um tempo de vida por solicitação. Registrar o tipo de interceptador com a DI substitui a forma como um interceptador é criado e seu tempo de vida.

public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc(options =>
    {
        options.Interceptors.Add<LoggingInterceptor>();
    });
    services.AddSingleton<LoggingInterceptor>();
}

Opções de servidor do ASP.NET Core

Grpc.AspNetCore.Server é hospedado por um servidor Web do ASP.NET Core. Há várias opções para servidores ASP.NET Core, incluindo Kestrel, IIS e HTTP.sys. Cada servidor oferece opções adicionais para como as solicitações HTTP são atendidas.

O servidor usado por um aplicativo ASP.NET Core é configurado no código de inicialização do aplicativo. O servidor padrão é Kestrel.

Para obter mais informações sobre os diferentes servidores e suas opções de configuração, confira:

Configurar opções de cliente

A configuração do cliente gRPC é definida em GrpcChannelOptions. As opções de configuração estão no pacote Grpc.Net.Client.

A tabela a seguir descreve as opções para configurar canais gRPC:

Opção	Valor padrão	Descrição
`HttpHandler`	Nova instância	O `HttpMessageHandler` usado para fazer chamadas do gRPC. Um cliente pode ser definido para configurar um `HttpClientHandler` personalizado ou adicionar manipuladores adicionais ao pipeline HTTP para chamadas do gRPC. Se nenhum `HttpMessageHandler` for especificado, uma nova instância `HttpClientHandler` será criada para o canal com descarte automático.
`HttpClient`	`null`	O `HttpClient` usado para fazer chamadas do gRPC. Essa configuração é uma alternativa a `HttpHandler`.
`DisposeHttpClient`	`false`	Se for definido como `true` e um `HttpMessageHandler` ou `HttpClient` for especificado, então o `HttpHandler` ou `HttpClient`, respectivamente, será descartado quando o `GrpcChannel` for descartado.
`LoggerFactory`	`null`	O `LoggerFactory` usado pelo cliente para registrar informações sobre chamadas do gRPC. Uma instância `LoggerFactory` pode ser resolvida com base na injeção de dependência ou criada usando `LoggerFactory.Create`. Para obter exemplos de configuração de log, confira Registro em log e diagnóstico no gRPC no .NET.
`MaxSendMessageSize`	`null`	O tamanho máximo em bytes da mensagem que pode ser enviada a partir do cliente. Tentar enviar uma mensagem que exceda o tamanho máximo de mensagem configurado resultará em uma exceção. Quando definido como `null`, o tamanho da mensagem será ilimitado.
`MaxReceiveMessageSize`	4 MB	O tamanho máximo em bytes da mensagem que pode ser recebida pelo cliente. Se o cliente receber uma mensagem que exceda esse limite, ele gerará uma exceção. Aumentar esse valor permite que o cliente receba mensagens maiores, mas pode afetar o consumo de memória negativamente. Quando definido como `null`, o tamanho da mensagem será ilimitado.
`Credentials`	`null`	Uma instância de `ChannelCredentials`. As credenciais são usadas para adicionar metadados de autenticação a chamadas do gRPC.
`CompressionProviders`	gzip	Uma coleção dos provedores de compactação usados para compactar e descompactar mensagens. Provedores de compactação personalizados podem ser criados e adicionados à coleção. Os provedores padrão configurados dão suporte à compactação gzip.
`ThrowOperationCanceledOnCancellation`	`false`	Se for definido como `true`, os clientes gerarão OperationCanceledException quando uma chamada for cancelada ou seu prazo for excedido.
`UnsafeUseInsecureChannelCallCredentials`	`false`	Se for definido como `true`, `CallCredentials` serão aplicadas a chamadas do gRPC feitas por um canal inseguro. O envio de cabeçalhos de autenticação por uma conexão insegura tem implicações de segurança e não deve ser feito em ambientes de produção.
`MaxRetryAttempts`	5	O máximo de novas tentativas. Esse valor limita todos os valores de novas tentativas e de cobertura especificados na configuração do serviço. Definir esse valor sozinho não habilita novas tentativas. As repetições são habilitadas na configuração de serviço, o que pode ser feito usando `ServiceConfig`. Um valor `null` remove o limite máximo de novas tentativas. Para obter mais informações sobre novas tentativas, confira Tratamento de falhas transitórias com novas tentativas do gRPC.
`MaxRetryBufferSize`	16 MB	O tamanho máximo do buffer em bytes que podem ser usados para armazenar mensagens enviadas ao fazer novas tentativas ou chamadas de cobertura. Se o limite do buffer for excedido, não serão feitas mais tentativas de repetição e todas as chamadas de cobertura, menos uma, serão canceladas. Esse limite é aplicado a todas as chamadas feitas usando o canal. Um valor `null` remove o limite máximo de tamanho do buffer de repetição.
`MaxRetryBufferPerCallSize`	1 MB	O tamanho máximo do buffer em bytes que podem ser usados para armazenar mensagens enviadas ao fazer novas tentativas ou chamadas de cobertura. Se o limite do buffer for excedido, não serão feitas mais tentativas de repetição e todas as chamadas de cobertura, menos uma, serão canceladas. Esse limite é aplicado a uma chamada. Um valor `null` remove o limite máximo de tamanho do buffer de repetição por chamada.
`ServiceConfig`	`null`	A configuração de serviço para um canal gRPC. Uma configuração de serviço pode ser usada para configurar novas tentativas do gRPC.

O seguinte código:

Define o tamanho máximo de mensagens a serem enviadas e recebidas no canal.
Cria um cliente.

static async Task Main(string[] args)
{
    var channel = GrpcChannel.ForAddress("https://localhost:5001", new GrpcChannelOptions
    {
        MaxReceiveMessageSize = 5 * 1024 * 1024, // 5 MB
        MaxSendMessageSize = 2 * 1024 * 1024 // 2 MB
    });
    var client = new Greeter.GreeterClient(channel);

    var reply = await client.SayHelloAsync(
                      new HelloRequest { Name = "GreeterClient" });
    Console.WriteLine("Greeting: " + reply.Message);
}

Note que os interceptadores de cliente não estão configurados com GrpcChannelOptions. Em vez disso, os interceptadores de cliente são configurados usando o método de extensão Intercept com um canal. Esse método de extensão está no namespace Grpc.Core.Interceptors.

static async Task Main(string[] args)
{
    var channel = GrpcChannel.ForAddress("https://localhost:5001");
    var callInvoker = channel.Intercept(new LoggingInterceptor());
    var client = new Greeter.GreeterClient(callInvoker);

    var reply = await client.SayHelloAsync(
                      new HelloRequest { Name = "GreeterClient" });
    Console.WriteLine("Greeting: " + reply.Message);
}

Opções de manipulador do System.Net

Grpc.Net.Client usa um transporte HTTP derivado de HttpMessageHandler para fazer solicitações HTTP. Cada manipulador oferece opções adicionais sobre como as solicitações HTTP são feitas.

O manipulador é configurado em um canal e pode ser substituído ao definir GrpcChannelOptions.HttpHandler. Por padrão, o .NET Core 3 e o .NET 5 ou posterior usam SocketsHttpHandler. Os aplicativos do cliente gRPC no .NET Framework devem configurar o WinHttpHandler.

Para obter mais informações sobre os diferentes manipuladores e suas opções de configuração, confira: