Cum să construiești un serviciu API de înaltă performanță folosind FastAPI

FastAPI este un cadru web modern, rapid (eficient), special conceput pentru construirea de API-uri. Este bazat pe sugestiile de tip Python și suportă programarea asincronă, permițând dezvoltatorilor să construiască servicii API de înaltă performanță, cu disponibilitate ridicată și latență scăzută. În acest articol, vă vom prezenta în detaliu cum să folosiți FastAPI pentru a construi un serviciu API de înaltă performanță, vom explica pas cu pas, ajutându-vă să realizați întregul proces, de la configurarea mediului până la desfășurare.

Primul pas: Pregătirea mediului

Trebuie să vă asigurați că aveți instalat Python 3.6+. Dacă nu l-ați instalat încă, puteți vizita site-ul oficial Python pentru a-l descărca și instala.

Instalarea FastAPI și Uvicorn

FastAPI în sine nu oferă servicii, are nevoie de un server ASGI pentru a funcționa. Aici folosim Uvicorn, un server ASGI de înaltă performanță. Puteți instala FastAPI și Uvicorn folosind următoarea comandă:

pip install fastapi uvicorn

Pasul doi: Construirea unui API de bază

Să creăm o aplicație FastAPI simplă.

Creează fișierul aplicației

În directorul proiectului dvs., creați un fișier Python, de exemplu, main.py, și scrieți următorul cod:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello, World!"}

În codul de mai sus, am importat mai întâi FastAPI și am creat o instanță app. Apoi, am definit o rută GET care returnează un răspuns JSON simplu atunci când se accesează calea rădăcină /.

Pornește serverul

Porniti serverul FastAPI folosind următoarea comandă:

uvicorn main:app --reload

main: se referă la numele fișierului, fără extensia .py.
app: se referă la instanța FastAPI.
--reload: în modul de dezvoltare, serverul se va reporni automat la modificările fișierelor.

Pasul trei: Definirea rutelor și modelului de date

Pentru a construi API-uri complexe, trebuie să folosiți Pydantic pentru a defini modelul de date.

Creează modelul de date

Adăugați următorul conținut în main.py:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

Această bucată de cod folosește Pydantic pentru a crea un model de date Item, care conține trei atribute: numele produsului, prețul și disponibilitatea.

Adaugă o nouă rută

Apoi, putem defini o nouă rută POST pentru a primi date de tip Item:

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

În această rută, FastAPI va valida automat datele primite și le va mapa la modelul Item.

Pasul patru: Generarea automată a documentației

Unul dintre cele mai mari avantaje ale FastAPI este capacitatea de a genera automat documentația API. Puteți vizualiza documentația accesând următoarele adrese:

Swagger UI: http://127.0.0.1:8000/docs
ReDoc: http://127.0.0.1:8000/redoc

În aceste documente generate, puteți testa interactiv API-ul, vizualizând formatul cererilor și răspunsurilor pentru fiecare rută.

Pasul cinci: Adăugarea autentificării

În aplicațiile reale, autentificarea este un pas important. Să adăugăm o autentificare simplă bazată pe roluri.

Adăugați dependențe de securitate

Folosiți metoda Depends din FastAPI și OAuth2PasswordBearer pentru a implementa autentificarea:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def fake_decode_token(token):
    return {"sub": token}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if user is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Credențiale de autentificare invalide")
    return user

Protejați rutele

Apoi, puteți adăuga autentificarea la rutele care necesită protecție:

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

Pasul șase: Desfășurarea aplicației FastAPI

Când ați terminat dezvoltarea, este posibil să doriți să desfășurați aplicația pe un server cloud. Puteți alege să desfășurați folosind Docker.

Creează Dockerfile

În directorul proiectului, creați un fișier numit Dockerfile și introduceți următorul conținut:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

Construiește imaginea Docker

În terminalul dvs., folosiți următoarea comandă pentru a construi imaginea Docker:

docker build -t myfastapiapp .

Rulați containerul Docker

Rulați aplicația FastAPI:

docker run -d --name fastapi -p 80:80 myfastapiapp

Concluzie

În acest articol, am explicat în detaliu cum să folosiți FastAPI pentru a construi un serviciu API de înaltă performanță, de la pregătirea mediului, la crearea unui API de bază, definirea rutelor și modelului de date, până la adăugarea autentificării și desfășurarea aplicației. FastAPI oferă multe funcționalități puternice, făcând construirea API-urilor moderne simplă și eficientă, iar dvs. puteți explora mai multe funcții și caracteristici prin documentația oficială. Sperăm că acest articol vă va ajuta să începeți mai repede cu FastAPI și să îmbunătățiți eficiența dezvoltării proiectelor dvs.!