Redis transport in NestJS - Mini Project: Build & Apply

NestJS Redis Transport Setup

📖 Scenario: You are building a simple NestJS microservice that communicates using Redis as the transport layer. Redis will help your microservice send and receive messages efficiently.

🎯 Goal: Create a NestJS microservice that uses Redis transport. You will set up the Redis client, configure the microservice options, and start the microservice to listen for messages.

📋 What You'll Learn

Create a Redis client options object with the correct Redis URL

Create a microservice options object using Redis transport and the Redis client options

Use the NestFactory to create a microservice with the Redis options

Start the microservice to listen for incoming messages

💡 Why This Matters

🌍 Real World

Redis transport is used in microservices to enable fast, scalable communication between services in real-world applications like chat apps, notifications, and data processing pipelines.

💼 Career

Understanding Redis transport in NestJS is valuable for backend developers working on microservices architecture, improving system scalability and performance.

1

Create Redis client options

Create a constant called redisClientOptions and set it to an object with a url property equal to 'redis://localhost:6379'.

NestJS

# Your code here

Hint

Use const redisClientOptions = { url: 'redis://localhost:6379' }; to set the Redis URL.

2

Create microservice options with Redis transport

Create a constant called microserviceOptions and set it to an object with transport set to Transport.REDIS and options set to redisClientOptions.

NestJS

const redisClientOptions = { url: 'redis://localhost:6379' };
# Your code here

Hint

Use const microserviceOptions = { transport: Transport.REDIS, options: redisClientOptions }; to configure Redis transport.

3

Create the NestJS microservice

Use NestFactory.createMicroservice with AppModule and microserviceOptions. Assign the result to a constant called app. Import Transport from @nestjs/microservices and AppModule from ./app.module.

NestJS

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

const redisClientOptions = { url: 'redis://localhost:6379' };

const microserviceOptions = { transport: Transport.REDIS, options: redisClientOptions };

# Your code here

Hint

Use const app = await NestFactory.createMicroservice(AppModule, microserviceOptions); inside an async function.

4

Start the microservice

Inside the bootstrap async function, call await app.listen() to start the microservice.

NestJS

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

const redisClientOptions = { url: 'redis://localhost:6379' };

const microserviceOptions = { transport: Transport.REDIS, options: redisClientOptions };

async function bootstrap() {
  const app = await NestFactory.createMicroservice(AppModule, microserviceOptions);
  # Your code here
}

bootstrap();

Hint

Call await app.listen(); to start the microservice.

Practice

1. What is the main purpose of using Redis transport in a NestJS microservice?

easy

A. To cache HTTP responses automatically

B. To store application data persistently in Redis

C. To replace the HTTP server with Redis server

D. To enable communication between microservices using Redis as a message broker

Solution

1. Step 1: Understand Redis transport role

   Redis transport in NestJS is designed to let microservices send and receive messages through Redis as a broker.

2. Step 2: Differentiate from data storage or caching

   Redis transport is not for storing data or caching HTTP responses; it is for messaging between services.

3. Final Answer:

   To enable communication between microservices using Redis as a message broker -> Option D

4. Quick Check:

   Redis transport = message broker communication [OK]

Hint: Redis transport is for messaging, not data storage or caching [OK]

Common Mistakes:

• Confusing Redis transport with Redis database usage
• Thinking Redis transport replaces HTTP server
• Assuming Redis transport caches HTTP responses

2. Which of the following is the correct way to configure a NestJS microservice to use Redis transport?

easy

A. app.connectMicroservice({ transport: Transport.REDIS, options: { url: 'redis://localhost:6379' } })

B. app.connectMicroservice({ transport: Transport.HTTP, options: { url: 'redis://localhost:6379' } })

C. app.connectMicroservice({ transport: Transport.REDIS, options: { host: 'localhost', port: 8080 } })

D. app.connectMicroservice({ transport: Transport.TCP, options: { url: 'redis://localhost:6379' } })

Solution

1. Step 1: Identify correct transport type

   Transport.REDIS is the correct transport for Redis messaging in NestJS.

2. Step 2: Check Redis connection options

   The Redis connection URL should be provided as url: 'redis://localhost:6379' inside options.

3. Final Answer:

   app.connectMicroservice({ transport: Transport.REDIS, options: { url: 'redis://localhost:6379' } }) -> Option A

4. Quick Check:

   Transport.REDIS with Redis URL = correct config [OK]

Hint: Use Transport.REDIS and provide Redis URL in options [OK]

Common Mistakes:

• Using wrong transport type like HTTP or TCP
• Providing Redis host and port instead of URL
• Using incorrect port number for Redis

3. Given the following NestJS microservice code using Redis transport, what will be the output when a message with pattern 'sum' and data { a: 5, b: 3 } is sent?

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

@Controller()
export class MathController {
  @MessagePattern('sum')
  sum(data: { a: number; b: number }) {
    return data.a + data.b;
  }
}

medium

A. { a: 5, b: 3 }

B. 53

C. 8

D. undefined

Solution

1. Step 1: Understand @MessagePattern handler

   The method listens for messages with pattern 'sum' and receives data object with properties a and b.

2. Step 2: Calculate the sum

   The method returns the sum of data.a and data.b, which is 5 + 3 = 8.

3. Final Answer:

   8 -> Option C

4. Quick Check:

   5 + 3 = 8 [OK]

Hint: Add the numbers from data object in the handler [OK]

Common Mistakes:

• Concatenating numbers as strings instead of adding
• Returning the whole data object instead of sum
• Not matching the message pattern correctly

4. Identify the error in this NestJS Redis microservice setup:

app.connectMicroservice({
  transport: Transport.REDIS,
  options: {
    host: 'localhost',
    port: 6379
  }
});

app.listen();

medium

A. Incorrect Redis options; should use 'url' instead of 'host' and 'port'

B. Missing await before app.listen()

C. Transport.REDIS is invalid; should use Transport.TCP

D. app.connectMicroservice should be called after app.listen()

Solution

1. Step 1: Check Redis transport options format

   Redis transport expects a single connection string URL, not separate host and port keys.

2. Step 2: Confirm correct usage

   The correct option is to provide url: 'redis://localhost:6379' inside options.

3. Final Answer:

   Incorrect Redis options; should use 'url' instead of 'host' and 'port' -> Option A

4. Quick Check:

   Redis options require URL string [OK]

Hint: Use Redis URL string in options, not separate host/port [OK]

Common Mistakes:

• Using separate host and port keys for Redis options
• Calling app.listen() before connecting microservice
• Confusing Transport.REDIS with Transport.TCP

5. You want to create a NestJS microservice using Redis transport that listens for a message pattern 'multiply' and returns the product of two numbers. Which code snippet correctly implements this with proper Redis connection and message handling?

hard

A. const app = await NestFactory.createMicroservice(AppModule, {
transport: Transport.TCP,
options: { host: 'localhost', port: 6379 }
});

@Controller()
export class MathController {
@MessagePattern('multiply')
multiply(data: { x: number; y: number }) {
return data.x + data.y;
}
}

await app.listen();

B. const app = await NestFactory.createMicroservice(AppModule, {
transport: Transport.REDIS,
options: { url: 'redis://localhost:6379' }
});

@Controller()
export class MathController {
@MessagePattern('multiply')
multiply(data: { x: number; y: number }) {
return data.x * data.y;
}
}

await app.listen();

C. const app = await NestFactory.createMicroservice(AppModule, {
transport: Transport.REDIS,
options: { host: 'localhost', port: 6379 }
});

@Controller()
export class MathController {
@MessagePattern('multiply')
multiply(data: { x: number; y: number }) {
return data.x * data.y;
}
}

await app.listen();

D. const app = await NestFactory.createMicroservice(AppModule, {
transport: Transport.REDIS,
options: { url: 'redis://localhost:6379' }
});

@Controller()
export class MathController {
@MessagePattern('multiply')
multiply(data: { x: number; y: number }) {
return data.x - data.y;
}
}

await app.listen();

Solution

1. Step 1: Verify Redis transport and connection options

   const app = await NestFactory.createMicroservice(AppModule, { transport: Transport.REDIS, options: { url: 'redis://localhost:6379' } }); @Controller() export class MathController { @MessagePattern('multiply') multiply(data: { x: number; y: number }) { return data.x * data.y; } } await app.listen(); correctly uses Transport.REDIS with a Redis URL string in options.

2. Step 2: Check message handler logic

   The multiply method correctly returns the product of x and y, matching the 'multiply' pattern.

3. Step 3: Confirm app lifecycle

   App is created as microservice and listens properly with await app.listen().

4. Final Answer:

   const app = await NestFactory.createMicroservice(AppModule, { transport: Transport.REDIS, options: { url: 'redis://localhost:6379' } }); @Controller() export class MathController { @MessagePattern('multiply') multiply(data: { x: number; y: number }) { return data.x * data.y; } } await app.listen(); -> Option B

5. Quick Check:

   Transport.REDIS + correct URL + multiply logic = const app = await NestFactory.createMicroservice(AppModule, { transport: Transport.REDIS, options: { url: 'redis://localhost:6379' } }); @Controller() export class MathController { @MessagePattern('multiply') multiply(data: { x: number; y: number }) { return data.x * data.y; } } await app.listen(); [OK]

Hint: Use Transport.REDIS with URL and multiply numbers in handler [OK]

Common Mistakes:

• Using Transport.TCP instead of REDIS
• Providing host and port instead of URL for Redis
• Incorrect arithmetic operation in handler