Cara melaksanakan pengesahan dan kebenaran permintaan dalam FastAPI

Cara melaksanakan pengesahan permintaan dan kebenaran dalam FastAPI

Dengan perkembangan Internet, isu keselamatan rangkaian telah menarik lebih banyak perhatian. Apabila membangunkan aplikasi web, meminta pengesahan dan kebenaran adalah aspek penting dalam memastikan keselamatan aplikasi. Artikel ini akan memperkenalkan cara melaksanakan pengesahan permintaan dan kebenaran dalam rangka kerja FastAPI.

FastAPI ialah rangka kerja web berasaskan Python berprestasi tinggi yang menyediakan cara mudah dan berkuasa untuk mencipta API web. Ia menyepadukan perpustakaan Pydantic dan rangka kerja Starlette, menjadikan proses pembangunan lebih mudah dan cekap.

1. Pasang kebergantungan

Pertama, kita perlu memasang FastAPI dan kebergantungan yang sepadan. Ia boleh dipasang melalui arahan berikut:

$ pip install fastapi
$ pip install uvicorn

2. Buat aplikasi asas

Seterusnya, kami mencipta aplikasi FastAPI yang mudah dan menambah beberapa laluan asas dan titik akhir. Dalam contoh ini, kami akan mencipta fail yang dipanggil "app.py" dan menyalin kod berikut ke dalamnya:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

3. Tambah Pengesahan dan Kebenaran

Seterusnya, kami akan membincangkan cara menggunakan Fungsi keselamatan FastAPI untuk melaksanakan pengesahan permintaan dan kebenaran. Kami akan menggunakan OAuth2.0 sebagai mekanisme untuk pengesahan dan kebenaran.

Pertama, kami perlu mengimport modul dan kelas yang berkaitan:

from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from passlib.context import CryptContext

Kemudian, kami mencipta konteks penyulitan kata laluan:

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

Seterusnya, kami menentukan model pengguna untuk mengesahkan pengguna:

durreee

Kemudian, kami mencipta Ammy. pangkalan data dan tambah beberapa maklumat pengguna, untuk tujuan ujian:

class User:
    def __init__(self, username: str, password: str, disabled: bool = False):
        self.username = username
        self.password = pwd_context.hash(password)
        self.disabled = disabled

    def verify_password(self, password: str):
        return pwd_context.verify(password, self.password)

    def get_user(self, username: str):
        if self.username == username:
            return self

Seterusnya, kami mentakrifkan fungsi untuk mengesahkan kelayakan pengguna:

fake_db = [
    User(username="user1", password="password"),
    User(username="user2", password="password", disabled=True)
]

Kemudian, kami mentakrifkan fungsi untuk mendapatkan pengguna semasa:

def authenticate_user(username: str, password: str):
    user = get_user(username)
    if not user:
        return False
    if not user.verify_password(password):
        return False
    return user

Akhir sekali, Kami menggunakan fungsi ini ke aplikasi FastAPI kami:

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"},
    )
    user = authenticate_user(token)
    if not user:
        raise credentials_exception
    return user

4. Menguji aplikasi

Kini, kami boleh menjalankan aplikasi dan mengujinya. Mulakan aplikasi dengan menjalankan arahan berikut:

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token")

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

@app.get("/items/")
async def read_items(current_user: User = Depends(get_current_user)):
    return {"items": [{"item_id": "Item 1"}, {"item_id": "Item 2"}]}

Seterusnya, kita boleh menggunakan curl atau mana-mana alat klien HTTP untuk menguji aplikasi. Mula-mula, kita perlu mendapatkan token akses:

$ uvicorn app:app --reload

Respons yang kita terima sepatutnya kelihatan seperti:

$ curl --request POST --url http://localhost:8000/token --header 'Content-Type: application/x-www-form-urlencoded' --data 'username=user1&password=password'

Kita kemudian boleh menggunakan token akses yang kita dapat untuk mengakses titik akhir terhad:

{"access_token":"user1","token_type":"bearer"}

Kita harus mendapat respons seperti ini:

$ curl --request GET --url http://localhost:8000/items/ --header 'Authorization: Bearer user1'

Jadi, kami berjaya melaksanakan pengesahan dan kebenaran permintaan dalam aplikasi FastAPI.

Ringkasan:

Artikel ini menerangkan cara melaksanakan pengesahan permintaan dan kebenaran dalam rangka kerja FastAPI. Kami menggunakan ciri keselamatan FastAPI dan melaksanakan pengesahan dan kebenaran melalui mekanisme OAuth2.0. Dengan mengimport modul dan kelas yang berkaitan, mencipta konteks penyulitan kata laluan, menentukan model pengguna dan fungsi pengesahan, fungsi pengesahan yang diminta dilaksanakan. Akhir sekali, kami menggunakan fungsi ini pada aplikasi FastAPI dan mengujinya. Dengan langkah ini, kami boleh membina aplikasi web yang selamat dan boleh dipercayai.

Atas ialah kandungan terperinci Cara melaksanakan pengesahan dan kebenaran permintaan dalam FastAPI. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!