Questa pagina è stata tradotta dall'API Cloud Translation.

Creazione di un servizio gRPC con C#

1. Panoramica

gRPC è un framework e un set di strumenti per le chiamate di procedure remote (RPC) indipendenti dal linguaggio e dalla piattaforma sviluppati da Google. Consente di definire un servizio mediante buffer di protocollo, un set di strumenti e un linguaggio di serializzazione binaria particolarmente potente. Consente quindi di generare stub client e server idiomatici dalla definizione del tuo servizio in varie lingue.

In questo codelab, imparerai come creare un servizio C# che espone un'API utilizzando il framework gRPC. Puoi interagire con questo servizio utilizzando un client della console scritto in C# che utilizza la stessa descrizione del servizio.

Cosa imparerai a fare

La lingua del buffer di protocollo.
Come implementare un servizio gRPC utilizzando C#.
Come implementare un client gRPC utilizzando C#.
Come aggiornare un servizio gRPC.

Che cosa ti serve

Un browser, ad esempio Chrome o Firefox.
Visual Studio 2013 o versione successiva installata.
Familiarità con .NET Framework e C#.

Come utilizzerai questo tutorial?

Solo lettura

Leggilo e completa gli esercizi

Come valuteresti la tua esperienza con la piattaforma Google Cloud?

Principiante

Livello intermedio

Eccellente

2. Scarica e crea esempi C# di gRPC

Scaricare esempi

Scarica il repository C# di esempio gRPC come file ZIP ed estrailo.

In alternativa, puoi clonare il relativo repository Git.

git clone https://github.com/meteatamel/grpc-samples-dotnet.git

In ogni caso, dovresti avere una cartella grpc-samples-dotnet con il seguente contenuto:

Crea la soluzione

La cartella dell'applicazione di esempio contiene GrpcSamples.sln, una soluzione di Visual Studio. Fai doppio clic per aprire la soluzione in Visual Studio. Dovresti vedere una soluzione con una serie di progetti.

Esamineremo i progetti in maggiore dettaglio nella prossima sezione, ma prima creiamo il progetto. Vai a Build > Build Solution o Ctrl + Shift + B per creare la soluzione. Verranno scaricate tutte le dipendenze da NuGet e quindi compilerai l'applicazione.

Alla fine, dovresti vedere un messaggio Build succeeded nell'output della console di Visual Studio.

3. Esplora l'esempio di Greeter

Greeter è un semplice esempio gRPC in cui un client invia una richiesta con un nome e il server risponde con un messaggio seguito dal nome. Esiste un progetto Greeter che include la definizione di servizio comune (file proto) su cui si basano il client e il server.

Progetto Greeter

Si tratta del progetto comune condiviso tra il client e il server. Ha un valore greeter.proto, che è la definizione del servizio gRPC utilizzato da client e server. La definizione del servizio definisce un servizio gRPC denominato GreetingService e ha un metodo greeting che accetta HelloRequest come input e HelloResponse come output.

service GreetingService {
    rpc greeting(HelloRequest) returns (HelloResponse);
}

Si tratta di un metodo unario (ovvero nessun flusso di dati) in cui il client invia una singola richiesta e riceve una singola risposta dal server. Puoi esplorare il resto dei contenuti di greeter.proto.. Questo progetto ha anche uno script denominato generate_protos.bat che può essere utilizzato per generare stub client e server dal file proto. Il progetto contiene già stub di client e server generati, quindi non è necessario generarli manualmente. Tuttavia, se si apportano modifiche al file di definizione del servizio, sarà necessario eseguire questo script per rigenerare gli stub.

Server di benvenuto

Questo è il progetto per il server gRPC. Program.cs è il punto di ingresso principale in cui è configurata l'implementazione della porta e del server. Il corso importante è GreeterServiceImpl.cs. Ha un metodo greeting in cui viene implementata la funzionalità effettiva.

public override Task<HelloResponse> greeting(HelloRequest request,
       ServerCallContext context)
{
    return Task.FromResult(new HelloResponse { 
          Greeting = "Hello " + request.Name });
}

Client di benvenuto

Questo è il lato client del servizio gRPC. Ha anche Program.cs come punto di ingresso. Crea un canale per comunicare con il server e quindi crea un client con il canale dallo stub generato. Quindi crea una richiesta e la invia al server utilizzando lo stub client.

4. Esegui l'esempio di Greeter

Per prima cosa, avvia il server di messaggi. Apri un prompt dei comandi, vai alla cartella bin > Debug del server Greeter ed esegui l'eseguibile. Dovresti vedere il server in ascolto.

> C:\grpc-samples-dotnet\GreeterServer\bin\Debug>GreeterServer.exe
GreeterServer listening on port 50051
Press any key to stop the server...

Poi esegui il client Greeter. In un prompt dei comandi separato, vai alla cartella bin > Debug del server Greeter ed esegui l'eseguibile. Dovresti vedere il client che invia la richiesta e riceve una risposta dal server.

> C:\grpc-samples-dotnet\GreeterClient\bin\Debug>GreeterClient.exe
GreeterClient sending request
GreeterClient received response: Hello Mete - on C#
Press any key to exit...

5. Aggiorna l'esempio del messaggio di benvenuto

Vediamo come funziona l'aggiornamento del servizio. Aggiungere al nostro servizio gRPC un nuovo metodo denominato "Addio" che restituisca addio anziché hello al client.

Il primo passaggio consiste nell'aggiornare il file di definizione del servizio greeter.proto.

service GreetingService {
    rpc greeting(HelloRequest) returns (HelloResponse);
    
    rpc goodbye(HelloRequest) returns (HelloResponse);
}

A questo punto occorre rigenerare gli stub client e server. In un prompt dei comandi, esegui generate_protos.bat. Dopo aver generato gli stub, potrebbe essere necessario aggiornare i progetti Visual Studio per ottenere il codice aggiornato.

Infine, aggiorna il codice client e server per sfruttare il nuovo metodo. Nel servizio, aggiorna GreeterServiceImpl.cs e aggiungi un nuovo metodo goodbye.

public override Task<HelloResponse> goodbye(HelloRequest request,
       ServerCallContext context)
{
    return Task.FromResult(new HelloResponse { 
          Greeting = "Goodbye " + request.Name });
}

Nel client, effettua una chiamata al metodo goodbye in Program.cs.

response = client.goodbye(request);
Console.WriteLine("GreeterClient received response: " 
                       + response.Greeting);

Ricrea il progetto ed esegui di nuovo il server e il client. Ora il cliente dovrebbe ricevere un messaggio di addio.

> C:\grpc-samples-dotnet\GreeterClient\bin\Debug>GreeterClient.exe
GreeterClient sending request
GreeterClient received response: Hello Mete - on C#
GreeterClient received response: Goodbye Mete - on C#
Press any key to exit...

6. Esplora l'esempio di Chat

Nella soluzione sono presenti anche un progetto ChatServer e un progetto ChatWindowsClient. Come suggerisce il nome, si tratta di una coppia client e server per una semplice applicazione di chat. Il progetto Chat contiene il file di definizione del servizio denominato chat.proto. Definisce un valore ChatService con un metodo chat.

service ChatService {
 rpc chat(stream ChatMessage) returns (stream ChatMessageFromServer);
}

La cosa importante in questo caso è che sia i messaggi di chat in arrivo che quelli in uscita sono contrassegnati con la parola chiave stream. Questo trasforma la connessione in un flusso bidirezionale in cui il client e il server possono inviarsi messaggi l'uno all'altro in qualsiasi momento. la soluzione perfetta per un'applicazione di chat.

Puoi esplorare ulteriormente il campione, crearlo ed eseguirlo per vedere come funziona come allenamento.