¿Qué son los microservicios?

Los microservicios son una arquitectura de software que se enfoca en crear aplicaciones a partir de pequeñas piezas de funcionalidad independientes que se ejecutan como servicios separados. Cada servicio se ejecuta en su propio proceso y se comunica con otros servicios a través de una interfaz bien definida. Esta arquitectura facilita el desarrollo, la implementación y el mantenimiento de aplicaciones complejas al permitir que los equipos se centren en servicios individuales y los cambien sin afectar a otros servicios.

¿Qué es Nest JS?

Nest JS es un marco de trabajo para Node.js que se utiliza para crear aplicaciones escalables y fáciles de mantener. Se basa en las mejores prácticas de la programación orientada a objetos, la programación funcional y la programación reactiva. Nest JS también admite múltiples tecnologías de comunicación, como gRPC y RabbitMQ.

¿Qué es gRPC?

gRPC es un marco de trabajo de comunicación de RPC (Remote Procedure Call) de alta velocidad y bajo costo que utiliza protocol buffers para definir la estructura del mensaje y la interfaz de servicio. gRPC es compatible con varios lenguajes de programación, lo que lo hace ideal para sistemas distribuidos y aplicaciones de microservicios.

¿Qué es RabbitMQ?

RabbitMQ es un software de mensajería de código abierto que se utiliza para enviar y recibir mensajes entre aplicaciones. RabbitMQ funciona como un intermediario entre los emisores y los receptores de los mensajes, lo que permite la comunicación asíncrona entre las aplicaciones.

Creando microservicios en Nest JS usando gRPC y RabbitMQ

Para crear microservicios en Nest JS utilizando gRPC y RabbitMQ, debemos seguir los siguientes pasos:

Paso 1: Crear un nuevo proyecto Nest JS

El primer paso es crear un nuevo proyecto Nest JS utilizando el CLI de Nest. Para hacerlo, abrimos una terminal y ejecutamos el siguiente comando:

nest new nombre_del_proyecto

Esto creará un nuevo proyecto Nest JS en una carpeta con el nombre nombre_del_proyecto.

Paso 2: Agregar los paquetes de gRPC y RabbitMQ

El siguiente paso es agregar los paquetes de gRPC y RabbitMQ al proyecto. Para hacerlo, abrimos la terminal y ejecutamos los siguientes comandos:

npm install @nestjs/microservices @grpc/grpc-js protobufjs
npm install amqplib

Esto instalará los paquetes necesarios para utilizar gRPC y RabbitMQ en el proyecto.

Paso 3: Crear un servicio gRPC

El siguiente paso es crear un servicio gRPC utilizando el prototipo de protocol buffers. Para hacerlo, creamos un archivo .proto en la carpeta src con el siguiente contenido:

syntax = "proto3";

package nombre_del_paquete;

service NombreDelServicio {
  rpc MetodoDelServicio (NombreDelMensaje) returns (NombreDelMensaje) {}
}

message NombreDelMensaje {
  string campo1 = 1;
  int32 campo2 = 2;
}

Reemplazamos nombre_del_paquete, NombreDelServicio, MetodoDelServicio, NombreDelMensaje, campo1 y campo2 con los nombres y campos deseados para nuestro servicio. Luego, compilamos el archivo.proto` utilizando el siguiente comando en la terminal:

npx grpc_tools_node_protoc --js_out=import_style=commonjs,binary:./src --grpc_out=./src --plugin=protoc-gen-grpc=`which grpc_tools_node_protoc_plugin` ./src/nombre_del_archivo.proto

Esto creará un archivo .js en la carpeta src con el mismo nombre que el archivo .proto, que contiene el código generado para nuestro servicio gRPC.

Paso 4: Configurar el servidor gRPC

El siguiente paso es configurar el servidor gRPC en nuestro proyecto Nest JS. Para hacerlo, creamos un archivo grpc.server.ts en la carpeta src con el siguiente contenido:

import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { join } from 'path';

const grpcServerOptions: MicroserviceOptions = {
  transport: Transport.GRPC,
  options: {
    package: 'nombre_del_paquete',
    protoPath: join(__dirname, 'nombre_del_archivo.proto'),
  },
};

export default grpcServerOptions;

Reemplazamos nombre_del_paquete y nombre_del_archivo.proto con los nombres correspondientes para nuestro servicio gRPC.

Paso 5: Crear un servicio RabbitMQ

El siguiente paso es crear un servicio RabbitMQ. Para hacerlo, creamos un archivo rabbitmq.service.ts en la carpeta src con el siguiente contenido:

import { Injectable } from '@nestjs/common';
import { connect } from 'amqplib';

@Injectable()
export class RabbitMQService {
  private connection;
  private channel;

  async onModuleInit() {
    this.connection = await connect('amqp://localhost');
    this.channel = await this.connection.createChannel();
    await this.channel.assertQueue('nombre_de_la_cola');
  }

  async sendMessage(message: string) {
    await this.channel.sendToQueue('nombre_de_la_cola', Buffer.from(message));
  }

  async receiveMessage() {
    await this.channel.consume('nombre_de_la_cola', (message) => {
      console.log(message.content.toString());
    });
  }

  async onModuleDestroy() {
    await this.channel.close();
    await this.connection.close();
  }
}

Reemplazamos nombre_de_la_cola con el nombre deseado para nuestra cola RabbitMQ.

Paso 6: Configurar el cliente gRPC

El siguiente paso es configurar el cliente gRPC en nuestro proyecto Nest JS. Para hacerlo, creamos un archivo grpc.client.ts en la carpeta src con el siguiente contenido:

import { Client, ClientGrpc, Transport } from '@nestjs/microservices';
import { join } from 'path';

const grpcClientOptions: ClientOptions = {
  transport: Transport.GRPC,
  options: {
    package: 'nombre_del_paquete',
    protoPath: join(__dirname, 'nombre_del_archivo.proto'),
    url: 'localhost:50051',
  },
};

export interface GrpcClient {
  metodoDelServicio(data: NombreDelMensaje): Observable<NombreDelMensaje>;
}

export const grpcClientProvider = {
  provide: 'GRPC_CLIENT',
  useFactory: (client: ClientGrpc) => client.getService<GrpcClient>('NombreDelServicio'),
  inject: ['GRPC_CLIENT'],
};

export default grpcClientOptions;

Reemplazamos nombre_del_paquete, nombre_del_archivo.proto, localhost:50051,NombreDelMensaje y NombreDelServicio con los valores correspondientes para nuestro servicio gRPC.

Paso 7: Integrar el cliente gRPC y el servicio RabbitMQ

Finalmente, integramos el cliente gRPC y el servicio RabbitMQ en nuestro proyecto Nest JS. Para hacerlo, creamos un archivo app.module.ts en la carpeta raíz de nuestro proyecto con el siguiente contenido:

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import grpcServerOptions from './grpc.server';
import grpcClientOptions, { grpcClientProvider } from './grpc.client';
import { RabbitMQService } from './rabbitmq.service';

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'GRPC_CLIENT',
        transport: Transport.GRPC,
        options: grpcClientOptions,
      },
    ]),
  ],
  controllers: [AppController],
  providers: [
    AppService,
    grpcClientProvider,
    grpcServerOptions,
    RabbitMQService,
  ],
})
export class AppModule {}

Luego, podemos usar el servicio RabbitMQ y el cliente gRPC en cualquier componente o controlador de nuestro proyecto Nest JS. Por ejemplo, en el archivo app.service.ts podemos enviar un mensaje a la cola RabbitMQ y recibir una respuesta del servidor gRPC de la siguiente manera:

import { Injectable } from '@nestjs/common';
import { GrpcClient } from './grpc.client';
import { RabbitMQService } from './rabbitmq.service';

@Injectable()
export class AppService {
  constructor(
    private readonly rabbitmqService: RabbitMQService,
    private readonly grpcClient: GrpcClient,
  ) {}

  async sendMessage(message: string): Promise<string> {
    await this.rabbitmqService.sendMessage(message);

    const response = await this.grpcClient.metodoDelServicio({
      campoDelMensaje: message,
    }).toPromise();

    return response.campoDelMensaje;
  }
}

En resumen, crear microservicios en Nest JS utilizando gRPC y RabbitMQ puede parecer un proceso complejo al principio, pero siguiendo los pasos descritos anteriormente podemos integrar fácilmente estos dos servicios en nuestro proyecto. Al hacerlo, podemos aprovechar los beneficios de gRPC, como una comunicación más eficiente y una definición clara de los servicios, junto con los beneficios de RabbitMQ, como la escalabilidad y la resiliencia en caso de fallos.

Microservicios con Nest JS