Cara nodejs diedarkan

Dengan pembangunan aplikasi Internet yang berterusan, selalunya sukar bagi satu pelayan untuk memenuhi keperluan konkurensi yang tinggi dan trafik yang besar. Untuk menyelesaikan masalah ini, sistem teragih telah wujud. Node.js ialah persekitaran berjalan JavaScript sebelah pelayan yang sangat popular. Ia menggunakan model I/O yang dipacu peristiwa, tidak menyekat dan boleh mengendalikan permintaan berkonkurensi tinggi dan berkemampuan tinggi. Walau bagaimanapun, kuasa pemprosesan satu proses Node.js masih terhad. Oleh itu, artikel ini akan memperkenalkan cara melaksanakan sistem teragih menggunakan Node.js.

Pengagihan merujuk kepada penguraian tugas kepada berbilang subtugas, menugaskan subtugas ini kepada nod kerja yang berbeza untuk dilaksanakan dan menyelesaikan keseluruhan tugasan secara kolaboratif melalui komunikasi rangkaian. Terdapat dua cara utama untuk melaksanakan sistem teragih dalam Node.js: satu ialah menggunakan mod berbilang proses dan satu lagi ialah menggunakan baris gilir mesej.

1. Gunakan mod berbilang proses

Node.js menyediakan API untuk mencipta proses kanak-kanak melalui modul child_process terbina dalam Kami boleh membuat berbilang proses kanak-kanak untuk memproses tugas yang sama secara serentak . Dalam mod berbilang proses, setiap sub-proses adalah bebas, dan data ditukar antara mereka melalui IPC (komunikasi antara proses).

1. Mod Master-Worker

Mod Master-Worker ialah salah satu mod berbilang proses paling klasik. Dalam mod ini, terdapat proses Induk dan berbilang proses Pekerja. Proses Induk bertanggungjawab untuk mengurus semua proses Pekerja, termasuk memulakan, menghentikan, memulakan semula, dsb., manakala proses Pekerja bertanggungjawab untuk memproses permintaan atau tugas tertentu.

Dalam Node.js, mod Master-Worker boleh dilaksanakan melalui modul kluster. Modul kluster ialah modul lanjutan yang dirangkumkan berdasarkan modul child_process Ia boleh melaksanakan mod Master-Worker dengan mudah, seperti yang ditunjukkan di bawah:

const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  console.log(`Master ${process.pid} is running`);

  // 当主进程被终止时，关闭所有工作进程
  process.on('SIGINT', () => {
    console.log('Received SIGINT. Shutting down workers...');
    for (const id in cluster.workers) {
      cluster.workers[id].kill();
    }
  });

  // 根据CPU数量创建工作进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }

  // 当有工作进程被断开连接（崩溃）时，自动重新启动
  cluster.on('exit', (worker, code, signal) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork();
  });
} else {
  console.log(`Worker ${process.pid} started`);

  // Workers可以处理具体的任务，例如下面是创建HTTP服务器的代码
  http.createServer((req, res) => {
    res.writeHead(200);
    res.end('Hello from worker!');
  }).listen(3000);
}

Kod di atas menunjukkan cara menggunakan modul kluster untuk mencipta proses Master. dan pelbagai proses Pekerja Dalam penggunaan sebenar, kami boleh meletakkan tugas dan logik perniagaan tertentu seperti pelayan HTTP ke dalam proses Pekerja untuk dilaksanakan.

2. Mod Kumpulan Proses

Mod Kumpulan Proses ialah mod berbilang proses yang lebih cekap. Dalam mod ini, kami boleh menggunakan semula proses yang telah dibuat untuk mencapai pengoptimuman prestasi. Secara amnya, bilangan proses dalam kumpulan proses harus dilaraskan secara dinamik mengikut bilangan CPU sistem untuk memastikan permintaan dapat dipenuhi di bawah beban yang tinggi.

Node.js tidak mempunyai modul kumpulan proses terbina dalam, tetapi kami boleh melaksanakannya melalui modul pihak ketiga. Sebagai contoh, modul kumpulan generik boleh digunakan untuk melaksanakan kumpulan proses Pekerja dengan mudah, seperti ditunjukkan di bawah:

const http = require('http');
const pool = require('generic-pool');
const numCPUs = require('os').cpus().length;

const workerFactory = {
  create: function() {
    return new Promise(resolve => {
      const worker = child_process.fork('./worker.js');
      worker.once('message', msg => {
        if (msg.ready) {
          resolve(worker);
        }
      });
    });
  },
  destroy: function(worker) {
    return new Promise(resolve => {
      worker.once('exit', () => {
        resolve();
      });
      worker.send('exit');
    });
  }
};

const workerPool = pool.createPool(workerFactory, { max: numCPUs });

// 创建HTTP服务器
http.createServer(async (req, res) => {
  const worker = await workerPool.acquire();
  worker.send({ type: 'request', path: req.url });
  worker.once('message', msg => {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(msg));
    workerPool.release(worker);
  });
}).listen(3000);

Kod di atas menunjukkan cara menggunakan modul kumpulan generik untuk mencipta kumpulan proses Pekerja dan memanggil proses dalam pelayan HTTP Pekerja dalam kumpulan mengendalikan permintaan tertentu.

2. Gunakan baris gilir mesej

Baris gilir mesej ialah mekanisme komunikasi teragih berdasarkan mod komunikasi tak segerak (tidak menyekat). Dalam mod baris gilir mesej, kita boleh menghantar mesej ke baris gilir, dan penerima mendapat mesej daripada baris gilir dan memprosesnya. Oleh itu, baris gilir mesej boleh menyelesaikan masalah seperti pengagihan tugas dan penghantaran data dalam sistem teragih, dan meningkatkan kebolehpercayaan dan skalabiliti sistem.

Terdapat banyak pelaksanaan baris gilir mesej dalam Node.js, seperti RabbitMQ, Redis, Kafka, dsb. Di sini kami mengambil RabbitMQ sebagai contoh untuk diperkenalkan.

1. Corak Pengeluar-Pengguna

Corak Pengeluar-Pengguna ialah corak baris gilir mesej klasik. Dalam mod ini, pengeluar bertanggungjawab untuk menghantar mesej ke baris gilir, dan pengguna bertanggungjawab untuk mendapatkan mesej daripada baris gilir dan memprosesnya.

Dalam Node.js, anda boleh menggunakan modul amqp.node untuk menyambung ke RabbitMQ dan menggunakan konsep seperti baris gilir dan suis untuk melaksanakan model pengeluar-pengguna. Berikut ialah contoh mudah:

const amqp = require('amqp');
const connection = amqp.createConnection({ host: 'localhost' });

// 连接RabbitMQ服务器
connection.on('ready', function() {
  console.log('Connected to RabbitMQ');

  // 创建消息队列
  connection.queue('hello-queue', { durable: true }, function(queue) {
    console.log('Created queue: ' + queue.name);

    // 创建消息生产者
    setInterval(function() {
      const message = 'Hello ' + new Date();
      console.log('Sending message: ' + message);
      connection.publish(queue.name, message, { persistent: true });
    }, 1000);

    // 创建消息消费者
    queue.subscribe(function(message) {
      console.log('Received message: ' + message.data.toString());
    });
  });
});

Kod di atas menunjukkan cara menggunakan modul amqp.node untuk menyambung ke pelayan RabbitMQ dan mencipta pengeluar dan pengguna. Pengeluar menghantar mesej ke baris gilir setiap 1 saat, dan pengguna mendapat mesej daripada baris gilir dan memprosesnya.

2. Corak Terbit-Langgan

Corak Terbit-Langgan ialah satu lagi corak baris gilir mesej biasa. Dalam mod ini, terdapat penerbit mesej dan berbilang pelanggan mesej. Penerbit menghantar mesej kepada topik dan pelanggan boleh mendapatkan mesej daripada topik itu mengikut peraturan langganan mereka sendiri.

Dalam Node.js, kami juga boleh menggunakan modul amqp.node untuk melaksanakan mod publish-subscribe. Berikut ialah contoh mudah:

const amqp = require('amqp');
const connection = amqp.createConnection({ host: 'localhost' });

// 连接RabbitMQ服务器
connection.on('ready', function() {
  console.log('Connected to RabbitMQ');

  // 创建消息主题
  const exchange = connection.exchange('logs', { type: 'fanout' }, function() {
    console.log('Created exchange: ' + exchange.name);

    // 创建消息订阅者
    connection.queue('', { exclusive: true }, function(queue) {
      console.log('Created queue: ' + queue.name);
      queue.bind(exchange, '');

      queue.subscribe(function(message) {
        console.log('Received message: ' + message.data.toString());
      });
    });

    // 创建消息发布者
    setInterval(function() {
      const message = 'Hello ' + new Date();
      console.log('Sending message: ' + message);
      exchange.publish('', message);
    }, 1000);
  });
});

Kod di atas menunjukkan cara menggunakan modul amqp.node untuk mencipta topik mesej, pelanggan mesej dan penerbit mesej. Penerbit menghantar mesej kepada topik setiap 1 saat, dan pelanggan mendapat mesej daripada topik dan memprosesnya.

Ringkasan

Artikel ini memperkenalkan cara menggunakan Node.js untuk melaksanakan sistem teragih. Dalam aplikasi praktikal, kita boleh memilih mekanisme komunikasi teragih yang berbeza mengikut keperluan perniagaan tertentu, seperti menggunakan mod berbilang proses atau mod baris gilir mesej. Tidak kira kaedah yang anda pilih, anda perlu memberi perhatian kepada isu seperti kebolehpercayaan, kebolehskalaan dan keselamatan sistem teragih.

Atas ialah kandungan terperinci Cara nodejs diedarkan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!