Wie man mit FastAPI leistungsstarke API-Dienste erstellt

FastAPI ist ein modernes, schnelles (effizientes) Web-Framework, das speziell für den Aufbau von APIs entwickelt wurde. Es basiert auf Python-Typanmerkungen und unterstützt asynchrone Programmierung, was Entwicklern ermöglicht, leistungsstarke, hochverfügbare und latenzarme API-Dienste zu erstellen. In diesem Artikel werden wir detailliert erläutern, wie man mit FastAPI leistungsstarke API-Dienste erstellt, und wir werden schrittweise vorgehen, um Ihnen zu helfen, den gesamten Prozess von der Einrichtung der Umgebung bis zur Bereitstellung zu realisieren.

Erster Schritt: Umgebung vorbereiten

Sie müssen sicherstellen, dass Python 3.6+ in Ihrer Entwicklungsumgebung installiert ist. Wenn es noch nicht installiert ist, können Sie die offizielle Python-Website besuchen, um es herunterzuladen und zu installieren.

FastAPI und Uvicorn installieren

FastAPI selbst bietet keinen Dienst an und benötigt einen ASGI-Server, um betrieben zu werden. Hier verwenden wir Uvicorn, einen leistungsstarken ASGI-Server. Sie können FastAPI und Uvicorn mit dem folgenden Befehl installieren:

pip install fastapi uvicorn

Zweiter Schritt: Grundlegende API erstellen

Lassen Sie uns eine einfache FastAPI-Anwendung erstellen.

Anwendungsdatei erstellen

Erstellen Sie in Ihrem Projektverzeichnis eine Python-Datei, z.B. main.py, und schreiben Sie den folgenden Code hinein:

from fastapi import FastAPI

app = FastAPI()

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

In diesem Code importieren wir zuerst FastAPI und erstellen eine app-Instanz. Dann definieren wir eine GET-Route, die beim Zugriff auf den Wurzelpfad / eine einfache JSON-Antwort zurückgibt.

Server starten

Starten Sie Ihren FastAPI-Server mit dem folgenden Befehl:

uvicorn main:app --reload

main: bezieht sich auf den Dateinamen ohne die .py-Erweiterung.
app: bezieht sich auf die FastAPI-Instanz.
--reload: Im Entwicklungsmodus wird der Server automatisch neu gestartet, wenn sich die Dateien ändern.

Dritter Schritt: Routen und Datenmodelle definieren

Um komplexe APIs zu erstellen, müssen Sie Pydantic verwenden, um Datenmodelle zu definieren.

Datenmodell erstellen

Fügen Sie in main.py den folgenden Inhalt hinzu:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

Dieser Code verwendet Pydantic, um ein Datenmodell Item zu erstellen, das drei Attribute enthält: den Namen des Artikels, den Preis und die Verfügbarkeit.

Neue Route hinzufügen

Als nächstes können wir eine neue POST-Route definieren, um Daten vom Typ Item zu empfangen:

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

In dieser Route validiert FastAPI automatisch die eingehenden Daten und mappt sie auf das Item-Modell.

Vierter Schritt: Automatische Dokumentationserstellung

Einer der größten Vorteile von FastAPI ist die automatische Generierung von API-Dokumentationen. Sie können die Dokumentation unter den folgenden Adressen einsehen:

Swagger UI: http://127.0.0.1:8000/docs
ReDoc: http://127.0.0.1:8000/redoc

In diesen generierten Dokumenten können Sie die API interaktiv testen und das Anfrage- und Antwortformat jeder Route einsehen.

Fünfter Schritt: Authentifizierung hinzufügen

In der Praxis ist die Authentifizierung ein wichtiger Aspekt. Lassen Sie uns eine einfache rollenbasierte Authentifizierung hinzufügen.

Sicherheitsabhängigkeiten hinzufügen

Verwenden Sie die Depends-Methode von FastAPI und OAuth2PasswordBearer, um die Authentifizierung zu implementieren:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def fake_decode_token(token):
    return {"sub": token}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if user is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Ungültige Authentifizierungsdaten")
    return user

Routen schützen

Dann können Sie die Authentifizierung zu den Routen hinzufügen, die geschützt werden müssen:

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

Sechster Schritt: FastAPI-Anwendung bereitstellen

Wenn Sie die Entwicklung abgeschlossen haben, müssen Sie möglicherweise die Anwendung auf einem Cloud-Server bereitstellen. Sie können Docker zur Bereitstellung verwenden.

Dockerfile erstellen

Erstellen Sie im Projektverzeichnis eine Datei mit dem Namen Dockerfile und geben Sie den folgenden Inhalt ein:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

Docker-Image erstellen

Verwenden Sie den folgenden Befehl in Ihrem Terminal, um das Docker-Image zu erstellen:

docker build -t myfastapiapp .

Docker-Container ausführen

Führen Sie Ihre FastAPI-Anwendung aus:

docker run -d --name fastapi -p 80:80 myfastapiapp

Zusammenfassung

In diesem Artikel haben wir detailliert erläutert, wie man mit FastAPI leistungsstarke API-Dienste erstellt, von der Vorbereitung der Umgebung über die Erstellung grundlegender APIs, die Definition von Routen und Datenmodellen bis hin zur Hinzufügung von Authentifizierung und Bereitstellung. FastAPI bietet viele leistungsstarke Funktionen, die den Aufbau moderner APIs einfach und effizient machen. Sie können die offizielle Dokumentation besuchen, um weitere Funktionen und Merkmale zu erkunden. Wir hoffen, dass dieser Artikel Ihnen hilft, schneller mit FastAPI zu beginnen und Ihre Projektentwicklungseffizienz zu steigern!