gRPC: un ejemplo con Java Spring Boot y Postman.

En un post anterior hablamos de gRPC, su funcionamiento y ventajas. En este caso lo que queremos es realizar un ejemplo completo que nos sirva como base para entender los diferentes tipos de streaming con gRPC, cómo implementarlos en Java con Springboot y probarlos con Postman.

De forma muy simplificada gRPC se basa en HTTP/2 y gracias a ello soporta la multiplexación, es decir, es posible enviar información en Streaming de diferentes formas:

• Unaria (1:1): el cliente envía una única solicitud y el servidor devuelve una única respuesta.
• Streaming del servidor (1:N): el cliente envía una única solicitud y el servidor puede retornar múltiples respuestas, es decir, un flujo de respuesta.
• Streaming del cliente (N:1): donde el cliente envía múltiples peticiones y el servidor devuelve una única respuesta.
• Streaming bidireccional (N:M): en la que tanto el cliente como el servidor envían mensajes entre sí de forma simultánea, es decir, sin esperar respuesta del otro lado.

¿Por qué es tan importante el streaming de datos?

El concepto de streaming data se refiere al flujo continuo de datos generados por diversas fuentes, pero esto es solo una parte de la batalla. El streaming de datos adquiere mayor relevancia debido a la consolidación de técnicas y aplicaciones que permiten el stream processing, es decir, procesar, almacenar y analizar los datos a medida que se generan.

El stream processing y streaming data son la combinación perfecta y necesaria para producir y procesar información en tiempo real o casi en tiempo real (NRT).

Este tipo de soluciones van adquiriendo más peso porque dan respuesta a diferentes casos de uso en todos los sectores, desde la gestión de inventarios en el mundo retail, operaciones en el mundo financiero en tiempo real, generaciones de experiencias personalizadas en el ámbito del transporte con el cálculo de tarifas, gestión del fraude, etc.

Vamos a ejemplificar los diferentes tipos de streaming data con gRPC mediante los siguientes ejemplos de un e-commerce muy sencillo:

• Unaria (1:1) a través de un servicio que retorna un producto por su identificador.

• Streaming de servicios (1:N) con un servicio que retorna un stream de productos por nombre del artículo.

• Streaming del cliente (N:1) a través de un servicio que genera un pedido a través de un stream de productos.

• Streaming bidireccional (N:M) implementando un servicio que actualiza el stock de un producto.

Los pasos que vamos a seguir para su construcción son los siguientes:

Os dejamos el ejemplo completo en este repositorio de GitHub, pero si preferís seguir el paso a paso lo haremos a través de cada rama del repositorio llamada: step-X.

1 Definición de los servicios (protobuf)

El primer paso de la construcción de nuestros servicios es la definición del archivo descriptor o IDLe siguiendo el formato Protocol Buffers. Este archivo contiene tanto las operaciones disponibles como las estructuras de datos. En las estructuras de datos se establecen los nombres y tipos de campos y componentes los mensajes que se envían y se reciben en las llamadas a función remotas.

En nuestro ejemplo indicamos los 4 servicios que hablamos anteriormente y la estructura de los mensajes. Es importante destacar que en dicha definición aparece la palabra stream del lado cliente o servidor del que queremos hacer la multiplexación.

Si necesitas más información para generar el descriptor puedes ir aquí.

2 Compilación y generación del código (grpc-maven-plugin)

Una vez escrita la definición del servicio hay que generar las clases que sirven como base para realizar la implementación, gRPC ofrece un plugin para maven sin necesidad de instalar ninguna herramienta adicional en el sistema.

• Para hacerlo simplemente generamos nuestra aplicación Springboot con el initializr.
• Añadimos las dependencias al pom.

       <dependency>
           <groupId>io.grpc</groupId>
           <artifactId>grpc-netty-shaded</artifactId>
           <scope>runtime</scope>
           <version>${io.grpc.version}</version>
       </dependency>
       <dependency>
           <groupId>io.grpc</groupId>
           <artifactId>grpc-protobuf</artifactId>
           <version>${io.grpc.version}</version>
       </dependency>
       <dependency>
           <groupId>io.grpc</groupId>
           <artifactId>grpc-stub</artifactId>
           <version>${io.grpc.version}</version>
       </dependency>
       <dependency>
           <groupId>io.grpc</groupId>
           <artifactId>grpc-testing</artifactId>
           <version>${io.grpc.version}</version>
           <scope>test</scope>
       </dependency>

• Copiamos los ficheros .proto a la ruta /src/main/proto.
• Y, por último, generamos las fuentes ejecutando mvn clean install. Esto nos creará los stubs y las funciones a utilizar por nuestro servicio en la carpeta target.

3 Implementación de los servicios (java)

Una vez generados los artefactos, hay que realizar la implementación del servidor, donde vamos a crear la lógica de negocio de nuestro e-commerce.

• Por una parte, la creación del servidor gRPC que indica el puerto y servicios a levantar.
• Por otra parte, la implementación de nuestros servicios con la lógica necesaria.

Es importante entender que en dicha implementación se utilizan las clases generadas en el paso anterior y la utilización de los métodos:

• onNext() para concatenar mensajes en el stream correspondiente.
• onComplete() para terminar la llamada HTTP.

Por último, levantamos nuestro servidor ejecutando:

mvn exec:java -Dexec.mainClass=com.paradigma.grpc.streaming.StoreServer

Probando los servicios (Postman)

En este caso, en lugar de implementar un cliente que invoque a nuestros servicios vamos a hacer uso de Postman que desde hace unos meses soporta gRPC y tiene previsto mejorar sus funcionalidades en las siguientes versiones. Aquí os dejamos un ejemplo de cómo crear peticiones gRPC con postman.

Si importamos en postman nuestro fichero .proto siguiendo el ejemplo podemos probar nuestros servicios:

• Unaria (1:1)

A través de un servicio que retorna un producto por su identificador. En este caso se envía un mensaje con el identificador de producto y se retorna un único mensaje con el producto, no hay streaming.

• Streaming del servidor (1:N)

En este ejemplo se busca un producto por su nombre y se retorna una única petición HTTP con 5 mensajes, esto lo determina la lógica de negocio que hemos implementado en nuestro servidor gRPC.

• Streaming del cliente (N:1)

A través de un servicio que genera un pedido a partir de un stream de productos. Para hacerlo en este caso desde Postman se inicia la petición HTTP a través del botón invoke:

Una vez iniciada la comunicación, se van incluyendo los mensajes de cada producto con el botón send, es análogo a lo que por nuestra parte en el servidor hacíamos con el método java onNext().

Se envían la cantidad de productos que queramos enviando cada uno con el botón next y se termina de enviar la petición HTTP con el botón End Streaming, es análogo a lo que hacíamos en nuestro código del servidor con el método onComplete().

Siguiendo la lógica de negocio de nuestro servidor, se retorna un único mensaje con el importe total de los productos que se han enviado en los N mensajes de entrada, el total de artículos y la fecha.

• Streaming bidireccional (N:M)

Implementando un servicio que actualiza el stock de un producto. En nuestra implementación por cada mensaje de streaming de entrada se retorna un mensaje en el streaming de salida con el stock actualizado de un producto.

Conclusiones

En este artículo, hemos visto cómo implementar servicios de streaming en gRPC a través de ejemplos muy sencillos.

El streaming es una potente característica que permite a clientes y servidores comunicarse enviando múltiples mensajes a través de una única conexión. Además, los mensajes se reciben en el mismo orden en que fueron enviados, pero cualquiera de las partes puede leer o escribir los mensajes en el orden que desee.

Si queréis probarlo vosotros y ver el potencial de gRPC el código fuente está disponible en GitHub.