Kem Intensif Pembangunan Bahagian Belakang FastAPI · Pelajaran

Aliran Kata Laluan OAuth2 dan Pengeluaran Token

Laksanakan skema OAuth2PasswordBearer, cincang kata laluan dengan passlib dan keluarkan token akses bertandatangan semasa log masuk.

Pelajaran 1 daripada 413 langkah

Aliran Kata Laluan OAuth2 dan Pengeluaran Token ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Aliran Kata Laluan OAuth2 dalam Bahasa Mudah

Aliran kata laluan OAuth2 (juga dikenali sebagai pemberian Kelayakan Pemilik Sumber) ialah cara paling mudah untuk mengesahkan klien pihak pertama: pengguna menghantar nama pengguna dan kata laluan mereka terus kepada API Anda, lalu API mengembalikan token akses bertandatangan.

Klien menghantar kelayakan sekali kepada titik akhir /token.
Pelayan mengesahkannya terhadap pangkalan data.
Jika berjaya, pelayan mengembalikan token akses JWT yang berjangka hayat pendek.
Setiap permintaan seterusnya membawa token tersebut dalam pengepala Authorization: Bearer <token>.

FastAPI menyediakan binaan sedia guna tepat untuk tujuan ini: OAuth2PasswordBearer dan OAuth2PasswordRequestForm.

Mengisytiharkan Skim OAuth2PasswordBearer

OAuth2PasswordBearer ialah kebergantungan FastAPI yang tahu cara mengambil token pembawa daripada pengepala Authorization. Anda mencipta satu tika dan menetapkan tokenUrl kepada titik akhir log masuk yang mengeluarkan token.

tokenUrl ialah laluan relatif — ia memberitahu antara muka dokumentasi tempat klien perlu meminta token.
Menggunakan skim sebagai kebergantungan menyebabkan titik akhir memerlukan token; pengepala yang tiada atau cacat mengembalikan 401 secara automatik.

from fastapi import Depends, FastAPI
from fastapi.security import OAuth2PasswordBearer

app = FastAPI()

# 'token' matches the path of our login route below
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")


@app.get("/users/me")
async def read_me(token: str = Depends(oauth2_scheme)):
    # FastAPI extracts the raw bearer token string for us
    return {"token": token}

Mencincang Kata Laluan dengan passlib

Anda mesti jangan sekali-kali menyimpan kata laluan mentah. Cincangkannya dengan algoritma yang kukuh dan diasinkan. Pustaka passlib membungkus bcrypt melalui API CryptContext yang kemas.

hash() menghasilkan ringkasan berasingan yang Anda simpan dalam pangkalan data.
verify() membandingkan percubaan teks biasa dengan cincangan tersimpan dalam masa yang tetap.
bcrypt sengaja diperlahankan, yang menyukarkan serangan kekerasan.

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")


def hash_password(plain: str) -> str:
    return pwd_context.hash(plain)


def verify_password(plain: str, hashed: str) -> bool:
    return pwd_context.verify(plain, hashed)


stored = hash_password("s3cret")
print("stored looks like:", stored[:7], "...")
print("correct ->", verify_password("s3cret", stored))
print("wrong   ->", verify_password("nope", stored))

Memodelkan Pengguna dan Pangkalan Data Palsu yang Kecil

Sebelum mengeluarkan token, kita memerlukan tempat untuk mencari pengguna. Dalam pengeluaran, ini ialah pangkalan data sebenar Anda; untuk pembelajaran, kita menggunakan kamus dalam memori. Perhatikan bahawa medan yang disimpan ialah hashed_password, bukannya teks biasa.

Model Pydantic memberikan bentuk ditaip kepada pengguna.
Pembantu get_user() memusatkan carian.

from pydantic import BaseModel


class UserInDB(BaseModel):
    username: str
    hashed_password: str
    disabled: bool = False


fake_users_db = {
    "alice": UserInDB(
        username="alice",
        hashed_password="$2b$12$exampleexampleexamplehashvalue",
    )
}


def get_user(username: str):
    return fake_users_db.get(username)

Mengesahkan Kelayakan

Pengesahan menggabungkan semua bahagian: cari pengguna, kemudian sahkan kata laluan yang diberikan terhadap cincangan tersimpan. Kembalikan pengguna jika berjaya, atau nilai palsu jika gagal.

Cari pengguna terlebih dahulu; jika tiada, gagalkan proses.
Kemudian panggil verify_password — jangan pintas proses sebelum pencincangan supaya masa pelaksanaan kekal lebih kurang seragam.
Pemanggil menentukan cara memberikan respons (biasanya 401).

def authenticate_user(db, username: str, password: str):
    user = db.get(username)
    if not user:
        return None
    if not verify_password(password, user.hashed_password):
        return None
    return user

Apakah Sebenarnya JWT

Token Web JSON terdiri daripada tiga segmen base64url yang digabungkan dengan titik: header.payload.signature.

Pengepala menamakan algoritma, contohnya HS256.
Muatan menyimpan tuntutan seperti sub (subjek) dan exp (tamat tempoh).
Tandatangan ialah HMAC bagi pengepala+muatan menggunakan kunci rahsia Anda.

JWT ialah bertandatangan, bukan disulitkan — sesiapa sahaja boleh membaca muatan, tetapi tiada siapa boleh memalsukannya tanpa rahsia tersebut. Jangan sekali-kali meletakkan kata laluan atau data sensitif dalam muatan.

Mengekod Token Akses Bertandatangan

Kita menandatangani token dengan pustaka python-jose (atau PyJWT). Sentiasa sertakan tuntutan exp supaya token tamat tempoh. Simpan nama pengguna dalam tuntutan sub — ia mengenal pasti pemilik token tersebut.

SECRET_KEY mestilah panjang, rawak dan tidak disimpan dalam kawalan sumber.
Tetapkan jangka hayat yang pendek (contohnya 15-30 minit) untuk token akses.

from datetime import datetime, timedelta, timezone
from jose import jwt

SECRET_KEY = "replace-with-a-long-random-secret"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30


def create_access_token(data: dict) -> str:
    to_encode = data.copy()
    expire = datetime.now(timezone.utc) + timedelta(
        minutes=ACCESS_TOKEN_EXPIRE_MINUTES
    )
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)


token = create_access_token({"sub": "alice"})
print("issued token segments:", token.count(".") + 1)

Bentuk Respons Token

Spesifikasi OAuth2 menetapkan JSON yang dikembalikan oleh titik akhir /token Anda. Sekurang-kurangnya, JSON itu mesti menyertakan access_token dan token_type, dengan jenis berupa rentetan literal "bearer".

Klien membaca token_type untuk mengetahui cara menghantar semula kelayakan tersebut.
Model Pydantic Token mendokumenkan dan mengesahkan respons.

from pydantic import BaseModel


class Token(BaseModel):
    access_token: str
    token_type: str


example = Token(access_token="eyJhbGci...", token_type="bearer")
print(example.model_dump())

Menyambungkan Titik Akhir Log Masuk /token

Laluan log masuk bergantung pada OAuth2PasswordRequestForm, yang membaca medan username dan password yang dikodkan sebagai borang (bukan JSON) — tepat seperti yang diperlukan oleh aliran kata laluan OAuth2. Jika berjaya, laluan ini mengembalikan respons Token.

Pengesahan yang gagal mencetuskan 401 dengan pengepala WWW-Authenticate: Bearer.
Tuntutan sub membawa nama pengguna ke dalam token.

from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordRequestForm

app = FastAPI()


@app.post("/token", response_model=Token)
async def login(form: OAuth2PasswordRequestForm = Depends()):
    user = authenticate_user(fake_users_db, form.username, form.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token = create_access_token({"sub": user.username})
    return Token(access_token=access_token, token_type="bearer")

Menyahkod Token untuk Mencari Pengguna Semasa

Laluan terlindung bergantung pada oauth2_scheme untuk menerima token mentah, kemudian menyahkodnya. Jika tandatangan tidak sah atau token telah tamat tempoh, jwt.decode mencetuskan JWTError dan kita mengembalikan 401.

Baca nama pengguna daripada tuntutan sub.
Muatkan semula pengguna daripada pangkalan data untuk mengesahkan bahawa pengguna tersebut masih wujud dan aktif.

from fastapi import Depends, HTTPException, status
from jose import JWTError, jwt


async def get_current_user(token: str = Depends(oauth2_scheme)):
    credentials_exc = 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 = payload.get("sub")
        if username is None:
            raise credentials_exc
    except JWTError:
        raise credentials_exc
    user = get_user(username)
    if user is None:
        raise credentials_exc
    return user

Amalan Keselamatan yang Penting

Mekanismenya berfungsi, tetapi pengukuhan untuk persekitaran pengeluaran menjadikannya selamat:

Kunci rahsia: muatkan SECRET_KEY daripada pemboleh ubah persekitaran; tukarkannya jika bocor.
HTTPS sahaja: token dalam pengepala dihantar sebagai teks biasa melalui rangkaian — TLS adalah wajib.
Tamat tempoh singkat: kekalkan token akses dalam tempoh yang singkat dan pasangkannya dengan token penyegar yang lebih panjang jangka hayatnya.
Tetapkan algoritma: hantarkan senarai algorithms=["HS256"] yang jelas kepada jwt.decode untuk menyekat serangan alg: none.
Ralat umum: nyatakan "Nama pengguna atau kata laluan tidak betul", dan jangan dedahkan yang mana satu salah.

Semakan Pantas: Titik Akhir /token

Inilah masanya untuk menguji pemahaman Anda tentang cara laluan log masuk FastAPI /token menggunakan kelayakan.

Jawab dalam pelajaran interaktif

Imbas Kembali: Daripada Kata Laluan kepada Token Pembawa

Anda telah melaksanakan aliran kata laluan OAuth2 lengkap dalam FastAPI:

OAuth2PasswordBearer mengisytiharkan skim pembawa dan mengekstrak token daripada pengepala Authorization.
passlib + bcrypt mencincang dan mengesahkan kata laluan supaya teks biasa tidak pernah disimpan.
authenticate_user mencari pengguna dan mengesahkan cincangan, lalu mengembalikan 401 jika gagal.
Laluan /token membaca kelayakan borang melalui OAuth2PasswordRequestForm dan mengeluarkan JWT bertandatangan dengan tuntutan sub serta tamat tempoh exp.
get_current_user menyahkod dan mengesahkan token, serta menetapkan algoritma untuk menyekat pemalsuan.

Dengan HTTPS, rahsia yang dimuatkan daripada persekitaran dan jangka hayat token yang pendek, ini ialah asas pengesahan yang kukuh dan mengikut amalan lazim.

Percuma untuk bermula

Pelajari Kem Intensif Pembangunan Bahagian Belakang FastAPI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 21
Pelajaran: 84

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Aliran Kata Laluan OAuth2 dan Pengeluaran Token” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “Aliran Kata Laluan OAuth2 dan Pengeluaran Token”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Aliran Kata Laluan OAuth2 dan Pengeluaran Token”?

Laksanakan skema OAuth2PasswordBearer, cincang kata laluan dengan passlib dan keluarkan token akses bertandatangan semasa log masuk. Anda berlatih Kem Intensif Pembangunan Bahagian Belakang FastAPI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Bahagian Belakang FastAPI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Aliran Kata Laluan OAuth2 dan Pengeluaran Token” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Aliran Kata Laluan OAuth2 dan Pengeluaran Token
Menandatangani dan Mengesahkan JWT dengan python-jose
Token Segar Semula dan Putaran Token
Keizinan Berasaskan Skop dan Pengawal Peranan

← Kembali ke Kem Intensif Pembangunan Bahagian Belakang FastAPI