### **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.

&nbsp;
### **Contoh Arsitektur Microservices**

\
![AUvz23M.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/A_Uvz23_M_39f5010294.png)

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

&nbsp;
### **Bagaimana Microservices berkomunikasi dengan service lain?**

\
![BIkvlps.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/B_Ikvlps_0efedff204.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.


&nbsp;
### **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.

&nbsp;
### **Implementasi Microservices menggunakan GRPC Framework Nest JS**

&nbsp;
#### **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](https://www.mistercoding.com/post/perbedaan-monorepo-dan-multi-repo)

&nbsp;
#### **Buat Project menggunakan Nest CLI**

\
Pertama buka terminal dan jalankan perintah

```shell
nest new latihan-microservices-grpc
```

\
Setelah itu kita akan menjadikan aplikasi Nest menjadi Monorepo

\
Kurang lebih aplikasi kita akan seperti berikut ini:

\
![H3fsssz.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/H3fsssz_e87fc5fbe7.png)

\
Buat service app1, app2, app3

\
Masuk kedalam project "latihan-microservices-grpc"


```shell
cd latihan-microservices-grpc
```

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

&nbsp;
```shell
nest g app app1
```

&nbsp;
```shell
nest g app app2
```

&nbsp;
```shell
nest g app app3
```

\
Maka struktur folder menjadi seperti

\
![Lxot9hn.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/Lxot9hn_953e1f2672.png)

&nbsp;
### **Install Dependency**

\
Jalankan perintah

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

&nbsp;
### **Buat Proto FIle**

\
![fh5H0wU.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/fh5_H0w_U_343be34f76.png)

\
proto/app1/app1.proto
```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;
}
```

&nbsp;
### **Konfigurasi gRPC app1**

\
 edit apps/app1/main.ts menjadi
```typescript
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
```typescript
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),
    };
  }
}


```

&nbsp;
### **Jalankan service app1**

\
Jalankan servie app1 menggunakan CLI

```shell
yarn start:dev app1
```

&nbsp;
### **Testing Grpc dari API Gateway (Main Service)**

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

&nbsp;
```typescript
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 {}

```

&nbsp;
### **Buat API pada API Gateway untuk memanggil service app1**

\
Edit app.controller

```typescript
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 });
  }
}

```

&nbsp;
### **Test hit API menggunakan postman**

\
![4IpfWHh.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/4_Ipf_W_Hh_fb92cf226c.png)

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

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

![bMVQkkC.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/b_MV_Qkk_C_5892c397b9.png)

\
![KCH3eM7.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/KCH_3e_M7_97f34f7f8f.png)

&nbsp;
### **Repository**

[https://github.com/mister-coding/nestjs-microservices-grpc](https://github.com/mister-coding/nestjs-microservices-grpc)


NestJS adalah sebuah framework untuk membuat aplikasi server-side (back-end) dengan menggunakan bahasa pemrograman TypeScript, yang dibangun di atas platform Node.js.

Kita akan belajar bagaimana membuat aplikasi microservices menggunakan Nest JS dan GRPC menggunakan Monorepo (Single Repository)

large_POpmjXf.png

medium_POpmjXf.png

small_POpmjXf.png

thumbnail_POpmjXf.png

POpmjXf.png

Nest JS Micoservices with GRPC and Monorepo

## **Apa itu Rate Limiter?**

\
Rate limiter adalah sebuah mekanisme yang digunakan untuk mengatur laju atau frekuensi akses terhadap suatu sumber daya atau layanan. Tujuannya adalah untuk mencegah penyalahgunaan atau kelebihan beban terhadap sistem tersebut.

\
Rate limiter berfungsi untuk membatasi jumlah permintaan yang diterima dalam periode waktu tertentu, sehingga pengguna atau aplikasi tidak dapat mengakses sumber daya atau layanan secara tidak terbatas.

\
Rate limiter dapat diterapkan dalam berbagai konteks, seperti API (Application Programming Interface), aplikasi web, atau layanan jaringan. Misalnya, dalam konteks API, rate limiter digunakan untuk membatasi jumlah permintaan API yang dapat dilakukan oleh pengguna dalam periode waktu tertentu. Dengan adanya rate limiter, pengguna tidak dapat secara berlebihan mengakses API dan mengganggu kinerja sistem atau menghabiskan sumber daya secara tidak perlu.

\
Rate limiter umumnya diterapkan dengan mengatur jumlah permintaan maksimum yang dapat diterima dalam periode waktu tertentu, seperti jumlah permintaan per detik atau per menit. Jika batas tersebut tercapai, permintaan tambahan akan ditolak atau tertunda hingga periode waktu berikutnya dimulai.

\
Implementasi rate limiter dapat dilakukan menggunakan berbagai teknik, seperti token bucket, leaky bucket, atau sliding window. Pilihan teknik implementasi tergantung pada kebutuhan dan karakteristik sistem yang digunakan.

\
Dengan adanya rate limiter, sistem dapat menjaga ketersediaan dan kinerja yang baik, serta melindungi sumber daya atau layanan dari penyalahgunaan atau serangan DDoS (Distributed Denial of Service).

&nbsp;
## **Implementasi Rate Limiting Nest JS**

&nbsp;
### Buat Project Nest JS

\
Jalankan perintah

```shell
nest new nest-rate-limiting
```

\
Masuk kedalam project

```shell
cd nest-rate-limiting
```

&nbsp;
### Install Package

```shell
yarn add @nestjs/throttler
```

\
**Edit module (app.module.ts)**

```typescript
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
import { APP_GUARD } from '@nestjs/core';

@Module({
  imports: [
    ThrottlerModule.forRoot({
      ttl: 60,
      limit: 10,
    }),
  ],
  controllers: [AppController],
  providers: [
    AppService,

    {
      provide: APP_GUARD,
      useClass: ThrottlerGuard,
    },
  ],
})
export class AppModule {}

```

\
Baris code
```typescript
{
      provide: APP_GUARD,
      useClass: ThrottlerGuard,
    },
```

\
Artinya adalah memasang Guard secara global di dalam module.

\
Kita juga bisa memasang berdasarkan Controller.

\
```typescript
import { Controller, Get, UseGuards } from '@nestjs/common';
import { AppService } from './app.service';
import { Throttle, ThrottlerGuard } from '@nestjs/throttler';

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

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

```

\
Ada dua parameter yang dimasukan yaitu
* ttl (Time to live)
* limit

\
TTL di gunakan untuk membatasi dalam satuan waktu (detik).

\
Limit digunakan untuk membatasi jumlah reuest.

\
Pada contoh diatas artinya dalam waktu 60 detik hanya boleh melakukan reuest sebanyak 10.

\
Pada konfigurasi diatas akan digunakan secara global. kita bisa juga  memberikan kontrol berdasarkan controller seperti dibawah ini:

```typescrip
@Throttle(3, 60)
  @UseGuards(ThrottlerGuard)
  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
```

\
Setelah kita request melebihi total yang di ijinkan maka akan seperti dibawah ini

![KvGLMyu.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/Kv_GL_Myu_afe1ec4a0a.png)



Rate limiter adalah sebuah mekanisme yang digunakan untuk mengatur laju atau frekuensi akses terhadap suatu sumber daya atau layanan. Tujuannya adalah untuk mencegah penyalahgunaan atau kelebihan beban terhadap sistem tersebut

large_nest_uitdpt.png

medium_nest_uitdpt.png

small_nest_uitdpt.png

thumbnail_nest_uitdpt.png

nest_uitdpt.png

Rate limiting Nest JS

##  Apa itu Homebrew?
Homebrew adalah sebuah sistem manajemen paket untuk macOS dan juga Linux yang memungkinkan pengguna untuk menginstal dan mengelola perangkat lunak di komputer mereka dengan mudah. Homebrew memungkinkan pengguna untuk menginstal perangkat lunak open-source dan utilitas lainnya yang tidak tersedia secara default di macOS maupun Linux.

\
Dengan Homebrew, pengguna dapat menginstal paket-paket baru dengan perintah sederhana yang dijalankan melalui Terminal. Homebrew akan mengunduh kode sumber paket tersebut, mengompilasinya (jika diperlukan), dan menginstalnya ke sistem pengguna.

\
Keuntungan utama menggunakan Homebrew adalah kemampuannya untuk memperluas fungsionalitas  dengan menginstal paket-paket perangkat lunak yang berguna dan populer dalam komunitas pengembang. Homebrew juga menyediakan mekanisme untuk mengelola pembaruan paket yang telah diinstal, sehingga pengguna dapat dengan mudah memperbarui perangkat lunak yang ada ke versi terbaru.

\
Secara keseluruhan, Homebrew adalah alat yang sangat berguna bagi pengguna macOS mapun Linux yang ingin menginstal perangkat lunak tambahan, memperluas fungsionalitas sistem operasi, atau bekerja dengan proyek pengembangan perangkat lunak yang mengandalkan dependensi tertentu.


## Install Homebew di Linux Fedora
Pada tutorial kali ini kita akan menginstall Homebrew pada lingkunan Linux Fedora

\
Jalankan
```shell
sudo dnf groupinstall 'Development Tools'
```

dan

```shell
sudo dnf install procps-ng curl file git
```

\
Kemudian jalankan perintah

```shell
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```
\
Setelah itu jalankan perintah

```shell
eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
```

\
Kemudian

```shell
echo "eval \"\$($(brew --prefix)/bin/brew shellenv)\"" >> ~/.bashrc
```

\
Setelah sukses, silahkan test menggunakan terminal

```shell
brew
```

![Wr8phi6.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/Wr8phi6_ec19d22900.png)

\
Setelah sukses menginstall brew, selanjunya kita coba menggunakan brew untuk menginstall paket2.


\
# Install package menggunakan brew

\
Kali ini saya akan menginstall wrk menggunakan brew

\
Jalankan perintah

```shell
brew install wrk
```

\
Tunggu sampai proses installasi selesai

![1s37rgw.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/1s37rgw_3dc823664e.png)

\
Jalankan wrk
```shell
wrk
```

![Mjbh8De.png](https://mrcodingblog.s3.ap-southeast-1.wasabisys.com/Mjbh8_De_74b99d7d1e.png)

Kelas tidak ditmukan