Se usó la API de Cloud Translation para traducir esta página.

Compila un servicio de gRPC con C#

1. Descripción general

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

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

Qué aprenderás

Es el idioma del búfer 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
Visual Studio 2013 o una versión posterior instalado
Estar familiarizado con .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 muestras de C# de gRPC

Descargar muestras

Descarga el repositorio de muestra de C# de gRPC 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:

Crea 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.

Repasaremos los proyectos con más detalle en la siguiente 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 la muestra de Greeter

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

Proyecto Salud

Este es el proyecto común que comparten 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 obtiene una única 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 clientes y servidores 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 realizas algún cambio en el archivo de definición del servicio, deberás ejecutar esta secuencia de comandos para volver a generar los stubs.

Servidor de saludo

Este es el proyecto del servidor de gRPC. Program.cs es el punto de entrada principal en el que se configura la implementación del puerto y el 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 la persona que recibe la invitación

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, un cliente con el canal a partir del stub generado. Luego, crea una solicitud y la envía al servidor mediante el stub de cliente.

4. Ejecuta la muestra de Greeter

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

> 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 Greeter. En un símbolo del sistema independiente, navega a la carpeta bin > Debug de Greeter Server y ejecuta el 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 es la actualización de nuestro servicio. Agrega un método nuevo a nuestro servicio de gRPC llamado "goodbye", que muestra "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, debes volver a generar los stubs de cliente y servidor. En un símbolo del sistema, ejecuta generate_protos.bat. Una vez que se generan 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, realiza una llamada al método goodbye en Program.cs..

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

Vuelve a compilar el proyecto y ejecuta el servidor y el cliente nuevamente. Deberías ver que el cliente ahora 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 de cliente y servidor para una aplicación de chat simple. El proyecto Chat tiene el archivo de definición de servicio llamado chat.proto. Define un elemento ChatService con un método chat.

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

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

Puedes explorar aún más el ejemplo, compilarlo y ejecutarlo para ver cómo funciona como ejercicio.