FastAPI 和 RBAC（基于角色的访问控制）

最新推荐文章于 2025-06-27 14:26:01 发布

原创最新推荐文章于 2025-06-27 14:26:01 发布 · 981 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#fastapi #java #网络 #python #数据库 #运维 #前端

Python Web 专栏收录该内容

137 篇文章

订阅专栏

FastAPI 和 RBAC（基于角色的访问控制）

1. 🚀 基于角色的访问控制（RBAC）简介

基于角色的访问控制（RBAC, Role-Based Access Control）是一种常见的权限管理模型，通过定义用户角色和角色之间的权限关系来控制对系统资源的访问。在企业级应用中，RBAC 被广泛应用于资源保护、用户访问管理及数据安全等领域。

在 RBAC 中，用户与角色进行绑定，每个角色会被赋予一组权限。通过角色来管理用户的访问权限，相较于直接绑定权限，RBAC 可以更好地实现权限管理的可扩展性和灵活性。典型的使用场景包括不同等级的用户（如普通用户、管理员、超级管理员）需要访问不同范围和级别的资源。

FastAPI，作为一种现代化的、基于 Python 的 Web 开发框架，支持高效的 API 构建与管理。在实现 RBAC 时，FastAPI 提供了许多工具和功能，比如依赖注入机制、OAuth2 和 JWT 支持，使得实现细粒度的权限控制变得更加灵活和高效。RBAC 的实现不仅仅限于权限控制，还可以和认证系统（如 JWT）结合，形成多层次的安全机制。

RBAC 的关键组成部分包括：

用户：系统中的操作主体。
角色：一组用户身份的集合，具有相同的权限。
权限：能够访问某些资源的能力，通常表现为某种 CRUD 操作的权限（创建、读取、更新、删除）。
角色-权限映射：角色与权限之间的关系。

通过这种方式，可以有效地将权限从用户管理中解耦出来，让权限管理更加集中化与简化。

2. 🔐 在 FastAPI 中实现 RBAC

实现 RBAC 的关键在于如何将角色与权限以及用户之间建立有效的映射关系。FastAPI 为此提供了多种机制，比如依赖注入、数据库 ORM 和 JWT。

示例代码实现

以下是一个简化版的 RBAC 实现示例，使用 FastAPI 和 SQLAlchemy 来实现角色与权限管理。首先，我们需要创建一个数据库模型来存储用户、角色和权限的信息。

from fastapi import FastAPI, Depends, HTTPException, status
from sqlalchemy import Column, Integer, String, ForeignKey
from sqlalchemy.orm import relationship, Session
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from pydantic import BaseModel
from typing import List

DATABASE_URL = "sqlite:///./test.db"

Base = declarative_base()
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# 用户模型
class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    hashed_password = Column(String)

    roles = relationship("Role", secondary="user_roles")

# 角色模型
class Role(Base):
    __tablename__ = "roles"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, unique=True)

    permissions = relationship("Permission", secondary="role_permissions")
    users = relationship("User", secondary="user_roles")

# 权限模型
class Permission(Base):
    __tablename__ = "permissions"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, unique=True)

# 角色与权限的关联表
class RolePermission(Base):
    __tablename__ = "role_permissions"
    role_id = Column(Integer, ForeignKey("roles.id"), primary_key=True)
    permission_id = Column(Integer, ForeignKey("permissions.id"), primary_key=True)

# 用户与角色的关联表
class UserRole(Base):
    __tablename__ = "user_roles"
    user_id = Column(Integer, ForeignKey("users.id"), primary_key=True)
    role_id = Column(Integer, ForeignKey("roles.id"), primary_key=True)

# FastAPI 实例
app = FastAPI()

# 权限校验
def get_permissions_from_roles(roles: List[str], db: Session):
    permissions = []
    for role_name in roles:
        role = db.query(Role).filter(Role.name == role_name).first()
        if role:
            permissions.extend([perm.name for perm in role.permissions])
    return permissions

# 依赖项：获取数据库会话
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/user-permissions/")
def get_user_permissions(roles: List[str], db: Session = Depends(get_db)):
    permissions = get_permissions_from_roles(roles, db)
    return {"permissions": permissions}

在上述代码中，首先定义了 User, Role, Permission 等数据库模型，随后在 get_user_permissions 路由中实现了根据角色获取权限的功能。通过数据库模型的关联，我们实现了角色与权限之间的关系，用户通过角色来获取相应的权限。

RBAC 的核心要素

用户角色管理：通过 UserRole 表来管理用户与角色的多对多关系。
角色权限管理：通过 RolePermission 表来管理角色与权限的多对多关系。

每当用户请求访问某一资源时，我们就可以根据他们的角色，查询相应的权限，并决定是否允许访问。

3. ⚙️ 结合 JWT 与 RBAC 实现细粒度权限管理

为了更高效地管理用户的身份验证和授权，我们可以将 JWT（JSON Web Token）与 RBAC 结合起来。JWT 是一种轻量级的、基于 JSON 格式的身份验证方案，能够传递用户信息，并且可以加密和签名。

通过在用户登录时生成 JWT，我们可以在后续的请求中携带 JWT，实现无状态认证。而与 RBAC 结合时，JWT 中通常包含了用户的角色信息，服务器通过解析 JWT 中的角色来判断用户的权限。

JWT 示例代码

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
from jose import JWTError, jwt
from typing import List
import datetime

# JWT 配置
SECRET_KEY = "5f99d67c3d903370b9f07d5f837a3f4c1e7425bb94da0d9db8a4abde1a04a8fb"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

# 创建 JWT
def create_access_token(data: dict, expires_delta: datetime.timedelta = None):
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.datetime.utcnow() + expires_delta
    else:
        expire = datetime.datetime.utcnow() + datetime.timedelta(minutes=15)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

# 获取当前用户角色信息
def get_roles_from_jwt(token: str):
    credentials_exception = 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])
        roles: List[str] = payload.get("roles", [])
        if roles is None:
            raise credentials_exception
        return roles
    except JWTError:
        raise credentials_exception

# 获取权限
def get_permissions_from_jwt(token: str, db: Session = Depends(get_db)):
    roles = get_roles_from_jwt(token)
    return get_permissions_from_roles(roles, db)

@app.get("/user-permissions/")
def read_user_permissions(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
    permissions = get_permissions_from_jwt(token, db)
    return {"permissions": permissions}