Hur man bygger högpresterande API-tjänster med FastAPI

FastAPI är ett modernt, snabbt (effektivt) webb ramverk, speciellt designat för att bygga API:er. Det är baserat på Python-typanvisningar och stöder asynkron programmering, vilket gör att utvecklare kan bygga högpresterande, hög tillgänglighet och låg latens API-tjänster. Denna artikel kommer att ge en detaljerad genomgång av hur man använder FastAPI för att bygga högpresterande API-tjänster, vi kommer att gå igenom stegen för att hjälpa dig att genomföra hela processen från miljöuppsättning till distribution.

Steg 1: Förberedelse av miljö

Du behöver se till att Python 3.6+ är installerat i din utvecklingsmiljö. Om det inte är installerat kan du besöka Python officiella webbplats för att ladda ner och installera det.

Installera FastAPI och Uvicorn

FastAPI i sig erbjuder ingen tjänst, den behöver en ASGI-server för att köras. Här använder vi Uvicorn, en högpresterande ASGI-server. Du kan installera FastAPI och Uvicorn med följande kommando:

pip install fastapi uvicorn

Steg 2: Bygg en grundläggande API

Låt oss skapa en enkel FastAPI-applikation.

Skapa applikationsfil

I din projektmapp, skapa en Python-fil, till exempel main.py, och skriv följande kod:

from fastapi import FastAPI

app = FastAPI()

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

I koden ovan importerar vi först FastAPI och skapar en app-instans. Sedan definierar vi en GET-rutt som returnerar ett enkelt JSON-svar när roten / nås.

Starta servern

Starta din FastAPI-server med följande kommando:

uvicorn main:app --reload

main: hänvisar till filnamnet utan .py-suffix.
app: hänvisar till FastAPI-instansen.
--reload: i utvecklingsläge, startar om servern automatiskt vid filändringar.

Steg 3: Definiera rutter och datamodeller

För att bygga komplexa API:er behöver du använda Pydantic för att definiera datamodeller.

Skapa datamodell

Lägg till följande innehåll i main.py:

from pydantic import BaseModel

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

Denna kod skapar en datamodell Item med tre attribut: produktnamn, pris och tillgänglighet.

Lägg till nya rutter

Därefter kan vi definiera en ny POST-rutt för att ta emot data av typen Item:

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

I denna rutt kommer FastAPI automatiskt att validera den inkommande datan och mappa den till Item-modellen.

Steg 4: Automatisk dokumentation

En av FastAPIs största fördelar är att den kan generera API-dokumentation automatiskt. Du kan se den genom att besöka följande adresser:

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

I dessa genererade dokument kan du interaktivt testa API:et och se begäran och svarformat för varje rutt.

Steg 5: Lägg till autentisering

I praktiska tillämpningar är autentisering en viktig del. Låt oss lägga till en enkel rollbaserad autentisering.

Lägg till säkerhetsberoenden

Använd FastAPIs Depends-metod och OAuth2PasswordBearer för att implementera 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="Ogiltiga autentiseringsuppgifter")
    return user

Skydda rutter

Därefter kan du lägga till autentisering till de rutter som behöver skyddas:

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

Steg 6: Distribuera FastAPI-applikationen

När du har slutfört utvecklingen kan du behöva distribuera applikationen på en molnserver. Du kan välja att använda Docker för distribution.

Skapa Dockerfile

Skapa en fil med namnet Dockerfile i projektmappen och skriv följande innehåll:

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

COPY ./app /app

Bygg Docker-bild

I din terminal, använd följande kommando för att bygga Docker-bilden:

docker build -t myfastapiapp .

Kör Docker-container

Kör din FastAPI-applikation:

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

Sammanfattning

I denna artikel har vi detaljerat förklarat hur man använder FastAPI för att bygga högpresterande API-tjänster, från miljöförberedelse till skapande av grundläggande API, definiering av rutter och datamodeller, samt tillägg av autentisering och distribution. FastAPI erbjuder många kraftfulla funktioner som gör det enkelt och effektivt att bygga moderna API:er, och du kan utforska fler funktioner och egenskaper genom den officiella dokumentationen. Vi hoppas att denna artikel kan hjälpa dig att snabbt komma igång med FastAPI och effektivt öka din projektutveckling!