0Pricing
NestJS Enterprise Backend APIs · Lekcja

Integracja RabbitMQ

Zintegruj RabbitMQ jako brokera wiadomości na potrzeby solidnej asynchronicznej komunikacji między mikroserwisami NestJS.

Integracja RabbitMQ to bezpłatna lekcja NestJS Enterprise Backend APIs na CoddyKit. To lekcja 2 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej NestJS Enterprise Backend APIs, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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-management

This 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!

Często zadawane pytania

Czy lekcja „Integracja RabbitMQ” jest bezpłatna?

Tak — pełny tekst „Integracja RabbitMQ” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu NestJS Enterprise Backend APIs, przejdź na CoddyKit PRO. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.

Co nauczysz się w „Integracja RabbitMQ”?

Zintegruj RabbitMQ jako brokera wiadomości na potrzeby solidnej asynchronicznej komunikacji między mikroserwisami NestJS. Ćwiczysz NestJS Enterprise Backend APIs z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć NestJS Enterprise Backend APIs?

Nie wymagamy żadnego doświadczenia. NestJS Enterprise Backend APIs w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 3.

Ile czasu zajmuje lekcja „Integracja RabbitMQ”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji NestJS Enterprise Backend APIs?

Tak. Każda lekcja NestJS Enterprise Backend APIs zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Przegląd mikroserwisów NestJS
  2. Integracja RabbitMQ
  3. Komunikacja między usługami
← Powrót do NestJS Enterprise Backend APIs