Python FastAPI Middleware: คู่มือฉบับสมบูรณ์สำหรับการประมวลผลคำขอและการตอบสนอง

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

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

Middleware ในบริบทของ Web Frameworks คืออะไร

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

อุปมาที่เป็นที่นิยมคือ onion model แกนหลักของหัวหอมคือตรรกะทางธุรกิจของแอปพลิเคชันของคุณ (ปลายทาง) แต่ละชั้นของหัวหอมที่ล้อมรอบแกนหลักคือ middleware คำขอจะต้องปอกเปลือกแต่ละชั้นนอกเพื่อไปยังแกนหลัก และการตอบสนองจะเดินทางกลับออกมาผ่านชั้นเดียวกัน แต่ละชั้นสามารถตรวจสอบและแก้ไขคำขอในขณะที่กำลังเข้ามาและการตอบสนองในขณะที่กำลังออกไปได้

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

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

FastAPI สร้างขึ้นบน Starlette toolkit ซึ่งมีการใช้งานมาตรฐาน ASGI (Asynchronous Server Gateway Interface) ที่แข็งแกร่ง Middleware เป็นแนวคิดพื้นฐานใน ASGI ทำให้เป็นพลเมืองชั้นหนึ่งในระบบนิเวศ FastAPI

รูปแบบที่ง่ายที่สุด: FastAPI Middleware พร้อม Decorator

FastAPI มีวิธีที่ตรงไปตรงมาในการเพิ่ม middleware โดยใช้ตัวตกแต่ง @app.middleware("http") เหมาะสำหรับตรรกะที่เรียบง่ายและอยู่ในตัวเองซึ่งจำเป็นต้องรันสำหรับทุกคำขอ HTTP

มาสร้างตัวอย่างคลาสสิก: middleware เพื่อคำนวณเวลาประมวลผลสำหรับแต่ละคำขอและเพิ่มลงในส่วนหัวของการตอบสนอง สิ่งนี้มีประโยชน์อย่างเหลือเชื่อสำหรับการตรวจสอบประสิทธิภาพ

ตัวอย่าง: Process-Time Middleware

ขั้นแรก ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง FastAPI และ ASGI server เช่น Uvicorn แล้ว:

pip install fastapi uvicorn

ตอนนี้ มาเขียนโค้ดในไฟล์ชื่อ main.py:

import time

from fastapi import FastAPI, Request

app = FastAPI()

# กำหนดฟังก์ชัน middleware

@app.middleware("http")

async def add_process_time_header(request: Request, call_next):

# บันทึกเวลาเริ่มต้นเมื่อคำขอเข้ามา

start_time = time.time()

# ดำเนินการต่อไปยัง middleware ถัดไปหรือปลายทาง

response = await call_next(request)

# คำนวณเวลาประมวลผล

process_time = time.time() - start_time

# เพิ่มส่วนหัวที่กำหนดเองลงในการตอบสนอง

response.headers["X-Process-Time"] = str(process_time)

return response

@app.get("/")

async def root():

# จำลองการทำงานบางอย่าง

time.sleep(0.5)

return {"message": "Hello, World!"}

ในการรันแอปพลิเคชันนี้ ให้ใช้คำสั่ง:

uvicorn main:app --reload

ตอนนี้ หากคุณส่งคำขอไปยัง http://127.0.0.1:8000 โดยใช้เครื่องมืออย่าง cURL หรือ API client อย่าง Postman คุณจะเห็นส่วนหัวใหม่ในการตอบสนอง X-Process-Time โดยมีค่าประมาณ 0.5 วินาที

การแยกส่วนโค้ด:

• @app.middleware("http"): ตัวตกแต่งนี้ลงทะเบียนฟังก์ชันของเราเป็น middleware HTTP
• async def add_process_time_header(request: Request, call_next):: ฟังก์ชัน middleware ต้องเป็น asynchronous ฟังก์ชันนี้รับออบเจ็กต์ Request ขาเข้าและฟังก์ชันพิเศษ call_next
• response = await call_next(request): นี่คือบรรทัดที่สำคัญที่สุด call_next จะส่งต่อคำขอไปยังขั้นตอนถัดไปในไปป์ไลน์ (ไม่ว่าจะเป็น middleware อื่นหรือการดำเนินการตามเส้นทางจริง) คุณ ต้อง `await` การเรียกนี้ ผลลัพธ์คือออบเจ็กต์ Response ที่สร้างโดยปลายทาง
• response.headers[...] = ...: หลังจากได้รับการตอบสนองจากปลายทางแล้ว เราสามารถแก้ไขได้ ในกรณีนี้คือการเพิ่มส่วนหัวที่กำหนดเอง
• return response: สุดท้าย การตอบสนองที่แก้ไขจะถูกส่งกลับไปยังไคลเอนต์

การสร้าง Custom Middleware ของคุณเองด้วยคลาส

แม้ว่าวิธีการตกแต่งจะเรียบง่าย แต่ก็อาจมีข้อจำกัดสำหรับสถานการณ์ที่ซับซ้อนมากขึ้น โดยเฉพาะอย่างยิ่งเมื่อ middleware ของคุณต้องการการกำหนดค่าหรือจำเป็นต้องจัดการสถานะภายใน สำหรับกรณีเหล่านี้ FastAPI (ผ่าน Starlette) สนับสนุน class-based middleware โดยใช้ BaseHTTPMiddleware

วิธีการแบบคลาสมีโครงสร้างที่ดีกว่า อนุญาตให้มีการ dependency injection ใน constructor และโดยทั่วไปจะบำรุงรักษาได้ง่ายกว่าสำหรับตรรกะที่ซับซ้อน ตรรกะหลักอยู่ในเมธอด dispatch ที่เป็น asynchronous

ตัวอย่าง: Class-Based API Key Authentication Middleware

มาสร้าง middleware ที่ใช้งานได้จริงมากขึ้นซึ่งรักษาความปลอดภัย API ของเรา จะตรวจสอบส่วนหัวเฉพาะ X-API-Key และหากไม่มีคีย์หรือคีย์ไม่ถูกต้อง จะส่งคืนข้อผิดพลาด 403 Forbidden ทันที นี่คือตัวอย่างของการ "ลัดวงจร" คำขอ

ใน main.py:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint

from starlette.responses import Response

# รายการ API key ที่ถูกต้อง ในแอปพลิเคชันจริง สิ่งนี้จะมาจากฐานข้อมูลหรือ vault ที่ปลอดภัย

VALID_API_KEYS = ["my-super-secret-key", "another-valid-key"]

class APIKeyMiddleware(BaseHTTPMiddleware):

async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:

api_key = request.headers.get("X-API-Key")

if api_key not in VALID_API_KEYS:

# ลัดวงจรคำขอและส่งคืนการตอบสนองข้อผิดพลาด

return JSONResponse(

status_code=403,

content={"detail": "Forbidden: Invalid or missing API Key"}

)

# หากคีย์ถูกต้อง ดำเนินการต่อด้วยคำขอ

response = await call_next(request)

return response

app = FastAPI()

# เพิ่ม middleware ไปยังแอปพลิเคชัน

app.add_middleware(APIKeyMiddleware)

@app.get("/")

async def root():

return {"message": "Welcome to the secure zone!"}

ตอนนี้ เมื่อคุณรันแอปพลิเคชันนี้:

• คำขอ ที่ไม่มี ส่วนหัว X-API-Key (หรือมีค่าที่ไม่ถูกต้อง) จะได้รับรหัสสถานะ 403 และข้อความแสดงข้อผิดพลาด JSON
• คำขอ ที่มี ส่วนหัว X-API-Key: my-super-secret-key จะสำเร็จและได้รับการตอบสนอง 200 OK

รูปแบบนี้มีประสิทธิภาพอย่างยิ่ง โค้ดปลายทางที่ / ไม่จำเป็นต้องรู้อะไรเกี่ยวกับการตรวจสอบ API key ข้อกังวลนั้นจะถูกแยกออกไปในเลเยอร์ middleware อย่างสมบูรณ์

กรณีการใช้งานทั่วไปและมีประสิทธิภาพสำหรับ Middleware

Middleware เป็นเครื่องมือที่สมบูรณ์แบบสำหรับการจัดการข้อกังวลที่ครอบคลุม มาสำรวจกรณีการใช้งานที่พบบ่อยและมีผลกระทบมากที่สุด

1. การบันทึกส่วนกลาง

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

ตัวอย่าง Logging Middleware:

import logging

from fastapi import FastAPI, Request

import time

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def logging_middleware(request: Request, call_next):

start_time = time.time()

# บันทึกรายละเอียดคำขอ

logger.info(f"Incoming request: {request.method} {request.url.path}")

response = await call_next(request)

process_time = time.time() - start_time

# บันทึกรายละเอียดการตอบสนอง

logger.info(f"Response status: {response.status_code} | Process time: {process_time:.4f}s")

return response

Middleware นี้บันทึก method และ path ของคำขอในขณะที่เข้ามา และรหัสสถานะการตอบสนองและเวลาประมวลผลทั้งหมดในขณะที่ออกไป สิ่งนี้ให้การมองเห็นที่ประเมินค่าไม่ได้ในการรับส่งข้อมูลของแอปพลิเคชันของคุณ

2. การจัดการข้อผิดพลาดส่วนกลาง

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

ตัวอย่าง Error Handling Middleware:

from fastapi import FastAPI, Request

from fastapi.responses import JSONResponse

import logging

logger = logging.getLogger(__name__)

app = FastAPI()

@app.middleware("http")

async def error_handling_middleware(request: Request, call_next):

try:

return await call_next(request)

except Exception as e:

logger.error(f"An unhandled error occurred: {e}", exc_info=True)

return JSONResponse(

status_code=500,

content={"detail": "An internal server error occurred. Please try again later."}

)

@app.get("/error")

async def cause_error():

return 1 / 0 # This will raise a ZeroDivisionError

เมื่อมี middleware นี้ คำขอไปยัง /error จะไม่ทำให้ server ขัดข้องหรือเปิดเผย stack trace อีกต่อไป แต่จะส่งคืนรหัสสถานะ 500 พร้อมกับ JSON body ที่สะอาด ในขณะที่ข้อผิดพลาดทั้งหมดถูกบันทึกไว้ฝั่ง server เพื่อให้นักพัฒนาตรวจสอบ

3. CORS (Cross-Origin Resource Sharing)

หากแอปพลิเคชัน frontend ของคุณให้บริการจากโดเมน โปรโตคอล หรือพอร์ตที่แตกต่างจาก backend FastAPI ของคุณ เบราว์เซอร์จะบล็อกคำขอเนื่องจาก Same-Origin Policy CORS คือกลไกในการผ่อนคลายนโยบายนี้ FastAPI มี CORSMiddleware เฉพาะที่กำหนดค่าได้สูงสำหรับจุดประสงค์นี้

ตัวอย่าง CORS Configuration:

from fastapi import FastAPI

from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# กำหนดรายการ origins ที่อนุญาต ใช้ "*" สำหรับ Public APIs แต่ควรระบุเฉพาะเจาะจงเพื่อความปลอดภัยที่ดีขึ้น

origins = [

"http://localhost:3000",

"https://my-production-frontend.com",

]

app.add_middleware(

CORSMiddleware,

allow_origins=origins,

allow_credentials=True, # อนุญาตให้รวม cookies ในคำขอข้ามโดเมน

allow_methods=["*"], # อนุญาต HTTP methods มาตรฐานทั้งหมด

allow_headers=["*"], # อนุญาต headers ทั้งหมด

)

นี่เป็นหนึ่งใน middleware ชิ้นแรกๆ ที่คุณน่าจะเพิ่มในโปรเจ็กต์ใดๆ ที่มี frontend ที่แยกจากกัน ทำให้ง่ายต่อการจัดการนโยบายข้ามโดเมนจากตำแหน่งส่วนกลางแห่งเดียว

4. GZip Compression

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

ตัวอย่าง GZip Middleware:

from fastapi import FastAPI

from fastapi.middleware.gzip import GZipMiddleware

app = FastAPI()

# เพิ่ม GZip middleware คุณสามารถกำหนดขนาดขั้นต่ำสำหรับการบีบอัดได้

app.add_middleware(GZipMiddleware, minimum_size=1000)

@app.get("/")

async def root():

# การตอบสนองนี้มีขนาดเล็กและจะไม่ถูก gzipped

return {"message": "Hello World"}

@app.get("/large-data")

async def large_data():

# การตอบสนองขนาดใหญ่นี้จะถูก gzipped โดยอัตโนมัติโดย middleware

return {"data": "a_very_long_string..." * 1000}

เมื่อมี middleware นี้ การตอบสนองใดๆ ที่มีขนาดใหญ่กว่า 1000 ไบต์จะถูกบีบอัด หากไคลเอนต์ระบุว่ายอมรับการเข้ารหัส GZip (ซึ่งเบราว์เซอร์และไคลเอนต์สมัยใหม่เกือบทั้งหมดทำ)

แนวคิดขั้นสูงและแนวทางปฏิบัติที่ดีที่สุด

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

1. ลำดับ Middleware มีความสำคัญ!

นี่คือกฎที่สำคัญที่สุดที่ควรจำ Middleware จะถูกประมวลผลตามลำดับที่เพิ่มไปยังแอปพลิเคชัน Middleware ที่เพิ่มครั้งแรกคือชั้นนอกสุดของ "หัวหอม"

พิจารณาการตั้งค่านี้:

app.add_middleware(ErrorHandlingMiddleware) # ชั้นนอกสุด

app.add_middleware(LoggingMiddleware)

app.add_middleware(AuthenticationMiddleware) # ชั้นในสุด

การไหลของคำขอจะเป็นดังนี้:

1. ErrorHandlingMiddleware ได้รับคำขอ โดยจะห่อ `call_next` ในบล็อก `try...except`
2. จะเรียก `next` โดยส่งคำขอไปยัง `LoggingMiddleware`
3. LoggingMiddleware ได้รับคำขอ บันทึก และเรียก `next`
4. AuthenticationMiddleware ได้รับคำขอ ตรวจสอบข้อมูลประจำตัว และเรียก `next`
5. คำขอไปถึง ปลายทาง ในที่สุด
6. ปลายทางส่งคืนการตอบสนอง
7. AuthenticationMiddleware ได้รับการตอบสนองและส่งต่อขึ้นไป
8. LoggingMiddleware ได้รับการตอบสนอง บันทึก และส่งต่อขึ้นไป
9. ErrorHandlingMiddleware ได้รับการตอบสนองสุดท้ายและส่งคืนให้กับไคลเอนต์

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

2. การส่งข้อมูลด้วย `request.state`

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

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

ตัวอย่าง: การส่งข้อมูลผู้ใช้จาก Middleware

# ในเมธอด dispatch ของ authentication middleware ของคุณ:

# ... หลังจากตรวจสอบโทเค็นและถอดรหัสผู้ใช้แล้ว ...

user_data = {"id": 123, "username": "global_dev"}

request.state.user = user_data

response = await call_next(request)

# ในปลายทางของคุณ:

@app.get("/profile")

async def get_user_profile(request: Request):

current_user = request.state.user

return {"profile_for": current_user}

สิ่งนี้ทำให้ตรรกะสะอาดและหลีกเลี่ยงการทำให้ namespace ของออบเจ็กต์ `Request` เสียหาย

3. ข้อควรพิจารณาด้านประสิทธิภาพ

แม้ว่า middleware จะมีประสิทธิภาพ แต่แต่ละเลเยอร์จะเพิ่มค่าใช้จ่ายเล็กน้อย สำหรับแอปพลิเคชันที่มีประสิทธิภาพสูง ให้คำนึงถึงประเด็นเหล่านี้:

• ทำให้กระชับ: ตรรกะ Middleware ควรเร็วและมีประสิทธิภาพมากที่สุด
• เป็น asynchronous: หาก middleware ของคุณต้องการดำเนินการ I/O (เช่น การตรวจสอบฐานข้อมูล) ตรวจสอบให้แน่ใจว่าเป็น `async` อย่างสมบูรณ์เพื่อหลีกเลี่ยงการบล็อก event loop ของ server
• ใช้ด้วยจุดประสงค์: อย่าเพิ่ม middleware ที่คุณไม่ต้องการ แต่ละรายการจะเพิ่มความลึกของ call stack และเวลาประมวลผล

4. การทดสอบ Middleware ของคุณ

Middleware เป็นส่วนสำคัญของตรรกะของแอปพลิเคชันของคุณและควรได้รับการทดสอบอย่างละเอียด `TestClient` ของ FastAPI ทำให้สิ่งนี้ตรงไปตรงมา คุณสามารถเขียนการทดสอบที่ส่งคำขอโดยมีและไม่มีเงื่อนไขที่จำเป็น (เช่น มีและไม่มี API key ที่ถูกต้อง) และยืนยันว่า middleware ทำงานตามที่คาดไว้

ตัวอย่างการทดสอบสำหรับ APIKeyMiddleware:

from fastapi.testclient import TestClient

from .main import app # นำเข้าแอป FastAPI ของคุณ

client = TestClient(app)

def test_request_without_api_key_is_forbidden():

response = client.get("/")

assert response.status_code == 403

assert response.json() == {"detail": "Forbidden: Invalid or missing API Key"}

def test_request_with_valid_api_key_is_successful():

headers = {"X-API-Key": "my-super-secret-key"}

response = client.get("/", headers=headers)

assert response.status_code == 200

assert response.json() == {"message": "Welcome to the secure zone!"}

สรุป

FastAPI middleware เป็นเครื่องมือพื้นฐานและมีประสิทธิภาพสำหรับนักพัฒนาที่สร้าง Web APIs สมัยใหม่ ให้วิธีที่สวยงามและนำกลับมาใช้ใหม่ได้เพื่อจัดการข้อกังวลที่ครอบคลุม โดยแยกออกจากตรรกะทางธุรกิจหลักของคุณ ด้วยการสกัดกั้นและประมวลผลทุกคำขอและการตอบสนอง middleware ช่วยให้คุณสามารถใช้งานการบันทึกที่แข็งแกร่ง การจัดการข้อผิดพลาดส่วนกลาง นโยบายความปลอดภัยที่เข้มงวด และการปรับปรุงประสิทธิภาพ เช่น การบีบอัด

จากตัวตกแต่ง @app.middleware("http") ที่เรียบง่าย ไปจนถึงโซลูชันแบบคลาสที่ซับซ้อน คุณมีความยืดหยุ่นในการเลือกแนวทางที่เหมาะสมกับความต้องการของคุณ ด้วยการทำความเข้าใจแนวคิดหลัก กรณีการใช้งานทั่วไป และแนวทางปฏิบัติที่ดีที่สุด เช่น การจัดลำดับ middleware และการจัดการสถานะ คุณสามารถสร้างแอปพลิเคชัน FastAPI ที่สะอาด ปลอดภัย และบำรุงรักษาได้ง่ายยิ่งขึ้น

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