So implementieren Sie die Authentifizierung und Autorisierung von Anforderungen in FastAPI

王林
Freigeben: 2023-07-29 16:39:20
Original
1573 Leute haben es durchsucht

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
Nach dem Login kopieren
  1. 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"}
Nach dem Login kopieren
  1. 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
Nach dem Login kopieren

Dann erstellen wir einen Passwortverschlüsselungskontext:

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
Nach dem Login kopieren

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
Nach dem Login kopieren

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)
]
Nach dem Login kopieren

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
Nach dem Login kopieren

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
Nach dem Login kopieren

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"}]}
Nach dem Login kopieren
  1. 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
Nach dem Login kopieren

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'
Nach dem Login kopieren

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

{"access_token":"user1","token_type":"bearer"}
Nach dem Login kopieren

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'
Nach dem Login kopieren

Wir sollten eine Antwort wie diese erhalten:

{"items":[{"item_id":"Item 1"},{"item_id":"Item 2"}]}
Nach dem Login kopieren

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!

Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage
Über uns Haftungsausschluss Sitemap
Chinesische PHP-Website:Online-PHP-Schulung für das Gemeinwohl,Helfen Sie PHP-Lernenden, sich schnell weiterzuentwickeln!