Kurs NestJS · Moduł 7: Testowanie
Message Queues - system posłańców Imperium
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.registerzTransport.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ą zemit(), 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,
nackz ostatnim argumentemtruewraca 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 przezchannel.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. Jaką główną zaletę dają Message Queues w komunikacji między serwisami?
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: