Čtenáři jako vy pomáhají podporovat MUO. Když provedete nákup pomocí odkazů na našich stránkách, můžeme získat provizi přidružené společnosti. Přečtěte si více.

Vytváření REST API je často mechanický úkol, který zahrnuje spoustu standardních návrhů a programování nazpaměť. Naštěstí nástroje jako FastAPI mohou ulehčit spoustě únavných detailů.

Pomocí FastAPI můžete rychle vytvořit efektivní, kompletní REST API pro vaši aplikaci CRUD. S MongoDB jako zdrojem dat vás tento výukový program provede během okamžiku nastavením vlastního API.

Co je FastAPI?

FastAPI je rychlý a open-source webový rámec Pythonu pro vytváření API. Poskytuje vestavěnou podporu pro asynchronní požadavky, automatické ověřování dat a automatickou dokumentaci koncových bodů API.

Výhody FastAPI oproti jiným Python Frameworkům

  • FastAPI je relativně rychlejší než jiné frameworky jako Django a Flask. Je to proto, že FastAPI staví na asyncio, asynchronní I/O knihovně pro Python, která dokáže zpracovávat souběžné požadavky rychleji.
    • instagram viewer
  • FastAPI poskytuje čistý a jednoduchý způsob vytváření API s minimálním úsilím, protože vyžaduje méně kódu než Flask nebo Django.
  • A konečně, FastAPI usnadňuje generování dokumentace pro koncové body. Používá Swagger k vytváření dokumentace, kterou můžete použít k testování koncových bodů spouštěním požadavků a prohlížením odpovědí.

Nastavte databázi MongoDB

Chcete-li začít, budete muset lokálně nastavit databázi MongoDB. Případně se můžete rozhodnout pro jednodušší variantu nastavení clusteru MongoDB v cloudu.

Dále pomocí nainstalovaného nástroje grafického uživatelského rozhraní MongoDB, Compass, vytvořte připojení k databázi. Klikněte na Nové připojení a zadejte identifikátor URI připojení pro navázání spojení se serverem MongoDB spuštěným lokálně.

Nakonec vytvořte novou databázi a kolekci, do které budou uložena data testovacího rozhraní API.

Nastavte FastAPI Server

Pomocí terminálu vytvořte složku projektu a zadejte nový adresář.

Kód tohoto projektu najdete v něm úložiště GitHub.

Dále zkontrolujte, zda používáte Python verze 3.6+. Pokud ne, nainstalujte nejnovější Krajta verze.

python --verze

Poté nainstalujte Virtualenv a vytvořte izolované virtuální vývojové prostředí. To je vysoce doporučeno, protože vám to umožní vyhnout se konfliktům, zejména pokud používáte různé verze balíčků pro různé projekty.

pip install virtualenv

Dále vytvořte virtuální prostředí s názvem „venv“ ve vašem aktuálním adresáři:

virtualenv venv

Nakonec aktivujte virtuální prostředí.

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

Jakmile nakonfigurujete virtuální prostředí, nainstalujte balíčky FastAPI, PyMongo a Uvicorn.

pip install fastapi pymongo uvicorn

PyMongo je knihovna založená na Pythonu pro práci s databází MongoDB. Poskytuje rozhraní API, které podporuje všechny funkce MongoDB a umožňuje vám komunikovat s MongoDB, aniž byste museli psát nezpracované dotazy MongoDB.

Na druhé straně Uvicorn je asynchronní webový server založený na modulu Python asyncio. Jeho hlavní funkcí je rychlé opětovné načtení vašich serverů FastAPI na cestách. Použití Uvicorn je podobné práce s Nodemonem.

Vytvořte FastAPI Server

Nakonec vytvořte jednoduchý server FastAPI, který naslouchá požadavkům přicházejícím z domovské trasy. V kořenovém adresáři složky vašeho projektu vytvořte soubor server.py a přidejte níže uvedený kód.

z fastapi import FastAPI
aplikace = FastAPI()
@app.get("/")
asynchronnídefDomov():
vrátit se {"zpráva": "Ahoj světe"}

Nakonec spusťte níže uvedený příkaz a roztočte vývojový server. Uvicorn bude sloužit vaší aplikaci na portu 8000.

uvicon server: app --reload

Pokračujte a zobrazte odpověď serveru ve svém prohlížeči na adrese http://localhost: 8000.

Vytvořte REST API pomocí CRUD Operations

Nyní vytvořte REST API, které implementuje metody CRUD (vytvoření, čtení, aktualizace a odstranění). V kořenovém adresáři složky projektu vytvořte čtyři složky: config, models, routes a schemas.

├── konfigurace
├── modely
├── trasy
├── schémata
└── server.py

1. Nakonfigurujte připojení k databázi

V adresáři config vytvořte nový soubor db.py a přidejte níže uvedený kód.

z pymongo import MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = připojení_db.název_databáze
kolekce = db["název_sbírky"]
  • Pomocí metody MongoClient() vytvořte připojení k databázi MongoDB. Přebírá řetězec URI připojení jako argument, který určuje hostitele a port serveru MongoDB.
  • Tyto dvě proměnné určují, ke které databázi a kolekci na vašem serveru MongoDB má server přistupovat.

2. Definujte datový model

Tento model bude definovat strukturu vašich dat v databázi včetně polí a datových typů.

V adresáři modelu vytvořte nový soubor user_model.py a přidejte níže uvedený kód.

z pydantický import Základní Model 
třídaUživatel(Základní model):
 jméno: str
 role: str
  • Výše uvedený kód vytvoří třídu s názvem User, což je podtřída třídy BaseModel z knihovny Pydantic. Třída User má dvě pole, název a roli s jejich datovými typy nastavenými na řetězce.
  • K vytváření datových modelů můžete použít knihovnu Pydantic s FastAPI. Můžete jej také použít k ověření dat, jejich serializaci (JSON na Python) a de-serializaci (Python na JSON).

3. Definujte datové schéma

Z vytvořeného datového modelu můžete definovat schéma pro svá data. V adresáři schémat vytvořte nový soubor: user_schema.py a přidejte níže uvedený kód.

defuser_serializer(uživatel) -> diktovat:
vrátit se {
'id':str (uživatel["_id"]),
'název':uživatel["název"],
'role':uživatel["role"]
 }
defusers_serializer(uživatelé) -> seznam:
vrátit se [user_serializer (uživatel) pro uživatel v uživatelé]

4. Definujte trasy API

Nakonec definujte cesty pro různé operace CRUD.

V adresáři routes vytvořte nový soubor: user_routes.py a přidejte níže uvedený kód.

Přidejte data pomocí metody Post

Vytvořte trasu příspěvku pro přidání dat.

z fastapi import APIRouter
z modely.uživatelský_model import Uživatel
z schemas.user_schema import users_serializer
z bson import ObjectId
z config.db import sbírka
uživatel = APIRouter()
@user.post("/")
asynchronnídefvytvořit uživatele(uživatel: uživatel):
 _id = collection.insert_one (diktovat (uživatel))
 user = users_serializer (collection.find({"_id": _id.inserted_id}))
vrátit se {"postavení": "OK","data": uživatel}
  • FastAPI poskytuje metodu APIRouter(), která definuje objekt směrovače, který poskytuje rozhraní pro odesílání požadavků API na server.
  • Určete trasu příspěvku, která vytvoří nový uživatelský objekt v databázi vložením dat do kolekce po její serializaci. Dále uložte a předejte insert_id, abyste našli přidružená data v kolekci, a nakonec vraťte stav „OK“ s daty v odpovědi, pokud je požadavek na odeslání úspěšný.
  • Metody insert_one a find jsou definovány klientem PyMongo.

Nyní přidejte níže uvedený kód do souboru server.py, abyste inicializovali trasy.

z routes.user_routes import uživatel
app.include_router (uživatel)

Pokračujte a otestujte si cestu příspěvku ve svém prohlížeči pomocí nástroje Swagger UI API poskytovaného FastAPI.

Číst data pomocí metody Get

Po definování trasy příspěvku a inicializaci tras definujte zbytek ostatních tras.

@user.get("/")
asynchronnídefnajít_všechny_uživatele():
 users = users_serializer (collection.find())
vrátit se {"postavení": "OK","data": uživatelé}

@user.get("/{id}")
asynchronnídefget_one_user(id: str):
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
vrátit se {"postavení": "OK","data": uživatel}

Definujte dvě trasy získávání, které načítají všechna data v kolekci a načítají konkrétní data z kolekce na základě ID.

Aktualizujte data pomocí metody Put

Vytvořte put route pro aktualizaci uložených dat v databázi.

@user.put("/{id}")
asynchronnídefupdate_user(id: str, user: User):
 collection.find_one_and_update(
 {
"_id": ObjectId (id)
 }, 
 {
"$set": dict (uživatel)
 })
 user = users_serializer (collection.find({"_id": ObjectId (id)}))
vrátit se {"postavení": "OK","data": uživatel}

Metoda put používá ID k nalezení konkrétních dat v kolekci a aktualizuje hodnotu polí v dokumentu novými daty předanými z API. Poté můžete vyhledat aktualizovaná data podle ID a vrátit je v odpovědi API.

Odstraňte data pomocí metody mazání

Vytvořte cestu pro odstranění pro odstranění uložených dat v databázi.

@user.delete("/{id}")
asynchronnídefdelete_user(id: str):
 collection.find_one_and_delete({"_id": ObjectId (id)})
 users = users_serializer (collection.find())
vrátit se {"postavení": "OK","data": []}

Cesta odstranění převezme ID konkrétního dokumentu, který chcete z kolekce odstranit.

Vytvářejte REST API pomocí FastAPI

FastAPI poskytuje skvělý způsob pohodlného vytváření backendových webových API Pythonu. Jeho vestavěné nástroje pro integraci databází a automatickou produkci API činí proces jednoduchým.

Můžete to udělat ještě o krok dále a vytvářet plnohodnotné aplikace. Zkuste integrovat front-end klienta pomocí populárních technologií jako React, Angular nebo Vue.