Cititorii ca tine ajută la sprijinirea MUO. Când efectuați o achiziție folosind link-uri de pe site-ul nostru, este posibil să câștigăm un comision de afiliat. Citeşte mai mult.

Construirea unui API REST este adesea o sarcină mecanică, care implică o mulțime de proiectare standard și programare. Din fericire, instrumente precum FastAPI pot scuti o mulțime de detalii plictisitoare.

Folosind FastAPI, puteți construi rapid un API REST complet și eficient pentru aplicația dvs. CRUD. Având MongoDB ca sursă de date, acest tutorial vă va ghida spre configurarea propriei API în cel mai scurt timp.

Ce este FastAPI?

FastAPI este un cadru web Python rapid și open-source pentru construirea de API-uri. Oferă suport încorporat pentru solicitările asincrone, validarea automată a datelor și documentarea automată a punctelor finale API.

Avantajele FastAPI față de alte cadre Python

  • FastAPI este relativ mai rapid decât alte cadre precum Django și Flask. Acest lucru se datorează faptului că FastAPI se bazează pe asyncio, o bibliotecă I/O asincronă pentru Python care poate procesa cererile concurente mai rapid.
  • FastAPI oferă o modalitate curată și simplă de a construi API-uri cu efort minim, deoarece necesită mai puțin cod decât Flask sau Django.
  • În cele din urmă, FastAPI facilitează generarea de documentație pentru punctele finale. Folosește Swagger pentru a produce documentație pe care o puteți folosi pentru a testa punctele finale prin rularea cererilor și vizualizarea răspunsurilor.

Configurați o bază de date MongoDB

Pentru a începe, va trebui configurați local baza de date MongoDB. Alternativ, puteți opta pentru varianta mai ușoară de configurarea unui cluster MongoDB în Cloud.

Apoi, folosind instrumentul de interfață grafică cu utilizatorul MongoDB instalat, Compass, creați o conexiune la baza de date. Apasă pe Conexiune nouă butonul și furnizați URI-ul de conectare pentru a stabili o conexiune cu serverul MongoDB care rulează local.

În cele din urmă, creați o nouă bază de date și o nouă colecție pentru a păstra datele API de testare.

Configurați un server FastAPI

Folosind un terminal, creați un folder de proiect și introduceți noul director.

Puteți găsi codul acestui proiect în documentul său Depozitul GitHub.

Apoi, verificați pentru a vedea dacă rulați Python versiunea 3.6+. Dacă nu, instalați cel mai recent Piton versiune.

python --versiune

Apoi, instalați Virtualenv pentru a crea un mediu de dezvoltare virtual izolat. Acest lucru este foarte recomandat deoarece vă permite să evitați conflictele, mai ales dacă utilizați versiuni diferite de pachete pentru proiecte diferite.

pip install virtualenv

Apoi, creați un mediu virtual numit "venv" în directorul dvs. curent:

virtualenv venv

În cele din urmă, activați mediul virtual.

# Pe Unix sau MacOS: 
sursă venv/bin/activate
# Pe Windows:
 .\venv\Scripts\activate

După ce ați configurat mediul virtual, instalați pachetele FastAPI, PyMongo și Uvicorn.

pip install fastapi pymongo uvicorn

PyMongo este o bibliotecă bazată pe Python pentru lucrul cu baza de date MongoDB. Oferă un API care acceptă toate caracteristicile MongoDB și vă permite să interacționați cu MongoDB fără a fi nevoie să scrieți interogări brute MongoDB.

Uvicorn, pe de altă parte, este un server web asincron bazat pe modulul asincron Python. Caracteristica sa principală este reîncărcarea la cald a serverelor dvs. FastAPI din mers. Utilizarea Uvicorn este similară cu lucrând cu Nodemon.

Creați serverul FastAPI

În cele din urmă, creați un server FastAPI simplu care ascultă pentru a primi cererile care vin de la ruta de acasă. În directorul rădăcină al folderului proiectului, creați un fișier server.py și adăugați codul de mai jos.

din fastapi import FastAPI
aplicație = FastAPI()
@app.get("/")
asincrondefAcasă():
întoarcere {"mesaj": "Salut Lume"}

În cele din urmă, rulați comanda de mai jos pentru a porni serverul de dezvoltare. Uvicorn vă va servi aplicația pe portul 8000.

server uvicon: app --reload

Continuați și vedeți răspunsul serverului în browser la adresa http://localhost: 8000.

Creați API-ul REST cu operațiuni CRUD

Acum construiți API-ul REST care implementează metodele CRUD (creați, citiți, actualizați și ștergeți). În directorul rădăcină al folderului de proiect, creați patru foldere: config, modele, rute și scheme.

├── config
├── modele
├── rute
├── scheme
└── server.py

1. Configurați conexiunea la baza de date

În directorul de configurare, creați un fișier nou, db.py și adăugați codul de mai jos.

din pymongo import MongoClient
db_connection = MongoClient(„mongodb://localhost: 27017”)
db = db_connection.database_name
colectie = db["nume_colecție"]
  • Utilizați metoda MongoClient() pentru a crea o conexiune la o bază de date MongoDB. Acesta ia un șir URI de conexiune ca argument care specifică gazda și portul serverului MongoDB.
  • Cele două variabile specifică ce bază de date și colecție din serverul dvs. MongoDB ar trebui să acceseze serverul.

2. Definiți un model de date

Acest model va defini structura datelor dumneavoastră în baza de date, inclusiv câmpurile și tipurile de date.

În directorul modelului, creați un fișier nou, user_model.py și adăugați codul de mai jos.

din pidantic import Model de bază 
clasăUtilizator(Model de bază):
 nume: str
 rol: str
  • Codul de mai sus creează o clasă numită User, care este o subclasă a clasei BaseModel din biblioteca Pydantic. Clasa User are două câmpuri, nume și rol, cu tipurile de date setate la șiruri.
  • Puteți utiliza biblioteca Pydantic cu FastAPI pentru a crea modele de date. De asemenea, îl puteți utiliza pentru a valida datele, a le serializa (JSON în Python) și a le deserializa (Python în JSON).

3. Definiți o schemă de date

Din modelul de date creat, puteți defini schema pentru datele dvs. În directorul de scheme, creați un fișier nou: user_schema.py și adăugați codul de mai jos.

defuser_serialzer(utilizator) -> dict:
întoarcere {
'id':str (utilizator[„_id”]),
'Nume':utilizator["Nume"],
'rol':utilizator["rol"]
 }
defutilizatori_serializator(utilizatori) -> lista:
întoarcere [user_serializer (utilizator) pentru utilizator în utilizatori]

4. Definiți rutele API

În cele din urmă, definiți rutele pentru diferitele operațiuni CRUD.

În directorul rute, creați un fișier nou: user_routes.py și adăugați codul de mai jos.

Adăugați date cu metoda Post

Creați traseul postării pentru a adăuga date.

din fastapi import APIRouter
din modele.model_utilizator import Utilizator
din scheme.schema_utilizator import utilizatori_serializator
din bson import ObjectId
din config.db import Colectie
utilizator = APIRouter()
@user.post("/")
asincrondefcreaza utilizator(utilizator: utilizator):
 _id = collection.insert_one (dict (utilizator))
 utilizator = users_serializer (collection.find({„_id”: _id.inserted_id}))
întoarcere {"stare": "Bine","date": utilizator}
  • FastAPI oferă metoda APIRouter() care definește un obiect router care oferă o interfață pentru a face cereri API către un server.
  • Specificați o rută de postare care creează un nou obiect utilizator în baza de date prin inserarea datelor în colecție după serializarea acesteia. Apoi, stocați și transmiteți inserted_id pentru a găsi datele asociate din colecție și, în final, returnați starea „Ok” cu datele din răspuns, dacă solicitarea de postare este reușită.
  • Metodele insert_one și find sunt definite de clientul PyMongo.

Acum, adăugați codul de mai jos la server.py pentru a inițializa rutele.

din rute.rute_utilizator import utilizator
app.include_router (utilizator)

Continuați și testați traseul postării în browser folosind instrumentul Swagger UI API oferit de FastAPI.

Citiți datele cu metoda Get

După definirea traseului post și inițializarea rutelor, definiți restul celorlalte rute.

@user.get("/")
asincrondefgăsiți_toți_utilizatorii():
 utilizatori = users_serializer (collection.find())
întoarcere {"stare": "Bine","date": utilizatori}

@user.get("/{id}")
asincrondefobține_un_utilizator(id: str):
 utilizator = users_serializer (collection.find({„_id”: ObjectId (id)}))
întoarcere {"stare": "Bine","date": utilizator}

Definiți două rute de obținere care preiau toate datele din colecție și preiau date specifice din colecție pe baza ID-ului.

Actualizați datele cu metoda Put

Creați ruta de intrare pentru a actualiza datele stocate în baza de date.

@user.put("/{id}")
asincrondefupdate_user(id: str, utilizator: Utilizator):
 collection.find_one_and_update(
 {
„_id”: ObjectId (id)
 }, 
 {
"$set": dict (utilizator)
 })
 utilizator = users_serializer (collection.find({„_id”: ObjectId (id)}))
întoarcere {"stare": "Bine","date": utilizator}

Metoda put folosește ID-ul pentru a găsi datele specifice din colecție și actualizează valoarea câmpurilor din document cu noile date transmise din API. Apoi puteți căuta datele actualizate după ID și le puteți returna în răspunsul API.

Ștergeți datele cu metoda Delete

Creați ruta de ștergere pentru a șterge datele stocate în baza de date.

@user.delete("/{id}")
asincrondefdelete_user(id: str):
 collection.find_one_and_delete({„_id”: ObjectId (id)})
 utilizatori = users_serializer (collection.find())
întoarcere {"stare": "Bine","date": []}

Ruta de ștergere include ID-ul documentului specific pe care doriți să îl ștergeți din colecție.

Creați API-uri REST cu FastAPI

FastAPI oferă o modalitate excelentă de a construi în mod convenabil API-uri web Python backend. Instrumentele sale încorporate pentru integrarea bazei de date și producția automată de API fac ca procesul să fie unul simplu.

Puteți chiar să faceți acest lucru cu un pas mai departe și să creați aplicații cu drepturi depline. Încercați să integrați un client front-end folosind tehnologii populare precum React, Angular sau Vue.