Bootcamp i backendutveckling med FastAPI · Lektion

OAuth2 Password Flow och utfärdande av tokens

Implementera schemat OAuth2PasswordBearer, hasha lösenord med passlib och utfärda signerade åtkomsttokens vid inloggning.

Lektion 1 av 413 steg

OAuth2 Password Flow och utfärdande av tokens är en gratis lektion i Bootcamp i backendutveckling med FastAPI på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med FastAPI, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med FastAPI innehåller totalt 4 lektioner.

OAuth2-lösenordsflödet på ren svenska

OAuth2-lösenordsflödet (även kallat bidraget Resource Owner Password Credentials) är det enklaste sättet att autentisera en förstapartsklient: användaren skickar sitt användarnamn och lösenord direkt till ert API, som returnerar en signerad åtkomsttoken.

Klienten skickar autentiseringsuppgifterna en gång till en /token-endpoint.
Servern verifierar dem mot databasen.
Vid lyckad autentisering returnerar den en kortlivad JWT-åtkomsttoken.
Alla senare förfrågningar innehåller token i rubriken Authorization: Bearer <token>.

FastAPI ger oss färdiga byggblock för exakt detta: OAuth2PasswordBearer och OAuth2PasswordRequestForm.

Deklarera OAuth2PasswordBearer-schemat

OAuth2PasswordBearer är ett FastAPI-beroende som vet hur en bearer-token hämtas från rubriken Authorization. Ni skapar en instans och anger dess tokenUrl till den endpoint för inloggning som utfärdar tokens.

tokenUrl är en relativ sökväg – den talar om för dokumentationsgränssnittet var klienter ska begära en token.
När schemat används som ett beroende kräver endpointen en token; en saknad eller felaktigt formaterad rubrik ger automatiskt 401.

from fastapi import Depends, FastAPI
from fastapi.security import OAuth2PasswordBearer

app = FastAPI()

# 'token' matches the path of our login route below
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")


@app.get("/users/me")
async def read_me(token: str = Depends(oauth2_scheme)):
    # FastAPI extracts the raw bearer token string for us
    return {"token": token}

Hasha lösenord med passlib

Ni får aldrig lagra lösenord i klartext. Hasha dem med en stark algoritm som använder salt. Biblioteket passlib kapslar in bcrypt bakom ett tydligt CryptContext-API.

hash() skapar ett saltat digestvärde som ni lagrar i databasen.
verify() jämför ett lösenordsförsök i klartext med den lagrade hashen i konstant tid.
bcrypt är avsiktligt långsamt, vilket försvårar brute force-attacker.

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")


def hash_password(plain: str) -> str:
    return pwd_context.hash(plain)


def verify_password(plain: str, hashed: str) -> bool:
    return pwd_context.verify(plain, hashed)


stored = hash_password("s3cret")
print("stored looks like:", stored[:7], "...")
print("correct ->", verify_password("s3cret", stored))
print("wrong   ->", verify_password("nope", stored))

Modellera användare och en liten fejkad databas

Innan vi utfärdar tokens behöver vi någonstans att slå upp användare. I produktion är detta er riktiga databas; för inlärning använder vi en dict i minnet. Observera att det lagrade fältet är hashed_password, aldrig lösenordet i klartext.

En Pydantic-modell ger användaren en typad struktur.
En get_user()-hjälpfunktion centraliserar uppslagningarna.

from pydantic import BaseModel


class UserInDB(BaseModel):
    username: str
    hashed_password: str
    disabled: bool = False


fake_users_db = {
    "alice": UserInDB(
        username="alice",
        hashed_password="$2b$12$exampleexampleexamplehashvalue",
    )
}


def get_user(username: str):
    return fake_users_db.get(username)

Autentisera autentiseringsuppgifterna

Autentisering knyter ihop delarna: hitta användaren och verifiera sedan det angivna lösenordet mot den lagrade hashen. Returnera användaren vid lyckad autentisering eller ett falskt värde vid misslyckande.

Slå först upp användaren; om användaren saknas ska autentiseringen misslyckas.
Anropa sedan verify_password – avbryt inte innan hashningen, så att tidsåtgången förblir ungefär enhetlig.
Den som anropar funktionen avgör hur svaret ska se ut, vanligtvis 401.

def authenticate_user(db, username: str, password: str):
    user = db.get(username)
    if not user:
        return None
    if not verify_password(password, user.hashed_password):
        return None
    return user

Vad en JWT faktiskt är

En JSON Web Token består av tre base64url-segment som sammanfogas med punkter: header.payload.signature.

Headern anger algoritmen, till exempel HS256.
Payloaden innehåller claims som sub (subjekt) och exp (utgångstid).
Signaturen är en HMAC av header+payload som använder er hemliga nyckel.

JWT:er är signerade, inte krypterade – vem som helst kan läsa payloaden, men ingen kan förfalska den utan hemligheten. Lägg aldrig lösenord eller känsliga uppgifter i payloaden.

Koda en signerad åtkomsttoken

Vi signerar tokens med biblioteket python-jose (eller PyJWT). Inkludera alltid ett exp-claim så att tokens löper ut. Lagra användarnamnet i claimet sub – det identifierar vem token tillhör.

SECRET_KEY måste vara lång, slumpmässig och hållas utanför versionshanteringen.
Ange en kort livstid, till exempel 15–30 minuter, för åtkomsttokens.

from datetime import datetime, timedelta, timezone
from jose import jwt

SECRET_KEY = "replace-with-a-long-random-secret"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30


def create_access_token(data: dict) -> str:
    to_encode = data.copy()
    expire = datetime.now(timezone.utc) + timedelta(
        minutes=ACCESS_TOKEN_EXPIRE_MINUTES
    )
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)


token = create_access_token({"sub": "alice"})
print("issued token segments:", token.count(".") + 1)

Strukturen för tokensvaret

OAuth2-specifikationen anger vilken JSON som er /token-endpoint ska returnera. Den måste minst innehålla access_token och token_type, där typen är den exakta strängen "bearer".

Klienter läser token_type för att veta hur autentiseringsuppgiften ska skickas tillbaka.
En Pydantic-Token-modell dokumenterar och validerar svaret.

from pydantic import BaseModel


class Token(BaseModel):
    access_token: str
    token_type: str


example = Token(access_token="eyJhbGci...", token_type="bearer")
print(example.model_dump())

Koppla in inloggningsendpointen /token

Inloggningsrutten är beroende av OAuth2PasswordRequestForm, som läser formulärkodade fält för username och password (inte JSON) – exakt vad OAuth2-lösenordsflödet kräver. Vid lyckad autentisering returnerar den svaret enligt Token.

Misslyckad autentisering utlöser 401 med rubriken WWW-Authenticate: Bearer.
Claimet sub för användarnamnet vidare in i token.

from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordRequestForm

app = FastAPI()


@app.post("/token", response_model=Token)
async def login(form: OAuth2PasswordRequestForm = Depends()):
    user = authenticate_user(fake_users_db, form.username, form.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token = create_access_token({"sub": user.username})
    return Token(access_token=access_token, token_type="bearer")

Avkoda token för att hitta den aktuella användaren

En skyddad route är beroende av oauth2_scheme för att ta emot den råa token och avkodar den sedan. Om signaturen är ogiltig eller token har löpt ut utlöser jwt.decode ett JWTError, och vi returnerar 401.

Läs användarnamnet från claimet sub.
Läs in användaren från databasen igen för att bekräfta att användaren fortfarande finns och är aktiv.

from fastapi import Depends, HTTPException, status
from jose import JWTError, jwt


async def get_current_user(token: str = Depends(oauth2_scheme)):
    credentials_exc = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username = payload.get("sub")
        if username is None:
            raise credentials_exc
    except JWTError:
        raise credentials_exc
    user = get_user(username)
    if user is None:
        raise credentials_exc
    return user

Viktiga säkerhetsrutiner

Tekniken fungerar, men härdning för produktion gör den säker:

Hemlig nyckel: läs in SECRET_KEY från en miljövariabel och byt den om den läcker.
Endast HTTPS: tokens i rubriker skickas i klartext över nätverket – TLS är obligatoriskt.
Kort giltighetstid: håll åtkomsttokens kortlivade och kombinera dem med refresh tokens med längre giltighetstid.
Lås algoritmen: skicka en uttrycklig lista algorithms=["HS256"] till jwt.decode för att blockera attacken alg: none.
Generiska fel: säg "Felaktigt användarnamn eller lösenord" och avslöja aldrig vilket av dem som var fel.

Snabb kontroll: endpointen /token

Nu är det dags att testa er förståelse av hur FastAPI:s inloggningsroute /token tar emot autentiseringsuppgifter.

Besvara frågan i den interaktiva lektionen

Sammanfattning: från lösenord till bearer-token

Ni har implementerat hela OAuth2-lösenordsflödet i FastAPI:

OAuth2PasswordBearer deklarerar bearer-schemat och hämtar tokens från rubriken Authorization.
passlib + bcrypt hashar och verifierar lösenord, så att lösenord i klartext aldrig lagras.
authenticate_user slår upp användaren och verifierar hashen, och returnerar 401 vid misslyckande.
Routen /token läser formulärautentiseringsuppgifter via OAuth2PasswordRequestForm och utfärdar en signerad JWT med ett sub-claim och ett exp-claim för utgångstid.
get_current_user avkodar och validerar token och låser algoritmen för att blockera förfalskning.

Med HTTPS, en hemlighet som läses in från miljön och korta tokenlivstider är detta en stabil och idiomatisk grund för autentisering.

Gratis att börja

Lär dig Bootcamp i backendutveckling med FastAPI med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 21
Lektioner: 84

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”OAuth2 Password Flow och utfärdande av tokens” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Bootcamp i backendutveckling med FastAPI, inklusive ”OAuth2 Password Flow och utfärdande av tokens”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Bootcamp i backendutveckling med FastAPI innehåller totalt 4 lektioner.

Vad lär jag mig i ”OAuth2 Password Flow och utfärdande av tokens”?

Implementera schemat OAuth2PasswordBearer, hasha lösenord med passlib och utfärda signerade åtkomsttokens vid inloggning. Ni övar på Bootcamp i backendutveckling med FastAPI med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med FastAPI?

Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med FastAPI på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”OAuth2 Password Flow och utfärdande av tokens”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med FastAPI-lektionen?

Ja. Varje Bootcamp i backendutveckling med FastAPI-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

OAuth2 Password Flow och utfärdande av tokens
Signering och verifiering av JWT:er med python-jose
Refresh tokens och tokenrotation
Auktorisering baserad på scopes och rollguards

← Tillbaka till Bootcamp i backendutveckling med FastAPI