Menskalakan Aplikasi Node.js: Amalan, Teknik dan Alat Terbaik

Apabila aplikasi Node.js anda semakin popular, pengendalian lebih ramai pengguna, permintaan dan data akan menjadi perlu. Penskalaan memastikan aplikasi anda kekal responsif dan berfungsi dengan cekap di bawah beban yang semakin meningkat. Dalam artikel ini, kami akan meneroka pelbagai cara untuk menskalakan aplikasi Node.js, sebab ia penting dan memberikan contoh dunia sebenar dengan coretan kod yang berkaitan. Kami juga akan merangkumi alatan dan teknik biasa, seperti pengelompokan, pengimbangan beban, perkhidmatan mikro dan penskalaan mendatar.

Mengapa Penskalaan Penting?

Penskalaan membolehkan aplikasi Node.js anda mengendalikan peningkatan bilangan pengguna dan transaksi tanpa kesesakan prestasi atau masa henti. Jika permohonan anda tidak berskala secukupnya:

• Isu prestasi: Masa tindak balas boleh meningkat, menyebabkan kekecewaan pengguna.
• Lebihan beban sistem: Pelayan mungkin ranap di bawah beban berat, mengakibatkan masa henti.
• Pengalaman pengguna yang lemah: Apl yang perlahan atau tidak bertindak balas menyebabkan pengguna tercicir, menjejaskan matlamat perniagaan.

Strategi Penskalaan untuk Node.js

Terdapat dua jenis penskalaan utama:

1. Penskalaan Menegak: Meningkatkan kapasiti pelayan tunggal dengan menaik taraf perkakasannya (cth., lebih banyak CPU, memori). Ini boleh membantu dalam jangka pendek tetapi mempunyai had, kerana sumber pelayan hanya boleh berkembang dengan begitu banyak.
2. Penskalaan Mendatar: Menambah lebih banyak pelayan atau kejadian untuk mengendalikan permintaan. Pendekatan ini mengagihkan beban merentas berbilang mesin atau perkhidmatan dan lebih mampan untuk aplikasi berskala besar.

Dalam aplikasi Node.js, penskalaan mendatar selalunya menjadi pilihan pilihan. Mari terokai kaedah untuk menskalakan Node.js secara mendatar.

1. Pengelompokan dalam Node.js

Node.js adalah satu-benang secara semula jadi, bermakna ia berjalan pada satu teras. Pengelompokan membolehkan anda menjalankan berbilang contoh aplikasi Node.js anda, setiap satu pada teras CPU yang berbeza, menggunakan potensi penuh mesin berbilang teras.

Contoh Kod: Pengelompokan dalam 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`);
}

Penjelasan:

• Proses induk menghasilkan proses pekerja untuk setiap teras CPU yang tersedia.
• Pekerja berkongsi pelabuhan yang sama, dan permintaan diedarkan di kalangan mereka.
• Jika pekerja mengalami kemalangan, pekerja baharu akan bercabang.

Pendekatan ini membolehkan aplikasi Node.js anda mengendalikan lebih banyak permintaan secara serentak, memanfaatkan berbilang teras.

2. Pengimbangan Beban dengan NGINX

Untuk menskala secara mendatar, anda boleh menggunakan berbilang tika aplikasi Node.js anda merentas pelayan yang berbeza. Pengimbangan beban memastikan trafik diagihkan secara sama rata merentas keadaan ini, menghalang mana-mana pelayan tunggal daripada terharu.

NGINX ialah alat yang berkuasa untuk mengimbangi beban. Begini cara untuk mengkonfigurasinya.

Konfigurasi Pengimbangan Beban NGINX

1. Pasang NGINX jika ia belum dipasang (lihat Artikel 6 untuk langkah pemasangan).
2. Buka fail konfigurasi NGINX untuk aplikasi anda:

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

1. Tambah konfigurasi pengimbangan beban:

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. Simpan dan keluar daripada fail.
2. Uji dan mulakan semula NGINX:

   sudo nginx -t
   sudo systemctl restart nginx

Penjelasan:

• Blok huluan mentakrifkan berbilang kejadian Node.js (127.0.0.1:3000, 127.0.0.1:3001, dsb.).
• NGINX akan membuat permintaan round-robin kepada kejadian ini, mengagihkan trafik secara sama rata.

Dengan menambahkan lebih banyak pelayan atau kejadian, anda boleh mengecilkan dan memberi perkhidmatan kepada lebih ramai pengguna secara serentak.

3. Menggunakan Microservices untuk Skala Node.js

Satu lagi pendekatan biasa untuk menskalakan aplikasi Node.js ialah memecahkan aplikasi monolitik kepada perkhidmatan yang lebih kecil dan dipisahkan dikenali sebagai perkhidmatan mikro. Setiap perkhidmatan mikro mengendalikan bahagian tertentu fungsi (cth., pengesahan, pembayaran, pengurusan pengguna) dan berkomunikasi dengan orang lain melalui API.

Contoh Kod: Microservice Architecture

Perkhidmatan Mikro Pengguna (perkhidmatan pengguna.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');
});

Pesan Microservice (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');
});

Gerbang 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');
});

Penjelasan:

• 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.

Atas ialah kandungan terperinci Menskalakan Aplikasi Node.js: Amalan, Teknik dan Alat Terbaik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!