Node.js アプリケーションのスケーリング: ベスト プラクティス、テクニック、ツール

Node.js アプリケーションの人気が高まるにつれて、より多くのユーザー、リクエスト、データを処理することが必要になります。スケーリングにより、負荷が増加してもアプリケーションの応答性が維持され、効率的に実行されます。この記事では、Node.js アプリケーションをスケーリングするさまざまな方法とそれが不可欠な理由を検討し、関連するコード スニペットを含む実際の例を示します。クラスタリング、負荷分散、マイクロサービス、水平スケーリングなどの一般的なツールや手法についても説明します。

スケーリングが重要な理由

スケーリングにより、Node.js アプリケーションはパフォーマンスのボトルネックやダウンタイムを発生させることなく、増加するユーザーとトランザクションを処理できるようになります。アプリケーションが適切にスケーリングされていない場合:

• パフォーマンスの問題: 応答時間が長くなり、ユーザーの不満を引き起こす可能性があります。
• システムの過負荷: 負荷が高いとサーバーがクラッシュし、ダウンタイムが発生する可能性があります。
• ユーザー エクスペリエンスが悪い: アプリが遅い、または応答しない場合、ユーザーの離脱につながり、ビジネス目標に影響を与えます。

Node.js のスケーリング戦略

スケーリングには主に 2 つのタイプがあります:

1. 垂直スケーリング: ハードウェアをアップグレードして単一サーバーの容量を増加します (CPU、メモリの増設など)。これは短期的には役に立ちますが、サーバー リソースの増加には限界があるため、限界があります。
2. 水平スケーリング: リクエストを処理するサーバーまたはインスタンスを追加します。このアプローチは、複数のマシンまたはサービスに負荷を分散し、大規模なアプリケーションの持続可能性を高めます。

Node.js アプリケーションでは、多くの場合、水平スケーリングが推奨されます。 Node.js を水平方向にスケーリングする方法を見てみましょう。

1. Node.js でのクラスタリング

Node.js は本質的にシングルスレッドです。つまり、単一のコアで実行されます。クラスタリングを使用すると、Node.js アプリケーションの複数のインスタンスをそれぞれ異なる CPU コアで実行し、マルチコア マシンの可能性を最大限に活用できます。

コード例: Node.js でのクラスタリング

const cluster = require('cluster');
const http = require('http');
const os = require('os');

// Check if current process is the master
if (cluster.isMaster) {
  // Get number of CPU cores
  const numCPUs = os.cpus().length;

  // Fork workers
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // Listen for dying workers and replace them
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died. Starting a new worker...`);
    cluster.fork();
  });

} else {
  // Workers can share any TCP connection
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello from worker ' + process.pid);
  }).listen(8000);

  console.log(`Worker ${process.pid} started`);
}

説明:

• マスター プロセスは、利用可能な CPU コアごとにワーカー プロセスを生成します。
• ワーカーは同じポートを共有し、リクエストはワーカー間で分散されます。
• ワーカーがクラッシュすると、新しいワーカーがフォークされます。

このアプローチにより、Node.js アプリケーションは複数のコアを活用して、より多くのリクエストを同時に処理できるようになります。

2. NGINX による負荷分散

水平方向にスケールするには、Node.js アプリケーションの複数のインスタンスを異なるサーバーにデプロイできます。負荷分散により、トラフィックがこれらのインスタンス間で均等に分散され、単一のサーバーが過負荷になるのを防ぎます。

NGINX は、負荷分散のための強力なツールです。設定方法は次のとおりです。

NGINX ロード バランシングの構成

1. まだインストールされていない場合は、NGINX をインストールします (インストール手順については記事 6 を参照してください)。
2. アプリケーションの NGINX 構成ファイルを開きます。

   sudo nano /etc/nginx/sites-available/nodeapp.conf

1. 負荷分散構成を追加します。

upstream node_backend {
    server 127.0.0.1:3000;
    server 127.0.0.1:3001;
    server 127.0.0.1:3002;
}

server {
    listen 80;
    server_name your_domain_or_IP;

    location / {
        proxy_pass http://node_backend;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

1. ファイルを保存して終了します。
2. NGINX をテストして再起動します。

   sudo nginx -t
   sudo systemctl restart nginx

説明:

• 上流ブロックは複数の Node.js インスタンス (127.0.0.1:3000、127.0.0.1:3001 など) を定義します。
• NGINX はこれらのインスタンスへのリクエストをラウンドロビン処理し、トラフィックを均等に分散します。

サーバーまたはインスタンスを追加すると、スケールアウトしてより多くのユーザーに同時にサービスを提供できます。

3. マイクロサービスを使用して Node.js をスケールする

Node.js アプリケーションを拡張するためのもう 1 つの一般的なアプローチは、モノリシック アプリケーションを マイクロサービス として知られる、より小さく分離されたサービスに分割することです。各マイクロサービスは、機能の特定の部分 (認証、支払い、ユーザー管理など) を処理し、API を介して他のマイクロサービスと通信します。

コード例: マイクロサービス アーキテクチャ

ユーザー マイクロサービス (user-service.js):

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

app.get('/user/:id', (req, res) => {
    const userId = req.params.id;
    res.send(`User details for ID: ${userId}`);
});

app.listen(3001, () => {
    console.log('User service listening on port 3001');
});

マイクロサービスの注文 (order-service.js):

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

app.get('/order/:id', (req, res) => {
    const orderId = req.params.id;
    res.send(`Order details for ID: ${orderId}`);
});

app.listen(3002, () => {
    console.log('Order service listening on port 3002');
});

API ゲートウェイ:

const express = require('express');
const app = express();
const request = require('request');

app.get('/user/:id', (req, res) => {
    request(`http://localhost:3001/user/${req.params.id}`).pipe(res);
});

app.get('/order/:id', (req, res) => {
    request(`http://localhost:3002/order/${req.params.id}`).pipe(res);
});

app.listen(3000, () => {
    console.log('API Gateway listening on port 3000');
});

説明:

• The application is divided into two microservices: one for users and one for orders.
• An API Gateway routes incoming requests to the appropriate microservice.
• Each microservice is lightweight and independent, making the system easier to scale and manage.

4. Scaling Node.js with Containerization (Docker)

Containers provide an efficient way to package your application and its dependencies, ensuring consistency across different environments (development, testing, production). Docker is a popular tool for containerization.

Docker Example: Node.js Application

1. Create a Dockerfile in your Node.js project:

# Use an official Node.js runtime as the base image
FROM node:14

# Set the working directory
WORKDIR /usr/src/app

# Copy package.json and install dependencies
COPY package*.json ./
RUN npm install

# Copy the application source code
COPY . .

# Expose the port the app runs on
EXPOSE 3000

# Start the Node.js application
CMD ["node", "app.js"]

1. Build and run the Docker container:

docker build -t nodeapp .
docker run -p 3000:3000 nodeapp

With Docker, you can easily scale your application by running multiple containers across different servers or environments.

5. Scaling with Kubernetes

Kubernetes is a powerful tool for automating the deployment, scaling, and management of containerized applications. When you need to run your Node.js application in multiple containers, Kubernetes helps in orchestration, ensuring availability and scalability.

Here’s a high-level view of how to scale Node.js applications with Kubernetes:

1. Containerize your Node.js app using Docker (as shown above).
2. Deploy the Docker container to Kubernetes clusters.
3. Scale up or down the number of containers dynamically using Kubernetes kubectl scale commands or by setting auto-scaling policies.

Conclusion

Scaling your Node.js application is critical for handling increased traffic, ensuring high availability, and delivering a consistent user experience. Techniques such as clustering, load balancing, microservices, and containerization provide powerful ways to scale horizontally. With tools like NGINX, Docker, and Kubernetes, you can efficiently scale your Node.js application to meet growing demands. By implementing these strategies, you’ll be prepared to handle both current and future traffic spikes with ease.

以上がNode.js アプリケーションのスケーリング: ベスト プラクティス、テクニック、ツールの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。