អត្ថបទនេះបកប្រែពីភាសាអង់គ្លេសដោយ AI។ អានអត្ថបទដើមជាភាសាអង់គ្លេស →
FastAPI JWT Authentication ឆ្នាំ 2026: បង្កើត Login API ពេញលេញក្នុងឯកសារតែមួយ (Argon2 + PyJWT តេស្តរួចរាល់)
មេរៀន auth លើ FastAPI ភាគច្រើន បង្រៀនត្រឹមតែ "វាបង្កើត token ឱ្យ" ប៉ុណ្ណោះ។ ប៉ុន្តែអត្ថបទនេះទៅឆ្ងាយជាងហ្នឹង៖ ឯកសារតែមួយ កូដ 118 បន្ទាត់ មាន endpoint ចំនួនប្រាំ ហើយរាល់ response ខាងក្រោមសុទ្ធតែបានមកពីការដំណើរការកូដជាក់ស្ដែង រួមទាំងករណី error ដែលមគ្គុទ្ទេសក៍ភាគច្រើនរំលងចោលផងដែរ ដូចជា៖ គ្មាន token, ខុសពាក្យសម្ងាត់, token ត្រូវគេកែបន្លំ និង token ហួសសុពលភាព។
ខ្ញុំបានសរសេរកូដវាម្ដងមួយបន្ទាត់ៗនៅក្នុងវីដេអូនេះ៖
▶ WATCH ON YOUTUBEWatch the video
តេស្តជាមួយ៖ Python 3.12 · FastAPI 0.128 · PyJWT 2.15 · pwdlib 0.2 (Argon2) · Pydantic 2.13 · Uvicorn 0.39.
អ្វីដែលអ្នកនឹងបង្កើត
| Endpoint | តួនាទី |
|---|---|
GET / |
សារ root និងតំណភ្ជាប់ទៅកាន់ docs |
GET /health |
ពិនិត្យស្ថានភាពប្រព័ន្ធ (Health check) |
POST /token |
ចូលប្រើ (Log in) ជាមួយ username និង password រួចទទួលបាន JWT |
GET /me |
បង្ហាញព័ត៌មាន user ដែលកំពុង Login (ត្រូវការ token) |
GET /protected |
ឧទាហរណ៍នៃ route ដែលមានការការពារ (ត្រូវការ token) |
ដំណើរការរបស់វា៖ client ផ្ញើ username និង password ទៅកាន់ /token រួចទទួលបាន JWT ដែលចុះហត្ថលេខារួច បន្ទាប់មកផ្ញើ token នោះជា Authorization: Bearer <token> រាល់ពេលស្នើសុំចូលទៅកាន់ route ដែលមានការការពារ។ dependency តែមួយគត់គឺ get_current_user() នឹងទទួលរ៉ាប់រងការត្រួតពិនិត្យទាំងអស់ ដូច្នេះដើម្បីការពារ route ថ្មីណាមួយ អ្នកគ្រាន់តែថែមមួយបន្ទាត់ប៉ុណ្ណោះ។
1. ដំឡើង
requirements.txt:
fastapi>=0.115.0
uvicorn[standard]>=0.30.0
pyjwt>=2.9.0
pwdlib[argon2]>=0.2.0
python-multipart>=0.0.9
python-dotenv>=1.0.1python3.12 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt- PyJWT ប្រើសម្រាប់ចុះហត្ថលេខា (sign) និងផ្ទៀងផ្ទាត់ token។ (ឯកសារជំនួយផ្លូវការរបស់ FastAPI បានប្តូរពី python-jose មកប្រើ PyJWT វិញហើយ។)
- pwdlib[argon2] ប្រើសម្រាប់ hash ពាក្យសម្ងាត់ជាមួយ Argon2 ដែលជាជម្រើសទំនើបជំនួសឱ្យ passlib។
- python-multipart ចាំបាច់ត្រូវមាន ព្រោះ endpoint សម្រាប់ login ទទួលទិន្នន័យជាទម្រង់ HTML form។
សូមប្រើ Python 3.10 ឬជំនាន់ថ្មីជាងនេះ៖ កូដនេះប្រើ type hint បែប str | None ដែល Pydantic មិនគាំទ្រនៅលើជំនាន់ 3.9 នោះទេ។
2. កំណត់ Config៖ secret, algorithm និងរយៈពេលផុតកំណត់
load_dotenv()
app = FastAPI(title="FastAPI JWT Authentication", version="1.0.0")
JWT_SECRET = os.getenv("JWT_SECRET", "dev-only-secret-change-me")
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30
password_hash = PasswordHash.recommended()
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")PasswordHash.recommended() នឹងជ្រើសរើសយក Argon2។ ចំណែក OAuth2PasswordBearer(tokenUrl="token") ប្រាប់ FastAPI ថាត្រូវយក token មកពីណា ហើយវាក៏ជាអ្នកដំណើរការប៊ូតុង Authorize នៅក្នុង Swagger UI ផងដែរ។
បង្កើត secret ពិតប្រាកដមួយ រួចដាក់វាចូលក្នុង .env។ មូលហេតុលម្អិតមានរៀបរាប់នៅខាងក្រោម៖
python -c "import secrets; print(secrets.token_urlsafe(32))"JWT_SECRET=paste-the-output-here3. User, model និងការពិនិត្យពាក្យសម្ងាត់
សម្រាប់គំរូសាកល្បងនេះ យើងទុក user នៅក្នុង dict ហើយពាក្យសម្ងាត់ត្រូវបាន hash តាំងពីពេល app ចាប់ផ្តើមដំណើរការ ដូច្នេះមិនមានការរក្សាទុកពាក្យសម្ងាត់ជាអក្សរធម្មតា (plain-text) ឡើយ៖
DEMO_USERS = {
"demo": {
"username": "demo",
"full_name": "Demo User",
"hashed_password": password_hash.hash("demo123"),
}
}
class Token(BaseModel):
access_token: str
token_type: str
class User(BaseModel):
username: str
full_name: str | None = None
def authenticate_user(username: str, password: str) -> User | None:
record = DEMO_USERS.get(username)
if record is None:
return None
if not password_hash.verify(password, record["hashed_password"]):
return None
return get_user(username)សូមកត់សម្គាល់ថា User មិនមាន field សម្រាប់ password ទេ។ ដោយសារ route នីមួយៗកំណត់ response_model=User នោះតម្លៃ hash នឹងមិនអាចធ្លាយចេញទៅក្នុង response ដោយអចេតនាបានឡើយ។
4. បង្កើត token
def create_access_token(data: dict, expires: timedelta | None = None) -> str:
payload = data.copy()
if expires is None:
expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
payload["exp"] = datetime.now(timezone.utc) + expires
return jwt.encode(payload, JWT_SECRET, algorithm=ALGORITHM)សូមប្រើ datetime.now(timezone.utc) ជំនួសឱ្យ utcnow() ដែលគេលែងឱ្យប្រើ (deprecated)។ PyJWT នឹងជួយពិនិត្យ exp ឱ្យអ្នកដោយស្វ័យប្រវត្តិតែម្តងនៅពេលវា decode។
5. Dependency សម្រាប់ការពាររាល់ route
async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]) -> User:
error = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Could not validate credentials",
headers={"WWW-Authenticate": "Bearer"},
)
try:
payload = jwt.decode(token, JWT_SECRET, algorithms=[ALGORITHM])
except InvalidTokenError:
raise error
username = payload.get("sub")
if username is None:
raise error
user = get_user(username)
if user is None:
raise error
return userមានចំណុចសំខាន់ពីរដែលត្រូវចាប់អារម្មណ៍នៅត្រង់នេះ៖
algorithms=[ALGORITHM]ត្រូវបញ្ជាក់ច្បាស់លាស់ជា list។ កុំបណ្តោយឱ្យ header របស់ token ជាអ្នកកំណត់ algorithm ឱ្យសោះ។- រាល់ពេលមានបញ្ហាបរាជ័យ វាតែងតែបញ្ជូន 401 ដូចៗគ្នាជានិច្ច។ មិនថា signature មិនត្រឹមត្រូវ, token ហួសកំណត់ ឬរក user មិនឃើញទេ សុទ្ធតែបង្ហាញដូចគ្នាបេះបិទទៅកាន់ client ដែលធ្វើឱ្យជនវាយប្រហារ (attacker) មិនអាចទស្សន៍ទាយដឹងអ្វីបានឡើយ។
6. បណ្តា Endpoint
@app.post("/token", response_model=Token)
async def login(form: Annotated[OAuth2PasswordRequestForm, Depends()]):
user = authenticate_user(form.username, form.password)
if user is None:
raise HTTPException(status_code=401, detail="Incorrect username or password")
token = create_access_token({"sub": user.username})
return Token(access_token=token, token_type="bearer")
@app.get("/me", response_model=User)
async def read_me(user: Annotated[User, Depends(get_current_user)]):
return user
@app.get("/protected")
async def protected(user: Annotated[User, Depends(get_current_user)]):
return {
"message": f"Hello {user.username}, your JWT is valid.",
"framework": "FastAPI",
"language": "Python",
}បើចង់ការពារ route ថ្មីណាមួយ អ្នកគ្រាន់តែថែម user: Annotated[User, Depends(get_current_user)] ទៅក្នុង parameter របស់វាជាការស្រេច។ ទម្រង់ទាំងមូលមានតែប៉ុណ្ណឹងឯង។
7. ដំណើរការវា
uvicorn app:app --reloadបើក http://127.0.0.1:8000/docs ចុចលើពាក្យ Authorize ហើយ log in ដោយប្រើ demo / demo123។ ឬក៏អ្នកអាចតេស្តជាមួយ curl ដូចដែលខ្ញុំបានធ្វើនៅខាងក្រោម។
8. លទ្ធផលតេស្តជាក់ស្តែង៖ ករណីដំណើរការជោគជ័យ (Happy path)
ចូលប្រព័ន្ធ (Log in)៖
curl -X POST http://127.0.0.1:8000/token -d "username=demo&password=demo123"{"access_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdW...","token_type":"bearer"}JWT ផ្សំឡើងពីផ្នែក base64url ចំនួនបីដែលខណ្ឌដោយសញ្ញាចុច (.) រួមមាន៖ header, payload និង signature។ នៅពេល decode ផ្នែកពីរដំបូង យើងឃើញ៖
{"alg":"HS256","typ":"JWT"}
{"sub":"demo","exp":1791785986}អ្នកណាក៏អាចមើល payload ឃើញដែរ។ វាគ្រាន់តែចុះហត្ថលេខា (signed) ប៉ុណ្ណោះ មិនមែនជាការបំប្លែងកូដសម្ងាត់ (encrypted) ទេ ដូច្នេះកុំដាក់ password ឬទិន្នន័យសម្ងាត់ចូលក្នុងហ្នឹងឱ្យសោះ។
យក token ទៅប្រើ៖
curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:8000/me{"username":"demo","full_name":"Demo User"}curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:8000/protected{"message":"Hello demo, your JWT is valid.","framework":"FastAPI","language":"Python"}9. លទ្ធផលតេស្តជាក់ស្តែង៖ ករណី error ផ្សេងៗ
នេះជាផ្នែកដែលបញ្ជាក់ច្បាស់ថាប្រព័ន្ធ auth របស់អ្នកដំណើរការបានត្រឹមត្រូវពិតមែនឬអត់។
| ការតេស្ត | Status | Response |
|---|---|---|
/me ដោយគ្មាន token |
401, www-authenticate: Bearer |
{"detail":"Not authenticated"} |
| Login ដោយប្រើពាក្យសម្ងាត់ខុស | 401 | {"detail":"Incorrect username or password"} |
/me ដោយកែតួអក្សរចុងក្រោយរបស់ token |
401 | {"detail":"Could not validate credentials"} |
/me ជាមួយ token ដែលផុតកំណត់ 1 នាទីមុន |
401 | {"detail":"Could not validate credentials"} |
គ្រាន់តែកែប្រែអក្សរតែមួយតួ វានឹងធ្វើឱ្យ signature ខូចភ្លាម ហើយចំពោះ token ដែលហួសសុពលភាពវិញ ក៏ត្រូវបានច្រានចោលដោយមុខងារត្រួតពិនិត្យ exp ស្រាប់របស់ PyJWT ដែរ។ ករណីទាំងពីរនេះមិនបាច់សរសេរកូដបន្ថែមសូម្បីតែមួយបន្ទាត់។
ការព្រមានដែល PyJWT 2.15 បានបង្ហាញប្រាប់ខ្ញុំ
ពេលខ្ញុំចុះហត្ថលេខាលើ token ដោយប្រើ fallback secret ខាង PyJWT បានបង្ហាញសារព្រមានថា៖
InsecureKeyLengthWarning: The HMAC key is 25 bytes long, which is below the
minimum recommended length of 32 bytes for SHA256. See RFC 7518 Section 3.2."dev-only-secret-change-me" មានប្រវែងត្រឹមតែ 25 bytes ប៉ុណ្ណោះ។ សម្រាប់ HS256 តម្លៃ secret របស់អ្នកគួរតែមានយ៉ាងហោចណាស់ 32 bytes។ ការប្រើ secrets.token_urlsafe(32) នឹងបង្កើតអក្សរឱ្យអ្នករហូតដល់ 43 តួ ដែលវែងគ្រប់គ្រាន់តែម្តង។ គ្រាន់តែដាក់ JWT_SECRET នៅក្នុង .env សារព្រមាននេះនឹងបាត់ទៅវិញហើយ។
មុនពេលអ្នកយកទៅប្រើជាក់ស្តែង
នេះគ្រាន់តែជាកូដគ្រឹះសម្រាប់រៀនសូត្រប៉ុណ្ណោះ មិនទាន់ជាប្រព័ន្ធសុវត្ថិភាពពេញលេញនៅឡើយទេ៖
- ប្តូរការទុក user ទៅក្នុង database ពិតប្រាកដ ហើយត្រូវ hash ពាក្យសម្ងាត់នៅពេលចុះឈ្មោះ (signup) មិនមែនពេល app ចាប់ផ្តើមដំណើរការ (startup) នោះទេ។
- កុំរក្សាទុក secret នៅក្នុង repo ឱ្យសោះ។ គួរប្រើកម្មវិធីគ្រប់គ្រង secret (secrets manager) នៅលើ production និងឧស្សាហ៍ផ្លាស់ប្តូរវា (rotate)។
- បន្ថែម refresh token ដើម្បីកុំឱ្យ access token ដែលមានសុពលភាព 30 នាទីនោះ មានអាយុកាលវែងពេក។
- កំណត់កម្រិតនៃការហៅប្រើ (Rate-limit) លើ
/tokenដើម្បីបង្អាក់ការទស្សន៍ទាយពាក្យសម្ងាត់។ - ប្រើ HTTPS ជានិច្ច។ ដរាបណា bearer token នៅមានសុពលភាព តម្លៃរបស់វាគឺស្មើនឹងពាក្យសម្ងាត់ដែរ។
- រក្សាទុកការតេស្តករណី error ពីផ្នែកទី 9 នៅក្នុង test suite របស់អ្នក។
វីដេអូពេញលេញ
កូដគ្រប់បន្ទាត់ត្រូវបានសរសេរបង្ហាញលើអេក្រង់ រួចតេស្តផ្ទាល់នៅលើ Swagger UI៖ មេរៀន FastAPI JWT Authentication (2026)។
បើជាប់ error ត្រង់ណា? អ្នកអាច copy កូដ traceback មកដាក់ក្នុង comment បាន ចាំខ្ញុំជួយមើលឱ្យ។
សរសេរព្រាងឡើងដោយមានជំនួយពី AI។ កូដទាំងអស់ដកស្រង់ចេញពីគម្រោងផ្ទាល់ខ្លួនរបស់ខ្ញុំ ហើយរាល់ response ខាងលើគឺសុទ្ធតែទទួលបានពីការដំណើរការជាក់ស្តែងកាលពីថ្ងៃទី 12 ខែតុលា ឆ្នាំ 2026។


