Migrieren von gRPC-Diensten von C-core zu ASP.NET CoreMigrating gRPC services from C-core to ASP.NET Core

Von John LuoBy John Luo

Aufgrund der Implementierung des zugrundeliegenden Stapels funktionieren nicht alle Features in C-core-basierten gRPC-Apps und ASP.NET Core-basierten Apps gleich.Due to the implementation of the underlying stack, not all features work in the same way between C-core-based gRPC apps and ASP.NET Core-based apps. In diesem Artikel wird auf die Hauptunterschiede zwischen den beiden Stapeln in Bezug auf die Migration eingegangen.This document highlights the key differences for migrating between the two stacks.

Lebensdauer der gRPC-DienstimplementierunggRPC service implementation lifetime

Im ASP.NET Core-Stapel werden gRPC-Dienste standardmäßig mit bereichsbezogener Lebensdauer erstellt.In the ASP.NET Core stack, gRPC services, by default, are created with a scoped lifetime. Im Gegensatz hierzu ist gRPC-C-core standardmäßig an einen Dienst mit Singletonlebensdauer gebunden.In contrast, gRPC C-core by default binds to a service with a singleton lifetime.

Die bereichsbezogene Lebensdauer ermöglicht es der Dienstimplementierung, andere Dienste mit bereichsbezogener Lebensdauer aufzulösen.A scoped lifetime allows the service implementation to resolve other services with scoped lifetimes. Bei einer bereichsbezogenen Lebensdauer kann beispielsweise auch DbContext durch Konstruktorinjektion aus dem Abhängigkeitsinjektionscontainer aufgelöst werden.For example, a scoped lifetime can also resolve DbContext from the DI container through constructor injection. Wenn bereichsbezogene Lebensdauer verwendet wird:Using scoped lifetime:

  • wird für jede Anforderung eine neue Instanz der Dienstimplementierung konstruiert.A new instance of the service implementation is constructed for each request.
  • ist es nicht möglich, Zustände zwischen Anforderungen über Instanzmember für den Implementierungstyp freizugeben.It isn't possible to share state between requests via instance members on the implementation type.
  • wird erwartet, dass freigegebene Zustände in einem Singletondienst im Abhängigkeitsinjektionscontainer gespeichert werden.The expectation is to store shared states in a singleton service in the DI container. Die gespeicherten freigegebenen Zustände werden im Konstruktor der gRPC-Dienstimplementierung aufgelöst.The stored shared states are resolved in the constructor of the gRPC service implementation.

Weitere Informationen zur Lebensdauer von Diensten finden Sie unter Dependency Injection in ASP.NET Core.For more information on service lifetimes, see Dependency Injection in ASP.NET Core.

Hinzufügen eines SingletondienstsAdd a singleton service

Die Übertragung einer gRPC-C-core-Implementierung in ASP.NET Core kann vereinfacht werden, indem die Lebensdauer der Dienstimplementierung von bereichsbezogen in Singleton geändert wird.To facilitate the transition from a gRPC C-core implementation to ASP.NET Core, it's possible to change the service lifetime of the service implementation from scoped to singleton. Hierbei wird eine Instanz der Dienstimplementierung zum Abhängigkeitsinjektionscontainer hinzugefügt:This involves adding an instance of the service implementation to the DI container:

public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc();
    services.AddSingleton(new GreeterService());
}

Eine Dienstimplementierung mit Singletonlebensdauer kann allerdings bereichsbezogene Dienste nicht mehr durch Konstruktorinjektion auflösen.However, a service implementation with a singleton lifetime is no longer able to resolve scoped services through constructor injection.

Konfigurieren von Optionen für gRPC-DiensteConfigure gRPC services options

In C-core-basierten Apps werden Einstellungen wie grpc.max_receive_message_length und grpc.max_send_message_length mit ChannelOption beim Konstruieren der Serverinstanz konfiguriert.In C-core-based apps, settings such as grpc.max_receive_message_length and grpc.max_send_message_length are configured with ChannelOption when constructing the Server instance.

In ASP.NET Core stellt gRPC die Konfiguration über den Typ GrpcServiceOptions bereit.In ASP.NET Core, gRPC provides configuration through the GrpcServiceOptions type. Beispielsweise kann die Maximalgröße für eingehende Nachrichten für einen gRPC-Dienst über AddGrpc konfiguriert werden.For example, a gRPC service's the maximum incoming message size can be configured via AddGrpc. Im folgenden Beispiel wird der Standardwert für MaxReceiveMessageSize von 4 MB in 16 MB geändert:The following example changes the default MaxReceiveMessageSize of 4 MB to 16 MB:

public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc(options =>
    {
        options.MaxReceiveMessageSize = 16 * 1024 * 1024; // 16 MB
    });
}

Weitere Informationen zur Konfiguration finden Sie unter gRPC für .NET-Konfiguration.For more information on configuration, see gRPC für .NET-Konfiguration.

ProtokollierungLogging

Bei C-core-basierten Apps wird mit GrpcEnvironment die Protokollierung für Debuggingzwecke konfiguriert.C-core-based apps rely on the GrpcEnvironment to configure the logger for debugging purposes. Im ASP.NET Core-Stapel wird diese Funktion über die Protokollierungs-API bereitgestellt.The ASP.NET Core stack provides this functionality through the Logging API. Beispielsweise kann Protokollierung über Konstruktorinjektion zum gRPC-Dienst hinzugefügt werden:For example, a logger can be added to the gRPC service via constructor injection:

public class GreeterService : Greeter.GreeterBase
{
    public GreeterService(ILogger<GreeterService> logger)
    {
    }
}

HTTPSHTTPS

Bei C-core-basierten Apps wird HTTPS über die Eigenschaft Server.Ports konfiguriert.C-core-based apps configure HTTPS through the Server.Ports property. Ein ähnliches Konzept wird beim Konfigurieren von Servern in ASP.NET Core verwendet.A similar concept is used to configure servers in ASP.NET Core. Kestrel verwendet beispielsweise die Endpunktkonfiguration für diese Funktion.For example, Kestrel uses endpoint configuration for this functionality.

Gegenüberstellung gRPC-Interceptors und MiddlewaregRPC Interceptors vs Middleware

ASP.NET Core-Middleware bietet ähnliche Funktionen wie Interceptors in C-core-basierten gRPC-Apps.ASP.NET Core middleware offers similar functionalities compared to interceptors in C-core-based gRPC apps. ASP.NET Core-Middleware und Interceptors sind konzeptionell ähnlich.ASP.NET Core middleware and interceptors are conceptually similar. Beide:Both:

  • werden dafür verwendet, eine Pipeline zu konstruieren, die gRPC-Anforderungen verarbeitet.Are used to construct a pipeline that handles a gRPC request.
  • ermöglichen das Ausführen von Arbeiten vor oder nach der nächsten Komponente in der Pipeline.Allow work to be performed before or after the next component in the pipeline.
  • ermöglichen den Zugriff auf HttpContext:Provide access to HttpContext:
    • In der Middleware ist HttpContext ein Parameter.In middleware the HttpContext is a parameter.
    • In Interceptors kann auf HttpContext durch den Parameter ServerCallContext mit der Erweiterungsmethode ServerCallContext.GetHttpContext zugegriffen werden.In interceptors the HttpContext can be accessed using the ServerCallContext parameter with the ServerCallContext.GetHttpContext extension method. Beachten Sie, dass dieses Feature spezifisch für Interceptors ist, die in ASP.NET Core ausgeführt werden.Note that this feature is specific to interceptors running in ASP.NET Core.

Unterschiede zwischen gRPC-Interceptors und ASP.NET Core-Middleware:gRPC Interceptor differences from ASP.NET Core Middleware:

  • Interceptors:Interceptors:
    • arbeiten auf der gRPC-Abstraktionsebene mit ServerCallContext.Operate on the gRPC layer of abstraction using the ServerCallContext.
    • stellen Zugriff bereit auf:Provide access to:
      • die deserialisierte, beim Aufruf gesendete Nachricht.The deserialized message sent to a call.
      • die beim Aufruf zurückgegebene Nachricht, bevor diese serialisiert wird.The message being returned from the call before it is serialized.
    • können von gRPC-Diensten ausgelöste Ausnahmen abfangen und verarbeiten.Can catch and handle exceptions thrown from gRPC services.
  • Middleware:Middleware:
    • wird vor gRPC-Interceptors ausgeführt.Runs before gRPC interceptors.
    • arbeitet mit den zugrundeliegenden HTTP/2-Nachrichten.Operates on the underlying HTTP/2 messages.
    • kann nur auf Bytes aus den Anforderungs- und Antwortdatenströmen zugreifen.Can only access bytes from the request and response streams.

Zusätzliche RessourcenAdditional resources