Python -Webanwendungen: Die Grundlagen von WSGI

Key Takeaways

• WSGI oder Webserver -Gateway -Schnittstelle untermauert alle Python -Web -Frameworks und bietet eine gemeinsame Spezifikation für Webserver, die die Interaktion zwischen verschiedenen Webservern und Anwendungsrahmen ermöglicht.
• Eine WSGI -Anwendung ist ein Python -Callable, der zwei Argumente akzeptieren muss, die Umgebung (ein Python -Diktat, das Anforderungsdaten enthält) und start_fn (ein Anruf). Die Anwendung muss start_fn mit zwei Argumenten aufrufen: den Statuscode und eine Liste von Headers, und ein iterables zurückgeben, das die Bytes im Antwortkörper enthält.
• Middleware kann verwendet werden, um die Funktionalität von WSGI -Apps zu erweitern, wobei Middleware und der Handler sich nicht kennen oder sich um einander kümmern müssen. Dies erleichtert das Hinzufügen von Funktionen wie Protokollierung oder Fehlerbehandlung.
• WSGI -Apps können auf verschiedene Weise serviert werden, wobei Gunicorn und UWSGI zwei beliebte Optionen sind. Es wird empfohlen, vor diesen so etwas wie Nginx einzurichten, um statische Vermögenswerte zu servieren.

Unter Django, Flasche, Flasche und jedem anderen Python -Web -Framework liegt die Webserver -Gateway -Schnittstelle oder kurz WSGI. WSGI ist zu Python, welche Servlets für Java sind - eine gemeinsame Spezifikation für Webserver, mit der verschiedene Webserver und Anwendungsrahmen basierend auf einer gemeinsamen API interagieren können. Wie bei den meisten Dingen ist die Python -Version jedoch erheblich einfacher.

WSGI ist in PEP 3333 definiert, was ich Ihnen empfehle, als Referenz zu lesen, wenn Sie nach diesem schnellen Intro weitere Informationen wünschen.

In diesem Artikel werden Sie aus der Perspektive eines Anwendungsentwicklers in die WSGI -Spezifikation vorgestellt und Ihnen zeigen, wie Sie direkt mit WSGI arbeiten, um Anwendungen zu erstellen (wenn Sie dies wünschen).

Ihre erste WSGI -App

Hier ist die einfachste Python -Web -App möglich:

<span>def app(environ, start_fn):
</span>    start_fn<span>('200 OK', [('Content-Type', 'text/plain')])
</span>    <span>return ["Hello World!\n"]
</span>

Das ist es! Die ganze Datei. Nennen Sie es App.py und führen Sie es mit einem wSGI-kompatiblen Server aus, und Sie erhalten eine Hello World-Antwort mit einem 200-Status. Dafür können Sie Gunicorn verwenden. Installieren Sie es einfach über PIP (PIP Installieren Sie Gunicorn) und führen Sie es mit Gunicorn App: App aus. Dieser Befehl fordert Gunicorn an, den WSGI -Callable aus der App -Variablen im App -Modul zu erhalten.

Im Moment sollten Sie ziemlich aufgeregt sein. Nur 3 Zeilen für eine laufende Anwendung? Das muss eine Art Aufzeichnung sein (abgesehen von PHP, da mod_php betrügt). Ich wette, Sie werden nur noch mehr wissen, mehr zu wissen.

Was sind die wesentlichen Teile einer WSGI -Anwendung?

• Eine WSGI -Anwendung ist eine Python Callable , z. B. eine Funktion, eine Klasse oder eine Klasseninstanz mit einer __call__ -Methode
• Die Anwendung Callable muss zwei Argumente akzeptieren: The Environ, ein Python -Diktat, das die Anforderungsdaten enthält, und start_fn selbst ein Anruf.
• Die Anwendung muss den start_fn mit zwei Argumenten aufrufen: den Statuscode (als Zeichenfolge) und eine Liste von Headern, die als 2-Tupel ausgedrückt werden.
• Die Anwendung gibt eine iterable, die die Bytes im Reaktionskörper in praktischen, streamablen Brocken enthält - in diesem Fall eine Liste von Saiten, die nur "Hallo, Welt!" Enthalten. (Wenn App eine Klasse ist, kann dies in der __iter__ -Methode erreicht werden.)

beispielsweise sind diese nächsten beiden Beispiele dem ersten entsprechen:

<span>def app(environ, start_fn):
</span>    start_fn<span>('200 OK', [('Content-Type', 'text/plain')])
</span>    <span>return ["Hello World!\n"]
</span>

<span>class app(object):
</span>
    <span>def __init__(self, environ, start_fn):
</span>        self<span>.environ = environ
</span>        self<span>.start_fn = start_fn
</span>
    <span>def __iter__(self):
</span>        self<span>.start_fn('200 OK', [('Content-Type', 'text/plain')])
</span>        <span>yield "Hello World!\n"
</span>

Sie denken vielleicht bereits über Möglichkeiten nach, wie Sie diese Informationen verwenden können, aber wahrscheinlich ist das relevanteste Middlewares.

jazz es

Middlewares sind eine einfache Möglichkeit, die Funktionalität von WSGI -Apps zu erweitern. Da Sie nur einen Anruf bereitstellen müssen, können Sie ihn in andere Funktionen einbinden, wie Sie möchten.

Angenommen, wir möchten den Inhalt der Umgebung untersuchen. Wie in diesem Beispiel können wir problemlos eine Middleware erstellen:

<span>class Application(object):
</span>    <span>def __call__(self, environ, start_fn):
</span>        start_fn<span>('200 OK', [('Content-Type', 'text/plain')])
</span>        <span>yield "Hello World!\n"
</span>
app <span>= Application()
</span>

Hier ist log_environ eine Funktion, die eine Funktion zurückgibt, die das Environ-Argument vor dem Aufschieben auf den ursprünglichen Callback ziemlich zeichnet.

Der Vorteil des Schreibens von Middlewares auf diese Weise besteht darin, dass die Middleware und der Handler nicht wissen oder sich umeinander kümmern müssen. Sie können beispielsweise log_environ leicht auf eine Flask -Anwendung bauen, da Flask -Apps WSGI -Apps sind.

Ein paar andere nützliche Middleware -Ideen:

<span>import pprint
</span>

<span>def handler(environ, start_fn):
</span>    start_fn<span>('200 OK', [('Content-Type', 'text/plain')])
</span>    <span>return ["Hello World!\n"]
</span>

<span>def log_environ(handler):
</span>    <span>def _inner(environ, start_fn):
</span>        pprint<span>.pprint(environ)
</span>        <span>return handler(environ, start_fn)
</span>    <span>return _inner
</span>

app <span>= log_environ(handler)
</span>

Sie können reduziert werden, um eine Reihe von Middleware sofort anzuwenden, wenn Sie keine große Pyramide an der Unterseite Ihrer Datei erstellen möchten:

<span>import pprint
</span>

<span>def handle_error(handler):
</span>    <span>def _inner(environ, start_fn):
</span>        <span>try:
</span>            <span>return handler(environ, start_fn)
</span>        <span>except Exception as e:
</span>            <span>print e  # Log error
</span>            start_fn<span>('500 Server Error', [('Content-Type', 'text/plain')])
</span>            <span>return ['500 Server Error']
</span>    <span>return _inner
</span>

<span>def wrap_query_params(handler):
</span>    <span>def _inner(environ, start_fn):
</span>        qs <span>= environ.get('QUERY_STRING')
</span>        environ<span>['QUERY_PARAMS'] = urlparse.parse_qs(qs)
</span>        <span>return handler(environ, start_fn)
</span>    <span>return _inner
</span>

Sie können auch Middleware schreiben, die die Antwort modifiziert, indem Sie das Argument start_fn nutzen. Hier ist eine Middleware, die die Ausgabe umkehrt, wenn der Header vom Typ des Inhalts Text/Ebene ist:

<span># Applied from bottom to top on the way in, then top to bottom on the way out
</span>MIDDLEWARES <span>= [wrap_query_params,
</span>               log_environ<span>,
</span>               handle_error<span>]
</span>
app <span>= reduce(lambda h, m: m(h), MIDDLEWARES, handler)
</span>

Es ist dank der Trennung von Start_fn und der Antwort etwas mehr verwirrt, aber immer noch perfekt praktikabel.

Beachten Sie auch, dass wir, um mit WSGI streng spezifisch zu sein, nach einer -Methode für die Antwort nachzudenken und es aufrufen, wenn sie vorhanden sind. Legacy -WSGI -Anwendungen können auch eine -Funktion anstelle eines iterablen Rufens nach dem Aufrufen von Handler zurückgeben. Wenn Sie möchten, dass Ihre Middleware ältere Anwendungen unterstützt, müssen Sie diesen Fall möglicherweise verarbeiten.

Wenn Sie ein wenig mit Raw WSGI spielen, beginnen Sie zu verstehen, warum Python buchstäblich Dutzende von Web -Frameworks hat. WSGI macht es ziemlich einfach, etwas aufzubauen, das von vorne anfängt. Zum Beispiel könnten Sie das Problem des Routings in Betracht ziehen:

<span>def reverser(handler):
</span>
    <span># A reverse function
</span>    rev <span>= lambda it: it[::-1]
</span>
    <span>def _inner(environ, start_fn):
</span>        do_reverse <span>= []  # Must be a reference type such as a list
</span>
        <span># Override start_fn to check the content type and set a flag
</span>        <span>def start_reverser(status, headers):
</span>            <span>for name, value in headers:
</span>                <span>if (name.lower() == 'content-type'
</span>                        <span>and value.lower() == 'text/plain'):
</span>                    do_reverse<span>.append(True)
</span>                    <span>break
</span>
            <span># Remember to call `start_fn`
</span>            start_fn<span>(status, headers)
</span>
        response <span>= handler(environ, start_reverser)
</span>
        <span>try:
</span>            <span>if do_reverse:
</span>                <span>return list(rev(map(rev, response)))
</span>
            <span>return response
</span>        <span>finally:
</span>            <span>if hasattr(response, 'close'):
</span>                response<span>.close()
</span>    <span>return _inner
</span>

direkt mit WSGI arbeiten kann schön sein, wenn Sie die Flexibilität der Zusammenstellung von Bibliotheken über

genießen

• Vorlagenbibliotheken: Geben Sie einfach eine vorliegende Bibliothek ein, die Sie mögen (z. B. Jinja2, PyStashe) und geben Sie die gerenderte Vorlage von Ihrem Handler zurück!
• Helfen Sie Ihrem Routing mit einer Bibliothek wie Routen oder vielleicht die Routing von Werkzug. Schauen Sie sich Werkzeug an, wenn Sie eine immer so leuchtende Abstraktion über WSGI verwenden möchten.
• Verwenden Sie alle Datenbank-/Migrationsbibliotheken wie mit Flask oder ähnlichem.

Natürlich möchten Sie für nicht spezialisierte Anwendungen wahrscheinlich immer noch ein Framework verwenden, damit die Kantenfälle ordnungsgemäß behandelt werden und so weiter.

Aber was ist mit Servern?

Es gibt eine Reihe von Möglichkeiten, WSGI -Apps zu bedienen. Wir haben bereits über Gunicorn gesprochen, was eine anständige Option ist. UWSGI ist eine weitere großartige Option. Stellen Sie einfach sicher, dass Sie so etwas wie Nginx vor diesen einrichten, um statische Assets zu servieren, und Sie sollten einen soliden Ausgangspunkt haben.

Und das ist alles, was es gibt!

häufig gestellte Fragen (FAQs) zu Python -Webanwendungen und WSGI

Welche Rolle spielt WSGI in Python -Webanwendungen? Es spielt eine entscheidende Rolle in Python -Webanwendungen, da die Anwendung und der Webserver die Anforderungen aneinander kommunizieren und aneinander senden können. WSGI fungiert als Brücke und ermöglicht es dem Webserver, Anforderungen von einem Client (wie einem Webbrowser) an eine Webanwendung weiterzuleiten. Die Anwendung verarbeitet dann die Anforderung und sendet eine Antwort über den Webserver an den Client zurück.

Wie funktioniert WSGI in einer Python -Webanwendung? Webserver zur Kommunikation mit Webanwendungen. Wenn ein Client eine Anforderung an einen Webserver sendet, verwendet der Server die WSGI -Schnittstelle, um diese Anforderung an die Webanwendung zu übergeben. Die Anwendung verarbeitet die Anforderung und gibt eine Antwort zurück, die der Server dann an den Client zurücksendet. Dieser Prozess ermöglicht eine konsistente und zuverlässige Möglichkeit für Webserver und Anwendungen, unabhängig von ihren spezifischen Implementierungen zu interagieren.

Was sind einige beliebte WSGI -Server für Python? Erhältlich für Python, jeweils seine eigenen Stärken und Schwächen. Zu den am häufigsten verwendeten gehören Gunicorn, UWSGI und Mod_WSGI. Gunicorn ist für seine Einfachheit und Benutzerfreundlichkeit bekannt, während UWSGI für seine Geschwindigkeit und Effizienz gelobt wird. Mod_wsgi hingegen ist ein Modul für Apache -Server und wird häufig in Unternehmensumgebungen verwendet.

Wie bereitete ich eine Python -Webanwendung mit WSGI bereit? Zuerst müssen Sie einen WSGI -Server wie Gunicorn oder UWSGI installieren. Anschließend müssen Sie Ihren Webserver so konfigurieren, dass der WSGI -Server als Proxy zum Umgang mit Anforderungen an Ihre Anwendung verwendet wird. Dies beinhaltet die Änderung der Konfigurationsdatei Ihres Servers so, dass die erforderlichen WSGI -Einstellungen enthalten sind. Schließlich müssen Sie Ihren WSGI -Server starten und auf die WSGI -Datei Ihrer Anwendung hinweisen.

Kann ich WSGI mit Django verwenden? Tatsächlich verfügt Django mit einer integrierten WSGI-Anwendung, mit der Sie Ihre Django-Projekte bereitstellen können. Die Django WSGI -Anwendung fungiert als Brücke zwischen Ihrem Django -Projekt und dem Webserver, sodass sie Anforderungen und Antworten kommunizieren und austauschen können.

Was ist der Unterschied zwischen WSGI und ASGI? ASGI sind beide Schnittstellen für Python -Webanwendungen, dienen jedoch unterschiedlichen Zwecken. WSGI ist eine synchrone Oberfläche, die eine Kommunikation zwischen einem Webserver und einer Webanwendung ermöglicht. Die ASGI oder eine asynchrone Server -Gateway -Schnittstelle ist eine Erweiterung von WSGI, die asynchrone Operationen unterstützt. Dies bedeutet, dass Ihre Anwendung bei ASGI gleichzeitig ohne Blockierung mehrere Anforderungen bearbeiten kann, was sie für Echtzeitanwendungen effizienter macht.

Wie erstelle ich eine WSGI-Anwendung in Python? > Erstellen einer WSGI -Anwendung in Python beinhaltet die Definition einer Funktion, die zwei Argumente akzeptiert: ein Umgebungswörterbuch und ein Start_Response Callable. Das Umweltwörterbuch enthält Informationen zur eingehenden Anfrage, während der Start_Response Callable verwendet wird, um die Antwort auf die Anforderung zu starten. Ihre Funktion sollte ein Iterable zurückgeben, das den Körper der Antwort erzeugt. Erstens bietet es eine Standardschnittstelle für Webserver und Anwendungen, sodass die Entwicklung und Bereitstellung von Python -Webanwendungen erleichtert wird. Zweitens ermöglicht es eine größere Flexibilität, da Sie aus einer Vielzahl von WSGI-kompatiblen Servern und Anwendungen auswählen können. Schließlich fördert es die Wiederverwendbarkeit von Code, da Sie dieselbe WSGI -Anwendung mit verschiedenen Servern und Middleware verwenden können. Tatsächlich sind Flask -Anwendungen standardmäßig WSGI -Anwendungen. Wenn Sie eine Flask -Anwendung erstellen, erstellen Sie tatsächlich eine WSGI -Anwendung, mit der das Flask -Framework eingehende Anfragen verarbeitet und Antworten senden kann.

Was ist eine WSGI -Middleware? Es kann Anfragen verarbeiten, bevor sie die Anwendung und Antworten erreichen, bevor sie an den Kunden zurückgesandt werden. Middleware kann verwendet werden, um eine Vielzahl von Funktionen wie Sitzungsmanagement, URL -Routing und Authentifizierung zu implementieren.

Das obige ist der detaillierte Inhalt vonPython -Webanwendungen: Die Grundlagen von WSGI. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!