Kommunikation mellan processer med gRPC och namngivna rör

Av James Newton-King

.NET stöder kommunikation mellan processer (IPC) med hjälp av gRPC. Mer information om hur du kommer igång med att använda gRPC för att kommunicera mellan processer finns i Kommunikation mellan processer med gRPC.

Namngivna rör är en IPC-transport som stöds i alla versioner av Windows. Namngivna rör integreras väl med Windows-säkerhet för att styra klientåtkomsten till röret. I den här artikeln beskrivs hur du konfigurerar gRPC-kommunikation över namngivna rör.

Förutsättningar

• .NET 8 eller senare
• Windows

Serverkonfiguration

Namngivna rör stöds av Kestrel, som konfigureras i Program.cs:

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

Föregående exempel:

• Konfigurerar Kestrelslutpunkter i ConfigureKestrel.
• Anropar ListenNamedPipe för att lyssna på en namngiven kanal med det angivna namnet.
• Skapar en namngiven pipe-slutpunkt som inte är konfigurerad att använda HTTPS. Information om hur du aktiverar HTTPS finns i Kestrel HTTPS-slutpunktskonfiguration.

Konfigurera PipeSecurity för namngivna rör

Om du vill styra vilka användare eller grupper som kan ansluta använder du NamedPipeTransportOptions klassen. Detta gör att ett anpassat PipeSecurity objekt kan anges.

Exempel:

using Microsoft.AspNetCore.Server.Kestrel.Transport.NamedPipes;
using System.IO.Pipes;
using System.Security.AccessControl;

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

        // Configure PipeSecurity
        listenOptions.UseNamedPipes(options =>
        {
            var pipeSecurity = new PipeSecurity();
            // Grant read/write access to the Users group
            pipeSecurity.AddAccessRule(new PipeAccessRule(
                "Users",
                PipeAccessRights.ReadWrite,
                AccessControlType.Allow));
            // Add additional rules as needed

            options.PipeSecurity = pipeSecurity;
        });
    });
});

Föregående exempel:

• Använder UseNamedPipes för att komma åt och konfigurera NamedPipeTransportOptions.
• Anger egenskapen PipeSecurity för att styra vilka användare eller grupper som kan ansluta till det namngivna röret.
• Beviljar läs-/skrivåtkomst till Users gruppen. Ytterligare säkerhetsregler kan läggas till efter behov för scenariot.

Anpassa Kestrel namngivna rörslutpunkter

Kestrel"s namngivna pipe-stöd möjliggör avancerad anpassning, så att du kan konfigurera olika säkerhetsinställningar för varje slutpunkt med hjälp av CreateNamedPipeServerStream alternativet . Den här metoden är perfekt för scenarier där flera namngivna pipe-slutpunkter kräver unika åtkomstkontroller. Möjligheten att anpassa rör per slutpunkt är tillgänglig från och med .NET 9.

Ett exempel på var detta är användbart är en Kestrel app som kräver två pipe-slutpunkter med olika åtkomstsäkerhet. Alternativet CreateNamedPipeServerStream kan användas för att skapa rör med anpassade säkerhetsinställningar, beroende på rörnamnet.

var builder = WebApplication.CreateBuilder();
builder.WebHost.ConfigureKestrel(options =>
{
    options.ListenNamedPipe("pipe1");
    options.ListenNamedPipe("pipe2");
});

builder.WebHost.UseNamedPipes(options =>
{
    options.CreateNamedPipeServerStream = (context) =>
    {
        var pipeSecurity = CreatePipeSecurity(context.NamedPipeEndpoint.PipeName);

        return NamedPipeServerStreamAcl.Create(context.NamedPipeEndpoint.PipeName, PipeDirection.InOut,
            NamedPipeServerStream.MaxAllowedServerInstances, PipeTransmissionMode.Byte,
            context.PipeOptions, inBufferSize: 0, outBufferSize: 0, pipeSecurity);
    };
});

Klientkonfiguration

GrpcChannel stöder gRPC-anropningar via anpassade transporter. När en kanal skapas kan den konfigureras med en SocketsHttpHandler som har en anpassad ConnectCallback. Återanropet gör att klienten kan upprätta anslutningar via anpassade transporter och sedan skicka HTTP-begäranden via den transporten.

Exempel på anslutningsfabrik för namngivna rör:

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;
        }
    }
}

Använda den anpassade anslutningsfabriken för att skapa en kanal:

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
    });
}

Kanaler som skapats med hjälp av föregående kod skickar gRPC-anrop via namngivna pipes.