Node.js Backend Development Bootcamp · レッスン

Node.jsマイクロサービスの開発

ドメイン駆動設計に焦点を当て、相互に通信する独立したNode.jsサービスを構築します。

「Node.jsマイクロサービスの開発」はCoddyKit上の無料Node.js Backend Development Bootcampレッスンです。これはレッスン2/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応の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マイクロサービスの開発」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、Node.js Backend Development Bootcampコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 Node.js Backend Development Bootcampコースには全4レッスンが含まれています。

「Node.jsマイクロサービスの開発」で何を学びますか？

ドメイン駆動設計に焦点を当て、相互に通信する独立したNode.jsサービスを構築します。ブラウザで直接実行するハンズオンコードでNode.js Backend Development Bootcampを演習し、24時間対応の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に戻る