Hvordan bruke FastAPI til å bygge høyytelses API-tjenester

FastAPI er et moderne, raskt (effektivt) web-rammeverk, designet for å bygge API-er. Det er basert på Python typehinting, og støtter asynkron programmering, noe som lar utviklere bygge høyytelses, høy tilgjengelighet, lav latens API-tjenester. Denne artikkelen vil gi deg en detaljert introduksjon til hvordan du bruker FastAPI til å bygge høyytelses API-tjenester, og vi vil gå gjennom prosessen trinn for trinn for å hjelpe deg med å oppnå alt fra miljøoppsett til distribusjon.

Trinn 1: Miljøforberedelse

Du må sørge for at utviklingsmiljøet ditt har Python 3.6+ installert. Hvis du ikke har installert det ennå, kan du besøke Python sin offisielle nettside for å laste ned og installere.

Installer FastAPI og Uvicorn

FastAPI i seg selv tilbyr ikke tjenester, og trenger en ASGI-server for å kjøre. Her bruker vi Uvicorn, en høyytelses ASGI-server. Du kan installere FastAPI og Uvicorn med følgende kommando:

pip install fastapi uvicorn

Trinn 2: Bygg en grunnleggende API

La oss lage en enkel FastAPI-applikasjon.

Opprett applikasjonsfil

I prosjektmappen din, opprett en Python-fil, for eksempel main.py, og skriv inn følgende kode:

from fastapi import FastAPI

app = FastAPI()

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

I koden ovenfor importerer vi først FastAPI og oppretter en app instans. Deretter definerer vi en GET-rute som returnerer et enkelt JSON-svar når vi besøker rotstien /.

Start serveren

Start FastAPI-serveren din med følgende kommando:

uvicorn main:app --reload

main: refererer til filnavnet, uten .py suffiks.
app: refererer til FastAPI-instansen.
--reload: i utviklingsmodus, vil serveren starte på nytt automatisk ved filendringer.

Trinn 3: Definer ruter og datamodeller

For å bygge komplekse API-er, må du bruke Pydantic for å definere datamodeller.

Opprett datamodell

Legg til følgende innhold i main.py:

from pydantic import BaseModel

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

Denne koden bruker Pydantic til å opprette en datamodell Item, som inneholder tre attributter: varenavn, pris og tilgjengelighet.

Legg til nye ruter

Deretter kan vi definere en ny POST-rute for å motta data av typen Item:

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

I denne ruten vil FastAPI automatisk validere de innkommende dataene og mappe dem til Item modellen.

Trinn 4: Automatisk dokumentasjon

En av de største fordelene med FastAPI er at det kan generere API-dokumentasjon automatisk. Du kan se dokumentasjonen ved å besøke følgende adresser:

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

I disse genererte dokumentene kan du interaktivt teste API-en og se forespørsel- og responsformatet for hver rute.

Trinn 5: Legg til autentisering

I praktiske applikasjoner er autentisering en viktig del. La oss legge til en enkel rollebasert autentisering.

Legg til sikkerhetsavhengigheter

Bruk FastAPI sin Depends metode og OAuth2PasswordBearer for å implementere autentisering:

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 autentiseringslegitimasjon")
    return user

Beskytte ruter

Deretter kan du legge til autentisering til rutene som trenger beskyttelse:

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

Trinn 6: Distribuer FastAPI-applikasjonen

Når du er ferdig med utviklingen, må du kanskje distribuere applikasjonen til en skyserver. Du kan velge å bruke Docker for distribusjon.

Opprett Dockerfile

Opprett en fil kalt Dockerfile i prosjektmappen, og skriv inn følgende innhold:

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

COPY ./app /app

Bygg Docker-bilde

I terminalen din, bruk følgende kommando for å bygge Docker-bildet:

docker build -t myfastapiapp .

Kjør Docker-container

Kjør FastAPI-applikasjonen din:

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

Oppsummering

I denne artikkelen har vi detaljert hvordan du bruker FastAPI til å bygge høyytelses API-tjenester, fra miljøforberedelse til opprettelse av grunnleggende API, definisjon av ruter og datamodeller, til å legge til autentisering og distribusjon. FastAPI tilbyr mange kraftige funksjoner som gjør det enkelt og effektivt å bygge moderne API-er. Du kan utforske flere funksjoner og egenskaper gjennom den offisielle dokumentasjonen. Vi håper denne artikkelen kan hjelpe deg med å komme raskere i gang med FastAPI og effektivt forbedre utviklingseffektiviteten i prosjektene dine!