Tādi lasītāji kā jūs palīdz atbalstīt MUO. Veicot pirkumu, izmantojot saites mūsu vietnē, mēs varam nopelnīt filiāles komisiju. Lasīt vairāk.

REST API izveide bieži ir mehānisks uzdevums, kas ietver daudzus standarta projektēšanas un automātiskās programmēšanas darbus. Par laimi, tādi rīki kā FastAPI var atbrīvot no daudzām nogurdinošām detaļām.

Izmantojot FastAPI, varat ātri izveidot efektīvu, pilnīgu REST API savai CRUD lietojumprogrammai. Izmantojot MongoDB kā datu avotu, šī apmācība palīdzēs jums ātri izveidot savu API.

Kas ir FastAPI?

FastAPI ir ātrs un atvērtā pirmkoda Python tīmekļa ietvars API veidošanai. Tas nodrošina iebūvētu atbalstu asinhroniem pieprasījumiem, automātisku datu validāciju un automātisku API galapunktu dokumentāciju.

FastAPI priekšrocības salīdzinājumā ar citiem Python ietvariem

  • FastAPI ir salīdzinoši ātrāks nekā citas sistēmas, piemēram, Django un Flask. Tas ir tāpēc, ka FastAPI tiek veidots uz asyncio — Python asinhronas I/O bibliotēkas, kas var ātrāk apstrādāt vienlaicīgus pieprasījumus.
  • FastAPI nodrošina tīru un vienkāršu veidu, kā izveidot API ar minimālu piepūli, jo tam ir nepieciešams mazāk koda nekā Flask vai Django.
  • Visbeidzot, FastAPI ļauj viegli ģenerēt galapunktu dokumentāciju. Tas izmanto Swagger, lai izveidotu dokumentāciju, ko varat izmantot galapunktu pārbaudei, izpildot pieprasījumus un skatot atbildes.

Iestatiet MongoDB datu bāzi

Lai sāktu, jums tas būs jādara iestatiet MongoDB datu bāzi lokāli. Alternatīvi, varat izvēlēties vieglāko variantu MongoDB klastera iestatīšana mākonī.

Pēc tam, izmantojot instalēto MongoDB grafiskā lietotāja interfeisa rīku Compass, izveidojiet datu bāzes savienojumu. Noklikšķiniet uz Jauns savienojums pogu un norādiet savienojuma URI, lai izveidotu savienojumu ar MongoDB serveri, kas darbojas lokāli.

Visbeidzot, izveidojiet jaunu datu bāzi un kolekciju, lai glabātu savus testa API datus.

Iestatiet FastAPI serveri

Izmantojot termināli, izveidojiet projekta mapi un ievadiet šo jauno direktoriju.

Jūs varat atrast šī projekta kodu tajā GitHub repozitorijs.

Pēc tam pārbaudiet, vai izmantojat Python versiju 3.6+. Ja nē, instalējiet jaunāko Python versija.

python -- versija

Pēc tam instalējiet Virtualenv, lai izveidotu izolētu virtuālo izstrādes vidi. Tas ir ļoti ieteicams, jo tas ļauj izvairīties no konfliktiem, īpaši, ja dažādiem projektiem izmantojat dažādas pakotņu versijas.

pip instalēt virtualenv

Pēc tam izveidojiet virtuālo vidi ar nosaukumu "venv" pašreizējā direktorijā:

virtualenv venv

Visbeidzot aktivizējiet virtuālo vidi.

# Operētājsistēmā Unix vai MacOS: 
avots venv/bin/activate
# Operētājsistēmā Windows:
 .\venv\Scripts\activate

Kad esat konfigurējis virtuālo vidi, instalējiet FastAPI, PyMongo un Uvicorn pakotnes.

pip instalēt fastapi pymongo uvicorn

PyMongo ir uz Python balstīta bibliotēka darbam ar MongoDB datu bāzi. Tas nodrošina API, kas atbalsta visas MongoDB funkcijas un ļauj mijiedarboties ar MongoDB, nerakstot neapstrādātus MongoDB vaicājumus.

Savukārt Uvicorn ir asinhrons tīmekļa serveris, kura pamatā ir Python asyncio modulis. Tās galvenā funkcija ir ātra FastAPI serveru atkārtota ielāde, atrodoties ceļā. Uvicorn lietošana ir līdzīga darbs ar Nodemon.

Izveidojiet FastAPI serveri

Visbeidzot, izveidojiet vienkāršu FastAPI serveri, kas klausās, lai saņemtu pieprasījumus no mājas maršruta. Projekta mapes saknes direktorijā izveidojiet failu server.py un pievienojiet tālāk norādīto kodu.

no fastapi imports FastAPI
lietotne = FastAPI()
@app.get("/")
asinhronsdefmājas():
atgriezties {"ziņa": "Sveika pasaule"}

Visbeidzot, palaidiet tālāk norādīto komandu, lai atvērtu izstrādes serveri. Uvicorn apkalpos jūsu pieteikumu portā 8000.

uvicon serveris: app --reload

Turpiniet un skatiet servera atbildi savā pārlūkprogrammā vietnē http://localhost: 8000.

Izveidojiet REST API ar CRUD operācijām

Tagad izveidojiet REST API, kas ievieš CRUD metodes (izveidot, lasīt, atjaunināt un dzēst). Projekta mapes saknes direktorijā izveidojiet četras mapes: konfigurācija, modeļi, maršruti un shēmas.

├── konfigurācija
├── modeļi
├── maršruti
├── shēmas
└── server.py

1. Konfigurējiet datu bāzes savienojumu

Konfigurācijas direktorijā izveidojiet jaunu failu db.py un pievienojiet tālāk norādīto kodu.

no pimongo imports Mongoklients
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_savienojums.datubāzes_nosaukums
kolekcija = db["kolekcijas_nosaukums"]
  • Izmantojiet MongoClient() metodi, lai izveidotu savienojumu ar MongoDB datu bāzi. Tas izmanto savienojuma URI virkni kā argumentu, kas norāda MongoDB servera resursdatoru un portu.
  • Abi mainīgie nosaka, kurai datu bāzei un kolekcijai jūsu MongoDB serverī serverim ir jāpiekļūst.

2. Definējiet datu modeli

Šis modelis definēs jūsu datu struktūru datu bāzē, tostarp laukus un datu tipus.

Modeļa direktorijā izveidojiet jaunu failu user_model.py un pievienojiet tālāk norādīto kodu.

no pidantisks imports Pamatmodelis 
klasēLietotājs(Pamatmodelis):
 nosaukums: str
 loma: str
  • Iepriekš minētais kods izveido klasi ar nosaukumu User, kas ir Pydantic bibliotēkas BaseModel klases apakšklase. Lietotāju klasei ir divi lauki, nosaukums un loma, un to datu tipi ir iestatīti uz virknēm.
  • Varat izmantot Pydantic bibliotēku ar FastAPI, lai izveidotu datu modeļus. Varat arī to izmantot, lai validētu datus, serializētu tos (JSON uz Python) un deserializētu (Python uz JSON).

3. Definējiet datu shēmu

No izveidotā datu modeļa varat definēt datu shēmu. Shēmu direktorijā izveidojiet jaunu failu: user_schema.py un pievienojiet tālāk norādīto kodu.

defuser_serializer(lietotājs) -> dikti:
atgriezties {
'id':str (lietotājs["_id"]),
'vārds':lietotājs["vārds"],
"loma":lietotājs["loma"]
 }
defusers_serializer(lietotāji) -> saraksts:
atgriezties [user_serializer (lietotājs) priekš lietotājs iekšā lietotāji]

4. Definējiet API maršrutus

Visbeidzot, definējiet maršrutus dažādām CRUD operācijām.

Maršrutu direktorijā izveidojiet jaunu failu: user_routes.py un pievienojiet tālāk norādīto kodu.

Pievienojiet datus, izmantojot publicēšanas metodi

Izveidojiet pasta maršrutu, lai pievienotu datus.

no fastapi imports API maršrutētājs
no modeļi.lietotāja_modelis imports Lietotājs
no schemas.user_schema imports users_serializer
no bson imports Objekta ID
no config.db imports kolekcija
lietotājs = APIRouter()
@user.post("/")
asinhronsdefizveidot_lietotājs(lietotājs: lietotājs):
 _id = collection.insert_one (dict (lietotājs))
 lietotājs = lietotāji_serializer (collection.find({"_id": _id.inserted_id}))
atgriezties {"statuss": "Labi","dati": lietotājs}
  • FastAPI nodrošina APIRouter() metodi, kas definē maršrutētāja objektu, kas nodrošina saskarni, lai veiktu API pieprasījumus serverim.
  • Norādiet pasta maršrutu, kas datu bāzē izveido jaunu lietotāja objektu, ievietojot datus kolekcijā pēc tās serializēšanas. Pēc tam saglabājiet un nosūtiet parametru inserted_id, lai kolekcijā atrastu saistītos datus, un, visbeidzot, atgrieziet statusu “Ok” ar datiem atbildē, ja izlikšanas pieprasījums ir veiksmīgs.
  • Metodes insert_one un find ir definējis PyMongo klients.

Tagad pievienojiet tālāk norādīto kodu server.py, lai inicializētu maršrutus.

no routes.user_routes imports lietotājs
app.include_router (lietotājs)

Dodieties uz priekšu un pārbaudiet izlikšanas maršrutu savā pārlūkprogrammā, izmantojot FastAPI nodrošināto Swagger UI API rīku.

Lasiet datus, izmantojot iegūšanas metodi

Pēc pasta maršruta noteikšanas un maršrutu inicializācijas definējiet pārējos citus maršrutus.

@user.get("/")
asinhronsdefatrast_visus_lietotājus():
 lietotāji = lietotāji_serializer (collection.find())
atgriezties {"statuss": "Labi","dati": lietotāji}

@user.get("/{id}")
asinhronsdefget_one_user(id: str):
 lietotājs = lietotāji_serializer (collection.find({"_id": ObjectId (id)}))
atgriezties {"statuss": "Labi","dati": lietotājs}

Definējiet divus iegūšanas maršrutus, kas izgūst visus kolekcijas datus, un izgūst konkrētus datus no kolekcijas, pamatojoties uz ID.

Atjauniniet datus, izmantojot pārdošanas metodi

Izveidojiet ievietošanas maršrutu, lai atjauninātu datubāzē saglabātos datus.

@user.put("/{id}")
asinhronsdefupdate_user(id: str, lietotājs: lietotājs):
 collection.find_one_and_update(
 {
"_id": ObjectId (id)
 }, 
 {
"$set": dikti (lietotājs)
 })
 lietotājs = lietotāji_serializer (collection.find({"_id": ObjectId (id)}))
atgriezties {"statuss": "Labi","dati": lietotājs}

Put metode izmanto ID, lai kolekcijā atrastu konkrētus datus, un atjaunina dokumenta lauku vērtību ar jaunajiem datiem, kas nosūtīti no API. Pēc tam varat meklēt atjauninātos datus pēc ID un atgriezt tos API atbildē.

Dzēst datus, izmantojot dzēšanas metodi

Izveidojiet dzēšanas maršrutu, lai dzēstu datubāzē saglabātos datus.

@user.delete("/{id}")
asinhronsdefdelete_user(id: str):
 collection.find_one_and_delete({"_id": ObjectId (id)})
 lietotāji = lietotāji_serializer (collection.find())
atgriezties {"statuss": "Labi","dati": []}

Dzēšanas maršrutā tiek ievadīts tā konkrētā dokumenta ID, kuru vēlaties dzēst no kolekcijas.

Izveidojiet REST API, izmantojot FastAPI

FastAPI nodrošina lielisku veidu, kā ērti izveidot aizmugursistēmas Python tīmekļa API. Tā iebūvētie rīki datu bāzu integrācijai un automātiskai API ražošanai padara procesu vienkāršu.

Varat pat spert soli tālāk un izveidot pilnvērtīgas lietotnes. Mēģiniet integrēt priekšgala klientu, izmantojot tādas populāras tehnoloģijas kā React, Angular vai Vue.