วิธีใช้ FastAPI เพื่อสร้างและจัดการคำขอ POST

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

FastAPI คืออะไร

FastAPI เป็นเฟรมเวิร์กเว็บที่ทันสมัย รวดเร็ว (มีประสิทธิภาพสูง) สำหรับการสร้าง API ด้วย Python 3.7+ โดยอิงตามคำแนะนำประเภท Python มาตรฐาน ได้รับการออกแบบมาให้ใช้งานง่ายและให้ประสิทธิภาพสูงเทียบเท่ากับ Node.js และ Go เฟรมเวิร์กนี้ยังใช้งานง่ายและตรงไปตรงมา ทำให้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับทั้งผู้เริ่มต้นและผู้เชี่ยวชาญ

ทำไมต้องใช้ FastAPI

มีหลายเหตุผลที่นักพัฒนากำลังเลือก FastAPI มากกว่าเฟรมเวิร์กอื่นๆ:

1. ความเร็ว: FastAPI นั้นรวดเร็ว อันที่จริง มันเป็นหนึ่งในเฟรมเวิร์กเว็บที่เร็วที่สุดในปัจจุบัน
2. ใช้งานง่าย: ด้วยเอกสารประกอบแบบโต้ตอบอัตโนมัติ (ต้องขอบคุณ Swagger UI และ ReDoc) ทำให้ง่ายต่อการทดสอบ API ของคุณอย่างเหลือเชื่อ
3. การตรวจสอบความถูกต้องของข้อมูล: FastAPI ใช้ประโยชน์จาก Pydantic สำหรับการตรวจสอบความถูกต้องของข้อมูล ซึ่งช่วยให้มั่นใจได้ว่าข้อมูลที่ API ของคุณได้รับนั้นถูกต้อง
4. พร้อมใช้งานแบบอะซิงโครนัส: รองรับการเขียนโปรแกรมแบบอะซิงโครนัสทันที ทำให้เหมาะสำหรับแอปพลิเคชันเว็บสมัยใหม่ที่มีประสิทธิภาพสูง

การตั้งค่า FastAPI

ก่อนที่เราจะเจาะลึกคำขอ POST มาตั้งค่า FastAPI อย่างรวดเร็ว คุณจะต้องติดตั้ง Python บนระบบของคุณ จากนั้น คุณสามารถติดตั้ง FastAPI และเซิร์ฟเวอร์ ASGI เช่น Uvicorn โดยใช้ pip:

pip install fastapi uvicorn

เมื่อคุณติดตั้ง FastAPI แล้ว คุณสามารถสร้างแอปพลิเคชัน FastAPI อย่างง่ายได้ มาเริ่มต้นด้วยการสร้างไฟล์ชื่อ main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

ในการเรียกใช้แอปพลิเคชัน ให้ใช้ Uvicorn:

uvicorn main:app --reload

เปิดเบราว์เซอร์ของคุณและไปที่ http://127.0.0.1:8000 คุณควรเห็นการตอบสนอง JSON: {"Hello": "World"}

การสร้าง POST Endpoint

ตอนนี้เรามีแอป FastAPI พื้นฐานที่ทำงานอยู่แล้ว มาเพิ่ม POST endpoint กัน คำขอ POST ใช้เพื่อส่งข้อมูลที่จะประมวลผลไปยังทรัพยากรที่ระบุ ในการจัดการคำขอ POST ใน FastAPI คุณใช้ตัวตกแต่ง @app.post

นี่คือตัวอย่างง่ายๆ ของวิธีการจัดการคำขอ POST:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

@app.post("/items/")
def create_item(item: Item):
    return item

ในตัวอย่างนี้:

1. เรากำหนดอินสแตนซ์ FastAPI
2. เราสร้างโมเดล Pydantic Item ที่อธิบายโครงสร้างข้อมูลของเนื้อหาคำขอ
3. เราใช้ตัวตกแต่ง @app.post เพื่อกำหนด POST endpoint /items/
4. ฟังก์ชัน create_item รับอ็อบเจกต์ Item เป็นอินพุตและส่งคืน

ในการทดสอบสิ่งนี้ คุณสามารถใช้ไคลเอนต์ API เช่น apidog หรือเพียงแค่ใช้ Swagger UI แบบโต้ตอบที่ FastAPI ให้ไว้ที่ http://127.0.0.1:8000/docs

การจัดการข้อมูลและการตรวจสอบความถูกต้อง

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

ตัวอย่างเช่น หากคุณส่งคำขอ POST ไปยัง /items/ พร้อมเนื้อหา JSON ต่อไปนี้:

{
    "name": "Item name",
    "price": 25.5
}

FastAPI จะยอมรับคำขอนี้เนื่องจากตรงตามข้อกำหนดของโมเดล Item อย่างไรก็ตาม หากคุณละเว้นฟิลด์ price FastAPI จะปฏิเสธคำขอและส่งคืนข้อผิดพลาด

การใช้ Apidog เพื่อทดสอบคำขอ POST FastAPI ของคุณ

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

นี่คือวิธีที่คุณสามารถใช้ Apidog เพื่อทดสอบคำขอ POST ของคุณ:

1. เปิด Apidog และสร้างคำขอใหม่

2. ตั้งค่าวิธีการร้องขอเป็น POST

3. ป้อน URL ของทรัพยากรที่คุณต้องการอัปเดต เพิ่มส่วนหัวหรือพารามิเตอร์เพิ่มเติมที่คุณต้องการรวม จากนั้นคลิกปุ่ม "ส่ง" เพื่อส่งคำขอ

4. ตรวจสอบว่าการตอบสนองเป็นไปตามที่คุณคาดหวัง

คำขอ POST ขั้นสูง

ตอนนี้ มาสำรวจสถานการณ์ขั้นสูงเพิ่มเติม FastAPI ช่วยให้คุณทำอะไรได้อีกมากมายด้วยคำขอ POST ตัวอย่างเช่น คุณสามารถ:

• จัดการการอัปโหลดไฟล์: ใช้ File และ UploadFile จาก fastapi
• ประมวลผลข้อมูลแบบฟอร์ม: ใช้ Form จาก fastapi
• ใช้พารามิเตอร์เส้นทาง: รวม พารามิเตอร์เส้นทาง กับคำขอ POST

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

นี่คือตัวอย่างของการจัดการการอัปโหลดไฟล์ด้วย FastAPI:

from fastapi import FastAPI, File, UploadFile

app = FastAPI()

@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile):
    return {"filename": file.filename}

endpoint นี้จะยอมรับไฟล์และส่งคืนชื่อไฟล์ คุณสามารถทดสอบสิ่งนี้ด้วย apidog หรือ Swagger UI

การประมวลผลข้อมูลแบบฟอร์ม

ในการประมวลผลข้อมูลแบบฟอร์ม ให้ใช้คลาส Form จาก FastAPI:

from fastapi import FastAPI, Form

app = FastAPI()

@app.post("/login/")
def login(username: str = Form(...), password: str = Form(...)):
    return {"username": username}

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

การใช้พารามิเตอร์เส้นทาง

คุณยังสามารถรวมพารามิเตอร์เส้นทางกับคำขอ POST ได้:

from fastapi import FastAPI

app = FastAPI()

@app.post("/users/{user_id}/items/")
def create_item_for_user(user_id: int, item: Item):
    return {"user_id": user_id, "item": item}

endpoint นี้สร้างรายการสำหรับผู้ใช้เฉพาะที่ระบุโดยพารามิเตอร์เส้นทาง user_id

บทสรุป

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

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

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