Cara Membuat Kluster Node.js Untuk Mempercepatkan Aplikasi Anda

mata teras

node.js telah menjadi persekitaran yang dijalankan oleh pelayan yang popular untuk mengendalikan laman web trafik tinggi dengan seni bina yang didorong oleh peristiwa dan tidak menyekat I/O API, yang membolehkan pemprosesan permintaan tak segerak.
skalabiliti node.js adalah ciri utama yang diadopsi oleh syarikat besar. Walaupun dijalankan dalam satu benang secara lalai dan mempunyai had memori, Node.js boleh melanjutkan aplikasi melalui modul kluster untuk memecah proses tunggal ke dalam pelbagai proses atau proses pekerja.
modul kluster node.js berfungsi dengan melaksanakan proses node.js yang sama beberapa kali. Ia membolehkan proses utama dikenalpasti dan membuat proses pekerja yang boleh berkongsi pemegang pelayan dan berkomunikasi dengan proses nod induk.
Aplikasi Node.js boleh dipasangkan menggunakan modul kluster, yang membolehkan pelbagai proses dijalankan secara serentak. Ini meningkatkan kecekapan sistem, meningkatkan prestasi aplikasi, dan meningkatkan kebolehpercayaan dan uptime.
Walaupun modul kluster Node.js disyorkan terutamanya untuk pelayan web, ia juga boleh digunakan untuk aplikasi lain apabila mempertimbangkan peruntukan tugas dengan teliti antara proses pekerja dan komunikasi yang berkesan antara proses pekerja dan proses utama.

node.js menjadi semakin popular sebagai persekitaran yang berjalan di sisi pelayan, terutamanya dalam laman web trafik tinggi, dan statistik juga membuktikannya. Selain itu, ketersediaan pelbagai kerangka menjadikannya persekitaran yang baik untuk prototaip pesat. Node.js mempunyai seni bina yang didorong oleh peristiwa yang menggunakan API I/O yang tidak menyekat untuk membolehkan pemprosesan permintaan yang tidak segerak. Ciri yang penting dan sering diabaikan dari Node.js adalah skalabilitasnya. Malah, ini adalah sebab utama mengapa sesetengah syarikat besar mengintegrasikan node.js (seperti Microsoft, Yahoo, Uber, dan Walmart) ke platform mereka dan juga memindahkan operasi pelayan mereka sepenuhnya ke Node.js (seperti PayPal, eBay , dan Groupon). Setiap proses Node.js berjalan dalam satu benang, secara lalai, had memori untuk sistem 32-bit adalah 512MB dan had memori untuk sistem 64-bit ialah 1GB. Walaupun had memori boleh ditingkatkan kepada kira-kira 1GB pada sistem 32-bit dan kira-kira 1.7GB pada sistem 64-bit, memori dan kuasa pemprosesan masih boleh menjadi hambatan untuk pelbagai proses. Penyelesaian yang elegan yang Node.js menyediakan aplikasi yang diperluaskan adalah untuk memecah proses tunggal ke dalam pelbagai proses atau proses pekerja dalam istilah Node.js. Ini boleh dicapai melalui modul kluster. Modul kluster membolehkan anda membuat proses kanak -kanak (proses kerja) yang berkongsi semua port pelayan dengan proses nod utama (proses utama). Dalam artikel ini, anda akan belajar bagaimana untuk membuat kluster Node.js untuk mempercepat permohonan anda.

modul kluster node.js: Apa yang dilakukannya dan bagaimana ia berfungsi

Kluster adalah kumpulan proses pekerja yang serupa yang berjalan di bawah proses nod induk. Proses pekerja dijana menggunakan kaedah Fork () modul Child_processes. Ini bermakna proses pekerja boleh berkongsi pemegang pelayan dan berkomunikasi dengan proses nod induk menggunakan IPC (komunikasi interprocess). Proses utama bertanggungjawab untuk memulakan dan mengawal proses kerja. Anda boleh membuat banyak proses pekerja yang anda suka dalam proses utama. Juga, ingat bahawa secara lalai, sambungan masuk diperuntukkan pengundian antara proses pekerja (kecuali Windows). Sebenarnya, terdapat satu lagi cara untuk memperuntukkan sambungan masuk, yang saya tidak akan membincangkan di sini, menyerahkan tugasan kepada sistem operasi (tetapan lalai di Windows). Dokumentasi Node.js mengesyorkan menggunakan gaya pengundian lalai sebagai dasar penjadualan. Walaupun menggunakan modul kluster terdengar rumit dalam teori, pelaksanaannya sangat mudah. Untuk memulakan menggunakannya, anda perlu memasukkannya ke dalam aplikasi Node.js anda:

<code class="language-javascript">var cluster = require('cluster');</code>

Modul kluster melaksanakan proses node.js yang sama beberapa kali. Oleh itu, perkara pertama yang perlu anda lakukan ialah menentukan bahagian kod yang digunakan untuk proses utama dan bahagian kod yang digunakan untuk proses pekerja. Modul kluster membolehkan anda mengenal pasti proses utama seperti berikut:

<code class="language-javascript">if(cluster.isMaster) { ... }</code>

Proses utama adalah proses yang anda mulakan, yang seterusnya memulakan proses pekerja. Untuk memulakan proses pekerja dalam proses utama, kami akan menggunakan kaedah garpu ():

<code class="language-javascript">cluster.fork();</code>

Kaedah ini mengembalikan objek pekerja yang mengandungi beberapa kaedah dan sifat mengenai pekerja yang diperolehi. Kami akan melihat beberapa contoh di bahagian seterusnya. Modul kluster mengandungi pelbagai peristiwa. Dua peristiwa biasa yang berkaitan dengan permulaan proses pekerja dan momen penamatan adalah acara dalam talian dan keluar. Apabila proses pekerja memperoleh dan menghantar mesej dalam talian, acara dalam talian dipancarkan. Apabila proses pekerja mati, acara keluar dipancarkan. Kemudian, kita akan belajar bagaimana menggunakan kedua -dua peristiwa ini untuk mengawal kitaran hayat proses pekerja. Sekarang, mari kita buat semua yang telah kita lihat setakat ini dan tunjukkan contoh yang lengkap.

Contoh

Bahagian ini mengandungi dua contoh. Contoh pertama adalah aplikasi mudah yang menunjukkan cara menggunakan modul kluster dalam aplikasi Node.js. Contoh kedua adalah pelayan ekspres yang mengambil kesempatan daripada modul kluster Node.js, yang merupakan sebahagian daripada kod pengeluaran yang biasanya saya gunakan dalam projek berskala besar. Kedua -dua contoh boleh didapati untuk dimuat turun dari GitHub.

cara menggunakan modul kluster dalam aplikasi node.js

Dalam contoh pertama ini, kami menyediakan pelayan mudah yang memberi respons kepada semua permintaan masuk menggunakan mesej yang mengandungi ID Proses Pekerja yang mengendalikan permintaan. Proses utama memperoleh empat proses pekerja. Dalam setiap proses pekerja, kami mula mendengar port 8000 untuk menerima permintaan masuk. Kod yang melaksanakan apa yang saya nyatakan adalah seperti berikut:

<code class="language-javascript">var cluster = require('cluster');
var http = require('http');
var numCPUs = 4;

if (cluster.isMaster) {
    for (var i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
} else {
    http.createServer(function(req, res) {
        res.writeHead(200);
        res.end('process ' + process.pid + ' says hello!');
    }).listen(8000);
}</code>

Anda boleh mengakses URL dengan memulakan pelayan (menjalankan nod perintah simps.js) dan mengakses url https://www.php.cn/link/7D2D180C45C41870F36E747816456190 .

bagaimana untuk membangunkan pelayan ekspres yang sangat berskala

Express adalah salah satu kerangka aplikasi web yang paling popular untuk Node.js (jika bukan yang paling popular). Kami telah menutupnya beberapa kali di laman web ini. Jika anda berminat untuk mempelajari lebih lanjut, saya cadangkan anda membaca artikel "Membuat API RESTful dengan Express 4" dan "Membina Node.js-Driven Chat Room Web Aplikasi: Express and Azure". Contoh kedua menunjukkan bagaimana untuk membangunkan pelayan ekspres yang sangat berskala. Ia juga menunjukkan bagaimana untuk memindahkan pelayan proses tunggal untuk memanfaatkan modul kluster dengan sedikit kod.

<code class="language-javascript">var cluster = require('cluster');</code>

Tambahan pertama untuk contoh ini adalah menggunakan modul OS Node.js untuk mendapatkan bilangan teras CPU. Modul OS mengandungi fungsi CPU () yang mengembalikan pelbagai teras CPU. Dengan menggunakan pendekatan ini, kita boleh menentukan secara dinamik bilangan proses pekerja untuk mendapatkan berdasarkan spesifikasi pelayan untuk memaksimumkan penggunaan sumber. Penambahan kedua dan lebih penting adalah untuk menangani kematian proses kerja. Apabila proses pekerja mati, modul kluster akan mengeluarkan acara keluar. Ia boleh diproses dengan mendengar acara itu dan melaksanakan fungsi panggil balik apabila ia dipancarkan. Anda boleh melakukan ini dengan menulis kenyataan seperti cluster.on ('keluar', panggilan balik); Dalam fungsi panggil balik, kami memperoleh proses pekerja baru untuk mengekalkan bilangan proses pekerja yang dijangkakan. Ini membolehkan kami memastikan aplikasi berjalan walaupun dengan beberapa pengecualian yang tidak diawali. Dalam contoh ini, saya juga menyediakan pendengar untuk acara dalam talian, yang dipancarkan apabila proses pekerja diperoleh dan bersedia untuk menerima permintaan masuk. Ini boleh digunakan untuk pembalakan atau operasi lain.

Perbandingan prestasi

Terdapat beberapa alat untuk menanda aras API, tetapi di sini saya menggunakan alat penanda aras Apache untuk menganalisis bagaimana menggunakan modul kluster mempengaruhi prestasi aplikasi. Untuk menubuhkan ujian, saya membangunkan pelayan Express yang mempunyai laluan dan fungsi panggil balik untuk laluan itu. Dalam fungsi panggil balik, lakukan operasi maya dan kembalikan mesej ringkas. Terdapat dua versi pelayan: seseorang tidak mempunyai proses pekerja, di mana semua operasi berlaku dalam proses utama, dan yang lain mempunyai 8 proses pekerja (kerana mesin saya mempunyai 8 teras). Jadual berikut menunjukkan bagaimana modul gabungan gabungan meningkatkan bilangan permintaan yang diproses sesaat.

并发连接	1	2	4	8	16
单进程	654	711	783	776	754
8个工作进程	594	1198	2110	3010	3024

(bilangan permintaan diproses sesaat)

Operasi lanjutan

Semasa menggunakan modul kluster agak mudah, anda boleh menggunakan proses pekerja untuk melaksanakan operasi lain. Sebagai contoh, anda boleh menggunakan modul kluster untuk mencapai (hampir!) Sifar downtime untuk aplikasi anda. Kami akan belajar bagaimana melakukan beberapa operasi ini dalam beberapa ketika.

komunikasi antara proses utama dan proses pekerja

Kadang -kadang, anda mungkin perlu menghantar mesej dari proses utama ke proses pekerja untuk menetapkan tugas atau melakukan tindakan lain. Sebagai balasan, proses pekerja mungkin perlu memaklumkan proses utama yang telah selesai. Untuk mendengar mesej, anda harus menetapkan pendengar acara untuk acara mesej dalam proses utama dan proses pekerja:

<code class="language-javascript">var cluster = require('cluster');</code>

Objek pekerja adalah rujukan yang dikembalikan oleh kaedah garpu (). Untuk mendengar mesej dari proses utama dalam proses kerja:

<code class="language-javascript">if(cluster.isMaster) { ... }</code>

Mesej

boleh menjadi rentetan atau objek JSON. Untuk menghantar mesej ke proses pekerja tertentu, anda boleh menulis kod seperti ini:

<code class="language-javascript">cluster.fork();</code>

Begitu juga, untuk menghantar mesej ke proses utama, anda boleh menulis:

<code class="language-javascript">var cluster = require('cluster');
var http = require('http');
var numCPUs = 4;

if (cluster.isMaster) {
    for (var i = 0; i < numCPUs; i++) {
        cluster.fork();
    }
} else {
    http.createServer(function(req, res) {
        res.writeHead(200);
        res.end('process ' + process.pid + ' says hello!');
    }).listen(8000);
}</code>

Dalam node.js, mesej adalah generik dan tidak mempunyai jenis tertentu. Oleh itu, adalah lebih baik untuk menghantar mesej sebagai objek JSON yang mengandungi beberapa maklumat mengenai jenis mesej, pengirim, dan kandungan itu sendiri. Contohnya:

<code class="language-javascript">var cluster = require('cluster');

if(cluster.isMaster) {
    var numWorkers = require('os').cpus().length;

    console.log('Master cluster setting up ' + numWorkers + ' workers...');

    for(var i = 0; i < numWorkers; i++) {
        cluster.fork();
    }

    cluster.on('online', function(worker) {
        console.log('Worker ' + worker.process.pid + ' is online');
    });

    cluster.on('exit', function(worker, code, signal) {
        console.log('Worker ' + worker.process.pid + ' died with code: ' + code + ', and signal: ' + signal);
        console.log('Starting a new worker');
        cluster.fork();
    });
} else {
    var app = require('express')();
    app.all('/*', function(req, res) {res.send('process ' + process.pid + ' says hello!').end();})

    var server = app.listen(8000, function() {
        console.log('Process ' + process.pid + ' is listening to all incoming requests');
    });
}</code>

Satu perkara yang perlu diperhatikan di sini adalah bahawa panggilan balik peristiwa mesej diproses secara tidak segerak. Tiada perintah pelaksanaan yang ditetapkan. Anda boleh mencari contoh komunikasi yang lengkap antara proses utama dan proses pekerja di GitHub.

sifar downtime

Satu hasil penting yang boleh dicapai menggunakan proses pekerja ialah pelayan downtime (hampir) sifar. Dalam proses utama, anda boleh menamatkan dan memulakan semula proses pekerja satu demi satu selepas membuat perubahan pada aplikasi. Ini membolehkan anda menjalankan versi lama semasa memuatkan versi baru. Untuk dapat memulakan semula permohonan anda semasa runtime, anda perlu ingat dua perkara. Pertama, proses utama berjalan sepanjang masa, dan hanya proses pekerja yang ditamatkan dan dimulakan semula. Oleh itu, adalah penting untuk memastikan proses utama pendek dan hanya menguruskan proses kerja. Kedua, anda perlu memaklumkan proses utama bahawa proses pekerja perlu dimulakan semula. Terdapat beberapa cara untuk melakukan ini, termasuk input pengguna atau pemantauan perubahan fail. Yang terakhir ini lebih cekap, tetapi anda perlu mengenal pasti fail untuk memantau dalam proses utama. Cara saya mengesyorkan memulakan semula proses pekerja adalah untuk mula -mula cuba menutupnya dengan selamat; Anda boleh melaksanakan bekas dengan menghantar mesej penutupan ke proses pekerja, seperti yang ditunjukkan di bawah:

<code class="language-javascript">worker.on('message', function(message) {
    console.log(message);
});</code>

dan mulakan shutdown selamat dalam pengendali acara mesej pekerja:

<code class="language-javascript">process.on('message', function(message) {
    console.log(message);
});</code>

Untuk melakukan ini untuk semua proses pekerja, anda boleh menggunakan harta pekerja modul kluster, yang memegang rujukan kepada semua proses pekerja yang sedang berjalan. Kami juga boleh membungkus semua tugas dalam fungsi dalam proses utama yang boleh dipanggil apabila kita mahu memulakan semula semua proses pekerja.

<code class="language-javascript">var cluster = require('cluster');</code>

kita boleh mendapatkan ID semua proses pekerja yang sedang berjalan dari objek pekerja dalam modul kluster. Objek ini memegang rujukan kepada semua proses pekerja yang sedang berjalan dan kemas kini secara dinamik apabila proses pekerja ditamatkan dan dimulakan semula. Pertama, kami menyimpan ID semua proses pekerja yang sedang berjalan di array pekerja. Dengan cara ini, kami mengelakkan memulakan semula proses pekerja yang baru diperolehi. Kami kemudian meminta agar setiap proses pekerja ditutup dengan selamat. Sekiranya proses pekerja masih berjalan selepas 5 saat dan masih wujud dalam objek pekerja, maka kami memanggil fungsi membunuh pada proses pekerja untuk memaksanya untuk ditutup. Anda boleh mencari contoh praktikal di GitHub.

Kesimpulan

Aplikasi Node.js boleh dipasangkan menggunakan modul kluster untuk membolehkan penggunaan sistem yang lebih cekap. Proses berganda boleh dijalankan serentak dengan beberapa baris kod, yang menjadikan penghijrahan agak mudah kerana node.js mengendalikan bahagian yang sukar. Seperti yang saya tunjukkan dalam perbandingan prestasi, adalah mungkin untuk mencapai peningkatan yang signifikan dalam prestasi aplikasi dengan memanfaatkan sumber sistem dengan lebih cekap. Sebagai tambahan kepada prestasi, anda boleh meningkatkan kebolehpercayaan aplikasi dan uptime dengan memulakan semula proses pekerja semasa aplikasi sedang berjalan. Iaitu, anda perlu berhati -hati apabila mempertimbangkan menggunakan modul kluster dalam permohonan anda. Penggunaan utama modul kluster yang disyorkan adalah untuk pelayan web. Dalam kes lain, anda perlu melihat dengan lebih dekat bagaimana untuk memperuntukkan tugas antara proses pekerja dan bagaimana untuk menyampaikan kemajuan dengan berkesan antara proses pekerja dan proses utama. Malah untuk pelayan web, pastikan proses node.js tunggal adalah hambatan (memori atau CPU) sebelum membuat sebarang perubahan pada aplikasi anda, kerana perubahan anda mungkin memperkenalkan kesilapan. Akhir sekali, laman web Node.js menyediakan dokumentasi yang baik untuk modul kluster. Oleh itu, pastikan anda menyemaknya!

FAQs Mengenai Node.js Cluster

Apakah kelebihan utama menggunakan kelompok Node.js?

Kelebihan utama menggunakan kluster Node.js adalah untuk meningkatkan prestasi aplikasi. Node.js berjalan pada benang, yang bermaksud ia hanya boleh menggunakan satu teras CPU pada satu masa. Walau bagaimanapun, pelayan moden biasanya mempunyai beberapa teras. Dengan menggunakan cluster Node.js, anda boleh membuat proses utama yang menghasilkan pelbagai proses pekerja, masing -masing berjalan pada teras CPU yang berbeza. Ini membolehkan permohonan anda memproses lebih banyak permintaan pada masa yang sama, yang meningkatkan kelajuan dan prestasinya dengan ketara.

Bagaimana kelompok node.js berfungsi?

node.js cluster berfungsi dengan mewujudkan proses utama yang menghasilkan pelbagai proses pekerja. Proses utama mendengarkan permintaan masuk dan mengedarkannya kepada proses pekerja dengan cara pengundian. Setiap proses pekerja berjalan pada teras CPU yang berasingan dan mengendalikan permintaan secara bebas. Ini membolehkan permohonan anda memanfaatkan semua teras CPU yang ada dan memproses lebih banyak permintaan pada masa yang sama.

bagaimana membuat cluster node.js?

Membuat cluster node.js melibatkan menggunakan modul "cluster" yang disediakan oleh Node.js. Pertama, anda perlu mengimport modul "kluster" dan "OS". Anda kemudian boleh menggunakan kaedah "cluster.fork ()" untuk membuat proses pekerja. "OS.CPUS (). Panjang" memberi anda bilangan teras CPU yang tersedia, yang boleh anda gunakan untuk menentukan bilangan proses pekerja untuk dicipta. Berikut adalah contoh mudah:

<code class="language-javascript">var cluster = require('cluster');</code>

Bagaimana menangani kemalangan proses pekerja dalam cluster Node.js?

Anda boleh mengendalikan kemalangan proses pekerja dalam kluster Node.js dengan mendengar peristiwa "keluar" pada proses utama. Apabila proses pekerja terhempas, ia menghantar acara "keluar" ke proses utama. Anda kemudian boleh menggunakan kaedah "cluster.fork ()" untuk membuat proses pekerja baru untuk menggantikan proses pekerja yang terhempas. Berikut adalah contoh:

<code class="language-javascript">if(cluster.isMaster) { ... }</code>

Bolehkah saya menggunakan cluster node.js dengan express.js?

Ya, anda boleh menggunakan kluster Node.js dengan Express.js. Malah, menggunakan clustering Node.js dapat meningkatkan prestasi aplikasi Express.js. Anda hanya perlu meletakkan kod aplikasi Express.js dalam blok kod proses pekerja dalam skrip kluster.

Apakah batasan kelompok Node.js?

Walaupun kluster Node.js dapat meningkatkan prestasi aplikasi dengan ketara, ia juga mempunyai beberapa batasan. Sebagai contoh, proses pekerja tidak berkongsi keadaan atau ingatan. Ini bermakna anda tidak boleh menyimpan data sesi dalam ingatan kerana ia tidak boleh diakses dalam semua proses pekerja. Sebaliknya, anda perlu menggunakan storan sesi bersama, seperti pangkalan data atau pelayan REDIS.

Bagaimana memuatkan permintaan mengimbangi dalam kluster Node.js?

Secara lalai, proses utama dalam kluster Node.js mengedarkan permintaan masuk ke proses pekerja dengan cara pengundian. Ini memberikan bentuk asas pengimbangan beban. Walau bagaimanapun, jika anda memerlukan pengimbangan beban yang lebih maju, anda mungkin perlu menggunakan pelayan proksi terbalik, seperti nginx.

Bolehkah saya menggunakan kluster Node.js dalam pengeluaran?

Ya, anda boleh menggunakan kluster Node.js dalam persekitaran pengeluaran. Malah, sangat disyorkan untuk menggunakan kelompok Node.js dalam persekitaran pengeluaran untuk memanfaatkan sepenuhnya teras CPU pelayan dan meningkatkan prestasi aplikasi anda.

bagaimana debug node.js cluster?

Debugging node.js clusters boleh menjadi agak rumit kerana anda mempunyai beberapa proses pekerja yang berjalan pada masa yang sama. Walau bagaimanapun, anda boleh melampirkan debugger untuk setiap proses menggunakan bendera "periksa" dengan port unik untuk setiap proses pekerja. Berikut adalah contoh:

<code class="language-javascript">cluster.fork();</code>

Bolehkah saya menggunakan kluster Node.js dengan modul Node.js lain?

Ya, anda boleh menggunakan kluster Node.js dengan modul Node.js lain. Walau bagaimanapun, anda perlu ambil perhatian bahawa proses pekerja tidak berkongsi keadaan atau ingatan. Ini bermakna jika modul bergantung kepada keadaan bersama, ia mungkin tidak berfungsi dengan baik dalam persekitaran kluster.

Atas ialah kandungan terperinci Cara Membuat Kluster Node.js Untuk Mempercepatkan Aplikasi Anda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!