Implementing Microservices in NestJS Using Redis

Introduction

Microservices architecture enables building applications as a collection of loosely coupled, independently deployable services. In this project, we will implement NestJS microservices and use Redis as a message broker to handle communication between services.

This setup demonstrates both request–response and event-driven messaging patterns, ensuring that services remain independent, scalable, and easy to maintain. Using Redis simplifies message passing while providing a lightweight and fast solution for microservices communication.

What is Redis?

Redis is an open-source, in-memory data structure store that can function as a database, cache, and message broker. It is widely used in modern applications for its speed and simplicity.

Redis is especially useful in microservices architectures for event-driven communication, caching frequently accessed data, and handling lightweight message queues.

Why Use Redis in Microservices?

Using Redis as a message broker provides several benefits:

Note: Redis is simpler than Kafka and not as durable. It's perfect for learning, prototypes, and many real-world apps where high durability is not critical.

What We Will Build

In this tutorial, we will create four NestJS microservices that communicate via Redis:

Redis will serve as the message broker, enabling both request–response and event-driven Pub/Sub communication between services.

Architecture Overview (Redis)

Prerequisites

Step 1: Install NestJS CLI

npm i -g @nestjs/cli					

Choose npm or yarn and enable TypeScript.

Step 2: Create NestJS Applications

Step 3: Install Redis Dependencies

Run this in ALL four projects:

npm install @nestjs/microservices ioredis					

Step 4: Install & Run Redis (Without Docker – Windows Friendly)

Redis does not officially support native Windows installers anymore, but a stable, production-tested Windows build is available and widely used for development.

We will install Redis using a ZIP package.

cd C:\Redis
redis-server.exe						

cd C:\Redis
redis-cli.exe
ping					

Redis is now running at localhost:6379.

Step 5: Create User Service (Redis Consumer)

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<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.REDIS,
      options: {
        host: 'localhost',
        port: 6379,
      },
    },
  );

  await app.listen();
  console.log('User Service running with Redis');
}
bootstrap();				

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

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

@Controller()
export class AppController {

  @MessagePattern('get_users')
  getUsers() {
    console.log('Redis get_users event received');
    return [
      { id: 1, name: 'Amit' },
      { id: 2, name: 'Rahul' },
    ];
  }
}				

Step 6: Create Order Service (Redis Consumer)

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.REDIS,
      options: {
        host: 'localhost',
        port: 6379,
      },
    },
  );

  await app.listen();
  console.log('Order Service running with Redis');
}
bootstrap();					

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

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

@Controller()
export class AppController {

  @MessagePattern('get_orders')
  getOrders() {
    console.log('Redis get_orders event received');
    return [
      { id: 1, item: 'Laptop' },
      { id: 2, item: 'Phone' },
    ];
  }
}					

Step 7: Create Payment Service (Redis Consumer)

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<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.REDIS,
      options: {
        host: 'localhost',
        port: 6379,
      },
    },
  );

  await app.listen();
  console.log('Payment Service running with Redis');
}
bootstrap();					

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

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

@Controller()
export class AppController {

  @MessagePattern('get_payments')
  getPayments() {
    console.log('Redis get_payments event received');
    return [
      { id: 1, amount: 5000, status: 'SUCCESS' },
      { id: 2, amount: 2000, status: 'PENDING' },
    ];
  }
}					

Step 8: API Gateway (Redis Client)

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.REDIS,
        options: { host: 'localhost', port: 6379 },
      },
      {
        name: 'ORDER_SERVICE',
        transport: Transport.REDIS,
        options: { host: 'localhost', port: 6379 },
      },
      {
        name: 'PAYMENT_SERVICE',
        transport: Transport.REDIS,
        options: { host: 'localhost', port: 6379 },
      },
    ]),
  ],
  controllers: [AppController],
})
export class AppModule {}					

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 readonly userService: ClientProxy,
    @Inject('ORDER_SERVICE') private readonly orderService: ClientProxy,
    @Inject('PAYMENT_SERVICE') private readonly paymentService: ClientProxy,
  ) {}

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

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

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

Step 9: Run Applications (Order Matters)

Step 10: Test in Browser

Now you will see data coming from the microservice, like

#1 For User

#2 For Orders

#3 For Payments

What Happens If One Service Stops?

Loose coupling achieved

Redis vs Kafka vs gRPC: Comparison for Microservices

Conclusion

In this project, we: