PricingLoginStart free
Bootcamp backendontwikkeling met FastAPI · Les

OAuth2 Password Flow en tokenuitgifte

Implementeer het OAuth2PasswordBearer-schema, hash wachtwoorden met passlib en geef bij het inloggen ondertekende accesstokens uit.

Les 1 van 413 stappen

OAuth2 Password Flow en tokenuitgifte is een gratis Bootcamp backendontwikkeling met FastAPI-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Bootcamp backendontwikkeling met FastAPI. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.

De OAuth2-wachtwoordflow in gewone taal

De OAuth2-wachtwoordflow (ook wel de toekenning Resource Owner Password Credentials) is de eenvoudigste manier om een eerstepartijclient te authenticeren: de gebruiker stuurt zijn of haar gebruikersnaam en wachtwoord rechtstreeks naar je API, en de API geeft een ondertekend toegangstoken terug.

  • De client plaatst eenmaal referenties naar een /token-endpoint.
  • De server controleert ze aan de hand van de database.
  • Bij succes retourneert de server een kortlevend JWT-toegangstoken.
  • Elk later verzoek bevat dat token in de header Authorization: Bearer <token>.

FastAPI biedt hiervoor kant-en-klare bouwstenen: OAuth2PasswordBearer en OAuth2PasswordRequestForm.

Het OAuth2PasswordBearer-schema declareren

OAuth2PasswordBearer is een FastAPI-afhankelijkheid die weet hoe je een bearer-token uit de header Authorization haalt. Je maakt één instantie en wijst de tokenUrl ervan naar het loginendpoint dat tokens uitgeeft.

  • tokenUrl is een relatief pad — het vertelt de documentatie-interface waar clients een token moeten aanvragen.
  • Als je het schema als afhankelijkheid gebruikt, moet het endpoint een token vereisen; een ontbrekende of onjuist opgemaakte header levert automatisch 401 op.
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}

Wachtwoorden hashen met passlib

Je mag nooit onbewerkte wachtwoorden opslaan. Hash ze met een sterk algoritme met salt. De bibliotheek passlib verpakt bcrypt achter een overzichtelijke CryptContext-API.

  • hash() produceert een digest met salt die je in de database opslaat.
  • verify() vergelijkt een poging in platte tekst in constante tijd met de opgeslagen hash.
  • bcrypt is bewust traag, waardoor brute-forceaanvallen worden bemoeilijkt.
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))

Gebruikers modelleren en een kleine nepdatabase

Voordat we tokens uitgeven, hebben we een plek nodig om gebruikers op te zoeken. In productie is dit je echte database; om te leren gebruiken we een dictionary in het geheugen. Let erop dat het opgeslagen veld hashed_password is, nooit de tekst zonder hash.

  • Een Pydantic-model geeft de gebruiker een getypeerde structuur.
  • Een helper get_user() centraliseert het opzoeken.
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)

De referenties authenticeren

Authenticatie brengt de onderdelen samen: zoek de gebruiker op en controleer vervolgens het opgegeven wachtwoord aan de hand van de opgeslagen hash. Retourneer de gebruiker bij succes of een waarde die als onwaar wordt geëvalueerd bij mislukking.

  • Zoek de gebruiker eerst op; als die ontbreekt, mislukt de authenticatie.
  • Roep daarna verify_password aan — stop niet voortijdig vóór het hashen, zodat de timing ongeveer gelijk blijft.
  • De aanroeper bepaalt hoe hij reageert, meestal met 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

Wat een JWT werkelijk is

Een JSON Web Token bestaat uit drie base64url-segmenten die door punten zijn verbonden: header.payload.signature.

  • De header vermeldt het algoritme, bijvoorbeeld HS256.
  • De payload bevat claims zoals sub (onderwerp) en exp (vervaltijd).
  • De handtekening is een HMAC van header+payload met je geheime sleutel.

JWT's zijn ondertekend, niet versleuteld — iedereen kan de payload lezen, maar niemand kan die vervalsen zonder het geheim. Zet nooit wachtwoorden of gevoelige gegevens in de payload.

Een ondertekend toegangstoken coderen

We ondertekenen tokens met de bibliotheek python-jose (of PyJWT). Neem altijd een exp-claim op, zodat tokens verlopen. Sla de gebruikersnaam op in de sub-claim — die identificeert aan wie het token toebehoort.

  • SECRET_KEY moet lang en willekeurig zijn en buiten versiebeheer worden gehouden.
  • Stel een korte levensduur in, bijvoorbeeld 15-30 minuten, voor toegangstokens.
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)

De structuur van het tokenantwoord

De OAuth2-specificatie bepaalt welke JSON je /token-endpoint retourneert. Deze moet minimaal access_token en token_type bevatten, waarbij het type de letterlijke tekenreeks "bearer" is.

  • Clients lezen token_type om te weten hoe ze de referentie moeten terugsturen.
  • Een Pydantic-model Token documenteert en valideert het antwoord.
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())

Het /token-loginendpoint aansluiten

De loginroute is afhankelijk van OAuth2PasswordRequestForm, die de velden form-encoded username en password leest (geen JSON) — precies wat de OAuth2-wachtwoordflow vereist. Bij succes retourneert de route het Token-antwoord.

  • Mislukte authenticatie veroorzaakt 401 met een header WWW-Authenticate: Bearer.
  • De sub-claim neemt de gebruikersnaam mee in het 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")

Het token decoderen om de huidige gebruiker te vinden

Een beveiligde route is afhankelijk van oauth2_scheme om het onbewerkte token te ontvangen en decodeert het vervolgens. Als de handtekening ongeldig is of het token is verlopen, veroorzaakt jwt.decode een JWTError en retourneren we 401.

  • Lees de gebruikersnaam uit de sub-claim.
  • Laad de gebruiker opnieuw uit de database om te bevestigen dat die nog bestaat en actief is.
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

Belangrijke beveiligingspraktijken

De techniek werkt, maar voor gebruik in productie zijn extra maatregelen nodig:

  • Geheime sleutel: laad SECRET_KEY uit een omgevingsvariabele en vervang de sleutel als die uitlekt.
  • Alleen HTTPS: tokens in headers staan onversleuteld op de verbinding — TLS is verplicht.
  • Korte vervaltijd: houd toegangstokens kort geldig en combineer ze met langer geldige vernieuwingstokens.
  • Leg het algoritme vast: geef een expliciete lijst algorithms=["HS256"] door aan jwt.decode om de aanval met alg: none te blokkeren.
  • Algemene foutmeldingen: zeg "Incorrect username or password" en geef nooit prijs welke van de twee onjuist was.

Korte controle: het /token-endpoint

Het is tijd om te testen of je begrijpt hoe de FastAPI-/token-loginroute referenties verwerkt.

Beantwoord dit in de interactieve les

Samenvatting: van wachtwoord naar bearer-token

Je hebt de volledige OAuth2-wachtwoordflow in FastAPI geïmplementeerd:

  • OAuth2PasswordBearer declareert het bearer-schema en haalt tokens uit de header Authorization.
  • passlib + bcrypt hashen en controleren wachtwoorden, zodat tekst zonder hash nooit wordt opgeslagen.
  • authenticate_user zoekt de gebruiker op en controleert de hash, en retourneert bij mislukking 401.
  • De route /token leest formulierreferenties via OAuth2PasswordRequestForm en geeft een ondertekende JWT uit met een sub-claim en een vervaltijd in exp.
  • get_current_user decodeert en valideert het token en legt het algoritme vast om vervalsing te blokkeren.

Met HTTPS, een uit de omgeving geladen geheim en korte tokenlevensduren vormt dit een solide, idiomatische basis voor authenticatie.

Gratis beginnen

Leer Bootcamp backendontwikkeling met FastAPI met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
21
Lessen
84
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “OAuth2 Password Flow en tokenuitgifte” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Bootcamp backendontwikkeling met FastAPI, waaronder “OAuth2 Password Flow en tokenuitgifte”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Bootcamp backendontwikkeling met FastAPI bevat in totaal 4 lessen.

Wat leer ik in “OAuth2 Password Flow en tokenuitgifte”?

Implementeer het OAuth2PasswordBearer-schema, hash wachtwoorden met passlib en geef bij het inloggen ondertekende accesstokens uit. Je oefent met Bootcamp backendontwikkeling met FastAPI door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Bootcamp backendontwikkeling met FastAPI te beginnen?

Ervaring vooraf is niet nodig. Bootcamp backendontwikkeling met FastAPI op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “OAuth2 Password Flow en tokenuitgifte”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Bootcamp backendontwikkeling met FastAPI?

Ja. Elke les over Bootcamp backendontwikkeling met FastAPI bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. OAuth2 Password Flow en tokenuitgifte
  2. JWT's ondertekenen en verifiëren met python-jose
  3. Refresh tokens en tokenrotatie
  4. Autorisatie op basis van scopes en roleguards
← Terug naar Bootcamp backendontwikkeling met FastAPI