FastAPI 中如何使用 JWT 进行身份验证？

推荐答案

在 FastAPI 中使用 JWT 进行身份验证的步骤如下：

1. 安装依赖： 首先，安装 python-jose 和 passlib 库来生成和验证 JWT 令牌。

   pip install python-jose[cryptography] passlib[bcrypt]

2. 创建 JWT 工具函数： 创建用于生成和验证 JWT 令牌的工具函数。

   // www.javascriptcn.com code example
   from datetime import datetime, timedelta
   from jose import JWTError, jwt
   from passlib.context import CryptContext
   
   SECRET_KEY = "your-secret-key"
   ALGORITHM = "HS256"
   ACCESS_TOKEN_EXPIRE_MINUTES = 30
   
   pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
   
   def create_access_token(data: dict, expires_delta: 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
   
   def verify_password(plain_password, hashed_password):
       return pwd_context.verify(plain_password, hashed_password)
   
   def get_password_hash(password):
       return pwd_context.hash(password)

3. 创建用户模型和认证路由： 定义用户模型并创建用于登录和获取 JWT 令牌的路由。

   // www.javascriptcn.com code example
   from fastapi import FastAPI, Depends, HTTPException, status
   from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
   from pydantic import BaseModel
   
   app = FastAPI()
   
   oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
   
   class User(BaseModel):
       username: str
       email: str = None
       full_name: str = None
       disabled: bool = None
   
   class UserInDB(User):
       hashed_password: str
   
   def fake_decode_token(token):
       user = get_user(fake_users_db, token)
       return user
   
   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
           token_data = TokenData(username=username)
       except JWTError:
           raise credentials_exception
       user = get_user(fake_users_db, username=token_data.username)
       if user is None:
           raise credentials_exception
       return user
   
   @app.post("/token")
   async def login(form_data: OAuth2PasswordRequestForm = Depends()):
       user_dict = fake_users_db.get(form_data.username)
       if not user_dict:
           raise HTTPException(status_code=400, detail="Incorrect username or password")
       user = UserInDB(**user_dict)
       if not verify_password(form_data.password, user.hashed_password):
           raise HTTPException(status_code=400, detail="Incorrect username or password")
       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"}
   
   @app.get("/users/me")
   async def read_users_me(current_user: User = Depends(get_current_user)):
       return current_user

本题详细解读

JWT 简介

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在网络应用环境间安全地传递声明。JWT 通常用于身份验证和信息交换。

FastAPI 中的 JWT 实现

在 FastAPI 中，JWT 的实现通常涉及以下几个步骤：

1. 安装依赖：

   • python-jose 用于生成和验证 JWT 令牌。
   • passlib 用于密码哈希和验证。

2. 创建 JWT 工具函数：

   • create_access_token 函数用于生成 JWT 令牌。
   • verify_password 和 get_password_hash 函数用于密码的验证和哈希。

3. 创建用户模型和认证路由：

   • 定义用户模型 User 和 UserInDB。
   • 创建 /token 路由用于用户登录并返回 JWT 令牌。
   • 创建 /users/me 路由用于获取当前用户信息，该路由依赖于 get_current_user 函数来验证 JWT 令牌。

安全性考虑

• 密钥管理：确保 SECRET_KEY 的安全性，避免泄露。
• 令牌过期：设置合理的令牌过期时间，防止令牌被长期滥用。
• 密码哈希：使用 bcrypt 等安全哈希算法存储用户密码。

通过以上步骤，你可以在 FastAPI 中实现基于 JWT 的身份验证机制。