gRPC: una alternativa para servicios de alto rendimiento

gRPC (google Remote Procedure Calls) es un framework que nos sirve para realizar llamadas a procedimientos remotos.

Es de alto rendimiento. Multilenguaje (clientes y servidores). Además de tener un Streaming avanzado, lo que permite comunicaciones tipo: unary, server streaming, client streaming y streaming bidirectional.

Es ideal para microservicios gracias a su alto rendimiento, tipado fuerte y soporte multiplataforma.

Ya hemos hecho una comparativa entre otras alternativas como GraphQL:

gRPC y GraphQL

Usa Protocol buffers (*.proto) como mecanismo de serialización (y deserialización); el cual es un formato binario, más pequeño, rápido y sencillo que XML y JSON. Además de soportar diversos lenguajes como: Java, Python, Go, etc.

También usa HTTP/2 como protocolo de comunicación, el cual es una mejora del HTTP clásico. El cual prioriza solicitudes, permite la comprensión de encabezados, multiplexación (múltiples llamadas simultáneas) y tiene mayor seguridad.

Empezando con gRPC y .NET

Crearemos una aplicación Cliente-Servidor para mostrar el uso de gRPC. Como lenguaje base usaremos C# y la herramienta dotnet para crear los proyectos.

Quien ha trabajado con aplicaciones Cliente-Servidor podrá entender el flujo. Una aplicación Cliente hará solicitudes y el Servidor las atenderá.

Para este ejemplo necesitaremos crear:

• Un proyecto servidor. 
• Un proyecto cliente.

Empecemos con el Servidor

Creamos el proyecto servidor con soporte a gRPC:

$ dotnet new grpc -o GrpcServer
$ cd GrpcServer

Una vez ubicados en el directorio podemos ejecutarlo:

$ dotnet run

Abrimos el navegador en la ruta: http://localhost:5057

Si todo va bien, veremos un mensaje.

Continuemos con el Cliente

Creamos el proyecto cliente de tipo consola:

$ dotnet new console -o GrpcClient
$ cd GrpcClient

Una vez ubicados en el directorio del Cliente, copiamos el directorio y archivo Protos\greet.proto del proyecto Servidor al Cliente.

Editamos el archivo GrpcClient.csproj de para agregar el archivo copiado. De tal manera que quede de esta forma:

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

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Google.Protobuf" Version="3.33.5" />
    <PackageReference Include="Grpc.Net.Client" Version="2.76.0" />
    <PackageReference Include="Grpc.Tools" Version="2.78.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
	
	<Protobuf Include="Protos\greet.proto" GrpcServices="Client" />

  </ItemGroup>

</Project>

El archivo Protos\greet.proto es el siguiente:

syntax = "proto3";

option csharp_namespace = "Greet";

package greet;


service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}


message HelloReply {
  string message = 1;
}

Este archivo *.proto define el contrato de comunicación entre Cliente y Servidor en gRPC, y permite a un Cliente enviar un nombre y recibir un saludo como respuesta.

Compilamos y ejecutamos el proyecto Cliente:

$ dotnet build
$ dotnet run

Si todo va bien, veremos algo como esto en el Cliente:

Respuesta del servidor: Hello Code Monkey Junior

Y en el Servidor:

Usando la configuración de inicio de C:\Users\HP\Documents\pruebasCSharp\pruebasGRPC\GrpcServer\Properties\launchSettings.json...
Compilando...
info: Microsoft.Hosting.Lifetime[14]
      Now listening on: http://localhost:5057
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:\Users\HP\Documents\pruebasCSharp\pruebasGRPC\GrpcServer
info: GrpcServer.Services.GreeterService[0]
      The message is received from Code Monkey Junior

Este solo es un ejemplo de gRPC. Aún falta saber más de Protobuf y HTTP/2 a profundidad.

Como mencionamos con gRPC podemos crear aplicaciones con diversos lenguajes de programación.

Por ejemplo, si tenemos un servidor creado en lenguaje de programación C# no habrá problema que clientes hechos en otros lenguajes como Java, Python, Go, etc. puedan realizar solicitudes y recibir respuestas.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://grpc.io/
https://protobuf.dev/
https://dotnet.microsoft.com
https://alquimistadecodigo.blogspot.com/2024/05/grpc-protobuff-protocol-buffers.html
https://alquimistadecodigo.blogspot.com/2024/05/grpc-en-java-y-protobuff.html