API Bahagian Belakang Perusahaan NestJS · Pelajaran

Komunikasi antara Perkhidmatan

Laksanakan corak untuk komunikasi berkesan antara mikroperkhidmatan, termasuk mekanisme berasaskan peristiwa dan permintaan-respons.

Pelajaran 3 daripada 312 langkah

Komunikasi antara Perkhidmatan ialah pelajaran API Bahagian Belakang Perusahaan NestJS percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran API Bahagian Belakang Perusahaan NestJS, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus API Bahagian Belakang Perusahaan NestJS merangkumi sejumlah 3 pelajaran.

Perkhidmatan Mikro Perlu Berkomunikasi

Perkhidmatan mikro direka bentuk supaya bebas, tetapi perkhidmatan ini sering perlu bekerjasama untuk menyelesaikan tugas yang kompleks. Ini bermakna perkhidmatan tersebut mesti berkomunikasi antara satu sama lain!

Dalam pelajaran ini, kita akan meneroka corak utama yang membolehkan perkhidmatan mikro NestJS anda menghantar mesej dan berkongsi data dengan berkesan.

Komunikasi Segerak berbanding Tak Segerak

Memahami perbezaan antara komunikasi segerak dengan tak segerak amat penting untuk perkhidmatan mikro:

Segerak: Penghantar menunggu balasan segera. Ia seperti panggilan telefon terus apabila anda menjangkakan jawapan serta-merta.
Tak segerak: Penghantar tidak menunggu balasan. Ia seperti menghantar e-mel – anda menghantarnya dan meneruskan tugas lain, sambil menjangkakan balasan kemudian (atau tidak menerimanya langsung).

Kedua-dua corak mempunyai kegunaan yang berbeza dalam sistem teragih.

Corak Permintaan-Respons

Corak Permintaan-Respons ialah kaedah komunikasi segerak. Satu perkhidmatan (klien) menghantar permintaan kepada perkhidmatan lain (pelayan) dan menjeda pelaksanaan sendiri sementara menunggu respons terus.

Sesuai untuk operasi yang memerlukan hasil segera.
Serupa dengan cara klien web biasa berinteraksi dengan API REST.
Selalunya dilaksanakan menggunakan HTTP, RPC atau broker mesej yang dikonfigurasi untuk balasan segerak.

NestJS: Menerima Permintaan

Dalam NestJS, perkhidmatan mikro mendengar permintaan masuk menggunakan penghias @MessagePattern(). Corak ini mesti sepadan dengan corak yang dihantar oleh klien.

Fungsi pengendali yang dihias menerima muatan dan mengembalikan respons. Cuba jalankan perkhidmatan mikro Product Service ini:

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: Menghantar Permintaan

Untuk menghantar permintaan kepada 'Product Service' (daripada babak sebelumnya), perkhidmatan mikro lain atau Gerbang API menggunakan ClientProxy.

Kaedah client.send() menghantar mesej dengan corak dan muatan tertentu, lalu mengembalikan Observable RxJS yang diselesaikan dengan respons.

Coretan ini menunjukkan cara perkhidmatan klien memulakan permintaan:

// 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 },
//     },
//   ]),
// ],

Bila Menggunakan Permintaan-Respons

Corak Request-Response paling sesuai apabila:

Anda memerlukan jawapan segera daripada perkhidmatan sasaran.
Operasi tersebut kritikal dan memerlukan maklum balas langsung (contohnya, pemprosesan pembayaran dan pengesahan pengguna).
Anda mendapatkan data tertentu daripada perkhidmatan lain.
Interaksi tersebut mempunyai hubungan klien-pelayan yang jelas.

Harap maklum bahawa corak ini mewujudkan gandingan langsung antara perkhidmatan.

Komunikasi Berasaskan Peristiwa

Komunikasi berasaskan peristiwa ialah corak tak segerak yang menggunakan model 'terbitkan-langgan'. Perkhidmatan tidak memanggil satu sama lain secara langsung; sebaliknya, perkhidmatan menerbitkan peristiwa kepada broker mesej (seperti RabbitMQ) apabila sesuatu yang penting berlaku.

Sesuatu perkhidmatan menerbitkan peristiwa (contohnya, 'OrderCreated').
Perkhidmatan lain melanggan peristiwa yang diminati.
Corak ini menyahgandingkan perkhidmatan dengan ketara, menjadikannya lebih bebas antara satu sama lain.

NestJS: Menerbitkan Peristiwa

Untuk menerbitkan peristiwa dalam NestJS, anda menggunakan kaedah client.emit() daripada ClientProxy. Tidak seperti send(), emit() menghantar peristiwa dan kembali serta-merta tanpa menunggu jawapan.

Pendekatan 'lancar-dan-lupakan' ini sesuai untuk memaklumkan perkhidmatan lain tentang perubahan keadaan. Jalankan Perkhidmatan Pesanan ini yang memancarkan peristiwa:

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: Mendengar Peristiwa

Perkhidmatan mikro lain boleh melanggan peristiwa menggunakan penghias @EventPattern(). Apabila peristiwa dengan corak yang sepadan dipancarkan, kaedah yang dihiasi akan dicetuskan secara automatik.

Hal ini membolehkan beberapa perkhidmatan bertindak balas terhadap peristiwa yang sama secara bebas. Jalankan Perkhidmatan Pemberitahuan ini untuk menerima peristiwa tersebut:

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();

Bila Hendak Menggunakan Pendekatan Dipacu Peristiwa

Komunikasi berasaskan peristiwa amat bermanfaat untuk:

Penyahgandingan: Perkhidmatan tidak perlu mengetahui kewujudan satu sama lain, lalu mengurangkan kebergantungan.
Penyiaran: Memaklumkan beberapa pengguna tentang satu peristiwa (contohnya, peristiwa 'UserRegistered').
Proses jangka panjang: Memulakan tugasan yang tidak memerlukan jawapan segera.
Ketahanan: Perkhidmatan boleh memproses peristiwa apabila tersedia, sekali gus meningkatkan toleransi terhadap kegagalan.

Kaedah ini menambah kerumitan tetapi menawarkan fleksibiliti dan kebolehskalaan yang tinggi.

Kuiz Corak Komunikasi

Bayangkan situasi apabila 'Perkhidmatan Pesanan' perlu memaklumkan 'Perkhidmatan Penghantaran' bahawa sesuatu pesanan sedia untuk dihantar, tetapi 'Perkhidmatan Pesanan' tidak perlu menunggu pengesahan penghantaran dengan serta-merta. Apakah corak komunikasi yang paling sesuai untuk situasi ini?

Jawab dalam pelajaran interaktif

Imbas Kembali: Perkhidmatan Berkomunikasi

Tahniah! Anda telah mempelajari corak asas komunikasi antara perkhidmatan dalam perkhidmatan mikro NestJS.

Request-Response (menggunakan client.send() dan @MessagePattern()) digunakan untuk interaksi langsung dan segera yang mengharapkan balasan.
Berasaskan Peristiwa (menggunakan client.emit() dan @EventPattern()) digunakan untuk komunikasi tak segerak dan dinyahgandingkan melalui peristiwa, sesuai untuk pemberitahuan dan penyiaran.

Pemilihan corak yang tepat bergantung pada keperluan khusus anda dari segi gandingan, daya tindak balas dan kebolehskalaan dalam sistem teragih anda.

Percuma untuk bermula

Pelajari TypeScript dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 20
Pelajaran: 76

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Komunikasi antara Perkhidmatan” percuma?

Ya — teks penuh “Komunikasi antara Perkhidmatan” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus API Bahagian Belakang Perusahaan NestJS, tingkat taraf kepada CoddyKit PRO. Kursus API Bahagian Belakang Perusahaan NestJS merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Komunikasi antara Perkhidmatan”?

Laksanakan corak untuk komunikasi berkesan antara mikroperkhidmatan, termasuk mekanisme berasaskan peristiwa dan permintaan-respons. Anda berlatih API Bahagian Belakang Perusahaan NestJS menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan API Bahagian Belakang Perusahaan NestJS?

Tiada pengalaman terdahulu diperlukan. Pembelajaran API Bahagian Belakang Perusahaan NestJS di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.

Berapa lamakah pelajaran “Komunikasi antara Perkhidmatan” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran API Bahagian Belakang Perusahaan NestJS ini?

Ya. Setiap pelajaran API Bahagian Belakang Perusahaan NestJS menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Gambaran Keseluruhan Mikroperkhidmatan NestJS
Integrasi RabbitMQ
Komunikasi antara Perkhidmatan

← Kembali ke API Bahagian Belakang Perusahaan NestJS