Kurs NestJS · Moduł 7: Testowanie

Message Queues - system posłańców Imperium

5 min czytania ·
W tej lekcji6

Legionista kończy rejestrację, a serwis wysyła mu list powitalny. Serwer pocztowy akurat nie odpowiada - i rejestracja pada. Człowiek stoi przed bramą odrzucony, choć jego wpis do rejestru powiódł się bez zarzutu. Zawiodła rzecz uboczna, a pociągnęła za sobą rzecz główną.

Rzym rozwiązał to inaczej. Dowódca nie czeka, aż posłaniec wróci z Galii - zostawia list w skrzynce kurierskiej i wraca do swoich zajęć. Posłaniec zabierze go, gdy będzie mógł; jeśli koń okuleje, list poczeka. W systemach nazywamy tę skrzynkę kolejką wiadomości.

Co daje kolejka

Zaleta jest jedna i o nią właśnie chodzi: komunikacja asynchroniczna. Producent - ten, kto wysyła - nie czeka na konsumenta, czyli tego, kto odbiera. Zostawia wiadomość i idzie dalej.

Konsekwencje są trzy. Rejestracja kończy się natychmiast, bo nie jest już związana z pocztą. Awaria konsumenta nie przewraca producenta - wiadomości czekają w kolejce, aż wstanie. A gdy listów przybywa, dokładasz kolejnych konsumentów do tej samej kolejki, nie ruszając producenta.

Producent - zostawienie listu

Aplikacja wysyłająca potrzebuje klienta połączonego z brokerem, czyli z serwerem obsługującym kolejki:

ClientsModule.register([
  {
    name: 'LEGION_SERVICE',
    transport: Transport.RMQ,
    options: {
      urls: ['amqp://localhost:5672'],
      queue: 'legion_queue',
    },
  },
]);

Transport.RMQ wskazuje RabbitMQ - najczęściej używanego brokera. urls to adres serwera, a queue nazwa skrzynki, do której trafią listy. Nazwa LEGION_SERVICE posłuży do wstrzyknięcia klienta tam, gdzie będzie potrzebny.

emit kontra send - dwa rodzaje listów

Mając klienta, wysyłamy wiadomość jedną z dwóch metod. Różnica między nimi jest zasadnicza:

// emit - wyślij i zapomnij, nie czekamy na odpowiedź
this.client.emit('legion.created', { id: 1, name: 'Legio X' });

// send - wyślij i poczekaj na odpowiedź
const result = await this.client.send('legion.count', {}).toPromise();

emit() to fire-and-forget - zostawiasz list i idziesz dalej, nie oczekując odpowiedzi. Tak ogłaszasz fakty: legion powstał, płatność przeszła, użytkownik się zarejestrował. Nadawcy nie interesuje, co odbiorca z tym zrobi.

send() czeka na odpowiedź - to pytanie, nie ogłoszenie. Używasz go, gdy potrzebujesz wyniku: ile jest legionów, czy ten identyfikator istnieje.

Wybór między nimi decyduje o tym, czy w ogóle korzystasz z zalet kolejki. send() przywraca czekanie, a więc i sprzężenie, od którego uciekaliśmy - konsument znów musi działać, żeby producent ruszył dalej. Dlatego do powiadomień, e-maili i logów zawsze emit(); send() zostaw dla przypadków, gdy naprawdę potrzebujesz odpowiedzi.

Konsument - odebranie listu

Po drugiej stronie kolejki stoi serwis nasłuchujący:

@Controller()
export class LegionConsumer {
  @EventPattern('legion.created')
  async handleLegionCreated(@Payload() data: LegionCreatedDto) {
    await this.mailService.sendWelcome(data);
  }
}

@EventPattern('legion.created') mówi: ta metoda obsługuje wiadomości o takiej nazwie. Nazwa jest umową między producentem a konsumentem - musi zgadzać się co do znaku z tą podaną w emit(). @Payload() wyciąga treść wiadomości, czyli obiekt przekazany jako drugi argument.

Zauważ, że konsument wygląda jak zwykły kontroler - bo działa podobnie. Różnica polega na tym, skąd przychodzi żądanie: nie z sieci HTTP, tylko z kolejki.

Potwierdzenie - kwit odbioru

Broker musi wiedzieć, czy list dotarł i został przetworzony. Bez tej informacji nie może go usunąć - a gdyby usunął od razu po wysłaniu, awaria konsumenta w połowie pracy oznaczałaby bezpowrotną stratę wiadomości.

Stąd potwierdzenie, czyli acknowledgement:

@EventPattern('legion.created')
async handleLegionCreated(@Payload() data: LegionCreatedDto, @Ctx() context: RmqContext) {
  const channel = context.getChannelRef();
  const originalMsg = context.getMessage();

  try {
    await this.mailService.sendWelcome(data);

    channel.ack(originalMsg);
  } catch (error) {
    channel.nack(originalMsg, false, true);
  }
}

@Ctx() daje dostęp do kontekstu RabbitMQ. getChannelRef() zwraca kanał komunikacji z brokerem, a getMessage() - surową wiadomość, której dotyczy potwierdzenie.

Sedno jest w bloku try. channel.ack(originalMsg) potwierdza poprawne przetworzenie - dopiero wtedy broker usuwa wiadomość z kolejki. Zwróć uwagę na miejsce tego wywołania: po wykonaniu pracy, nie przed. Potwierdzenie na początku metody znaczyłoby "odebrałem", a nie "przetworzyłem", i awaria wysyłki e-maila skończyłaby się cichą utratą listu.

W catch stoi nack - odmowa potwierdzenia. Ostatni argument true każe brokerowi wstawić wiadomość z powrotem do kolejki, żeby spróbować później. To jest właśnie ta odporność, dla której kolejki wprowadziliśmy: nieudana próba nie niszczy wiadomości.

Podsumowanie

Skrzynka kurierska działa, listy dochodzą:

  • kolejka wiadomości daje komunikację asynchroniczną - producent nie czeka na konsumenta,
  • dzięki temu awaria konsumenta nie przewraca producenta, a wiadomości czekają, aż odbiorca wstanie,
  • klienta konfigurujemy przez ClientsModule.register z Transport.RMQ, adresem brokera i nazwą kolejki,
  • emit() to fire-and-forget - ogłaszasz fakt i nie czekasz na odpowiedź; send() czeka na odpowiedź, więc przywraca sprzężenie,
  • do powiadomień i e-maili używaj emit(); send() tylko wtedy, gdy naprawdę potrzebujesz wyniku,
  • konsument nasłuchuje przez @EventPattern('nazwa'), a treść wyciąga @Payload(); nazwa musi zgadzać się z tą z emit(),
  • channel.ack(originalMsg) potwierdza przetworzenie i dopiero wtedy broker usuwa wiadomość z kolejki,
  • potwierdzaj po wykonaniu pracy, nie przed - inaczej awaria oznacza cichą utratę wiadomości,
  • nack z ostatnim argumentem true wraca wiadomość do kolejki do ponownej próby,
  • pełny przepływ: producent wysyła przez emit → wiadomość czeka w kolejce → konsument odbiera przez @EventPattern → potwierdza przez channel.ack.

To ostatnia lekcja tego modułu. Umiesz już sprawdzić każdą część osobno, ich współpracę, całą drogę żądania, zmierzyć pokrycie i wytrzymałość, a teraz także rozdzielić serwisy tak, by awaria jednego nie pociągała reszty. A na razie zapamiętaj: kolejka to skrzynka kurierska - dowódca zostawia list i wraca do swoich spraw, a potwierdzenie odbioru przychodzi dopiero wtedy, gdy posłaniec naprawdę dotarł.

Kod do tej lekcji: src/message-queues.ts
// Message Queues - System Poslancow Imperium Rzymskiego
import { Injectable } from '@nestjs/common';

// 1. Prosta implementacja kolejki wiadomosci
class MessageQueue<T> {
  private queue: Array<{ id: string; data: T; timestamp: Date }> = [];
  private handlers: Map<string, (data: T) => Promise<void>> = new Map();

  // Wyslij wiadomosc do kolejki
  async publish(channel: string, data: T): Promise<string> {
    const id = `msg-${Date.now()}`;
    this.queue.push({ id, data, timestamp: new Date() });

    const handler = this.handlers.get(channel);
    if (handler) {
      await handler(data);
    }
    return id;
  }

  // Zasubskrybuj kanal
  subscribe(channel: string, handler: (data: T) => Promise<void>) {
    this.handlers.set(channel, handler);
  }

  getQueueStatus() {
    return {
      size: this.queue.length,
      channels: Array.from(this.handlers.keys()),
      oldestMessage: this.queue[0]?.timestamp,
    };
  }
}

// 2. NestJS Bull Queue - konfiguracja
// @Module({
//   imports: [
//     BullModule.forRoot({
//       redis: { host: 'localhost', port: 6379 },
//     }),
//     BullModule.registerQueue({ name: 'tribute-collection' }),
//   ],
// })
// export class QueueModule {}

// 3. Producent - dodawanie zadan do kolejki
@Injectable()
class TributeQueueService {
  private queue = new MessageQueue<any>();

  constructor() {
    this.queue.subscribe('tribute', async (data) => {
      console.log(
        `Collecting tribute: ${data.province} - ${data.amount} gold`
      );
    });

    this.queue.subscribe('alert', async (data) => {
      console.log(`ALERT: ${data.message}`);
    });
  }

  async scheduleTributeCollection(province: string, amount: number) {
    return this.queue.publish('tribute', { province, amount });
  }

  async sendAlert(message: string, priority: 'low' | 'high') {
    return this.queue.publish('alert', { message, priority });
  }

  getStatus() {
    return this.queue.getQueueStatus();
  }
}

// 4. Wzorce komunikacji:
// - Point-to-Point: producent -> konsument
// - Pub/Sub: producent -> wielu konsumentow
// - Request/Reply: producent czeka na odpowiedz
// - Fan-out: wiadomosc do wielu kolejek

// 5. Processor - przetwarzanie zadan
// @Processor('tribute-collection')
// class TributeProcessor {
//   @Process('collect')
//   async handleCollect(job: Job<TributeData>) {
//     const { province, amount } = job.data;
//     return { collected: true, province };
//   }
//
//   @OnQueueCompleted()
//   onCompleted(job: Job, result: any) {
//     console.log(`Job ${job.id} completed`);
//   }
// }

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Jaką główną zaletę dają Message Queues w komunikacji między serwisami?

  2. 2. Czym różni się client.emit() od client.send() w mikroserwisach NestJS?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj przepływ wiadomości w systemie z kolejką od początku do końca:

  1. PytanieKomunikacja asynchroniczna w kolejkach
  2. PytanieMetody emit() i send() klienta
  3. Ułóż w kolejnościPrzepływ wiadomości przez kolejkę
  4. PytaniePotwierdzanie wiadomości channel.ack()
  5. Projekt do wysłaniaProjekt: System testów Imperium Rzymskiego
  6. WideoPodsumowanie modułu

Przydatne artykuły