วิธีการปรับใช้แอปพลิเคชัน Node.js

ในบทความนี้ เราจะอธิบายวิธีการปรับใช้ (deploy) แอปพลิเคชัน Node JS เราจะพูดถึงข้อดีและข้อเสียของ Node และตัวเลือกการปรับใช้ — รวมถึง IaaS, PaaS และ BaaS สุดท้ายเราจะปรับใช้แอปพลิเคชัน Node ไปยัง Back4app

Node.js คืออะไร?

Node.js เป็น runtime สำหรับ JavaScript แบบเปิดโล่งและข้ามแพลตฟอร์มที่สร้างบน V8 JavaScript engine ของ Chrome Node มุ่งหวังที่จะช่วยให้นักพัฒนา JavaScript สามารถพัฒนาได้ครบทุกส่วนด้วยการเขียนโค้ดสำหรับการทำงานฝั่งเซิร์ฟเวอร์ กรณีการใช้งานของ Node รวมถึงการเขียนสคริปต์ฝั่งเซิร์ฟเวอร์ แอปพลิเคชันเรียลไทม์ การสตรีมมิ่งเว็บแอปพลิเคชัน แอปพลิเคชันแบบหน้าเดียว (SPA) เครื่องมือสำหรับการร่วมมือ และเกมบนเว็บ

Node มีสถาปัตยกรรมแบบขับเคลื่อนด้วยเหตุการณ์ที่สามารถทำ I/O แบบอะซิงโครนัสได้ มันทำงานได้เร็วมาก เนื่องจากความสามารถในการคอมไพล์ JavaScript ให้เป็นโค้ดเครื่องแบบเนทีฟ มันสามารถจัดการกับ การเชื่อมต่อที่ใช้งานอยู่จำนวนมหาศาล และช่วยให้นักพัฒนาสร้างแอปพลิเคชันที่สามารถปรับขนาดได้และมีประสิทธิภาพสูงได้อย่างง่ายดาย

เทคโนโลยีนี้ถูกนำเสนอครั้งแรกในปี 2009 โดยผู้สร้าง Ryan Dahl ในการประชุมประจำปี European JSConf ทันทีที่เปิดตัวมันก็กลายเป็นหนึ่งในซอฟต์แวร์ที่น่าสนใจที่สุดในระบบนิเวศของ JavaScript

ความนิยมของ Node สูงสุดในปี 2017 และยังคงสูงอยู่ มันเป็นหนึ่งในเครื่องมือพัฒนาที่ได้รับความนิยมมากที่สุดที่ใช้โดยบริษัทหลายล้านดอลลาร์ เช่น IBM, LinkedIn, Microsoft, Netflix และอื่นๆ ความเรียบง่ายและความสามารถในการปรับขนาดทำให้มันเหมาะสำหรับบริษัททุกรูปแบบ — รวมถึงสตาร์ทอัพ

ในสองส่วนต่อไปนี้ เราจะเจาะลึกถึงข้อดีและข้อเสียของ Node

ข้อดีของ Node.js

ประสิทธิภาพสูง

ตามที่กล่าวไว้ในบทนำ Node ใช้เครื่องยนต์ JavaScript ที่มีประสิทธิภาพสูงของ Google V8 สามารถคอมไพล์และรัน JavaScript ได้อย่างรวดเร็วเป็นพิเศษ โดยเฉพาะอย่างยิ่งเพราะมันคอมไพล์ JavaScript ให้เป็นโค้ดเครื่องแบบเนทีฟ

Node ยังใช้ event loop ซึ่งช่วยให้มันสามารถทำงาน I/O แบบไม่บล็อกได้ แม้ว่า JavaScript จะเป็นภาษาโปรแกรมแบบ single-threaded นี่ทำให้มันเป็นหนึ่งในตัวเลือกที่เร็วที่สุดในตลาด

ความสามารถในการปรับขนาด

หนึ่งในประโยชน์สำคัญของ Node.js คือความสามารถในการปรับขนาด แอปพลิเคชัน Node สามารถปรับขนาดได้ทั้งในแนวนอนและแนวตั้ง การปรับขนาดแนวนอนทำได้โดยการเพิ่มโหนดเพิ่มเติมเข้าไปในระบบที่มีอยู่ ในขณะที่การปรับขนาดแนวตั้งหมายถึงการเพิ่มทรัพยากรเพิ่มเติมให้กับโหนดเฉพาะ ตัวเลือกการปรับขนาดที่ยอดเยี่ยมของแพลตฟอร์มนี้ทำให้มันเหมาะสำหรับทั้งสตาร์ทอัพและบริษัทใหญ่ที่มีผู้ใช้รายวันหลายสิบล้านคนเช่น LinkedIn, Netflix และ PayPal

Node ยังเหมาะสำหรับสถาปัตยกรรม microservices อีกด้วย ซึ่งช่วยให้นักพัฒนาสามารถสร้างส่วนประกอบขนาดเล็กที่สามารถเข้ากันได้กับสายการส่งมอบแบบต่อเนื่องและสามารถปรับขนาดได้ง่ายตามต้องการ

เรียนรู้ง่าย

พื้นฐานของ Node มาจาก JavaScript ทำให้เรียนรู้ได้ง่ายมากสำหรับนักพัฒนาที่รู้พื้นฐานของ JavaScript อยู่แล้ว มันไม่มีความซับซ้อนในการเรียนรู้สูงและสามารถเชี่ยวชาญได้ภายในเวลาไม่กี่สัปดาห์ ความเรียบง่ายของ Node ทำให้มันเหมาะสำหรับโครงการทุกประเภท

เวลาสู่ตลาดที่เร็วขึ้น

เวลาสู่ตลาดเป็นหนึ่งในเกณฑ์สำคัญของทีมพัฒนาจำนวนมาก ทุกคนต้องการที่จะนำผลิตภัณฑ์ออกสู่ตลาดให้เร็วที่สุดและ Node ช่วยให้คุณทำเช่นนั้นได้

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

เครื่องมือที่ผ่านการทดสอบมาแล้ว

Node เป็นเครื่องมือที่ผ่านการทดสอบในสนามรบและมีความเป็นผู้ใหญ่ซึ่งมีมาตั้งแต่ปี 2009 ความเสถียรของมันได้รับการทดสอบโดยบริษัทใหญ่ๆ เช่น eBay, Netflix และ LinkedIn ซึ่งมีผู้ใช้หลายล้านคนต่อวัน

ด้วยคุณสมบัติที่ยอดเยี่ยมของมัน Node ถูกนำมาใช้ในเทคโนโลยีหลายแบบ (โดยปกติมักจะใช้ร่วมกับ Express และฐานข้อมูล NoSQL) บางส่วนของเทคโนโลยีที่ใช้ Node ได้แก่:

• MERN
• MEAN
• DERN

ชุมชนที่ยอดเยี่ยม

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

อีกสิ่งที่ยอดเยี่ยมเกี่ยวกับ Node.js คือตัวจัดการแพ็คเกจของมันที่ชื่อว่า npm (Node Package Manager) npm ช่วยให้นักพัฒนาดันและใช้แพ็คเกจ JavaScript ที่พร้อมใช้งานแทนที่จะสร้างใหม่ทั้งหมด แพ็คเกจเหล่านี้สามารถลดค่าใช้จ่ายและความซับซ้อนในการพัฒนาแอปพลิเคชันได้อย่างมาก ณ เวลาที่เขียน มีแพ็คเกจมากกว่า 1.3 ล้านแพ็คเกจที่โฮสต์อยู่บน npm

ข้อจำกัดของ Node.js

ประสิทธิภาพลดลงสำหรับงานที่ซับซ้อน

ข้อเสียที่ใหญ่ที่สุดของ Node.js คือความสามารถในการทำงานที่ต้องการการคำนวณหนักๆ ในปัจจุบันโปรแกรมและอัลกอริทึมหลายๆ อย่างต้องการการประมวลผลแบบขนานเพื่อให้ได้ผลลัพธ์ที่ดีที่สุด ดังที่คุณทราบ Node.js มีพื้นฐานมาจาก JavaScript ซึ่งออกแบบให้เป็นภาษาสำหรับส่วนหน้าแบบ single-threaded และไม่รองรับหลายเธรด

ด้วยการอัปเดตเวอร์ชั่น 10.5 ทีม Node.js ได้เปิดตัวการสนับสนุน multithreading ในรูปแบบของ worker threads โมดูลนี้ช่วยให้นักพัฒนาสามารถใช้เธรดเพิ่มเติมจากพูลเธรดได้ แม้จะมี worker threads Node ยังไม่เหมาะสำหรับการคำนวณหนัก ๆ หากข้อกำหนดของโปรเจกต์ของคุณรวมถึงการคำนวณที่ซับซ้อน การประมวลผลหนัก หรือการประมวลผลแบบขนาน คุณอาจจะเลือกใช้ภาษาโปรแกรมอื่นแทน

โมเดลการเขียนโปรแกรมแบบอะซิงโครนัส

Node.js ใช้โมเดลการเขียนโปรแกรมแบบอะซิงโครนัส เนื่องจากเหตุนี้มันจึงพึ่งพาการใช้ callbacks เป็นอย่างมาก Callbacks คือฟังก์ชันที่ทำงานเบื้องหลังและ (ในบางจุด) คืนค่าผลลัพธ์ โดยการใช้ callbacks โค้ดของคุณอาจกลายเป็นรกและยากต่อการดีบัก นอกจากนี้ หากคุณซ้อน callbacks หลายระดับ คุณอาจพบกับสิ่งที่เรียกว่า “callback hell”

Callback hell และปัญหาอื่นๆ ของการเขียนโปรแกรมแบบอะซิงโครนัสสามารถหลีกเลี่ยงได้ง่ายๆ โดยการปฏิบัติตามหลักการโค้ดที่สะอาด

API ไม่เสถียร

อีกปัญหาใหญ่กับ Node.js คือความไม่เสถียรของ application programming interface (API) ของมัน API ของ Node มีการเปลี่ยนแปลงบ่อยครั้งพร้อมกับการเปลี่ยนแปลงที่ไม่สามารถถอยกลับได้ซึ่งอาจทำให้ชิ้นส่วนของโค้ดเสียหาย ด้วยเหตุนี้นักพัฒนา Node จำเป็นต้องเฝ้าดูการเปลี่ยนแปลงและตรวจสอบให้แน่ใจว่า codebase ของพวกเขาสามารถทำงานร่วมกับ Node.js API เวอร์ชั่นล่าสุดได้

ขาดระบบสนับสนุนห้องสมุดที่แข็งแกร่ง

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

ระบบทะเบียนโมดูลที่ขยายเกินควบคุมและยังไม่เติบโตเต็มที่

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

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

อย่าเข้าใจผมผิด ผมคิดว่า npm ยอดเยี่ยม แต่คุณก็ควรระมัดระวังเมื่อจะติดตั้งโมดูลสุ่ม

ตัวเลือกการปรับใช้ Node.js

มีหลายวิธีในการปรับใช้แอปพลิเคชัน Node.js โดยทั่วไปแล้วเราสามารถแบ่งออกเป็นสี่กลุ่มดังนี้:

1. การโฮสต์แบบดั้งเดิม
2. Infrastructure as a Service (IaaS)
3. Platform as a Service (PaaS)
4. Backend as a Service (BaaS)

เราสามารถแสดงผลพวกมันในแผนภูมิพีระมิดตามระดับของการนามธรรม:

ตัวเลือกการปรับใช้ดูแลเลเยอร์การนามธรรมดังต่อไปนี้:

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

บริการ IaaS เช่น AWS

Infrastructure as a Service (IaaS) เป็นโมเดลบริการคลาวด์คอมพิวติ้งที่ให้ทรัพยากรการคำนวณเช่น เซิร์ฟเวอร์ เครือข่าย ระบบปฏิบัติการ และพื้นที่เก็บข้อมูลในสภาพแวดล้อมที่จำลองเป็นเสมือน เซิร์ฟเวอร์คลาวด์เหล่านี้โดยทั่วไปจะถูกจัดให้กับองค์กรผ่าน API ระดับสูงหรือแดชบอร์ดขั้นสูงซึ่งให้ลูกค้ามีการควบคุมอย่างสมบูรณ์เหนือโครงสร้างพื้นฐานทั้งหมด

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

IaaS เกิดขึ้นในช่วงต้นปี 2010 และนับตั้งแต่นั้นกลายเป็นโมเดลนามธรรมมาตรฐานสำหรับงานประเภทต่างๆ แม้จะมีเทคโนโลยีใหม่ๆ เช่น microservices และ serverless ปรากฏขึ้น IaaS ก็ยังคงเป็นตัวเลือกที่ได้รับความนิยมมากที่สุด

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

ตัวอย่าง IaaS แบบทั่วไปได้แก่:

• Amazon Web Services (AWS)
• Google Compute Engine (GCE)
• Microsoft Azure
• DigitalOcean
• Linode
• Rackspace

บริการ PaaS เช่น Heroku

Platform as a Service (PaaS) เป็นโมเดลบริการคลาวด์คอมพิวติ้งที่มอบสภาพแวดล้อมคลาวด์ให้กับผู้ใช้ เพื่อที่พวกเขาจะสามารถพัฒนา จัดการ และส่งมอบแอปพลิเคชันได้ นอกจากจะให้ทรัพยากรคอมพิวเตอร์แล้ว PaaS ยังมาพร้อมกับเครื่องมือที่สร้างไว้ล่วงหน้ามากมายสำหรับการพัฒนา ปรับแต่ง และทดสอบแอปพลิเคชัน ผู้ขาย PaaS ส่วนใหญ่จะอนุญาตให้คุณเริ่มต้นแอปของคุณได้ในไม่กี่คลิก!

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

ข้อดีของ PaaS บางประการ ได้แก่:

• ความเร็วในการเข้าสู่ตลาดที่เร็วขึ้น
• ความปลอดภัยที่เพิ่มขึ้น
• ความคุ้มค่า
• ความสามารถในการปรับขนาด
• ความพร้อมใช้งานสูง
• ต้องเขียนโค้ดน้อยลง

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

บริการ PaaS ได้แก่:

• Heroku
• AWS Elastic Beanstalk
• DigitalOcean App Platform
• Microsoft Azure App Service
• The Fly Platform (Fly.io)
• Render

บริการ BaaS เช่น Back4app

Backend as a Service (BaaS) เป็นแพลตฟอร์มที่ทำให้การพัฒนาฝั่งหลังอัตโนมัติและดูแลโครงสร้างพื้นฐานคลาวด์ นอกจากนี้ยังมาพร้อมกับคุณสมบัติต่างๆ เช่น การจัดการผู้ใช้ การแจ้งเตือนทางอีเมล การแจ้งเตือนแบบพุช ฟังก์ชันโค้ดบนคลาวด์ การรวมเข้ากับโซเชียลมีเดีย การจัดเก็บไฟล์ และการชำระเงิน

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

BaaS มอบประโยชน์ทั้งหมดของ IaaS และ PaaS ในขณะที่รวมการนามธรรมของฝั่งหลัง ทีมที่ใช้ BaaS จะช่วยลดเวลาในการสู่ตลาดอย่างมาก ลดค่าใช้จ่ายด้านวิศวกรรม และต้องการวิศวกรน้อยลง

BaaS สามารถใช้ได้กับโครงการหลายประเภท — รวมถึงการสร้าง MVP (Minimum Viable Product) แอปแบบสแตนด์อโลน หรือแอปที่ต้องการการรวมเพียงเล็กน้อย & แอปสำหรับองค์กรที่ไม่ใช่ภารกิจสำคัญ

ข้อเสียของ BaaS คือความยืดหยุ่นน้อยกว่า IaaS และ PaaS ให้ระดับการควบคุมและการปรับแต่งที่ต่ำกว่า และมีความเป็นไปได้ในการล็อกอินสำหรับแพลตฟอร์มที่ไม่เปิดซอร์ส

ตัวอย่าง BaaS บางส่วน:

• Back4app
• AWS Amplify
• Firebase
• Parse
• Cloudkit
• Backendless

กระบวนการปรับใช้ Node.js

ในส่วนนี้ของบทความ เราจะดูที่ Back4app และเรียนรู้วิธีการสร้างและปรับใช้แอปพลิเคชัน Node JS

Back4app คืออะไร?

Back4app เป็นหนึ่งในโซลูชัน Backend as a Service (BaaS) แบบเปิดโอเพ่นซอร์สที่ดีที่สุด ในตลาด มันมีคุณสมบัติและประโยชน์หลากหลายสำหรับผู้ใช้ ทำให้นักพัฒนาสามารถสร้างเว็บและแอปมือถือได้อย่างรวดเร็ว ด้วยการใช้ Back4app คุณจะสามารถมุ่งเน้นไปที่ธุรกิจหลักแทนที่จะกังวลเกี่ยวกับฝั่งหลังหรือโครงสร้างพื้นฐาน

โซลูชันนี้มาพร้อมกับแดชบอร์ดที่เต็มไปด้วยคุณสมบัติและใช้งานง่าย และ command line interface (CLI) พวกเขายังมี SDK สำหรับเครื่องมือยอดนิยมทั้งหมดของคุณ เช่น Flutter, React Native, Node.js, Angular, Android, iOS และอื่นๆ!

คุณสมบัติหลักของ Back4app ได้แก่:

• ฐานข้อมูลที่คล้ายกับสเปรดชีท
• REST และ GraphQL API
• Live Queries
• การยืนยันตัวตน (รวมถึงการยืนยันตัวตนผ่านโซเชียลมีเดีย)
• การโฮสต์ที่สามารถปรับขนาดได้
• การแจ้งเตือนแบบพุชและอีเมล

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับคุณสมบัติของพวกเขา ให้ดูที่ Back4app Features

Back4app ปฏิบัติตามโมเดลราคาที่เรียบง่ายและชัดเจนซึ่งเหมาะกับแอปทุกขนาด พวกเขามีแผนฟรีที่เอ generös (ไม่ต้องใช้บัตรเครดิต) เหมาะสำหรับการสร้างต้นแบบและทดลองแพลตฟอร์ม มันรวมถึง:

• 25k requests
• 250 MB data storage
• 1 GB transfer
• 1 GB file storage

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการตั้งราคา Back4app ให้ดูที่ หน้าราคาของเรา

การแนะนำโปรเจกต์

เราจะเขียนโค้ดและปรับใช้แอปพลิเคชัน TODO แบบง่าย แอปบนเว็บนี้จะรองรับการทำงาน CRUD พื้นฐาน — สร้าง อ่าน อัปเดต และลบ เราจะเขียนใน Node.js โดยใช้เฟรมเวิร์ก Express การจัดเก็บข้อมูลจะถูกดูแลโดย Parse และเราจะใช้ Twig เป็นเอนจิ้นการเทมเพลต

คลิกที่นี่เพื่อดูแอปที่ปรับใช้แล้ว!

ความต้องการเบื้องต้น:

• เข้าใจพื้นฐานของ Node.js
• เข้าใจพื้นฐานของ Express
• มีประสบการณ์กับเอนจิ้นการเทมเพลต
• เข้าใจพื้นฐานของฐานข้อมูลและ ParseJS

Back4app CLI

ขั้นตอนต่อไปนี้จะต้องใช้บัญชี Back4app หากคุณมีอยู่แล้ว เข้าสู่ระบบ มิฉะนั้นดำเนินการ สมัครบัญชีฟรี

Back4app CLI คืออินเทอร์เฟซบรรทัดคำสั่งที่ช่วยให้คุณโต้ตอบกับแพลตฟอร์ม Back4app

เพื่อติดตั้งบน Mac/Linux ให้รัน:

$ curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

คำสั่งนี้จะดาวน์โหลดไบนารี CLI ล่าสุดและเก็บไว้ใน /usr/local/bin/b4a

สำหรับระบบปฏิบัติการอื่นๆ โปรดดูที่ เอกสารอย่างเป็นทางการ

ในการใช้ CLI คุณจะต้องทำการยืนยันตัวตนด้วยบัญชีของคุณ เพื่อทำสิ่งนั้นคุณต้องสร้าง account key ก่อน ไปที่แดชบอร์ด Back4app ของคุณแล้วคลิกที่ชื่อผู้ใช้ของคุณ (มุมบนขวาของหน้าจอ) แล้วเลือก “Account Keys”:

ในการเพิ่ม account key ใหม่ ให้ป้อนชื่อกุญแจที่กำหนดเองแล้วกด “+”. จดจำกุญแจไว้เพราะเราจะต้องใช้ในขั้นตอนถัดไป:

หลังจากที่คุณสร้างกุญแจสำเร็จแล้ว ให้กลับไปที่เทอร์มินัลและรัน:

$ b4a configure accountkey Input your account key or press ENTER to generate a new one. NOTE: on pressing ENTER we'll try to open the url: "http://dashboard.back4app.com/classic#/wizard/account-key" in default browser. Account Key: <YOUR_GENERATED_ACCOUNT_KEY> Successfully stored account key for: "<YOUR_EMAIL>".

เพื่อให้แน่ใจว่าการยืนยันตัวตนทำงาน ให้ลองดูรายชื่อแอปของคุณ:

$ b4a list These are the apps you currently have access to:

หากบัญชีของคุณใหม่เปรียบเสมือนของผม แอปใดๆ จะไม่ถูกแสดง

สร้างแอป

ต่อไปเราจะสร้างแอปบน Back4app

รันคำสั่ง:

$ b4a new Would you like to create a new app, or add Cloud Code to an existing app? Type "(n)ew" or "(e)xisting": n Please choose a name for your Parse app. Note that this name will appear on the Back4App website, but it does not have to be the same as your mobile app's public name. Name: nodejs-back4app Awesome! Now it's time to set up some Cloud Code for the app: "nodejs-back4app", Next we will create a directory to hold your Cloud Code. Please enter the name to use for this directory, or hit ENTER to use "nodejs-back4app" as the directory name. Directory Name: You can either set up a blank project or create a sample Cloud Code project Please type "(b)lank" if you wish to setup a blank project, otherwise press ENTER: Successfully configured email for current project to: "<YOUR_EMAIL>" Your Cloud Code has been created at /dev/nodejs-back4app.

1. สร้างแอปใหม่หรือเพิ่มลงในแอปที่มีอยู่: new
2. เลือกชื่อแอป: เลือกชื่อที่กำหนดเอง
3. ชื่อไดเรกทอรี: กด ENTER
4. โครงการ Cloud Code ว่างหรือแบบตัวอย่าง: กด ENTER

คำสั่งนี้จะสร้างไดเรกทอรีด้วยโครงสร้างดังนี้:

nodejs-back4app/ ├── cloud/ │ └── main.js ├── public/ │ └── index.html ├── .parse.local └── .parse.project

1. cloud คือไดเรกทอรีสำหรับโค้ดและฟังก์ชันบนคลาวด์ทั้งหมด
2. public คือไดเรกทอรีสำหรับไฟล์สาธารณะ เช่น รูปภาพ สไตล์ชีท และอื่นๆ
3. .parse.local และ .parse.project ใช้เก็บการกำหนดค่า Parse

ลบไฟล์ main.js และ index.html ออก เนื่องจากเราไม่ต้องการมัน

การโฮสต์เว็บไซต์

เนื่องจากเรากำลังสร้างแอป Node.js เราจำเป็นต้องเปิดใช้งานการโฮสต์เว็บไซต์เพื่อให้ Back4app สามารถโฮสต์แอปของเราและทำให้สามารถเข้าถึงได้จากอินเทอร์เน็ต

ในการเปิดใช้งานคุณสมบัติการโฮสต์เว็บไซต์ ไปที่แดชบอร์ด Back4app ของคุณ เลือกแอปของคุณ คลิก “App Settings” ที่ด้านซ้ายของหน้าจอ แล้วเลือก “Server Settings” ค้นหา “Webhosting and Custom Domains” แล้วคลิกที่ “Settings” อีกครั้ง

คลิก “Activate Back4app Hosting” และเลือกชื่อซับโดเมน ผมจะใช้ nodejsback4app:

สุดท้าย คลิก “Save”

จากนั้นแอปของคุณจะสามารถเข้าถึงได้ที่:

https://<your_subdomain>.b4a.app/

คุณสามารถเชื่อมโยงโดเมนที่กำหนดเองกับเว็บแอปของคุณได้ด้วย!

Express กับฟังก์ชัน Cloud Code

ต่อไป มาทำงานกับโค้ดจริงกัน

เปลี่ยนไดเรกทอรีไปที่ cloud และสร้างไฟล์ package.json ภายใน:

Back4app ใช้ไฟล์นี้ในการดาวน์โหลดโมดูลผ่าน npm เราเพิ่ม body-parser เพราะเราจะต้องใช้มันในภายหลังเพื่อวิเคราะห์คำขอ

ต่อไป สร้างไฟล์อีกไฟล์หนึ่งในโฟลเดอร์ cloud ที่ชื่อว่า app.js:

ไฟล์นี้ใช้ในการเริ่มต้นและกำหนดค่า Express เรายังได้กำหนด endpoint หนึ่งที่จะใช้เป็นการตรวจสอบความถูกต้องในขั้นตอนถัดไป ดังที่คุณเห็นเราไม่จำเป็นต้องกำหนด app หรือ require dependencies ใดๆ เพราะ Back4app จัดการให้เราโดยอัตโนมัติ

ต่อไป ปรับใช้แอป:

$ b4a deploy Uploading source files Uploading recent changes to scripts... Finished uploading files New release is named v1 (using Parse JavaScript SDK v2.2.25)

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

เพื่อให้แน่ใจว่ามันทำงาน เปิดเว็บเบราว์เซอร์ที่คุณชื่นชอบและไปที่แอปของคุณ:

https://<your_subdomain>.b4a.app/ # Example https://nodejsback4app.b4a.app/

คุณควรได้รับการตอบกลับดังต่อไปนี้:

ทำได้ดี!

ในส่วนต่อไป เราจะเริ่มทำงานกับแอป TODO จริงๆ

ฐานข้อมูลกับ ParseJS

มากำหนดโมเดลฐานข้อมูลสำหรับแอป TODO กัน

ไปที่แดชบอร์ด Back4app และเลือก “Database” ที่ด้านซ้ายของหน้าจอ หลังจากนั้นคลิกที่ “Create a new class” ตั้งชื่อ Task และตรวจสอบให้แน่ใจว่าเลือก “Public Read and Write enabled”:

จากนั้น เพิ่มคอลัมน์ดังต่อไปนี้:

+-----------+-------------+---------------+----------+ | Data type | Name | Default value | Required | +-----------+-------------+---------------+----------+ | String | name | <leave blank> | yes | +-----------+-------------+---------------+----------+ | String | description | <leave blank> | no | +-----------+-------------+---------------+----------+ | Boolean | isDone | false | yes | +-----------+-------------+---------------+----------+

ตรรกะแอป

แอปจะมี endpoints ดังต่อไปนี้:

1. / แสดงรายการงาน
2. /create สร้างงาน
3. /<ID> แสดงรายละเอียดงาน
4. /<ID>/delete ลบงาน
5. /<ID>/toggle สลับสถานะงาน — เสร็จ/ไม่เสร็จ

เรามาสร้างมันกันเถอะ

เพื่อให้โค้ดบนคลาวด์ของเราง่ายต่อการบำรุงรักษามากขึ้น เราจะแยกมันออกเป็นสองไฟล์

1. app.js — เริ่มต้นและกำหนดค่าเซิร์ฟเวอร์ Express
2. routes.js — กำหนด endpoints และตรรกะของพวกมัน

แนวทางที่ดีกว่าในการสร้างเว็บแอปสมัยใหม่คือการใช้สถาปัตยกรรม Model-View-Controller (MVC) การเริ่มต้นที่ดีสำหรับ Express คือการใช้ express-generator

ไปแทนที่เนื้อหาใน app.js ด้วยสิ่งต่อไปนี้:

1. เราได้ตั้งค่า Twig เป็นเอนจิ้นมุมมองเริ่มต้น
2. เส้นทางต่างๆ ไม่ได้ถูกกำหนดในไฟล์นี้อีกต่อไป แต่จะอยู่ใน routes.js

ต่อไป สร้าง routes.js และใส่โค้ดต่อไปนี้:

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

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ ParseJS ให้ดูที่ คู่มือ JavaScript

ต่อไป เรามาเพิ่มเทมเพลตมุมมองให้กับ endpoints กัน

สร้างโฟลเดอร์ views ภายในโฟลเดอร์ cloud ดาวน์โหลดไฟล์เทมเพลตจาก GitHub repo และวางไว้ในไดเรกทอรี views

โครงสร้างไดเรกทอรีสุดท้ายของคุณควรมีลักษณะดังนี้:

nodejs-back4app/ ├── cloud/ │ ├── views/ │ │ ├── base.twig │ │ ├── create.twig │ │ ├── error.twig │ │ ├── index.twig │ │ └── task.twig │ ├── app.js │ ├── routes.js │ └── package.json ├── public ├── parse.local └── parse.project

สุดท้าย เพิ่ม twing ลงใน package.json เพื่อเปิดใช้งานการรองรับ Twig:

ปรับใช้แอป:

$ b4a deploy Uploading source files Uploading recent changes to scripts... Finished uploading files New release is named v2 (using Parse JavaScript SDK v2.2.25)

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

ไฟล์สาธารณะ

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

ไปที่ app.js และเพิ่มบรรทัดต่อไปนี้:

จากนั้นคุณสามารถอ้างอิงถึงไฟล์สาธารณะในเทมเพลตของคุณผ่านเส้นทางสัมพัทธ์:

<img src="/back4app.png" alt="Back4app Logo">

แสดงภาพที่อยู่ใน public/back4app.png

บทสรุป

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

แอป Node สามารถปรับใช้บนโซลูชันที่แตกต่างกันได้ เช่น IaaS, PaaS และ SaaS แต่ละแบบมีข้อดีและข้อเสียที่ควรพิจารณาเมื่อเลือกตัวเลือกการปรับใช้

หนึ่งในวิธีที่ง่ายที่สุดในการปรับใช้แอป Node คือการใช้ Back4app — โซลูชัน BaaS แบบเปิดโอเพ่นซอร์สที่มีคุณสมบัติมากมาย Back4app ยอดเยี่ยมเพราะมันช่วยให้คุณมุ่งเน้นไปที่สิ่งที่สำคัญขณะมอบหมายการดูแลฝั่งหลังและการปรับใช้ให้กับผู้อื่น

รับซอร์สโค้ดสุดท้ายได้จาก repo back4app-nodejs

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับตัวเลือกการโฮสต์ Node.js โปรดดู วิธีการโฮสต์แอป Node.JS โดยใช้คอนเทนเนอร์