FastAPI är en snabb och lätt webbram för att bygga moderna gränssnitt för tillämpningsprogrammering med hjälp av Python 3.6 och senare. I den här handledningen så går vi igenom grunderna för att bygga en app med FastAPI, och du får lära dig lite om varför detta nominerades som ett av de bästa ramverken med öppen källkod år 2021.
När du väl är redo att utveckla dina egna FastAPI-appar så behöver du inte leta länge efter en plats där du kan hosta dem. Kinsta’s tjänster för applikations- och databashosting erbjuder en ”Platform As a Service” som är stark på Python.
Låt oss först lära oss grunderna.
Fördelar med FastAPI
Nedan följer några av de fördelar som FastAPI-ramverket ger ett projekt.
- Hastighet: Som namnet antyder så är FastAPI ett mycket snabbt ramverk. Hastigheten är jämförbar med Go och Node.js, som allmänt anses vara bland de snabbaste alternativen för att bygga API: er.
- Lätt att lära sig och koda: FastAPI har redan räknat ut nästan allt som du behöver för att göra ett produktionsklart API. Som utvecklare som använder FastAPI så behöver du inte koda allt från grunden. Med endast några få rader kod så kan du ha ett RESTful API som är redo för distribuering.
- Omfattande dokumentation: FastAPI använder OpenAPI-dokumentationsstandarderna, så att dokumentation kan genereras dynamiskt. Dokumentationen innefattar detaljerad information om FastAPI: s ändpunkter, svar, parametrar och returkoder.
- API: er med färre fel: FastAPI stöder anpassad datavalidering, vilket gör att utvecklare kan bygga API:er med färre fel. FastAPI: s utvecklare skryter med att ramverket resulterar i så mycket som 40 % färre mänskligt orsakade fel.
- Typtips: Modulen types introducerades i Python 3.5. Den gör det möjligt att deklarera
type
för en variabel. När typen av en variabel deklareras så kan IDE: er ge ett bättre stöd och förutsäga fel mer exakt.
Hur man kommer igång med FastAPI
För att följa den här handledningen och komma igång med FastAPI så måste du först göra några saker.
Se till att du har en texteditor/IDE för programmerare, exempelvis Visual Studio Code. Andra alternativ är Sublime Text och Espresso.
Det är vanligt att dina Pythonprogram och deras instanser körs i virtuella miljöer. Virtuella miljöer gör det möjligt att köra olika paketuppsättningar och konfigurationer samtidigt och undvika konflikter på grund av inkompatibla paketversioner.
För att skapa en virtuell miljö så öppnar du din terminal och kör det här kommandot:
$ python3 -m venv env
Du måste även aktivera den virtuella miljön. Kommandot för att göra detta varierar beroende på vilket operativsystem och skal som du använder. Här är några exempel på CLI-aktivering för ett antal miljöer:
# On Unix or MacOS (bash shell):
/path/to/venv/bin/activate
# On Unix or MacOS (csh shell):
/path/to/venv/bin/activate.csh
# On Unix or MacOS (fish shell):
/path/to/venv/bin/activate.fish
# On Windows (command prompt):
pathtovenvScriptsactivate.bat
# On Windows (PowerShell):
pathtovenvScriptsActivate.ps1
(Vissa IDE: er med Python-kunskap kan även konfigureras för att aktivera den aktuella virtuella miljön)
Nu kan du installera FastAPI:
$ pip3 install fastapi
FastAPI är ett ramverk för att bygga API: er, men för att testa dina API: er så behöver du en lokal webbserver. Uvicorn är en blixtsnabb ASGI-webbserver (Asynchronous Server Gateway Interface) för Python som är utmärkt för utveckling. För att installera Uvicorn så kör du det här kommandot:
$ pip3 install "uvicorn[standard]"
När installationen har lyckats så skapar du en fil med namnet main.py i projektets arbetskatalog. Denna fil kommer att vara din applikationsstartpunkt.
Ett snabbt FastAPI-exempel
Du kommer att testa din FastAPI-installation genom snabb konfigurering av en exempeländpunkt. Klistra in följande kod i din fil main.py och spara sedan filen:
# main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def root():
return {"greeting":"Hello world"}
Ovanstående utdrag skapar en grundläggande FastAPI-slutpunkt. Nedan följer en sammanfattning av vad varje rad gör:
from fastapi import FastAPI
: Funktionaliteten för ditt API tillhandahålls av FastAPI Python-klassen.app = FastAPI()
: Detta skapar en FastAPI-instans.@app.get("/")
: Detta är en Python-dekorator som anger för FastAPI att funktionen nedanför den ska ansvara för hanteringen av förfrågningar.@app.get("/")
: Detta är en dekorator som anger vägen. Detta skapar enGET
-metod på webbplatsens sökväg. Resultatet returneras sedan av den inplacerade funktionen.- Andra möjliga operationer som används för att kommunicera är
@app.post()
,@app.put()
,@app.delete()
,@app.options()
,@app.head()
,@app.patch()
och@app.trace()
.
I filkatalogen så kör du följande kommando i terminalen för att starta API-servern:
$ uvicorn main:app --reload
I det här kommandot så är main
namnet på din modul. Objektet app
är en instans av din applikation och importeras till ASGI-servern. Flaggan --reload
anger att servern ska laddas om automatiskt när du gör ändringar.
Du bör se något liknande i din terminal:
$ uvicorn main:app --reload
INFO: Will watch for changes in these directories: ['D:\WEB DEV\Eunit\Tests\fast-api']
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [26888] using WatchFiles
INFO: Started server process [14956]
INFO: Waiting for application startup.
INFO: Application startup complete.
Navigera till http://localhost:8000
i din webbläsare för att bekräfta att ditt API fungerar. Du bör se ”Hello”: ”World” som ett JSON-objekt på sidan. Detta visar hur enkelt det är att skapa ett API med FastAPI. Allt som du behövde göra var att definiera en rutt och returnera din Python-ordbok, vilket syns på rad sex i utklippet ovan.
Användning av typtips
Om du använder Python så är du van vid att ange variabler med grundläggande datatyper som int
, str
, float
och bool
. Från och med Python’s version 3.9 har det dock införts avancerade datastrukturer. Detta gör att du kan arbeta med datastrukturer som dictionaries
, tuples
och lists
. Med FastAPI: s typhänvisningar så kan du strukturera schemat för dina data med hjälp av pydantiska modeller och sedan använda de pydantiska modellerna för att typhänvisa och dra nytta av den datavalidering som tillhandahålls.
I exemplet nedan så demonstreras användningen av typtips i Python med en enkel prisberäknare för måltider, calculate_meal_fee
:
def calculate_meal_fee(beef_price: int, meal_price: int) -> int:
total_price: int = beef_price + meal_price
return total_price
print("Calculated meal fee", calculate_meal_fee(75, 19))
Observera att typtips inte ändrar hur din kod körs.
Interaktiv API-dokumentation i FastAPI
FastAPI använder Swagger UI för att tillhandahålla en automatisk interaktiv API-dokumentation. För att komma åt den, navigera till http://localhost:8000/docs
så kommer du att se en skärm med alla dina slutpunkter, metoder och scheman.
Denna automatiska, webbläsarbaserade API-dokumentation tillhandahålls av FastAPI och du behöver inte göra något annat för att dra nytta av den.
En alternativ webbläsarbaserad API-dokumentation, som också tillhandahålls av FastAPI, är Redoc. För att få tillgång till Redoc så navigerar du till http://localhost:8000/redoc
, där du kommer att få en lista över dina slutpunkter, metoder och deras respektive svar.
Upprättande av rutter i FastAPI
Med dekoratorn @app
så kan du ange ruttens metod, t.ex. @app.get
eller @app.post
, som stöder GET
, POST
, PUT
och DELETE
, samt de mindre vanliga alternativen HEAD
, PATCH
och TRACE
.
Att bygga din app med FastAPI
I den här handledningen så får du en genomgång av hur du bygger en CRUD-applikation med FastAPI. Applikationen kommer att kunna:
- Skapa en användare
- Läsa en användares databaspost
- Uppdatera en befintlig användare
- Ta bort en viss användare
För att utföra dessa CRUD-operationer så kommer du att skapa metoder som exponerar API-slutpunkterna. Resultatet kommer att bli en minnesdatabas som kan lagra en lista över användare.
Du kommer att använda biblioteket pydantic för att utföra datavalidering och inställningshantering med hjälp av Python-typannotationer. I den här handledningen så kommer du att deklarera formen för dina data som klasser med attribut.
Den här handledningen kommer att använda databasen i minnet. Detta är för att komma igång snabbt med att använda FastAPI för att bygga dina API: er. För produktion så kan du dock använda dig av vilken databas som helst, t.ex. PostgreSQL, MySQL, SQLite eller till och med Oracle.
Att bygga appen
Du börjar med att skapa din användarmodell. Användarmodellen kommer att ha följande attribut:
id
: En universell unik identifierare (UUID)first_name
: Användarens förnamnlast_name
: Användarens efternamngender
: Användarens könroles
: En lista som innehåller rollernaadmin
ochuser
Börja med att skapa en ny fil som heter models.py i din arbetskatalog och klistra sedan in följande kod i models.py för att skapa din modell:
# models.py
from typing import List, Optional
from uuid import UUID, uuid4
from pydantic import BaseModel
from enum import Enum
from pydantic import BaseModel
class Gender(str, Enum):
male = "male"
female = "female"
class Role(str, Enum):
admin = "admin"
user = "user"
class User(BaseModel):
id: Optional[UUID] = uuid4()
first_name: str
last_name: str
gender: Gender
roles: List[Role]
I koden ovan:
- Din klass
User
utökarBaseModel
, som sedan importeras frånpydantic
. - Du har definierat användarens attribut enligt ovan.
Nästa steg är att skapa din databas. Ersätt innehållet i filen main.py med följande kod:
# main.py
from typing import List
from uuid import uuid4
from fastapi import FastAPI
from models import Gender, Role, User
app = FastAPI()
db: List[User] = [
User(
id=uuid4(),
first_name="John",
last_name="Doe",
gender=Gender.male,
roles=[Role.user],
),
User(
id=uuid4(),
first_name="Jane",
last_name="Doe",
gender=Gender.female,
roles=[Role.user],
),
User(
id=uuid4(),
first_name="James",
last_name="Gabriel",
gender=Gender.male,
roles=[Role.user],
),
User(
id=uuid4(),
first_name="Eunit",
last_name="Eunit",
gender=Gender.male,
roles=[Role.admin, Role.user],
),
]
I main.py:
- Du initialiserade
db
med enList
-typ och skickade in modellenUser
- Du skapade en minnesdatabas med fyra användare, var och en med de nödvändiga attributen
first_name
,last_name
,gender
ochroles
. AnvändarenEunit
tilldelas rollernaadmin
ochuser
, medan de andra tre användarna endast tilldelas rollenuser
.
Läs databasposter
Du har framgångsrikt konfigurerat din minnesdatabas och fyllt den med användare, så nästa steg är att konfigurera en slutpunkt som returnerar en lista över alla användare. Det är här som FastAPI kommer in i bilden.
I din fil main.py så klistrar du in följande kod precis under din slutpunkt Hello World
:
# main.py
@app.get("/api/v1/users")
async def get_users():
return db
Koden definierar slutpunkten /api/v1/users
och skapar en asynkron funktion, get_users
, som returnerar allt innehåll i databasen, db
.
Spara din fil så kan du testa din användarslutpunkt. Kör följande kommando i terminalen för att starta API-servern:
$ uvicorn main:app --reload
Navigera till http://localhost:8000/api/v1/users
i din webbläsare. Detta bör ge en lista över alla dina användare, som du ser nedan:
I det här skedet så kommer din fil main.py att se ut så här:
# main.py
from typing import List
from uuid import uuid4
from fastapi import FastAPI
from models import Gender, Role, User
app = FastAPI()
db: List[User] = [
User(
id=uuid4(),
first_name="John",
last_name="Doe",
gender=Gender.male,
roles=[Role.user],
),
User(
id=uuid4(),
first_name="Jane",
last_name="Doe",
gender=Gender.female,
roles=[Role.user],
),
User(
id=uuid4(),
first_name="James",
last_name="Gabriel",
gender=Gender.male,
roles=[Role.user],
),
User(
id=uuid4(),
first_name="Eunit",
last_name="Eunit",
gender=Gender.male,
roles=[Role.admin, Role.user],
),
]
@app.get("/")
async def root():
return {"Hello": "World",}
@app.get("/api/v1/users")
async def get_users():
return db
Skapa databasposter
Nästa steg är att skapa en slutpunkt för att skapa en ny användare i din databas. Klistra in följande utdrag i din fil main.py:
# main.py
@app.post("/api/v1/users")
async def create_user(user: User):
db.append(user)
return {"id": user.id}
I det här stycket så har du definierat slutpunkten för att skicka in en ny användare och använt dig av dekoratorn @app.post
för att skapa en POST
-metod.
Du har även skapat funktionen create_user
, som accepterar user
i modellen User
, och bifogat (lagt till) den nyskapade user
till databasen, db
. Slutligen så returnerar slutpunkten ett JSON-objekt med den nyskapade användarens id
.
Du måste använda den automatiska API-dokumentationen som tillhandahålls av FastAPI för att testa din slutpunkt, som ovan. Detta beror på att du inte kan göra en postförfrågan med hjälp av webbläsaren. Navigera till http://localhost:8000/docs
för att testa med hjälp av den dokumentation som tillhandahålls av SwaggerUI.
Radera databasposter
Eftersom du bygger en CRUD-app så måste din applikation ha möjlighet att ta bort en specificerad resurs. I den här handledningen så kommer du att skapa en slutpunkt för att ta bort en användare.
Klistra in följande kod i din fil main.py:
# main.py
from uuid import UUID
from fastapi HTTPException
@app.delete("/api/v1/users/{id}")
async def delete_user(id: UUID):
for user in db:
if user.id == id:
db.remove(user)
return
raise HTTPException(
status_code=404, detail=f"Delete user failed, id {id} not found."
)
Här är en uppdelning linje för linje av hur koden fungerar:
@app.delete("/api/v1/users/{id}")
: Du skapade slutpunkten delete med hjälp av dekoratorn@app.delete()
. Sökvägen är fortfarande/api/v1/users/{id}
, men sedan hämtasid
, som är en sökvägsvariabel som motsvarar användarens id.async def delete_user(id: UUID):
: Du skapar funktionendelete_user
, som hämtarid
från webbadressen.for user in db:
: Detta säger åt applikationen att gå igenom användarna i databasen och kontrollera omid
matchar en användare i databasen.db.remove(user)
: Omid
matchar en användare så raderas användaren, annars så skickas enHTTPException
med statuskoden 404.
Uppdatera databasposter
Du ska skapa en slutpunkt för att uppdatera en användares uppgifter. De uppgifter som kan uppdateras omfattar följande parametrar: first_name
, , last_name
, och roles
.
I din fil models.py så klistrar du in följande kod under din modell User
, dvs. efter klassen User(BaseModel):
:
# models.py
class UpdateUser(BaseModel):
first_name: Optional[str]
last_name: Optional[str]
roles: Optional[List[Role]]
I det här utdraget så är klassen UpdateUser
en förlängning av BaseModel
. Du ställer sedan in de uppdaterbara användarparametrarna, exempelvis first_name
, last_name
och roles
, som valfria.
Nu ska du skapa en slutpunkt för att uppdatera en viss användares uppgifter. I din fil main.py så klistrar du in följande kod efter @app.delete
-dekoratorn:
# main.py
@app.put("/api/v1/users/{id}")
async def update_user(user_update: UpdateUser, id: UUID):
for user in db:
if user.id == id:
if user_update.first_name is not None:
user.first_name = user_update.first_name
if user_update.last_name is not None:
user.last_name = user_update.last_name
if user_update.roles is not None:
user.roles = user_update.roles
return user.id
raise HTTPException(status_code=404, detail=f"Could not find user with id: {id}")
I koden ovan så har du gjort följande:
- Skapat
@app.put("/api/v1/users/{id}")
—slutpunkten för uppdatering. Den har variabel-parameternid
som motsvarar användarens id. - Skapat en metod som heter
update_user
, som tar emot klassenUpdateUser
ochid
. - Använt en
for
-slinga för att kontrollera om den användare som är associerad med överlämnatid
finns i databasen. - Kontrollerat om någon av användarens parametrar är
is not None
(inte noll). Om någon parameter, t.ex.first_name
,last_name
ellerroles
, inte är noll, så uppdateras den. - Om operationen är framgångsrik så returneras användaridentiteten.
- Om användaren inte kunde lokaliseras, så uppstår undantaget
HTTPException
med statuskoden 404 och meddelandetCould not find user with id: {id}
.
För att testa den här slutpunkten så måste du se till att din Uvicorn-server är igång. Om den inte är igång, så kan du ange det här kommandot:
uvicorn main:app --reload
Nedan visas en skärmdump av testet.
Sammanfattning
I den här handledningen så har du lärt dig mer om FastAPI-ramverket för Python och sett med egna ögon hur snabbt som du kan få igång en FastAPI-driven applikation. Du har lärt dig hur man bygger CRUD API-slutpunkter med hjälp av ramverket – skapa, läsa, uppdatera och radera databasposter.
Om du vill ta din webbapplikationsutveckling till nästa nivå så ska du se till att kolla in Kinsta’s plattform för applikations- och databashosting. Precis som FastAPI så är den kraftfullt enkel.
Lämna ett svar