A comunicação entre sistemas distribuídos é uma parte fundamental do desenvolvimento de aplicativos modernos. O gRPC (Google Remote Procedure Call) se tornou uma tecnologia popular para facilitar essa comunicação eficiente e confiável.

Neste artigo, vamos explorar como usar o gRPC em conjunto com o framework NestJS para criar serviços altamente eficientes e escaláveis.

O que é gRPC?

O gRPC é um framework de código aberto desenvolvido pelo Google que permite a comunicação eficiente entre serviços distribuídos. Ele utiliza o protocolo HTTP/2 para transportar dados e usa o Protocol Buffers (protobufs) como linguagem de interface para definir os contratos dos serviços. O gRPC oferece suporte a várias linguagens de programação e fornece recursos como streaming, autenticação e descoberta de serviços.

Por que usar gRPC?

Existem várias razões para considerar o uso do gRPC em seu projeto:

Eficiência: O gRPC utiliza o protocolo HTTP/2, que oferece uma comunicação mais eficiente em comparação com o HTTP/1. Ele permite a multiplexação de várias chamadas em uma única conexão, reduzindo a sobrecarga de cabeçalhos.
Contratos definidos: O gRPC usa Protocol Buffers para definir os contratos dos serviços, o que torna a comunicação entre serviços claramente definida e documentada. Isso facilita a manutenção e evolução dos serviços.
Streaming: O gRPC suporta streaming de dados, o que é útil para casos de uso como transmissão de vídeo ao vivo, notificações em tempo real e muito mais.
Suporte a várias linguagens: Você pode usar o gRPC em uma ampla variedade de linguagens de programação, tornando-o adequado para projetos com várias tecnologias.

Configuração do Ambiente

Antes de começarmos a usar o gRPC com NestJS, precisamos configurar nosso ambiente. Certifique-se de ter o Node.js e o NestJS instalados em seu sistema.

# Instale o NestJS CLI globalmente (caso ainda não o tenha instalado)
npm install -g @nestjs/cli

# Crie um novo projeto NestJS
nest new meu-projeto-grpc

# Navegue até o diretório do projeto
cd meu-projeto-grpc

Em seguida, vamos instalar as dependências necessárias para o gRPC e o NestJS gRPC:

# Instale as dependências do gRPC
npm install grpc @nestjs/microservices

# Instale o NestJS gRPC
npm install @nestjs/microservices/grpc

Criando um Serviço gRPC com NestJS

Agora que temos nosso ambiente configurado, vamos criar um serviço gRPC simples usando o NestJS. Primeiro, precisamos definir um arquivo de proto para especificar nosso contrato de serviço. Crie um arquivo chamado user.proto na raiz do projeto:

syntax = "proto3";

package user;

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse);
}

message UserRequest {
  string id = 1;
}

message UserResponse {
  string name = 1;
  string email = 2;
}

Neste exemplo, definimos um serviço UserService que possui um método GetUser que recebe um UserRequest e retorna um UserResponse. O UserRequest contém um campo id que representa o ID do usuário que desejamos recuperar.

Agora, vamos criar um módulo NestJS para nosso serviço gRPC. Crie um arquivo chamado user.module.ts:

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { join } from 'path';

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'USER_PACKAGE',
        transport: Transport.GRPC,
        options: {
          package: 'user',
          protoPath: join(__dirname, 'user.proto'),
        },
      },
    ]),
  ],
  controllers: [],
  providers: [],
})
export class UserModule {}

Neste módulo, estamos usando o ClientsModule do NestJS para configurar o cliente gRPC. Estamos especificando o nome do pacote e o caminho para o arquivo user.proto que definimos anteriormente.

Agora, vamos criar um controlador para nosso serviço gRPC. Crie um arquivo chamado user.controller.ts:

import { Controller, Get, Param } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';
import { UserRequest, UserResponse } from './user.proto';

@Controller('user')
export class UserController {
  @GrpcMethod('UserService', 'GetUser')
  getUser(data: UserRequest): UserResponse {
    // Implemente a lógica para buscar o usuário com base no ID
    // Retorna um UserResponse
  }
}

Neste controlador, estamos usando o decorator @GrpcMethod para associar o método getUser com o método GetUser definido em nosso serviço gRPC.

Agora que nosso serviço gRPC está configurado, podemos implementar a lógica no método getUser para buscar o usuário com base no ID fornecido em data e retornar um UserResponse.

Inicializando o Serviço gRPC

Para iniciar nosso serviço gRPC, precisamos adicionar algumas configurações ao arquivo main.ts:

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

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  app.connectMicroservice<MicroserviceOptions>({
    transport: Transport.GRPC,
    options: {
      package: 'user',
      protoPath: join(__dirname, 'user.proto'),
    },
  });

  await app.startAllMicroservicesAsync();
  await app.listen(3000);
}
bootstrap();

Neste código, estamos criando um serviço gRPC com as mesmas configurações que usamos no módulo UserModule. Estamos usando o mesmo arquivo user.proto para especificar o contrato do serviço.

Agora, você pode iniciar seu aplicativo NestJS com o comando:

npm run start

Seu serviço gRPC estará disponível em localhost:3000.

Consumindo o Serviço gRPC

Agora que temos nosso serviço gRPC em funcionamento, podemos consumi-lo de outro aplicativo ou cliente gRPC. Vamos criar um

exemplo simples de cliente gRPC em Node.js para consumir nosso serviço.

Crie um novo diretório chamado grpc-client e navegue até ele:

mkdir grpc-client
cd grpc-client

Agora, instale as dependências necessárias:

npm install grpc

Em seguida, crie um arquivo chamado user-client.js:

const grpc = require('grpc');
const { UserRequest } = require('./user_pb');
const { UserServiceClient } = require('./user_grpc_pb');

const client = new UserServiceClient('localhost:3000', grpc.credentials.createInsecure());

const request = new UserRequest();
request.setId('1');

client.getUser(request, (error, response) => {
  if (!error) {
    console.log('User:', response.getName(), 'Email:', response.getEmail());
  } else {
    console.error(error);
  }
});

Neste exemplo, estamos criando um cliente gRPC que se conecta ao serviço gRPC em localhost:3000. Estamos usando os módulos gerados automaticamente a partir do arquivo user.proto que definimos anteriormente.

Conclusão

O gRPC é uma ferramenta poderosa para facilitar a comunicação eficiente entre serviços distribuídos. Quando combinado com o NestJS, ele oferece uma maneira eficaz de criar serviços altamente escaláveis e de alto desempenho. Neste artigo, exploramos como configurar um serviço gRPC com o NestJS, definir contratos de serviço e criar um cliente gRPC simples.

Se você está desenvolvendo um aplicativo distribuído ou microserviços, o gRPC com NestJS é uma escolha sólida para atender às suas necessidades de comunicação. Sua eficiência, suporte a streaming e facilidade de uso o tornam uma opção atraente para desenvolvedores.

Esperamos que este artigo tenha sido útil para você começar a trabalhar com gRPC e NestJS. Se você tiver alguma dúvida ou comentário, não hesite em compartilhá-los abaixo!

Comentários

Gostaríamos de ouvir sua opinião sobre este artigo! Você já trabalhou com gRPC e NestJS antes? Tem alguma experiência para compartilhar ou perguntas adicionais? Deixe seus comentários abaixo e vamos continuar a discussão. Seu feedback é muito valioso para nós.

Geração de Serviços Eficientes com gRPC e NestJS