איך לפרוס אפליקציית Node.js?

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

Node.js คืออะไร?

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

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

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

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

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

ข้อดีของ Node.js

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

ตามที่กล่าวไว้ในบทนำ Node ขับเคลื่อนด้วย JavaScript engine ของ 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) บางส่วนของเทคโนโลยีเหล่านี้ ได้แก่:

• 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 ได้นำเสนอการรองรับมัลติเธรดในรูปแบบของ worker threads โมดูลนี้ช่วยให้นักพัฒนาสามารถใช้ประโยชน์จากเธรดเพิ่มเติมจากพูลของเธรดได้ แม้ว่าจะมี worker threads แต่ Node ยังคงไม่เหมาะสำหรับการคำนวณหนัก ๆ หากความต้องการของโครงการของคุณรวมถึงการคำนวณที่ซับซ้อน การคำนวณหนัก หรือการประมวลผลแบบขนาน คุณอาจจะใช้ภาษาโปรแกรมอื่นให้เหมาะสมกว่า

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

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

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

API ที่ไม่เสถียร

อีกปัญหาใหญ่ของ Node.js คือความไม่เสถียรของ API (Application Programming Interface) ของมัน API ของ Node มักมีการเปลี่ยนแปลงที่ไม่รองรับกับเวอร์ชันก่อนหน้า ซึ่งอาจทำให้โค้ดบางส่วนขัดข้อง เป็นผลให้ผู้พัฒนา Node ต้องคอยติดตามการเปลี่ยนแปลงและตรวจสอบให้แน่ใจว่าโค้ดของตนเข้ากันได้กับเวอร์ชันล่าสุดของ 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 APIs
• Live Queries
• การตรวจสอบสิทธิ์ (รวมถึงการตรวจสอบสิทธิ์ทางสังคม)
• การโฮสต์ที่สามารถขยายได้
• การแจ้งเตือนแบบพุชและทางอีเมล

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

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

• 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 คุณจะต้องทำการยืนยันตัวตนด้วยบัญชีของคุณ ในการทำเช่นนั้นคุณต้องสร้างคีย์บัญชีก่อน ไปที่แดชบอร์ด Back4app ของคุณแล้วคลิกที่ชื่อผู้ใช้ของคุณ (มุมขวาบนของหน้าจอ) แล้วเลือก “Account Keys”:

ในการเพิ่มคีย์บัญชีใหม่ ให้ป้อนชื่อคีย์ที่กำหนดเองแล้วกด “+”. บันทึกคีย์ไว้เพราะเราจำเป็นต้องใช้ในขั้นตอนต่อไป:

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

$ 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 แล้วสร้างไฟล์ 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        | <เว้นว่าง>       | yes      |
+-----------+-------------+---------------+----------+
| String    | description | <เว้นว่าง>       | 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) ไม่ได้ถูกกำหนดในไฟล์นี้อีกต่อไป แต่ถูกกำหนดใน routes.js

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

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

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

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

สร้างโฟลเดอร์ views ภายในโฟลเดอร์ cloud ดาวน์โหลดไฟล์เทมเพลตจาก รีโพซิทอรี GitHub และวางลงในไดเรกทอรี 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 แล้วเพิ่มบรรทัดต่อไปนี้:

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

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

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

บทสรุป

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

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

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

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

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