Hvordan man bygger højtydende API-tjenester med FastAPI

FastAPI er et moderne, hurtigt (effektivt) web-framework, der er designet til at bygge API'er. Det er baseret på Python type hints og understøtter asynkron programmering, hvilket giver udviklere mulighed for at bygge højtydende, højtilgængelige API-tjenester med lav forsinkelse. Denne artikel vil detaljeret beskrive, hvordan man bruger FastAPI til at bygge højtydende API-tjenester, og vi vil gennemgå det trin for trin for at hjælpe dig med at realisere hele processen fra opsætning af miljø til implementering.

Trin 1: Forberedelse af miljø

Du skal sikre dig, at din udviklingsmiljø har Python 3.6+ installeret. Hvis du ikke har installeret det endnu, kan du besøge Python's officielle hjemmeside for at downloade og installere det.

Installation af FastAPI og Uvicorn

FastAPI leverer ikke selv en server, så du har brug for en ASGI-server til at hoste den. Her bruger vi Uvicorn, en højtydende ASGI-server. Du kan installere FastAPI og Uvicorn med følgende kommando:

pip install fastapi uvicorn

Trin 2: Byg en grundlæggende API

Lad os oprette en simpel FastAPI-applikation.

Opret applikationsfil

I din projektmappe skal du oprette en Python-fil, f.eks. main.py, og derefter skrive følgende kode:

from fastapi import FastAPI

app = FastAPI()

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

I ovenstående kode importerer vi først FastAPI og opretter en app-instans. Derefter definerer vi en GET-rute, der returnerer et simpelt JSON-svar, når rodstien / tilgås.

Start serveren

Start din FastAPI-server med følgende kommando:

uvicorn main:app --reload

main: refererer til filnavnet uden .py-efternavnet.
app: refererer til FastAPI-instansen.
--reload: i udviklingstilstand genstarter serveren automatisk, når filerne ændres.

Trin 3: Definer ruter og datamodeller

For at opbygge komplekse API'er skal du bruge Pydantic til at definere datamodeller.

Opret datamodel

Tilføj følgende indhold i main.py:

from pydantic import BaseModel

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

Denne kode bruger Pydantic til at oprette en datamodel Item, der indeholder tre egenskaber: produktnavn, pris og tilgængelighed.

Tilføj nye ruter

Derefter kan vi definere en ny POST-rute til at modtage data af typen Item:

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

I denne rute vil FastAPI automatisk validere de indkommende data og kortlægge dem til Item-modellen.

Trin 4: Automatisk dokumentation

En af de største fordele ved FastAPI er, at den kan generere API-dokumentation automatisk. Du kan se dokumentationen ved at besøge følgende adresser:

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

I disse genererede dokumenter kan du interaktivt teste API'en og se anmodnings- og svarformater for hver rute.

Trin 5: Tilføj autentificering

I praktiske anvendelser er autentificering en vigtig del. Lad os tilføje en simpel rollebaseret autentificering.

Tilføj sikkerhedsafhængigheder

Brug FastAPI's Depends-metode og OAuth2PasswordBearer til at implementere autentificering:

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="Ugyldige autentificeringsoplysninger")
    return user

Beskyt ruter

Derefter kan du tilføje autentificering til de ruter, der skal beskyttes:

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

Trin 6: Implementer FastAPI-applikationen

Når du er færdig med udviklingen, skal du muligvis implementere applikationen på en cloud-server. Du kan vælge at bruge Docker til implementering.

Opret Dockerfile

Opret en fil med navnet Dockerfile i projektmappen og indtast følgende indhold:

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

COPY ./app /app

Byg Docker-billede

Brug følgende kommando i din terminal til at bygge Docker-billedet:

docker build -t myfastapiapp .

Kør Docker-container

Kør din FastAPI-applikation:

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

Konklusion

I denne artikel har vi detaljeret gennemgået, hvordan man bruger FastAPI til at bygge højtydende API-tjenester, fra forberedelse af miljø til oprettelse af grundlæggende API, definition af ruter og datamodeller, samt tilføjelse af autentificering og implementering. FastAPI tilbyder mange kraftfulde funktioner, der gør det enkelt og effektivt at bygge moderne API'er, og du kan udforske flere funktioner og egenskaber gennem den officielle dokumentation. Vi håber, at denne artikel kan hjælpe dig med hurtigere at komme i gang med FastAPI og effektivt forbedre din projektudvikling!