Implementing Microservices in Node.js with NestJS: Concepts, Benefits, and Step‑by‑Step Guide

What Is Microservices

Microservices are an application architecture that isolates each functional component into its own loosely‑coupled service, allowing independent deployment and scaling, and addressing the complexity of monolithic web applications.

When Should You Use Microservices?

Microservices solve rapid development challenges for large, complex applications, but the decision depends on specific trade‑offs. Advantages include language agnosticism, scalability, unlimited iteration, and easier unit testing; disadvantages involve management difficulty, tracing issues, required expertise, testing challenges, and audit‑log complexities.

Microservice Communication

Because services are independent, choosing the right communication protocol is crucial. Two main styles exist: synchronous (request‑response) and asynchronous (event‑driven). Options include HTTP/REST, HTTP/2, WebSocket, TCP sockets, and UDP packets.

Why Use Node.js for Microservices?

Node.js offers a single‑threaded, asynchronous event‑loop model, event‑driven architecture, high performance via the V8 engine, and rapid development thanks to extensive abstractions, making it well‑suited for building scalable microservices.

Implementing a Microservice Architecture

The example builds a user‑management microservice that communicates via TCP packets. NestJS is used as the framework, leveraging its built‑in microservice features.

Step 1: Set Up the Microservice

Create a new NestJS project and install the microservices package.

npx @nestjs/cli new user-microservice

npm i --save @nestjs/microservices

Update main.ts to start a TCP microservice:

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

async function bootstrap() {
  const microservicesOptions: any = {
    transport: Transport.TCP,
    options: { host: '127.0.0.1', port: 8875 },
  };
  const app: INestMicroservice = await NestFactory.createMicroservice(
    AppModule,
    microservicesOptions,
  );
  app.listen(() => console.log('Microservice is listening'));
}
bootstrap();

Step 2: Listen for Messages

Define a message pattern for creating a user and a DTO for validation.

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

  @MessagePattern('create_user')
  async createUser(@Payload() payload: CreateUserDto) {
    const user = await this.appService.createUser(payload);
    return user;
  }
}

import { IsString, IsEmail } from 'class-validator';

export class CreateUserDto {
  @IsEmail()
  email: string;

  @IsString()
  password: string;
}

Step 3: Test the Microservice

Use the free tool PacketSender to send a TCP packet (length 122) with a JSON payload containing an email and password. The microservice logs the received request and returns the created user object.

Step 4: API Gateway

Create a separate NestJS application that acts as an API gateway. Configure a client proxy to the user microservice using environment variables.

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ConfigService } from "./config/config.service";

@Module({
  imports: [],
  controllers: [AppController],
  providers: [
    {
      provide: 'USER_MICROSERVICE',
      useFactory: (configService: ConfigService) => {
        const options = {
          transport: Transport.TCP,
          options: {
            host: configService.get('USERS_MICROSERVICE_HOST'),
            port: Number(configService.get('USERS_MICROSERVICE_PORT')),
          },
        };
        return ClientProxyFactory.create(options as ClientOptions);
      },
      inject: [ConfigService],
    },
    AppService,
  ],
})
export class AppModule {}

Inject the client proxy into a controller to forward POST requests to the microservice:

@Controller()
export class AppController {
  constructor(
    @Inject('USER_MICROSERVICE') private readonly client: ClientProxy,
    private readonly appService: AppService,
  ) {}

  @Post('create-user')
  async createUser(@Body() payload: CreateUserDto) {
    return this.client.send('create_user', payload).toPromise();
  }
}

With the gateway in place, external clients can create users via a simple HTTP endpoint while the underlying business logic runs in the isolated microservice.

END