Setting up authorization and authentication in FastAPI involves several steps:

1. Install necessary packages: First, you'll need to install two packages: fastapi-users and fastapi-jwt-auth. fastapi-users provides the user authentication and management functionality, while fastapi-jwt-auth provides JWT (JSON Web Token) authentication.
``` 
pip install fastapi-users fastapi-jwt-auth[bcrypt]
``` 
2. Define your User model: You'll need to create a model that defines the properties of a user, such as their email and password.
``` 
class User(BaseModel, UserManagerMixin):
    email: EmailStr
    password: str
    is_active: bool = True
    is_superuser: bool = False
``` 
3. Create a user database: You'll need to create a database of user objects, which can be done using any database framework, such as SQLAlchemy or Tortoise-ORM.

4. Configure the authentication system: You'll need to configure the authentication system to use JWT tokens for authentication. This involves defining a secret key for encoding and decoding the tokens.
``` 
from fastapi_jwt_auth import AuthJWT

authjwt_secret_key = "secret"
authjwt_algorithm = "HS256"
``` 
5. Create authentication routes: You'll need to create routes for registering, logging in, and logging out users.

``` 
from fastapi_users import FastAPIUsers, LoginCredentials
from fastapi_users.authentication import JWTAuthentication

users = FastAPIUsers(
    User,
    [JWTAuthentication(secret=authjwt_secret_key, lifetime_seconds=3600)],
    UserCreate,
    UserUpdate,
    UserDB,
)

@app.post("/auth/jwt/login")
async def login(credentials: LoginCredentials):
    user = await fastapi_users.get_user(credentials.username)
    if not user or not await fastapi_users.verify_password(credentials.password, user.password):
        raise HTTPException(status_code=HTTP_401_UNAUTHORIZED, detail="Incorrect username or password")
    access_token = AuthJWT.create_access_token(subject=user.email)
    return {"access_token": access_token}
``` 

6. Secure your routes: You'll need to use the Depends function from FastAPI to add authentication and authorization to your routes.
``` 
from fastapi import Depends
from fastapi_jwt_auth import AuthJWT

async def get_current_user(authjwt: AuthJWT = Depends()):
    try:
        authjwt.jwt_required()
        user_email = authjwt.get_jwt_subject()
        user = await fastapi_users.get_user(user_email)
        return user
    except Exception as e:
        raise HTTPException(status_code=HTTP_401_UNAUTHORIZED, detail=str(e))
``` 
This function can then be added as a dependency to your routes that require authentication.

Overall, setting up authentication and authorization in FastAPI involves creating a user model, configuring authentication and authorization routes, and securing your routes using the Depends function.
การตั้งค่าการอนุญาตและการรับรองความถูกต้องใน FastAPI เกี่ยวข้องกับหลายขั้นตอน: 1. ติดตั้งแพ็คเกจที่จำเป็น: ขั้นแรก คุณจะต้องติดตั้งสองแพ็คเกจ: fastapi-users และ fastapi-jwt-auth ผู้ใช้ fastapi ให้ฟังก์ชันการตรวจสอบสิทธิ์ผู้ใช้และการจัดการ ในขณะที่ fastapi-jwt-auth ให้การตรวจสอบสิทธิ์ JWT (JSON Web Token) ``` pip install fastapi-users fastapi-jwt-auth[bcrypt] ``` 2. กำหนดโมเดลผู้ใช้ของคุณ: คุณจะต้องสร้างโมเดลที่กำหนดคุณสมบัติของผู้ใช้ เช่น อีเมลและรหัสผ่าน ``` class User(BaseModel, UserManagerMixin): อีเมล: EmailStr รหัสผ่าน: str is_active: bool = True is_superuser: bool = False ``` 3. สร้างฐานข้อมูลผู้ใช้: คุณจะต้องสร้างฐานข้อมูลของวัตถุผู้ใช้ซึ่ง สามารถทำได้โดยใช้เฟรมเวิร์กฐานข้อมูลใดๆ เช่น SQLAlchemy หรือ Tortoise-ORM 4. กำหนดค่าระบบการตรวจสอบสิทธิ์: คุณจะต้องกำหนดค่าระบบการตรวจสอบสิทธิ์เพื่อใช้โทเค็น JWT สำหรับการตรวจสอบสิทธิ์ สิ่งนี้เกี่ยวข้องกับการกำหนดคีย์ลับสำหรับการเข้ารหัสและถอดรหัสโทเค็น ``` จาก fastapi_jwt_auth import AuthJWT authjwt_secret_key = "secret" authjwt_algorithm = "HS256" ``` 5. สร้างเส้นทางการตรวจสอบสิทธิ์: คุณจะต้องสร้างเส้นทางสำหรับการลงทะเบียน เข้าสู่ระบบ และออกจากระบบผู้ใช้ ``` จาก fastapi_users นำเข้า FastAPIUsers, LoginCredentials จาก fastapi_users.authentication นำเข้า JWTAuthentication users = FastAPIUsers( ผู้ใช้, [JWTAuthentication(secret=authjwt_secret_key, life_seconds=3600)], UserCreate, UserUpdate, UserDB, ) @app.post("/auth/ jwt/login") การเข้าสู่ระบบ async def (ข้อมูลรับรอง: LoginCredentials): user = await fastapi_users.get_user (credentials.username) หากไม่ใช่ผู้ใช้หรือไม่รอ fastapi_users.verify_password (credentials.password, user.password): เพิ่ม HTTPException (status_code=HTTP_401_UNAUTHORIZED , detail="ชื่อผู้ใช้หรือรหัสผ่านไม่ถูกต้อง") access_token = AuthJWT.create_access_token(subject=user.email) return {"access_token": access_token} ``` 6. รักษาความปลอดภัยเส้นทางของคุณ: คุณจะต้องใช้ฟังก์ชัน Depends จาก FastAPI เพื่อเพิ่มการรับรองความถูกต้องและการอนุญาตให้กับเส้นทางของคุณ ``` จากการนำเข้า fastapi ขึ้นอยู่กับการนำเข้า fastapi_jwt_auth AuthJWT async def get_current_user(authjwt: AuthJWT = Depends()): ลอง: authjwt.jwt_required() user_email = authjwt.get_jwt_subject() user = await fastapi_users.get_user(user_email) ส่งคืนผู้ใช้ ยกเว้น ข้อยกเว้นเช่น e: Raise HTTPException(status_code=HTTP_401_UNAUTHORIZED, detail=str(e)) ``` จากนั้นคุณสามารถเพิ่มฟังก์ชันนี้เป็นการพึ่งพาเส้นทางของคุณที่ต้องมีการรับรองความถูกต้องได้ โดยรวมแล้ว การตั้งค่าการรับรองความถูกต้องและการอนุญาตใน FastAPI เกี่ยวข้องกับการสร้างแบบจำลองผู้ใช้ การกำหนดค่าเส้นทางการรับรองความถูกต้องและการอนุญาต และการรักษาความปลอดภัยเส้นทางของคุณโดยใช้ฟังก์ชัน Depends
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence