สร้างแอปด้วย FastAPI สำหรับ Python

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

เมื่อคุณพร้อมที่จะพัฒนาแอป FastAPI ของคุณเองแล้ว คุณจะไม่ต้องมองหาที่ไหนไกลเพื่อโฮสต์แอปเหล่านั้น บริการโฮสติ้งแอปพลิเคชันและฐานข้อมูลของ Kinsta มอบแพลตฟอร์มเป็นบริการที่แข็งแกร่งบน Python

มาเรียนรู้พื้นฐานกันก่อน

ข้อดีของ FastAPI

ด้านล่างนี้คือข้อดีบางประการที่เฟรมเวิร์ก FastAPI นำมาสู่โครงการ

• ความเร็ว: ตามชื่อที่แสดง FastAPI เป็นกรอบการทำงานที่รวดเร็วมาก ความเร็วเทียบได้กับ Go และ Node.js ซึ่งโดยทั่วไปถือว่าเป็นหนึ่งในตัวเลือกที่เร็วที่สุดสำหรับการสร้าง API
• เรียนรู้และเขียนโค้ดได้ง่าย: FastAPI ได้ค้นพบเกือบทุกอย่างที่คุณต้องการเพื่อสร้าง API ที่พร้อมสำหรับการผลิตแล้ว ในฐานะนักพัฒนาที่ใช้ FastAPI คุณไม่จำเป็นต้องเขียนโค้ดทุกอย่างตั้งแต่เริ่มต้น ด้วยโค้ดเพียงไม่กี่บรรทัด คุณก็สามารถมี RESTful API พร้อมสำหรับการปรับใช้
• เอกสารประกอบที่ครอบคลุม: FastAPI ใช้มาตรฐานเอกสาร OpenAPI ดังนั้นจึงสามารถสร้างเอกสารแบบไดนามิกได้ เอกสารนี้ให้ข้อมูลโดยละเอียดเกี่ยวกับจุดสิ้นสุด การตอบสนอง พารามิเตอร์ และโค้ดส่งคืนของ FastAPI
• API ที่มีข้อบกพร่องน้อยลง: FastAPI รองรับการตรวจสอบข้อมูลแบบกำหนดเอง ซึ่งช่วยให้นักพัฒนาสามารถสร้าง API ที่มีข้อบกพร่องน้อยลง นักพัฒนาของ FastAPI อวดว่าเฟรมเวิร์กส่งผลให้มีข้อบกพร่องที่เกิดจากมนุษย์น้อยลง – น้อยลงมากถึง 40%
• คำแนะนำประเภท: โมดูลประเภทถูกนำมาใช้ใน Python 3.5 สิ่งนี้ทำให้คุณสามารถประกาศ type ของตัวแปรได้ เมื่อมีการประกาศประเภทของตัวแปร IDE จะสามารถให้การสนับสนุนที่ดีขึ้นและคาดการณ์ข้อผิดพลาดได้แม่นยำยิ่งขึ้น

วิธีเริ่มต้นใช้งาน FastAPI

หากต้องการทำตามบทช่วยสอนนี้และเริ่มต้นใช้งาน FastAPI คุณต้องทำบางสิ่งก่อน

ตรวจสอบให้แน่ใจว่าคุณมีโปรแกรมแก้ไขข้อความ/IDE ของโปรแกรมเมอร์ เช่น Visual Studio Code ตัวเลือกอื่นๆ ได้แก่ Sublime Text และ Espresso

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

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

 $ python3 -m venv env

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

 # On Unix or MacOS (bash shell): /path/to/venv/bin/activate # On Unix or MacOS (csh shell): /path/to/venv/bin/activate.csh # On Unix or MacOS (fish shell): /path/to/venv/bin/activate.fish # On Windows (command prompt): \path\to\venv\Scripts\activate.bat # On Windows (PowerShell): \path\to\venv\Scripts\Activate.ps1

(ยังสามารถกำหนดค่า IDE ที่รับรู้ด้วย Python บางตัวเพื่อเปิดใช้งานสภาพแวดล้อมเสมือนปัจจุบันได้อีกด้วย)

ตอนนี้ ติดตั้ง FastAPI:

 $ pip3 install fastapi

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

 $ pip3 install "uvicorn[standard]"

เมื่อติดตั้งสำเร็จ ให้สร้างไฟล์ชื่อ main.py ภายในไดเร็กทอรีการทำงานของโปรเจ็กต์ของคุณ ไฟล์นี้จะเป็นจุดเริ่มต้นการสมัครของคุณ

ตัวอย่าง FastAPI ด่วน

คุณจะได้ทดสอบการติดตั้ง FastAPI ของคุณโดยตั้งค่าปลายทางตัวอย่างอย่างรวดเร็ว ในไฟล์ main.py ให้วางโค้ดต่อไปนี้ จากนั้นบันทึกไฟล์:

 # main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"greeting":"Hello world"}

ตัวอย่างด้านบนสร้างจุดสิ้นสุด FastAPI พื้นฐาน ด้านล่างนี้คือบทสรุปของสิ่งที่แต่ละบรรทัดทำ:

• from fastapi import FastAPI : ฟังก์ชันสำหรับ API ของคุณมีให้โดยคลาส FastAPI Python
• app = FastAPI() : สิ่งนี้สร้างอินสแตนซ์ FastAPI
• @app.get("/") : นี่คือตัวตกแต่งหลามที่ระบุให้ FastAPI ว่าฟังก์ชันด้านล่างมีหน้าที่จัดการคำขอ
• @app.get("/") : นี่คือมัณฑนากรที่ระบุเส้นทาง สิ่งนี้สร้าง GET บนเส้นทางของไซต์ ผลลัพธ์จะถูกส่งกลับโดยฟังก์ชันที่ห่อไว้
• การดำเนินการที่เป็นไปได้อื่นๆ ที่ใช้ในการสื่อสาร ได้แก่ @app.post() , @app.put() , @app.delete() , @app.options() , @app.head() , @app.patch() และ @app.trace()

ในไดเร็กทอรีไฟล์ ให้รันคำสั่งต่อไปนี้ในเทอร์มินัลเพื่อเริ่มเซิร์ฟเวอร์ API:

 $ uvicorn main:app --reload

ในคำสั่งนี้ main คือชื่อโมดูลของคุณ วัตถุ app เป็นอินสแตนซ์ของแอปพลิเคชันของคุณ และนำเข้าสู่เซิร์ฟเวอร์ ASGI แฟ --reload บอกให้เซิร์ฟเวอร์โหลดซ้ำโดยอัตโนมัติเมื่อคุณทำการเปลี่ยนแปลงใดๆ

คุณควรเห็นสิ่งนี้ในเทอร์มินัลของคุณ:

 $ uvicorn main:app --reload INFO: Will watch for changes in these directories: ['D:\\WEB DEV\\Eunit\\Tests\\fast-api'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [26888] using WatchFiles INFO: Started server process [14956] INFO: Waiting for application startup. INFO: Application startup complete.

ในเบราว์เซอร์ของคุณ ให้ไปที่ http://localhost:8000 เพื่อยืนยันว่า API ของคุณทำงานอยู่ คุณควรเห็น "สวัสดี": "โลก" เป็นวัตถุ JSON บนหน้า นี่แสดงให้เห็นว่าการสร้าง API ด้วย FastAPI นั้นง่ายเพียงใด สิ่งที่คุณต้องทำคือกำหนดเส้นทางและส่งคืนพจนานุกรม Python ของคุณดังที่เห็นในบรรทัดที่หกของส่วนย่อยด้านบน

การใช้คำแนะนำประเภท

หากคุณใช้ Python คุณจะคุ้นเคยกับการใส่คำอธิบายประกอบตัวแปรด้วยประเภทข้อมูลพื้นฐาน เช่น int , str , float และ bool อย่างไรก็ตาม จาก Python เวอร์ชัน 3.9 ได้มีการแนะนำโครงสร้างข้อมูลขั้นสูง สิ่งนี้ทำให้คุณสามารถทำงานกับโครงสร้างข้อมูล เช่น dictionaries tuples lists ลิสต์ ด้วยคำใบ้ประเภท FastAPI คุณสามารถจัดโครงสร้างสคีมาของข้อมูลของคุณโดยใช้โมเดล pydantic จากนั้นใช้โมเดล pydantic เพื่อพิมพ์คำใบ้และได้รับประโยชน์จากการตรวจสอบข้อมูลที่มีให้

ในตัวอย่างด้านล่าง การใช้คำใบ้ประเภทใน Python แสดงให้เห็นด้วยเครื่องคำนวณราคาอาหารอย่างง่าย calculate_meal_fee :

 def calculate_meal_fee(beef_price: int, meal_price: int) -> int: total_price: int = beef_price + meal_price return total_price print("Calculated meal fee", calculate_meal_fee(75, 19))

โปรดทราบว่าคำใบ้ประเภทจะไม่เปลี่ยนวิธีการเรียกใช้โค้ดของคุณ

เอกสาร FastAPI Interactive API

FastAPI ใช้ Swagger UI เพื่อจัดทำเอกสาร API แบบโต้ตอบอัตโนมัติ หากต้องการเข้าถึง ให้ไปที่ http://localhost:8000/docs แล้วคุณจะเห็นหน้าจอที่มีปลายทาง เมธอด และสคีมาทั้งหมดของคุณ

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

เอกสารประกอบ API บนเบราว์เซอร์ทางเลือกซึ่งจัดทำโดย FastAPI เช่นกันคือ Redoc หากต้องการเข้าถึง Redoc ให้ไปที่ http://localhost:8000/redoc ซึ่งคุณจะเห็นรายการปลายทาง วิธีการ และการตอบสนองที่เกี่ยวข้อง

การตั้งค่าเส้นทางใน FastAPI

@app decorator ช่วยให้คุณระบุวิธีการของเส้นทาง เช่น @app.get หรือ @app.post และรองรับ GET , POST , PUT และ DELETE รวมถึงตัวเลือกทั่วไป HEAD , PATCH และ TRACE

สร้างแอปของคุณด้วย FastAPI

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้เกี่ยวกับการสร้างแอปพลิเคชัน CRUD ด้วย FastAPI แอปพลิเคชันจะสามารถ:

• สร้างผู้ใช้
• อ่านบันทึกฐานข้อมูลของผู้ใช้
• อัปเดตผู้ใช้ที่มีอยู่
• ลบผู้ใช้เฉพาะ

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

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

บทช่วยสอนนี้จะใช้ฐานข้อมูลในหน่วยความจำ เพื่อให้คุณเริ่มต้นใช้งาน FastAPI เพื่อสร้าง API ได้อย่างรวดเร็ว อย่างไรก็ตาม สำหรับการผลิต คุณสามารถใช้ฐานข้อมูลใดก็ได้ที่คุณเลือก เช่น PostgreSQL, MySQL, SQLite หรือแม้แต่ Oracle

สร้างแอป

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

• id : ตัวระบุเฉพาะสากล (UUID)
• first_name : ชื่อแรกของผู้ใช้
• last_name : นามสกุลของผู้ใช้
• gender : เพศของผู้ใช้
• roles ซึ่งเป็นรายการที่ประกอบด้วยบทบาทของผู้ admin และ user

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

 # models.py from typing import List, Optional from uuid import UUID, uuid4 from pydantic import BaseModel from enum import Enum from pydantic import BaseModel class Gender(str, Enum): male = "male" female = "female" class Role(str, Enum): admin = "admin" user = "user" class User(BaseModel): id: Optional[UUID] = uuid4() first_name: str last_name: str gender: Gender roles: List[Role]

ในรหัสด้านบน:

• คลาส User ของคุณขยาย BaseModel ซึ่งนำเข้ามาจาก pydantic
• คุณกำหนดแอตทริบิวต์ของผู้ใช้ตามที่กล่าวไว้ข้างต้น

ขั้นตอนต่อไปคือการสร้างฐานข้อมูลของคุณ แทนที่เนื้อหาของไฟล์ main.py ด้วยรหัสต่อไปนี้:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ]

ใน main.py :

• คุณเตรียมใช้งาน db ด้วยประเภท List และส่งผ่านไปยัง User model
• คุณสร้างฐานข้อมูลในหน่วยความจำที่มีผู้ใช้ 4 คน โดยแต่ละคนมีแอตทริบิวต์ที่จำเป็น เช่น first_name , last_name , gender และ roles ผู้ใช้ Eunit ได้รับมอบหมายบทบาทของ admin และ user ในขณะที่ผู้ใช้อีกสามคนได้รับมอบหมายบทบาทของ user เท่านั้น

อ่านบันทึกฐานข้อมูล

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

ในไฟล์ main.py ของคุณ ให้วางโค้ดต่อไปนี้ใต้ตำแหน่งข้อมูล Hello World ของคุณ:

 # main.py @app.get("/api/v1/users") async def get_users(): return db

รหัสนี้กำหนด endpoint /api/v1/users และสร้างฟังก์ชัน async, get_users ซึ่งส่งคืนเนื้อหาทั้งหมดของฐานข้อมูล db

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

 $ uvicorn main:app --reload

ในเบราว์เซอร์ของคุณ ให้ไปที่ http://localhost:8000/api/v1/users นี่ควรส่งคืนรายชื่อผู้ใช้ทั้งหมดของคุณดังที่แสดงด้านล่าง:

ในขั้นตอนนี้ ไฟล์ main.py ของคุณจะมีลักษณะดังนี้:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ] @app.get("/") async def root(): return {"Hello": "World",} @app.get("/api/v1/users") async def get_users(): return db

สร้างบันทึกฐานข้อมูล

ขั้นตอนต่อไปคือการสร้างจุดสิ้นสุดเพื่อสร้างผู้ใช้ใหม่ในฐานข้อมูลของคุณ วางข้อมูลโค้ดต่อไปนี้ลงในไฟล์ main.py ของคุณ:

 # main.py @app.post("/api/v1/users") async def create_user(user: User): db.append(user) return {"id": user.id}

ในตัวอย่างนี้ คุณได้กำหนดจุดสิ้นสุดเพื่อส่งผู้ใช้ใหม่และใช้ @app.post decorator เพื่อสร้างเมธอด POST

คุณยังสร้างฟังก์ชัน create_user ซึ่งยอมรับ user ของโมเดล User และต่อท้าย (เพิ่ม) user ที่สร้างขึ้นใหม่ในฐานข้อมูล db สุดท้าย ปลายทางจะส่งคืนวัตถุ JSON ของ id ผู้ใช้ที่สร้างขึ้นใหม่

คุณจะต้องใช้เอกสารประกอบ API อัตโนมัติที่ได้รับจาก FastAPI เพื่อทดสอบจุดสิ้นสุดของคุณ ดังที่เห็นด้านบน นี่เป็นเพราะคุณไม่สามารถส่งคำขอโพสต์โดยใช้เว็บเบราว์เซอร์ ไปที่ http://localhost:8000/docs เพื่อทดสอบโดยใช้เอกสารประกอบจาก SwaggerUI

ลบบันทึกฐานข้อมูล

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

วางโค้ดต่อไปนี้ลงในไฟล์ main.py ของคุณ:

 # main.py from uuid import UUID from fastapi HTTPException @app.delete("/api/v1/users/{id}") async def delete_user(id: UUID): for user in db: if user.id == id: db.remove(user) return raise HTTPException( status_code=404, detail=f"Delete user failed, id {id} not found." )

นี่คือรายละเอียดทีละบรรทัดของวิธีการทำงานของรหัสนั้น:

• @app.delete("/api/v1/users/{id}") : คุณสร้างปลายทางการลบโดยใช้ @app.delete() มัณฑนากร เส้นทางยังคงเป็น /api/v1/users/{id} แต่จากนั้นจะดึงข้อมูล id ซึ่งเป็นตัวแปรเส้นทางที่สอดคล้องกับรหัสของผู้ใช้
• async def delete_user(id: UUID): : สร้างฟังก์ชัน delete_user ซึ่งดึง id จาก URL
• for user in db: : สิ่งนี้บอกให้แอปวนซ้ำผู้ใช้ในฐานข้อมูล และตรวจสอบว่า id ที่ส่งผ่านนั้นตรงกับผู้ใช้ในฐานข้อมูลหรือไม่
• db.remove(user) : ถ้า id ตรงกับผู้ใช้ ผู้ใช้นั้นจะถูกลบ; มิฉะนั้น HTTPException ที่มีรหัสสถานะ 404 จะถูกยกขึ้น

อัปเดตบันทึกฐานข้อมูล

คุณกำลังจะสร้างจุดสิ้นสุดเพื่ออัปเดตรายละเอียดของผู้ใช้ รายละเอียดที่สามารถอัพเดตได้ประกอบด้วยพารามิเตอร์ต่อไปนี้: first_name , last_name และ roles

ในไฟล์ models.py ให้วางโค้ดต่อไปนี้ใต้ User model ของคุณ ซึ่งอยู่หลัง User(BaseModel): class:

 # models.py class UpdateUser(BaseModel): first_name: Optional[str] last_name: Optional[str] roles: Optional[List[Role]]

ในโค้ดนี้ คลาส UpdateUser ขยาย BaseModel จากนั้น คุณตั้งค่าพารามิเตอร์ผู้ใช้ที่อัปเดตได้ เช่น first_name , last_name และ roles ให้เป็นทางเลือก

ตอนนี้ คุณจะสร้างจุดสิ้นสุดเพื่ออัปเดตรายละเอียดของผู้ใช้รายใดรายหนึ่ง ในไฟล์ main.py ให้วางโค้ดต่อไปนี้ต่อท้าย @app.delete decorator:

 # main.py @app.put("/api/v1/users/{id}") async def update_user(user_update: UpdateUser, id: UUID): for user in db: if user.id == id: if user_update.first_name is not None: user.first_name = user_update.first_name if user_update.last_name is not None: user.last_name = user_update.last_name if user_update.roles is not None: user.roles = user_update.roles return user.id raise HTTPException(status_code=404, detail=f"Could not find user with id: {id}")

ในโค้ดด้านบน คุณได้ทำสิ่งต่อไปนี้แล้ว:

• สร้าง @app.put("/api/v1/users/{id}") จุดสิ้นสุดการอัปเดต มี id พารามิเตอร์ตัวแปรที่สอดคล้องกับรหัสของผู้ใช้
• สร้างเมธอดชื่อ update_user ซึ่งใช้ในคลาส UpdateUser และ id
• ใช้ for วนซ้ำเพื่อตรวจสอบว่าผู้ใช้ที่เชื่อมโยงกับ id ที่ส่งผ่านนั้นอยู่ในฐานข้อมูลหรือไม่
• ตรวจสอบว่าพารามิเตอร์ของผู้ใช้ is not None (ไม่ใช่ค่าว่าง) หากพารามิเตอร์ใดๆ เช่น first_name , last_name หรือ roles ไม่เป็น null แสดงว่าพารามิเตอร์นั้นถูกอัพเดต
• หากดำเนินการสำเร็จ รหัสผู้ใช้จะถูกส่งคืน
• หากไม่พบผู้ใช้ ข้อยกเว้น HTTPException ที่มีรหัสสถานะ 404 และข้อความ Could not find user with id: {id} จะปรากฏขึ้น

หากต้องการทดสอบตำแหน่งข้อมูลนี้ ตรวจสอบให้แน่ใจว่าเซิร์ฟเวอร์ Uvicorn ของคุณทำงานอยู่ หากไม่ได้รัน ให้ป้อนคำสั่งนี้:

 uvicorn main:app --reload

ด้านล่างนี้เป็นภาพหน้าจอของการทดสอบ

ดูวิธีที่ FastAPI สามารถลดข้อบกพร่องที่เกิดจากมนุษย์ได้ถึง 40 เปอร์เซ็นต์ เริ่มต้นที่นี่: คลิกเพื่อทวีต

สรุป

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

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