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

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?

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:

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

 

Install Dependency

Jalankan perintah

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

 

Buat Proto FIle

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

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

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

 

Repository

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