การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

หากคุณกำลังอ่านบทความนี้ คุณอาจคุ้นเคยกับความเป็นไปได้ที่มาพร้อมกับการใช้ API (Application Programming Interface) แล้ว

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

คำตอบนั้นง่าย: คุณต้องการ สร้าง API ของคุณเอง.

แม้ว่านี่อาจดูเหมือนเป็นงานที่ยากในตอนแรก แต่จริงๆ แล้วเป็นเรื่องง่าย เราจะแสดงวิธีการทำเช่นนี้โดยใช้ Python

สิ่งที่คุณต้องเริ่มต้น

ในการพัฒนา API คุณต้องมี:

  • ไพธอน 3;
  • ขวด — กรอบงานที่เรียบง่ายและใช้งานง่ายสำหรับการสร้างเว็บแอปพลิเคชัน
  • กระติกน้ำ-พักผ่อน เป็นส่วนขยายสำหรับ Flask ที่ช่วยให้คุณพัฒนา REST API ได้อย่างรวดเร็วและมีการกำหนดค่าเพียงเล็กน้อย

การติดตั้งทำได้ด้วยคำสั่ง:

pip install flask-restful

เราขอแนะนำหลักสูตรการเขียนโปรแกรมแบบเร่งรัดฟรีสำหรับผู้เริ่มต้น:
การพัฒนาบอตโทรเลขใน C # — 26–28 สิงหาคม หลักสูตรเร่งรัดฟรีที่ช่วยให้คุณเข้าใจวิธีการทำงานของผู้ช่วยบอท ลักษณะเฉพาะของการทำงานกับ Telegram API และความแตกต่างอื่น ๆ ผู้เข้าร่วมที่ดีที่สุดสามคนจะได้รับ 30 รูเบิลจาก Skillbox.

ก่อนที่คุณจะเริ่ม

เราจะพัฒนา RESTful API ด้วยพื้นฐาน ฟังก์ชั่น CRUID.

เพื่อให้เข้าใจงานนี้อย่างถ่องแท้ มาทำความเข้าใจคำศัพท์สองคำที่กล่าวมาข้างต้นกัน

ส่วนที่เหลือคืออะไร?

REST API (Representational State Transfer) เป็น API ที่ใช้คำขอ HTTP เพื่อแลกเปลี่ยนข้อมูล

REST API ต้องเป็นไปตามเกณฑ์ที่กำหนด:

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

CRUD คืออะไร?

ครึด เป็นแนวคิดการเขียนโปรแกรมที่อธิบายการดำเนินการพื้นฐานสี่ประการ (สร้าง อ่าน อัปเดต และลบ)

ใน REST API ประเภทคำขอและวิธีการร้องขอมีหน้าที่รับผิดชอบในการดำเนินการ เช่น โพสต์ รับ วาง ลบ

ตอนนี้เราเข้าใจคำศัพท์พื้นฐานแล้ว เราก็เริ่มสร้าง API ได้เลย

ออกแบบ

มาสร้างคลังคำพูดเกี่ยวกับปัญญาประดิษฐ์กันดีกว่า AI เป็นหนึ่งในเทคโนโลยีที่เติบโตเร็วที่สุดในปัจจุบัน และ Python เป็นเครื่องมือยอดนิยมสำหรับการทำงานกับ AI

ด้วย API นี้ นักพัฒนา Python สามารถรับข้อมูลเกี่ยวกับ AI และรับแรงบันดาลใจจากความก้าวหน้าใหม่ๆ ได้อย่างรวดเร็ว หากนักพัฒนามีความคิดเห็นอันมีค่าเกี่ยวกับหัวข้อนี้ เขาจะสามารถเพิ่มความคิดเห็นเหล่านั้นลงในพื้นที่เก็บข้อมูลได้

เริ่มต้นด้วยการนำเข้าโมดูลที่จำเป็นและตั้งค่า Flask:

from flask import Flask
from flask_restful import Api, Resource, reqparse
import random
app = Flask(__name__)
api = Api(app)

ในตัวอย่างนี้ Flask, Api และ Resource คือคลาสที่เราต้องการ

Reqparse เป็นอินเทอร์เฟซการแยกวิเคราะห์แบบสอบถาม Flask-RESTful... คุณจะต้องใช้โมดูลสุ่มเพื่อแสดงเครื่องหมายคำพูดแบบสุ่ม

ตอนนี้เราจะสร้างคลังคำพูดเกี่ยวกับ AI

รายการซื้อคืนแต่ละรายการจะประกอบด้วย:

  • รหัสดิจิทัล
  • ชื่อผู้เขียนใบเสนอราคา
  • อ้าง.

เนื่องจากนี่เป็นเพียงตัวอย่างการฝึกอบรม เราจะจัดเก็บรายการทั้งหมดไว้ในรายการ Python ในแอปพลิเคชันจริง เราน่าจะใช้ฐานข้อมูลแทน

ai_quotes = [
    {
        "id": 0,
        "author": "Kevin Kelly",
        "quote": "The business plans of the next 10,000 startups are easy to forecast: " +
                 "Take X and add AI."
    },
    {
        "id": 1,
        "author": "Stephen Hawking",
        "quote": "The development of full artificial intelligence could " +
                 "spell the end of the human race… " +
                 "It would take off on its own, and re-design " +
                 "itself at an ever increasing rate. " +
                 "Humans, who are limited by slow biological evolution, " +
                 "couldn't compete, and would be superseded."
    },
    {
        "id": 2,
        "author": "Claude Shannon",
        "quote": "I visualize a time when we will be to robots what " +
                 "dogs are to humans, " +
                 "and I’m rooting for the machines."
    },
    {
        "id": 3,
        "author": "Elon Musk",
        "quote": "The pace of progress in artificial intelligence " +
                 "(I’m not referring to narrow AI) " +
                 "is incredibly fast. Unless you have direct " +
                 "exposure to groups like Deepmind, " +
                 "you have no idea how fast — it is growing " +
                 "at a pace close to exponential. " +
                 "The risk of something seriously dangerous " +
                 "happening is in the five-year timeframe." +
                 "10 years at most."
    },
    {
        "id": 4,
        "author": "Geoffrey Hinton",
        "quote": "I have always been convinced that the only way " +
                 "to get artificial intelligence to work " +
                 "is to do the computation in a way similar to the human brain. " +
                 "That is the goal I have been pursuing. We are making progress, " +
                 "though we still have lots to learn about " +
                 "how the brain actually works."
    },
    {
        "id": 5,
        "author": "Pedro Domingos",
        "quote": "People worry that computers will " +
                 "get too smart and take over the world, " +
                 "but the real problem is that they're too stupid " +
                 "and they've already taken over the world."
    },
    {
        "id": 6,
        "author": "Alan Turing",
        "quote": "It seems probable that once the machine thinking " +
                 "method had started, it would not take long " +
                 "to outstrip our feeble powers… " +
                 "They would be able to converse " +
                 "with each other to sharpen their wits. " +
                 "At some stage therefore, we should " +
                 "have to expect the machines to take control."
    },
    {
        "id": 7,
        "author": "Ray Kurzweil",
        "quote": "Artificial intelligence will reach " +
                 "human levels by around 2029. " +
                 "Follow that out further to, say, 2045, " +
                 "we will have multiplied the intelligence, " +
                 "the human biological machine intelligence " +
                 "of our civilization a billion-fold."
    },
    {
        "id": 8,
        "author": "Sebastian Thrun",
        "quote": "Nobody phrases it this way, but I think " +
                 "that artificial intelligence " +
                 "is almost a humanities discipline. It's really an attempt " +
                 "to understand human intelligence and human cognition."
    },
    {
        "id": 9,
        "author": "Andrew Ng",
        "quote": "We're making this analogy that AI is the new electricity." +
                 "Electricity transformed industries: agriculture, " +
                 "transportation, communication, manufacturing."
    }
]

ตอนนี้เราจำเป็นต้องสร้างคลาสทรัพยากรใบเสนอราคาที่จะกำหนดการดำเนินงานของจุดสิ้นสุด API ของเรา ภายในชั้นเรียน คุณจะต้องประกาศสี่วิธี: รับ, โพสต์, ใส่, ลบ

เริ่มจากวิธี GET กันก่อน

ทำให้สามารถรับใบเสนอราคาเฉพาะได้โดยการระบุ ID หรือใบเสนอราคาแบบสุ่มหากไม่ได้ระบุ ID

class Quote(Resource):
    def get(self, id=0):
        if id == 0:
            return random.choice(ai_quotes), 200
        for quote in ai_quotes:
            if(quote["id"] == id):
                return quote, 200
        return "Quote not found", 404

วิธีการ GET ส่งกลับเครื่องหมายคำพูดแบบสุ่มหาก ID มีค่าเริ่มต้น เช่น ไม่มีการระบุ ID เมื่อเรียกใช้เมธอด

หากมีการระบุ วิธีการจะค้นหาข้อมูลอ้างอิงและค้นหาข้อมูลที่มี ID ที่ระบุ หากไม่พบสิ่งใดเลย ข้อความ “ไม่พบใบเสนอราคา 404” จะปรากฏขึ้น

ข้อควรจำ: วิธีการนี้จะส่งคืนสถานะ HTTP เป็น 200 หากคำขอสำเร็จ และ 404 หากไม่พบบันทึก

ตอนนี้เรามาสร้างวิธี POST เพื่อเพิ่มใบเสนอราคาใหม่ลงในพื้นที่เก็บข้อมูล

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

def post(self, id):
      parser = reqparse.RequestParser()
      parser.add_argument("author")
      parser.add_argument("quote")
      params = parser.parse_args()
      for quote in ai_quotes:
          if(id == quote["id"]):
              return f"Quote with id {id} already exists", 400
      quote = {
          "id": int(id),
          "author": params["author"],
          "quote": params["quote"]
      }
      ai_quotes.append(quote)
      return quote, 201

ในโค้ดด้านบน วิธี POST ยอมรับ ID ใบเสนอราคา จากนั้น เมื่อใช้ reqparse ระบบจะดึงข้อมูลผู้เขียนและการอ้างอิงจากแบบสอบถาม และจัดเก็บไว้ในพจนานุกรม Params

หากมีใบเสนอราคาที่มี ID ที่ระบุอยู่แล้ว วิธีการจะแสดงข้อความและรหัสที่เกี่ยวข้อง 400

หากยังไม่ได้สร้างการอ้างอิงด้วย ID ที่ระบุ วิธีการจะสร้างบันทึกใหม่ด้วย ID และผู้แต่งที่ระบุ เช่นเดียวกับพารามิเตอร์อื่น ๆ จากนั้นจะเพิ่มรายการลงในรายการ ai_quotes และส่งคืนรายการพร้อมใบเสนอราคาใหม่พร้อมกับรหัส 201

ตอนนี้เราสร้างวิธี PUT เพื่อเปลี่ยนใบเสนอราคาที่มีอยู่ในที่เก็บ

def put(self, id):
      parser = reqparse.RequestParser()
      parser.add_argument("author")
      parser.add_argument("quote")
      params = parser.parse_args()
      for quote in ai_quotes:
          if(id == quote["id"]):
              quote["author"] = params["author"]
              quote["quote"] = params["quote"]
              return quote, 200
      
      quote = {
          "id": id,
          "author": params["author"],
          "quote": params["quote"]
      }
      
      ai_quotes.append(quote)
      return quote, 201

วิธีการ PUT คล้ายกับตัวอย่างก่อนหน้านี้ ใช้ ID และอินพุต และแยกวิเคราะห์พารามิเตอร์เครื่องหมายคำพูดโดยใช้ reqparse

หากมีการอ้างอิงด้วย ID ที่ระบุ วิธีการจะอัปเดตด้วยพารามิเตอร์ใหม่ จากนั้นส่งออกการอ้างอิงที่อัปเดตด้วยรหัส 200 หากยังไม่มีการอ้างอิงด้วย ID ที่ระบุ จะมีการสร้างบันทึกใหม่ด้วยรหัส 201

สุดท้ายนี้ เรามาสร้างวิธี DELETE เพื่อลบคำพูดที่ไม่สร้างแรงบันดาลใจอีกต่อไป

def delete(self, id):
      global ai_quotes
      ai_quotes = [qoute for qoute in ai_quotes if qoute["id"] != id]
      return f"Quote with id {id} is deleted.", 200

เมธอดนี้รับ ID ใบเสนอราคาเป็นอินพุตและอัปเดตรายการ ai_quotes โดยใช้รายการที่แชร์

ตอนนี้เราได้สร้างวิธีการทั้งหมดแล้ว สิ่งที่เราต้องทำคือเพียงเพิ่มทรัพยากรลงใน API กำหนดเส้นทาง และเรียกใช้ Flask

api.add_resource(Quote, "/ai-quotes", "/ai-quotes/", "/ai-quotes/<int:id>")
if __name__ == '__main__':
    app.run(debug=True)

บริการ REST API ของเราพร้อมแล้ว!

ต่อไป เราสามารถบันทึกโค้ดลงในไฟล์ app.py ได้โดยการรันโค้ดในคอนโซลโดยใช้คำสั่ง:

python3 app.py

หากทุกอย่างดีเราจะได้สิ่งนี้:

* โหมดแก้ไขข้อบกพร่อง: เปิด
* วิ่งต่อไป 127.0.0.1:5000/ (กด CTRL+C เพื่อออก)
* เริ่มต้นด้วยสถานะ
* ดีบักเกอร์เปิดใช้งานอยู่!
* PIN ดีบักเกอร์: XXXXXXX

การทดสอบ API

เมื่อสร้าง API แล้ว จะต้องมีการทดสอบ

ซึ่งสามารถทำได้โดยใช้ยูทิลิตี้คอนโซล curl หรือไคลเอนต์ Insomnia REST หรือโดยการเผยแพร่ API บน Rapid API

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

การเผยแพร่ API ของเรา

RapidAPI เป็นตลาดกลางที่ใหญ่ที่สุดในโลกซึ่งมี API มากกว่า 10 รายการ (และนักพัฒนาประมาณ 000 ล้านคน)

RapidAPI ไม่เพียงแต่มีอินเทอร์เฟซเดียวสำหรับการทำงานกับ API ของบริษัทอื่น แต่ยังช่วยให้คุณสามารถเผยแพร่ API ของคุณเองได้อย่างรวดเร็วและง่ายดายอีกด้วย

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

วิธีเผยแพร่ API ของคุณบน Heroku

1. ติดตั้ง Heroku

ขั้นตอนแรกคือการลงทะเบียนและติดตั้ง Heroku Command Line Interface (CLI) สิ่งนี้ใช้ได้กับ Ubuntu 16+

sudo snap ติดตั้ง heroku —classic

จากนั้นเข้าสู่ระบบ:

heroku เข้าสู่ระบบ

2. เพิ่มไฟล์ที่จำเป็น

ตอนนี้เราต้องเพิ่มไฟล์ที่จะเผยแพร่ไปยังโฟลเดอร์ในแอปพลิเคชันของเรา:

  • Requirement.txt พร้อมรายการโมดูล Python ที่จำเป็น
  • Procfile ซึ่งระบุว่าคำสั่งใดที่ต้องดำเนินการเพื่อรันแอปพลิเคชัน
  • .gitignore - เพื่อแยกไฟล์ที่ไม่จำเป็นบนเซิร์ฟเวอร์

ไฟล์ Requirements.txt จะมีบรรทัดต่อไปนี้:

  • ขวด
  • ขวดพักผ่อน
  • ยูนิคอร์น

โปรดทราบว่าเราได้เพิ่ม gunicorn (Python WSGI HTTP Server) ลงในรายการเนื่องจากเราจำเป็นต้องเรียกใช้แอปพลิเคชันของเราบนเซิร์ฟเวอร์

Procfile จะประกอบด้วย:

เว็บ: gunicorn app:app

เนื้อหาของ .gitignore:

*.pyc
__pycache__/

ตอนนี้ไฟล์ถูกสร้างขึ้นแล้ว มาเริ่มต้น repo git และคอมมิต:

git init
git add
git commit -m "First API commit"

3. สร้างแอปพลิเคชัน Heroku ใหม่

heroku create

เราผลักสาขาหลักไปที่ repo Heroku ระยะไกล:

git push heroku master

ตอนนี้คุณสามารถเริ่มต้นได้โดยการเปิดบริการ API โดยใช้คำสั่ง:

heroku ps:scale web=1
heroku open
 

API จะมีให้บริการที่ your-random-heroku-name.herokuapp.com/ai-quotes.

วิธีเพิ่ม Python API ของคุณไปยังตลาด RapidAPI

เมื่อบริการ API ของคุณเผยแพร่บน Heroku แล้ว คุณจะเพิ่มบริการดังกล่าวลงใน Rapid API ได้ ที่นี่ เอกสารรายละเอียด ในหัวข้อนี้

1. สร้างบัญชี RapidAPI

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

ลงทะเบียนบัญชีฟรี - สามารถทำได้โดยใช้ Facebook, Google, GitHub

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

2. เพิ่ม API ลงในแผงควบคุม

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

3. จากนั้น ป้อนข้อมูลทั่วไปเกี่ยวกับ API ของคุณ

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

4. หลังจากคลิก "เพิ่ม API" หน้าใหม่จะปรากฏขึ้นเพื่อให้คุณป้อนข้อมูลเกี่ยวกับ API ของเราได้

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

5. ตอนนี้คุณสามารถป้อนตำแหน่งข้อมูล API หรือดาวน์โหลดด้วยตนเองได้ ไฟล์ผยอง โดยใช้ OpenAPI

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

ตอนนี้เราต้องตั้งค่าจุดสิ้นสุดของ API ของเราในหน้าจุดสิ้นสุด ในกรณีของเรา จุดสิ้นสุดสอดคล้องกับแนวคิดของ CRUD (รับ โพสต์ วาง ลบ)

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

ถัดไป คุณต้องสร้างตำแหน่งข้อมูลใบเสนอราคา GET AI ที่แสดงใบเสนอราคาแบบสุ่ม (หาก ID เป็นค่าเริ่มต้น) หรือใบเสนอราคาสำหรับ ID ที่ระบุ

หากต้องการสร้างจุดสิ้นสุด ให้คลิกปุ่ม "สร้างจุดสิ้นสุด"

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

เราทำซ้ำขั้นตอนนี้กับตำแหน่งข้อมูล API อื่นๆ ทั้งหมด นั่นคือทั้งหมด! ยินดีด้วย คุณได้เผยแพร่ API ของคุณแล้ว!

หากทุกอย่างเรียบร้อยดี หน้า API จะมีลักษณะดังนี้:

การเขียน API ใน Python (ด้วย Flask และ RapidAPI)

ข้อสรุป

ในบทความนี้ เราได้เรียนรู้กระบวนการสร้างบริการ RESTful API ของคุณเองใน Python พร้อมกับกระบวนการเผยแพร่ API ไปยังคลาวด์ Heroku และเพิ่มลงในไดเรกทอรี RapidAPI

แต่เวอร์ชันทดสอบแสดงเฉพาะหลักการพื้นฐานของการพัฒนา API เท่านั้น โดยไม่ได้คำนึงถึงความแตกต่าง เช่น ความปลอดภัย ความทนทานต่อข้อผิดพลาด และความสามารถในการปรับขนาด

เมื่อพัฒนา API จริง ทั้งหมดนี้จะต้องนำมาพิจารณาด้วย

ที่มา: will.com

เพิ่มความคิดเห็น