Hoe FastAPI te gebruiken voor het bouwen van hoge-prestatie API-diensten

FastAPI is een modern, snel (efficiënt) webframework, speciaal ontworpen voor het bouwen van API's. Het is gebaseerd op Python type hints en ondersteunt asynchrone programmering, waardoor ontwikkelaars hoge-prestatie, hoog beschikbare, lage-latentie API-diensten kunnen bouwen. Dit artikel zal u gedetailleerd uitleggen hoe u FastAPI kunt gebruiken om hoge-prestatie API-diensten te bouwen, we zullen stap voor stap uitleggen om u te helpen het volledige proces van omgeving opzetten tot implementatie te realiseren.

Eerste stap: Omgevingsvoorbereiding

U moet ervoor zorgen dat Python 3.6+ is geïnstalleerd in uw ontwikkelomgeving. Als het nog niet is geïnstalleerd, kunt u de officiële Python-website bezoeken om het te downloaden en te installeren.

Installeer FastAPI en Uvicorn

FastAPI zelf biedt geen service, het heeft een ASGI-server nodig om te draaien. Hier gebruiken we Uvicorn, een hoge-prestatie ASGI-server. U kunt de volgende opdracht gebruiken om FastAPI en Uvicorn te installeren:

pip install fastapi uvicorn

Tweede stap: Basis API bouwen

Laten we een eenvoudige FastAPI-app maken.

Maak een applicatiebestand

Maak in uw projectdirectory een Python-bestand, bijvoorbeeld main.py, en schrijf de volgende code:

from fastapi import FastAPI

app = FastAPI()

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

In de bovenstaande code importeren we eerst FastAPI en maken we een app instantie. Vervolgens definiëren we een GET-route die een eenvoudige JSON-respons retourneert wanneer de rootroute / wordt bezocht.

Start de server

Start uw FastAPI-server met de volgende opdracht:

uvicorn main:app --reload

• main: verwijst naar de bestandsnaam, zonder de .py extensie.
• app: verwijst naar de FastAPI-instantie.
• --reload: in de ontwikkelingsmodus wordt de server automatisch opnieuw opgestart bij bestandwijzigingen.

Derde stap: Routes en datamodellen definiëren

Om complexe API's op te bouwen, moet u Pydantic gebruiken om datamodellen te definiëren.

Maak datamodellen

Voeg de volgende inhoud toe aan main.py:

from pydantic import BaseModel

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

Deze code maakt een datamodel Item aan met drie eigenschappen: productnaam, prijs en beschikbaarheid.

Voeg nieuwe routes toe

Vervolgens kunnen we een nieuwe POST-route definiëren om gegevens van het type Item te ontvangen:

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

In deze route valideert FastAPI automatisch de binnenkomende gegevens en map deze naar het Item model.

Vierde stap: Automatische documentatiegeneratie

Een van de grootste voordelen van FastAPI is dat het automatisch API-documentatie genereert. U kunt de volgende adressen bezoeken om het te bekijken:

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

In deze gegenereerde documentatie kunt u interactief de API testen en de aanvraag- en responsformaten van elke route bekijken.

Vijfde stap: Authenticatie toevoegen

In praktische toepassingen is authenticatie een belangrijk aspect. Laten we een eenvoudige rolgebaseerde authenticatie toevoegen.

Voeg beveiligingsafhankelijkheden toe

Gebruik FastAPI's Depends methode en OAuth2PasswordBearer om authenticatie te implementeren:

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="Ongeldige authenticatiegegevens")
    return user

Beveilig routes

Vervolgens kunt u authenticatie toevoegen aan de routes die beveiligd moeten worden:

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

Zesde stap: FastAPI-app implementeren

Wanneer u klaar bent met ontwikkelen, moet u mogelijk de applicatie implementeren op een cloudserver. U kunt ervoor kiezen om Docker te gebruiken voor implementatie.

Maak een Dockerfile

Maak een bestand genaamd Dockerfile in de projectdirectory en voer de volgende inhoud in:

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

COPY ./app /app

Bouw de Docker-image

Bouw de Docker-image met de volgende opdracht in uw terminal:

docker build -t myfastapiapp .

Voer de Docker-container uit

Voer uw FastAPI-app uit:

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

Samenvatting

In dit artikel hebben we gedetailleerd uitgelegd hoe u FastAPI kunt gebruiken om hoge-prestatie API-diensten te bouwen, van omgevingsvoorbereiding tot het creëren van basis API's, het definiëren van routes en datamodellen, tot het toevoegen van authenticatie en implementatie. FastAPI biedt veel krachtige functies die het bouwen van moderne API's eenvoudig en efficiënt maken. U kunt de officiële documentatie verder verkennen voor meer functies en mogelijkheden. We hopen dat dit artikel u helpt om sneller met FastAPI aan de slag te gaan en uw projectontwikkelingssnelheid effectief te verbeteren!