Bootcamp i backendudvikling med Node.js · Lektion

Rollebaseret adgangskontrol (RBAC)

Implementér rollebaseret autorisation for at begrænse adgangen til bestemte endpoints baseret på brugerroller og tilladelser.

Lektion 6 af 611 trin

Rollebaseret adgangskontrol (RBAC) er en gratis Bootcamp i backendudvikling med Node.js-lektion på CoddyKit. Dette er lektion 6 af 6. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Bootcamp i backendudvikling med Node.js, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i backendudvikling med Node.js-kurset indeholder 6 lektioner i alt.

Hvad er RBAC?

Rollebaseret adgangskontrol (RBAC) er en metode til at begrænse adgangen til ressourcer baseret på de roller, som de enkelte brugere har i en organisation.

I stedet for at tildele tilladelser direkte til brugere tildeles tilladelser til roller.
Brugerne tildeles derefter roller og arver disse tilladelser.
Det forenkler administrationen af sikkerhed, især i større applikationer.

Definition af brugerroller

Først skal vi definere de roller, som vores applikation skal bruge. Det er typisk brede kategorier som 'admin', 'editor' eller 'basic_user'.

Det er en overskuelig måde at administrere disse roller på at bruge en Python-Enum:

from enum import Enum

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

# Example usage:
# role = UserRole.ADMIN

Tildeling af brugerroller

Hver bruger i dit system har en eller flere tilknyttede roller. I en rigtig FastAPI-applikation kommer disse oplysninger normalt fra brugerens godkendte token (f.eks. en JWT-payload).

I denne lektion bruger vi en enkel User-model og en simuleret funktion til at repræsentere den aktuelt godkendte bruger med sine tildelte roller.

from typing import List
from pydantic import BaseModel
from enum import Enum

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

class User(BaseModel):
    username: str
    roles: List[UserRole]

# Mock function to get current user (normally from JWT)
async def get_current_user() -> User:
    # In a real app, this would decode a JWT
    # For demonstration, let's return a mock admin user
    return User(username="admin_user", roles=[UserRole.ADMIN])

Brugerdefineret rolleafhængighed

FastAPIs system til afhængighedsinjektion er perfekt til at implementere RBAC. Vi kan oprette en brugerdefineret afhængighed, der kontrollerer, om den godkendte bruger har den eller de nødvendige roller til at få adgang til et slutpunkt.

Denne afhængighed kan genbruges på tværs af mange slutpunkter.
Hvis brugeren ikke har den krævede rolle, udløser den en HTTPException.

Opbygning af rolleudtjekket

Vores role_required-afhængighed modtager en liste over roller. Den henter derefter den aktuelle bruger og kontrollerer, om nogen af brugerens tildelte roller matcher de krævede roller.

from fastapi import Depends, HTTPException, status
from typing import List
from pydantic import BaseModel
from enum import Enum

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

class User(BaseModel):
    username: str
    roles: List[UserRole]

# Mock function to get current user
async def get_current_user() -> User:
    return User(username="test_user", roles=[UserRole.BASIC_USER])

def role_required(required_roles: List[UserRole]):
    async def role_checker(current_user: User = Depends(get_current_user)):
        if not any(role in current_user.roles for role in required_roles):
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail="Not enough permissions"
            )
        return current_user
    return role_checker

Kode: Slutpunkt kun for administratorer

Her er en komplet FastAPI-applikation, der demonstrerer, hvordan du beskytter et slutpunkt, så kun brugere med rollen 'admin' kan få adgang. Kør denne kode, og prøv at få adgang til /admin og /public.

from fastapi import FastAPI, Depends, HTTPException, status
from typing import List
from pydantic import BaseModel
from enum import Enum
import uvicorn

app = FastAPI()

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

class User(BaseModel):
    username: str
    roles: List[UserRole]

# Mock function to get current user
# Change roles here to test different access levels
async def get_current_user() -> User:
    # Try changing to [UserRole.BASIC_USER] or [UserRole.ADMIN]
    return User(username="admin_user", roles=[UserRole.ADMIN])

def role_required(required_roles: List[UserRole]):
    async def role_checker(current_user: User = Depends(get_current_user)):
        if not any(role in current_user.roles for role in required_roles):
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail="Not enough permissions"
            )
        return current_user
    return role_checker

@app.get("/public")
async def read_public_data():
    return {"message": "This is public data!"}

@app.get("/admin")
async def read_admin_data(current_user: User = Depends(role_required([UserRole.ADMIN]))):
    return {"message": f"Welcome, {current_user.username}! This is admin data."}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Test af rolleudtjekket

Når du kører den foregående kode:

Åbn http://127.0.0.1:8000/public: Dette bør altid virke.
Åbn http://127.0.0.1:8000/admin: Dette virker, hvis get_current_user returnerer en bruger med UserRole.ADMIN.

Prøv at ændre den simulerede brugers roller i get_current_user til [UserRole.BASIC_USER], og kør appen igen. Du får en 403 Forbidden-fejl, når du forsøger at få adgang til /admin.

Tilladelse af flere roller

Nogle gange skal et slutpunkt være tilgængeligt for mere end én rolle. Både brugere med rollerne 'admin' og 'editor' kan f.eks. få lov til at opdatere en artikel.

Vores role_required-afhængighed er allerede designet til dette! Den accepterer en List[UserRole], og kontrollen med any() betyder, at adgangen gives, hvis brugeren har en hvilken som helst af de angivne roller.

Kode: Adgang for flere roller

Dette eksempel viser et slutpunkt, som enten en 'admin' eller en 'editor' kan få adgang til. Prøv at ændre den simulerede brugers roller til [UserRole.EDITOR] og [UserRole.BASIC_USER] for at se adgangskontrollen i praksis.

from fastapi import FastAPI, Depends, HTTPException, status
from typing import List
from pydantic import BaseModel
from enum import Enum
import uvicorn

app = FastAPI()

class UserRole(str, Enum):
    ADMIN = "admin"
    EDITOR = "editor"
    BASIC_USER = "basic_user"

class User(BaseModel):
    username: str
    roles: List[UserRole]

# Mock function to get current user
# Change roles here to test different access levels
async def get_current_user() -> User:
    # Try [UserRole.ADMIN], [UserRole.EDITOR], or [UserRole.BASIC_USER]
    return User(username="editor_user", roles=[UserRole.EDITOR])

def role_required(required_roles: List[UserRole]):
    async def role_checker(current_user: User = Depends(get_current_user)):
        if not any(role in current_user.roles for role in required_roles):
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail="Not enough permissions"
            )
        return current_user
    return role_checker

@app.get("/edit_content")
async def edit_content(current_user: User = Depends(role_required([UserRole.ADMIN, UserRole.EDITOR]))):
    return {"message": f"Hello {current_user.username}! You can edit content."}

@app.get("/view_only")
async def view_only_content(current_user: User = Depends(role_required([UserRole.BASIC_USER]))):
    return {"message": f"Hello {current_user.username}! You can view content."}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Kontrol af RBAC-implementeringen

Du skal oprette et endpoint /dashboard, som kun må være tilgængeligt for brugere med rollen ADMIN. Hvilken af følgende metoder er den korrekte måde at anvende afhængigheden role_required på?

Besvar den i den interaktive lektion

Opsummering af RBAC

Du har lært, hvordan du implementerer rollebaseret adgangskontrol i dine FastAPI-applikationer:

Definerede roller ved hjælp af Python Enum for at gøre koden tydelig.
Forstod, hvordan brugerroller typisk knyttes til brugere, f.eks. via JWT'er.
Oprettede en genanvendelig brugerdefineret afhængighed (role_required) til at kontrollere brugerroller.
Anvendte denne afhængighed på endpoints for at begrænse adgangen baseret på én eller flere roller.

RBAC er en effektiv måde at administrere tilladelser på, så din API bliver mere sikker og lettere at vedligeholde!

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 22
Lektioner: 92

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Rollebaseret adgangskontrol (RBAC)” gratis?

Ja — hele teksten til “Rollebaseret adgangskontrol (RBAC)” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Bootcamp i backendudvikling med Node.js-kurset, skal du opgradere til CoddyKit PRO. Bootcamp i backendudvikling med Node.js-kurset indeholder 6 lektioner i alt.

Hvad lærer jeg i “Rollebaseret adgangskontrol (RBAC)”?

Implementér rollebaseret autorisation for at begrænse adgangen til bestemte endpoints baseret på brugerroller og tilladelser. Du øver dig i Bootcamp i backendudvikling med Node.js med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Bootcamp i backendudvikling med Node.js?

Der kræves ingen tidligere erfaring. Bootcamp i backendudvikling med Node.js på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 6 af 6.

Hvor lang tid tager lektionen “Rollebaseret adgangskontrol (RBAC)”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Bootcamp i backendudvikling med Node.js-lektion?

Ja. Alle Bootcamp i backendudvikling med Node.js-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Bootcamp i backendudvikling med Node.js