NestJS-yritysbackendien API:t · Oppitunti

Palvelujen välinen viestintä

Toteuttakaa malleja mikropalvelujen tehokkaaseen viestintään, mukaan lukien tapahtumapohjaiset ja pyyntö–vastausmekanismit.

Oppitunti 3/312 vaihetta

Palvelujen välinen viestintä on ilmainen NestJS-yritysbackendien API:t-oppitunti CoddyKitissä. Tämä on oppitunti 3/3. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu NestJS-yritysbackendien API:t-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. NestJS-yritysbackendien API:t-kurssilla on yhteensä 3 oppituntia.

Mikropalvelujen on viestittävä keskenään

Mikropalvelut on suunniteltu itsenäisiksi, mutta niiden on usein tehtävä yhteistyötä monimutkaisten tehtävien suorittamiseksi. Siksi niiden on viestittävä keskenään!

Tässä oppitunnissa tutustumme tärkeimpiin tapoihin, joilla NestJS-mikropalvelut voivat lähettää viestejä ja jakaa tietoja tehokkaasti.

Synkroninen ja asynkroninen viestintä

Synkronisen ja asynkronisen viestinnän eron ymmärtäminen on mikropalvelujen kannalta ratkaisevan tärkeää:

Synkroninen: Lähettäjä odottaa välitöntä vastausta. Se muistuttaa suoraa puhelua, jossa odotatte vastausta heti.
Asynkroninen: Lähettäjä ei odota vastausta. Se muistuttaa sähköpostin lähettämistä: lähetätte viestin ja jatkatte muita tehtäviä odottaen vastausta myöhemmin (tai ette lainkaan).

Kummallakin mallilla on hajautetussa järjestelmässä omat käyttötapauksensa.

Pyyntö–vastausmalli

Pyyntö–vastaus-malli on synkroninen viestintämenetelmä. Yksi palvelu (asiakas) lähettää pyynnön toiselle palvelulle (palvelimelle) ja keskeyttää oman suorituksensa odottaessaan suoraa vastausta.

Sopii toimintoihin, jotka tarvitsevat välittömän tuloksen.
Muistuttaa sitä, miten tavallinen web-asiakas käyttää REST-rajapintaa.
Toteutetaan usein HTTP:n, RPC:n tai synkronisia vastauksia varten määritettyjen viestinvälittäjien avulla.

NestJS: pyyntöjen vastaanottaminen

NestJS:ssä mikropalvelu kuuntelee saapuvia pyyntöjä käyttämällä @MessagePattern()-annotaatiota. Tämän kuvion on vastattava asiakkaan lähettämää kuviota.

Annotaatiolla koristeltu käsittelijäfunktio vastaanottaa hyötykuorman ja palauttaa vastauksen. Kokeile suorittaa tämä Product Service -mikropalvelu:

import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { Module, Controller, MessagePattern } from '@nestjs/common';

@Controller()
class ProductController {
  @MessagePattern('get_product_details')
  getProductDetails(id: string): any {
    console.log(`Product Service: Request for ID: ${id}`);
    const products = {
      '1': { id: '1', name: 'Laptop', price: 1200 },
      '2': { id: '2', name: 'Mouse', price: 25 },
    };
    return products[id] || { id, name: 'Product Not Found', price: 0 };
  }
}

@Module({
  controllers: [ProductController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.TCP,
      options: { host: '127.0.0.1', port: 8877 },
    },
  );
  await app.listen();
  console.log('Product Microservice is listening on port 8877');
}

bootstrap();

NestJS: pyyntöjen lähettäminen

Lähettääkseen pyynnön Product Service -palvelulle (edellisestä näkymästä) toinen mikropalvelu tai API-yhdyskäytävä käyttää ClientProxy-oliota.

client.send()-metodi lähettää viestin tietyn kuvion ja hyötykuorman kanssa ja palauttaa RxJS:n Observable-olion, joka tuottaa vastauksen.

Tämä koodikatkelma näyttää, miten asiakaspalvelu käynnistäisi pyynnön:

// product-client.service.ts in 'Order Service' microservice
import { Injectable, Inject } from '@nestjs/common';
import { ClientProxy } from '@nestjs/microservices';
import { lastValueFrom } from 'rxjs'; // For awaiting observable

@Injectable()
export class ProductClientService {
  constructor(@Inject('PRODUCT_SERVICE') private client: ClientProxy) {}

  async fetchProduct(productId: string): Promise<any> {
    console.log(`Order Service: Fetching product ID: ${productId}`);
    // 'get_product_details' must match the pattern in Product Service
    const product = await lastValueFrom(
      this.client.send('get_product_details', productId),
    );
    console.log('Received product:', product);
    return product;
  }
}

// To make this work, 'PRODUCT_SERVICE' needs to be registered
// in an AppModule using ClientsModule.register():
// imports: [
//   ClientsModule.register([
//     {
//       name: 'PRODUCT_SERVICE',
//       transport: Transport.TCP,
//       options: { host: '127.0.0.1', port: 8877 },
//     },
//   ]),
// ],

Milloin käyttää pyyntö–vastausmallia

Request-Response-malli sopii parhaiten, kun:

Tarvitsette kohdepalvelulta välittömän vastauksen.
Toiminto on kriittinen ja edellyttää suoraa palautetta (esimerkiksi maksujen käsittely tai käyttäjän todentaminen).
Haette toisesta palvelusta tiettyjä tietoja.
Vuorovaikutus noudattaa selkeää asiakas–palvelin-suhdetta.

Huomioikaa, että tämä malli kytkee palvelut suoraan toisiinsa.

Tapahtumapohjainen viestintä

Tapahtumapohjainen viestintä on asynkroninen malli, joka käyttää publish-subscribe-mallia. Palvelut eivät kutsu toisiaan suoraan, vaan julkaisevat tapahtumia viestinvälittäjään (kuten RabbitMQ), kun jotain merkittävää tapahtuu.

Palvelu julkaisee tapahtuman (esimerkiksi 'OrderCreated').
Muut palvelut tilaavat tapahtumia, joista ne ovat kiinnostuneita.
Tämä malli vähentää palveluiden välistä kytkentää merkittävästi ja tekee niistä itsenäisempiä.

NestJS: tapahtumien julkaiseminen

Tapahtuma julkaistaan NestJS:ssä käyttämällä ClientProxy-olion client.emit()-metodia. Toisin kuin send(), emit() lähettää tapahtuman ja palautuu heti odottamatta vastausta.

Tämä fire-and-forget-lähestymistapa sopii erinomaisesti muiden palveluiden ilmoittamiseen tilan muutoksista. Suorittakaa tämä tapahtuman lähettävä Order Service:

import { NestFactory } from '@nestjs/core';
import { Module, Controller, Post, Body, Inject } from '@nestjs/common';
import { ClientProxy, ClientsModule, Transport } from '@nestjs/microservices';

interface OrderCreatedEvent {
  orderId: string;
  userId: string;
  totalAmount: number;
}

@Controller('orders')
class OrderController {
  constructor(@Inject('NOTIFICATION_SERVICE') private client: ClientProxy) {}

  @Post()
  async createOrder(@Body() orderData: any) {
    const orderId = `ORD-${Date.now()}`;
    const event: OrderCreatedEvent = {
      orderId,
      userId: orderData.userId || 'user-123',
      totalAmount: orderData.amount || 100,
    };
    this.client.emit('order_created', event);
    console.log(`Order ${orderId} created, 'order_created' event emitted.`);
    return { message: 'Order created and event sent', orderId };
  }
}

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'NOTIFICATION_SERVICE',
        transport: Transport.TCP,
        options: { host: '127.0.0.1', port: 8878 },
      },
    ]),
  ],
  controllers: [OrderController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Order Service (HTTP) is listening on port 3000');
}

bootstrap();

NestJS: tapahtumien kuunteleminen

Muut mikropalvelut voivat tilata tapahtumia käyttämällä @EventPattern()-dekoraattoria. Kun vastaavan mallin mukainen tapahtuma julkaistaan, dekoroitu metodi käynnistyy automaattisesti.

Näin useat palvelut voivat reagoida samaan tapahtumaan toisistaan riippumatta. Suorittakaa tämä tapahtuman vastaanottava Notification Service:

import { NestFactory } from '@nestjs/core';
import { MicroserviceOptions, Transport } from '@nestjs/microservices';
import { Module, Controller, EventPattern } from '@nestjs/common';

interface OrderCreatedEvent {
  orderId: string;
  userId: string;
  totalAmount: number;
}

@Controller()
class NotificationController {
  @EventPattern('order_created')
  handleOrderCreated(data: OrderCreatedEvent) {
    console.log('Notification Service received OrderCreated event:', data);
    console.log(`Sending notification for Order ${data.orderId} to User ${data.userId}`);
  }
}

@Module({
  controllers: [NotificationController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.TCP,
      options: { host: '127.0.0.1', port: 8878 },
    },
  );
  await app.listen();
  console.log('Notification Microservice is listening on port 8878');
}

bootstrap();

Milloin tapahtumapohjaista mallia kannattaa käyttää

Tapahtumapohjainen viestintä on erittäin hyödyllistä seuraavissa tilanteissa:

Riippuvuuksien vähentäminen: Palveluiden ei tarvitse tietää toisistaan, mikä vähentää riippuvuuksia.
Yleislähetys: Useille vastaanottajille ilmoittaminen yhdestä tapahtumasta (esimerkiksi 'UserRegistered'-tapahtuma).
Pitkäkestoiset prosessit: Tehtävien käynnistäminen, kun välitöntä vastausta ei tarvita.
Vikasietoisuus: Palvelut voivat käsitellä tapahtumia, kun ne ovat käytettävissä, mikä parantaa vikasietoisuutta.

Se lisää monimutkaisuutta, mutta tarjoaa paljon joustavuutta ja skaalautuvuutta.

Viestintämallien tietovisa

Ajatellaan tilannetta, jossa Order Service tarvitsee ilmoittaa Shipping Servicelle, että tilaus on valmis lähetettäväksi, mutta Order Servicen ei tarvitse odottaa toimitusvahvistusta heti. Mikä viestintämalli sopii tähän parhaiten?

Vastaa interaktiivisessa oppitunnissa

Kertaus: palveluiden välinen viestintä

Onnittelut! Olette oppineet NestJS-mikropalveluiden välisen viestinnän keskeiset mallit.

Request-Response (käyttäen client.send()-metodia ja @MessagePattern()-dekoraattoria) sopii välittömään ja suoraan vuorovaikutukseen, jossa vastausta odotetaan.
Tapahtumapohjainen viestintä (käyttäen client.emit()-metodia ja @EventPattern()-dekoraattoria) sopii asynkroniseen ja löyhästi kytkettyyn tapahtumapohjaiseen viestintään, erityisesti ilmoituksiin ja yleislähetyksiin.

Oikean mallin valinta riippuu hajautetun järjestelmän kytkentää, reagointinopeutta ja skaalautuvuutta koskevista tarpeistanne.

Aloita maksutta

Opi TypeScript tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 20
Oppitunnit: 76

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Palvelujen välinen viestintä” ilmainen?

Kyllä – oppitunnin ”Palvelujen välinen viestintä” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko NestJS-yritysbackendien API:t-kurssin, päivitä CoddyKit PROhon. NestJS-yritysbackendien API:t-kurssilla on yhteensä 3 oppituntia.

Mitä opin oppitunnilla ”Palvelujen välinen viestintä”?

Toteuttakaa malleja mikropalvelujen tehokkaaseen viestintään, mukaan lukien tapahtumapohjaiset ja pyyntö–vastausmekanismit. Harjoittelet NestJS-yritysbackendien API:t-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni NestJS-yritysbackendien API:t-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin NestJS-yritysbackendien API:t-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/3.

Kuinka kauan ”Palvelujen välinen viestintä”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä NestJS-yritysbackendien API:t-oppitunnilla?

Kyllä. Jokainen NestJS-yritysbackendien API:t-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: NestJS-yritysbackendien API:t