คำอธิบายโดยละเอียดว่าโหนดใช้หลายกระบวนการอย่างไร จะปรับใช้โปรเจ็กต์โหนดได้อย่างไร

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

บทความมีหลายส่วน:

• เธรดและกระบวนการ
• Node.js ใช้งานการติดตั้งเซิร์ฟเวอร์ Multi-Process
• Server Node.js
• ใช้ PM2 เพื่อจัดการโครงการ Node.js
• ใช้ Nginx เพื่อใช้

กระบวนการส่งต่อพร็อกซีของอินเตอร์เฟสบริการเทียบกับกระบวนการเธรด

(

กระบวนการ) เป็นคอมพิวเตอร์ การจัดสรรระบบปฏิบัติการและหน่วยพื้นฐานของงานการจัดตารางเวลา เปิดตัวจัดการงานและคุณจะเห็นว่ามีโปรแกรมจำนวนมากที่ทำงานอยู่เบื้องหลังของคอมพิวเตอร์และแต่ละโปรแกรมเป็นกระบวนการ

เบราว์เซอร์ที่ทันสมัยโดยทั่วไปมีสถาปัตยกรรมหลายกระบวนการ นอกจากนี้ยังมีกระบวนการเครือข่าย กระบวนการ GPU เป็นต้น

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

เธรด

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

เราทุกคนรู้ดีว่า JavaScript เป็นภาษาแบบเธรดเดียว การออกแบบนี้เป็นเพราะในวันแรก ๆ JS ส่วนใหญ่จะใช้ในการเขียนสคริปต์และรับผิดชอบในการตระหนักถึงเอฟเฟกต์เชิงโต้ตอบของเพจ หากได้รับการออกแบบให้เป็นภาษาแบบมัลติเธรด ประการแรก มันไม่จำเป็น และประการที่สอง หลายเธรดร่วมกันใช้งานโหนด DOM แล้วเบราว์เซอร์ควรรับฟังคำแนะนำของใคร แน่นอนว่าด้วยการพัฒนาเทคโนโลยี ตอนนี้ JS ยังรองรับการทำงานแบบมัลติเธรดด้วย แต่ใช้เพื่อจัดการตรรกะบางอย่างที่ไม่เกี่ยวข้องกับการดำเนินการ DOM เท่านั้น

ปัญหาเกี่ยวกับกระบวนการเดี่ยว

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

เพื่อตอบสนองต่อสถานการณ์นี้ เราจำเป็นต้องมีโมเดลหลายกระบวนการที่เหมาะสมเพื่อแปลงโปรแกรม node.js แบบกระบวนการเดียวให้เป็นสถาปัตยกรรมแบบหลายกระบวนการ

การใช้งานหลายกระบวนการของ node.js

มีสองโซลูชันทั่วไปสำหรับการใช้สถาปัตยกรรมหลายกระบวนการใน node.js ซึ่งทั้งสองใช้โมดูลดั้งเดิมคือโมดูล child_process และโมดูล cluster

child_process

child_process เป็นโมดูลในตัวของ Node.js คุณสามารถเดาได้จากชื่อที่รับผิดชอบสิ่งต่าง ๆ ที่เกี่ยวข้องกับกระบวนการเด็ก

เราจะไม่อธิบายรายละเอียดเกี่ยวกับการใช้งานเฉพาะของโมดูลนี้ เราใช้วิธี fork วิธีใดวิธีหนึ่งเพื่อสาธิตวิธีการใช้กระบวนการหลายกระบวนการและการสื่อสารระหว่างหลายกระบวนการ

ก่อนอื่น มาดูโครงสร้างไดเร็กทอรีของกรณีสาธิตที่เตรียมไว้:

child_process ใช้โมดูล http เพื่อสร้างเซิร์ฟเวอร์ /sum ต้องฟังข้อความที่ส่งโดยกระบวนการลูกด้วย:

/ /child_process.js

const http = ต้องการ ('http')
const { ทางแยก } = ต้องการ ('child_process')

const server = http.createServer ((req, res) => {
  if (req.url == '/sum') {
    // วิธีการส้อมได้รับเส้นทางโมดูลจากนั้นเริ่มกระบวนการเด็กและเรียกใช้โมดูลในกระบวนการเด็ก // childprocess แสดงถึงกระบวนการลูกที่สร้าง

    // ส่งข้อความไปยังกระบวนการเด็กกระบวนการเด็กส่ง ('กระบวนการเด็กเริ่มคำนวณ')

    // ตรวจสอบข้อความของกระบวนการเด็กในกระบวนการ parent bildprocess.on ('ข้อความ', (data) => {
      Res.end (data + '')
    -

    // ฟังเหตุการณ์ปิดของกระบวนการเด็ก process.on ('ปิด', () => {
      // หากกระบวนการย่อยออกตามปกติหรือรายงานข้อผิดพลาดและวางสาย กระบวนการจะไปที่นี่ console.log('กระบวนการย่อยปิด')
      childprocess.kill ()
    -

    //ฟังเหตุการณ์ข้อผิดพลาดของกระบวนการลูก childProcess.on('error', () => {
      console.log('ข้อผิดพลาดกระบวนการลูก')
      childprocess.kill ()
    -
  -
    
  ถ้า (req.url == '/สวัสดี') {
    Res.end ('Hello')
  -
  
  // จำลองกระบวนการพาเรนต์เพื่อรายงานข้อผิดพลาดหาก (req.url == '/ข้อผิดพลาด') {
     โยนข้อผิดพลาดใหม่ ('ข้อผิดพลาดกระบวนการหลัก')
     Res.end ('Hello')
   -
-
เซิร์ฟเวอร์ ฟัง (3000, () => {
  console.log('เซิร์ฟเวอร์กำลังทำงานบน 3000')
})

sum.js ใช้เพื่อจำลองงานที่จะดำเนินการโดยกระบวนการลูก กระบวนการเด็กฟังข้อความที่ส่งโดยกระบวนการหลักประมวลผลงานการคำนวณแล้วส่งผลลัพธ์ไปยังกระบวนการหลัก:

// sum.js

ฟังก์ชั่น getSum () {
  ให้ผลรวม = 0
  สำหรับ (ให้ i = 0; i <10,000 * 1000 * 100; i ++) {
    ผลรวม += 1
  -

  ผลรวมผลรวม
-

// กระบวนการเป็นวัตถุระดับโลกใน node.js ซึ่งเป็นตัวแทนของกระบวนการปัจจุบัน นี่คือกระบวนการเด็ก
// ฟังข้อความที่ส่งโดยกระบวนการหลัก process.on('message', (data) => {
  console.log('ข้อความจากกระบวนการหลัก:' ข้อมูล)
    
  const result = getSum ()
  //ส่งผลการคำนวณไปยังกระบวนการหลัก process.send(result)
})

เปิดเทอร์มินัลแล้วรันโหนดคำสั่ง node 1.child_process :

เยี่ยมชมเบราว์เซอร์:

จากนั้น จำลองสถานการณ์ที่กระบวนการลูกรายงานข้อผิดพลาด:

// sum.js

ฟังก์ชั่น getSum () {
  -
-

// หลังจากที่กระบวนการลูกทำงานเป็นเวลา 5 วินาที กระบวนการจำลองจะวางสาย setTimeout(() => {
   โยนข้อผิดพลาดใหม่ ('รายงานข้อผิดพลาด')
 }, 1,000 * 5)

process.on('ข้อความ', (ข้อมูล) => {
  -
})

ไปที่เบราว์เซอร์อีกครั้งและสังเกตคอนโซลหลังจากผ่านไป 5 วินาที:

กระบวนการลูกเสียชีวิตแล้วจึงเข้าถึง URL อื่น: /hello ,

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

ต่อไปเราจะจำลองสถานการณ์ที่กระบวนการแม่รายงานข้อผิดพลาดแสดงความคิดเห็นรายงานข้อผิดพลาดจำลองของโมดูล sum.js จากนั้นรีสตาร์ทบริการและการเข้าถึง /error ด้วยเบราว์เซอร์:

หลังจากที่พบว่ากระบวนการหลักวางสาย โปรแกรม node.js ทั้งหมดก็ออกจากการทำงานโดยอัตโนมัติ และบริการก็พังทลายลงโดยสิ้นเชิง ทำให้ไม่มีที่ว่างสำหรับการกู้คืน

จะเห็นได้ว่าการนำสถาปัตยกรรมหลายกระบวนการของ node.js ไปใช้นั้นไม่ใช่เรื่องยาก โดยใช้วิธี fork ของ child_process การสื่อสารระหว่างกระบวนการส่วนใหญ่ผ่านวิธี send และ on จากการตั้งชื่อนี้ เรายังสามารถทราบได้ว่าชั้นล่างสุดควรเป็นรูปแบบการสมัครสมาชิกเผยแพร่

แต่มันมีปัญหาร้ายแรง แม้ว่ากระบวนการย่อยจะไม่ส่งผลกระทบต่อกระบวนการหลัก แต่ เมื่อกระบวนการหลักเกิดข้อผิดพลาดและวางสาย กระบวนการย่อยทั้งหมดจะถูก "ฆ่าในหม้อเดียว" ดังนั้นโซลูชันนี้จึงเหมาะสำหรับ การดำเนินการที่ซับซ้อนและใช้เวลานานในกระบวนการย่อยแยกต่างหาก เพื่อให้แม่นยำยิ่งขึ้นการใช้งานนี้ใช้เพื่อแทนที่การใช้งานมัลติเธรดไม่ใช่การประมวลผลแบบหลายครั้ง

คลัสเตอร์

ใช้โมดูล child_process เพื่อใช้หลายกระบวนการซึ่งดูเหมือนจะไร้ประโยชน์ ดังนั้นโดยทั่วไปขอแนะนำให้ใช้โมดูล cluster เพื่อใช้โมเดลหลายกระบวนการของ Node.js.

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

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

const http = ต้องการ ('http')
คลัสเตอร์ const = ต้องการ ('คลัสเตอร์')
const cpus = ต้องการ ('os'). cpus ()

ถ้า (cluster.isMaster) {
  // เมื่อโปรแกรมเริ่มต้นมันจะไปที่นี่ก่อนและสร้างกระบวนการย่อยหลายรายการตามจำนวนแกน CPU สำหรับ (ให้ i = 0; i <cpus.length; i ++) {
    // สร้างคลัสเตอร์กระบวนการเด็ก () ()
  -

  // เมื่อกระบวนการเด็กใดวางสายโมดูลคลัสเตอร์จะปล่อยเหตุการณ์ 'ออก' ณ จุดนี้กระบวนการจะเริ่มต้นใหม่โดยเรียกส้อมอีกครั้ง
  Cluster.on ('Exit', () => {
    คลัสเตอร์.ส้อม()
  -
} อื่น {
  // วิธีการเรียกใช้งานเพื่อสร้างกระบวนการเด็กและโมดูลจะถูกดำเนินการอีกครั้ง
    console.log (process.pid)
    res.end ('ตกลง')
  -

  Server.Listen (3000, () => {
    console.log ('เซิร์ฟเวอร์ทำงานบน 3000', 'PID:' + process.pid)
  -
}

เริ่มบริการ:

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

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

มาเขียนสคริปต์คำขอเพื่อขอบริการข้างต้นแล้วดูผล

//request.js

const http = ต้องการ ('http')

สำหรับ (ให้ i = 0; i <1,000; i ++) {
  http.get ('http: // localhost: 3000')
}

โมดูล HTTP ไม่เพียงสามารถสร้างเซิร์ฟเวอร์ HTTP แต่ยังสามารถใช้เพื่อส่งคำขอ HTTP Axios รองรับสภาพแวดล้อมของเบราว์เซอร์และเซิร์ฟเวอร์

ใช้คำสั่ง node เพื่อเรียกใช้งานไฟล์และดูที่คอนโซลต้นฉบับ:

รหัสกระบวนการของกระบวนการย่อยที่แตกต่างกันที่จัดการโดยเฉพาะการร้องขอจะถูกพิมพ์

นี่คือสถาปัตยกรรมหลายกระบวนการของ NODD.JS ที่ใช้งานผ่านโมดูล cluster

แน่นอนเมื่อเราปรับใช้โครงการ node.js เราจะไม่เขียนและใช้โมดูล cluster แห้ง มีเครื่องมือที่มีประโยชน์มากที่เรียกว่า PM2 ซึ่งเป็นเครื่องมือการจัดการกระบวนการตามโมดูลคลัสเตอร์ การใช้งานขั้นพื้นฐานจะแนะนำในบทต่อๆ ไป

สรุป

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

Deployment Practice

เตรียมโครงการด่วน

บทความนี้ได้จัดเตรียมโปรแกรมตัวอย่างที่พัฒนาโดยใช้ Express คลิกที่นี่เพื่อเข้าถึง

โดยส่วนใหญ่จะใช้บริการอินเทอร์เฟซ เมื่อเข้าถึง /api/users จะใช้ mockjs เพื่อจำลองข้อมูลผู้ใช้ 10 ชิ้นและส่งคืนรายชื่อผู้ใช้ ในเวลาเดียวกัน ตัวจับเวลาจะเริ่มจำลองสถานการณ์ข้อผิดพลาด:

const express = need('express')
const mock = ต้องการ ('mockjs')

แอป const = ด่วน ()

app.get ("/api/users", (req, res) => {
  const userlist = mock.mock ({
    'รายชื่อผู้ใช้|10': [{
      'รหัส|+1': 1,
      'ชื่อ': '@cname',
      'อีเมล': '@email'
    -
  -
  
  Settimeout (() => {
      โยนข้อผิดพลาดใหม่ ('เซิร์ฟเวอร์ล้มเหลว')
  }, 5,000)

  Res.status (200)
  res.json (ผู้ใช้)
-

app.listen(3000, () => {
  console.log("บริการเริ่มต้น: 3000")
})

ทดสอบในเครื่องและดำเนินการคำสั่งในเทอร์มินัล:

node server.js

เปิดเบราว์เซอร์และเข้าถึงอินเตอร์เฟสรายการผู้ใช้:

หลังจากห้าวินาทีเซิร์ฟเวอร์จะแขวน:

เราสามารถแก้ปัญหานี้ได้ในภายหลังเมื่อเราใช้ PM2 เพื่อจัดการแอปพลิเคชัน

โครงการ

Express จำเป็นต้องได้รับการบรรจุหรือไม่?

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

• ไวยากรณ์ขั้นสูงไม่ได้รับการสนับสนุนและต้องรวบรวม ES6+ ในไวยากรณ์ ES5
• ที่
• .jsx .vue .ts
• รู้

ได้ ปัญหาเหล่านี้ ยิ่งไปกว่านั้น Node.js ใช้ข้อกำหนดโมดูลาร์ CommonJS และมีกลไกการแคช; หากคุณแพ็คเกจลงในไฟล์ข้อได้เปรียบนี้จะสูญเปล่า ดังนั้นสำหรับโครงการ Node.js ไม่จำเป็นต้องบรรจุภัณฑ์

บทความนี้ใช้ระบบ CentOS เป็นตัวอย่างเพื่อสาธิต

วิธีการติดตั้ง node.js บนเซิร์ฟเวอร์

NVM

เพื่ออำนวยความสะดวกในการสลับเวอร์ชันโหนดเราใช้ NVM เพื่อจัดการโหนด

NVM (ตัวจัดการเวอร์ชันโหนด) เป็นเครื่องมือการจัดการเวอร์ชันของ Node.js. โหนดสามารถสลับไปได้ระหว่างหลายเวอร์ชันโดยพลการหลีกเลี่ยงการดาวน์โหลดและการติดตั้งซ้ำ ๆ เมื่อต้องการการสลับเวอร์ชัน

ที่เก็บอย่างเป็นทางการของ NVM คือ github.com/nvm-sh/nvm เนื่องจากสคริปต์การติดตั้งของมันถูกเก็บไว้ในไซต์ githubusercontent จึงมักจะไม่สามารถเข้าถึงได้ ดังนั้นฉันจึงสร้างที่เก็บกระจกใหม่สำหรับมันบน Gitee เพื่อให้ฉันสามารถเข้าถึงสคริปต์การติดตั้งจาก Gitee

ดาวน์โหลดสคริปต์การติดตั้งผ่านคำสั่ง curl และใช้ bash เพื่อเรียกใช้สคริปต์ซึ่งจะทำการติดตั้ง NVM:

# CURL -O- https://gitee.com/hsyq/nvm/raw/master/install.sh | ทุบตี

เมื่อการติดตั้งเสร็จสมบูรณ์หลังจากนั้นเราเปิดหน้าต่างใหม่เพื่อใช้ nvm:

[root@ecs-221238 ~]# nvm 
-v0.39.1

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

ติดตั้ง node.js

ตอนนี้คุณสามารถใช้ NVM เพื่อติดตั้งและจัดการโหนด

ดูเวอร์ชันโหนดที่มีอยู่:

# nvm ls-remote

ติดตั้งโหนด:

# nvm ติดตั้ง 18.0.0 มุม

มองโหนดที่ติดตั้ง:

[root@ecs-221238 ~] # nvm รายการ
-> v18.0.0
ค่าเริ่มต้น -> 18.0.0 ( -> v18.0.0)
iojs -> n/a (ค่าเริ่มต้น)
ไม่เสถียร -> n/a (ค่าเริ่มต้น)
โหนด -> เสถียร ( -> v18.0.0) (ค่าเริ่มต้น)
เสถียร -> 18.0 ( -> v18.0.0) (ค่าเริ่มต้น)

เลือกรุ่นที่จะใช้:

# nvm ใช้ 18.0.0

สิ่งหนึ่งที่ควรทราบคือเมื่อใช้ NVM บน Windows คุณต้องใช้สิทธิ์ผู้ดูแลระบบเพื่อดำเนินการคำสั่ง NVM บน Centos ฉันเข้าสู่ระบบในฐานะผู้ใช้รูทโดยค่าเริ่มต้นดังนั้นจึงไม่มีปัญหา หากคุณพบข้อผิดพลาดที่ไม่รู้จักเมื่อใช้งานคุณสามารถค้นหาวิธีแก้ปัญหาหรือลองดูว่าปัญหาเกิดจากการอนุญาตหรือไม่

เมื่อติดตั้งโหนด NPM จะติดตั้งโดยอัตโนมัติ ตรวจสอบหมายเลขเวอร์ชันของโหนดและ npm:

[root@ecs -221238 ~]# node -v
v18.0.0

[root@ECS -221238 ~]# npm -v

แหล่งที่มาของภาพ NPM เริ่มต้น

ใน 8.6.0

[root@ECS-221238 ~]# npm config รับรีจิสทรี
https://registry.npmjs.org/

สลับไปที่แหล่งกระจก Taobao ในประเทศ:

[root@ecs-221238 ~]# npm config set registry https://registry.npmmirror.com

ณ จุดนี้เซิร์ฟเวอร์ได้ติดตั้งโหนดโหนด สภาพแวดล้อมและ NPM ได้รับการกำหนดค่า

ในการอัปโหลดโครงการไปยังเซิร์ฟเวอร์

ไม่ว่าจะเป็นการดาวน์โหลดไปยังเซิร์ฟเวอร์จากที่เก็บ GitHub/Gitlab/Gitee หรืออัปโหลดในเครื่องผ่านเครื่องมือ FTP ขั้นตอนนั้นง่ายมากและจะไม่แสดงอีกครั้ง

โครงการสาธิตถูกวางไว้ในไดเรกทอรี /www :

พอร์ตเปิดเซิร์ฟเวอร์

เซิร์ฟเวอร์คลาวด์เปิดพอร์ต 22 สำหรับการเข้าสู่ระบบระยะไกลเท่านั้น พอร์ตที่ใช้กันทั่วไปเช่น 80 และ 443 ไม่เปิด นอกจากนี้โครงการด่วนที่เราเตรียมไว้บนพอร์ต 3000 ดังนั้นคุณต้องไปที่คอนโซลของคลาวด์เซิร์ฟเวอร์ค้นหากลุ่มความปลอดภัยเพิ่มกฎสองสามข้อและเปิดพอร์ต 80 และ 3000

การใช้ PM2 เพื่อจัดการแอปพลิเคชัน

เราสามารถใช้ nodemon สำหรับการตรวจสอบแบบเรียลไทม์และรีสตาร์ทอัตโนมัติเพื่อปรับปรุงประสิทธิภาพการพัฒนา ในสภาพแวดล้อมการผลิตคุณต้องใช้นักฆ่าตัวใหญ่ - PM2

สำหรับการใช้งานขั้นพื้นฐาน

ให้ติดตั้ง PM2 ทั่วโลก:

# NPM I -G PM2

ดำเนินการคำสั่ง pm2 -v เพื่อตรวจสอบว่าการติดตั้งสำเร็จหรือไม่:

[root@ECS -221238 ~] # PM2 
-v5.2.0

สลับไปยังไดเรกทอรีโครงการและติดตั้งการพึ่งพาก่อน:

CD /www /Express-Demo
การติดตั้ง NPM

จากนั้นใช้คำสั่ง pm2 เพื่อเริ่มแอปพลิเคชัน

pm2 เริ่ม app.js -i สูงสุด
// หรือ PM2 start server.js -i 2

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

-I: อินสแตนซ์จำนวนอินสแตนซ์ คุณสามารถเขียนหมายเลขเฉพาะหรือกำหนด PM2 เป็น MAX

ตอนนี้แอปพลิเคชันเริ่มต้นขึ้นแล้ว PM2 จะจัดการแอปพลิเคชันในรูปแบบของกระบวนการ daemon

เข้าถึงอินเทอร์เฟซในเบราว์เซอร์ท้องถิ่น:

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

กลับไปที่เทอร์มินัลเซิร์ฟเวอร์และดำเนินการคำสั่ง pm2 logs เพื่อดูบันทึก PM2:

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

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

สรุปคำสั่ง PM2 ทั่วไป

ที่นี่เป็นบทสรุปของคำสั่งที่ใช้กันทั่วไปของเครื่องมือ PM2 สำหรับการอ้างอิง

# โหมดส้อม PM2 start app.js -แอปชื่อ # ตั้งชื่อของแอปพลิเคชันเป็นแอป

#Cluster Mode# ใช้การโหลดบาลานซ์เพื่อเริ่ม 4 กระบวนการ PM2 เริ่มต้น App.js -i 4     

# จะเริ่มกระบวนการ 4 กระบวนการโดยใช้การปรับสมดุลโหลดขึ้นอยู่กับ CPU ที่มีอยู่
pm2 เริ่ม app.js -i 0   

# เทียบเท่ากับเอฟเฟกต์ของคำสั่งด้านบน PM2 start app.js -i สูงสุด 

 # ขยายแอพด้วยแอพสเกล PM2 เพิ่มเติม 3 กระบวนการ +3

# ขยายหรือลดขนาดแอพเป็น 2 กระบวนการ PM2 Scale App 2              

# ดูสถานะแอปพลิเคชัน # แสดงสถานะของรายการ PM2 ทั้งหมด  

# พิมพ์รายการของกระบวนการทั้งหมดในรูปแบบ JSON RAW PM2 JLIST

# ใช้ JSON Beautified เพื่อพิมพ์รายการของกระบวนการทั้งหมด PM2 Prettylist  

# แสดงข้อมูลทั้งหมดเกี่ยวกับกระบวนการเฉพาะ PM2 อธิบาย 0

# ใช้แดชบอร์ดเพื่อตรวจสอบกระบวนการทั้งหมด PM2 Monit             

#log Management# แสดงบันทึกแอปพลิเคชันทั้งหมดบันทึก PM2 แบบเรียลไทม์          

# แสดงแอปพลิเคชันแอปพลิเคชันบันทึกแอปพลิเคชันแอป PM2 เรียลไทม์แอปบันทึก

# ใช้รูปแบบ JSON เพื่อแสดงบันทึกแบบเรียลไทม์อย่าส่งออกบันทึกเก่าเพียงส่งออกบันทึกที่สร้างขึ้นใหม่บันทึก PM2 -JSON

# การจัดการแอพพลิเคชั่น# หยุดกระบวนการทั้งหมด PM2 หยุดทั้งหมด

# รีสตาร์ทกระบวนการทั้งหมด PM2 รีสตาร์ททั้งหมด       
# หยุดกระบวนการด้วย ID ที่ระบุ PM2 หยุด 0     

# รีสตาร์ทกระบวนการด้วย ID ที่ระบุ PM2 รีสตาร์ท 0         

# ลบกระบวนการ PM2 พร้อม ID 0 ลบ 0

# ลบกระบวนการทั้งหมด PM2 ลบทั้งหมดที่

คุณสามารถลองแต่ละคำสั่งด้วยตัวเองเพื่อดูเอฟเฟกต์

นี่คือการสาธิตพิเศษของคำสั่ง monit ซึ่งสามารถเปิดแผงในเทอร์มินัลเพื่อแสดงสถานะการทำงานของแอปพลิเคชันแบบเรียลไทม์

ขั้นสูง: ใช้ไฟล์การกำหนดค่า PM2

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

คุณสามารถสร้างไฟล์กำหนดค่าผ่านคำสั่งต่อไปนี้:

[root@ECS-221238 Express-Demo]# PM2 init ง่ายๆ
ไฟล์ /www/express-demo/ecosystem.config.js สร้างขึ้น

จะสร้าง ecosystem.config.js ไฟล์:

module.exports = {
  แอพ: [{
    ชื่อ: "App1",
    สคริปต์: "./app.js"
  -
}

คุณยังสามารถสร้างไฟล์การกำหนดค่าด้วยตัวเองเช่น app.config.js :

const path = ต้องการ ('พา ธ ')

โมดูล.ส่งออก = {
  // ไฟล์การกำหนดค่าหนึ่งไฟล์สามารถจัดการแอปพลิเคชันหลาย node.js ในเวลาเดียวกัน // แอพเป็นอาร์เรย์แต่ละรายการคือการกำหนดค่าของแอปพลิเคชันแอปพลิเคชัน: [{{
    // ชื่อแอปพลิเคชัน: "Express-demo",

    // สคริปต์ไฟล์รายการแอปพลิเคชัน: "./server.js"

    // มีสองโหมดสำหรับการเริ่มต้นแอปพลิเคชัน: คลัสเตอร์และส้อม
    exec_mode: 'คลัสเตอร์'

    // จำนวนอินสแตนซ์แอปพลิเคชันเพื่อสร้างอินสแตนซ์: 'max',

    // เปิดการตรวจสอบและรีสตาร์ทแอปพลิเคชันโดยอัตโนมัติเมื่อไฟล์เปลี่ยนดู: จริง

    // ละเว้นการเปลี่ยนแปลงไฟล์ไดเรกทอรีบางไฟล์
    // เนื่องจากไดเรกทอรีบันทึกถูกวางไว้ในเส้นทางโครงการจะต้องถูกละเว้นมิฉะนั้นแอปพลิเคชันจะสร้างบันทึกเมื่อเริ่มต้น วนลูปละเว้น _watch: [
      "node_modules",
      "บันทึก"
    -
    // ข้อผิดพลาดบันทึกการจัดเก็บข้อมูล path err_file: path.resolve (__ dirname, 'logs/error.log')

    // พิมพ์เส้นทางการจัดเก็บข้อมูลบันทึก out_file: path.resolve (__ dirname, 'logs/out.log'),

    // ตั้งค่ารูปแบบวันที่ด้านหน้าของแต่ละบันทึกในไฟล์บันทึก log_date_format: "yyyy-mm-dd hh: mm: ss"
  -
}

ให้ PM2 ใช้ไฟล์การกำหนดค่าเพื่อจัดการแอปพลิเคชันโหนด:

PM2 start app.config.js

ตอนนี้แอปพลิเคชันที่จัดการโดย PM2 จะใส่บันทึกในไดเรกทอรีโครงการ (ค่าเริ่มต้นอยู่ในไดเรกทอรีการติดตั้งของ PM2) และสามารถตรวจสอบการเปลี่ยนแปลงไฟล์ รีสตาร์ทบริการโดยอัตโนมัติ