NestJS Enterprise Backend APIs · Lekcja

Przegląd mikroserwisów NestJS

Skonfiguruj mikroserwisy NestJS z użyciem różnych mechanizmów transportu, takich jak TCP, Redis i RabbitMQ, poznając ich kluczowe koncepcje.

Lekcja 1 z 311 kroki

Przegląd mikroserwisów NestJS to bezpłatna lekcja NestJS Enterprise Backend APIs na CoddyKit. To lekcja 1 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.

Intro to NestJS Microservices

Welcome to the world of NestJS Microservices! In this lesson, we'll explore how NestJS helps you build small, independent services that communicate with each other.

Microservices are an architectural style where applications are built as a collection of loosely coupled services. NestJS provides powerful tools to make this easier.

Why Use Microservices?

Adopting a microservice architecture offers several key advantages:

Scalability: Individual services can be scaled independently based on their load.
Resilience: Failure in one service is less likely to bring down the entire application.
Independent Deployment: Services can be developed, deployed, and updated without affecting others.
Technology Diversity: Different services can use different technologies if needed.

Core Concepts: Client & Server

In a microservice setup, we typically have:

Microservice Server: This is the actual microservice that listens for incoming messages and processes them.
Microservice Client: This is any other application or service that wants to communicate with the microservice server. It sends messages and receives responses.

They work together to perform distributed tasks.

Transporters: The Communication Bridge

How do microservice clients and servers communicate? They use transporters. A transporter is the underlying communication protocol or mechanism.

NestJS supports various transporters out of the box:

TCP: For direct, point-to-point communication.
Redis: A popular in-memory data store, often used as a message broker.
RabbitMQ/NATS/Kafka: Robust message queue systems for advanced scenarios.

Setting Up a TCP Microservice Server

Let's create a basic NestJS microservice server using the TCP transporter. This server will listen for messages on a specific port.

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.TCP,
      options: {
        host: '127.0.0.1',
        port: 8888,
      },
    },
  );
  await app.listen();
  console.log('TCP Microservice is listening on port 8888');
}
bootstrap();

Defining Message Handlers

On the server side, we define message handlers using the @MessagePattern() decorator. This tells NestJS which method should handle a specific message pattern.

Here, we define a handler for a 'sum' command that adds numbers.

import { Controller } from '@nestjs/common';
import { MessagePattern } from '@nestjs/microservices';

@Controller()
export class AppController {
  @MessagePattern({ cmd: 'sum' })
  accumulate(data: number[]): number {
    console.log('Server received sum request:', data);
    return (data || []).reduce((a, b) => a + b, 0);
  }
}

Setting Up a TCP Microservice Client

Now, let's create a client application that can send messages to our TCP microservice server. We use ClientProxyFactory to create a client instance.

import { NestFactory } from '@nestjs/core';
import { ClientProxyFactory, Transport } from '@nestjs/microservices';
import { INestApplicationContext } from '@nestjs/common';

async function bootstrap() {
  const app: INestApplicationContext = await NestFactory.createApplicationContext({});
  const client = ClientProxyFactory.create({
    transport: Transport.TCP,
    options: {
      host: '127.0.0.1',
      port: 8888,
    },
  });

  const pattern = { cmd: 'sum' };
  const payload = [1, 2, 3, 4];

  console.log('Client sending message to microservice...');
  const result = await client.send(pattern, payload).toPromise();
  console.log('Microservice response:', result);

  await app.close();
}
bootstrap();

Request-Response Pattern: send()

The client.send() method is used for a request-response communication pattern. This means the client sends a message and expects a reply from the microservice server.

It returns an Observable, so we typically use .toPromise() to await the response in an async function.

client.send({ cmd: 'sum' }, [1, 2, 3]).toPromise()

Event-Based Pattern: emit()

For event-based communication, where you don't necessarily need a direct response, you can use the client.emit() method.

This is useful for 'fire-and-forget' scenarios like sending notifications or logging events. The client sends the event and continues without waiting for a reply.

client.emit({ cmd: 'user_created' }, { userId: 42, name: 'Alice' });
console.log('User created event emitted.');

Quick Check: Microservice Fundamentals

Which of the following statements are TRUE about NestJS microservices and their components?

Odpowiedz w interaktywnej lekcji

Recap: Microservices Overview

Fantastic job! You've taken your first steps into NestJS microservices. We covered:

The benefits of microservices for scalability and resilience.
Core concepts: microservice clients, servers, and transporters.
How to set up basic TCP microservice servers and clients.
The difference between request-response (send()) and event-based (emit()) communication patterns.

In upcoming lessons, we'll dive deeper into specific transporters like Redis and RabbitMQ!

Bezpłatny start

Ucz się TypeScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 20
Lekcje: 76

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Przegląd mikroserwisów NestJS” jest bezpłatna?

Tak — pełny tekst „Przegląd mikroserwisów NestJS” 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 „Przegląd mikroserwisów NestJS”?

Skonfiguruj mikroserwisy NestJS z użyciem różnych mechanizmów transportu, takich jak TCP, Redis i RabbitMQ, poznając ich kluczowe koncepcje. Ć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 1 z 3.

Ile czasu zajmuje lekcja „Przegląd mikroserwisów NestJS”?

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

Przegląd mikroserwisów NestJS
Integracja RabbitMQ
Komunikacja między usługami

← Powrót do NestJS Enterprise Backend APIs