Comunicazione tra processi con gRPC

Nota

Questa non è la versione più recente di questo articolo. Per la versione corrente, vedere la versione .NET 11 di questo articolo.

Avviso

Questa versione di ASP.NET Core non è più supportata. Per altre informazioni, vedere i criteri di supporto di .NET e .NET Core. Per la versione corrente, vedere la versione .NET 10 di questo articolo.

I processi in esecuzione nello stesso computer possono essere progettati per comunicare tra loro. I sistemi operativi forniscono tecnologie per abilitare la comunicazione tra processi (IPC) veloce ed efficiente. Esempi comuni di tecnologie IPC sono socket di dominio Unix e named pipe.

.NET offre supporto per la comunicazione tra processi tramite gRPC.

Il supporto predefinito per named pipe in ASP.NET Core richiede .NET 8 o versione successiva.

Per iniziare

Le chiamate IPC vengono inviate da un client a un server. Per comunicare tra app in un computer con gRPC, almeno un'app deve ospitare un server ASP.NET Core gRPC.

Un server ASP.NET Core gRPC viene in genere creato dal modello gRPC. Il file di progetto creato dal modello usa Microsoft.NET.SDK.Web come SDK:

<Project Sdk="Microsoft.NET.Sdk.Web">

  <ItemGroup>
    <PackageReference Include="Grpc.AspNetCore" Version="2.47.0" />
    <Protobuf Include="Protos\greet.proto" GrpcServices="Server" />
  </ItemGroup>

</Project>

Il valore dell'SDK Microsoft.NET.SDK.Web aggiunge automaticamente un riferimento al framework ASP.NET Core. Il riferimento consente all'app di usare ASP.NET tipi core necessari per ospitare un server.

È anche possibile aggiungere un server a progetti non-ASP.NET Core esistenti, ad esempio Servizi Windows, app macchine virtuali Windows o app WinForms. Per altre informazioni, vedere Host gRPC nei progetti non-ASP.NET Core.

Trasporti per la comunicazione tra processi (IPC)

Le chiamate gRPC tra un client e un server in computer diversi vengono in genere inviate tramite socket TCP. TCP è una buona scelta per la comunicazione tra una rete o Internet. Tuttavia, i trasporti IPC offrono vantaggi quando i processi comunicano sulla stessa macchina:

  • Minore sovraccarico e velocità di trasferimento più veloci.
  • Integrazione con le funzionalità di sicurezza del sistema operativo.
  • Non usa porte TCP, che sono una risorsa limitata.

.NET supporta più trasporti IPC:

A seconda del sistema operativo, le app multipiattaforma possono scegliere trasporti IPC diversi. Un'app può controllare il sistema operativo all'avvio e scegliere il trasporto desiderato per tale piattaforma:

var builder = WebApplication.CreateBuilder(args);
builder.WebHost.ConfigureKestrel(serverOptions =>
{
    if (OperatingSystem.IsWindows())
    {
        serverOptions.ListenNamedPipe("MyPipeName");
    }
    else
    {
        var socketPath = Path.Combine(Path.GetTempPath(), "socket.tmp");
        serverOptions.ListenUnixSocket(socketPath);
    }

    serverOptions.ConfigureEndpointDefaults(listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http2;
    });
});

Considerazioni relative alla sicurezza

Le app IPC inviano e ricevono chiamate RPC. La comunicazione esterna è un potenziale vettore di attacco per le app IPC e deve essere protetta correttamente.

Proteggere l'app server IPC da chiamanti imprevisti

L'app server IPC ospita servizi RPC che possono essere chiamati da altre app. I chiamanti in ingresso devono essere autenticati per impedire ai client non attendibili di effettuare chiamate RPC al server.

La sicurezza del trasporto è un'opzione per proteggere un server. I TRASPORTI IPC, ad esempio socket di dominio Unix e named pipe, supportano la limitazione dell'accesso in base alle autorizzazioni del sistema operativo:

  • Le named pipe consentono di proteggere una pipe con il modello di controllo di accesso di Windows. I diritti di accesso possono essere configurati in .NET quando un server viene avviato usando la PipeSecurity classe .
  • I socket di dominio Unix supportano la protezione di un socket con autorizzazioni per i file.

Un'altra opzione per proteggere un server IPC consiste nell'usare l'autenticazione e l'autorizzazione integrate in ASP.NET Core. Ad esempio, il server può essere configurato per richiedere l'autenticazione del certificato. Le chiamate RPC effettuate dalle app client senza il certificato richiesto hanno esito negativo con una risposta non autorizzata.

Convalidare il server nell'app client IPC

È importante che l'app client convalide l'identità del server che sta chiamando. La validazione è necessaria per impedire che un attore malintenzionato arresti il server attendibile, ne esegua uno proprio e accetti i dati in ingresso dai client.

Le named pipe consentono di ottenere l'account con cui è in esecuzione il server. Un client può convalidare che il server sia stato avviato dall'account previsto:

internal static bool CheckPipeConnectionOwnership(
    NamedPipeClientStream pipeStream, SecurityIdentifier expectedOwner)
{
    var remotePipeSecurity = pipeStream.GetAccessControl();
    var remoteOwner = remotePipeSecurity.GetOwner(typeof(SecurityIdentifier));
    return expectedOwner.Equals(remoteOwner);
}

Un'altra opzione per convalidare il server consiste nel proteggere gli endpoint con HTTPS all'interno di ASP.NET Core. Il client può configurare SocketsHttpHandler per verificare che il server utilizzi il certificato previsto quando viene stabilita la connessione.

var socketsHttpHandler = new SocketsHttpHandler()
{
    SslOptions = new SslOptions()
    {
        RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) =>
        {
            if (sslPolicyErrors != SslPolicyErrors.None)
            {
                return false;
            }

            // Validate server cert thumbprint matches the expected thumbprint.
        }
    }
};

Proteggere dall'escalation dei privilegi tramite pipe con nome

Le named pipe supportano una funzionalità chiamata impersonificazione. Utilizzando l'impersonificazione, il server di named pipe può eseguire codice con i privilegi dell'utente client. Si tratta di una funzionalità potente, ma può consentire a un server con privilegi limitati di rappresentare un chiamante con privilegi elevati e quindi eseguire codice dannoso.

I client possono proteggersi da questo attacco non consentendo l'impersonificazione quando si connettono a un server. A meno che un server non lo richieda, si dovrebbe usare un valore di TokenImpersonationLevel pari a None o Anonymous durante la creazione di una connessione client:

using var pipeClient = new NamedPipeClientStream(
    serverName: ".", pipeName: "testpipe", PipeDirection.In, PipeOptions.None, TokenImpersonationLevel.None);
await pipeClient.ConnectAsync();

TokenImpersonationLevel.None è il valore predefinito nei NamedPipeClientStream costruttori che non hanno un impersonationLevel parametro.

Configurare client e server

Il client e il server devono essere configurati per l'uso di un trasporto IPC (Inter-Process Communication). Per ulteriori informazioni su come configurare Kestrel e SocketsHttpHandler per utilizzare IPC:

Nota

Il supporto predefinito per named pipe in ASP.NET Core richiede .NET 8 o versione successiva.

Avviso

Un trasporto IPC, ad esempio socket di dominio Unix o named pipe, richiede al client di configurare SocketsHttpHandler.ConnectCallback per creare una connessione all'endpoint personalizzato. Un canale che usa un ConnectCallback non supporta il bilanciamento del carico sul lato client o il rilevamento dello stato della connettività e le funzionalità seguenti non sono disponibili:

  • Bilanciamento del carico lato client configurato con ServiceConfig.LoadBalancingConfigs.
  • Rilevamento dello stato della connettività con GrpcChannel.State e GrpcChannel.WaitForStateChangedAsync.

Il tentativo di usare queste funzionalità in un canale configurato per IPC genera un'eccezione:

System.InvalidOperationException: Channel is configured with an HTTP transport doesn't support client-side load balancing or connectivity state tracking. The underlying HTTP transport must be a SocketsHttpHandler with no SocketsHttpHandler.ConnectCallback configured. The HTTP transport must be configured on the channel using GrpcChannelOptions.HttpHandler.

I processi in esecuzione nello stesso computer possono essere progettati per comunicare tra loro. I sistemi operativi forniscono tecnologie per abilitare la comunicazione tra processi (IPC) veloce ed efficiente. Esempi comuni di tecnologie IPC sono socket di dominio Unix e named pipe.

.NET offre supporto per la comunicazione tra processi tramite gRPC.

Nota

Il supporto predefinito per named pipe in ASP.NET Core richiede .NET 8 o versione successiva. Per altre informazioni, vedere la versione .NET 8 o successiva di questo articolo

Per iniziare

Le chiamate gRPC vengono inviate da un client a un server. Per comunicare tra app in un computer con gRPC, almeno un'app deve ospitare un server ASP.NET Core gRPC.

ASP.NET Core e gRPC possono essere ospitati in qualsiasi app usando .NET Core 3.1 o versione successiva aggiungendo il Microsoft.AspNetCore.App framework al progetto.

<Project Sdk="Microsoft.NET.Sdk">

  <ItemGroup>
    <FrameworkReference Include="Microsoft.AspNetCore.App" />
    <PackageReference Include="Grpc.AspNetCore" Version="2.47.0" />
    <Protobuf Include="Protos\greet.proto" GrpcServices="Server" />
  </ItemGroup>

</Project>

Il file di progetto precedente:

  • Aggiunge un riferimento al framework a Microsoft.AspNetCore.App. Il riferimento al framework consente alle app non ASP.NET Core, ad esempio servizi Windows, app macchine virtuali Windows o app WinForms, di usare ASP.NET Core e ospitare un server ASP.NET Core.
  • Aggiunge un riferimento al pacchetto NuGet a Grpc.AspNetCore.
  • Aggiunge un .proto file.

Configurare i socket di dominio Unix

Le chiamate gRPC tra un client e un server in computer diversi vengono in genere inviate tramite socket TCP. TCP è stato progettato per la comunicazione tra una rete. I socket di dominio Unix (UDS) sono una tecnologia IPC ampiamente supportata che è più efficiente di TCP quando il client e il server si trovano nello stesso computer. .NET offre supporto integrato per UDS nelle app client e server.

Requisiti:

Configurazione del server

I socket di dominio Unix (UDS) sono supportati da Kestrel, che è configurato in Program.cs:

public static readonly string SocketPath = Path.Combine(Path.GetTempPath(), "socket.tmp");

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
            webBuilder.ConfigureKestrel(options =>
            {
                if (File.Exists(SocketPath))
                {
                    File.Delete(SocketPath);
                }
                options.ListenUnixSocket(SocketPath, listenOptions =>
                {
                    listenOptions.Protocols = HttpProtocols.Http2;
                });
            });
        });

L'esempio precedente:

  • Configura gli endpoint di Kestrel in ConfigureKestrel.
  • Chiama ListenUnixSocket per mettersi in ascolto su un socket di dominio Unix (UDS) con il percorso specificato.
  • Crea un endpoint UDS che non è configurato per utilizzare HTTPS. Per informazioni sull'abilitazione di HTTPS, vedere Kestrel Configurazione dell'endpoint HTTPS.

Configurazione del client

GrpcChannel consente di effettuare chiamate gRPC tramite trasporti personalizzati. Quando viene creato un canale, può essere configurato con un SocketsHttpHandler con un ConnectCallback personalizzato. Il callback consente al client di effettuare connessioni su trasporti personalizzati e quindi inviare richieste HTTP su tale trasporto.

Esempio di fabbrica di connessioni per socket di dominio Unix:

public class UnixDomainSocketConnectionFactory
{
    private readonly EndPoint _endPoint;

    public UnixDomainSocketConnectionFactory(EndPoint endPoint)
    {
        _endPoint = endPoint;
    }

    public async ValueTask<Stream> ConnectAsync(SocketsHttpConnectionContext _,
        CancellationToken cancellationToken = default)
    {
        var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);

        try
        {
            await socket.ConnectAsync(_endPoint, cancellationToken).ConfigureAwait(false);
            return new NetworkStream(socket, true);
        }
        catch
        {
            socket.Dispose();
            throw;
        }
    }
}

Utilizzo della connection factory personalizzata per creare un canale:

public static readonly string SocketPath = Path.Combine(Path.GetTempPath(), "socket.tmp");

public static GrpcChannel CreateChannel()
{
    var udsEndPoint = new UnixDomainSocketEndPoint(SocketPath);
    var connectionFactory = new UnixDomainSocketConnectionFactory(udsEndPoint);
    var socketsHttpHandler = new SocketsHttpHandler
    {
        ConnectCallback = connectionFactory.ConnectAsync
    };

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

Canali creati usando il codice precedente inviano chiamate gRPC su socket di dominio Unix. Il supporto per altre tecnologie IPC può essere implementato usando l'estendibilità in Kestrel e SocketsHttpHandler.