Communication entre processus avec gRPC et canaux nommés

Par James Newton-King

.NET prend en charge la communication entre processus (IPC) à l’aide de gRPC. Pour plus d’informations sur la prise en main de l’utilisation de gRPC pour communiquer entre processus, consultez Communication entre processus avec gRPC.

Les canaux nommés sont un transport IPC pris en charge sur toutes les versions de Windows. Les canaux nommés s’intègrent bien à la sécurité Windows pour contrôler l’accès client au canal. Cet article explique comment configurer la communication gRPC sur des canaux nommés.

Prérequis

• .NET 8 ou version ultérieure
• Windows

Configurer le serveur

Les canaux nommés sont pris en charge par Kestrel, qui est configuré dans Program.cs :

var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.ListenNamedPipe("MyPipeName", listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http2;
    });
});

L’exemple précédent :

• Configure les points de terminaison de Kestrel dans ConfigureKestrel.
• Appelle ListenNamedPipe pour écouter un canal nommé avec le nom spécifié.
• Crée un point de terminaison de canal nommé qui n’est pas configuré pour utiliser HTTPS. Pour plus d’informations sur l’activation du protocole HTTPS, consultez Kestrel Configuration du point de terminaison HTTPS.

Configuration de client

GrpcChannel prend en charge les appels gRPC sur des transports personnalisés. Lorsqu’un canal est créé, il peut être configuré avec un SocketsHttpHandler qui a un ConnectCallback personnalisé. Le rappel permet au client d’établir des connexions via des transports personnalisés, puis d’envoyer des requêtes HTTP sur ce transport.

Remarque

Certaines fonctionnalités de connectivité de GrpcChannel, telles que l’équilibrage de charge côté client et l’état du canal, ne peuvent pas être utilisées avec des canaux nommés.

Exemple de fabrique de connexion de canaux nommés :

public class NamedPipesConnectionFactory
{
    private readonly string pipeName;

    public NamedPipesConnectionFactory(string pipeName)
    {
        this.pipeName = pipeName;
    }

    public async ValueTask<Stream> ConnectAsync(SocketsHttpConnectionContext _,
        CancellationToken cancellationToken = default)
    {
        var clientStream = new NamedPipeClientStream(
            serverName: ".",
            pipeName: this.pipeName,
            direction: PipeDirection.InOut,
            options: PipeOptions.WriteThrough | PipeOptions.Asynchronous,
            impersonationLevel: TokenImpersonationLevel.Anonymous);

        try
        {
            await clientStream.ConnectAsync(cancellationToken).ConfigureAwait(false);
            return clientStream;
        }
        catch
        {
            clientStream.Dispose();
            throw;
        }
    }
}

Utilisation de la fabrique de connexion personnalisée pour créer un canal :

public static GrpcChannel CreateChannel()
{
    var connectionFactory = new NamedPipesConnectionFactory("MyPipeName");
    var socketsHttpHandler = new SocketsHttpHandler
    {
        ConnectCallback = connectionFactory.ConnectAsync
    };

    return GrpcChannel.ForAddress("http://localhost", new GrpcChannelOptions
    {
        HttpHandler = socketsHttpHandler
    });
}

Les canaux créés à l’aide du code précédent envoient des appels gRPC sur des canaux nommés.