Bagaimana anda mengimplementasikan autentikasi (OAuth2/JWT)?

Question

Accepted Answer

FastAPI menyediakan alat bawaan (`OAuth2PasswordBearer`, utilitas keamanan) untuk mengimplementasikan autentikasi, biasanya menggunakan **aliran kata sandi OAuth2 dengan token JWT**. Pola ini menggabungkan penerbitan token (login) dengan dependensi yang memvalidasi token pada rute yang dilindungi.

## Hashing kata sandi dan penerbitan JWT saat login

```python
from passlib.context import CryptContext
from jose import jwt
from datetime import datetime, timedelta

pwd = CryptContext(schemes=["bcrypt"])    # secure password hashing

@app.post("/login")
def login(form: OAuth2PasswordRequestForm = Depends()):
    user = get_user(form.username)
    if not user or not pwd.verify(form.password, user.hashed_password):  # constant-time check
        raise HTTPException(401, "Invalid credentials")
    # issue a signed JWT containing the user identity + expiry
    token = jwt.encode(
        {"sub": user.username, "exp": datetime.utcnow() + timedelta(minutes=30)},
        SECRET_KEY, algorithm="HS256",
    )
    return {"access_token": token, "token_type": "bearer"}
```

Kata sandi **di-hash** (bcrypt) — tidak pernah disimpan sebagai teks biasa. Saat login yang valid, **JWT** diterbitkan: token yang ditandatangani membawa identitas pengguna dan waktu kedaluwarsa.

## Memvalidasi token pada rute yang dilindungi (dependensi)

```python
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")   # extracts the Bearer token

def get_current_user(token: str = Depends(oauth2_scheme)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])   # verify signature + expiry
        username = payload.get("sub")
    except JWTError:
        raise HTTPException(401, "Invalid token")
    user = get_user(username)
    if not user:
        raise HTTPException(401, "User not found")
    return user

@app.get("/me")
def read_me(user: User = Depends(get_current_user)):     # PROTECTED — requires a valid token
    return user
```

Dependensi `get_current_user` mengekstrak dan **memverifikasi** JWT (tanda tangan + kedaluwarsa), memuat pengguna, dan disuntikkan ke titik akhir yang dilindungi — rute apa pun yang bergantung padanya memerlukan autentikasi.

## Otorisasi (peran/ruang lingkup)

```python
def require_admin(user: User = Depends(get_current_user)):
    if not user.is_admin:
        raise HTTPException(403, "Forbidden")     # authorization check
    return user
# OAuth2 SCOPES provide fine-grained permission control
```

## Mengapa ini penting

Autentikasi penting dan **kritis untuk keamanan** — hampir setiap API nyata perlu melindungi rute, dan mengabaikan autentikasi menciptakan kerentanan serius.

Memahami pendekatan FastAPI penting: ini menyediakan blok bangunan (`OAuth2PasswordBearer`, utilitas keamanan) untuk pola standar **aliran kata sandi OAuth2 dengan JWT**, yang secara elegan memanfaatkan kekuatan FastAPI — titik akhir login menerbitkan token yang ditandatangani, dan **dependensi `get_current_user`** memvalidasinya, dengan bersih melindungi rute apa pun yang bergantung padanya (pola autentikasi idiomatik FastAPI).

Beberapa aspek sangat penting untuk diterapkan dengan benar: **hashing kata sandi** (bcrypt, bukan teks biasa, dengan verifikasi waktu konstan), **penandatanganan dan verifikasi JWT** dengan benar (tanda tangan + validasi kedaluwarsa), membedakan **autentikasi** (siapa Anda) dari **otorisasi** (apa yang dapat Anda lakukan, melalui pemeriksaan peran/ruang lingkup), dan menjaga kunci rahasia tetap aman.

Mengetahui cara mengimplementasikan pola ini dengan aman — penerbitan token, dependensi validasi, dan otorisasi — adalah pengetahuan tingkat senior fundamental untuk membangun aplikasi FastAPI yang aman, karena autentikasi ada di mana-mana dan sumber kesalahan berbahaya yang sering terjadi saat diimplementasikan dengan tidak benar.