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

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

FastAPI เป็นเฟรมเวิร์กเว็บ Python ที่ได้รับการพัฒนาสร้างขึ้นใหม่ทั้งหมด เพื่อรวมคุณสมบัติ Python ที่ทันสมัยเข้าด้วยกัน โดยใช้มาตรฐาน ASGI สำหรับการเชื่อมต่อแบบอะซิงโครนัส (Asynchronous Server Gateway Interface) พร้อมกันกับไคลเอนต์

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

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

หมายเหตุ: ในบทความนี้เราเพียงสรุปเนื้อหาใจความสำคัญมาเพียงเท่านั้น ซึ่งผู้อ่านสามารถอ่านรายละเอียดฉบับเต็มอย่างละเอียดได้ที่: Get started with FastAPI

1. ติดตั้ง FastAPI 

FastAPI สามารถติดตั้งองค์ประกอบได้ค่อนข้างน้อยด้วยตัวเอง ดังนั้นจึงเป็นการดีที่สุดที่จะเริ่มโปรเจ็กต์ FastAPI ใน virtual environment โดยส่วนประกอบ FastAPI หลักสามารถติดตั้งได้ด้วย pip install fastapi อย่างไรก็ตามจะต้องติดตั้งเซิร์ฟเวอร์ ASGI สำหรับการทดสอบในเครื่องด้วย FastAPI ซึ่งจะทำงานได้ดีกับ Uvicorn

2. ตัวอย่าง FastAPI อย่างง่าย: ต่อไปนี้คือแอปพลิเคชัน FastAPI ง่ายๆ 

from fastapi import FastAPI

app = FastAPI()

@app.get("/")

async def root():

    return {"greeting":"Hello world"}

บันทึกสิ่งนี้เป็น main.py จากนั้นเรียกใช้จากภายใน “venv” ของเราด้วยคำสั่งสั่ง uvicorn main:app ซึ่งวัตถุแอปคือสิ่งที่เราใช้สำหรับเซิร์ฟเวอร์ ASGI ของเรา อย่างไรก็ตาม "โปรดทราบว่าเราสามารถใช้ WSGI กับอะแดปเตอร์ ASGI-to-WSGI ได้ แต่วิธีที่ดีที่สุดคือใช้ ASGI"

ทั้งนี้ "มีการเสนอชื่อเข้าชิงรางวัล Best Places to Work in IT ประจำปี 2024" ด้วยนะ

3. ประเภทเส้นทางใน FastAPI

สำหรับเครื่องมือตกแต่ง @app ให้เราตั้งค่าวิธีการใช้สำหรับเส้นทาง เช่น

• @app.get หรือ @app.post

• GET

• POST

• PUT

• DELETE

• OPTIONS

• HEAD

• PATCH

• TRACE

อีกทั้งเรายังสามารถรองรับวิธีการต่างๆ บนเส้นทางที่กำหนดได้ง่ายๆ โดยการรวมฟังก์ชันเส้นทางหลายรายการ เช่น

• @app.get("/") ในฟังก์ชันหนึ่ง

•  @app.post("/") ในฟังก์ชันอื่น

4. พารามิเตอร์เส้นทาง แบบสอบถาม และแบบฟอร์มใน FastAPI

หากเราต้องการแยกตัวแปรออกจากเส้นทางของเส้นทาง เราสามารถทำได้โดยกำหนดตัวแปรเหล่านั้นในการประกาศเส้นทาง จากนั้นส่งต่อไปยังฟังก์ชันเส้นทาง

@app.get("/users/{user_id}")

async def user(user_id: str):

    return {"user_id":user_id}

หากต้องการแยกพารามิเตอร์การสืบค้นออกจาก URL เราสามารถใช้การประกาศแบบพิมพ์ในฟฟังก์ชันเส้นทาง ซึ่ง FastAPI จะตรวจจับโดยอัตโนมัติ

userlist = ["Spike","Jet","Ed","Faye","Ein"]

@app.get("/userlist")

async def userlist_(start: int = 0, limit: int = 3):

    return userlist[start:start+limit]

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

5. ประเภทการตอบกลับใน FastAPI 

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

from fastapi.responses import HTMLResponse

@app.get("/")

def root():

    return HTMLResponse("<b>Hello world</b>")

อย่างไรก็ตาม fastapi.responses สามารถรองรับประเภทการตอบกลับทั่วไปหลายประเภท เช่น 

• RedirectResponse: เปลี่ยนเส้นทางไปยัง URL ที่ให้ไว้

• FileResponse: ส่งคืนไฟล์จากเส้นทางที่ให้ไว้ สตรีมแบบอะซิงโครนัส

• StreamingResponse: นำเข้าเครื่องกำเนิดไฟฟ้าและสตรีมผลลัพธ์ไปยังไคลเอนต์

• HTMLResponse หรือ PlainTextResponse: ส่งกลับข้อความเป็น HTML หรือข้อความธรรมดา

6. วัตถุการตอบสนองใน FastAPI 

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

from fastapi import Response

@app.get("/")

def modify_header(response:Response):

    response.headers["X-New-Header"] = "Hi, I'm a new header!"

    return {"msg":"Headers modified in response"}

7. คุกกี้ใน FastAPI

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

from fastapi import Cookie

@app.get("/")

async def main(user_nonce: Optional[str]=Cookie(none)):

    return {"user_nonce": user_nonce}

การตั้งค่าคุกกี้ทำได้โดยใช้เมธอด .set_cookie() บนออบเจ็กต์ Response:

from fastapi import Response

@app.post("/")

async def main(response: Response):

    response.set_cookie(key="user_nonce", value="")

    return {"msg":"User nonce cookie cleared"}

8. การใช้โมเดล Pydantic กับ FastAPI

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

นี่คือตัวอย่างวิธีที่ Pydantic สามารถใช้ตรวจสอบ JSON ขาเข้าได้:

from typing import List, Optional

from fastapi import FastAPI

from pydantic import BaseModel, EmailStr

app = FastAPI()

class Movie(BaseModel):

    name: str

    year: int

    rating: Optional[int] = None

    tags: List[str] = []

@app.post("/movies/", response_model=Movie)

async def create_movie(movie: Movie):

    return movie

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

9. การใช้ WebSockets ใน FastAPI

สำหรับตำแหน่งข้อมูล WebSocket  ใน FastAPI นั้นเรียบง่ายเช่นกัน: 

from fastapi import FastAPI, WebSocket

@app.websocket("/ws")

async def ws_connection(websocket: WebSocket):

    await websocket.accept()

    while True:

        data = await websocket.receive_text()

        await websocket.send_text(f"You said: {data}")

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

 10. การใช้ Swagger/OpenAPI ใน FastAPI

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

FastAPI จะสร้างคำจำกัดความของ OpenAPI ให้กับตำแหน่งข้อมูลทั้งหมดของเว็บไซต์โดยอัตโนมัติ หากเราไปที่ /openapi.json ที่รากของไซต์ FastAPI เราจะได้รับไฟล์ JSON ที่อธิบายตำแหน่งข้อมูลแต่ละจุด ข้อมูลที่สามารถรับได้ และข้อมูลที่ส่งคืน 

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

สามารถอ่านข้อมูลอย่างละเอียดฉบับเต็มได้ที่: Get started with FastAPI

บทความที่เกี่ยวข้อง

• DENO เปิดตัวเว็บเซิร์ฟเวอร์ API ที่เร็วและง่ายขึ้น
• FRAMEWORK ใหม่สำหรับ DENO ช่วยเร่งการโหลดหน้าเว็บได้เร็วขึ้น 45 ถึง 60 เท่า!
• การออกแบบเว็บไซต์ 

---Wynnsoft Solution รับทำเว็บไซต์ รับทำ SEO รับทำการตลาดออนไลน์ รับทำโฆษณา Facebook รับทำเว็บไซต์ ขอนแก่น และรับทำเว็บไซต์ทั่วประเทศ—

ข้อมูลจาก: infoworld.com