Node.js บนเครื่องมัลติคอร์

Node.jsดูน่าสนใจแต่ฉันต้องพลาดบางอย่าง - Node.js ไม่ได้รับการปรับแต่งเพียงเพื่อให้ทำงานในกระบวนการและเธรดเดียวใช่หรือไม่

ถ้าอย่างนั้นมันจะปรับขนาดสำหรับซีพียูมัลติคอร์และเซิร์ฟเวอร์มัลติซีพียูอย่างไร? ท้ายที่สุดมันก็ยอดเยี่ยมมากที่จะทำเซิร์ฟเวอร์เธรดเดี่ยวให้เร็วที่สุดเท่าที่จะเป็นไปได้ แต่สำหรับการโหลดที่สูงฉันจะใช้ซีพียูหลายตัว และเช่นเดียวกันสำหรับการทำให้แอปพลิเคชันเร็วขึ้น - ดูเหมือนว่าทุกวันนี้วิธีการใช้ซีพียูหลายตัวและทำงานแบบขนาน

Node.js พอดีกับภาพนี้ได้อย่างไร เป็นความคิดที่จะแจกจ่ายหลาย ๆ ครั้งหรืออะไร

[ โพสต์นี้เป็นข้อมูลล่าสุด ณ วันที่ 2012-09-02 (ใหม่กว่าด้านบน) ]

Node.js ปรับขนาดบนเครื่องมัลติคอร์อย่างแน่นอน

ใช่ Node.js เป็นหนึ่งเธรดต่อกระบวนการ นี่คือการตัดสินใจออกแบบโดยเจตนาและไม่จำเป็นต้องจัดการกับความหมายการล็อก หากคุณไม่เห็นด้วยกับสิ่งนี้คุณอาจยังไม่เข้าใจว่าการดีบักโค้ดแบบมัลติเธรดนั้นเป็นเรื่องยากเพียงใด สำหรับคำอธิบายลึกของรูปแบบกระบวนการ Node.js และทำไมมันทำงานด้วยวิธีนี้ (และทำไมมันจะไม่สนับสนุนหลายหัวข้อ) อ่านโพสต์อื่น ๆ ของฉัน

ดังนั้นฉันจะใช้ประโยชน์จากกล่อง 16 core ของฉันได้อย่างไร

สองทาง:

• สำหรับงานที่ต้องคำนวณหนัก ๆ ขนาดใหญ่เช่นการเข้ารหัสภาพ Node.js สามารถเปิดไฟกระบวนการเด็กหรือส่งข้อความไปยังกระบวนการผู้ปฏิบัติงานเพิ่มเติม ในการออกแบบนี้คุณจะต้องมีหนึ่งเธรดที่จัดการโฟลว์ของเหตุการณ์และกระบวนการ N ที่ทำงานหนักในการคำนวณและเคี้ยวซีพียูอีก 15 ตัว
• สำหรับการปรับปริมาณงานบนเว็บเซอร์วิซคุณควรรันเซิร์ฟเวอร์ Node.js หลายเครื่องในหนึ่งกล่องหนึ่งตัวต่อคอร์และแยกการรับส่งข้อมูลระหว่างคำขอ สิ่งนี้จะให้ CPU-affinity ที่ยอดเยี่ยมและจะขยายสเกลความเร็วเกือบเป็นเส้นตรงด้วยการนับคอร์

ปรับขนาดปริมาณงานบนเว็บเซอร์

ตั้งแต่ v6.0.X Node.js ได้รวมโมดูลคลัสเตอร์โดยตรงจากกล่องซึ่งทำให้ง่ายต่อการตั้งค่าตัวทำงานของโหนดหลายตัวที่สามารถฟังในพอร์ตเดียว หมายเหตุว่านี้ไม่ได้เช่นเดียวกับพี่ learnboost "คลัสเตอร์" โมดูลพร้อมใช้งานผ่านNPM

if (cluster.isMaster) {
  // Fork workers.
  for (var i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
} else {
  http.Server(function(req, res) { ... }).listen(8000);
}

คนงานจะแข่งขันเพื่อยอมรับการเชื่อมต่อใหม่และกระบวนการที่โหลดน้อยที่สุดมีแนวโน้มที่จะชนะมากที่สุด มันทำงานได้ค่อนข้างดีและสามารถเพิ่มปริมาณงานได้ค่อนข้างดีบนกล่องแบบมัลติคอร์

หากคุณมีภาระมากพอที่จะใส่ใจกับหลายคอร์แล้วคุณจะต้องทำสิ่งต่าง ๆ เพิ่มเติม:

1. เรียกใช้บริการ Node.js ของคุณหลังเว็บพร็อกซีเช่นNginxหรือApache - สิ่งที่สามารถทำการควบคุมปริมาณการเชื่อมต่อ (ยกเว้นกรณีที่คุณต้องการให้เงื่อนไขโอเวอร์โหลดนำกล่องลงมาอย่างสมบูรณ์) เขียน URL ใหม่ให้บริการเนื้อหาคงที่และพร็อกซีย่อยบริการอื่น ๆ

2. รีไซเคิลกระบวนการทำงานของคุณเป็นระยะ สำหรับกระบวนการที่ใช้เวลานานแม้กระทั่งหน่วยความจำขนาดเล็กก็จะรั่วไหลในที่สุด

3. ตั้งค่าการรวบรวม / การตรวจสอบบันทึก

ป.ล. : มีการพูดคุยกันระหว่างแอรอนกับคริสโตเฟอร์ในความคิดเห็นของโพสต์อื่น ความคิดเห็นบางประการเกี่ยวกับเรื่องนี้:

• โมเดลซ็อกเก็ตที่ใช้ร่วมกันนั้นสะดวกมากสำหรับการอนุญาตให้กระบวนการหลาย ๆ ฟังบนพอร์ตเดียวและแข่งขันเพื่อยอมรับการเชื่อมต่อใหม่ ตามแนวคิดคุณอาจนึกถึง Apache แบบ preforked ทำสิ่งนี้กับข้อแม้ที่สำคัญว่าแต่ละขั้นตอนจะยอมรับการเชื่อมต่อเพียงครั้งเดียวและจากนั้นก็ตาย การสูญเสียประสิทธิภาพสำหรับ Apache อยู่ในค่าใช้จ่ายของการฟอร์กกระบวนการใหม่และไม่มีอะไรเกี่ยวข้องกับการดำเนินการซ็อกเก็ต
• สำหรับ Node.js การมีพนักงาน N คนแข่งขันกันในซ็อกเก็ตเดียวเป็นโซลูชั่นที่เหมาะสมอย่างยิ่ง อีกทางเลือกหนึ่งคือการตั้งค่า Front-end แบบ on-box เช่น Nginx และมีทราฟฟิกพร็อกซีนั้นไปยังพนักงานแต่ละคน โซลูชันทั้งสองมีคุณลักษณะด้านประสิทธิภาพที่คล้ายคลึงกันมาก และเนื่องจากอย่างที่ฉันได้กล่าวไว้ข้างต้นคุณอาจต้องการใช้ Nginx (หรือทางเลือก) ที่บังหน้าบริการโหนดของคุณอย่างไรก็ตามตัวเลือกที่นี่อยู่ระหว่าง:

พอร์ตที่ใช้ร่วมกัน: nginx (port 80) --> Node_workers x N (sharing port 3000 w/ Cluster)

VS

พอร์ตส่วนบุคคล: nginx (port 80) --> {Node_worker (port 3000), Node_worker (port 3001), Node_worker (port 3002), Node_worker (port 3003) ...}

มีประโยชน์บางอย่างในการตั้งค่าพอร์ตแต่ละพอร์ต (อาจมีข้อต่อระหว่างกระบวนการน้อยกว่ามีการตัดสินใจในการทำโหลดบาลานซ์ที่ซับซ้อนมากขึ้นเป็นต้น) แต่ก็เป็นงานที่ต้องตั้งค่ามากขึ้นและโมดูลคลัสเตอร์ในตัวนั้นต่ำ - ทางเลือกที่ซับซ้อนที่เหมาะกับคนส่วนใหญ่

วิธีหนึ่งคือการรันหลายอินสแตนซ์ของ node.js บนเซิร์ฟเวอร์จากนั้นวาง load balancer (โดยเฉพาะอย่างยิ่ง non-blocking หนึ่งอย่าง nginx) ที่อยู่ด้านหน้า

Ryan Dahl ตอบคำถามนี้ในการพูดคุยเรื่องเทคโนโลยีที่เขาให้ที่ Googleเมื่อฤดูร้อนที่ผ่านมา ในการถอดความ "เพียงแค่เรียกใช้กระบวนการหลายโหนดและใช้สิ่งที่เหมาะสมเพื่อให้พวกเขาสื่อสารเช่น sendmsg () - IPC สไตล์หรือ RPC แบบดั้งเดิม"

หากคุณต้องการทำให้มือสกปรกทันทีให้ไปที่โมดูลspark2 Forever มันทำให้การวางไข่กระบวนการหลายโหนดง่ายขึ้นเล็กน้อย มันจัดการการตั้งค่าการแชร์พอร์ตเพื่อให้พวกเขาแต่ละคนสามารถยอมรับการเชื่อมต่อกับพอร์ตเดียวกันและตอบสนองโดยอัตโนมัติหากคุณต้องการให้แน่ใจว่ากระบวนการจะเริ่มต้นใหม่หาก / เมื่อตาย

UPDATE - 10/11/11 : ความเห็นพ้องในชุมชนโหนดดูเหมือนว่าคลัสเตอร์ตอนนี้เป็นโมดูลที่ต้องการสำหรับการจัดการหลายอินสแตนซ์โหนดต่อเครื่อง ตลอดไปยังคุ้มค่าดู

คุณสามารถใช้โมดูลคลัสเตอร์ ตรวจสอบนี้

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

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

    cluster.on('exit', function(worker, code, signal) {
        console.log('worker ' + worker.process.pid + ' died');
    });
} else {
    // Workers can share any TCP connection
    // In this case its a HTTP server
    http.createServer(function(req, res) {
        res.writeHead(200);
        res.end("hello world\n");
    }).listen(8000);
}

มัลติโหนดใช้ประโยชน์จากแกนประมวลผลทั้งหมดที่คุณมี
มีลักษณะที่http://github.com/kriszyp/multi-node

สำหรับความต้องการที่ง่ายขึ้นคุณสามารถเริ่มต้นโหนดหลายสำเนาบนหมายเลขพอร์ตที่แตกต่างกันและวาง load balancer ไว้ข้างหน้า

Node Js สนับสนุนการทำคลัสเตอร์เพื่อใช้ประโยชน์เต็มที่จาก cpu ของคุณ หากคุณไม่ได้ทำงานกับคลัสเตอร์คุณอาจเสียความสามารถด้านฮาร์ดแวร์ของคุณไป

การทำคลัสเตอร์ใน Node.js ช่วยให้คุณสร้างกระบวนการแยกซึ่งสามารถแชร์พอร์ตเซิร์ฟเวอร์เดียวกันได้ ตัวอย่างเช่นถ้าเราใช้เซิร์ฟเวอร์ HTTP หนึ่งตัวในพอร์ต 3000 นั่นคือเซิร์ฟเวอร์หนึ่งตัวที่ทำงานบนเธรดเดี่ยวบนตัวประมวลผลหลักเดียว

รหัสที่แสดงด้านล่างอนุญาตให้คุณจัดกลุ่มแอปพลิเคชันของคุณ รหัสนี้เป็นรหัสทางการที่แสดงโดย Node.js

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

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

    Object.keys(cluster.workers).forEach(function(id) {
        console.log("I am running with ID : " + cluster.workers[id].process.pid);
    });

    cluster.on('exit', function(worker, code, signal) {
        console.log('worker ' + worker.process.pid + ' died');
    });
} else {

    //Do further processing.
}

ตรวจสอบบทความนี้สำหรับบทช่วยสอนเต็มรูปแบบ

ตามที่กล่าวไว้ข้างต้นClusterจะปรับขนาดและโหลดแอพของคุณในทุกคอร์

เพิ่มสิ่งที่ชอบ

cluster.on('exit', function () {
  cluster.fork();
});

จะรีสตาร์ทผู้ทำงานที่ล้มเหลว

ทุกวันนี้ผู้คนจำนวนมากชอบPM2ซึ่งจัดการการจัดกลุ่มสำหรับคุณและยังมีคุณสมบัติการตรวจสอบที่ยอดเยี่ยมอีกด้วย

จากนั้นเพิ่ม Nginx หรือ HAProxy หน้าเครื่องหลายเครื่องที่รันด้วยการทำคลัสเตอร์และคุณมี failover หลายระดับและความสามารถในการโหลดที่สูงขึ้นมาก

รุ่นในอนาคตของโหนดจะช่วยให้คุณสามารถแยกกระบวนการและส่งข้อความไปยังมันได้และ Ryan ได้ระบุว่าเขาต้องการหาวิธีที่จะแชร์ตัวจัดการไฟล์ด้วยดังนั้นจึงไม่เป็นการใช้งาน Web Worker โดยตรง

ในขณะนี้ยังไม่มีวิธีแก้ปัญหาที่ง่าย แต่ก็ยังเร็วเกินไปและโหนดเป็นหนึ่งในโครงการโอเพ่นซอร์สที่เคลื่อนไหวเร็วที่สุดเท่าที่ฉันเคยเห็นมาดังนั้นคาดว่าจะมีบางสิ่งที่ยอดเยี่ยมในอนาคตอันใกล้

Spark2 ขึ้นอยู่กับ Spark ซึ่งตอนนี้ไม่ได้รับการบำรุงรักษาอีกต่อไป คลัสเตอร์เป็นตัวตายตัวแทนและมีคุณสมบัติเจ๋ง ๆ เช่นวางไข่หนึ่งกระบวนการต่อซีพียูคอร์และการตอบสนองคนตาย

ฉันใช้Node คนทำงานเพื่อเรียกใช้กระบวนการอย่างง่าย ๆ จากกระบวนการหลักของฉัน ดูเหมือนว่าจะทำงานได้ดีในขณะที่เรารอวิธีการอย่างเป็นทางการที่จะมา

เด็กคนใหม่ในบล็อกที่นี่คือ"Up"ของ LearnBoost "ขึ้น"

มันมี "Zero-downtime reloads" และสร้างผู้ทำงานหลายคนเพิ่มเติม (โดยค่าเริ่มต้นจำนวนซีพียู แต่สามารถกำหนดค่าได้) เพื่อมอบสิ่งที่ดีที่สุดในโลก

มันใหม่ แต่ดูเหมือนว่าจะค่อนข้างเสถียรและฉันใช้มันอย่างมีความสุขในโครงการปัจจุบันของฉัน

คลัสเตอร์โมดูลช่วยให้คุณสามารถใช้ประโยชน์จากแกนทุกเครื่องของคุณ ในความเป็นจริงคุณสามารถใช้ประโยชน์จากนี้ในเวลาเพียง 2 คำสั่งและโดยไม่ต้องสัมผัสรหัสของคุณโดยใช้ที่นิยมมากผู้จัดการกระบวนการPM2

npm i -g pm2
pm2 start app.js -i max

คุณสามารถรันแอ็พพลิเคชัน node.js ของคุณบนหลายคอร์โดยใช้โมดูลคลัสเตอร์ร่วมกับระบบปฏิบัติการโมดูลซึ่งอาจใช้เพื่อตรวจสอบจำนวน CPU ที่คุณมี

ตัวอย่างเช่นลองจินตนาการว่าคุณมีserverโมดูลที่รันเซิร์ฟเวอร์ http ง่าย ๆ บนแบ็กเอนด์และคุณต้องการเรียกใช้สำหรับซีพียูหลายตัว:

// Dependencies.
const server = require('./lib/server'); // This is our custom server module.
const cluster = require('cluster');
const os = require('os');

 // If we're on the master thread start the forks.
if (cluster.isMaster) {
  // Fork the process.
  for (let i = 0; i < os.cpus().length; i++) {
    cluster.fork();
  }
} else {
  // If we're not on the master thread start the server.
  server.init();
}

นอกจากนี้ยังเป็นไปได้ที่จะออกแบบเว็บเซอร์วิสเป็นเซิร์ฟเวอร์แบบสแตนด์อโลนหลายแห่งที่ฟังซ็อกเก็ตยูนิกซ์เพื่อให้คุณสามารถผลักดันฟังก์ชั่นเช่นการประมวลผลข้อมูลไปสู่กระบวนการแยก

สิ่งนี้คล้ายกับสถาปัตยกรรมเว็บเซิร์ฟเวอร์ / ฐานข้อมูลการตรวจจับส่วนใหญ่ที่กระบวนการ cgi จัดการกับตรรกะทางธุรกิจและจากนั้นดันและดึงข้อมูลผ่านซ็อกเก็ตยูนิกซ์ไปยังฐานข้อมูล

ความแตกต่างคือการประมวลผลข้อมูลถูกเขียนเป็นโหนดเว็บเซิร์ฟเวอร์ฟังบนพอร์ต

มันซับซ้อนมากขึ้น แต่ท้ายที่สุดแล้วมันเป็นจุดที่การพัฒนาแบบมัลติคอร์ต้องไป สถาปัตยกรรมแบบหลายกระบวนการโดยใช้หลายองค์ประกอบสำหรับแต่ละคำขอของเว็บ

เป็นไปได้ที่จะขยาย NodeJS ออกเป็นหลายกล่องโดยใช้ TCP load balancer (HAProxy) ด้านหน้ากล่องหลายกล่องที่ใช้งาน NodeJS หนึ่งกระบวนการ

หากคุณมีความรู้ทั่วไปที่จะแบ่งปันระหว่างอินสแตนซ์ทั้งหมดคุณสามารถใช้ที่เก็บ Redis ส่วนกลางหรือคล้ายกันซึ่งสามารถเข้าถึงได้จากอินสแตนซ์กระบวนการทั้งหมด (เช่นจากกล่องทั้งหมด)