Creați o aplicație cu FastAPI pentru Python

FastAPI este un cadru web rapid și ușor pentru construirea de interfețe moderne de programare a aplicațiilor folosind Python 3.6 și versiuni ulterioare. În acest tutorial, vom parcurge elementele de bază ale construirii unei aplicații cu FastAPI și veți obține o idee de ce a fost nominalizată drept unul dintre cele mai bune framework-uri open-source din 2021.

Odată ce sunteți gata să vă dezvoltați propriile aplicații FastAPI, nu va trebui să căutați departe pentru a găsi un loc în care să le găzduiți. Serviciile Kinsta de găzduire a aplicațiilor și găzduire a bazelor de date oferă o platformă ca serviciu care este puternică pe Python.

Să învățăm mai întâi elementele de bază.

Avantajele FastAPI

Mai jos sunt câteva dintre avantajele pe care cadrul FastAPI le aduce unui proiect.

• Viteză: După cum sugerează și numele, FastAPI este un cadru foarte rapid. Viteza sa este comparabilă cu cea a Go și Node.js, care sunt în general considerate a fi printre cele mai rapide opțiuni pentru construirea de API-uri.
• Ușor de învățat și de codat: FastAPI și-a dat deja seama aproape tot ce aveți nevoie pentru a crea un API pregătit pentru producție. În calitate de dezvoltator care folosește FastAPI, nu trebuie să codificați totul de la zero. Cu doar câteva linii de cod, puteți avea un API RESTful pregătit pentru implementare.
• Documentație cuprinzătoare: FastAPI utilizează standardele de documentație OpenAPI, astfel încât documentația poate fi generată dinamic. Această documentație oferă informații detaliate despre punctele finale ale FastAPI, răspunsuri, parametri și coduri de returnare.
• API-uri cu mai puține erori: FastAPI acceptă validarea datelor personalizate, ceea ce permite dezvoltatorilor să creeze API-uri cu mai puține erori. Dezvoltatorii FastAPI se laudă că cadrul are ca rezultat mai puține erori induse de om - cu până la 40% mai puține.
• Sugestii de tip: Modulul de tipuri a fost introdus în Python 3.5. Acest lucru vă permite să declarați type unei variabile. Când este declarat tipul unei variabile, IDE-urile sunt capabile să ofere un suport mai bun și să prezică erorile cu mai multă acuratețe.

Cum să începeți cu FastAPI

Pentru a urma acest tutorial și a începe cu FastAPI, mai întâi va trebui să faceți câteva lucruri.

Asigurați-vă că aveți un editor de text/IDE pentru programator, cum ar fi Visual Studio Code. Alte opțiuni includ Sublime Text și Espresso.

Este o practică obișnuită să rulați aplicațiile dvs. Python și instanțele lor în medii virtuale. Mediile virtuale permit rularea simultană a diferitelor seturi și configurații de pachete și evită conflictele din cauza versiunilor de pachete incompatibile.

Pentru a crea un mediu virtual, deschideți terminalul și rulați această comandă:

 $ python3 -m venv env

De asemenea, va trebui să activați mediul virtual. Comanda pentru a face acest lucru va varia în funcție de sistemul de operare și shell-ul pe care îl utilizați. Iată câteva exemple de activare CLI pentru o serie de medii:

 # On Unix or MacOS (bash shell): /path/to/venv/bin/activate # On Unix or MacOS (csh shell): /path/to/venv/bin/activate.csh # On Unix or MacOS (fish shell): /path/to/venv/bin/activate.fish # On Windows (command prompt): \path\to\venv\Scripts\activate.bat # On Windows (PowerShell): \path\to\venv\Scripts\Activate.ps1

(Unele IDE-uri compatibile cu Python pot fi, de asemenea, configurate pentru a activa mediul virtual actual.)

Acum, instalați FastAPI:

 $ pip3 install fastapi

FastAPI este un cadru pentru construirea de API-uri, dar pentru a vă testa API-urile veți avea nevoie de un server web local. Uvicorn este un server web Asynchronous Server Gateway Interface (ASGI) foarte rapid pentru Python, care este excelent pentru dezvoltare. Pentru a instala Uvicorn, rulați această comandă:

 $ pip3 install "uvicorn[standard]"

După instalarea cu succes, creați un fișier numit main.py în directorul de lucru al proiectului. Acest fișier va fi punctul de intrare în aplicație.

Un exemplu rapid FastAPI

Veți testa instalarea FastAPI prin configurarea rapidă a unui exemplu de punct final. În fișierul main.py , inserați următorul cod, apoi salvați fișierul:

 # main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"greeting":"Hello world"}

Fragmentul de mai sus creează un punct final FastAPI de bază. Mai jos este un rezumat a ceea ce face fiecare linie:

• from fastapi import FastAPI : funcționalitatea pentru API-ul dvs. este furnizată de clasa FastAPI Python.
• app = FastAPI() : Aceasta creează o instanță FastAPI.
• @app.get("/") : Acesta este un decorator python care specifică FastAPI că funcția de sub acesta este responsabilă de gestionarea cererilor.
• @app.get("/") : Acesta este un decorator care specifică ruta. Aceasta creează o metodă GET pe traseul site-ului. Rezultatul este apoi returnat de funcția wrapped.
• Alte operațiuni posibile care sunt folosite pentru a comunica includ @app.post() , @app.put() , @app.delete() , @app.options() , @app.head() , @app.patch() și @app.trace() .

În directorul de fișiere, rulați următoarea comandă în terminalul dvs. pentru a porni serverul API:

 $ uvicorn main:app --reload

În această comandă, main este numele modulului dumneavoastră. Obiectul app este o instanță a aplicației dvs. și este importat în serverul ASGI. Indicatorul --reload îi spune serverului să se reîncarce automat atunci când faceți modificări.

Ar trebui să vedeți așa ceva în terminalul dvs.:

 $ uvicorn main:app --reload INFO: Will watch for changes in these directories: ['D:\\WEB DEV\\Eunit\\Tests\\fast-api'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [26888] using WatchFiles INFO: Started server process [14956] INFO: Waiting for application startup. INFO: Application startup complete.

În browser, navigați la http://localhost:8000 pentru a confirma că API-ul dvs. funcționează. Ar trebui să vedeți „Hello”: „World” ca obiect JSON pe pagină. Acest lucru ilustrează cât de ușor este să creați un API cu FastAPI. Tot ce trebuia să faceți era să definiți o rută și să returnați dicționarul dvs. Python, așa cum se vede pe linia șase a fragmentului de mai sus.

Utilizarea indicațiilor de tip

Dacă utilizați Python, sunteți obișnuit să adnotați variabile cu tipuri de date de bază, cum ar fi int , str , float și bool . Cu toate acestea, din versiunea Python 3.9, au fost introduse structuri avansate de date. Acest lucru vă permite să lucrați cu structuri de date precum dictionaries , tuples și lists . Cu sugestiile de tip FastAPI, puteți structura schema datelor dvs. folosind modele pidantice și apoi, utilizați modelele pidantice pentru a introduce indiciu și beneficia de validarea datelor furnizată.

În exemplul de mai jos, utilizarea indicațiilor de tip în Python este demonstrată cu un calculator simplu pentru prețul mesei, calculate_meal_fee :

 def calculate_meal_fee(beef_price: int, meal_price: int) -> int: total_price: int = beef_price + meal_price return total_price print("Calculated meal fee", calculate_meal_fee(75, 19))

Rețineți că sugestiile de tip nu schimbă modul în care rulează codul.

Documentația API interactivă FastAPI

FastAPI folosește Swagger UI pentru a furniza documentație automată interactivă API. Pentru a-l accesa, navigați la http://localhost:8000/docs și veți vedea un ecran cu toate punctele finale, metodele și schemele dvs.

Această documentație API automată, bazată pe browser, este furnizată de FastAPI și nu trebuie să faceți nimic altceva pentru a profita de ea.

O documentație alternativă API bazată pe browser, furnizată și de FastAPI, este Redoc. Pentru a accesa Redoc, navigați la http://localhost:8000/redoc , unde vi se va prezenta o listă cu punctele finale, metodele și răspunsurile acestora.

Configurarea rutelor în FastAPI

Decoratorul @app vă permite să specificați metoda rutei, cum ar fi @app.get sau @app.post și acceptă GET , POST , PUT și DELETE , precum și opțiunile mai puțin comune, HEAD , PATCH și TRACE .

Creați-vă aplicația cu FastAPI

În acest tutorial, veți fi explicat prin construirea unei aplicații CRUD cu FastAPI. Aplicația va putea:

• Creați un utilizator
• Citiți înregistrarea bazei de date a unui utilizator
• Actualizați un utilizator existent
• Ștergeți un anumit utilizator

Pentru a executa aceste operațiuni CRUD, veți crea metode care expun punctele finale API. Rezultatul va fi o bază de date în memorie care poate stoca o listă de utilizatori.

Veți folosi biblioteca pydantic pentru a efectua validarea datelor și gestionarea setărilor folosind adnotări de tip Python. În scopul acestui tutorial, veți declara forma datelor dvs. ca clase cu atribute.

Acest tutorial va folosi baza de date din memorie. Acest lucru este pentru a începe rapid să utilizați FastAPI pentru a vă construi API-urile. Cu toate acestea, pentru producție, puteți utiliza orice bază de date pe care o alegeți, cum ar fi PostgreSQL, MySQL, SQLite sau chiar Oracle.

Construirea aplicației

Veți începe prin a vă crea modelul de utilizator. Modelul utilizatorului va avea următoarele atribute:

• id : un identificator unic universal (UUID)
• first_name : prenumele utilizatorului
• last_name : Numele de familie al utilizatorului
• gender : genul utilizatorului
• roles , care este o listă care conține rolurile de admin și user

Începeți prin a crea un fișier nou numit models.py în directorul dvs. de lucru, apoi inserați următorul cod în models.py pentru a vă crea modelul:

 # models.py from typing import List, Optional from uuid import UUID, uuid4 from pydantic import BaseModel from enum import Enum from pydantic import BaseModel class Gender(str, Enum): male = "male" female = "female" class Role(str, Enum): admin = "admin" user = "user" class User(BaseModel): id: Optional[UUID] = uuid4() first_name: str last_name: str gender: Gender roles: List[Role]

In codul de mai sus:

• Clasa dvs. User extinde BaseModel , care este apoi importat din pydantic .
• Ați definit atributele utilizatorului, așa cum sa discutat mai sus.

Următorul pas este să vă creați baza de date. Înlocuiți conținutul fișierului main.py cu următorul cod:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ]

În main.py :

• Ați inițializat db cu un tip de List și ați trecut în modelul User
• Ați creat o bază de date în memorie cu patru utilizatori, fiecare cu atributele necesare, cum ar fi first_name , last_name , gender și roles . Utilizatorului Eunit i se atribuie rolurile de admin și user , în timp ce celorlalți trei utilizatori li se atribuie doar rolul de user .

Citiți înregistrările bazei de date

Ați configurat cu succes baza de date în memorie și ați populat-o cu utilizatori, așa că următorul pas este să configurați un punct final care va returna o listă cu toți utilizatorii. Aici intervine FastAPI.

În fișierul main.py , inserați următorul cod chiar sub punctul final Hello World :

 # main.py @app.get("/api/v1/users") async def get_users(): return db

Acest cod definește punctul final /api/v1/users și creează o funcție asincronă, get_users , care returnează tot conținutul bazei de date, db .

Salvați fișierul și vă puteți testa punctul final de utilizator. Rulați următoarea comandă în terminalul dvs. pentru a porni serverul API:

 $ uvicorn main:app --reload

În browser, navigați la http://localhost:8000/api/v1/users . Aceasta ar trebui să returneze o listă cu toți utilizatorii dvs., după cum se vede mai jos:

În această etapă, fișierul dvs. main.py va arăta astfel:

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ] @app.get("/") async def root(): return {"Hello": "World",} @app.get("/api/v1/users") async def get_users(): return db

Creați înregistrări de bază de date

Următorul pas este să creați un punct final pentru a crea un utilizator nou în baza de date. Lipiți următorul fragment în fișierul main.py :

 # main.py @app.post("/api/v1/users") async def create_user(user: User): db.append(user) return {"id": user.id}

În acest fragment, ați definit punctul final pentru a trimite un nou utilizator și ați folosit decoratorul @app.post pentru a crea o metodă POST .

De asemenea, ați creat funcția create_user , care acceptă user modelului User și ați adăugat (adăugat) user nou creat la baza de date, db . În cele din urmă, punctul final returnează un obiect JSON cu id -ul utilizatorului nou creat.

Va trebui să utilizați documentația automată API furnizată de FastAPI pentru a vă testa punctul final, așa cum s-a văzut mai sus. Acest lucru se datorează faptului că nu puteți face o solicitare de postare folosind browserul web. Navigați la http://localhost:8000/docs pentru a testa folosind documentația furnizată de SwaggerUI.

Ștergeți înregistrările bazei de date

Deoarece construiți o aplicație CRUD, aplicația dvs. va trebui să aibă capacitatea de a șterge o resursă specificată. Pentru acest tutorial, veți crea un punct final pentru a șterge un utilizator.

Lipiți următorul cod în fișierul main.py :

 # main.py from uuid import UUID from fastapi HTTPException @app.delete("/api/v1/users/{id}") async def delete_user(id: UUID): for user in db: if user.id == id: db.remove(user) return raise HTTPException( status_code=404, detail=f"Delete user failed, id {id} not found." )

Iată o defalcare linie cu linie a modului în care funcționează codul:

• @app.delete("/api/v1/users/{id}") : ați creat punctul final de ștergere folosind decoratorul @app.delete() . Calea este încă /api/v1/users/{id} , dar apoi preia id -ul, care este o variabilă de cale corespunzătoare id-ului utilizatorului.
• async def delete_user(id: UUID): : creează funcția delete_user , care preia id -ul de la adresa URL.
• for user in db: : Aceasta îi spune aplicației să parcurgă utilizatorii din baza de date și să verifice dacă id -ul transmis se potrivește cu un utilizator din baza de date.
• db.remove(user) : Dacă id -ul corespunde unui utilizator, acesta va fi șters; în caz contrar, va fi generată o HTTPException cu un cod de stare 404.

Actualizați înregistrările bazei de date

Veți crea un punct final pentru a actualiza detaliile unui utilizator. Detaliile care pot fi actualizate includ următorii parametri: first_name , last_name și roles .

În fișierul model.py , inserați următorul cod sub modelul dvs. de User , adică după clasa User(BaseModel): :

 # models.py class UpdateUser(BaseModel): first_name: Optional[str] last_name: Optional[str] roles: Optional[List[Role]]

În acest fragment, clasa UpdateUser extinde BaseModel . Apoi setați parametrii utilizator actualizabili, cum ar fi first_name , last_name și roles , să fie opționali.

Acum veți crea un punct final pentru a actualiza detaliile unui anumit utilizator. În fișierul main.py , inserați următorul cod după @app.delete decorator:

 # main.py @app.put("/api/v1/users/{id}") async def update_user(user_update: UpdateUser, id: UUID): for user in db: if user.id == id: if user_update.first_name is not None: user.first_name = user_update.first_name if user_update.last_name is not None: user.last_name = user_update.last_name if user_update.roles is not None: user.roles = user_update.roles return user.id raise HTTPException(status_code=404, detail=f"Could not find user with id: {id}")

În codul de mai sus, ați făcut următoarele:

• S-a creat @app.put("/api/v1/users/{id}") , punctul final al actualizării. Are un id de parametru variabil care corespunde id-ului utilizatorului.
• A creat o metodă numită update_user , care preia clasa UpdateUser și id .
• S-a folosit o buclă for a verifica dacă utilizatorul asociat cu id -ul transmis se află în baza de date.
• Verificat dacă vreunul dintre parametrii utilizatorului is not None (nu nul). Dacă vreun parametru, cum ar fi first_name , last_name sau roles , nu este nul, atunci este actualizat.
• Dacă operațiunea are succes, se returnează id-ul de utilizator.
• Dacă utilizatorul nu a fost localizat, se afișează o excepție HTTPException cu un cod de stare 404 și un mesaj Nu s-a Could not find user with id: {id} .

Pentru a testa acest punct final, asigurați-vă că serverul Uvicorn rulează. Dacă nu rulează, introduceți această comandă:

 uvicorn main:app --reload

Mai jos este o captură de ecran a testului.

Vedeți cum FastAPI ar putea elimina erorile induse de oameni cu până la 40% Începeți chiar aici: Faceți clic pentru a Tweet

rezumat

În acest tutorial, ați aflat despre cadrul FastAPI pentru Python și ați văzut singur cât de repede puteți obține o aplicație bazată pe FastAPI. Ați învățat cum să construiți puncte finale API CRUD utilizând cadrul - crearea, citirea, actualizarea și ștergerea înregistrărilor bazei de date.

Acum, dacă doriți să duceți dezvoltarea aplicației dvs. web la următorul nivel, asigurați-vă că consultați platforma Kinsta pentru găzduirea aplicațiilor și găzduirea bazelor de date. La fel ca FastAPI, este foarte simplu.