Redis transport in NestJS - Step-by-Step Execution

Concept Flow - Redis transport

NestJS Microservice Setup

↓

Configure Redis Transport

↓

Connect to Redis Server

↓

Send/Receive Messages

↓

Handle Messages in Handlers

↓

Process Response or Event

↓

End

This flow shows how a NestJS microservice uses Redis transport to connect, send, receive, and handle messages.

Execution Sample

NestJS

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

This code creates a NestJS microservice using Redis transport and connects to a Redis server.

Execution Table

Step	Action	Evaluation	Result
1	Create microservice with Redis transport	Transport.REDIS and options.url set	Microservice instance created, ready to connect
2	Connect to Redis server	Attempt connection to redis://localhost:6379	Connection established successfully
3	Listen for messages	Waiting for incoming messages	Microservice ready to receive messages
4	Receive message from client	Message received on Redis channel	Handler invoked with message payload
5	Process message in handler	Handler logic executed	Response or event sent back via Redis
6	Send response/event	Message published to Redis channel	Client receives response or event
7	Microservice continues listening	Loop back to waiting for messages	Ready for next message
8	Shutdown microservice	Stop listening and disconnect	Redis connection closed, microservice stopped

💡 Microservice stops when shutdown is called or process ends

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 4	After Step 6	Final
app	undefined	Microservice instance	Connected instance	Listening instance	Response sent	Closed

Key Moments - 3 Insights

Why does the microservice need the Redis URL in options?

The Redis URL tells the microservice where to connect. Without it, the connection cannot be established (see Step 2 in execution_table).

What happens if the Redis server is not running when connecting?

The connection attempt will fail, and the microservice cannot listen or send messages. This stops progress at Step 2.

How does the microservice know when a message arrives?

It listens on Redis channels and triggers handlers when messages arrive (Step 4 and 5). This is automatic after connection.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'app' after Step 2?

A Response sent

B Microservice instance created but not connected

C Connected instance

D Closed

💡 Hint

Check variable_tracker column 'After Step 2' for 'app' value

At which step does the microservice start listening for messages?

A Step 3

B Step 1

C Step 5

D Step 7

💡 Hint

Look at execution_table row describing 'Listen for messages'

If the Redis URL is incorrect, which step will fail?

A Step 1

B Step 2

C Step 3

D Step 6

💡 Hint

Connection to Redis server happens at Step 2

Concept Snapshot

NestJS Redis Transport Quick Guide:
- Use Transport.REDIS in microservice options
- Provide Redis URL (e.g., redis://localhost:6379)
- Microservice connects to Redis server
- Listens and sends messages via Redis channels
- Handlers process incoming messages
- Shutdown closes Redis connection cleanly

Full Transcript

This visual execution trace shows how a NestJS microservice uses Redis transport. First, the microservice is created with Redis transport and a Redis URL. Then it connects to the Redis server. Once connected, it listens for messages on Redis channels. When a message arrives, the handler processes it and sends a response or event back through Redis. The microservice continues listening until it is shut down, which closes the Redis connection. Key points include the importance of the Redis URL for connection, the automatic listening for messages after connection, and the message handling flow.

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