¿Cómo crear un microservicio NestJS Redis?

Nest.js es un framework web progresivo de Node.js que te proporciona un backend robusto para tus aplicaciones frontend. Es altamente comparable a Angular en términos de conceptos como Módulo, Proveedor, entre otros, y es una clara elección por los desarrolladores de Angular.

La necesidad del Redis transporte

Para entender la necesidad del transportador Redis, veremos la siguiente ilustración.

En la ilustración anterior, cada servicio publica mensajes en Redis. También se suscriben a los mensajes de Redis. Los mensajes publicados se clasifican en canales sin saber qué servicios recibirán el mensaje. Además, es totalmente posible que ningún servicio reciba un tipo de mensaje concreto.

Cada microservicio puede suscribirse a un gran número de canales. Alternativamente, cada canal también puede ser suscrito por múltiples servicios. La idea básica es que los mensajes son fire and forget. En otras palabras, si se publica un mensaje y ningún servicio se suscribe a él, el mensaje será eliminado. Básicamente, no hay garantía de que cada mensaje llegue a un suscriptor.

En este enfoque, los distintos microservicios están ampliamente desacoplados entre sí. No es necesario que ningún microservicio conozca la existencia de otros servicios. En otras palabras, cada microservicio puede evolucionar por sí mismo con un intermediario común para la comunicación con sus pares.

via GIPHY

Instalación

Primero instalamos los siguientes paquetes en el cliente y en el microservicio.

$ npm i --save @nestjs/microservices
$ npm i --save redis

Básicamente, el cliente publicará un mensaje en Redis. El servicio se suscribirá al mensaje y hará algo con el mensaje.

Además, necesitamos Redis para que las cosas funcionen. Usaremos docker para crear rápidamente un contenedor Redis usando el siguiente comando:

$ docker run --name demo-redis -p 6379:6379 -d redis

Una vez que el contenedor está arriba y los paquetes están instalados, podemos empezar con los siguientes pasos.

Configurar el Microservicio NestJS Redis

Para utilizar el transportador Redis, pasamos el objeto options al método createMicroservice() de la clase NestFactory.

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

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.REDIS,
      options: {
        url: 'redis://localhost:6379',
      }
    }
  )
  await app.listen();
}
bootstrap();

Main.ts

Básicamente, especificamos el tipo de transporte. En este caso, utilizamos el enum Transport.REDIS para el mismo. Además, especificamos la URL de nuestro contenedor Redis en ejecución.

Nótese aquí que el objeto de opciones depende del tipo de transporte. Además de la URL, otras propiedades disponibles son retryAttempts y retryDelay. Puedes ver los detalles de todas las propiedades disponibles en este enlace.

Suscripción a un evento en el microservicio NestJS Redis

Ahora podemos suscribirnos a un evento particular o a un mensaje en el Microservicio NestJS Redis.

Véase el código siguiente:

import { Controller } from '@nestjs/common';
import { EventPattern, MessagePattern } from '@nestjs/microservices';

@Controller()
export class AppController {

  @MessagePattern({cmd: 'greeting'})
  getGreetingMessage(name: string): string {
    return `Hello ${name}`;
  }

  @MessagePattern({cmd: 'greeting-async'})
  async getGreetingMessageAysnc(name: string): Promise<string> {
    return `Hello ${name} Async`;
  }

  @EventPattern('book-created')
  async handleBookCreatedEvent(data: Record<string, unknown>) {
    console.log(data);
  }

}

app.controller.ts

Básicamente, estamos utilizando MessagePattern y EventPattern para recibir mensajes. Para el propósito de este post, puedes simplemente pensar en estos métodos como manejadores para diferentes tipos de mensajes.

Publicar un mensaje

Para publicar un mensaje usando el transportador Redis, necesitamos configurar la aplicación cliente. En primer lugar, tenemos que especificar cómo el cliente debe comunicarse con Redis.

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

@Module({
  imports: [
    ClientsModule.register([
      {name: 'GREETING_SERVICE',transport: Transport.REDIS,
      options : {
        url: 'redis://localhost:6379',
      }
    }
    ])
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

app.module.ts

Básicamente, aquí usamos el método register() del ClientsModule para registrar nuestro servidor Redis. Especificamos un nombre de token GREETING_SERVICE en la configuración. Básicamente, usando este nombre de token y ClientProxy, podemos inyectar este servicio dentro de nuestra aplicación.

Ver abajo:

import { Inject, Injectable } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';

@Injectable()
export class AppService {

  constructor(@Inject('GREETING_SERVICE') private client: ClientProxy){}

  async getHello(){
    return this.client.send({cmd: 'greeting'}, 'Progressive Coder');
  }

  async getHelloAsync() {
    const message = await this.client.send({cmd: 'greeting-async'}, 'Progressive Coder');
    return message;
  }

  async publishEvent() {
    this.client.emit('book-created', {'bookName': 'The Way Of Kings', 'author': 'Brandon Sanderson'});
  }
}

app.service.ts

La instancia ClientProxy viene con métodos como send() y emit(). Usando estos métodos, podemos enviar o publicar mensajes. Si vamos estrictamente a la ruta de publicación-suscripción, es mejor usar el método emit().

import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get("/greeting")
  async getHello() {
    return this.appService.getHello();
  }

  @Get("/greeting-async")
  async getHelloAsync() {
    return this.appService.getHelloAsync();
  }

  @Get("/publish-event")
  async publishEvent() {
    this.appService.publishEvent();
  }
}

app.controller.ts

Quiero más

Por supuesto! gracias al apoyo que se ha conseguido por todos ustedes (comentando, suscribiendote y compartiendo) se agregaron nuevos videos, en esta ocasión iniciamos el curso de testing en angular, curso de node, curso mongo y mucho más

A continuación se muestra una implementación del controlador para activar estos métodos de servicio.

Conclusión

Con esto, hemos aprendido con éxito cómo crear un Microservicio NestJS Redis. Hemos aprendido a configurar el transportador Redis y a utilizarlo para implementar el enfoque de mensajería publish-subscribe.

Código

Fuente