การตั้งค่า API โดยใช้ Flask, Cloud SQL และ App Engine ของ Google

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

จังโก้

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

กระติกน้ำ

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

เพื่อจุดประสงค์ในการเรียนรู้ เราจะสร้าง Flask API ที่มีจุดสิ้นสุดสองสามจุดเพื่อจัดการคอลเลคชันเพลงโปรดของเรา ปลายทางจะเป็นสำหรับคำขอ GET และ POST : การดึงและสร้างทรัพยากร นอกจากนั้น เราจะใช้ชุดบริการบนแพลตฟอร์ม Google Cloud เราจะตั้งค่า Cloud SQL ของ Google สำหรับฐานข้อมูลของเรา และเปิดแอปของเราโดยปรับใช้กับ App Engine บทแนะนำนี้มีจุดมุ่งหมายเพื่อผู้เริ่มต้นใช้งาน Google Cloud สำหรับแอปของตนเป็นครั้งแรก

ตั้งโครงการขวด

บทช่วยสอนนี้ถือว่าคุณได้ติดตั้ง Python 3.x แล้ว หากคุณไม่ดาวน์โหลด ให้ไปที่เว็บไซต์ทางการเพื่อดาวน์โหลดและติดตั้ง

ในการตรวจสอบว่ามีการติดตั้ง Python หรือไม่ ให้เปิด command-line interface (CLI) ของคุณและเรียกใช้คำสั่งด้านล่าง:

 python -V

ขั้นตอนแรกของเราคือการสร้างไดเร็กทอรีที่โครงการของเราจะอาศัยอยู่ เราจะเรียกมันว่า flask-app :

 mkdir flask-app && cd flask-app

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

มาสร้างสภาพแวดล้อมเสมือนจริงในไดเร็กทอรี flask-app ของเรา:

 python3 -m venv env

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

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

 source env/bin/activate

คุณจะเห็นว่าข้อความแจ้ง CLI ของคุณมี env ที่จุดเริ่มต้น ซึ่งบ่งชี้ว่าสภาพแวดล้อมของเราทำงานอยู่

ตอนนี้ มาติดตั้งแพ็คเกจ Flask ของเรา:

 pip install flask

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

 mkdir api && cd api

ถัดไป สร้างไฟล์ main.py ซึ่งจะทำหน้าที่เป็นจุดเริ่มต้นของแอปของเรา:

 touch main.py

เปิด main.py และป้อนรหัสต่อไปนี้:

 #main.py from flask import Flask app = Flask(__name__) @app.route('/') def home(): return 'Hello World' if __name__ == '__main__': app.run()

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

มาเรียกใช้แอพกันเถอะ:

 python main.py

สิ่งนี้เริ่มต้นเซิร์ฟเวอร์ในพื้นที่ของเราและให้บริการแอพของเราใน https://127.0.0.1:5000/ ป้อน URL ในเบราว์เซอร์ของคุณ แล้วคุณจะเห็นการตอบสนองของ Hello World พิมพ์อยู่บนหน้าจอของคุณ

แล้วโว้ย! แอพของเราเปิดใช้งานแล้ว งานต่อไปคือการทำให้มันใช้งานได้

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

มาทำให้ main.py ส่งคืนข้อมูลกัน:

 #main.py from flask import Flask, jsonify app = Flask(__name__) songs = [ { "title": "Rockstar", "artist": "Dababy", "genre": "rap", }, { "title": "Say So", "artist": "Doja Cat", "genre": "Hiphop", }, { "title": "Panini", "artist": "Lil Nas X", "genre": "Hiphop" } ] @app.route('/songs') def home(): return jsonify(songs) if __name__ == '__main__': app.run()

ในที่นี้ เรารวมรายชื่อเพลง รวมทั้งชื่อเพลงและชื่อศิลปินไว้ด้วย จากนั้นเราก็เปลี่ยน root / route เป็น /songs เส้นทางนี้ส่งคืนอาร์เรย์ของเพลงที่เราระบุ เพื่อให้ได้รายการของเราเป็นค่า JSON เรา JSONified รายการโดยส่งผ่าน jsonify ตอนนี้ แทนที่จะเห็น Hello world ธรรมดาๆ เราเห็นรายชื่อศิลปินเมื่อเราเข้าถึง https://127.0.0.1:5000/songs endpoint

คุณอาจสังเกตเห็นว่าหลังจากการเปลี่ยนแปลงทุกครั้ง เราต้องรีสตาร์ทเซิร์ฟเวอร์ของเรา หากต้องการเปิดใช้งานการโหลดซ้ำอัตโนมัติเมื่อโค้ดมีการเปลี่ยนแปลง ให้เปิดใช้งานตัวเลือกการดีบัก ในการดำเนินการนี้ ให้เปลี่ยน app.run เป็น:

 app.run(debug=True)

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

 #main.py from flask import Flask, jsonify, request app = Flask(__name__) songs = [ { "title": "Rockstar", "artist": "Dababy", "genre": "rap", }, { "title": "Say So", "artist": "Doja Cat", "genre": "Hiphop", }, { "title": "Panini", "artist": "Lil Nas X", "genre": "Hiphop" } ] @app.route('/songs') def home(): return jsonify(songs) @app.route('/songs', methods=['POST']) def add_songs(): song = request.get_json() songs.append(song) return jsonify(songs) if __name__ == '__main__': app.run(debug=True)

ฟังก์ชันการดู add_songs ของเรานำเพลงที่ผู้ใช้ส่งมาและผนวกเข้ากับรายการเพลงที่มีอยู่ของเรา

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

เหตุใดจึงต้องใช้อินสแตนซ์ Cloud SQL

ตามเว็บไซต์อย่างเป็นทางการ:

“Google Cloud SQL เป็นบริการฐานข้อมูลที่มีการจัดการเต็มรูปแบบ ซึ่งทำให้ง่ายต่อการติดตั้ง บำรุงรักษา จัดการ และดูแลฐานข้อมูล MySQL เชิงสัมพันธ์และ PostgreSQL ในระบบคลาวด์ Cloud SQL ที่โฮสต์บน Google Cloud Platform มีโครงสร้างพื้นฐานฐานข้อมูลสำหรับแอปพลิเคชันที่ทำงานได้ทุกที่”

ซึ่งหมายความว่าเราสามารถเอาต์ซอร์สการจัดการโครงสร้างพื้นฐานของฐานข้อมูลทั้งหมดให้กับ Google ด้วยราคาที่ยืดหยุ่น

ความแตกต่างระหว่าง Cloud SQL และ Compute Engine ที่จัดการด้วยตนเอง

ใน Google Cloud เราสามารถเปิดเครื่องเสมือนบนโครงสร้างพื้นฐาน Compute Engine ของ Google และติดตั้งอินสแตนซ์ SQL ของเราได้ ซึ่งหมายความว่าเราจะรับผิดชอบสำหรับความสามารถในการปรับขนาดตามแนวตั้ง การจำลองแบบ และโฮสต์ของการกำหนดค่าอื่นๆ ด้วย Cloud SQL เราได้รับการกำหนดค่ามากมายตั้งแต่เริ่มต้น ดังนั้นเราจึงใช้เวลากับโค้ดได้มากขึ้นและใช้เวลาตั้งค่าน้อยลง

ก่อนที่เราจะเริ่ม:

1. ลงชื่อสมัครใช้ Google Cloud Google ให้เครดิตฟรี $300 แก่ผู้ใช้ใหม่
2. สร้างโครงการ ซึ่งค่อนข้างตรงไปตรงมาและสามารถทำได้จากคอนโซลโดยตรง

สร้างอินสแตนซ์ Cloud SQL

หลังจากลงชื่อสมัครใช้ Google Cloud ในแผงด้านซ้าย ให้เลื่อนไปที่แท็บ "SQL" แล้วคลิกบนแท็บนั้น

อันดับแรก เราต้องเลือกเอ็นจิ้น SQL เราจะใช้ MySQL สำหรับบทความนี้

ต่อไป เราจะสร้างอินสแตนซ์ โดยค่าเริ่มต้น อินสแตนซ์ของเราจะถูกสร้างขึ้นในสหรัฐอเมริกา และโซนจะถูกเลือกให้เราโดยอัตโนมัติ

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

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

ตอนนี้ เรากำลังดำเนินการอยู่ เราจะทำบางสิ่ง:

1. สร้างฐานข้อมูล
2. สร้างผู้ใช้ใหม่
3. ไวท์ลิสต์ที่อยู่ IP ของเรา

สร้างฐานข้อมูล

ไปที่แท็บ "ฐานข้อมูล" เพื่อสร้างฐานข้อมูล

สร้างผู้ใช้ใหม่

ในส่วน "ชื่อโฮสต์" ให้ตั้งค่าเป็น "% (โฮสต์ใดก็ได้)"

ที่อยู่ IP ที่อนุญาตพิเศษ

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

หากต้องการอนุญาตที่อยู่ IP ของคุณ ให้พิมพ์ my ip ในการค้นหาของ Google เพื่อรับ IP ของคุณ จากนั้นไปที่แท็บ "การเชื่อมต่อ" และ "เพิ่มเครือข่าย"

เชื่อมต่อกับอินสแตนซ์

จากนั้นไปที่แผง "ภาพรวม" และเชื่อมต่อโดยใช้คลาวด์เชลล์

คำสั่งเพื่อเชื่อมต่อกับอินสแตนซ์ Cloud SQL ของเราจะถูกพิมพ์ล่วงหน้าในคอนโซล

คุณสามารถใช้ทั้งผู้ใช้รูทหรือผู้ใช้ที่สร้างขึ้นก่อนหน้านี้ ในคำสั่งด้านล่าง เรากำลังพูดว่า: เชื่อมต่อกับอินสแตนซ์ flask-demo ในฐานะผู้ใช้ USERNAME คุณจะได้รับแจ้งให้ป้อนรหัสผ่านของผู้ใช้

 gcloud sql connect flask-demo --user=USERNAME

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

 gcloud projects list

นำรหัสโครงการที่ส่งออกจากคำสั่งด้านบน และป้อนลงในคำสั่งด้านล่าง โดยแทนที่ PROJECT_ID ด้วย

 gcloud config set project PROJECT_ID

จากนั้นรันคำสั่ง gcloud sql connect และเราจะเชื่อมต่อกัน

เรียกใช้คำสั่งนี้เพื่อดูฐานข้อมูลที่ใช้งานอยู่:

 > show databases; 

ฐานข้อมูลของฉันชื่อ db_demo และฉันจะเรียกใช้คำสั่งด้านล่างเพื่อใช้ฐานข้อมูล db_demo คุณอาจเห็นฐานข้อมูลอื่นๆ เช่น information_schema และ performance_schema สิ่งเหล่านี้มีไว้เพื่อเก็บข้อมูลเมตาของตาราง

 > use db_demo;

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

 create table songs( song_id INT NOT NULL AUTO_INCREMENT, title VARCHAR(255), artist VARCHAR(255), genre VARCHAR(255), PRIMARY KEY(song_id) );

รหัสนี้เป็นคำสั่ง SQL ที่สร้างตารางชื่อ songs โดยมีสี่คอลัมน์ ( song_id , title , artist และ genre ) เรายังได้แนะนำว่าตารางควรกำหนด song_id เป็นคีย์หลักและเพิ่มขึ้นจาก 1 โดยอัตโนมัติ

ตอนนี้ เรียกใช้ show tables; เพื่อยืนยันว่าสร้างตารางแล้ว

และเช่นเดียวกัน เราได้สร้างฐานข้อมูลและตาราง songs ของเรา

งานต่อไปของเราคือการตั้งค่า Google App Engine เพื่อให้เราสามารถปรับใช้แอปของเราได้

Google App Engine

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

เว็บไซต์ App Engine กล่าวว่า:

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

ตั้งค่า App Engine

มีสองสามวิธีในการตั้งค่า App Engine: ผ่าน UI ของ Google Cloud Console หรือผ่าน Google Cloud SDK เราจะใช้ SDK สำหรับส่วนนี้ ช่วยให้เราสามารถปรับใช้ จัดการ และตรวจสอบอินสแตนซ์ Google Cloud จากเครื่องในพื้นที่ของเรา

ติดตั้ง Google Cloud SDK

ทำตามคำแนะนำเพื่อดาวน์โหลดและติดตั้ง SDK สำหรับ Mac หรือ Windows คู่มือนี้จะแสดงวิธีเริ่มต้น SDK ใน CLI ของคุณและวิธีเลือกโครงการ Google Cloud

เมื่อติดตั้ง SDK แล้ว เราจะไปอัปเดตสคริปต์ Python ด้วยข้อมูลรับรองของฐานข้อมูลและปรับใช้กับ App Engine

การตั้งค่าท้องถิ่น

ในสภาพแวดล้อมในพื้นที่ของเรา เราจะอัปเดตการตั้งค่าเพื่อให้เหมาะกับสถาปัตยกรรมใหม่ของเรา ซึ่งรวมถึง Cloud SQL และ App Engine

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

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

 #app.yaml runtime: python37 env_variables: CLOUD_SQL_USERNAME: YOUR-DB-USERNAME CLOUD_SQL_PASSWORD: YOUR-DB-PASSWORD CLOUD_SQL_DATABASE_NAME: YOUR-DB-NAME CLOUD_SQL_CONNECTION_NAME: YOUR-CONN-NAME

ตอนนี้เรากำลังจะติดตั้ง PyMySQL นี่คือแพ็คเกจ Python MySQL ที่เชื่อมต่อและดำเนินการค้นหาบนฐานข้อมูล MySQL ติดตั้งแพ็คเกจ PyMySQL โดยเรียกใช้บรรทัดนี้ใน CLI ของคุณ:

 pip install pymysql

ณ จุดนี้ เราพร้อมที่จะใช้ PyMySQL เพื่อเชื่อมต่อกับฐานข้อมูล Cloud SQL ของเราจากแอป ซึ่งจะช่วยให้เรารับและแทรกข้อความค้นหาในฐานข้อมูลของเราได้

เริ่มต้นตัวเชื่อมต่อฐานข้อมูล

ขั้นแรก สร้างไฟล์ db.py ในโฟลเดอร์รูทของเรา และเพิ่มโค้ดด้านล่าง:

 #db.py import os import pymysql from flask import jsonify db_user = os.environ.get('CLOUD_SQL_USERNAME') db_password = os.environ.get('CLOUD_SQL_PASSWORD') db_name = os.environ.get('CLOUD_SQL_DATABASE_NAME') db_connection_name = os.environ.get('CLOUD_SQL_CONNECTION_NAME') def open_connection(): unix_socket = '/cloudsql/{}'.format(db_connection_name) try: if os.environ.get('GAE_ENV') == 'standard': conn = pymysql.connect(user=db_user, password=db_password, unix_socket=unix_socket, db=db_name, cursorclass=pymysql.cursors.DictCursor ) except pymysql.MySQLError as e: print(e) return conn def get_songs(): conn = open_connection() with conn.cursor() as cursor: result = cursor.execute('SELECT * FROM songs;') songs = cursor.fetchall() if result > 0: got_songs = jsonify(songs) else: got_songs = 'No Songs in DB' conn.close() return got_songs def add_songs(song): conn = open_connection() with conn.cursor() as cursor: cursor.execute('INSERT INTO songs (title, artist, genre) VALUES(%s, %s, %s)', (song["title"], song["artist"], song["genre"])) conn.commit() conn.close()

เราทำบางสิ่งที่นี่

ขั้นแรก เราดึงข้อมูลรับรองฐานข้อมูลของเราจากไฟล์ app.yaml โดยใช้วิธี os.environ.get App Engine สามารถสร้างตัวแปรสภาพแวดล้อมที่กำหนดไว้ใน app.yaml ได้ในแอป

ประการที่สอง เราได้สร้างฟังก์ชัน open_connection มันเชื่อมต่อกับฐานข้อมูล MySQL ของเราด้วยข้อมูลประจำตัว

ประการที่สาม เราได้เพิ่มสองฟังก์ชัน: get_songs และ add_songs ขั้นแรกเริ่มการเชื่อมต่อกับฐานข้อมูลโดยการเรียกฟังก์ชัน open_connection จากนั้นจะค้นหาตาราง songs สำหรับทุกแถว และหากว่างเปล่า จะส่งกลับ "No Songs in DB" ฟังก์ชัน add_songs แทรกบันทึกใหม่ลงในตาราง songs

สุดท้าย เรากลับไปที่จุดเริ่มต้น ไฟล์ main.py ของเรา ตอนนี้ แทนที่จะรับเพลงของเราจากวัตถุ ดังที่เราทำก่อนหน้านี้ เราเรียกฟังก์ชัน add_songs เพื่อแทรกบันทึก และเราเรียกฟังก์ชัน get_songs เพื่อดึงบันทึกจากฐานข้อมูล

มาทำการ refactor main.py :

 #main.py from flask import Flask, jsonify, request from db import get_songs, add_songs app = Flask(__name__) @app.route('/', methods=['POST', 'GET']) def songs(): if request.method == 'POST': if not request.is_json: return jsonify({"msg": "Missing JSON in request"}), 400 add_songs(request.get_json()) return 'Song Added' return get_songs() if __name__ == '__main__': app.run()

เรานำเข้าฟังก์ชัน get_songs และ add_songs และเรียกฟังก์ชันเหล่านี้ในฟังก์ชันการดู songs() ของเรา หากเราส่งคำขอ post เราจะเรียกฟังก์ชัน add_songs และหากเราส่งคำขอ เรา get เรียกฟังก์ชัน get_songs

และแอพของเราก็เสร็จแล้ว

ถัดไปคือการเพิ่มไฟล์ requirements.txt ไฟล์นี้มีรายการแพ็คเกจที่จำเป็นในการรันแอพ App Engine ตรวจสอบไฟล์นี้และติดตั้งแพ็คเกจในรายการ

 pip freeze | grep "Flask\|PyMySQL" > requirements.txt

บรรทัดนี้รับสองแพ็คเกจที่เราใช้สำหรับแอพ (Flask และ PyMySQL) สร้างไฟล์ requirements.txt และต่อท้ายแพ็คเกจและเวอร์ชันของไฟล์เหล่านั้น

ณ จุดนี้ เราได้เพิ่มไฟล์ใหม่สามไฟล์: db.py , app.yaml และ requirements.txt

ปรับใช้กับ Google App Engine

เรียกใช้คำสั่งต่อไปนี้เพื่อปรับใช้แอปของคุณ:

 gcloud app deploy

หากเป็นไปด้วยดี คอนโซลของคุณจะแสดงผลดังนี้:

แอปของคุณกำลังทำงานบน App Engine หากต้องการดูในเบราว์เซอร์ ให้เรียกใช้ gcloud app browse ใน CLI ของคุณ

เราสามารถเปิดใช้บุรุษไปรษณีย์เพื่อทดสอบ post และ get คำขอได้

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

บทสรุป

การใช้โครงสร้างพื้นฐานแบบ platform-as-a-service (PaaS) เช่น App Engine และ Cloud SQL โดยพื้นฐานแล้วจะแยกระดับโครงสร้างพื้นฐานออกไป และช่วยให้เราสร้างได้เร็วยิ่งขึ้น ในฐานะนักพัฒนา เราไม่ต้องกังวลเกี่ยวกับการกำหนดค่า การสำรองและการกู้คืน ระบบปฏิบัติการ การปรับขนาดอัตโนมัติ ไฟร์วอลล์ การย้ายข้อมูลการรับส่งข้อมูล และอื่นๆ อย่างไรก็ตาม หากคุณต้องการควบคุมการกำหนดค่าพื้นฐาน การใช้บริการที่สร้างขึ้นเองอาจเป็นการดีกว่า

อ้างอิง

• “ดาวน์โหลดไพทอน”
• “venv — การสร้างสภาพแวดล้อมเสมือนจริง”, Python (เอกสารประกอบ)
• “ดาวน์โหลดบุรุษไปรษณีย์”
• “คลาวด์ SQL”, Google Cloud
• Google Cloud
• “Google Cloud Free Tier”, Google Cloud
• “การสร้างและจัดการโครงการ”, Google Cloud
• “ภาพรวม VPC” (คลาวด์ส่วนตัวเสมือน), Google Cloud
• “App Engine”, Google Cloud
• “การเริ่มต้นอย่างรวดเร็ว” (ดาวน์โหลด Google Cloud SDK), Google Cloud
• เอกสาร PyMySQL