Integración de RabbitMQ
Integre RabbitMQ como broker de mensajes para permitir una comunicación asíncrona sólida entre sus microservicios de NestJS.
Integración de RabbitMQ es una lección gratuita de NestJS Enterprise Backend APIs en CoddyKit. Esta es la lección 2 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de NestJS Enterprise Backend APIs, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de NestJS Enterprise Backend APIs incluye 3 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
Meet RabbitMQ
Welcome to integrating RabbitMQ with NestJS! RabbitMQ is a popular message broker that helps different parts of your application communicate reliably.
Think of it as a post office for your application's messages. Services can drop off messages, and other services can pick them up when they're ready.
Why Use Message Queues?
In a microservices architecture, direct communication can lead to tight coupling. Message queues solve this by enabling asynchronous communication.
- Decoupling: Services don't need to know about each other directly.
- Resilience: If a service is down, messages wait in the queue.
- Scalability: Easily add more consumers to process messages faster.
- Load Balancing: Distribute tasks among multiple workers.
Key RabbitMQ Concepts
Let's quickly define the essential terms:
- Producer: An application that sends messages to the queue.
- Consumer: An application that receives and processes messages from the queue.
- Queue: A buffer that stores messages. Messages wait here until a consumer picks them up.
- Message: The data payload sent by a producer and consumed by a consumer.
NestJS & RabbitMQ Transporter
NestJS provides excellent support for microservices using various transporters. RabbitMQ is one such transporter, enabling robust inter-service communication.
You'll configure your NestJS applications as either a client (producer) that sends messages, or a microservice (consumer) that listens for and processes messages.
Running RabbitMQ Locally
Before integrating, you need a running RabbitMQ instance. The easiest way for local development is using Docker:
docker run -d --hostname my-rabbit --name some-rabbit -p 5672:5672 -p 15672:15672 rabbitmq:3-managementThis command starts a RabbitMQ server on port 5672 (for AMQP) and 15672 (for management UI).
Producer App Entry Point
This main.ts file is the entry point for a NestJS application configured to act as a producer. It starts an HTTP server that can trigger message sending.
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
await app.listen(3000);
console.log('Producer HTTP Gateway running on port 3000');
}
bootstrap();Producer Client Configuration
To send messages, the producer NestJS app needs a client proxy. Configure the ClientsModule in your AppModule to define this RabbitMQ client.
The name ('MESSAGE_SERVICE') is a token used for dependency injection.
import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { AppController } from './app.controller';
@Module({
imports: [
ClientsModule.register([
{
name: 'MESSAGE_SERVICE',
transport: Transport.RMQ,
options: {
urls: ['amqp://localhost:5672'],
queue: 'my_nest_queue',
queueOptions: { durable: false },
},
},
]),
],
controllers: [AppController],
})
export class AppModule {}Sending an Event Message
Now, inject the configured ClientProxy into a controller or service. Use client.emit() to send an event message to the RabbitMQ queue.
emit() is used for event-based communication where no response is expected.
import { Controller, Get, Inject } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';
@Controller('events')
export class AppController {
constructor(@Inject('MESSAGE_SERVICE') private client: ClientProxy) {}
@Get('publish')
async publishEvent() {
const payload = { id: 101, text: 'Hello from producer!' };
this.client.emit('message_event', payload);
return 'Event sent to RabbitMQ!';
}
}Consumer Microservice Entry
This main.ts bootstraps a NestJS application as a microservice. It listens for messages from the specified RabbitMQ queue, acting as a consumer.
Notice NestFactory.createMicroservice instead of create.
import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.createMicroservice<MicroserviceOptions>(
AppModule,
{
transport: Transport.RMQ,
options: {
urls: ['amqp://localhost:5672'],
queue: 'my_nest_queue',
queueOptions: { durable: false },
},
},
);
await app.listen();
console.log('Consumer Microservice is listening on RabbitMQ queue!');
}
bootstrap();Processing Incoming Messages
In your consumer service, use the @MessagePattern() decorator to define methods that will handle specific messages from the queue.
It's crucial to acknowledge (ack()) messages to inform RabbitMQ they've been processed successfully.
import { Injectable } from '@nestjs/common';
import { MessagePattern, RmqContext, Ctx, Payload } from '@nestjs/microservices';
@Injectable()
export class AppService {
@MessagePattern('message_event')
handleMessage(@Payload() data: any, @Ctx() context: RmqContext) {
console.log('Received message:', data);
const channel = context.getChannelRef();
const originalMsg = context.getMessage();
channel.ack(originalMsg);
return { status: 'success', data: data };
}
}RabbitMQ Quick Check
You've learned how to set up producers and consumers. Let's test your understanding!
Recap: RMQ Integration
You've successfully learned the basics of integrating RabbitMQ with NestJS!
- RabbitMQ enables asynchronous, decoupled communication.
- NestJS uses transporters like RabbitMQ for microservices.
- You configured a NestJS app as a producer (client) to send messages using
client.emit(). - You configured another NestJS app as a consumer (microservice) to receive messages using
@MessagePattern(). - Remember to acknowledge messages for reliability.
This is a powerful pattern for building scalable and robust microservices!
Preguntas frecuentes
¿La lección «Integración de RabbitMQ» es gratis?
Sí — el texto completo de «Integración de RabbitMQ» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de NestJS Enterprise Backend APIs, actualiza a CoddyKit PRO. El curso de NestJS Enterprise Backend APIs incluye 3 lecciones en total.
¿Qué aprenderé en «Integración de RabbitMQ»?
Integre RabbitMQ como broker de mensajes para permitir una comunicación asíncrona sólida entre sus microservicios de NestJS. Practicas NestJS Enterprise Backend APIs con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar NestJS Enterprise Backend APIs?
No se requiere experiencia previa. NestJS Enterprise Backend APIs en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 3.
¿Cuánto tiempo toma la lección «Integración de RabbitMQ»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de NestJS Enterprise Backend APIs?
Sí. Cada lección de NestJS Enterprise Backend APIs incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Introducción a los microservicios de NestJS
- Integración de RabbitMQ
- Comunicación entre servicios