Čitatelia ako vy pomáhajú podporovať MUO. Keď uskutočníte nákup pomocou odkazov na našej stránke, môžeme získať pridruženú províziu. Čítaj viac.

Vytvorenie REST API je často mechanická úloha, ktorá zahŕňa množstvo štandardných návrhov a programovania naspamäť. Našťastie nástroje ako FastAPI dokážu odľahčiť veľa únavných detailov.

Pomocou FastAPI môžete rýchlo vytvoriť efektívne a kompletné REST API pre vašu aplikáciu CRUD. S MongoDB ako zdrojom údajov vás tento tutoriál okamžite prevedie nastavením vlastného API.

Čo je FastAPI?

FastAPI je rýchly a open-source webový rámec Pythonu na vytváranie API. Poskytuje vstavanú podporu pre asynchrónne požiadavky, automatickú validáciu údajov a automatickú dokumentáciu koncových bodov API.

Výhody FastAPI oproti iným rámcom Pythonu

  • FastAPI je relatívne rýchlejší ako iné rámce ako Django a Flask. Je to preto, že FastAPI stavia na asyncio, asynchrónnej I/O knižnici pre Python, ktorá dokáže rýchlejšie spracovať súbežné požiadavky.
  • FastAPI poskytuje čistý a jednoduchý spôsob vytvárania API s minimálnym úsilím, pretože vyžaduje menej kódu ako Flask alebo Django.
    instagram viewer
  • A nakoniec, FastAPI uľahčuje vytváranie dokumentácie pre koncové body. Používa Swagger na vytváranie dokumentácie, ktorú môžete použiť na testovanie koncových bodov spúšťaním požiadaviek a prezeraním odpovedí.

Nastavte databázu MongoDB

Ak chcete začať, budete musieť lokálne nastaviť databázu MongoDB. Prípadne sa môžete rozhodnúť pre jednoduchšiu možnosť nastavenie klastra MongoDB v cloude.

Potom pomocou nainštalovaného nástroja grafického používateľského rozhrania MongoDB, Compass, vytvorte pripojenie k databáze. Kliknite na Nové pripojenie a poskytnite URI pripojenia na vytvorenie spojenia so serverom MongoDB spusteným lokálne.

Nakoniec vytvorte novú databázu a kolekciu na uchovávanie údajov testovacieho rozhrania API.

Nastavte FastAPI Server

Pomocou terminálu vytvorte priečinok projektu a zadajte tento nový adresár.

Kód tohto projektu nájdete v ňom úložisko GitHub.

Ďalej skontrolujte, či používate Python verzie 3.6+. Ak nie, nainštalujte najnovšiu verziu Python verzia.

python --verzia

Potom nainštalujte Virtualenv a vytvorte izolované virtuálne vývojové prostredie. Dôrazne sa to odporúča, pretože vám to umožňuje vyhnúť sa konfliktom, najmä ak používate rôzne verzie balíkov pre rôzne projekty.

pip install virtualenv

Ďalej vytvorte virtuálne prostredie s názvom „venv“ vo svojom aktuálnom adresári:

virtualenv venv

Nakoniec aktivujte virtuálne prostredie.

# V systéme Unix alebo MacOS: 
zdroj venv/bin/activate
# V systéme Windows:
 .\venv\Scripts\activate

Po nakonfigurovaní virtuálneho prostredia nainštalujte balíky FastAPI, PyMongo a Uvicorn.

pip install fastapi pymongo uvicorn

PyMongo je knižnica založená na Pythone na prácu s databázou MongoDB. Poskytuje rozhranie API, ktoré podporuje všetky funkcie MongoDB a umožňuje vám komunikovať s MongoDB bez toho, aby ste museli písať nespracované dotazy MongoDB.

Na druhej strane Uvicorn je asynchrónny webový server založený na module Python asyncio. Jeho hlavnou funkciou je rýchle opätovné načítanie vašich serverov FastAPI na cestách. Používanie Uvicorn je podobné práca s Nodemonom.

Vytvorte FastAPI Server

Nakoniec vytvorte jednoduchý server FastAPI, ktorý počúva požiadavky prichádzajúce z domácej trasy. V koreňovom adresári priečinka projektu vytvorte súbor server.py a pridajte nižšie uvedený kód.

od fastapi importovať FastAPI
aplikácia = FastAPI()
@app.get("/")
asyncdefDomov():
vrátiť {"správa": "Ahoj svet"}

Nakoniec spustite príkaz uvedený nižšie, čím spustíte vývojový server. Uvicorn bude slúžiť vašej aplikácii na porte 8000.

uvicon server: app --reload

Pokračujte a zobrazte odpoveď servera vo svojom prehliadači na adrese http://localhost: 8000.

Vytvorte REST API pomocou operácií CRUD

Teraz vytvorte REST API, ktoré implementuje metódy CRUD (vytvoriť, prečítať, aktualizovať a odstrániť). V koreňovom adresári priečinka projektu vytvorte štyri priečinky: config, models, routes a schémy.

├── konfigurácia
├── modely
├── trasy
├── schémy
└── server.py

1. Nakonfigurujte pripojenie k databáze

V adresári config vytvorte nový súbor db.py a pridajte kód uvedený nižšie.

od pymongo importovať MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = pripojenie_db.názov_databázy
zbierka = db["názov_kolekcie"]
  • Pomocou metódy MongoClient() vytvorte pripojenie k databáze MongoDB. Preberá reťazec URI pripojenia ako argument, ktorý určuje hostiteľa a port servera MongoDB.
  • Tieto dve premenné určujú, ku ktorej databáze a kolekcii na vašom serveri MongoDB má server pristupovať.

2. Definujte dátový model

Tento model bude definovať štruktúru vašich údajov v databáze vrátane polí a typov údajov.

V adresári modelu vytvorte nový súbor user_model.py a pridajte kód uvedený nižšie.

od pydantický importovať BaseModel 
triedaPoužívateľ(Základný model):
 meno: str
 rola: str
  • Vyššie uvedený kód vytvára triedu s názvom User, ktorá je podtriedou triedy BaseModel z knižnice Pydantic. Trieda User má dve polia, názov a rolu s ich dátovými typmi nastavenými na reťazce.
  • Na vytváranie dátových modelov môžete použiť knižnicu Pydantic s FastAPI. Môžete ho tiež použiť na overenie údajov, ich serializáciu (JSON na Python) a zrušenie serializácie (Python na JSON).

3. Definujte dátovú schému

Z vytvoreného dátového modelu môžete definovať schému pre vaše dáta. V adresári schém vytvorte nový súbor: user_schema.py a pridajte kód uvedený nižšie.

defuser_serializer(používateľ) -> diktovať:
vrátiť {
'id':str (používateľ["_id"]),
'názov':user["názov"],
'rola':user["rola"]
 }
defusers_serializer(používatelia) -> zoznam:
vrátiť [user_serializer (používateľ) pre užívateľ v používatelia]

4. Definujte trasy API

Nakoniec definujte cesty pre rôzne operácie CRUD.

V adresári routes vytvorte nový súbor: user_routes.py a pridajte nižšie uvedený kód.

Pridajte údaje pomocou metódy Post

Vytvorte trasu príspevku na pridanie údajov.

od fastapi importovať APIRouter
od models.user_model importovať Používateľ
od schemas.user_schema importovať users_serializer
od bson importovať ObjectId
od config.db importovať zber
užívateľ = APIRouter()
@user.post("/")
asyncdefcreate_user(používateľ: Používateľ):
 _id = collection.insert_one (diktovať (používateľ))
 user = users_serializer (collection.find({"_id": _id.inserted_id}))
vrátiť {"postavenie": "ok","údaje": používateľ}
  • FastAPI poskytuje metódu APIRouter(), ktorá definuje objekt smerovača, ktorý poskytuje rozhranie na odosielanie požiadaviek API na server.
  • Zadajte trasu príspevku, ktorá vytvorí nový objekt používateľa v databáze vložením údajov do kolekcie po jej serializácii. Potom uložte a odovzdajte vložené_id, aby ste našli pridružené údaje v kolekcii, a nakoniec vráťte stav „OK“ s údajmi v odpovedi, ak je žiadosť o príspevok úspešná.
  • Metódy insert_one a find sú definované klientom PyMongo.

Teraz pridajte nižšie uvedený kód do server.py na inicializáciu trás.

od routes.user_routes importovať užívateľ
app.include_router (používateľ)

Pokračujte a otestujte si cestu odosielania vo svojom prehliadači pomocou nástroja Swagger UI API, ktorý poskytuje FastAPI.

Čítanie údajov pomocou metódy Get

Po definovaní poštovej trasy a inicializácii trás definujte zvyšok ostatných trás.

@user.get("/")
asyncdefnájsť_všetkých_používateľov():
 users = users_serializer (collection.find())
vrátiť {"postavenie": "ok","údaje": používatelia}

@user.get("/{id}")
asyncdefget_one_user(id: str):
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
vrátiť {"postavenie": "ok","údaje": používateľ}

Definujte dve trasy získavania, ktoré získavajú všetky údaje v kolekcii a získavajú špecifické údaje z kolekcie na základe ID.

Aktualizujte údaje pomocou metódy Put

Vytvorte put route na aktualizáciu uložených údajov v databáze.

@user.put("/{id}")
asyncdefupdate_user(id: str, user: User):
 collection.find_one_and_update(
 {
"_id": ObjectId (id)
 }, 
 {
"$set": dict (používateľ)
 })
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
vrátiť {"postavenie": "ok","údaje": používateľ}

Metóda put používa ID na nájdenie konkrétnych údajov v kolekcii a aktualizuje hodnoty polí v dokumente novými údajmi odovzdanými z rozhrania API. Potom môžete vyhľadať aktualizované údaje podľa ID a vrátiť ich v odpovedi API.

Vymažte údaje pomocou metódy vymazania

Vytvorte cestu odstránenia na vymazanie údajov uložených v databáze.

@user.delete("/{id}")
asyncdefdelete_user(id: str):
 collection.find_one_and_delete({"_id": ObjectId (id)})
 users = users_serializer (collection.find())
vrátiť {"postavenie": "ok","údaje": []}

Cesta odstránenia prevezme ID konkrétneho dokumentu, ktorý chcete vymazať z kolekcie.

Vytvorte REST API s FastAPI

FastAPI poskytuje skvelý spôsob, ako pohodlne vytvárať backendové webové rozhrania API Pythonu. Jeho vstavané nástroje na integráciu databáz a automatickú produkciu API robia proces jednoduchým.

Môžete to urobiť ešte o krok ďalej a vytvoriť plnohodnotné aplikácie. Skúste integrovať front-end klienta pomocou populárnych technológií ako React, Angular alebo Vue.