Node.js Backend Development Bootcamp · 课时

开发 Node.js 微服务

构建能够相互通信的独立 Node.js 服务，重点学习领域驱动设计

开发 Node.js 微服务 是 CoddyKit 上的免费 Node.js Backend Development Bootcamp 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 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.

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 导师）并解锁 Node.js Backend Development Bootcamp 课程的其余内容，请升级到 CoddyKit PRO。 Node.js Backend Development Bootcamp 课程共包含 4 节课。

「开发 Node.js 微服务」这节课中我会学到什么？

构建能够相互通信的独立 Node.js 服务，重点学习领域驱动设计你通过在浏览器中直接运行的动手代码来练习 Node.js Backend Development Bootcamp，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Node.js Backend Development Bootcamp 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Node.js Backend Development Bootcamp 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「开发 Node.js 微服务」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Node.js Backend Development Bootcamp 课中编写并运行代码吗？

能。每节 Node.js Backend Development Bootcamp 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Node.js Backend Development Bootcamp