Implement RabbitMQ step by step in NestJS application

Implement RabbitMQ step by step in NestJS application

RabbitMQ, a powerful message broker widely used in modern applications, offers robust messaging capabilities that can enhance the scalability and resilience of your NestJS applications. Integrating RabbitMQ with NestJS allows you to build highly decoupled, asynchronous systems that can handle complex workflows efficiently. In this article, we'll explore how to integrate RabbitMQ step by step into a NestJS application.

Prerequisites

Before diving into RabbitMQ integration, ensure you have the following:

Node.js and NestJS: Make sure Node.js and NestJS are installed on your development machine. You can install NestJS globally using npm:
RabbitMQ Server: Install RabbitMQ locally or use a cloud-based service like RabbitMQ on Cloud if you prefer.

HeadingH3

Step 1: Setting Up a NestJS Project

If you haven't already set up a NestJS project, create one using the NestJS CLI:

                            nest new nest-rabbitmq-example
                            cd nest-rabbitmq-example
                          

Also create a module directory and keep your directory like this, this is good for modularized code, you can keep directory as per your choice.

Implement RabbitMQ step by step in NestJS application

Step 2: Install RabbitMQ Client for NestJS

NPM provides a module amqp-connection-manager that integrates seamlessly with RabbitMQ. Install it along with the RabbitMQ transport amqplib:

                            npm install amqp-connection-manager amqplib --save
                        

Step 3: Create RabbitMQ config

src\modules\rabbitmq\constants\rabbitmq-config-constants.ts

                            export const RABBITMQ_CONFIG_CONSTANTS = {
                                MODULE: 'idkblogs-service',
                                EVENT_VERSION: 'v1',
                                PRODUCER: {
                                  EXCHANGE_NAME: 'idkblog-exchange',
                                  ROUTING_KEY: '#',
                                  EXCHANGE_TYPE: 'headers',
                                  PUBLISH_OPTION_CONTENT_TYPE: 'application/json',
                                  CHANNEL_NAME: 'producer',
                                  PS_LISTING_UPDATE_EVENT_NAME: 'idkblogs-event',
                                },
                              }
                              
                        

also add following envs in your ENV files, for me its "local.env"

                        RABBITMQ_USERNAME=guest
                        RABBITMQ_PASSWORD=guest
                        RABBITMQ_HOST=localhost
                        RABBITMQ_VIRTUAL_HOST=idkblogs-host
                    

Step 4: Create DTOs

src\modules\rabbitmq\dto\rabbitmq-dto.ts

                            export class RabbitMQHeadersDTO {
                                cloud: string
                                country: string
                                'event-name': string
                              }
                              
                              export class RabbitMQMessageDTO {
                                event: string
                                'fields_changed': Array<string>
                                time: string
                                data: object
                              }          
                        

Step 5: Create RabbitMQ Producer Service

Create a service to publish messages to RabbitMQ. src\modules\rabbitmq\service\rabbitmq-manager.service.ts

                            import { Injectable, OnModuleInit } from '@nestjs/common'
                            import amqp, { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager'
                            import { Channel, Options  } from 'amqplib'
                            import { ConfigService } from '../../../config/config.service'
                            import { RABBITMQ_CONFIG_CONSTANTS } from '../constants/rabbitmq-config-constants'
                            import { RabbitMQHeadersDTO, RabbitMQMessageDTO } from '../dto/rabbitmq-dto'
                    
                            @Injectable()
                            export class RabbitMQService implements OnModuleInit {
                            private connection: AmqpConnectionManager
                            private channel: ChannelWrapper
                    
                            async onModuleInit() {
                                await this.connect()
                            }
                    
                            async connect() {
                                try {
                                /** You can fetch the rabbitMQ credentials from ENV or your config */
                                const { host, username, password, virtualhost } = ConfigService.getInstance().getRabbitMqConfig()
                                const amqpUrl = `amqp://${username}:${password}@${host}/${virtualhost}`
                                this.connection = amqp.connect(amqpUrl)
                                console.log('RABBIT_MQ_CONNECTION_CREATED_SUCCESSFULLY')
                                } catch (error) {
                                console.log('RABBIT_MQ_CONNECTION_FAILED',error.message)
                                }
                            }
                    
                            async createChannel(): Promise<ChannelWrapper> {
                                const wrapperChannel = this.connection.createChannel({ name: RABBITMQ_CONFIG_CONSTANTS.PRODUCER.CHANNEL_NAME, json: true })
                                await wrapperChannel.waitForConnect()
                    
                                await wrapperChannel.addSetup(async (channel: Channel) => {
                                await channel.assertExchange(
                                    RABBITMQ_CONFIG_CONSTANTS.PRODUCER.EXCHANGE_NAME,
                                    RABBITMQ_CONFIG_CONSTANTS.PRODUCER.EXCHANGE_TYPE,
                                    { durable: true }
                                )
                                })
                    
                                return wrapperChannel
                            }
                    
                            async publish(message: RabbitMQMessageDTO, headers: RabbitMQHeadersDTO) {
                                if (!this.channel) {
                                this.channel = await this.createChannel()
                                }
                    
                                const options: Options.Publish = {
                                contentType: RABBITMQ_CONFIG_CONSTANTS.PRODUCER.PUBLISH_OPTION_CONTENT_TYPE,
                                persistent: true,
                                headers,
                                }
                                try {
                                await this.channel.publish(RABBITMQ_CONFIG_CONSTANTS.PRODUCER.EXCHANGE_NAME, RABBITMQ_CONFIG_CONSTANTS.PRODUCER.ROUTING_KEY, message, options)
                                console.log('MESSAGE_PUBLISHED_SUCCESSFULLY')
                                } catch (error) {
                                console.log('MESSAGE_PUBLISHED_FAILED', error.message)
                                }
                            }
                    
                            async closeConnection() {
                                if (this.connection) {
                                await this.connection.close()
                                }
                            }
                            }
                    
                        

Step 6: Configure RabbitMQ Module

In your NestJS application module rabbitmq-module.ts, configure the RabbitMQ module:
File: src\modules\rabbitmq\rabbitmq-module.ts

                            import { Module } from '@nestjs/common'
                            import { RabbitMQService } from './service/rabbitmq-manager.service'
                    
                            @Module({
                            imports: [],
                            providers: [RabbitMQService],
                            exports: [RabbitMQService],
                            })
                            export class RabbitMQModule {}
                    
                          

Step 7: Use RabbitMQModule in different module

Go to that module for example src\modules\example\example.module.ts and import the RabbitMQModule module.

                        import { Module } from '@nestjs/common'
                        import { RabbitMQModule } from '../rabbitmq/rabbitmq-module'
                    
                        @Module({
                        imports: [RabbitMQModule],
                        controllers: [],
                        providers: [],
                        })
                        export class ExampleModule {}
                    

Step 8: Publish Message in RabbitMQ

Now you can use the any service of example.module.ts to publish the messages in RabbitMQ:
src\modules\rabbitmq\service\rabbitmq-manager.service.ts

                            import { Injectable } from '@nestjs/common'
                            import { RabbitMQService } from '../../rabbitmq/service/rabbitmq-manager.service'
                            import { RABBITMQ_CONFIG_CONSTANTS } from '../../rabbitmq/constants/rabbitmq-config-constants'
                            import { RabbitMQHeadersDTO, RabbitMQMessageDTO } from '../../rabbitmq/dto/rabbitmq-dto'
                    
                            @Injectable()
                            export class PropertySpecialistsService {
                            constructor(
                                private readonly rabbitMQService: RabbitMQService,
                            ) {
                            }
                    
                            async publishToMessageQueue() {
                                const headers: RabbitMQHeadersDTO = {
                                cloud: RABBITMQ_CONFIG_CONSTANTS.MODULE,
                                country: 'in',
                                'event-name': RABBITMQ_CONFIG_CONSTANTS.PRODUCER.PS_LISTING_UPDATE_EVENT_NAME,
                                }
                    
                                const message: RabbitMQMessageDTO = {
                                event: RABBITMQ_CONFIG_CONSTANTS.PRODUCER.PS_LISTING_UPDATE_EVENT_NAME,
                                fields_changed: ['anything'],
                                time: new Date(),
                                data: {
                                    id: 1,
                                    version: RABBITMQ_CONFIG_CONSTANTS.EVENT_VERSION,
                                    listing_id: 1,
                                    country: 'in',
                                },
                                }
                                await this.rabbitMQService.publish(message, headers)
                            }
                            }
                    
                          

Step 9: Verify in RabbitMQ

I am running RabbitMQ in windows machine and here RabbitMQ installed.
C:\Program Files\RabbitMQ Server\rabbitmq_server-3.13.0\sbin

Implement RabbitMQ step by step in NestJS application

We need to start the RabbitMQ in local using below commands inside the directory "C:\Program Files\RabbitMQ Server\rabbitmq_server-3.13.0\sbin":

                        rabbitmq-plugins.bat enable rabbitmq_management
                    

Implement RabbitMQ step by step in NestJS application

                        rabbitmq-server.bat start
                    

Implement RabbitMQ step by step in NestJS application

Now open URL http://localhost:15672/ and enter login details. By default username and password are "guest".

Implement RabbitMQ step by step in NestJS application

Before publishing the message, you can see nothing:

Implement RabbitMQ step by step in NestJS application

Implement RabbitMQ step by step in NestJS application

Implement RabbitMQ step by step in NestJS application

Implement RabbitMQ step by step in NestJS application

Now execute your codes and you will get your message published in your RabbitMQ:

Connection successful:

Implement RabbitMQ step by step in NestJS application

Channel Created:

Implement RabbitMQ step by step in NestJS application

Exchange Created:

Implement RabbitMQ step by step in NestJS application

After executing the code you can see the graph, it will denote that before some time, there was a message published.

Implement RabbitMQ step by step in NestJS application

Step 9: How to see published messages in RabbitMQ

Because we don't have subscribers to subscribe the message, so we need to create a queue to see the message.
Click on "Queues and streams" from nav bar -> Click on "Add new queue" -> Select Virtual host "idkblogs-bridge" -> Provide name "idkblogs-queue" and click on "Add Queue"
This will add a queue in RabbitMQ.

Implement RabbitMQ step by step in NestJS application

Once you will add your queue, you can see in the list.

Implement RabbitMQ step by step in NestJS application

Now bind the queue with your exchange: If you execute the code, it should be created an exchange, you need to go to the exchange details and add the queue name in "To queue".

Implement RabbitMQ step by step in NestJS application

After successfully bind the exchange with queue:

Implement RabbitMQ step by step in NestJS application

Now execute the code and publish message again, You can see there is 1 message ready to subscribe. now click on the queue and get the message.

Implement RabbitMQ step by step in NestJS application

See actual published Message by clicking on "Get Message" button.

Implement RabbitMQ step by step in NestJS application

---

Conclusion:

Integrating RabbitMQ with NestJS provides a powerful mechanism for building scalable, asynchronous applications. By following these steps, you can implement RabbitMQ in your NestJS application and leverage its capabilities for handling distributed messaging effectively. RabbitMQ's flexibility and reliability make it a great choice for modern microservices architectures, ensuring seamless communication between different parts of your application. Experiment with different RabbitMQ configurations and explore advanced features such as message acknowledgment, routing, and clustering to tailor the setup to your specific requirements. Happy coding with RabbitMQ and NestJS!

Related Keywords:

Beginner's Guide to RabbitMQ Integration in NestJS

Building Asynchronous Systems with RabbitMQ and NestJS

Step-by-Step Tutorial: RabbitMQ Integration in NestJS

Mastering RabbitMQ Integration in Your NestJS Application

Efficient Messaging: RabbitMQ Integration with NestJS Explained

Complete Walkthrough: RabbitMQ Setup in NestJS Application