เรียนรู้วิธีทำให้ Serverless ทำงานด้วย Node.js

บล็อก

เรียนรู้วิธีทำให้ Serverless ทำงานด้วย Node.js

บทนำ

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

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

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

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

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

ไม่ต้องกังวล เราจะมาทำความเข้าใจเรื่องนี้ในภายหลังในขณะที่เราตรวจสอบใบสมัครของเรา

ข้อดี

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

การจัดสรรทรัพยากร ในกรณีนี้ ส่วนใหญ่จะสัมพันธ์กับจำนวนของเหตุการณ์หรือคำขอขาเข้าหรือพร้อมกัน สิ่งนี้ถูกกำหนดและจัดการ/ให้บริการโดยผู้ให้บริการระบบคลาวด์เท่านั้น (AWS, GCP, Azure ฯลฯ) ที่ให้บริการเหล่านี้

ข้อดีบางประการของแอปพลิเคชันแบบไร้เซิร์ฟเวอร์ ได้แก่:

  • แอปพลิเคชันแบบไร้เซิร์ฟเวอร์ได้รับการปรับขนาดตามความต้องการตามจำนวนทรัพยากรที่จำเป็นในการจัดการคำขอที่ให้บริการ
  • คำขอที่เกิดขึ้นพร้อมกันจะถูกปฏิเสธในอินสแตนซ์คอนเทนเนอร์ใหม่
  • การอัปเดตความปลอดภัยหรือโปรแกรมแก้ไขได้รับการจัดการสำหรับเรา
  • รายละเอียดทางเทคนิคอื่น ๆ ทั้งหมดได้รับการจัดการโดยผู้ให้บริการระบบคลาวด์ที่มีปัญหา เพื่อให้ในฐานะวิศวกร เราสามารถมุ่งเน้นที่การบำรุงรักษาแอปพลิเคชันหลักและการใช้งานคุณลักษณะ
  • รอบการทำให้ใช้งานได้เร็วขึ้นโดยใช้คำสั่งเดียว |_+_|
  • Serverless นำเสนอสิ่งที่เป็นนามธรรมสำหรับโครงสร้างพื้นฐานระบบคลาวด์
  • สิ่งสำคัญที่สุดคือ การจ่ายเงินสำหรับทรัพยากรที่แน่นอนที่ใช้ไป เนื่องจากการจัดการเซิร์ฟเวอร์ได้รับการจัดการในนามของเรา

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

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

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

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

ข้อกำหนดเบื้องต้น

เพื่อให้ง่ายต่อการปฏิบัติตามบทช่วยสอนนี้ เราควร:

  • ติดตั้ง Node และ npm บนเครื่องของเรา
  • มีความรู้พื้นฐานการใช้ command line

เพื่อเริ่มต้นการพัฒนาแบบไร้เซิร์ฟเวอร์ เราต้องติดตั้ง CLI เพื่อให้เราสามารถรันคำสั่งเฉพาะแบบไร้เซิร์ฟเวอร์ได้ ในการติดตั้ง เราสามารถเรียกใช้:

sls deploy

ก่อนหน้านี้ในบทช่วยสอนนี้ เราได้อธิบายวิธีรันโค้ดแบบไร้เซิร์ฟเวอร์เป็นฟังก์ชันไร้สถานะ ดูตัวอย่างด้านล่าง:

$ npm install serverless -g

มาทบทวนวิธีการทำงานแบบไร้เซิร์ฟเวอร์ด้านบนกัน |_+_| const คือชื่อของฟังก์ชันแบบไร้เซิร์ฟเวอร์ของเรา

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

|_+_| ออบเจ็กต์มีข้อมูลเกี่ยวกับสภาพแวดล้อมที่ฟังก์ชันของเราจะต้องดำเนินการ (โปรดทราบว่าสิ่งนี้มักจะถูกจัดการโดยผู้ให้บริการคลาวด์ในนามของเรา)

สุดท้าย |_+_| ฟังก์ชันจะดูแลการส่งคืนการตอบสนองหรืออ็อบเจ็กต์ข้อผิดพลาด โดยปกติจะขึ้นอยู่กับคำขอจากเหตุการณ์ของผู้ใช้

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

  • การสร้างบัญชี AWS — เพื่อสร้างบัญชีฟรี คุณสามารถตรวจสอบสิ่งนี้ ลิงค์
  • การตั้งค่าการระบุตัวตนและการจัดการการเข้าถึง (IAM) สำหรับบทบาท/นโยบายของผู้ใช้
  • การกำหนดค่า AWS CLI
  • การกำหนดค่าบริการอื่นๆ ของ AWS ที่เราอาจต้องการ เช่น ฐานข้อมูล และอื่นๆ

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

โปรดทราบด้วยว่าเรายังสามารถใช้ประโยชน์จากทั้ง Azure หรือ GCP สำหรับกรณีการใช้งานของเราด้านบน

การสร้างแอปพลิเคชันแบบไร้เซิร์ฟเวอร์บนไมโครเซอร์วิส

ดังที่ได้กล่าวไว้ข้างต้น ให้เราเริ่มต้นโดยการตั้งค่าเพื่อการพัฒนาท้องถิ่น หากก่อนหน้านี้เรายังไม่ได้ติดตั้ง CLI แบบไร้เซิร์ฟเวอร์ทั่วโลก เราสามารถทำได้ตอนนี้:

const handlerFunction = (event, context, callback) => { // handle business logic code here based on the kind of request // handle callback here callback(error, result) } module.exports = handlerFunction;

Serverless เป็นเฟรมเวิร์กช่วยในการจัดการส่วนที่ยากสำหรับเราในฐานะวิศวกร สิ่งที่เราต้องทำคือเขียนโค้ดที่มีสถาปัตยกรรมที่ดีเป็นฟังก์ชันไร้สัญชาติในทุกภาษาที่รองรับการใช้งานแบบไร้เซิร์ฟเวอร์

ซื้อหมาป่าตัวร้าย

เรามาเริ่มต้นสร้างไดเร็กทอรีใหม่และเรียกมันว่า |_+_|:

handleFunction

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

นอกจากนี้ เราจะตั้งค่า API ของเราโดยใช้ Serverless-http บรรจุุภัณฑ์. ด้วยแพ็คเกจนี้ API ของเราสามารถคล้ายกับแอป Express ซึ่งเราน่าจะคุ้นเคยเช่นกัน

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

event

เราจะได้ผลลัพธ์ต่อไปนี้พร้อมไฟล์เทมเพลตที่แสดงด้านล่าง:

ไฟล์เทมเพลตเอาต์พุต
รูปที่ 1: เอาต์พุตหลังจากรันคำสั่ง create –template แบบไร้เซิร์ฟเวอร์

ลำดับชั้นของโฟลเดอร์
รูปที่ 2: ลำดับชั้นของโฟลเดอร์หลังจากรันคำสั่งข้างต้น

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

เคล็ดลับ: เราสามารถเรียกใช้ |_+_| คำสั่งเพื่อดูรายการคำสั่งที่มีพร้อมคำอธิบายที่เกี่ยวข้องจากบรรทัดคำสั่ง

มาเริ่มกันที่แอปพลิเคชันของเรา เรียกใช้ |_+_| คำสั่งสร้าง |_+_| ไฟล์ จากนั้นเราจะเริ่มเพิ่มการพึ่งพาอื่นๆ

เราจะเริ่มต้นด้วยการติดตั้ง เซิฟเวอร์เลสออฟไลน์ เสียบเข้าไป. แพ็คเกจนี้จำลองสภาพแวดล้อมของเกตเวย์ API ภายในเครื่อง และจะช่วยให้เราทดสอบแอปพลิเคชันของเราได้อย่างรวดเร็วในขณะที่เราทำงานกับมัน เราควรดำเนินการต่อและติดตั้ง |_+_| ปลั๊กอินที่เราจะใช้ในการตั้งค่าตัวแปรสภาพแวดล้อมของเรา

ในการติดตั้งเป็นการพึ่งพา dev เราสามารถเรียกใช้:

context

หลังจากการติดตั้งเสร็จสมบูรณ์ เราสามารถดำเนินการต่อและเพิ่มไปยัง |_+_| . ของเราได้ ไฟล์.

callback

ตอนนี้ ไปข้างหน้าและติดตั้งแพ็คเกจอื่น ๆ ที่เราต้องการสำหรับแอพของเรา เราจะติดตั้ง body-parser, mongoose, Express, serverless-http และ uuid เราสามารถทำได้โดยเรียกใช้:

$ npm i serverless -g

หลังจากขั้นตอนการติดตั้ง |_+_| . ของเรา ไฟล์ควรมีลักษณะเช่นนี้

serveless-example

มาสร้างโฟลเดอร์และไฟล์ทั้งหมดที่เราต้องการกัน สำหรับแอปพลิเคชันที่ใช้ไมโครเซอร์วิส เราสามารถสร้าง |_+_| |_+_| และ |_+_| ไดเรกทอรี หลังจากนั้น เราสามารถสร้างไฟล์ที่เกี่ยวข้องในไดเร็กทอรีเหล่านั้นได้ โปรดทราบว่าเราจะสร้าง API ของผลิตภัณฑ์เพื่อสาธิตวิธีสร้างแอปพลิเคชันที่ใช้ไมโครเซอร์วิสแบบไร้เซิร์ฟเวอร์ใน Node.js

ในการสร้างโฟลเดอร์เหล่านี้ เราสามารถเรียกใช้คำสั่งต่อไปนี้:

$ mkdir serverless-example $ cd serverless-example

หลังจากนั้น เราสามารถนำทางไดเร็กทอรีและสร้างไฟล์ที่เกี่ยวข้องโดยใช้ชื่อ |_+_| หลังจากนั้น เราก็สร้าง |_+_| . ของเราได้ ไฟล์เพื่อเก็บตัวแปรสภาพแวดล้อมของเรา สุดท้าย เราสามารถดำเนินการต่อและสร้างไฟล์กำหนดค่าฐานข้อมูล ซึ่งจะมีการเชื่อมต่อฐานข้อมูลของเรากับอินสแตนซ์ mongo ในพื้นที่ที่ทำงานบนเครื่องของเรา ในบทช่วยสอนนี้ เราใช้ mongoose เป็น ORM เพื่อเชื่อมต่อกับ MongoDB

โครงสร้างโฟลเดอร์ของเราควรดูแลอย่างไรหลังจากดำเนินการเสร็จแล้ว:

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

เร่งดาวน์โหลดธุรกรรมที่ซ้ำกัน
serverless create --template aws-nodejs

ดังที่ได้กล่าวไว้ข้างต้น เราใช้ mongoose to เชื่อมต่อกับ MongoDB . ของเรา ในท้องถิ่น นอกจากนี้เรายังเข้าถึงสตริงการเชื่อมต่อ MongoDB โดยใช้ |_+_| บรรจุุภัณฑ์. หากต้องการดูรูปแบบของ |_+_| ของเรา เราสามารถตรวจสอบ |_+_| ไฟล์.

หลังจากนั้น เราสามารถตั้งค่าสคีมาผลิตภัณฑ์ของเราภายใน |_+_| . ได้ ไดเรกทอรี เรามาดูกันที่ |_+_| ไฟล์:

serverless.yml

หลังจากนั้นก็สร้าง |_+_| . ได้เลย ไฟล์ใน |_+_| ไดเรกทอรี ตรรกะที่นี่จะประกอบด้วยวิธีที่ |_+_| . ของเรา พูดคุยกับฐานข้อมูล — โดยทั่วไป วิธีจัดการกับการดำเนินการ CRUD มาดูเนื้อหาของไฟล์กันดีกว่า:

handler.js

ในไฟล์ด้านบน เราได้จัดการการโต้ตอบทั้งหมดกับฐานข้อมูล เราเรียก |_+_|, |_+_| และ |_+_| วิธี MongoDB เพื่อโต้ตอบกับมัน

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

serverless help

เรานำเข้าการพึ่งพาที่จำเป็นทั้งหมด เช่น |_+_| ซึ่งช่วยให้เราตั้งค่าแอปพลิเคชันแบบไร้เซิร์ฟเวอร์ได้เหมือนกับแอปพลิเคชัน Express ทั่วไป แน่นอน เรายังนำเข้าแพ็คเกจ Express ของเราและเริ่มแอพ Express ด้วย

หลังจากนั้น เรานำเข้าการเชื่อมต่อฐานข้อมูลและ |_+_| . ของเรา ไฟล์. ไฟล์นี้จัดการการสร้างผลิตภัณฑ์ใหม่ ดึงผลิตภัณฑ์ทั้งหมดจากฐานข้อมูล และดึงผลิตภัณฑ์โดยใช้ |_+_| ในบรรทัดสุดท้าย เราจะเห็นว่าเรากำลังห่อแอป Express ของเราด้วยแพ็คเกจ Serverless-http อย่างไร

สุดท้าย |_+_| . ของเรา ไฟล์ควรมีลักษณะดังนี้หลังจากเสร็จสิ้น:

npm init

เราได้กำหนดค่าแอปและบริการหรือปลั๊กอินที่จำเป็นแล้ว แต่โปรดทราบว่าในแอปพลิเคชันขนาดใหญ่ อาจมีบริการเพิ่มเติมอื่นๆ ที่เราอาจต้องพิจารณาเพิ่ม มองไปที่ |_+_| config เราสามารถดูว่าเราได้รับการอ้างอิงไปยังไฟล์คอนโทรลเลอร์ของเราได้อย่างไรและตั้งค่าเส้นทางการกำหนดเส้นทางให้ถูกต้องทั้งหมด

เมื่อตั้งค่าทั้งหมดเสร็จแล้ว มาเริ่มแอปและทดสอบ API กัน ในการทำเช่นนั้น เราสามารถเรียกใช้ |_+_| ในเทอร์มินัลของเรา เมื่อเราทำเช่นนั้น เราจะได้ผลลัพธ์ต่อไปนี้:

npm เริ่มเอาต์พุต
ครึ่งหลังของ npm เริ่มต้น เอาต์พุต
รูปที่ 4: แสดงผลลัพธ์เมื่อเรารันคำสั่ง npm start

ที่นี่ เราจะเห็นได้ว่าเส้นทางและตัวแปร env ทั้งหมดของเราแสดงอยู่บนเทอร์มินัลของเรา ตอนนี้ เราสามารถไปข้างหน้าและทดสอบ API ของเรา ในบทช่วยสอนนี้ เราจะใช้ POSTMAN เพื่อทดสอบ ให้เราสร้างผลิตภัณฑ์ใหม่

การสร้างผลิตภัณฑ์ใหม่ด้วย POSTMAN
รูปที่ 5: แสดงวิธีการสร้างผลิตภัณฑ์ใหม่โดยใช้ POSTMAN

ในทางกลับกัน เราสามารถไปข้างหน้าและสร้างผลิตภัณฑ์เพิ่มเติมและลองใช้ปลายทางอื่นๆ ได้เช่นกัน สามารถพบที่เก็บรหัสสำหรับบทช่วยสอนด้านบนได้ ที่นี่บน GitHub .

บทสรุป

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

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

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

#ไร้เซิร์ฟเวอร์ #nodejs #microservice