Esercitazione: Creare un client e un server gRPC in ASP.NET Core
Questa esercitazione illustra come creare un client gRPC .NET Core e un server gRPC ASP.NET Core. Al termine, si otterrà un client gRPC che comunica con il servizio Greeter gRPC.
In questa esercitazione:
- Creare un server gRPC.
- Creare un client gRPC.
- Testare il client gRPC con il servizio gRPC Greeter.
Prerequisiti
Visual Studio 2022 con il carico di lavoro Sviluppo ASP.NET e Web.
Creare un servizio gRPC
- Avviare Visual Studio 2022 e selezionare Nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto cercare
gRPC. Selezionare ASP.NET Servizio Core gRPC e selezionare Avanti. - Nella finestra di dialogo Configura il nuovo progetto immettere
GrpcGreeterper Nome progetto. È importante denominare il progetto GrpcGreeter in modo che gli spazi dei nomi corrispondano quando si copia e incolla il codice. - Selezionare Avanti.
- Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 8.0 (supporto a lungo termine) e quindi selezionare Crea.
Eseguire il servizio
Premere CTRL+F5 per l'esecuzione senza il debugger.
Visual Studio visualizza la finestra di dialogo seguente quando un progetto non è ancora configurato per l'uso di SSL:
Selezionare Sì se si considera attendibile il certificato SSL di IIS Express.
Verrà visualizzata la finestra di dialogo seguente:
Selezionare Sì se si accetta di considerare attendibile il certificato di sviluppo.
Per informazioni sull'attendibilità del browser Firefox, vedere Firefox SEC_ERROR_INADEQUATE_KEY_USAGE errore del certificato.
Visual Studio:
- Avvia Kestrel il server.
- Avvia un browser.
- Passa a
http://localhost:port, ad esempiohttp://localhost:7042.- port: numero di porta assegnato in modo casuale per l'app.
localhost: nome host standard per il computer locale. Localhost viene usato solo per le richieste web del computer locale.
I log mostrano il servizio in ascolto su https://localhost:<port>, dove <port> è il numero di porta localhost assegnato in modo casuale quando il progetto viene creato e impostato in Properties/launchSettings.json.
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:<port>
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
Nota
Il modello gRPC è configurato per l'uso di Transport Layer Security (TLS). i client gRPC devono usare HTTPS per chiamare il server. Il numero di porta localhost del servizio gRPC viene assegnato in modo casuale quando il progetto viene creato e impostato nel file Properties\launchSettings.json del progetto di servizio gRPC.
Esaminare i file di progetto
File di progetto GrpcGreeter:
Protos/greet.proto: definisce ilGreetergRPC e viene usato per generare gli asset del server gRPC. Per altre informazioni, vedere Introduzione a gRPC.Servicesfolder: contiene l'implementazione delGreeterservizio.appSettings.json: contiene dati di configurazione, ad esempio il protocollo usato da Kestrel. Per altre informazioni, vedere Configurazione in ASP.NET Core.Program.cs, che contiene:- Punto di ingresso per il servizio gRPC. Per altre informazioni, vedere Host generico .NET in ASP.NET Core.
- Codice che configura il comportamento dell'app. Per altre informazioni, vedere Avvio dell'app.
Creare il client gRPC in un'app console .NET
- Aprire una seconda istanza di Visual Studio e selezionare Nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto selezionare App console e selezionare Avanti.
- Nella casella di testo Nome progetto immettere GrpcGreeterClient e selezionare Avanti.
- Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 8.0 (supporto a lungo termine) e quindi selezionare Crea.
Aggiungere i pacchetti NuGet necessari
Il progetto client gRPC richiede i pacchetti NuGet seguenti:
- Grpc.Net.Client, che contiene il client .NET Core.
- Google.Protobuf, che contiene le API per i messaggi protobuf per C#.
- Grpc.Tools, che contiene il supporto degli strumenti C# per i file protobuf. Il pacchetto di strumenti non è necessario in fase di esecuzione, quindi la dipendenza è contrassegnata come
PrivateAssets="All".
Installare i pacchetti tramite la Console di gestione pacchetti (PMC) o Gestisci pacchetti NuGet.
Opzione con la console di Gestione pacchetti per installare i pacchetti
Da Visual Studio selezionare Strumenti>Gestione pacchetti NuGet>Console di Gestione pacchetti
Dalla finestra della console di Gestione pacchetti eseguire
cd GrpcGreeterClientper modificare le directory nella cartella contenente iGrpcGreeterClient.csprojfile.Eseguire i comandi seguenti:
Install-Package Grpc.Net.Client Install-Package Google.Protobuf Install-Package Grpc.Tools
Opzione Gestisci pacchetti NuGet per installare i pacchetti
- Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni>Gestisci pacchetti NuGet.
- Selezionare la scheda Sfoglia.
- Immettere Grpc.Net.Client nella casella di ricerca.
- Selezionare il pacchetto Grpc.Net.Client dalla scheda Sfoglia e fare clic su Installa.
- Ripeti i passaggi per
Google.ProtobufeGrpc.Tools.
Aggiungere greet.proto
Creare una cartella Protos nel progetto client gRPC.
Copiare il file Protos\greet.proto dal servizio gRPC Greeter alla cartella Protos nel progetto client gRPC.
Aggiornare lo spazio dei nomi all'interno del
greet.protofile nello spazio dei nomi del progetto:option csharp_namespace = "GrpcGreeterClient";Modificare il file di
GrpcGreeterClient.csprojprogetto:
Fare clic con il pulsante destro del mouse sul progetto e scegliere Modifica file di progetto.
Aggiungere un gruppo di elementi con un elemento
<Protobuf>che fa riferimento al file greet.proto:<ItemGroup> <Protobuf Include="Protos\greet.proto" GrpcServices="Client" /> </ItemGroup>
Creare il client Greeter
- Compilare il progetto client per creare i tipi nello spazio dei
GrpcGreeterClientnomi .
Nota
I tipi GrpcGreeterClient vengono generati automaticamente dal processo di compilazione. Il pacchetto di strumenti Grpc.Tools genera i file seguenti in base al file greet.proto :
GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\Greet.cs: codice del buffer del protocollo che popola, serializza e recupera i tipi di messaggio di richiesta e risposta.GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\GreetGrpc.cs: contiene le classi client generate.
Per altre informazioni sugli asset C# generati automaticamente da Grpc.Tools, vedere Servizi gRPC con C#: Asset C# generati.
Aggiornare il file client
Program.csgRPC con il codice seguente.using System.Threading.Tasks; using Grpc.Net.Client; using GrpcGreeterClient; // The port number must match the port of the gRPC server. using var channel = GrpcChannel.ForAddress("https://localhost:7042"); var client = new Greeter.GreeterClient(channel); var reply = await client.SayHelloAsync( new HelloRequest { Name = "GreeterClient" }); Console.WriteLine("Greeting: " + reply.Message); Console.WriteLine("Press any key to exit..."); Console.ReadKey();Nel codice evidenziato precedente sostituire il numero
7042di porta localhost con ilHTTPSnumero di porta specificato nelProperties/launchSettings.jsonprogetto diGrpcGreeterservizio.
Program.cs contiene il punto di ingresso e la logica per il client gRPC.
Il client Greeter viene creato come descritto di seguito:
- Creare un'istanza di
GrpcChannelcontenente le informazioni per creare la connessione al servizio gRPC. - Usare
GrpcChannelper costruire il client Greeter:
// The port number must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:7042");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
Il client Greeter chiama il metodo SayHello asincrono. Viene visualizzato il risultato della chiamata SayHello:
// The port number must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:7042");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
Testare il client gRPC con il servizio Greeter gRPC
Aggiornare il appsettings.Development.json file aggiungendo le righe evidenziate seguenti:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
,"Microsoft.AspNetCore.Hosting": "Information",
"Microsoft.AspNetCore.Routing.EndpointMiddleware": "Information"
}
}
}
- Nel servizio Greeter premere
Ctrl+F5per avviare il server senza il debugger. - Nel progetto
GrpcGreeterClientpremereCtrl+F5per avviare il client senza il debugger.
Il client invia un saluto al servizio con un messaggio contenente il nome GreeterClient. Il servizio invia il messaggio "Hello GreeterClient" come risposta. La risposta "Hello GreeterClient" viene visualizzata al prompt dei comandi:
Greeting: Hello GreeterClient
Press any key to exit...
Il servizio gRPC registra i dettagli della chiamata con esito positivo nei log scritti al prompt dei comandi:
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:<port>
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
Content root path: C:\GH\aspnet\docs\4\Docs\aspnetcore\tutorials\grpc\grpc-start\sample\GrpcGreeter
info: Microsoft.AspNetCore.Hosting.Diagnostics[1]
Request starting HTTP/2 POST https://localhost:<port>/Greet.Greeter/SayHello application/grpc
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[0]
Executing endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[1]
Executed endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
Request finished in 78.32260000000001ms 200 application/grpc
Nota
Il codice in questo articolo richiede il certificato di sviluppo HTTPS ASP.NET Core per proteggere il servizio gRPC. Se il client .NET gRPC ha esito negativo con il messaggio The remote certificate is invalid according to the validation procedure. o The SSL connection could not be established., il certificato di sviluppo non è attendibile. Per risolvere questo problema, vedere Chiamare un servizio gRPC con un certificato non attendibile o non valido.
Passaggi successivi
Questa esercitazione illustra come creare un client gRPC .NET Core e un server gRPC ASP.NET Core. Al termine, si otterrà un client gRPC che comunica con il servizio Greeter gRPC.
In questa esercitazione:
- Creare un server gRPC.
- Creare un client gRPC.
- Testare il client gRPC con il servizio gRPC Greeter.
Prerequisiti
Visual Studio 2022 con il carico di lavoro Sviluppo ASP.NET e Web.
Creare un servizio gRPC
- Avviare Visual Studio 2022 e selezionare Crea un nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto cercare
gRPC. Selezionare ASP.NET Servizio Core gRPC e selezionare Avanti. - Nella finestra di dialogo Configura il nuovo progetto immettere
GrpcGreeterper Nome progetto. È importante denominare il progetto GrpcGreeter in modo che gli spazi dei nomi corrispondano quando si copia e incolla il codice. - Selezionare Avanti.
- Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 6.0 (supporto a lungo termine) e quindi selezionare Crea.
Eseguire il servizio
Premere CTRL+F5 per l'esecuzione senza il debugger.
Visual Studio visualizza la finestra di dialogo seguente quando un progetto non è ancora configurato per l'uso di SSL:
Selezionare Sì se si considera attendibile il certificato SSL di IIS Express.
Verrà visualizzata la finestra di dialogo seguente:
Selezionare Sì se si accetta di considerare attendibile il certificato di sviluppo.
Per informazioni sull'attendibilità del browser Firefox, vedere Firefox SEC_ERROR_INADEQUATE_KEY_USAGE errore del certificato.
Visual Studio:
- Avvia Kestrel il server.
- Avvia un browser.
- Passa a
http://localhost:port, ad esempiohttp://localhost:7042.- port: numero di porta assegnato in modo casuale per l'app.
localhost: nome host standard per il computer locale. Localhost viene usato solo per le richieste web del computer locale.
I log mostrano il servizio in ascolto su https://localhost:<port>, dove <port> è il numero di porta localhost assegnato in modo casuale quando il progetto viene creato e impostato in Properties/launchSettings.json.
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:<port>
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
Nota
Il modello gRPC è configurato per l'uso di Transport Layer Security (TLS). i client gRPC devono usare HTTPS per chiamare il server. Il numero di porta localhost del servizio gRPC viene assegnato in modo casuale quando il progetto viene creato e impostato nel file Properties\launchSettings.json del progetto di servizio gRPC.
macOS non supporta ASP.NET Core gRPC con TLS. Per eseguire correttamente i servizi gRPC in macOS, è necessaria una configurazione aggiuntiva. Per altre informazioni, vedere Non è possibile avviare un'app ASP.NET Core gRPC in macOS.
Esaminare i file di progetto
File di progetto GrpcGreeter:
Protos/greet.proto: definisce ilGreetergRPC e viene usato per generare gli asset del server gRPC. Per altre informazioni, vedere Introduzione a gRPC.Servicesfolder: contiene l'implementazione delGreeterservizio.appSettings.json: contiene dati di configurazione, ad esempio il protocollo usato da Kestrel. Per altre informazioni, vedere Configurazione in ASP.NET Core.Program.cs, che contiene:- Punto di ingresso per il servizio gRPC. Per altre informazioni, vedere Host generico .NET in ASP.NET Core.
- Codice che configura il comportamento dell'app. Per altre informazioni, vedere Avvio dell'app.
Creare il client gRPC in un'app console .NET
- Aprire una seconda istanza di Visual Studio e selezionare Crea un nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto selezionare Applicazione console e selezionare Avanti.
- Nella casella di testo Nome progetto immettere GrpcGreeterClient e selezionare Avanti.
- Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 6.0 (supporto a lungo termine) e quindi selezionare Crea.
Aggiungere i pacchetti NuGet necessari
Il progetto client gRPC richiede i pacchetti NuGet seguenti:
- Grpc.Net.Client, che contiene il client .NET Core.
- Google.Protobuf, che contiene le API per i messaggi protobuf per C#.
- Grpc.Tools, che contiene il supporto degli strumenti C# per i file protobuf. Il pacchetto di strumenti non è necessario in fase di esecuzione, quindi la dipendenza è contrassegnata come
PrivateAssets="All".
Installare i pacchetti tramite la Console di gestione pacchetti (PMC) o Gestisci pacchetti NuGet.
Opzione con la console di Gestione pacchetti per installare i pacchetti
Da Visual Studio selezionare Strumenti>Gestione pacchetti NuGet>Console di Gestione pacchetti
Dalla finestra della console di Gestione pacchetti eseguire
cd GrpcGreeterClientper modificare le directory nella cartella contenente iGrpcGreeterClient.csprojfile.Eseguire i comandi seguenti:
Install-Package Grpc.Net.Client Install-Package Google.Protobuf Install-Package Grpc.Tools
Opzione Gestisci pacchetti NuGet per installare i pacchetti
- Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni>Gestisci pacchetti NuGet.
- Selezionare la scheda Sfoglia.
- Immettere Grpc.Net.Client nella casella di ricerca.
- Selezionare il pacchetto Grpc.Net.Client dalla scheda Sfoglia e fare clic su Installa.
- Ripeti i passaggi per
Google.ProtobufeGrpc.Tools.
Aggiungere greet.proto
Creare una cartella Protos nel progetto client gRPC.
Copiare il file Protos\greet.proto dal servizio gRPC Greeter alla cartella Protos nel progetto client gRPC.
Aggiornare lo spazio dei nomi all'interno del
greet.protofile nello spazio dei nomi del progetto:option csharp_namespace = "GrpcGreeterClient";Modificare il file di
GrpcGreeterClient.csprojprogetto:
Fare clic con il pulsante destro del mouse sul progetto e scegliere Modifica file di progetto.
Aggiungere un gruppo di elementi con un elemento
<Protobuf>che fa riferimento al file greet.proto:<ItemGroup> <Protobuf Include="Protos\greet.proto" GrpcServices="Client" /> </ItemGroup>
Creare il client Greeter
- Compilare il progetto client per creare i tipi nello spazio dei
GrpcGreeterClientnomi .
Nota
I tipi GrpcGreeterClient vengono generati automaticamente dal processo di compilazione. Il pacchetto di strumenti Grpc.Tools genera i file seguenti in base al file greet.proto :
GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\Greet.cs: codice del buffer del protocollo che popola, serializza e recupera i tipi di messaggio di richiesta e risposta.GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\GreetGrpc.cs: contiene le classi client generate.
Per altre informazioni sugli asset C# generati automaticamente da Grpc.Tools, vedere Servizi gRPC con C#: Asset C# generati.
Aggiornare il file client
Program.csgRPC con il codice seguente.using System.Threading.Tasks; using Grpc.Net.Client; using GrpcGreeterClient; // The port number must match the port of the gRPC server. using var channel = GrpcChannel.ForAddress("https://localhost:7042"); var client = new Greeter.GreeterClient(channel); var reply = await client.SayHelloAsync( new HelloRequest { Name = "GreeterClient" }); Console.WriteLine("Greeting: " + reply.Message); Console.WriteLine("Press any key to exit..."); Console.ReadKey();Nel codice evidenziato precedente sostituire il numero
7042di porta localhost con ilHTTPSnumero di porta specificato nelProperties/launchSettings.jsonprogetto diGrpcGreeterservizio.
Program.cs contiene il punto di ingresso e la logica per il client gRPC.
Il client Greeter viene creato come descritto di seguito:
- Creare un'istanza di
GrpcChannelcontenente le informazioni per creare la connessione al servizio gRPC. - Usare
GrpcChannelper costruire il client Greeter:
// The port number must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:7042");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
Il client Greeter chiama il metodo SayHello asincrono. Viene visualizzato il risultato della chiamata SayHello:
// The port number must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:7042");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
Testare il client gRPC con il servizio Greeter gRPC
Aggiornare il appsettings.Development.json file aggiungendo le righe evidenziate seguenti:
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
,"Microsoft.AspNetCore.Hosting": "Information",
"Microsoft.AspNetCore.Routing.EndpointMiddleware": "Information"
}
}
}
- Nel servizio Greeter premere
Ctrl+F5per avviare il server senza il debugger. - Nel progetto
GrpcGreeterClientpremereCtrl+F5per avviare il client senza il debugger.
Il client invia un saluto al servizio con un messaggio contenente il nome GreeterClient. Il servizio invia il messaggio "Hello GreeterClient" come risposta. La risposta "Hello GreeterClient" viene visualizzata al prompt dei comandi:
Greeting: Hello GreeterClient
Press any key to exit...
Il servizio gRPC registra i dettagli della chiamata con esito positivo nei log scritti al prompt dei comandi:
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:<port>
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
Content root path: C:\GH\aspnet\docs\4\Docs\aspnetcore\tutorials\grpc\grpc-start\sample\GrpcGreeter
info: Microsoft.AspNetCore.Hosting.Diagnostics[1]
Request starting HTTP/2 POST https://localhost:<port>/Greet.Greeter/SayHello application/grpc
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[0]
Executing endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[1]
Executed endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
Request finished in 78.32260000000001ms 200 application/grpc
Nota
Il codice in questo articolo richiede il certificato di sviluppo HTTPS ASP.NET Core per proteggere il servizio gRPC. Se il client .NET gRPC ha esito negativo con il messaggio The remote certificate is invalid according to the validation procedure. o The SSL connection could not be established., il certificato di sviluppo non è attendibile. Per risolvere questo problema, vedere Chiamare un servizio gRPC con un certificato non attendibile o non valido.
Passaggi successivi
Questa esercitazione illustra come creare un client gRPC .NET Core e un server gRPC ASP.NET Core. Al termine, si otterrà un client gRPC che comunica con il servizio Greeter gRPC.
In questa esercitazione:
- Creare un server gRPC.
- Creare un client gRPC.
- Testare il client gRPC con il servizio gRPC Greeter.
Prerequisiti
- Visual Studio 2022 con il carico di lavoro Sviluppo ASP.NET e Web.
- .NET 6.0 SDK
Creare un servizio gRPC
- Avviare Visual Studio 2022 e selezionare Crea un nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto cercare
gRPC. Selezionare ASP.NET Servizio Core gRPC e selezionare Avanti. - Nella finestra di dialogo Configura il nuovo progetto immettere
GrpcGreeterper Nome progetto. È importante denominare il progetto GrpcGreeter in modo che gli spazi dei nomi corrispondano quando si copia e incolla il codice. - Selezionare Avanti.
- Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 6.0 (supporto a lungo termine) e quindi selezionare Crea.
Eseguire il servizio
Premere CTRL+F5 per l'esecuzione senza il debugger.
Visual Studio visualizza la finestra di dialogo seguente quando un progetto non è ancora configurato per l'uso di SSL:
Selezionare Sì se si considera attendibile il certificato SSL di IIS Express.
Verrà visualizzata la finestra di dialogo seguente:
Selezionare Sì se si accetta di considerare attendibile il certificato di sviluppo.
Per informazioni sull'attendibilità del browser Firefox, vedere Firefox SEC_ERROR_INADEQUATE_KEY_USAGE errore del certificato.
Visual Studio:
- Avvia Kestrel il server.
- Avvia un browser.
- Passa a
http://localhost:port, ad esempiohttp://localhost:7042.- port: numero di porta assegnato in modo casuale per l'app.
localhost: nome host standard per il computer locale. Localhost viene usato solo per le richieste web del computer locale.
I log mostrano il servizio in ascolto su https://localhost:<port>, dove <port> è il numero di porta localhost assegnato in modo casuale quando il progetto viene creato e impostato in Properties/launchSettings.json.
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:<port>
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
Nota
Il modello gRPC è configurato per l'uso di Transport Layer Security (TLS). i client gRPC devono usare HTTPS per chiamare il server. Il numero di porta localhost del servizio gRPC viene assegnato in modo casuale quando il progetto viene creato e impostato nel file Properties\launchSettings.json del progetto di servizio gRPC.
macOS non supporta ASP.NET Core gRPC con TLS. Per eseguire correttamente i servizi gRPC in macOS, è necessaria una configurazione aggiuntiva. Per altre informazioni, vedere Non è possibile avviare un'app ASP.NET Core gRPC in macOS.
Esaminare i file di progetto
File di progetto GrpcGreeter:
Protos/greet.proto: definisce ilGreetergRPC e viene usato per generare gli asset del server gRPC. Per altre informazioni, vedere Introduzione a gRPC.Servicesfolder: contiene l'implementazione delGreeterservizio.appSettings.json: contiene dati di configurazione, ad esempio il protocollo usato da Kestrel. Per altre informazioni, vedere Configurazione in ASP.NET Core.Program.cs, che contiene:- Punto di ingresso per il servizio gRPC. Per altre informazioni, vedere Host generico .NET in ASP.NET Core.
- Codice che configura il comportamento dell'app. Per altre informazioni, vedere Avvio dell'app.
Creare il client gRPC in un'app console .NET
- Aprire una seconda istanza di Visual Studio e selezionare Crea un nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto selezionare Applicazione console e selezionare Avanti.
- Nella casella di testo Nome progetto immettere GrpcGreeterClient e selezionare Avanti.
- Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 6.0 (supporto a lungo termine) e quindi selezionare Crea.
Aggiungere i pacchetti NuGet necessari
Il progetto client gRPC richiede i pacchetti NuGet seguenti:
- Grpc.Net.Client, che contiene il client .NET Core.
- Google.Protobuf, che contiene le API per i messaggi protobuf per C#.
- Grpc.Tools, che contiene il supporto degli strumenti C# per i file protobuf. Il pacchetto di strumenti non è necessario in fase di esecuzione, quindi la dipendenza è contrassegnata come
PrivateAssets="All".
Installare i pacchetti tramite la Console di gestione pacchetti (PMC) o Gestisci pacchetti NuGet.
Opzione con la console di Gestione pacchetti per installare i pacchetti
Da Visual Studio selezionare Strumenti>Gestione pacchetti NuGet>Console di Gestione pacchetti
Dalla finestra della console di Gestione pacchetti eseguire
cd GrpcGreeterClientper modificare le directory nella cartella contenente iGrpcGreeterClient.csprojfile.Eseguire i comandi seguenti:
Install-Package Grpc.Net.Client Install-Package Google.Protobuf Install-Package Grpc.Tools
Opzione Gestisci pacchetti NuGet per installare i pacchetti
- Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni>Gestisci pacchetti NuGet.
- Selezionare la scheda Sfoglia.
- Immettere Grpc.Net.Client nella casella di ricerca.
- Selezionare il pacchetto Grpc.Net.Client dalla scheda Sfoglia e fare clic su Installa.
- Ripeti i passaggi per
Google.ProtobufeGrpc.Tools.
Aggiungere greet.proto
Creare una cartella Protos nel progetto client gRPC.
Copiare il file Protos\greet.proto dal servizio gRPC Greeter alla cartella Protos nel progetto client gRPC.
Aggiornare lo spazio dei nomi all'interno del
greet.protofile nello spazio dei nomi del progetto:option csharp_namespace = "GrpcGreeterClient";Modificare il file di
GrpcGreeterClient.csprojprogetto:
Fare clic con il pulsante destro del mouse sul progetto e scegliere Modifica file di progetto.
Aggiungere un gruppo di elementi con un elemento
<Protobuf>che fa riferimento al file greet.proto:<ItemGroup> <Protobuf Include="Protos\greet.proto" GrpcServices="Client" /> </ItemGroup>
Creare il client Greeter
- Compilare il progetto client per creare i tipi nello spazio dei
GrpcGreeterClientnomi .
Nota
I tipi GrpcGreeterClient vengono generati automaticamente dal processo di compilazione. Il pacchetto di strumenti Grpc.Tools genera i file seguenti in base al file greet.proto :
GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\Greet.cs: codice del buffer del protocollo che popola, serializza e recupera i tipi di messaggio di richiesta e risposta.GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\GreetGrpc.cs: contiene le classi client generate.
Per altre informazioni sugli asset C# generati automaticamente da Grpc.Tools, vedere Servizi gRPC con C#: Asset C# generati.
Aggiornare il file client
Program.csgRPC con il codice seguente.using System.Threading.Tasks; using Grpc.Net.Client; using GrpcGreeterClient; // The port number must match the port of the gRPC server. using var channel = GrpcChannel.ForAddress("https://localhost:7042"); var client = new Greeter.GreeterClient(channel); var reply = await client.SayHelloAsync( new HelloRequest { Name = "GreeterClient" }); Console.WriteLine("Greeting: " + reply.Message); Console.WriteLine("Press any key to exit..."); Console.ReadKey();Nel codice evidenziato precedente sostituire il numero
7042di porta localhost con ilHTTPSnumero di porta specificato nelProperties/launchSettings.jsonprogetto diGrpcGreeterservizio.
Program.cs contiene il punto di ingresso e la logica per il client gRPC.
Il client Greeter viene creato come descritto di seguito:
- Creare un'istanza di
GrpcChannelcontenente le informazioni per creare la connessione al servizio gRPC. - Usare
GrpcChannelper costruire il client Greeter:
// The port number must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:7042");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
Il client Greeter chiama il metodo SayHello asincrono. Viene visualizzato il risultato della chiamata SayHello:
// The port number must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:7042");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
Testare il client gRPC con il servizio Greeter gRPC
- Nel servizio Greeter premere
Ctrl+F5per avviare il server senza il debugger. - Nel progetto
GrpcGreeterClientpremereCtrl+F5per avviare il client senza il debugger.
Il client invia un saluto al servizio con un messaggio contenente il nome GreeterClient. Il servizio invia il messaggio "Hello GreeterClient" come risposta. La risposta "Hello GreeterClient" viene visualizzata al prompt dei comandi:
Greeting: Hello GreeterClient
Press any key to exit...
Il servizio gRPC registra i dettagli della chiamata con esito positivo nei log scritti al prompt dei comandi:
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:<port>
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
Content root path: C:\GH\aspnet\docs\4\Docs\aspnetcore\tutorials\grpc\grpc-start\sample\GrpcGreeter
info: Microsoft.AspNetCore.Hosting.Diagnostics[1]
Request starting HTTP/2 POST https://localhost:<port>/Greet.Greeter/SayHello application/grpc
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[0]
Executing endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[1]
Executed endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
Request finished in 78.32260000000001ms 200 application/grpc
Aggiornare il appsettings.Development.json file aggiungendo le righe seguenti:
"Microsoft.AspNetCore.Hosting": "Information",
"Microsoft.AspNetCore.Routing.EndpointMiddleware": "Information"
Nota
Il codice in questo articolo richiede il certificato di sviluppo HTTPS ASP.NET Core per proteggere il servizio gRPC. Se il client .NET gRPC ha esito negativo con il messaggio The remote certificate is invalid according to the validation procedure. o The SSL connection could not be established., il certificato di sviluppo non è attendibile. Per risolvere questo problema, vedere Chiamare un servizio gRPC con un certificato non attendibile o non valido.
Passaggi successivi
Questa esercitazione illustra come creare un client gRPC .NET Core e un server gRPC ASP.NET Core.
Al termine, si otterrà un client gRPC che comunica con il servizio Greeter gRPC.
Visualizzare o scaricare il codice di esempio (procedura per il download).
In questa esercitazione:
- Creare un server gRPC.
- Creare un client gRPC.
- Testare il client gRPC con il servizio gRPC Greeter.
Prerequisiti
- Visual Studio 2019 16.8 o versione successiva con il carico di lavoro Sviluppo ASP.NET e Web
- .NET 5.0 SDK
Creare un servizio gRPC
- Avviare Visual Studio e selezionare Crea un nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto selezionare gRPC Service e selezionare Avanti.
- Nella finestra di dialogo Configura il nuovo progetto immettere
GrpcGreeterper Nome progetto. È importante denominare il progetto GrpcGreeter in modo che gli spazi dei nomi corrispondano quando si copia e incolla il codice. - Selezionare Avanti.
- Nella finestra di dialogo Informazioni aggiuntive selezionare .NET 5.0 nell'elenco a discesa Framework di destinazione.
- Seleziona Crea.
Eseguire il servizio
Premere CTRL+F5 per l'esecuzione senza il debugger.
Visual Studio visualizza la finestra di dialogo seguente quando un progetto non è ancora configurato per l'uso di SSL:
Selezionare Sì se si considera attendibile il certificato SSL di IIS Express.
Verrà visualizzata la finestra di dialogo seguente:
Selezionare Sì se si accetta di considerare attendibile il certificato di sviluppo.
Per informazioni sull'attendibilità del browser Firefox, vedere Firefox SEC_ERROR_INADEQUATE_KEY_USAGE errore del certificato.
Visual Studio avvia IIS Express ed esegue l'app. La barra degli indirizzi visualizza
localhost:port#e nonexample.como simili. Ciò accade perchélocalhostè il nome host standard per il computer locale. Localhost viene usato solo per le richieste web del computer locale. Quando Visual Studio crea un progetto Web, viene usata una porta casuale per il server Web.
I log indicano che il servizio è in ascolto su https://localhost:5001.
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:5001
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
Nota
Il modello gRPC è configurato per l'uso di Transport Layer Security (TLS). i client gRPC devono usare HTTPS per chiamare il server.
macOS non supporta ASP.NET Core gRPC con TLS. Per eseguire correttamente i servizi gRPC in macOS, è necessaria una configurazione aggiuntiva. Per altre informazioni, vedere Non è possibile avviare un'app ASP.NET Core gRPC in macOS.
Esaminare i file di progetto
File di progetto GrpcGreeter:
- greet.proto: il file Protos/greet.proto definisce il
GreetergRPC e viene usato per generare gli asset del server gRPC. Per altre informazioni, vedere Introduzione a gRPC. - Cartella Servizi : contiene l'implementazione del
Greeterservizio. appsettings.json: contiene dati di configurazione, ad esempio il protocollo usato da Kestrel. Per altre informazioni, vedere Configurazione in ASP.NET Core.Program.cs: contiene il punto di ingresso per il servizio gRPC. Per altre informazioni, vedere Host generico .NET in ASP.NET Core.Startup.cs: contiene il codice che configura il comportamento dell'app. Per altre informazioni, vedere Avvio dell'app.
Creare il client gRPC in un'app console .NET
- Aprire una seconda istanza di Visual Studio e selezionare Crea un nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto selezionare App console (.NET Core) e selezionare Avanti.
- Nella casella di testo Nome progetto immettere GrpcGreeterClient e selezionare Crea.
Aggiungere i pacchetti necessari
Per il progetto client gRPC sono richiesti i pacchetti seguenti:
- Grpc.Net.Client, che contiene il client .NET Core.
- Google.Protobuf, che contiene le API per i messaggi protobuf per C#.
- Grpc.Tools, che contiene il supporto di strumenti C# per i file protobuf. Il pacchetto di strumenti non è necessario in fase di esecuzione, quindi la dipendenza è contrassegnata come
PrivateAssets="All".
Installare i pacchetti tramite la Console di gestione pacchetti (PMC) o Gestisci pacchetti NuGet.
Opzione con la console di Gestione pacchetti per installare i pacchetti
Da Visual Studio selezionare Strumenti>Gestione pacchetti NuGet>Console di Gestione pacchetti
Dalla finestra della console di Gestione pacchetti eseguire
cd GrpcGreeterClientper modificare le directory nella cartella contenente iGrpcGreeterClient.csprojfile.Eseguire i comandi seguenti:
Install-Package Grpc.Net.Client Install-Package Google.Protobuf Install-Package Grpc.Tools
Opzione Gestisci pacchetti NuGet per installare i pacchetti
- Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni>Gestisci pacchetti NuGet.
- Selezionare la scheda Sfoglia.
- Immettere Grpc.Net.Client nella casella di ricerca.
- Selezionare il pacchetto Grpc.Net.Client dalla scheda Sfoglia e fare clic su Installa.
- Ripeti i passaggi per
Google.ProtobufeGrpc.Tools.
Aggiungere greet.proto
Creare una cartella Protos nel progetto client gRPC.
Copiare il file Protos\greet.proto dal servizio gRPC Greeter alla cartella Protos nel progetto client gRPC.
Aggiornare lo spazio dei nomi all'interno del
greet.protofile nello spazio dei nomi del progetto:option csharp_namespace = "GrpcGreeterClient";Modificare il file di
GrpcGreeterClient.csprojprogetto:Fare clic con il pulsante destro del mouse sul progetto e scegliere Modifica file di progetto.
Aggiungere un gruppo di elementi con un elemento
<Protobuf>che fa riferimento al file greet.proto:<ItemGroup> <Protobuf Include="Protos\greet.proto" GrpcServices="Client" /> </ItemGroup>
Creare il client Greeter
- Compilare il progetto client per creare i tipi nello spazio dei
GrpcGreeterClientnomi .
Nota
I tipi GrpcGreeterClient vengono generati automaticamente dal processo di compilazione. Il pacchetto di strumenti Grpc.Tools genera i file seguenti in base al file greet.proto :
GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\Greet.cs: codice del buffer del protocollo che popola, serializza e recupera i tipi di messaggio di richiesta e risposta.GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\GreetGrpc.cs: contiene le classi client generate.
Per altre informazioni sugli asset C# generati automaticamente da Grpc.Tools, vedere Servizi gRPC con C#: Asset C# generati.
Aggiornare il file client
Program.csgRPC con il codice seguente:using System; using System.Net.Http; using System.Threading.Tasks; using Grpc.Net.Client; namespace GrpcGreeterClient { class Program { static async Task Main(string[] args) { // The port number(5001) must match the port of the gRPC server. using var channel = GrpcChannel.ForAddress("https://localhost:5001"); var client = new Greeter.GreeterClient(channel); var reply = await client.SayHelloAsync( new HelloRequest { Name = "GreeterClient" }); Console.WriteLine("Greeting: " + reply.Message); Console.WriteLine("Press any key to exit..."); Console.ReadKey(); } } }
Program.cs contiene il punto di ingresso e la logica per il client gRPC.
Il client Greeter viene creato come descritto di seguito:
- Creare un'istanza di
GrpcChannelcontenente le informazioni per creare la connessione al servizio gRPC. - Usare
GrpcChannelper costruire il client Greeter:
static async Task Main(string[] args)
{
// The port number(5001) must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
Il client Greeter chiama il metodo SayHello asincrono. Viene visualizzato il risultato della chiamata SayHello:
static async Task Main(string[] args)
{
// The port number(5001) must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
Testare il client gRPC con il servizio Greeter gRPC
- Nel servizio Greeter premere
Ctrl+F5per avviare il server senza il debugger. - Nel progetto
GrpcGreeterClientpremereCtrl+F5per avviare il client senza il debugger.
Il client invia un saluto al servizio con un messaggio contenente il nome GreeterClient. Il servizio invia il messaggio "Hello GreeterClient" come risposta. La risposta "Hello GreeterClient" viene visualizzata al prompt dei comandi:
Greeting: Hello GreeterClient
Press any key to exit...
Il servizio gRPC registra i dettagli della chiamata con esito positivo nei log scritti al prompt dei comandi:
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:5001
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
Content root path: C:\GH\aspnet\docs\4\Docs\aspnetcore\tutorials\grpc\grpc-start\sample\GrpcGreeter
info: Microsoft.AspNetCore.Hosting.Diagnostics[1]
Request starting HTTP/2 POST https://localhost:5001/Greet.Greeter/SayHello application/grpc
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[0]
Executing endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[1]
Executed endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
Request finished in 78.32260000000001ms 200 application/grpc
Nota
Il codice in questo articolo richiede il certificato di sviluppo HTTPS ASP.NET Core per proteggere il servizio gRPC. Se il client .NET gRPC ha esito negativo con il messaggio The remote certificate is invalid according to the validation procedure. o The SSL connection could not be established., il certificato di sviluppo non è attendibile. Per risolvere questo problema, vedere Chiamare un servizio gRPC con un certificato non attendibile o non valido.
Passaggi successivi
Questa esercitazione illustra come creare un client gRPC .NET Core e un server gRPC ASP.NET Core.
Al termine, si otterrà un client gRPC che comunica con il servizio Greeter gRPC.
Visualizzare o scaricare il codice di esempio (procedura per il download).
In questa esercitazione:
- Creare un server gRPC.
- Creare un client gRPC.
- Testare il client gRPC con il servizio gRPC Greeter.
Prerequisiti
- Visual Studio 2019 16.4 o versione successiva con il carico di lavoro Sviluppo ASP.NET e Web
- .NET Core 3.1 SDK
Creare un servizio gRPC
Avviare Visual Studio e selezionare Crea un nuovo progetto. In alternativa, dal menu File di Visual Studio scegliere Nuovo>Progetto.
Nella finestra di dialogo Crea un nuovo progetto selezionare gRPC Service e selezionare Avanti:
Denominare il progetto GrpcGreeter. È importante denominare il progetto GrpcGreeter in modo che gli spazi dei nomi corrispondano quando si copia e incolla il codice.
Seleziona Crea.
Nella finestra di dialogo Crea un nuovo servizio gRPC:
- È selezionato il modello Servizio gRPC.
- Seleziona Crea.
Eseguire il servizio
Premere CTRL+F5 per l'esecuzione senza il debugger.
Visual Studio visualizza la finestra di dialogo seguente quando un progetto non è ancora configurato per l'uso di SSL:
Selezionare Sì se si considera attendibile il certificato SSL di IIS Express.
Verrà visualizzata la finestra di dialogo seguente:
Selezionare Sì se si accetta di considerare attendibile il certificato di sviluppo.
Per informazioni sull'attendibilità del browser Firefox, vedere Firefox SEC_ERROR_INADEQUATE_KEY_USAGE errore del certificato.
Visual Studio avvia IIS Express ed esegue l'app. La barra degli indirizzi visualizza
localhost:port#e nonexample.como simili. Ciò accade perchélocalhostè il nome host standard per il computer locale. Localhost viene usato solo per le richieste web del computer locale. Quando Visual Studio crea un progetto Web, viene usata una porta casuale per il server Web.
I log indicano che il servizio è in ascolto su https://localhost:5001.
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:5001
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
Nota
Il modello gRPC è configurato per l'uso di Transport Layer Security (TLS). i client gRPC devono usare HTTPS per chiamare il server.
macOS non supporta ASP.NET Core gRPC con TLS. Per eseguire correttamente i servizi gRPC in macOS, è necessaria una configurazione aggiuntiva. Per altre informazioni, vedere Non è possibile avviare un'app ASP.NET Core gRPC in macOS.
Esaminare i file di progetto
File di progetto GrpcGreeter:
- greet.proto: il file Protos/greet.proto definisce il
GreetergRPC e viene usato per generare gli asset del server gRPC. Per altre informazioni, vedere Introduzione a gRPC. - Cartella Servizi : contiene l'implementazione del
Greeterservizio. appsettings.json: contiene dati di configurazione, ad esempio il protocollo usato da Kestrel. Per altre informazioni, vedere Configurazione in ASP.NET Core.Program.cs: contiene il punto di ingresso per il servizio gRPC. Per altre informazioni, vedere Host generico .NET in ASP.NET Core.Startup.cs: contiene il codice che configura il comportamento dell'app. Per altre informazioni, vedere Avvio dell'app.
Creare il client gRPC in un'app console .NET
- Aprire una seconda istanza di Visual Studio e selezionare Crea un nuovo progetto.
- Nella finestra di dialogo Crea un nuovo progetto selezionare App console (.NET Core) e selezionare Avanti.
- Nella casella di testo Nome progetto immettere GrpcGreeterClient e selezionare Crea.
Aggiungere i pacchetti necessari
Per il progetto client gRPC sono richiesti i pacchetti seguenti:
- Grpc.Net.Client, che contiene il client .NET Core.
- Google.Protobuf, che contiene le API per i messaggi protobuf per C#.
- Grpc.Tools, che contiene il supporto di strumenti C# per i file protobuf. Il pacchetto di strumenti non è necessario in fase di esecuzione, quindi la dipendenza è contrassegnata come
PrivateAssets="All".
Installare i pacchetti tramite la Console di gestione pacchetti (PMC) o Gestisci pacchetti NuGet.
Opzione con la console di Gestione pacchetti per installare i pacchetti
Da Visual Studio selezionare Strumenti>Gestione pacchetti NuGet>Console di Gestione pacchetti
Dalla finestra della console di Gestione pacchetti eseguire
cd GrpcGreeterClientper modificare le directory nella cartella contenente iGrpcGreeterClient.csprojfile.Eseguire i comandi seguenti:
Install-Package Grpc.Net.Client Install-Package Google.Protobuf Install-Package Grpc.Tools
Opzione Gestisci pacchetti NuGet per installare i pacchetti
- Fare clic con il pulsante destro del mouse sul progetto in Esplora soluzioni>Gestisci pacchetti NuGet.
- Selezionare la scheda Sfoglia.
- Immettere Grpc.Net.Client nella casella di ricerca.
- Selezionare il pacchetto Grpc.Net.Client dalla scheda Sfoglia e fare clic su Installa.
- Ripeti i passaggi per
Google.ProtobufeGrpc.Tools.
Aggiungere greet.proto
Creare una cartella Protos nel progetto client gRPC.
Copiare il file Protos\greet.proto dal servizio gRPC Greeter alla cartella Protos nel progetto client gRPC.
Aggiornare lo spazio dei nomi all'interno del
greet.protofile nello spazio dei nomi del progetto:option csharp_namespace = "GrpcGreeterClient";Modificare il file di
GrpcGreeterClient.csprojprogetto:Fare clic con il pulsante destro del mouse sul progetto e scegliere Modifica file di progetto.
Aggiungere un gruppo di elementi con un elemento
<Protobuf>che fa riferimento al file greet.proto:<ItemGroup> <Protobuf Include="Protos\greet.proto" GrpcServices="Client" /> </ItemGroup>
Creare il client Greeter
- Compilare il progetto client per creare i tipi nello spazio dei
GrpcGreeterClientnomi .
Nota
I tipi GrpcGreeterClient vengono generati automaticamente dal processo di compilazione. Il pacchetto di strumenti Grpc.Tools genera i file seguenti in base al file greet.proto :
GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\Greet.cs: codice del buffer del protocollo che popola, serializza e recupera i tipi di messaggio di richiesta e risposta.GrpcGreeterClient\obj\Debug\[TARGET_FRAMEWORK]\Protos\GreetGrpc.cs: contiene le classi client generate.
Per altre informazioni sugli asset C# generati automaticamente da Grpc.Tools, vedere Servizi gRPC con C#: Asset C# generati.
Aggiornare il file client Program.cs gRPC con il codice seguente:
using System;
using System.Net.Http;
using System.Threading.Tasks;
using Grpc.Net.Client;
namespace GrpcGreeterClient
{
class Program
{
static async Task Main(string[] args)
{
// The port number(5001) must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
}
}
Program.cs contiene il punto di ingresso e la logica per il client gRPC.
Il client Greeter viene creato come descritto di seguito:
- Creare un'istanza di
GrpcChannelcontenente le informazioni per creare la connessione al servizio gRPC. - Usare
GrpcChannelper costruire il client Greeter:
static async Task Main(string[] args)
{
// The port number(5001) must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
Il client Greeter chiama il metodo SayHello asincrono. Viene visualizzato il risultato della chiamata SayHello:
static async Task Main(string[] args)
{
// The port number(5001) must match the port of the gRPC server.
using var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Greeter.GreeterClient(channel);
var reply = await client.SayHelloAsync(
new HelloRequest { Name = "GreeterClient" });
Console.WriteLine("Greeting: " + reply.Message);
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
Testare il client gRPC con il servizio Greeter gRPC
- Nel servizio Greeter premere
Ctrl+F5per avviare il server senza il debugger. - Nel progetto
GrpcGreeterClientpremereCtrl+F5per avviare il client senza il debugger.
Il client invia un saluto al servizio con un messaggio contenente il nome GreeterClient. Il servizio invia il messaggio "Hello GreeterClient" come risposta. La risposta "Hello GreeterClient" viene visualizzata al prompt dei comandi:
Greeting: Hello GreeterClient
Press any key to exit...
Il servizio gRPC registra i dettagli della chiamata con esito positivo nei log scritti al prompt dei comandi:
info: Microsoft.Hosting.Lifetime[0]
Now listening on: https://localhost:5001
info: Microsoft.Hosting.Lifetime[0]
Application started. Press Ctrl+C to shut down.
info: Microsoft.Hosting.Lifetime[0]
Hosting environment: Development
info: Microsoft.Hosting.Lifetime[0]
Content root path: C:\GH\aspnet\docs\4\Docs\aspnetcore\tutorials\grpc\grpc-start\sample\GrpcGreeter
info: Microsoft.AspNetCore.Hosting.Diagnostics[1]
Request starting HTTP/2 POST https://localhost:5001/Greet.Greeter/SayHello application/grpc
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[0]
Executing endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Routing.EndpointMiddleware[1]
Executed endpoint 'gRPC - /Greet.Greeter/SayHello'
info: Microsoft.AspNetCore.Hosting.Diagnostics[2]
Request finished in 78.32260000000001ms 200 application/grpc
Nota
Il codice in questo articolo richiede il certificato di sviluppo HTTPS ASP.NET Core per proteggere il servizio gRPC. Se il client .NET gRPC ha esito negativo con il messaggio The remote certificate is invalid according to the validation procedure. o The SSL connection could not be established., il certificato di sviluppo non è attendibile. Per risolvere questo problema, vedere Chiamare un servizio gRPC con un certificato non attendibile o non valido.
