קוראים כמוך עוזרים לתמוך ב-MUO. כאשר אתה מבצע רכישה באמצעות קישורים באתר שלנו, אנו עשויים להרוויח עמלת שותף. קרא עוד.

בניית ממשק API של REST היא לרוב משימה מכנית, הכוללת הרבה עיצוב לוחות ותכנות. למרבה המזל, כלים כמו FastAPI יכולים להקל על הרבה מהפרטים המייגעים.

באמצעות FastAPI, אתה יכול לבנות במהירות REST API יעיל ושלם עבור יישום ה-CRUD שלך. עם MongoDB כמקור הנתונים, מדריך זה ידריך אותך להגדרת API משלך תוך זמן קצר.

מה זה FastAPI?

FastAPI היא מסגרת אינטרנט מהירה ופתוח של Python לבניית ממשקי API. הוא מספק תמיכה מובנית לבקשות אסינכרוניות, אימות אוטומטי של נתונים ותיעוד אוטומטי של נקודות קצה API.

היתרונות של FastAPI על פני מסגרות Python אחרות

  • FastAPI מהיר יותר יחסית ממסגרות אחרות כמו Django ו-Flask. הסיבה לכך היא ש-FastAPI בונה על גבי asyncio, ספריית I/O אסינכרונית עבור Python שיכולה לעבד בקשות במקביל מהר יותר.
  • FastAPI מספק דרך נקייה ופשוטה לבנות ממשקי API במינימום מאמץ מכיוון שהוא דורש פחות קוד מאשר Flask או Django.
  • לבסוף, FastAPI מקל על יצירת תיעוד עבור נקודות קצה. הוא משתמש ב-Swagger כדי לייצר תיעוד שתוכל להשתמש בו כדי לבדוק נקודות קצה על ידי הפעלת בקשות וצפייה בתגובות.
instagram viewer

הגדר מסד נתונים של MongoDB

כדי להתחיל, תצטרך הגדר את מסד הנתונים של MongoDB באופן מקומי. לחלופין, אתה יכול לבחור באפשרות הקלה יותר של הגדרת אשכול MongoDB בענן.

לאחר מכן, באמצעות כלי ממשק המשתמש הגרפי המותקן MongoDB, Compass, צור חיבור למסד נתונים. לחץ על חיבור חדש לחצן ולספק את ה-URI לחיבור כדי ליצור חיבור עם שרת MongoDB הפועל באופן מקומי.

לבסוף, צור מסד נתונים ואוסף חדש כדי להחזיק את נתוני ה-API שלך לבדיקה.

הגדר שרת FastAPI

באמצעות מסוף, צור תיקיית פרויקט והזן את הספרייה החדשה.

אתה יכול למצוא את הקוד של הפרויקט הזה בו מאגר GitHub.

לאחר מכן, בדוק אם אתה מפעיל את Python גרסה 3.6+. אם לא, התקן את הגרסה העדכנית ביותר פִּיתוֹן גִרְסָה.

פיתון --גרסה

לאחר מכן, התקן את Virtualenv כדי ליצור סביבת פיתוח וירטואלית מבודדת. זה מומלץ מאוד כי זה מאפשר לך למנוע התנגשויות, במיוחד אם אתה משתמש בגרסאות שונות של חבילות עבור פרויקטים שונים.

pip להתקין virtualenv

לאחר מכן, צור סביבה וירטואלית בשם "venv" בתוך הספרייה הנוכחית שלך:

virtualenv venv

לבסוף, הפעל את הסביבה הוירטואלית.

# ב-Unix או MacOS: 
מקור venv/bin/activate
# בווינדוס:
 .\venv\Scripts\להפעיל

לאחר שהגדרת את הסביבה הוירטואלית, התקן את חבילות FastAPI, PyMongo ו-Uvicorn.

pip להתקין fastapi pymongo uvicorn

PyMongo היא ספרייה מבוססת Python לעבודה עם מסד הנתונים MongoDB. הוא מספק API שתומך בכל התכונות של MongoDB ומאפשר לך ליצור אינטראקציה עם MongoDB מבלי שתצטרך לכתוב שאילתות MongoDB גולמיות.

Uvicorn, לעומת זאת, הוא שרת אינטרנט אסינכרוני המבוסס על מודול Python asyncio. התכונה העיקרית שלו היא טעינה חמה מחדש של שרתי FastAPI שלך תוך כדי תנועה. שימוש ב-Uvicorn, דומה ל עבודה עם Nodemon.

צור את שרת FastAPI

לבסוף, צור שרת FastAPI פשוט שמאזין לקבל בקשות המגיעות מהמסלול הביתי. בספריית השורש של תיקיית הפרויקט שלך, צור קובץ server.py והוסף את הקוד למטה.

מ fastapi יְבוּא FastAPI
app = FastAPI()
@app.get("/")
אסינכרוןdefבית():
לַחֲזוֹר {"הוֹדָעָה": "שלום עולם"}

לבסוף, הפעל את הפקודה למטה כדי לסובב את שרת הפיתוח. Uvicorn ישרת את האפליקציה שלך ביציאה 8000.

שרת uvicon: app --טען מחדש

קדימה וצפה בתגובת השרת בדפדפן שלך בכתובת http://localhost: 8000.

צור את REST API עם פעולות CRUD

כעת בנה את REST API המיישם את שיטות ה-CRUD (יצירה, קריאה, עדכון ומחק). בספריית השורש של תיקיית הפרויקט שלך, צור ארבע תיקיות: תצורה, מודלים, מסלולים וסכימות.

├── תצורה
├── דגמים
├── מסלולים
├── סכימות
└── server.py

1. הגדר את חיבור מסד הנתונים

בספריית התצורה, צור קובץ חדש, db.py, והוסף את הקוד למטה.

מ pymongo יְבוּא MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_connection.database_name
אוסף = db["שם_אוסף"]
  • השתמש בשיטת MongoClient() כדי ליצור חיבור למסד נתונים MongoDB. הוא מקבל מחרוזת URI של חיבור כארגומנט המציין את המארח והיציאה של שרת MongoDB.
  • שני המשתנים מציינים לאיזה מסד נתונים ואוסף בשרת MongoDB שלך השרת צריך לגשת.

2. הגדר מודל נתונים

מודל זה יגדיר את מבנה הנתונים שלך במסד הנתונים כולל השדות וסוגי הנתונים.

בספריית המודלים, צור קובץ חדש, user_model.py, והוסף את הקוד למטה.

מ פידנטי יְבוּא דגם בסיס 
מעמדמִשׁתַמֵשׁ(BaseModel):
 שם: str
 תפקיד: str
  • הקוד שלמעלה יוצר מחלקה בשם User, שהיא תת מחלקה של המחלקה BaseModel מספריית Pydantic. למחלקה User יש שני שדות, שם ותפקיד כאשר סוגי הנתונים שלהם מוגדרים למחרוזות.
  • אתה יכול להשתמש בספריית Pydantic עם FastAPI כדי ליצור מודלים של נתונים. אתה יכול גם להשתמש בו כדי לאמת נתונים, לעשות אותם בסידרה (JSON ל-Python), ולבטל אותם בסידרה (Python ל-JSON).

3. הגדר סכמת נתונים

ממודל הנתונים שנוצר, אתה יכול להגדיר את הסכימה עבור הנתונים שלך. בספריית הסכמות, צור קובץ חדש: user_schema.py, והוסף את הקוד למטה.

defuser_serializer(מִשׁתַמֵשׁ) -> הכתב:
לַחֲזוֹר {
'תְעוּדַת זֶהוּת':str (משתמש["_תְעוּדַת זֶהוּת"]),
'שֵׁם':מִשׁתַמֵשׁ["שֵׁם"],
'תַפְקִיד':מִשׁתַמֵשׁ["תַפְקִיד"]
 }
defusers_serializer(משתמשים) -> רשימה:
לַחֲזוֹר [user_serializer (משתמש) ל מִשׁתַמֵשׁ ב משתמשים]

4. הגדר את נתיבי ה-API

לבסוף, הגדר את המסלולים עבור פעולות ה-CRUD השונות.

בספריית המסלולים, צור קובץ חדש: user_routes.py, והוסף את הקוד למטה.

הוסף נתונים בשיטת הפוסט

צור את מסלול הפוסט כדי להוסיף נתונים.

מ fastapi יְבוּא APIRouter
מ models.user_model יְבוּא מִשׁתַמֵשׁ
מ schemas.user_schema יְבוּא users_serializer
מ bson יְבוּא ObjectId
מ config.db יְבוּא אוסף
משתמש = APIRouter()
@user.post("/")
אסינכרוןdefצור משתמש(משתמש: משתמש):
 _id = collection.insert_one (dict (משתמש))
 user = users_serializer (collection.find({"_תְעוּדַת זֶהוּת": _id.inserted_id}))
לַחֲזוֹר {"סטָטוּס": "בסדר","נתונים": משתמש}
  • FastAPI מספקת את שיטת APIRouter() המגדירה אובייקט נתב המספק ממשק לביצוע בקשות API לשרת.
  • ציין מסלול פרסום שיוצר אובייקט משתמש חדש במסד הנתונים על ידי הכנסת הנתונים לאוסף לאחר סידורו. לאחר מכן, אחסן והעביר את inserted_id כדי למצוא את הנתונים המשויכים באוסף, ולבסוף, החזר סטטוס של "Ok" עם הנתונים בתגובה, אם בקשת הפוסט הצליחה.
  • שיטות insert_one ו-find מוגדרות על ידי הלקוח PyMongo.

כעת, הוסף את הקוד למטה ל-server.py כדי לאתחל את המסלולים.

מ routes.user_routes יְבוּא מִשׁתַמֵשׁ
app.include_router (משתמש)

קדימה, בדוק את מסלול הפרסום בדפדפן שלך באמצעות הכלי Swagger UI API המסופק על ידי FastAPI.

קרא נתונים בשיטת Get

לאחר הגדרת מסלול הפוסט ואתחול המסלולים, הגדירו את שאר המסלולים האחרים.

@user.get("/")
אסינכרוןdeffind_all_users():
 users = users_serializer (collection.find())
לַחֲזוֹר {"סטָטוּס": "בסדר","נתונים": משתמשים}

@user.get("/{id}")
אסינכרוןdefקבל_משתמש_אחד(מזהה: str):
 user = users_serializer (collection.find({"_תְעוּדַת זֶהוּת": ObjectId (id)}))
לַחֲזוֹר {"סטָטוּס": "בסדר","נתונים": משתמש}

הגדירו שני מסלולי גט המאחזרים את כל הנתונים באוסף ומחזירים נתונים ספציפיים מהאוסף על סמך המזהה.

עדכן נתונים בשיטת Put

צור את נתיב ה-put כדי לעדכן את הנתונים המאוחסנים במסד הנתונים.

@user.put("/{id}")
אסינכרוןdefupdate_user(מזהה: str, משתמש: משתמש):
 collection.find_one_and_update(
 {
"_תְעוּדַת זֶהוּת": ObjectId (מזהה)
 }, 
 {
"$set": dict (משתמש)
 })
 user = users_serializer (collection.find({"_תְעוּדַת זֶהוּת": ObjectId (id)}))
לַחֲזוֹר {"סטָטוּס": "בסדר","נתונים": משתמש}

שיטת ה-put משתמשת במזהה כדי למצוא את הנתונים הספציפיים באוסף ומעדכנת את הערך של השדות במסמך עם הנתונים החדשים המועברים מה-API. לאחר מכן תוכל לחפש את הנתונים המעודכנים לפי מזהה ולהחזיר אותם בתגובת ה-API.

מחק נתונים בשיטת המחיקה

צור את מסלול המחיקה כדי למחוק את הנתונים המאוחסנים במסד הנתונים.

@user.delete("/{id}")
אסינכרוןdefמחק משתמש(מזהה: str):
 collection.find_one_and_delete({"_תְעוּדַת זֶהוּת": ObjectId (id)})
 users = users_serializer (collection.find())
לַחֲזוֹר {"סטָטוּס": "בסדר","נתונים": []}

מסלול המחיקה לוקח את המזהה של המסמך הספציפי שברצונך למחוק מהאוסף.

צור ממשקי API של REST עם FastAPI

FastAPI מספק דרך מצוינת לבנייה נוחה של ממשקי API של Python אינטרנט. הכלים המובנים שלו לאינטגרציה של מסדי נתונים וייצור API אוטומטי הופכים את התהליך לפשוט.

אתה יכול אפילו לקחת את זה צעד קדימה ולבנות אפליקציות מהותיות. נסה לשלב לקוח חזיתי באמצעות טכנולוגיות פופולריות כמו React, Angular או Vue.