ภาพรวมไมโครเซอร์วิสของ NestJS
ตั้งค่าไมโครเซอร์วิสของ NestJS โดยใช้ตัวขนส่งหลากหลาย เช่น TCP, Redis และ RabbitMQ พร้อมทำความเข้าใจแนวคิดหลัก
ภาพรวมไมโครเซอร์วิสของ NestJS เป็นบทเรียน NestJS Enterprise Backend APIs ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน NestJS Enterprise Backend APIs และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส NestJS Enterprise Backend APIs มีบทเรียนทั้งหมด 3 บทเรียน
บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ
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?
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!
เรียนรู้ TypeScript ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 20
- บทเรียน
- 76
คำถามที่พบบ่อย
บทเรียน “ภาพรวมไมโครเซอร์วิสของ NestJS” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ภาพรวมไมโครเซอร์วิสของ NestJS” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส NestJS Enterprise Backend APIs ให้อัปเกรดเป็น CoddyKit PRO คอร์ส NestJS Enterprise Backend APIs มีบทเรียนทั้งหมด 3 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “ภาพรวมไมโครเซอร์วิสของ NestJS”
ตั้งค่าไมโครเซอร์วิสของ NestJS โดยใช้ตัวขนส่งหลากหลาย เช่น TCP, Redis และ RabbitMQ พร้อมทำความเข้าใจแนวคิดหลัก คุณปฏิบัติ NestJS Enterprise Backend APIs ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน NestJS Enterprise Backend APIs หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน NestJS Enterprise Backend APIs บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 3 บทเรียน
บทเรียน “ภาพรวมไมโครเซอร์วิสของ NestJS” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน NestJS Enterprise Backend APIs นี้ได้ไหม
ได้ บทเรียน NestJS Enterprise Backend APIs ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ภาพรวมไมโครเซอร์วิสของ NestJS
- การผสานรวม RabbitMQ
- การสื่อสารระหว่างบริการ