Hur FastAPI och Middleware Förbättrar Din API-hantering

FastAPI erbjuder en elegant lösning för att bygga kraftfulla och effektiva REST API:er genom att kombinera enkelhet med flexibilitet. En viktig aspekt av FastAPI är användningen av APIRouter, vilket gör det möjligt att strukturera applikationen genom att gruppera relaterade endpoints. Genom att använda taggar kan du snabbt gruppera olika routrar och skapa en mer organiserad och lättnavigerad API-struktur. Dessutom kan FastAPI hantera beroenden för autentisering eller andra funktioner som behövs för specifika vägar, vilket gör applikationen både säker och skalbar.

När du definierar en APIRouter i FastAPI, är prefixet obligatoriskt, då applikationen måste veta på vilken URL den ska montera routern. Det finns en särskild fördel med detta tillvägagångssätt – det gör det möjligt att bygga parallella eller hierarkiska routrar, vilket gör att även komplexa endpointstrukturer blir hanterbara. När du testar applikationen med Uvicorn och navigerar till den automatiskt genererade dokumentationen, kommer du att se att de olika routrarna behandlas som separata endpoints men är grupperade under relevanta taggar. Detta gör navigeringen och testningen mycket enklare.

En annan kraftfull funktion är att FastAPI tillåter att routrar kan nästlas, vilket skapar en mycket flexibel struktur för att hantera komplexa hierarkier av endpoints. Detta gör det möjligt för utvecklare att organisera sina API:er på ett sätt som är både överskådligt och effektivt. Routrar fungerar som delsystem i en applikation och är inte avsedda att användas fristående, även om det är möjligt att montera separata FastAPI-applikationer under specifika sökvägar – men det är en mer avancerad funktion som ligger utanför denna bok.

Middleware är en annan kritisk komponent i FastAPI. Den fungerar på samma sätt som i andra populära webbramverk som Django eller Express.js, och erbjuder utvecklare möjlighet att påverka både begärningar och svar i applikationen. Middleware-funktioner är de som körs på varje begäran och gör det möjligt att manipulera begäran innan den når själva applikationen, eller att göra ytterligare ändringar i svaret innan det skickas tillbaka till klienten. FastAPI bygger på ASGI-specifikationen, vilket gör middleware lätt att implementera och flexibel nog att användas för hela applikationen eller specifika delar genom APIRouters.

I praktiken kan du skapa en enkel middleware-funktion i FastAPI genom att definiera en funktion som tar emot begäran och sedan anropar en call_next-funktion. Här är ett exempel på hur en sådan middleware kan se ut i en FastAPI-applikation:

python
Copy code
from fastapi import FastAPI, Request

from random import randint
app = FastAPI()
@app.middleware("http")
async def add_random_header(request: Request, call_next):
    number = randint(1, 10)
    response = await call_next(request)
    response.headers["X-Random-Integer"] = str(number)
    return response
@app.get("/")
async def root():
    return {"message": "Hello World"}

När denna applikation startas kommer varje begäran till rotvägen ("/") att få ett svar med en rubrik som innehåller ett slumptal mellan 1 och 10. Detta är ett enkelt exempel på hur middleware kan användas för att manipulera HTTP-svar och tillhandahålla dynamiskt innehåll vid varje begäran. Middleware är särskilt användbart i applikationer som hanterar autentisering, cross-origin resource sharing (CORS), omdirigeringar och proxyhantering.

Sammanfattningsvis gör FastAPI:s användning av APIRouters och middleware det till ett exceptionellt verktyg för utvecklare som vill bygga skalbara och modulära API:er. Genom att strukturera applikationen med hjälp av routrar och använda middleware för att fånga och manipulera begärningar och svar, kan utvecklare skapa flexibla och effektiva applikationer som kan anpassas efter specifika behov. Vidare gör användningen av taggar i APIRouters det lättare att hålla reda på och organisera olika delar av API:t, vilket leder till en mer underhållbar kodbas.

För att utnyttja FastAPI på bästa sätt är det dock viktigt att förstå de underliggande koncepten för hur middleware och routrar samverkar och hur de kan anpassas för att möta applikationens specifika krav. Denna grundläggande förståelse kommer inte bara hjälpa till att skriva effektivare kod, utan också att skapa en mer robust applikation på lång sikt.

Hur man bygger en autentisering och auktorisering med JWT i FastAPI

Först och främst måste du skapa klassen AuthHandler och importera de nödvändiga modulerna. Denna klass kommer att hantera all logik för lösenordshantering, JWT-token generering och verifikation av användares autentisering. I vårt exempel kommer vi att använda FastAPI:s HTTPBearer för att hantera säkerheten och passlib för att hash lösenord.

Hashning av lösenord

Funktionen get_password_hash gör just detta. Den hashad lösenordet som lagras i databasen ser ut så här:

python
Copy code
def get_password_hash(self, password: str) -> str:
    return self.pwd_context.hash(password)

Denna funktion använder passlib.context för att hash lösenordet med en algoritm som heter bcrypt. Hashen gör att lösenordet inte kan återvinnas, vilket ökar säkerheten.

Verifiering av lösenord

python
Copy code
def verify_password(self, plain_password: str, hashed_password: str) -> bool:
    return self.pwd_context.verify(plain_password, hashed_password)

Om lösenorden stämmer överens returnerar funktionen True, annars False.

Token Encoding

Funktionen encode_token tar användarens ID och användarnamn och skapar en payload som kodas med en hemlig nyckel:

python
Copy code
def encode_token(self, user_id: int, username: str) -> str:
    payload = {
        "exp": datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(minutes=30),
        "iat": datetime.datetime.now(datetime.timezone.utc),
        "sub": {"user_id": user_id, "username": username},
    }
    return jwt.encode(payload, self.secret, algorithm="HS256")

Här definieras tre viktiga delar:

• exp: Utgångsdatumet för tokenet (30 minuter i detta exempel).

• iat: Tidsstämpeln när tokenet skapades.

• sub: Den användardata som lagras i tokenet, exempelvis användar-ID och användarnamn.

Dekodning av token

För att verifiera om användaren verkligen är autentiserad vid varje begäran måste vi kunna dekoda JWT:n och kontrollera att den är giltig. Om tokenet har gått ut eller om det är ogiltigt, kastar vi ett undantag:

python
Copy code
def decode_token(self, token: str):

    try:
        payload = jwt.decode(token, self.secret, algorithms=["HS256"])
        return payload["sub"]
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="Signature has expired")
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

Detta gör att vi kan säkerställa att varje begäran som kräver autentisering är korrekt verifierad och att användaren inte kan använda ett utgånget eller ogiltigt token.

Säkerhet och beroende

Den sista delen av implementeringen innebär att skapa en säkerhetsberoende funktion som kan injiceras i alla rutter som kräver autentisering. Funktionen auth_wrapper används för att kontrollera om en begäran innehåller ett giltigt JWT som skickas som en bearertoken i begärans header.

python
Copy code
def auth_wrapper(self, auth: HTTPAuthorizationCredentials = Security(security)) -> dict:

    return self.decode_token(auth.credentials)

Denna funktion ser till att alla skyddade rutter skyddas av en säker autentisering, vilket gör att obehöriga användare inte kan komma åt dessa resurser.

Skapa en router för användare

Efter att ha implementerat autentiseringen är det dags att skapa en router som hanterar användarens registrering och inloggning. Denna router kommer att ta emot en begäran om att registrera en ny användare och skapa ett nytt användarkonto med ett hashat lösenord.

python
Copy code
@router.post("/register", response_description="Register user")

async def register(request: Request, newUser: UserIn = Body(...)) -> UserBase:

    users = json.loads(open("users.json").read())["users"]
    newUser.password = auth_handler.get_password_hash(newUser.password)
    if any(user["username"] == newUser.username for user in users):
        raise HTTPException(status_code=409, detail="Username already taken")
    newUser = jsonable_encoder(newUser)
    newUser["id"] = str(uuid.uuid4())
    users.append(newUser)

    with open("users.json", "w") as f:

        json.dump({"users": users}, f, indent=4)
    return newUser

I detta exempel används en enkel JSON-fil som en "mock"-databas för att lagra användarinformation och lösenord. Den faktiska implementeringen skulle använda en riktig databas, men denna lösning fungerar bra för att testa och demonstrera autentisering och auktorisering.

Viktiga tillägg

Det är viktigt att förstå att hanteringen av säkerhet och autentisering kräver en noggrann planering, särskilt när det gäller att säkert lagra och hantera hemliga nycklar och känslig användardata. Det är också avgörande att inte bara skapa ett säkerhetssystem, utan att kontinuerligt testa och uppdatera det för att hantera nya säkerhetshot.

För en mer avancerad lösning kan det vara nödvändigt att införa fler säkerhetslager, till exempel 2FA (tvåfaktorsautentisering), återkalla åtkomst med hjälp av svartlistade token eller introducera rättighetsbaserad åtkomstkontroll för olika användarroller.

Vad är FARM-stack och hur passar komponenterna ihop?

FARM-stack är en uppsättning teknologier som tillsammans skapar en robust och effektiv miljö för webbutveckling. Namnet FARM kommer från de fyra huvudkomponenterna: FastAPI, React, MongoDB och Uvicorn. Varje komponent bidrar med en specifik funktion som gör det möjligt att bygga dynamiska, skalbara och högpresterande webbaserade applikationer. Tanken bakom att kombinera dessa teknologier är att skapa en effektiv arbetsmiljö som främjar snabb utveckling, flexibilitet och långsiktig underhållbarhet.

För att förstå FARM-stacken behöver man först förstå varje delkomponent och hur de samverkar. En grundläggande webblösning består vanligtvis av ett operativsystem, en lagringslösning, en webserver och ett utvecklingsverktyg. I denna bok fokuserar vi på hur dessa komponenter fungerar tillsammans i FARM-stack, särskilt genom att använda MongoDB som databas, FastAPI som webbramverk, React för frontend, och Uvicorn för serverhantering.

MongoDB, den NoSQL-databas som vi använder i denna stack, erbjuder en flexibel och skalbar lösning som är perfekt för att hantera stora mängder ostrukturerad data. MongoDB lagrar data i ett JSON-liknande format (BSON), vilket gör att det passar naturligt ihop med REST API:er som skickar och tar emot JSON-data. MongoDB:s flexibilitet med scheman gör det enklare att iterera och ändra datamodellen över tid, vilket är avgörande för snabb utveckling.

FastAPI är ett modernt och snabbt Python-baserat webbramverk som gör det möjligt att bygga REST API:er snabbt och effektivt. FastAPI är särskilt designat för att stödja asynkrona operationer och högpresterande API:er, vilket gör det utmärkt för applikationer som behöver hantera många samtidiga förfrågningar. FastAPI:s användning av Python-typning gör det också enklare att skriva och underhålla kod.

React, å andra sidan, är ett av de mest populära JavaScript-biblioteken för att bygga användargränssnitt. Med hjälp av React kan utvecklare skapa dynamiska och responsiva användargränssnitt som snabbt kan uppdateras baserat på användarinteraktioner. Det är ett utmärkt val för att bygga moderna webbaserade applikationer, och när det kombineras med FastAPI:s kraftfulla backendkapabiliteter, kan man skapa en fullstack-lösning som är både snabb och effektiv.

FARM-stacken är en av de mest moderna och flexibla lösningarna för att bygga webapplikationer idag, och den passar särskilt bra för små till medelstora applikationer där snabb utveckling och skalbarhet är av högsta prioritet. Det faktum att alla delar är öppna och väldokumenterade gör att utvecklare snabbt kan komma igång och börja bygga kraftfulla applikationer.

En viktig aspekt av FARM-stacken är dess förmåga att snabbt anpassa sig till förändrade krav. Eftersom MongoDB är en NoSQL-databas kan den enkelt anpassa sig till nya databehov utan att behöva omstrukturera databasen. På samma sätt erbjuder FastAPI stor flexibilitet när det gäller att hantera olika typer av HTTP-förfrågningar och göra asynkrona operationer på servern. Detta gör att utvecklare kan skapa mer komplexa och anpassade lösningar med mindre kod och färre begränsningar.

MongoDB, till exempel, ger en flexibel datamodell som gör det möjligt att lagra data på ett sätt som inte kräver strikt databasdesign från början. Detta betyder att man kan göra ändringar och justeringar av datamodellen under utvecklingens gång utan att behöva göra stora omarbetningar. FastAPI:s användning av asynkron programmering gör det möjligt att hantera stora mängder användarförfrågningar snabbt och effektivt.

En annan fördel med FARM-stacken är den höga graden av kompatibilitet mellan varje komponent. MongoDB:s schemalösa databasdesign passar perfekt med React:s komponentbaserade arkitektur, vilket gör det möjligt för utvecklare att enkelt hantera både frontend och backend utan att behöva hantera en komplex datamodell eller göra omfattande konfigurationer.

Det är också viktigt att tänka på att även om FARM-stacken är mycket kraftfull, finns det inga teknologier som är universella lösningar. För mycket stora och komplexa applikationer kan det finnas behov av att använda andra verktyg och teknologier, som till exempel mer traditionella SQL-databaser eller tunga backend-ramverk som Django. Men för små och medelstora applikationer, där snabb utveckling och flexibilitet är viktiga, erbjuder FARM-stacken en fantastisk lösning.

Hur Bygger Man En Backend med FastAPI och Beanie?

När vi pratar om backendutveckling i Python är det svårt att komma förbi de enorma fördelarna som kommer med användningen av Beanie ODM (Object Document Mapper) och FastAPI. Dessa två verktyg erbjuder en kraftfull och modern lösning för att skapa skalbara applikationer med MongoDB som databas, särskilt när du vill använda asynkron bearbetning och dra nytta av Pydantic för validering och typkontroll. Här får du en inblick i hur du bygger en backend med hjälp av dessa verktyg, tillsammans med en integration av OpenAI och funktionalitet för att skicka e-post.

Objekt-Dokument-Mappning med Beanie

Beanie är ett populärt ODM-verktyg för MongoDB som låter utvecklare interagera med databasen genom att skapa Python-klasser som representerar NoSQL-dokument. Med Beanie slipper man mycket av den boilerplate-kod som annars krävs för att hantera dokument och samlingar i MongoDB. Varje dokumentklass mappas till en motsvarande MongoDB-samling, och Beanie tar hand om all databasinteraktion, vilket gör att utvecklaren kan fokusera på applikationens logik snarare än på att hantera lågnivåoperationer.

En av Beanies största fördelar är dess asynkrona natur. Byggt på Motor, en asynkron drivrutin för MongoDB, är Beanie perfekt för att bygga högpresterande och skalbara applikationer i FastAPI. En annan fördel är att Beanie är baserat på Pydantic, vilket betyder att du får hela Pydantics kraftfulla funktioner för typvalidering och dataparsering direkt från början. Det betyder att du slipper definiera egna valideringar och kan direkt använda Pydantic-modeller för att säkerställa att alla in- och utdata är korrekta.

När du använder Beanie, får du också en enkel hantering av MongoDB:s ObjectId, vilket ofta kan vara en källa till förvirring och extrakod när du arbetar direkt med PyMongo. Beanie hanterar detta elegant och gör att du kan arbeta med ObjectId som vanliga Pydantic-objekt, vilket underlättar både kodläsbarhet och felsökning.

FastAPI och Beanie i Praktiken

Först definierar du en basmodell för användare i Beanie. Denna modell ärver från Beanies Document-klass och innehåller de fält som du vill lagra för varje användare. Eftersom Beanie är baserat på Pydantic, kan du använda alla de typvalideringar som erbjuds av Pydantic, som min- och maxlängd på strängar eller definiera standardvärden för datum. Du kan också använda inställningar för att definiera hur samlingarna i databasen ska hanteras, till exempel namnet på samlingen, caching och indexering.

Sedan kan du skapa ytterligare Pydantic-modeller som används för specifika API-anrop, som till exempel registrering, inloggning, eller att hämta information om den nuvarande användaren. Dessa modeller används för att säkerställa att API:ets in- och utdata följer de specifikationer som definieras för varje anrop.

För att ta nästa steg i projektet skapar du modeller för andra objekt i din applikation, som exempelvis bilar. Här definierar du en Car-modell som representerar en bil i databasen. Denna modell kan innehålla fält som märke, årsmodell, pris, beskrivning och bild-URL. Du kan även skapa relationer mellan dokument, som att en bil kan referera till en användare genom en Link till User-dokumentet. Detta gör att du kan hålla data strukturerad och undvika att duplicera användarinformation i varje bilobjekt.

Integration av Tredjepartstjänster

Att integrera dessa funktioner i din FastAPI-applikation innebär att du kommer att arbeta med externa API:er och hantera deras autentisering och felhantering. För dessa tredjepartstjänster, måste du även tänka på CORS-inställningar och säkerställa att dessa externa anrop inte påverkar applikationens prestanda eller säkerhet negativt.

Det är viktigt att förstå att även om det här kapitlet erbjuder en teknisk guide för att bygga en backend med FastAPI och Beanie, så måste du alltid vara medveten om säkerhetsfrågor som kan uppstå när du arbetar med externa tjänster och användardata. Till exempel, hantering av känslig information som användarlösenord och autentisering måste göras på ett säkert sätt, helst genom att använda hashingalgoritmer och säker autentisering via JWT.

Endtext

Hur kan React och MongoDB samarbeta i moderna webbapplikationer?

I dagens snabbt föränderliga värld av webbapplikationer finns det många teknologier som kan hjälpa utvecklare att bygga snabba, dynamiska och skalbara lösningar. En populär och effektiv kombination är användningen av React för frontend och MongoDB för datalagring. Tillsammans erbjuder dessa teknologier en flexibel och kraftfull stack, ofta kallad FARM (FastAPI, React, MongoDB). För att förstå hur dessa teknologier samverkar och varför de är ett så bra val för webbutveckling, är det viktigt att först titta på de grundläggande funktionerna och fördelarna med varje komponent i denna stack.

När det kommer till datalagring erbjuder MongoDB en flexibel och skalbar lösning. Till skillnad från traditionella relationsdatabaser är MongoDB en dokumentorienterad databas. Detta innebär att data lagras som dokument, vilket är JSON-liknande objekt bestående av nyckel-värdepar. En stor fördel med MongoDB är dess flexibilitet; dokument i samma samling (collection) kan ha olika fält och datatyper. Detta gör det enkelt att ändra strukturen på din databas när applikationens behov utvecklas, utan att behöva bryta existerande data.

I en typisk FARM-stackapplikation används MongoDB för att lagra och hämta data från en databas, medan React används för att skapa ett användargränssnitt som dynamiskt uppdaterar baserat på användarens input. Till exempel, om en användare söker efter specifika bilar i en lista, kan React skicka en förfrågan till servern som returnerar data från MongoDB. Denna samverkan gör det möjligt för utvecklare att bygga responsiva, realtidsbaserade webbapplikationer som kan hantera stora mängder data utan att offra prestanda.

En annan fördel med MongoDB är dess aggregeringsramverk, som gör det möjligt att köra komplexa sökfrågor och analyser på databasen. Tänk dig att du har en databas med miljontals bilposter och vill filtrera dessa efter flera kriterier. MongoDB:s aggregeringsramverk ger dig möjlighet att köra kraftfulla, optimerade frågor för att hämta precis den data du behöver. Detta gör det till ett utmärkt val för applikationer som kräver snabb och flexibel databehandling.

Men även om React och MongoDB erbjuder kraftfulla funktioner, finns det några viktiga saker att tänka på när du bygger webbapplikationer med dessa teknologier. För det första, även om React gör det enkelt att bygga användargränssnitt, kan det bli komplicerat när applikationen växer i storlek och komplexitet. För att hantera stora applikationer effektivt kan det vara nödvändigt att använda externa bibliotek som Redux eller React Context för att hantera delat tillstånd. Dessa verktyg gör det lättare att hantera data mellan olika komponenter, särskilt i större applikationer.

För det andra, även om MongoDB:s flexibilitet är en stor fördel, kan det också leda till problem om datamodellen inte planeras ordentligt från början. Eftersom dokument i en MongoDB-samling inte behöver följa en strikt schema kan det vara lätt att skapa en databasstruktur som blir svår att underhålla och optimera på lång sikt. Därför är det viktigt att tänka noga på hur data ska organiseras och vilka datatyper som ska användas när man designar sin databas.

Sammanfattningsvis erbjuder FARM-stackens kombination av React och MongoDB en mycket kraftfull plattform för att bygga moderna webbapplikationer. React gör det enkelt att skapa dynamiska användargränssnitt, medan MongoDB erbjuder en flexibel och skalbar lösning för att lagra och hämta data. Men för att fullt ut dra nytta av dessa teknologier är det viktigt att tänka på hur man hanterar tillstånd i React och hur man designar sin databas i MongoDB.