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

คุณอาจกำลังคิดว่าคุณมีระบบคลาวด์คอมพิวติ้งเพื่อดูแลสิ่งเหล่านี้ได้อย่างไร “ แล้วสิ่งใหม่นี้คืออะไร ไร้เซิร์ฟเวอร์ สิ่งที่ Vignes?”

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

หากไม่มีเซิร์ฟเวอร์สิ่งต่อไปนี้จะเป็นรูปแบบการทำงานของคุณ:

1. พัฒนาโค้ด

   
   
   

   เรียนรู้การเขียนโค้ดใน c++

2. อัปโหลดรหัสไปยังผู้ให้บริการ

3. กำหนดค่าทริกเกอร์ (คำขอ HTTP ในกรณีของเรา)

   
   
   

งานของเราเสร็จแล้ว! ตอนนี้ผู้ให้บริการแพลตฟอร์มจะดูแลคำขอที่เข้ามาและการปรับขนาด

ข้อมูลเบื้องต้นเกี่ยวกับบริการไมโครเซิร์ฟเวอร์แบบไร้เซิร์ฟเวอร์

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

ข้อมูลเบื้องต้นเกี่ยวกับ AWS Lambda & GCF การเปรียบเทียบ

คุณลักษณะแบบไร้เซิร์ฟเวอร์มักเรียกว่า 'back-end as a service' หรือ 'function as a service' จำนวนผู้ให้บริการคอมพิวเตอร์แบบไร้เซิร์ฟเวอร์เริ่มเพิ่มขึ้น อย่างไรก็ตามผู้เล่นรายใหญ่ทั่วไปบางรายยังมีตัวเลือกแบบไร้เซิร์ฟเวอร์เช่น Amazon Web Services ฟังก์ชัน AWS Lambda และ Google Cloud ฟังก์ชั่น Google Cloud (GCF) ซึ่งขณะนี้อยู่ในรุ่นเบต้าคือสิ่งที่ฉันใช้ แม้ว่าจะทำงานคล้ายกัน แต่ก็มีข้อแตกต่างที่สำคัญบางประการระหว่างกัน

	AWS Lambda	ฟังก์ชั่น Google Cloud
รองรับภาษา	Node.js, Python, C #, Java	โหนด js
ทริกเกอร์	DynamoDB, Kinesis, S3, SNS, API เกตเวย์ (HTTP), CloudFront และอีกมากมาย	HTTP, Cloud PubSub, ที่เก็บข้อมูลบนคลาวด์
เวลาดำเนินการสูงสุด	300 วินาที	540 วินาที

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

GCF มีการใช้งานที่เป็นไปได้สามแบบแยกกันตามทริกเกอร์

1. ทริกเกอร์ HTTP กำหนดเส้นทางคำขอ HTTP ไปยังฟังก์ชันคลาวด์

   
   
   

2. ภายใน Google pub / sub trigger Routes เผยแพร่และสมัครสมาชิกฟังก์ชันคลาวด์

3. ทริกเกอร์ที่เก็บข้อมูลบนคลาวด์กำหนดเส้นทางการเปลี่ยนแปลงใด ๆ ที่ทำกับที่เก็บข้อมูลไปยังฟังก์ชันคลาวด์

มาสร้างการตั้งค่าตามทริกเกอร์ HTTP โดยใช้ Google Cloud Functions

Google Cloud Functions ไม่จำเป็นต้องมีการตั้งค่าหรือการติดตั้งพิเศษเพิ่มเติม GCF ทำให้แน่ใจว่าสภาพแวดล้อมโหนดเริ่มต้นถูกตั้งค่าและพร้อมสำหรับการดำเนินการ เมื่อฟังก์ชันคลาวด์ถูกสร้างขึ้นโดยมี HTTP เป็นทริกเกอร์ฟังก์ชันนี้จะมี URL เพื่อเรียกใช้ฟังก์ชัน เมื่อเปรียบเทียบกับ AWS Lambda ซึ่งใช้เกตเวย์ API เป็นสื่อกลางในการสื่อสาร Google Cloud Functions จะให้ URL ตาม projectID ทันที และภูมิภาค

การสร้างแอปพลิเคชัน Serverless Node.js

ในการทำให้โค้ดของเราทำงานได้ใน GCF เราควรรวมโค้ดไว้ในฟังก์ชันเดียว GCF จะเรียกใช้ฟังก์ชันนั้นเมื่อใดก็ตามที่ทริกเกอร์เกิดขึ้น วิธีที่ทำได้คือการอัปโหลด

1. ไฟล์เดียว: ส่งออกฟังก์ชันเริ่มต้นที่จะเรียกใช้ฟังก์ชันอื่น ๆ ตามคำขอ

2. หลายไฟล์: มี index.js ไฟล์ที่ต้องการไฟล์อื่น ๆ ทั้งหมดและส่งออกฟังก์ชันเริ่มต้นเป็นจุดเริ่มต้น

3. หลายไฟล์: กำหนดค่าไฟล์หลักหนึ่งไฟล์ใน package.json ใช้ 'main': 'main.js' เป็นจุดเริ่มต้น

วิธีการใด ๆ ข้างต้นจะได้ผล

webpack รวม node_modules

GCF มีเวอร์ชัน Node runtime ที่รองรับ ตรวจสอบให้แน่ใจว่าเขียนโค้ดเพื่อรองรับเวอร์ชันนั้น ๆ ในขณะที่สร้างโพสต์นี้ GCF รองรับ Node เวอร์ชัน v6.11.1

ในการสร้างฟังก์ชันมีตัวเลือกที่ควรพิจารณาเล็กน้อย

1. หน่วยความจำ สิ่งนี้จะบอกว่าจำเป็นต้องใช้หน่วยความจำเท่าใดในการประมวลผลคำขอสำหรับการรันครั้งเดียว กำหนดเป็น MB. สำหรับแอปพลิเคชันขนาดเล็ก 128MB ควรเพียงพอ แต่สามารถเพิ่มได้ถึง 2GB

2. หมดเวลา การหมดเวลาตามชื่อหมายถึงการกำหนดระยะหมดเวลาการเรียกใช้โค้ดที่คาดไว้ หลังจากนี้รหัสจะถูกฆ่าและหยุดทำงาน การดำเนินการใด ๆ หลังจากจุดนี้จะหยุดลงทันที ระยะหมดเวลาสูงสุดคือ 540 วินาที

3. ฟังก์ชันในการดำเนินการ แม้ว่าจะสามารถส่งออกฟังก์ชันจากไฟล์ตัวจัดการหลักได้มากกว่าหนึ่งฟังก์ชัน แต่เราจำเป็นต้องกำหนดค่าหนึ่งฟังก์ชันที่ควรเรียกใช้เพื่อประมวลผลคำขอ สิ่งนี้ช่วยให้นักพัฒนามีจุดเข้าใช้งานหลายจุดตามวิธี HTTP / URL

ในการอัปโหลดโค้ดเพียงแค่คัดลอกวางโค้ดเพื่อสร้างพอร์ทัลฟังก์ชัน สำหรับไฟล์มากกว่าหนึ่งไฟล์ให้บีบอัดเนื้อหาและอัปโหลดไฟล์ ตรวจสอบให้แน่ใจว่าในกรณีของไฟล์ ZIP ควรมี index.js ไฟล์หรือ package.json ไฟล์ที่มีไฟล์หลักที่กล่าวถึง

ควรกล่าวถึงการพึ่งพาโมดูล NPM ใน package.json GCF พยายามติดตั้งโมดูลที่กล่าวถึงใน package.json ไฟล์ระหว่างการตั้งค่าครั้งแรก

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

exports.httpServer = function httpServer(req, res) { console.log(req); res.status(200).send('Server is working'); }

เมื่อสร้างฟังก์ชันแล้วให้เปิด URL ที่ให้ไว้เพื่อเรียกใช้ฟังก์ชัน ควรตอบสนองดังต่อไปนี้

ตอนนี้เรามาดู req วัตถุในบันทึก ในการดูบันทึก GCF มีตัวเลือกจากคอนโซลโดยตรง คลิกจุดแนวตั้งและเปิดตัวเลือกบันทึก

ตอนนี้เรามาอัปเดตโค้ดเพื่อจัดการเส้นทางง่ายๆสำหรับ /users

รหัสต่อไปนี้ใช้เพื่อจัดการกับ GET แบบธรรมดา & POST ขอ /users เส้นทาง:

exports.httpServer = function httpServer(req, res) { const path = req.path; switch(path) { case '/users': handleUsers(req, res); break; default: res.status(200).send('Server is working'); } }; const handleUsers = (req, res) => { if (req.method === 'GET') { res.status(200).send('Listing users...'); } else if (req.method === 'POST') { res.status(201).send('Creating User...') } else { res.status(404); } }

หลังจากอัปเดตแล้วมาทดสอบในเบราว์เซอร์กันเลย แต่คราวนี้เป็น /users ในตอนท้าย

เจ๋งมาก เราสร้างเซิร์ฟเวอร์ HTTP พื้นฐานพร้อมการกำหนดเส้นทาง

การดำเนินงานและการแก้จุดบกพร่อง

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

การปรับใช้:

โค้ดสำหรับฟังก์ชันสามารถปรับใช้งานได้สี่วิธี

• คัดลอกวางโค้ดในคอนโซล

• การอัปโหลดไฟล์ ZIP

• การปรับใช้จากที่เก็บข้อมูลระบบคลาวด์เป็นไฟล์ ZIP

• การปรับใช้จากที่เก็บซอร์สบนคลาวด์

ตัวเลือกที่สะดวกที่สุดคือการปรับใช้จากที่เก็บซอร์ส

การร้องขอ:

ในขณะที่สร้างฟังก์ชัน Console จะให้ HTTP URL เพื่อทริกเกอร์ฟังก์ชันซึ่งอยู่ในรูปแบบ: https://-.cloudfunctions.net/

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

การแก้จุดบกพร่อง:

GCF ผสานรวมกับบริการ Stackdriver Logging ใน Google Cloud บันทึกและข้อผิดพลาดของคอนโซลทั้งหมดจะถูกบันทึกไว้ที่นี่และจะช่วยแก้ปัญหาโค้ดที่ปรับใช้แล้ว

การทดสอบ:

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

ข้อ จำกัด และขั้นตอนต่อไป

การใช้ฟังก์ชั่นแบบไร้เซิร์ฟเวอร์นั้นมีข้อดีในตัวเองแถมยังมาพร้อมกับข้อ จำกัด อีกด้วย

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

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

  การวิเคราะห์การถดถอยในการประเมินอสังหาริมทรัพย์

Google Cloud Functions กำลังเติบโตและปรับปรุงอย่างมาก ยังคงได้รับการปรับปรุงและอัปเดตอยู่บ่อยครั้งโดยเฉพาะในภาษาที่รองรับได้ หากคุณกำลังวางแผนที่จะใช้ฟังก์ชัน Google Cloud โปรดติดตามการเปลี่ยนแปลงเพื่อหลีกเลี่ยงการเปลี่ยนแปลงที่ไม่สมบูรณ์ในการใช้งาน

ทำความเข้าใจพื้นฐาน

คอมพิวเตอร์ไร้เซิร์ฟเวอร์คืออะไร?

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

AWS Lambda และ Google Cloud Functions แตกต่างกันอย่างไร

AWS Lambda และ Google Cloud Functions (GCF) ต่างก็เป็นผู้ให้บริการคอมพิวเตอร์แบบไร้เซิร์ฟเวอร์ AWS Lambda ให้การสนับสนุนภาษาทริกเกอร์และเวลาดำเนินการสูงสุดที่น้อยลง ทำงานได้เหมือนกัน แต่ GCF นั้นง่ายกว่าในการติดตั้งและใช้งาน