Implementing Microservices in NestJS

Examples of Microservices

Key Characteristics of Microservices

Each microservice:

This architecture improves scalability, maintainability, and fault isolation, making it ideal for modern distributed applications.

Monolithic Application

A monolithic application is built as a single, large project where all features are tightly coupled.

Microservices Application

A microservices-based application is composed of multiple small, independent services, each handling a specific responsibility.

Monolith vs Microservices Comparison

Choosing microservices improves scalability, flexibility, and deployment speed, especially for large and growing applications.

What We Will Build

We will create four applications:

Step 1: Install NestJS CLI

npm i -g @nestjs/cli							
							

Choose npm or yarn and enable TypeScript.

Step 2: Create Four NestJS Applications

Step 3: Configure User Microservice Transport

Open user-service/src/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.createMicroservice(
    AppModule,
    {
      transport: Transport.TCP,
      options: {
        host: '127.0.0.1',
        port: 3001,
      },
    },
  );

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

Step 4: Create Message Handler

Open user-service/src/app.controller.ts

import { Controller } from '@nestjs/common';
import { MessagePattern } from '@nestjs/microservices';

@Controller()
export class AppController {

  @MessagePattern({ cmd: 'get_users' })
  getUsers() {
    return [
      { id: 1, name: 'Amit' },
      { id: 2, name: 'Rahul' },
    ];
  }
}			
							

Here,@MessagePattern works like a route, but for messages.

Step 5: Configure Order Service

Open order-service/src/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.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.TCP,
      options: {
        host: '127.0.0.1',
        port: 3002,
      },
    },
  );

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

Step 6: Create Message Handler

Open order-service/src/app.controller.ts

import { Controller } from '@nestjs/common';
import { MessagePattern } from '@nestjs/microservices';

@Controller()
export class AppController {

  @MessagePattern({ cmd: 'get_orders' })
  getOrders() {
    return [
      { id: 1, item: 'Laptop' },
      { id: 2, item: 'Phone' },
    ];
  }
}
							

Order Service listens on port 3002 and handles order-related data.

Step 7: Configure Payment Service

Open payment-service/src/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.createMicroservice(
    AppModule,
    {
      transport: Transport.TCP,
      options: {
        host: '127.0.0.1',
        port: 3003,
      },
    },
  );

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

Step 8: Create Message Handler

Open payment-service/src/app.controller.ts

import { Controller } from '@nestjs/common';
import { MessagePattern } from '@nestjs/microservices';

@Controller()
export class AppController {

  @MessagePattern({ cmd: 'get_payments' })
  getPayments() {
    return [
      { id: 1, amount: 5000, status: 'SUCCESS' },
      { id: 2, amount: 2000, status: 'PENDING' },
    ];
  }
}
							

Payment Service listens on port 3003 and manages payment-related data.

Step 9: Install Microservices Package

npm install @nestjs/microservices
							

Step 10: Connect to Microservices Projects

Open api-gateway/src/app.module.ts

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

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'USER_SERVICE',
        transport: Transport.TCP,
        options: { host: '127.0.0.1', port: 3001 },
      },
      {
        name: 'ORDER_SERVICE',
        transport: Transport.TCP,
        options: { host: '127.0.0.1', port: 3002 },
      },
      {
        name: 'PAYMENT_SERVICE',
        transport: Transport.TCP,
        options: { host: '127.0.0.1', port: 3003 },
      },
    ]),
  ],
  controllers: [AppController],
})
export class AppModule {}
							

Step 11: Send Message to Microservice from API Gateway

Open api-gateway/src/app.controller.ts

import { Controller, Get, Inject } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';
import { firstValueFrom } from 'rxjs';

@Controller()
export class AppController {
  constructor(
    @Inject('USER_SERVICE') private userService: ClientProxy,
    @Inject('ORDER_SERVICE') private orderService: ClientProxy,
    @Inject('PAYMENT_SERVICE') private paymentService: ClientProxy,
  ) {}

  @Get('users')
  getUsers() {
    return firstValueFrom(
      this.userService.send({ cmd: 'get_users' }, {}),
    );
  }

  @Get('orders')
  getOrders() {
    return firstValueFrom(
      this.orderService.send({ cmd: 'get_orders' }, {}),
    );
  }

  @Get('payments')
  getPayments() {
    return firstValueFrom(
      this.paymentService.send({ cmd: 'get_payments' }, {}),
    );
  }
}
							

Step 12: Run the Applications

# terminal 1

cd user-service
npm run start							
							

# terminal 2

cd order-service
npm run start
							

# terminal 3

cd payment-service
npm run start							
							

# terminal 4

cd api-gateway
npm run start							
							

Open browser:

Now you will see user data coming from the microservice, like

#1 For User

#2 For Orders

#3 For Payments