【FastAPI】在FastAPI中实现用户登录和Token认证（JWT）并展示到Swagger UI

写bug如流水

于 2024-10-08 09:44:47 发布

阅读量1.5k

点赞数 27

分类专栏： Python Web 文章标签： fastapi ui

本文链接：https://blog.csdn.net/h1773655323/article/details/142752100

版权

Python Web 专栏收录该内容

28 篇文章 1 订阅

订阅专栏

在FastAPI中实现用户登录和Token认证（JWT）并展示到Swagger UI

在现代的Web应用中，用户认证是非常关键的部分。无论是构建一个简单的API还是复杂的Web应用，保护用户数据和验证用户身份都是必不可少的。JWT（JSON Web Token）是一种非常流行的认证机制，结合FastAPI的强大功能，可以轻松实现基于Token的用户认证。

在本文中，我们将介绍如何在FastAPI中实现用户登录，生成JWT Token，并通过该Token保护API路由。同时，我们还会展示如何在Swagger UI中使用这些接口进行测试和演示。

为什么选择JWT进行认证？

JWT（JSON Web Token）是一种紧凑的、URL安全的令牌格式，广泛应用于身份验证和信息交换。它有以下几个优势：

轻量化：JWT是基于JSON格式的，传输数据量小，适合用于Web环境。
自包含：JWT包含了所需的所有信息，如用户的身份信息、签发时间、过期时间等，避免了每次请求都需要查询数据库。
易于验证：服务器只需要对JWT进行签名验证即可判断其合法性。

使用JWT的典型流程如下：

用户通过用户名和密码进行登录。
服务器验证用户名和密码，并生成JWT令牌。
用户在之后的请求中附带该JWT进行认证，服务器验证该JWT的合法性和有效性。

创建FastAPI应用并实现JWT认证

我们将分步骤展示如何使用FastAPI实现用户登录和JWT认证。

1. 安装依赖

在开始之前，我们需要安装fastapi和pyjwt。fastapi用于构建API，pyjwt用于生成和验证JWT。

pip install fastapi[all] pyjwt

2. 定义FastAPI应用

我们将创建一个FastAPI应用，并实现以下功能：

用户登录并获取JWT Token
使用JWT保护API路由
在Swagger UI中展示这些API

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from pydantic import BaseModel
from datetime import datetime, timedelta
from typing import Optional
import jwt

# 创建FastAPI应用
app = FastAPI()

# 定义密钥和算法
SECRET_KEY = "your_secret_key"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

# 模拟用户数据库
fake_users_db = {
    "user1": {
        "username": "user1",
        "full_name": "User One",
        "email": "user1@example.com",
        "hashed_password": "fakehashedpassword",
        "disabled": False,
    }
}

# 用于验证用户名和密码
def fake_hash_password(password: str):
    return "fakehashed" + password

# 定义用户模型
class User(BaseModel):
    username: str
    email: Optional[str] = None
    full_name: Optional[str] = None
    disabled: Optional[bool] = None

class UserInDB(User):
    hashed_password: str

# OAuth2PasswordBearer会创建一个依赖项来验证令牌
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

# 获取用户信息
def get_user(db, username: str):
    if username in db:
        user_dict = db[username]
        return UserInDB(**user_dict)

# 验证用户是否有效
def authenticate_user(db, username: str, password: str):
    user = get_user(db, username)
    if not user:
        return False
    if not user.hashed_password == fake_hash_password(password):
        return False
    return user

# 生成访问令牌
def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=15)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

# 登录并获取Token的路由
@app.post("/token", response_model=dict)
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
    user = authenticate_user(fake_users_db, form_data.username, form_data.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(
        data={"sub": user.username}, expires_delta=access_token_expires
    )
    return {"access_token": access_token, "token_type": "bearer"}

# 依赖项，通过Token获取当前用户
async def get_current_user(token: str = Depends(oauth2_scheme)):
    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])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
    except jwt.PyJWTError:
        raise credentials_exception
    user = get_user(fake_users_db, username)
    if user is None:
        raise credentials_exception
    return user

# 依赖项，获取当前激活的用户
async def get_current_active_user(current_user: User = Depends(get_current_user)):
    if current_user.disabled:
        raise HTTPException(status_code=400, detail="Inactive user")
    return current_user

# 受保护的路由
@app.get("/users/me", response_model=User)
async def read_users_me(current_user: User = Depends(get_current_active_user)):
    return current_user

3. 代码说明

用户登录和Token生成：
用户通过/token接口提交用户名和密码。我们在数据库（假设为fake_users_db）中验证用户的凭据。验证通过后，生成JWT Token并返回给用户。
JWT验证：
使用jwt.encode生成Token，jwt.decode解析Token。Token中存储了用户的身份信息（sub字段），并且有过期时间。
保护路由：
使用依赖项Depends(oauth2_scheme)来获取请求头中的Token，然后使用get_current_active_user函数对Token进行验证。只有通过验证的用户才能访问受保护的路由。
Swagger UI：
FastAPI自带的Swagger文档支持会自动生成所有API接口的文档，并且在/docs页面展示。我们可以通过该页面直接测试用户登录、Token生成、以及受保护的路由。