A hozzád hasonló olvasók támogatják a MUO-t. Amikor a webhelyünkön található linkek használatával vásárol, társult jutalékot kaphatunk. Olvass tovább.

A REST API felépítése gyakran mechanikus feladat, amely sok alaprajzi tervezést és gyors programozást foglal magában. Szerencsére az olyan eszközök, mint a FastAPI, sok fárasztó részletet enyhíthetnek.

A FastAPI használatával gyorsan létrehozhat egy hatékony, teljes REST API-t a CRUD alkalmazásához. A MongoDB adatforrásként ez az oktatóanyag elvezeti Önt a saját API gyors beállításához.

Mi az a FastAPI?

FastAPI egy gyors és nyílt forráskódú Python webes keretrendszer API-k építésére. Beépített támogatást biztosít az aszinkron kérésekhez, az adatok automatikus ellenőrzéséhez és az API-végpontok automatikus dokumentálásához.

A FastAPI előnyei más Python-keretrendszerekkel szemben

  • A FastAPI viszonylag gyorsabb, mint más keretrendszerek, például a Django és a Flask. Ennek az az oka, hogy a FastAPI az asynciora épül, egy aszinkron I/O-könyvtárra a Python számára, amely gyorsabban képes feldolgozni az egyidejű kéréseket.
  • A FastAPI tiszta és egyszerű módot biztosít az API-k minimális erőfeszítéssel történő létrehozására, mivel kevesebb kódot igényel, mint a Flask vagy a Django.
  • Végül a FastAPI megkönnyíti a végpontok dokumentációjának létrehozását. A Swagger segítségével olyan dokumentációt állít elő, amelyet a végpontok tesztelésére használhat kérések futtatásával és válaszok megtekintésével.

MongoDB adatbázis beállítása

A kezdéshez meg kell tennie állítsa be helyben a MongoDB adatbázist. Alternatív megoldásként választhatja a könnyebbik opciót is MongoDB-fürt létrehozása a felhőben.

Ezután a telepített MongoDB grafikus felhasználói felület eszköz, a Compass segítségével hozzon létre egy adatbázis-kapcsolatot. Kattints a Új kapcsolat gombot, és adja meg a kapcsolat URI-jét a helyileg futó MongoDB kiszolgálóval való kapcsolat létrehozásához.

Végül hozzon létre egy új adatbázist és gyűjteményt a teszt API-adatok tárolására.

FastAPI szerver beállítása

Terminál használatával hozzon létre egy projektmappát, és lépjen be az új könyvtárba.

A projekt kódja megtalálható benne GitHub adattár.

Ezután ellenőrizze, hogy a Python 3.6-os vagy újabb verziója fut-e. Ha nem, telepítse a legújabbat Piton változat.

python --verzió

Ezután telepítse a Virtualenv-t egy elszigetelt virtuális fejlesztői környezet létrehozásához. Ez erősen ajánlott, mert lehetővé teszi az ütközések elkerülését, különösen akkor, ha a különböző projektekhez különböző csomagverziókat használ.

pip install virtualenv

Ezután hozzon létre egy "venv" nevű virtuális környezetet az aktuális könyvtárban:

virtualenv venv

Végül aktiválja a virtuális környezetet.

# Unix vagy MacOS rendszeren: 
forrás venv/bin/activate
# Windows rendszeren:
 .\venv\Scripts\activate

Miután konfigurálta a virtuális környezetet, telepítse a FastAPI, PyMongo és Uvicorn csomagokat.

pip install fastapi pymongo uvicorn

A PyMongo egy Python-alapú könyvtár a MongoDB adatbázissal való együttműködéshez. Olyan API-t biztosít, amely támogatja a MongoDB összes funkcióját, és lehetővé teszi a MongoDB-vel való interakciót anélkül, hogy nyers MongoDB-lekérdezéseket kellene írnia.

Az Uvicorn viszont a Python asyncio modulon alapuló aszinkron webszerver. Fő funkciója a FastAPI-kiszolgálók gyors újratöltése útközben. Az Uvicorn használata hasonló a dolgozik a Nodemonnal.

Hozd létre a FastAPI szervert

Végül hozzon létre egy egyszerű FastAPI-kiszolgálót, amely figyeli az otthoni útvonalról érkező kéréseket. A projektmappa gyökérkönyvtárában hozzon létre egy server.py fájlt, és adja hozzá az alábbi kódot.

tól től fastapi import FastAPI
alkalmazás = FastAPI()
@app.get("/")
asyncdefitthon():
Visszatérés {"üzenet": "Helló Világ"}

Végül futtassa az alábbi parancsot a fejlesztői kiszolgáló felpörgetéséhez. Az Uvicorn a 8000-es porton fogja kiszolgálni az alkalmazást.

uvicon szerver: app --reload

Tekintse meg a szerver válaszát a böngészőjében a következő címen: http://localhost: 8000.

Hozza létre a REST API-t a CRUD műveletekkel

Most készítse el a REST API-t, amely megvalósítja a CRUD metódusokat (létrehozás, olvasás, frissítés és törlés). A projektmappa gyökérkönyvtárában hozzon létre négy mappát: konfiguráció, modellek, útvonalak és sémák.

├── konfig
├── modellek
├── útvonalak
├── sémák
└── server.py

1. Állítsa be az adatbázis-kapcsolatot

A konfigurációs könyvtárban hozzon létre egy új db.py fájlt, és adja hozzá az alábbi kódot.

tól től pymongo import MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_kapcsolat.adatbázis_neve
gyűjtemény = db["gyűjtemény_neve"]
  • A MongoClient() metódus használatával hozzon létre kapcsolatot egy MongoDB adatbázissal. A csatlakozási URI karakterláncot veszi fel argumentumként, amely megadja a MongoDB kiszolgáló gazdagépét és portját.
  • A két változó határozza meg, hogy a MongoDB-kiszolgálón melyik adatbázishoz és gyűjteményhez kell hozzáférnie a szervernek.

2. Határozzon meg egy adatmodellt

Ez a modell határozza meg az adatok szerkezetét az adatbázisban, beleértve a mezőket és az adattípusokat.

A modellkönyvtárban hozzon létre egy új user_model.py fájlt, és adja hozzá az alábbi kódot.

tól től pydantikus import BaseModel 
osztályFelhasználó(Alapmodell):
 név: str
 szerepe: str
  • A fenti kód létrehoz egy User nevű osztályt, amely a Pydantic könyvtár BaseModel osztályának alosztálya. A User osztálynak két mezője van, a név és a szerep, amelyek adattípusai karakterláncokra vannak beállítva.
  • Adatmodellek létrehozásához használhatja a Pydantic könyvtárat a FastAPI-val. Használhatja az adatok érvényesítésére, szerializálására (JSON-ról Python-ra) és deszerializálására (Python-JSON-ra).

3. Adjon meg egy adatsémát

A létrehozott adatmodellből meghatározhatja az adatok sémáját. A sémák könyvtárában hozzon létre egy új fájlt: user_schema.py, és adja hozzá az alábbi kódot.

defuser_serializer(felhasználó) -> diktál:
Visszatérés {
"azonosító":str (felhasználó["_id"]),
'név':felhasználó["név"],
'szerep':felhasználó["szerep"]
 }
defuser_serializer(felhasználók) -> lista:
Visszatérés [user_serializer (felhasználó) számára felhasználó ban ben felhasználók]

4. Határozza meg az API-útvonalakat

Végül határozza meg a különböző CRUD műveletek útvonalait.

Az útvonalak könyvtárban hozzon létre egy új fájlt: user_routes.py, és adja hozzá az alábbi kódot.

Adatok hozzáadása a feladási módszerrel

Hozza létre a bejegyzés útvonalát az adatok hozzáadásához.

tól től fastapi import APIRouter
tól től modellek.felhasználói_modell import Felhasználó
tól től schemas.user_schema import user_serializer
tól től bson import ObjectId
tól től config.db import Gyűjtemény
user = APIRouter()
@user.post("/")
asyncdeffelhasználó létrehozása(felhasználó: Felhasználó):
 _id = collection.insert_one (dict (felhasználó))
 user = user_serializer (collection.find({"_id": _id.inserted_id}))
Visszatérés {"állapot": "Rendben","adat": felhasználó}
  • A FastAPI biztosítja az APIRouter() metódust, amely definiál egy útválasztó objektumot, amely interfészt biztosít az API-kérések kiszolgáló felé történő küldéséhez.
  • Adjon meg egy bejegyzési útvonalat, amely új felhasználói objektumot hoz létre az adatbázisban az adatok beszúrásával a gyűjteménybe a szerializálás után. Ezután tárolja és adja át az inserted_id értéket, hogy megtalálja a társított adatokat a gyűjteményben, és végül adjon „Ok” állapotot a válaszban szereplő adatokkal, ha a közzétételi kérelem sikeres.
  • Az insert_one és find metódusokat a PyMongo kliens határozza meg.

Most adja hozzá az alábbi kódot a server.py fájlhoz az útvonalak inicializálásához.

tól től routes.user_routes import felhasználó
app.include_router (felhasználó)

Tesztelje a közzétételi útvonalat böngészőjében a FastAPI által biztosított Swagger UI API eszközzel.

Adatok olvasása a Get Methoddal

A postai útvonal meghatározása és az útvonalak inicializálása után határozza meg a többi útvonalat.

@user.get("/")
asyncdeffind_all_users():
 userek = user_serializer (collection.find())
Visszatérés {"állapot": "Rendben","adat": felhasználók}

@user.get("/{id}")
asyncdefget_one_user(azonosító: str):
 user = user_serializer (collection.find({"_id": ObjectId (id)}))
Visszatérés {"állapot": "Rendben","adat": felhasználó}

Határozzon meg két lekérési útvonalat, amelyek a gyűjteményben lévő összes adatot lekérik, és az azonosító alapján meghatározott adatokat kérnek le a gyűjteményből.

Frissítse az adatokat az eladási módszerrel

Hozzon létre egy put útvonalat az adatbázisban tárolt adatok frissítéséhez.

@user.put("/{id}")
asyncdefupdate_user(azonosító: str, felhasználó: Felhasználó):
 collection.find_one_and_update(
 {
"_id": ObjectId (id)
 }, 
 {
"$set": diktál (felhasználó)
 })
 user = user_serializer (collection.find({"_id": ObjectId (id)}))
Visszatérés {"állapot": "Rendben","adat": felhasználó}

A put metódus az azonosító segítségével keresi meg a gyűjteményben lévő konkrét adatokat, és frissíti a dokumentum mezőinek értékét az API-tól átadott új adatokkal. Ezután azonosító alapján megkeresheti a frissített adatokat, és visszaküldheti az API-válaszban.

Adatok törlése a törlési módszerrel

Hozza létre a törlési útvonalat az adatbázisban tárolt adatok törléséhez.

@user.delete("/{id}")
asyncdefdelete_user(azonosító: str):
 collection.find_one_and_delete({"_id": ObjectId (id)})
 userek = user_serializer (collection.find())
Visszatérés {"állapot": "Rendben","adat": []}

A törlési útvonal felveszi annak a dokumentumnak az azonosítóját, amelyet törölni szeretne a gyűjteményből.

Hozzon létre REST API-kat a FastAPI segítségével

A FastAPI nagyszerű lehetőséget kínál a Python webes API-k háttérbeli kényelmes felépítésére. Az adatbázis-integrációhoz és az automatikus API-gyártáshoz beépített eszközei egyszerűvé teszik a folyamatot.

Még egy lépéssel tovább is léphet, és teljes értékű alkalmazásokat készíthet. Próbáljon meg integrálni egy front-end klienst olyan népszerű technológiákkal, mint a React, Angular vagy Vue.