Comunicación de microservicio gRPC en NestJS

Imagina que estás en casa durante las vacaciones y tu familia decide reunirse. En lugar de que una sola persona cocine todo, todos aceptan traer platos especiales que sepan preparar bien. El objetivo es crear una comida completa combinando todos estos platos. Aceptas hacer arroz frito con pollo, tu hermano preparará pastel de postre y tu hermana preparará ensalada.

Cada plato representa un microservicio con una función o propósito específico. Por ejemplo, el arroz frito representa un plato principal abundante; la ensalada representa un acompañamiento fresco y saludable; y el pastel representa un postre dulce. En una arquitectura de microservicios, los desarrolladores pueden desarrollar, implementar y mantener cada microservicio independientemente de otros microservicios, asegurando que cada microservicio permanezca separado e independiente.

Así como cada plato en una fiesta familiar representa un microservicio con una función o propósito diferente, cada microservicio en un sistema de software debe comunicarse de manera efectiva con otros microservicios para formar una aplicación completamente funcional. De manera similar a cómo cada plato debe coordinarse con otros platos para crear una comida deliciosa, la comunicación entre microservicios se vuelve cada vez más importante a medida que aumenta la cantidad de microservicios. Podemos garantizar que los microservicios se ejecuten sin problemas mediante el uso de marcos de comunicación eficientes como gRPC para construir sistemas duraderos y escalables.

En este artículo, aprenderemos cómo gRPC, un marco de llamadas a procedimientos remotos de código abierto de alto rendimiento, permite que los microservicios en una aplicación NestJS se comuniquen. Cubriremos las ventajas de usar gRPC, cómo hacerlo en una aplicación NestJS y daremos un ejemplo de cómo los microservicios pueden comunicarse usándolo.

requisitos previos

Comencemos cubriendo los requisitos previos y las herramientas que necesitaremos:

• Node.js y NPM: ejecutar y manejar las dependencias de nuestra aplicación.
• NestJS CLI: para crear, administrar y ejecutar aplicaciones NestJS.
• Búfers de protocolo: define mensajes y servicios en gRPC.
• gRPC: permite que los microservicios en aplicaciones NestJS se comuniquen entre sí.
• grpcurl: le permite probar una comunicación de microservicio simple.

Microservicios y cómo se comunican

Los microservicios se comunican entre sí de muchas maneras. Dado que cada microservicio en una arquitectura de microservicios realiza una función o tarea específica, se requiere comunicación para garantizar que la aplicación completa funcione correctamente. La arquitectura de microservicios permite a los desarrolladores crear aplicaciones más flexibles, escalables y tolerantes a fallas debido a la independencia de cada microservicio. Además, el diseño modular de los microservicios los hace ideales para aplicaciones complejas, ya que diferentes componentes del sistema pueden tener diferentes necesidades y requisitos.

Desafíos de la comunicación de microservicios

Los microservicios normalmente se comunican entre sí a través de API y protocolos bien definidos, lo que permite que cada microservicio se comunique de manera confiable y eficiente. Sin embargo, la comunicación entre microservicios puede resultar un poco desafiante y complicada. Cuando muchos microservicios se comunican entre sí, los desarrolladores pueden encontrar varios problemas, entre ellos:

• Latencia: Congestión de la red debido a ineficiencias en la comunicación y transferencia de datos.
• Seguridad: Las posibles vulnerabilidades y amenazas pueden resultar de controles de acceso mal administrados o de no contar con los protocolos de seguridad necesarios.
• Descubrimiento de servicios: a medida que aumenta la cantidad de servicios en el sistema, administrar y encontrar el servicio adecuado se vuelve difícil. Peor aún, tener puntos finales codificados puede provocar un sistema frágil.
• Tolerancia a fallos: dado que varios servicios interactúan entre sí, cualquier fallo en el servicio puede tener un efecto dominó en todo el sistema.

En general, la comunicación entre microservicios puede resultar desafiante y compleja. Los desarrolladores pueden crear arquitecturas de microservicios altamente escalables, tolerantes a fallos y resistentes diseñando sistemas teniendo en cuenta los siguientes factores:

• La comunicación es fundamental.
• Protocolo de comunicación eficiente.
• Protocolos de seguridad adecuados.
• Un mecanismo de descubrimiento de servicios para localizar y comunicarse dinámicamente con servicios.

Patrones de comunicación en microservicios.

Los microservicios se comunican entre sí mediante varios patrones de comunicación. Veremos algunos de ellos: publicación-suscripción, solicitud-respuesta, arquitectura basada en eventos y colas de mensajes.

• Patrón de publicación-suscripción: implica comunicación de uno a muchos en la que se publican mensajes para varios suscriptores. Por ejemplo, una empresa envía correos electrónicos a sus distintos suscriptores del boletín.
• Patrón de solicitud-respuesta: un servicio envía una solicitud a otro servicio y el servicio receptor devuelve una respuesta. Por ejemplo, cuando la API recibe una solicitud y devuelve los datos solicitados o un mensaje de error en respuesta.
• Patrón de cola de mensajes: en este patrón, los mensajes se envían a una cola y se almacenan hasta que haya un servicio disponible para procesarlos. Por ejemplo, una empresa de reparto podría utilizar este patrón para recibir y organizar las solicitudes de entrega de los clientes y asignar conductores disponibles según su ubicación.
• Arquitectura basada en eventos: en este patrón, los servicios intercambian mensajes cuando ocurren eventos. Por ejemplo, cuando un usuario envía dinero desde su aplicación de banca móvil, se notifica la deducción al Servicio de Actualización de Cuenta.

Descripción general de gRPC

gRPC es un marco de llamada a procedimiento remoto (RPC) de código abierto de alto rendimiento desarrollado por Google. Permite que las aplicaciones cliente llamen a métodos en una aplicación de servidor ubicada en una computadora remota tan fácilmente como llamar a métodos en un objeto local. Simplifica el proceso de creación y escalado de aplicaciones distribuidas al proporcionar una comunicación eficiente e independiente del lenguaje entre las aplicaciones cliente y servidor.

gRPC vs REST vs SOAP en microservicios

Los protocolos de comunicación utilizados en la arquitectura de microservicios incluyen gRPC, REST y SOAP. Estas son algunas de las principales diferencias entre ellos:

• Soporte de lenguajes: REST y SOAP se usan comúnmente en lenguajes de programación basados ​​en web, mientras que gRPC admite múltiples lenguajes de programación, incluidos C++, Java, Python, etc.
• Rendimiento: debido a que gRPC utiliza serialización binaria, formatos de datos comprimidos y transmisión bidireccional, es más rápido y eficiente que REST y SOAP. Por tanto, las aplicaciones cliente y servidor pueden comunicarse en tiempo real.
• Formatos de datos: REST y SOAP usan XML o JSON, mientras que gRPC usa Protocol Buffers, un estándar de serialización binaria.
• Contratos de servicio y tipificación sólida: para establecer contratos de servicio, gRPC utiliza búferes de protocolo, que proporcionan una tipificación sólida y facilitan el control de versiones y el mantenimiento del servicio. REST y SOAP utilizan definiciones WSDL u OpenAPI menos expresivas y flexibles en sus contratos de servicio.
• Escalabilidad: gRPC es una excelente opción para la arquitectura de microservicios porque está diseñado para manejar sistemas distribuidos a gran escala y tiene características como equilibrio de carga y comprobaciones de estado listas para usar.

Usando gRPC con NestJS

En esta sección, aprenderá cómo crear un microservicio NestJS simple que use gRPC para devolver "¡Hola, mundo!":

Primero, debe instalar las herramientas NestJS CLI y gRPC:

npm install -g @nestjs/cli
npm install @nestjs/microservices @grpc/grpc-js

Debe crear un nuevo proyecto NestJS usando la CLI:

nest new hello-world-demo

El nombre del proyecto en este ejemplo es "hello-world-demo".

Ahora, navega a la carpeta del proyecto:

cd hello-world-demo

A continuación, debe crear un nuevo módulo y servicio. Los servicios son clases que proporcionan un tipo específico de funcionalidad a una aplicación, mientras que los módulos son contenedores para colecciones de servicios, controladores y proveedores relacionados. Al hacer esto, básicamente estás agregando una nueva capa de funcionalidad manejable y comprobable a tu aplicación NestJS. Esto facilita la adición de funcionalidad adicional en el futuro y beneficia la arquitectura general y la capacidad de mantenimiento de la aplicación.

nest g module hello
nest g service hello

Luego necesitas actualizar hello-world-demo/src/hello/hello.service.tsel archivo con el siguiente código:

import {
    
     Injectable } from '@nestjs/common';
import {
    
     GrpcMethod } from '@nestjs/microservices';

@Injectable()
export class HelloService {
    
    
  @GrpcMethod('HelloService', 'SayHello')
  sayHello(data: any): {
    
     message: string } {
    
    
    return {
    
     message: 'Hello, World!' };
  }
}

Este archivo de servicio contiene una clase HelloService marcada como proveedor inyectable. @GrpcMethodEl decorador se utiliza para sayHellomarcar un método como método gRPC que devuelve un mensaje "¡Hola, mundo!". En general, este código demuestra cómo crear un servicio gRPC básico utilizando NestJS.

Actualice hello-world-demo/src/app.module.tsel archivo para incluir HelloServicey usar gRPC:

import {
    
     Module } from '@nestjs/common';
import {
    
     ClientsModule, Transport } from '@nestjs/microservices';
import {
    
     AppController } from './app.controller';
import {
    
     AppService } from './app.service';
import {
    
     HelloService } from './hello/hello.service';

@Module({
    
    
  imports: [
    ClientsModule.register([
      {
    
    
        name: 'HELLO_PACKAGE',
        transport: Transport.GRPC,
        options: {
    
    
          url: 'localhost:5000',
          package: 'hello',
          protoPath: './hello.proto',
        },
      },
    ]),
  ],
  controllers: [AppController],
  providers: [AppService, HelloService],
})
export class AppModule {
    
    }

Tiene clientes gRPC para la clase de proveedor HelloService, el controlador HTTP y la clase de proveedor AppService HelloService. Utilizado por ClientsModule Registre un cliente gRPC utilizando las opciones proporcionadas, como la ruta a un archivo prototipo que describe el servicio, la URL del servidor gRPC y el nombre del paquete. Las clases AppService y HelloService que administran la lógica empresarial en la aplicación del proveedor están contenidas en los campos. La clase que gestiona las solicitudes HTTP entrantes al AppController es miembro de la propiedad de los controladores.

Cree un nuevo archivo hello-world-demo/hello.protoy agregue el siguiente código:

syntax = "proto3";

package hello;o

service HelloService {
  rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

Los archivos prototipo se utilizan para definir la estructura y la interfaz de los servicios gRPC. Es un archivo que describe el proceso de un servicio y los formatos de datos de entrada y salida de sus parámetros. El marco gRPC genera código de cliente y servidor en NestJ utilizando archivos prototipo escritos en el lenguaje Protocol Buffer.

Finalmente, actualice hello-world-demo/src/main.tsel archivo para iniciar el microservicio gRPC:

import {
    
     NestFactory } from '@nestjs/core';
import {
    
     Transport } from '@nestjs/microservices';
import {
    
     AppModule } from './app.module';

async function bootstrap() {
    
    
  const app = await NestFactory.createMicroservice(AppModule, {
    
    
    transport: Transport.GRPC,
    options: {
    
    
      url: 'localhost:5000',
      package: 'hello',
      protoPath: './hello.proto',
    },
  });
  await app.listen();
}
bootstrap();

Ahora, inicie el microservicio gRPC:

npm run start

Una vez que se inicia el servidor, escucha las solicitudes gRPC entrantes en la URL y el puerto especificados (5000 en este caso). Luego se puede enviar una solicitud al servidor desde un cliente gRPC, como una interfaz web, una aplicación móvil u otros microservicios. Para el ejemplo "Hola mundo" en el que hemos estado trabajando, puedes probar el servidor enviando una solicitud utilizando la herramienta de línea de comandos grpcurl. Para probar microservicios, puede utilizar grpcurl, una herramienta de línea de comandos para interactuar con servicios gRPC:

grpcurl -plaintext -d '{"name": "John"}' localhost:5000 hello.HelloService/SayHello

Esto debería devolver la siguiente respuesta:

{
    
    
  "message": "Hello, World!"
}

¡Eso es todo! Creaste un microservicio NestJS que usa gRPC para devolver "¡Hola, mundo!" y lo probaste usando grpcurl. Por supuesto, en una aplicación real, el microservicio puede tener una funcionalidad más compleja que simplemente devolver "¡Hola mundo!" en respuesta a una única solicitud. Sin embargo, el proceso básico de iniciar un servidor, escuchar las solicitudes entrantes y procesar esas solicitudes según la lógica empresarial será el mismo.

Beneficios de usar gRPC para la comunicación de microservicios

El uso de NestJS y gRPC para la comunicación de microservicios puede generar sistemas más rápidos, confiables y escalables. Aquí hay algunos beneficios:

• Contratos fuertemente tipados: la API proporcionada por gRPC está fuertemente tipada y utiliza buffers de protocolo para construir contratos de servicio. En otras palabras, tanto los servidores como los clientes pueden asegurarse de que los mensajes que envían y reciben siguen un esquema específico.
• Generación automática de código: NestJS proporciona herramientas que facilitan la generación automática de código TypeScript a partir de archivos de definición de servicios gRPC (.proto), lo que simplifica la integración de microservicios con NestJS.
• Interoperabilidad: facilitar la ejecución de NestJS y gRPC con otros protocolos como HTTP/REST al permitirles ejecutarse con otros servicios que utilizan diferentes protocolos de comunicación.
• Facilidad de uso: NestJS proporciona una API fácil de entender para definir servicios gRPC, lo que simplifica la creación y administración de microservicios.

en conclusión

La arquitectura de microservicios se está convirtiendo en una forma más popular de diseñar aplicaciones complejas y escalables. Proporciona flexibilidad y escalabilidad al descomponer las aplicaciones en componentes independientes y dedicados. Sin embargo, la efectividad de este diseño depende de una comunicación efectiva entre microservicios. Aquí es donde entra en juego gRPC, un marco de llamada a procedimiento remoto (RPC) de alto rendimiento.

En este artículo, exploramos los beneficios de utilizar gRPC para la comunicación de microservicios en NestJS. Discutimos los desafíos involucrados en la comunicación de microservicios, incluida la latencia, la seguridad, el descubrimiento de servicios y la tolerancia a fallas. También exploramos cómo gRPC puede ayudar a los desarrolladores a superar estos desafíos y crear arquitecturas de microservicios escalables y tolerantes a fallas. Además, comparamos gRPC con otros protocolos de comunicación como REST y SOAP, destacando su compatibilidad con idiomas, rendimiento, formatos de datos y ventajas de contrato de servicio.

Además, creamos un servicio simple de "hola mundo" usando gRPC en NestJS para demostrar cómo los servicios en una aplicación Nest pueden comunicarse de manera efectiva usando gRPC.

Finalmente, analizamos los beneficios de utilizar gRPC para la comunicación de microservicios en NestJS, incluidos contratos fuertemente tipados, generación automática de código, interoperabilidad y facilidad de uso.

En resumen, los desarrolladores pueden utilizar el rendimiento y la seguridad de tipos de gRPC y la simplicidad de NestJS para crear microservicios escalables y mantenibles con canales de comunicación eficientes, lo que da como resultado sistemas más robustos y confiables.