Sanic 'Hello World'

Bevor Sie sich mit Sanic beschäftigen, stellen Sie sicher, dass Python 3.7 oder neuer und pip (Pythons Paket-Installer) auf Ihrem System installiert sind. Sanic nutzt moderne Python-Funktionen stark für seine asynchronen Fähigkeiten.

Sie können Ihre Python-Version überprüfen, indem Sie diesen Befehl in Ihrem Terminal ausführen:

python3 --version

Sie sollten eine Ausgabe wie Python 3.x.x sehen. Wenn Sie Python installieren oder aktualisieren müssen, besuchen Sie python.org für die neueste Version.

Die Verwendung einer virtuellen Umgebung ist entscheidend für die effektive Verwaltung von Projektabhängigkeiten. Sie stellt sicher, dass die Pakete Ihres Sanic-Projekts nicht mit anderen Python-Projekten oder Ihren systemweiten Installationen kollidieren.

Erstellen Sie zuerst ein neues Verzeichnis für Ihr Sanic-Projekt und navigieren Sie dorthin:

mkdir sanic-hello-world
cd sanic-hello-world

Erstellen Sie als Nächstes eine virtuelle Umgebung innerhalb Ihres Projektverzeichnisses:

python3 -m venv .venv

Aktivieren Sie abschließend Ihre virtuelle Umgebung:

# Auf macOS/Linux
source .venv/bin/activate

# Auf Windows (mit Eingabeaufforderung)
.venv\Scripts\activate

Ihre Terminal-Eingabeaufforderung sollte nun (.venv) anzeigen, was bedeutet, dass die virtuelle Umgebung aktiv ist.

Sobald Ihre virtuelle Umgebung aktiv ist, können Sie Sanic und seine Abhängigkeiten mit pip installieren.

pip install sanic

Dieser Befehl installiert Sanic und alle seine notwendigen Komponenten, einschließlich uvloop und httptools, für maximale Leistung, sofern auf Ihrem System verfügbar.

Nun erstellen wir unsere erste Sanic "Hello World"-Anwendung. Erstellen Sie in Ihrem Projektverzeichnis (sanic-hello-world) eine neue Datei namens main.py.

Öffnen Sie main.py in Ihrem bevorzugten Code-Editor und fügen Sie den folgenden Python-Code hinzu:

from sanic import Sanic, response

# Erstellen einer Sanic-Anwendungsinstanz
app = Sanic("HelloWorldSanicApp")

# Definieren einer Route für die Stamm-URL ("/")
# Diese Route verarbeitet GET-Anfragen
@app.get("/")
async def hello_world(request):
    """
    Verarbeitet GET-Anfragen an die Stamm-URL und gibt eine "Hello, Sanic!"-Nachricht zurück.
    """
    return response.text("Hello, Sanic!")

# Einstiegspunkt zum Ausführen der Anwendung
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, dev=True)

Lassen Sie uns die Datei main.py Zeile für Zeile aufschlüsseln, um zu verstehen, wie Ihre Sanic-Anwendung funktioniert:

• from sanic import Sanic, response

  Diese Zeile importiert die notwendigen Komponenten aus der Sanic-Bibliothek: Sanic zum Erstellen der Anwendungsinstanz und response zum Generieren von HTTP-Antworten.

• app = Sanic("HelloWorldSanicApp")

  Hier erstellen wir eine Instanz der Sanic-Anwendung. Der String "HelloWorldSanicApp" ist der Name Ihrer Anwendung, der für Debugging oder Protokollierung nützlich sein kann.

• @app.get("/")

  Dies ist ein Dekorator, der Sanic anweist, die direkt darunter stehende Funktion für HTTP-GET-Anfragen mit dem Stamm-URL-Pfad ("/") zu verknüpfen. Sanic bietet auch @app.post(), @app.put(), @app.delete() usw. für andere HTTP-Methoden.

• async def hello_world(request):

  Dies definiert eine asynchrone Funktion namens hello_world. Das Schlüsselwort async ist für Sanic entscheidend und ermöglicht es ihm, Anfragen parallel zu verarbeiten, ohne zu blockieren. Die Funktion nimmt ein request-Objekt als Argument entgegen, das Details über die eingehende HTTP-Anfrage enthält.

• return response.text("Hello, Sanic!")

  Innerhalb unseres Routen-Handlers verwenden wir response.text(), um eine HTTP-Antwort mit dem Inhaltstyp text/plain und dem String "Hello, Sanic!" als Körper zu erstellen. Sanic bietet auch response.json() für JSON-Antworten, response.html() für HTML und mehr.

• if __name__ == "__main__":

  Diese Standard-Python-Konstruktion stellt sicher, dass der Code in diesem Block nur ausgeführt wird, wenn das Skript direkt ausgeführt wird (nicht, wenn es als Modul importiert wird).

• app.run(host="0.0.0.0", port=8000, dev=True)

  Diese Zeile startet den Sanic-Webserver.

  • host="0.0.0.0" macht den Server über jede Netzwerkschnittstelle erreichbar, nützlich für Docker oder externen Zugriff. Für die lokale Entwicklung können auch `127.0.0.1` oder `localhost` verwendet werden.
  • port=8000 gibt an, dass der Server auf Port 8000 lauschen wird.
  • dev=True aktiviert den Entwicklermodus, der Funktionen wie automatisches Neuladen des Servers bei Codeänderungen und detaillierte Fehlermeldungen beinhaltet.

Nachdem Ihre Datei main.py fertig ist, können Sie Ihren Sanic-Server starten. Stellen Sie sicher, dass Sie sich in Ihrem sanic-hello-world-Verzeichnis befinden und Ihre virtuelle Umgebung aktiv ist.

Führen Sie Ihre Anwendung mit dem Sanic CLI aus:

python main.py

Sie können auch das idiomatischere `sanic`-Befehlszeilentool verwenden, insbesondere für erweiterte Konfigurationen. Da wir `if __name__ == "__main__": app.run(...)` eingeschlossen haben, ist der Befehl `python main.py` für dieses einfache Beispiel ausreichend. Wenn Sie es mit `sanic main.app --dev` ausführen würden, müsste die Anwendungsinstanz `app` heißen, damit sie automatisch erkannt wird. Für diese Anleitung ist `python main.py` einfacher und funktioniert direkt.

[INFO] Goin' Fast @ http://0.0.0.0:8000
[INFO] Zum Beenden: STRG+C
                            

Wenn Ihre Sanic-Anwendung läuft, ist es Zeit zu testen, ob sie korrekt antwortet. Öffnen Sie Ihren Webbrowser und navigieren Sie zu:

http://127.0.0.1:8000/

Sie sollten den Text "Hello, Sanic!" in Ihrem Browser sehen. Alternativ können Sie ein Befehlszeilentool wie curl verwenden:

curl http://127.0.0.1:8000/

Die Ausgabe in Ihrem Terminal sollte einfach lauten:

Hello, Sanic!

Herzlichen Glückwunsch! Sie haben erfolgreich Ihre erste Sanic-Anwendung erstellt und ausgeführt.

Ihre Sanic-Anwendung wird in Ihrem Terminal weiterlaufen, bis Sie sie manuell beenden. Um den Server zu beenden, kehren Sie einfach zu dem Terminal zurück, in dem Sanic läuft, und drücken Sie:

STRG + C

Dies sendet ein Interrupt-Signal an den Serverprozess, wodurch dieser ordnungsgemäß heruntergefahren wird.

Sie haben erfolgreich Ihre erste "Hello World"-Anwendung mit Sanic abgeschlossen! Dieses grundlegende Wissen eröffnet Ihnen unzählige Möglichkeiten, hochleistungsfähige, asynchrone Webdienste mit Python zu erstellen.

Hier sind einige Ideen für Ihre nächsten Schritte mit Sanic:

• Dynamische Routen: Erfahren Sie, wie Sie Routen mit Pfadparametern erstellen (z. B. /users/<user_id>), um flexiblere APIs zu erstellen.
• JSON-Antworten: Geben Sie strukturierte Daten mit response.json({"message": "Hello from Sanic!"}) zurück.
• Anforderungsdaten: Greifen Sie auf Abfrageparameter (request.args), Formulardaten (request.form) und JSON-Bodies (request.json) zu.
• Middleware: Implementieren Sie Funktionen, die vor oder nach jeder Anfrage ausgeführt werden, um Authentifizierung, Protokollierung oder Datenänderungen zu handhaben.
• Blueprints: Organisieren Sie Ihre Anwendung in modulare Komponenten für größere Projekte.
• Datenbanken: Integrieren Sie Sanic mit asynchronen Datenbanktreibern (wie asyncpg für PostgreSQL oder aiomysql für MySQL) für Datenbankoperationen.
• WebSockets: Erkunden Sie die integrierte Unterstützung von Sanic für die Echtzeit-WebSocket-Kommunikation.
• Bereitstellung: Erfahren Sie, wie Sie Ihre Sanic-Anwendung in Produktionsumgebungen bereitstellen, indem Sie Docker, Gunicorn mit Uvicorn-Workern oder Sanics nativen Server verwenden.

Die offizielle Dokumentation von Sanic ist eine hervorragende Ressource für tiefere Einblicke in all diese Funktionen und mehr.