I den här delen kommer du att lära dig hur man implementerar ett autentiseringsflöde baserat på JWT (JSON Web Tokens) i din applikation. Webbtjänster eller mobilapplikationer är inte särskilt användbara om de inte är säkra. Du har säkert hört talas om de små felen i autentisering som har lett till hundratusentals eller till och med miljontals komprometterade användarkonton, vilket kan exponera känslig och värdefull information.

FastAPI är byggt på OpenAPI, tidigare känt som Swagger, en öppen specifikation för att skapa API:er. OpenAPI gör det möjligt att definiera olika säkerhetsscheman som är kompatibla med olika protokoll, som apiKey, http, OAuth 2.0, OpenID Connect och så vidare. FastAPI:s dokumentation ger en utmärkt och detaljerad handledning om hur man skapar ett autentiseringsflöde baserat på OAuth 2.0-protokollet, som använder formulärdata för att skicka användarnamn och lösenord. I den här artikeln kommer vi att fokusera på hur du skapar en enklare autentisering med hjälp av JWT.

Först och främst behöver du skapa en användarmodell som gör det möjligt att identifiera användare entydigt. Den här modellen kommer att lagra grundläggande uppgifter som e-postadress, användarnamn och ett primärt nyckelfält som kan vara en UUID eller ObjectId beroende på databasens natur.

Användarmodell för autentisering

Varje autentisering bygger på en användarmodell, som måste kunna lagra en minimisättning av data för att kunna identifiera användarna entydigt. De vanligaste unika fälten är e-postadress, användarnamn och förstås en primärnyckel, exempelvis en UUID. Vid användning av MongoDB lagras dessa data i en samling, men det är viktigt att tänka på vilka frågor som applikationen kommer att göra oftast när du skapar din modell.

När du skapar en användarmodell för autentisering är det viktigt att tänka på databasens strukturer, särskilt i MongoDB där förhållanden mellan data inte alltid är lika uppenbara som i relationsdatabaser. Här är det viktigt att bygga förfrågningar på ett sådant sätt att de kan optimeras utifrån de vanligaste användarmönstren.

Bygg autentisering med FastAPI

Autentisering och auktorisering med FastAPI blir lättare att förstå genom exempel. I de följande sektionerna kommer du att utveckla ett enkelt men fullt fungerande autentiseringssystem. För att hålla exemplet kort och fokuserat kommer vi att skapa en JSON-filbaserad databas istället för en verklig MongoDB-anslutning, vilket simulerar en MongoDB-samling.

För att bygga ditt autentiseringsflöde måste du använda FastAPI:s inbyggda säkerhetsverktyg. När du deklarerar beroenden med OAuth2-scopes i FastAPI, använder du Security()-klassen. För att hantera autentisering med JWT behöver du även bearertokens för auktorisering, som du kan implementera genom att använda FastAPI:s HTTPBearer-modul.

Dessutom behöver du funktionalitet för att hasha och jämföra lösenord, vilket kan uppnås med hjälp av passlib, som innehåller en CryptContext-klass för att hantera vanliga uppgifter relaterade till hashing och jämförelse av lösenord.

PyJWT är också ett viktigt verktyg för att skapa och validera JWT. Genom att använda dessa verktyg kommer du kunna skapa ett autentiseringsflöde som använder JWT för att skydda dina rutter och hantera användaråtkomst.

Skapa användarmodellen

För att komma igång, skapa en användarmodell i din applikation. Denna modell ska innehålla de nödvändiga fälten som användarnamn, lösenord och id. Här är ett exempel på en enkel användarmodell baserad på FastAPI och Pydantic:

python
from pydantic import BaseModel, Field
from typing import List
class UserBase(BaseModel):
    id: str = Field(...)
    username: str = Field(..., min_length=3, max_length=15)
    password: str = Field(...)
class UserIn(BaseModel):
    username: str = Field(..., min_length=3, max_length=15)
    password: str = Field(...)
class UserOut(BaseModel):
    id: str = Field(...)
    username: str = Field(..., min_length=3, max_length=15)
class UsersList(BaseModel):
    users: List[UserOut]

Modellen UserBase motsvarar användarrepresentationen som lagras i din "dummy"-databas eller MongoDB-samling. Fältet id kommer att vara en UUID, vilket efterliknar MongoDB:s ObjectId. Modellen UserIn används för att ta emot användardata för registrering eller inloggning, medan UserOut används för att visa användardata utan lösenordet men med ID och användarnamn. UsersList används för att representera en lista med användare.

Bygg applikationen

När användarmodellen har skapats är nästa steg att bygga själva FastAPI-applikationen. Här definierar du applikationens grundläggande struktur. Det första steget är att skapa en ny Python-fil för att definiera applikationen och skapa de nödvändiga autentiseringselementen:

python
from fastapi import FastAPI


app = FastAPI()

Denna kod skapar en grundläggande FastAPI-applikation. Därefter kan du börja bygga din autentisering. För att hantera autentisering kommer du att behöva skapa en authentication.py-fil där du definierar logiken för användarregistrering, inloggning och JWT-generering.

När applikationen och autentisering är på plats kan du skapa skyddade rutter som kräver JWT för åtkomst. Detta görs genom att använda beroenden i FastAPI för att verifiera JWT-token och autentisera användare vid varje begäran.

Viktiga överväganden för användaren

För att säkerställa att autentiseringsflödet är säkert och effektivt är det viktigt att tänka på några ytterligare aspekter. Använd starka och säkra metoder för att lagra lösenord, såsom bcrypt, och använd alltid HTTPS för att skydda dataöverföringar. När du arbetar med JWT, se till att hantera tokenets livslängd och uppdatering noggrant för att förhindra obehörig åtkomst.

Genom att följa dessa principer kan du bygga ett säkert och robust autentiseringssystem för din applikation, vilket är avgörande för att skydda användardata och upprätthålla applikationens integritet.

Hur FARM-stacken kan användas för att bygga kraftfulla webbapplikationer

React har länge varit en av de mest populära ramverken för att bygga användargränssnitt, och med introduktionen av funktionella komponenter, som sedan 2024 har blivit den föredragna metoden, har React utvecklats till ett ännu mer kraftfullt verktyg för webbutveckling. Funktionella komponenter är inte bara mer koncisa, utan även lättare att underhålla och mer flexibla jämfört med de äldre klassbaserade komponenterna. En grundläggande förståelse för hur och varför dessa komponenter fungerar på det sätt de gör, kan förvandla en utvecklare till en betydligt mer skicklig React-användare.

FARM-stacken, som består av FastAPI, React, och MongoDB, erbjuder ett modulärt och flexibelt ramverk för att bygga moderna webbapplikationer. FastAPI är en asynkron Python-webbramverk som gör det enkelt att bygga snabb och effektiv backend. Tillsammans med React och MongoDB kan utvecklare skapa skalbara och responsiva webbtjänster för alla typer av användningsfall. Det finns dock några viktiga överväganden att tänka på innan man sätter igång.

Autentisering och auktorisation är en av de mest kritiska delarna när man bygger webbapplikationer. Kapitel 6 behandlar hur man implementerar en JWT-baserad autentisering med FastAPI, vilket är en vanlig lösning. Men det är viktigt att förstå att denna lösning inte passar alla typer av applikationer. För vissa projekt kan det vara mer lämpligt att använda tredjepartslösningar som Firebase, Auth0 eller Cognito. Innan man väljer en sådan lösning är det avgörande att förstå både fördelarna och nackdelarna, inklusive kostnaderna för skalning, samt eventuella problem med att bli inlåst i en specifik tjänst.

Datavisualisering är en annan aspekt där FARM-stacken glänser. Med React som frontend och MongoDB som databashanterare, är möjligheterna för att skapa komplexa datavisualiseringar oändliga. Här handlar det inte bara om att bygga snygga diagram och grafer, utan om att kunna manipulera och presentera data på ett sätt som är både informativt och lättförståeligt. Det är inte alltid nödvändigt att skapa komplexa visualiseringar som de som görs med D3.js, utan ofta räcker det med enklare visualiseringar som stapeldiagram eller linjediagram för att förmedla viktig information. Med rätt backend och MongoDB kan man hantera och visualisera stora mängder data utan att tappa prestanda.

För projekt som kräver relationella databaser, som SQL-databaser med strikt struktur, behöver man inte överge FARM-stacken helt och hållet. FastAPI:s modulära natur gör det möjligt att integrera relationella databaser som PostgreSQL eller MySQL utan större svårigheter. Genom att använda SQLAlchemy eller andra asynkrona Python-drivrutiner för databaser kan man bygga robusta applikationer som hanterar både strukturerad och ostrukturerad data, till exempel genom att kombinera MongoDB och en SQL-databas i samma applikation.

För att ge praktisk insikt i hur man kan arbeta med FARM-stacken, kan det vara bra att titta på några projektidéer. Ett exempel är att skapa en enkel portföljwebbplats. Genom att använda React och FastAPI för att skapa en server-side genererad sida som hanterar blogginlägg, portföljobjekt eller artiklar, kan man snabbt sätta upp en funktionell webbplats. Med hjälp av React-Router eller Next.js kan man också skapa en snabb navigationsstruktur. Denna typ av projekt hjälper utvecklare att öva på grundläggande funktioner, som att definiera modeller, hantera GET-förfrågningar och integrera externa tjänster som Cloudinary för bildhantering.

För mer komplexa användningsfall kan ett projekt som handlar om att bygga ett inventariesystem med React-admin vara ett utmärkt sätt att fördjupa sina kunskaper. React-admin erbjuder en användarvänlig gränssnitt för att hantera CRUD-operationer och kan enkelt integreras med FastAPI och MongoDB. Med denna lösning kan man bygga en applikation där användare kan skapa, läsa, uppdatera och ta bort objekt i en inventariedatabas.

Dataanalys och visualisering kan också tas till nästa nivå genom att använda verktyg som Plotly Dash eller Streamlit. Dessa bibliotek gör det möjligt att skapa interaktiva webbaserade applikationer för att utforska och visualisera data. För att bygga en sådan applikation kan man börja med att välja en dataset, rensa och förbehandla den, och sedan bygga en användargränssnitt för att visa och filtrera informationen. Med hjälp av bibliotek som pandas och Matplotlib kan man enkelt analysera och visualisera olika korrelationer eller trender i datan. Dessutom kan man också implementera maskininlärningsmodeller, som en enkel linjär regression eller ett neuralt nätverk, för att få ännu djupare insikter från datan.

En annan användbar tillämpning är att skapa en dokumentautomatiseringspipeline. Detta kan vara särskilt användbart för företag som arbetar med repetitiva dokument, såsom kontrakt eller rapporter, som har en liknande struktur. Genom att använda FastAPI för att skapa en API som genererar och hanterar Word- eller Excel-dokument baserat på mallar, kan man automatisera många tidskrävande uppgifter. Med hjälp av paket som docx-tpl kan man skapa dokumentmallar där data som text, bilder och tabeller fylls i automatiskt baserat på användarens behov.

Dessa projektidéer erbjuder en utmärkt startpunkt för att förstå och tillämpa FARM-stacken i praktiken. Genom att arbeta med dessa exempel kommer du att kunna experimentera och förbättra din kompetens, samtidigt som du lär dig de praktiska aspekterna av att bygga webbapplikationer med moderna teknologier.

Hur utvecklas lagring och transport av väte för framtidens energi?
Hur skiljer sig tyskt och engelskt ordförråd i vardagliga konversationer?
Hur ljud uppstår genom vibrationer och varför det är viktigt att förstå
Hur kan en modifierad RICE-enhet förbättra prestanda för CAES med vätgas?