Redis transport in NestJS - Performance & Optimization

Performance: Redis transport

MEDIUM IMPACT

This affects the speed and responsiveness of message passing between microservices or modules in a NestJS application.

Sending messages between microservices using Redis transport

NestJS

@EventPattern('channel')
async processMessage(@Payload() message) {
  await heavyAsyncProcessing(message);
}

Using asynchronous processing frees the event loop, allowing faster handling of incoming messages and better responsiveness.

📈 Performance GainNon-blocking message handling reduces INP and improves throughput.

Sending messages between microservices using Redis transport

NestJS

@EventPattern('channel')
processMessage(@Payload() message) {
  // process message synchronously
  heavySyncProcessing(message);
}

Processing messages synchronously blocks the event loop, causing delays in handling other messages and increasing latency.

📉 Performance CostBlocks event loop during processing, increasing INP and causing slower message throughput.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Synchronous message processing	N/A	N/A	N/A	[X] Bad
Asynchronous message processing	N/A	N/A	N/A	[OK] Good

Rendering Pipeline

Redis transport in NestJS operates outside the browser rendering pipeline but impacts user experience by affecting server responsiveness and interaction latency.

→Message Queueing

→Event Loop Processing

→Network I/O

⚠️ BottleneckEvent Loop Processing when synchronous/blocking code is used

Core Web Vital Affected

INP

This affects the speed and responsiveness of message passing between microservices or modules in a NestJS application.

Optimization Tips

1Avoid synchronous blocking code in Redis message handlers to keep the event loop free.

2Use asynchronous processing to improve message throughput and reduce latency.

3Monitor event loop delays in DevTools Performance panel to detect blocking operations.

Performance Quiz - 3 Questions

What is the main performance risk when using Redis transport with synchronous message handlers in NestJS?

A Increasing DOM reflows in the browser

B Blocking the event loop and increasing message latency

C Adding large bundle size to the frontend

D Causing layout shifts on the page

DevTools: Performance

How to check: Record a session while sending messages and observe the event loop responsiveness and task durations.

What to look for: Look for long tasks blocking the event loop which indicate synchronous processing causing delays.

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