So implementieren Sie die Authentifizierung und Autorisierung von Anforderungen in FastAPI

So implementieren Sie die Anforderungsauthentifizierung und -autorisierung in FastAPI

Mit der Entwicklung des Internets haben Netzwerksicherheitsprobleme immer mehr Aufmerksamkeit auf sich gezogen. Bei der Entwicklung von Webanwendungen sind Anforderungsauthentifizierung und -autorisierung wichtige Aspekte zur Gewährleistung der Anwendungssicherheit. In diesem Artikel wird erläutert, wie Sie die Anforderungsauthentifizierung und -autorisierung im FastAPI-Framework implementieren.

FastAPI ist ein leistungsstarkes Python-basiertes Web-Framework, das eine einfache und leistungsstarke Möglichkeit zum Erstellen von Web-APIs bietet. Es integriert die Pydantic-Bibliothek und das Starlette-Framework und macht den Entwicklungsprozess einfacher und effizienter.

1. Abhängigkeiten installieren

Zuerst müssen wir FastAPI und die entsprechenden Abhängigkeiten installieren. Es kann mit dem folgenden Befehl installiert werden:

$ pip install fastapi
$ pip install uvicorn

2. Eine Basisanwendung erstellen

Als nächstes erstellen wir eine einfache FastAPI-Anwendung und fügen einige grundlegende Routen und Endpunkte hinzu. In diesem Beispiel erstellen wir eine Datei mit dem Namen „app.py“ und kopieren den folgenden Code hinein:

from fastapi import FastAPI

app = FastAPI()

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

3. Authentifizierung und Autorisierung hinzufügen

Als nächstes besprechen wir, wie wir die Sicherheitsfunktionalität von FastAPI verwenden, um die Anforderungsauthentifizierung zu implementieren und Genehmigung. Wir werden OAuth2.0 als Mechanismus zur Authentifizierung und Autorisierung verwenden.

Zuerst müssen wir die relevanten Module und Klassen importieren:

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

Dann erstellen wir einen Passwortverschlüsselungskontext:

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

Als nächstes definieren wir ein Benutzermodell zur Authentifizierung des Benutzers:

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

Dann erstellen wir einen Dummy Datenbank und fügen zu Testzwecken einige Benutzerinformationen hinzu:

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

Als nächstes definieren wir eine Funktion, um die Anmeldeinformationen des Benutzers zu überprüfen:

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

Dann definieren wir eine Funktion, um den aktuellen Benutzer abzurufen:

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

Abschließend wenden wir diese Funktionen an zu unserer FastAPI-Anwendung:

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"}]}

4. Testen der Anwendung

Jetzt können wir die Anwendung ausführen und testen. Starten Sie die Anwendung, indem Sie den folgenden Befehl ausführen:

$ uvicorn app:app --reload

Als Nächstes können wir Curl oder ein beliebiges HTTP-Client-Tool verwenden, um die Anwendung zu testen. Zuerst müssen wir das Zugriffstoken erhalten:

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

Die Antwort, die wir erhalten, sollte wie folgt aussehen:

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

Anschließend können wir das Zugriffstoken verwenden, das wir erhalten haben, um auf den eingeschränkten Endpunkt zuzugreifen:

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

Wir sollten eine Antwort wie diese erhalten:

{"items":[{"item_id":"Item 1"},{"item_id":"Item 2"}]}

Also haben wir die Authentifizierung und Autorisierung von Anfragen in der FastAPI-Anwendung erfolgreich implementiert.

Zusammenfassung:

In diesem Artikel wird beschrieben, wie Sie die Anforderungsauthentifizierung und -autorisierung im FastAPI-Framework implementieren. Wir nutzen die Sicherheitsfunktionen von FastAPI und führen die Authentifizierung und Autorisierung über den OAuth2.0-Mechanismus durch. Durch den Import relevanter Module und Klassen, die Erstellung eines Passwortverschlüsselungskontexts, die Definition von Benutzermodellen und Verifizierungsfunktionen wird die angeforderte Authentifizierungsfunktion implementiert. Abschließend haben wir diese Funktionen auf die FastAPI-Anwendung angewendet und getestet. Mit diesen Schritten können wir eine sichere und zuverlässige Webanwendung erstellen.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Authentifizierung und Autorisierung von Anforderungen in FastAPI. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!