0Pricing
Node.js Backend Development Bootcamp · บทเรียน

การพัฒนาไมโครเซอร์วิสด้วย Node.js

สร้างบริการ Node.js ที่เป็นอิสระและสื่อสารระหว่างกัน โดยมุ่งเน้นการออกแบบที่ขับเคลื่อนด้วยโดเมน

การพัฒนาไมโครเซอร์วิสด้วย Node.js เป็นบทเรียน Node.js Backend Development Bootcamp ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Node.js Backend Development Bootcamp และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Node.js Backend Development Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

Node.js Microservices Intro

Welcome to building Node.js microservices! We'll explore how to create small, independent services that work together.

A microservice is an architectural style where an application is built as a collection of small, autonomous services, each running in its own process and communicating with lightweight mechanisms, often an HTTP API.

การพัฒนาไมโครเซอร์วิสด้วย Node.js — ภาพประกอบ 1

Core Microservice Principles

Microservices follow key principles:

  • Independent Deployment: Each service can be deployed independently.
  • Loose Coupling: Services are not tightly dependent on each other.
  • Single Responsibility: Each service focuses on a specific business capability (a 'domain').
  • Technology Diversity: Different services can use different technologies (though we'll stick to Node.js here).

Domain-Driven Design Basics

Domain-Driven Design (DDD) is crucial for microservices. It means structuring your services around business domains (e.g., 'Users', 'Products', 'Orders').

  • Bounded Contexts: Each microservice defines its own clear boundary, owning its specific domain data and logic.
  • Ubiquitous Language: Using a common language for domain concepts within that service.

Structuring a Node.js Service

A typical Node.js microservice project might have a structure like this:

  • my-service/
  •   src/
  •     controllers/ (logic for requests)
  •     models/ (data schemas)
  •     routes/ (API endpoints)
  •     app.js (main Express setup)
  •   package.json
  •   .env (environment variables)

Inter-Service Communication

Microservices need to communicate to fulfill requests. Common methods include:

  • HTTP/REST: Synchronous calls between services. One service makes an HTTP request to another.
  • Message Queues: Asynchronous communication via a message broker (e.g., RabbitMQ, Kafka). Services publish events and subscribe to others.

For this lesson, we'll focus on HTTP communication due to its simplicity.

Building a User Microservice

Let's create a simple 'Users' microservice using Express. This service will manage user data and run on port 3001.

Try running this code:

const express = require('express');
const app = express();
const PORT = 3001;

app.use(express.json());

const users = [
  { id: 'u1', name: 'Alice', email: 'alice@example.com' },
  { id: 'u2', name: 'Bob', email: 'bob@example.com' }
];

app.get('/users/:id', (req, res) => {
  const user = users.find(u => u.id === req.params.id);
  if (user) {
    res.json(user);
  } else {
    res.status(404).send('User not found');
  }
});

app.get('/users', (req, res) => {
  res.json(users);
});

app.listen(PORT, () => {
  console.log(`Users Service running on port ${PORT}`);
});

Building a Product Microservice

Now, let's create a separate 'Products' microservice. This service will manage product data and run on port 3002.

This is a completely independent application:

const express = require('express');
const app = express();
const PORT = 3002;

app.use(express.json());

const products = [
  { id: 'p1', name: 'Laptop', price: 1200, ownerId: 'u1' },
  { id: 'p2', name: 'Mouse', price: 25, ownerId: 'u2' }
];

app.get('/products', (req, res) => {
  res.json(products);
});

app.listen(PORT, () => {
  console.log(`Products Service running on port ${PORT}`);
});

Simulating Service Communication

How would the 'Products' service get user details for a product's owner? It makes an HTTP call to the 'Users' service!

In this example, we simulate both a mini-server (for users) and a client (fetching user data) in one script to show the communication flow. This client part is what your Product service would do.

const http = require('http');

// --- SIMULATED USER SERVICE (SERVER PART) ---
const users = {
  'u1': { id: 'u1', name: 'Alice', email: 'alice@example.com' },
  'u2': { id: 'u2', name: 'Bob', email: 'bob@example.com' }
};

const simulatedUserServer = http.createServer((req, res) => {
  if (req.url.startsWith('/users/') && req.method === 'GET') {
    const userId = req.url.split('/')[2];
    if (users[userId]) {
      res.writeHead(200, { 'Content-Type': 'application/json' });
      res.end(JSON.stringify(users[userId]));
    } else {
      res.writeHead(404, { 'Content-Type': 'text/plain' });
      res.end('User not found');
    }
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('Not Found');
  }
});

const SIMULATED_PORT = 3001;
simulatedUserServer.listen(SIMULATED_PORT, () => {
  console.log(`Simulated User Service running on port ${SIMULATED_PORT}`);
});

// --- CLIENT PART (e.g., a Product Service trying to get user data) ---
async function fetchUserFromSimulatedService(userId) {
  return new Promise((resolve, reject) => {
    const options = {
      hostname: 'localhost',
      port: SIMULATED_PORT,
      path: `/users/${userId}`,
      method: 'GET'
    };

    const req = http.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => data += chunk);
      res.on('end', () => {
        if (res.statusCode === 200) {
          resolve(JSON.parse(data));
        } else {
          reject(new Error(`Failed to fetch user: ${res.statusCode}`));
        }
      });
    });

    req.on('error', (e) => reject(e));
    req.end();
  });
}

console.log('\n--- Product Service fetching user data simulation ---');
fetchUserFromSimulatedService('u1')
  .then(user => console.log('Fetched User:', user))
  .catch(error => console.error('Error fetching user:', error.message))
  .finally(() => {
    // Important: close the simulated server after demonstration
    simulatedUserServer.close(() => console.log('Simulated User Service stopped.'));
  });

fetchUserFromSimulatedService('u3') // Try fetching a non-existent user
  .then(user => console.log('Fetched User:', user))
  .catch(error => console.error('Error fetching user:', error.message));

Microservice Trade-offs

While powerful, microservices come with trade-offs:

  • Increased Complexity: More services mean more to manage, deploy, and monitor.
  • Data Consistency: Maintaining data consistency across multiple databases can be challenging.
  • Distributed Transactions: Operations spanning multiple services require careful design.
  • Operational Overhead: Requires robust CI/CD and monitoring tools.

Quick Check: Microservice Benefits

Based on what you've learned, which of the following is a primary benefit of using a microservices architecture?

Recap & Next Steps

We've covered the basics of developing Node.js microservices, understanding their core principles, and how they communicate. We saw how to structure small, domain-focused services and even simulated inter-service communication.

While powerful, remember the trade-offs in complexity. Next, you'll learn how to manage client requests to these services using an API Gateway!

คำถามที่พบบ่อย

บทเรียน “การพัฒนาไมโครเซอร์วิสด้วย Node.js” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การพัฒนาไมโครเซอร์วิสด้วย Node.js” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Node.js Backend Development Bootcamp ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Node.js Backend Development Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การพัฒนาไมโครเซอร์วิสด้วย Node.js”

สร้างบริการ Node.js ที่เป็นอิสระและสื่อสารระหว่างกัน โดยมุ่งเน้นการออกแบบที่ขับเคลื่อนด้วยโดเมน คุณปฏิบัติ Node.js Backend Development Bootcamp ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Node.js Backend Development Bootcamp หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Node.js Backend Development Bootcamp บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การพัฒนาไมโครเซอร์วิสด้วย Node.js” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Node.js Backend Development Bootcamp นี้ได้ไหม

ได้ บทเรียน Node.js Backend Development Bootcamp ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. บทนำสู่สถาปัตยกรรมไมโครเซอร์วิส
  2. การพัฒนาไมโครเซอร์วิสด้วย Node.js
  3. การใช้งานเกตเวย์ API
  4. การสื่อสารระหว่างบริการด้วยคิวข้อความ
← กลับไปที่ Node.js Backend Development Bootcamp