Compila un servicio de gRPC con C#

1. Descripción general

gRPC es un marco de trabajo y un conjunto de herramientas de llamada de procedimiento remoto (RPC) independientes del lenguaje y la plataforma que se desarrollaron en Google. Te permite definir un servicio con búferes de protocolo, un conjunto de herramientas y un lenguaje de serialización binaria particularmente potentes. Luego, te permite generar stubs idiomáticos de cliente y servidor a partir de la definición de tu servicio en una variedad de lenguajes.

En este codelab, aprenderás a compilar un servicio en C# que expone una API con el framework de gRPC. Interactúas con este servicio a través de un cliente de consola escrito en C# que usa la misma descripción de servicio que el servicio.

Qué aprenderás

Es el lenguaje de búferes de protocolo.
Cómo implementar un servicio de gRPC con C#
Cómo implementar un cliente de gRPC con C#
Cómo actualizar un servicio de gRPC

Requisitos

Un navegador, como Chrome o Firefox
Tener instalado Visual Studio 2013 o una versión posterior
Conocimiento de .NET Framework y el lenguaje C#

¿Cómo usarás este instructivo?

Leer

Leer y completar los ejercicios

¿Cómo calificarías tu experiencia con Google Cloud Platform?

Principiante

Intermedio

Avanzado

2. Descarga y compila las muestras de gRPC C#

Descarga muestras

Descarga el repositorio de la muestra de gRPC C# como un archivo ZIP y extráelo.

Como alternativa, puedes clonar su repositorio de Git.

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

De cualquier manera, deberías tener una carpeta grpc-samples-dotnet con el siguiente contenido:

Compila la solución

La carpeta de la aplicación de ejemplo contiene GrpcSamples.sln, una solución de Visual Studio. Haz doble clic para abrir la solución en Visual Studio. Deberías ver una solución con varios proyectos.

Analizaremos los proyectos con más detalle en la próxima sección, pero, primero, vamos a compilar el proyecto. Ve a Build > Build Solution o Ctrl + Shift + B para compilar la solución. Esto descargará todas las dependencias de NuGet y, luego, compilará la aplicación.

Al final, deberías ver un mensaje Build succeeded en el resultado de la consola de Visual Studio.

3. Explora el ejemplo de Greeter

Greeter es un ejemplo simple de gRPC en el que un cliente envía una solicitud con un nombre y el servidor responde con un mensaje seguido del nombre. Hay un proyecto de Greeter que incluye la definición de servicio común (archivo .proto) en la que se basan el cliente y el servidor.

Proyecto de saludo

Este es el proyecto común que se comparte entre el cliente y el servidor. Tiene un greeter.proto, que es la definición del servicio de gRPC que usan el cliente y el servidor. La definición del servicio define un servicio de gRPC llamado GreetingService y tiene un método greeting que toma HelloRequest como entrada y HelloResponse como salida.

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

Este es un método unario (es decir, sin transmisión) en el que el cliente envía una sola solicitud y recibe una sola respuesta del servidor. Puedes explorar el resto del contenido de greeter.proto.. Este proyecto también tiene una secuencia de comandos llamada generate_protos.bat que se puede usar para generar stubs de cliente y servidor a partir del archivo .proto. El proyecto ya contiene stubs de cliente y servidor generados, por lo que no tienes que generarlos por tu cuenta. Sin embargo, si cambias algo en el archivo de definición del servicio, deberás ejecutar este script para volver a generar los stubs.

Servidor de bienvenida

Este es el proyecto del servidor de gRPC. Program.cs es el punto de entrada principal en el que se configuran el puerto y la implementación del servidor. La clase importante es GreeterServiceImpl.cs. Tiene un método greeting en el que se implementa la funcionalidad real.

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

Cliente de bienvenida

Este es el lado del cliente del servicio de gRPC. También tiene Program.cs como punto de entrada. Crea un canal para comunicarse con el servidor y, luego, crea un cliente con el canal del stub generado. Luego, crea una solicitud y la envía al servidor con el stub del cliente.

4. Ejecuta la muestra de Greeter

Primero, inicia el servidor de Greeter. Abre un símbolo del sistema, navega a la carpeta bin > Debug de Greeter Server y ejecuta el archivo ejecutable. Deberías ver que el servidor está escuchando.

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

A continuación, ejecuta el cliente de Greeter. En un símbolo del sistema independiente, navega a la carpeta bin > Debug del servidor de Greeter y ejecuta el archivo ejecutable. Deberías ver que el cliente envía la solicitud y recibe una respuesta del servidor.

> 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. Actualiza la muestra de Greeter

Veamos cómo se ve la actualización de nuestro servicio. Agrega un nuevo método a nuestro servicio de gRPC llamado goodbye que muestre goodbye en lugar de hello al cliente.

El primer paso es actualizar el archivo de definición del servicio greeter.proto..

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

A continuación, deberás volver a generar los stubs de cliente y servidor. En un símbolo del sistema, ejecuta generate_protos.bat. Una vez que se generen los stubs, es posible que debas actualizar tus proyectos de Visual Studio para obtener el código actualizado.

Por último, actualiza el código del cliente y del servidor para aprovechar el nuevo método. En el servicio, actualiza GreeterServiceImpl.cs y agrega un nuevo método goodbye.

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

En el cliente, llama al método goodbye en Program.cs..

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

Vuelve a compilar el proyecto y a ejecutar el servidor y el cliente. Ahora deberías ver que el cliente recibe un mensaje de despedida.

> 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. Explora la muestra de Chat

También hay proyectos ChatServer y ChatWindowsClient en la solución. Como su nombre lo indica, se trata de un par cliente-servidor para una aplicación de chat simple. El proyecto Chat tiene el archivo de definición de servicio llamado chat.proto. Define un ChatService con un método chat.

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

Lo importante aquí es que tanto los mensajes entrantes como los salientes se marcan con la palabra clave stream. Básicamente, esto convierte la conexión en un flujo bidireccional en el que el cliente y el servidor pueden enviarse mensajes entre sí en cualquier momento, lo que la convierte en la solución perfecta para una aplicación de chat.

Puedes explorar más la muestra, compilarla y ejecutarla para ver cómo funciona como ejercicio.