Mister Coding

Nest JS Micoservices with GRPC and Monorepo


Agik Setiawan

Full Stack Developer

June 1st 2023

Apa itu Microservices?


Microservices adalah suatu pendekatan dalam pengembangan perangkat lunak yang memecah aplikasi menjadi komponen-komponen yang lebih kecil, independen, dan terisolasi. Setiap komponen, yang disebut sebagai layanan mikro, beroperasi secara mandiri dan memiliki tanggung jawab terbatas dalam fungsionalitas aplikasi secara keseluruhan.


Arsitektur microservices sering kali digunakan dalam konteks pengembangan aplikasi skala besar yang kompleks dan membutuhkan fleksibilitas dan skalabilitas yang tinggi. Dengan memecah aplikasi menjadi layanan mikro yang lebih kecil, pengembang dapat mengelola kompleksitas dengan lebih baik, meningkatkan kemampuan untuk melakukan perubahan, dan mempercepat siklus pengembangan.

 

Contoh Arsitektur Microservices


AUvz23M.png


Pada gambar diatas adalah contoh arsitektur microservices dimana terdapat banyak service yang saling berkaitan namun masing - masing service berdiri sendiri.

 

Bagaimana Microservices berkomunikasi dengan service lain?


BIkvlps.png


Ada banyak cara supaya antar service bisa saling berkomunikasi contohnya adalah menggunakan:

  • HTTP, kita bisa mengakses menggunakan HTTP jika service menyediakan expose untuk HTTP
  • Message Brocker (Event Drivern Architecture) misal menggunakan Nats, Kafka, Rabbit MQ, dll
  • RPC (Remote Procedure Call)


Pada contoh kali ini kita akan menggunakan RPC sebagai metode komunikasi antar service.


Kita akan menggunakan GRPC (Google Remote Procedure Call) yang kembangkan oleh google.

 

Apa itu GRPC?


gRPC adalah sebuah kerangka kerja (framework) open-source yang digunakan untuk membuat aplikasi terdistribusi berbasis layanan dengan menggunakan Remote Procedure Call (RPC). RPC adalah protokol yang memungkinkan komunikasi antara komponen aplikasi yang berjalan pada komputer yang berbeda melalui jaringan.


gRPC menggunakan protokol komunikasi HTTP/2 sebagai dasar untuk mentransfer data antara klien dan server. Ini berarti gRPC dapat mengambil keuntungan dari fitur-fitur canggih yang disediakan oleh HTTP/2 seperti multiplexing, kompresi header, dan streaming.


gRPC sering digunakan dalam pengembangan aplikasi yang memerlukan komunikasi antara komponen yang terdistribusi secara efisien dan handal. Misalnya, dalam sistem mikroservis, gRPC dapat digunakan untuk menghubungkan antara layanan mikro yang berbeda.

 

Implementasi Microservices menggunakan GRPC Framework Nest JS

 

Buat Project Nest JS Monorepo


Kali ini kita akan membuat Project Nest JS menggunakan Monorepo artinya satu repo terdiri dari banyak service yang berdiri sendiri.


Jika belum memahami arsitektur Monorepo silahakan buka https://www.mistercoding.com/post/perbedaan-monorepo-dan-multi-repo

 

Buat Project menggunakan Nest CLI


Pertama buka terminal dan jalankan perintah

nest new latihan-microservices-grpc


Setelah itu kita akan menjadikan aplikasi Nest menjadi Monorepo


Kurang lebih aplikasi kita akan seperti berikut ini:


H3fsssz.png


Buat service app1, app2, app3


Masuk kedalam project "latihan-microservices-grpc"

cd latihan-microservices-grpc


Kemudian buat service app1, app2,app2 dengan menjalankan perintah:

 

nest g app app1

 

nest g app app2

 

nest g app app3


Maka struktur folder menjadi seperti


Lxot9hn.png

 

Install Dependency


Jalankan perintah

yarn add @nestjs/microservices @grpc/grpc-js @grpc/proto-loader

 

Buat Proto FIle


fh5H0wU.png


proto/app1/app1.proto

syntax = "proto3";

package app1;

service HeroesService {
  rpc FindOne (HeroById) returns (HeroApp) {}
}

message HeroById {
  int32 id = 1;
}

message HeroApp {
  string app = 1;
  Hero data = 2;
}

message Hero {
  int32 id = 1;
  string name = 2;
}

 

Konfigurasi gRPC app1


edit apps/app1/main.ts menjadi

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

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    App1Module,
    {
      transport: Transport.GRPC,
      options: {
        url:"0.0.0.0:50001",
        package: 'app1',
        protoPath: process.cwd() + '/proto/app1/app1.proto',
      },
    },
  );
  app.listen();
}
bootstrap();



edit apps/app1/src/app1.controller.ts

import { Controller, Get } from '@nestjs/common';
import { App1Service } from './app1.service';
import { GrpcMethod } from '@nestjs/microservices';
import { Metadata, ServerUnaryCall } from '@grpc/grpc-js';

@Controller()
export class App1Controller {
  constructor(private readonly app1Service: App1Service) {}

  @Get()
  getHello(): string {
    return this.app1Service.getHello();
  }

  @GrpcMethod('HeroesService', 'FindOne')
  async findOne(
    data: any,
    metadata: Metadata,
    call: ServerUnaryCall<any, any>,
  ) {
    const items = [
      { id: 1, name: 'John' },
      { id: 2, name: 'Doe' },
    ];
    return {
      app: 'app1',
      data: items.find(({ id }) => id === data.id),
    };
  }
}


 

Jalankan service app1


Jalankan servie app1 menggunakan CLI

yarn start:dev app1

 

Testing Grpc dari API Gateway (Main Service)


Buka dan edit file "apps/latihan-microservice-grpc/src/app.module.ts

 

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

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'APP1',
        transport: Transport.GRPC,
        options: {
          url:"0.0.0.0:50001",
          package: 'app1',
          protoPath: process.cwd() + '/proto/app1/app1.proto',
        },
      },
    ]),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

 

Buat API pada API Gateway untuk memanggil service app1


Edit app.controller

import { Controller, Get, Inject, OnModuleInit } from '@nestjs/common';
import { AppService } from './app.service';
import { Observable } from 'rxjs';
import { ClientGrpc } from '@nestjs/microservices';

interface HeroesService {
  findOne(data: { id: number }): Observable<any>;
}

@Controller()
export class AppController implements OnModuleInit {
  private heroesService: HeroesService;

  constructor(
    @Inject('APP1') private client: ClientGrpc,
    private readonly appService: AppService,
  ) {}

  onModuleInit() {
    this.heroesService = this.client.getService<HeroesService>('HeroesService');
  }

  @Get()
  getHello(): string {
    return this.appService.getHello();
  }

  @Get('hero1')
  async getHero() {
    return await this.heroesService.findOne({ id: 1 });
  }
}

 

Test hit API menggunakan postman


4IpfWHh.png


Selamat, kita sudah berhasil membuat Nest JS Microservices menggunakan GRPC.


Untuk App2, App3, cara nya sama seperti cara di atas.

bMVQkkC.png


KCH3eM7.png

 

Repository

https://github.com/mister-coding/nestjs-microservices-grpc

Artikel Terkait

Berkenalan dengan NestJS dan cara install NestJS

Pada tutorial kali ini kita akan berkenalan dengan NestJS, memahami cara kerja NestJS dan cara menginstall NestJS

Mister Coding

© 2023 PT Koding Digital Indonesia. All rights reserved

Company

Privacy PolicyTerms & Condition