Website-Suche

Wie man Python WSGI-Anwendungen mit dem uWSGI-Webserver und Nginx bereitstellt

Einführung

Wie in unserem Artikel zum Vergleich von Python-Web-Servern eingeführt, ist uWSGI ein umfangreiches Projekt, das viel mehr kann, als nur Webanwendungen bereitzustellen. Allerdings macht seine große Funktionalität, kombiniert mit der relativen Einfachheit seiner Konfiguration, es zu einer ausgezeichneten Wahl für viele Bereitstellungsbedürfnisse – besonders wenn es mit Nginx kombiniert wird.

In diesem DigitalOcean-Artikel wollen wir uWSGI eingehend besprechen und die notwendigen Schritte für nicht nur die Installation des Servers, sondern auch die Bereitstellung von Python-Anwendungen auf der Grundlage verschiedener Frameworks durchgehen, wobei wir jeden wichtigen Schritt für kleine, mittelständische und sogar relativ große Anwendungen für die Produktion abdecken.

Wir werden auch darüber sprechen, wie man Nginx (und warum) mit diesem Setup verwendet, da Nginx und uWSGI nativ dafür entwickelt wurden, miteinander zu arbeiten, und so den perfekten Stack für die meisten Einsätze bilden.

Glossar

1. uWSGI verstehen und Nginx verwenden

  1. uWSGI in Kürze
  2. Webanwendungen mit Nginx bereitstellen
  3. Nginx als Reverse-Proxy mit uWSGI verwenden

2. Vorbereitung Ihres Droplets für die Produktion

  1. Aktualisierung des Standardbetriebssystems
  2. Einrichten von Python, pip und virtualenv
  3. Erstellen einer virtuellen (Python) Umgebung
  4. Herunterladen und Installieren von uWSGI
  5. Herunterladen und Installieren von Nginx

3. Bereitstellung von Python WSGI-Anwendungen mit uWSGI

  1. WSGI
  2. WSGI-Anwendungsobjekt (aufrufbar): wsgi.py
  3. Den Server betreiben
  4. Konfiguration von uWSGI
  5. Häufige Konfigurationen für uWSGI
  6. Verwaltung des uWSGI-Servers und der Prozesse mit Signalen

4. Nginx konfigurieren

5. Konfigurieren von uWSGI

6. Verschiedene Tipps, Vorschläge und Einstellungen für den Produktionsserver

Verstehen von uWSGI und Verwendung von Nginx

uWSGI ist ein ehrgeiziges Projekt. Sein Werkzeugkasten ermöglicht es Ihnen, so viel mehr zu tun, als nur Webanwendungen zu hosten. Da es die Aufgaben so gut und in einer so leistungsstarken Weise erledigt, hat es sich im Laufe der Jahre als unverzichtbares Werkzeug für viele Systemadministratoren und Entwickler erwiesen, wenn es darum geht, ihre Anwendungen bereitzustellen.

Nginx unterstützt seit Version 0.8.40 das uwsgi-Protokoll (das eigene von uWSGI). Dies ermöglicht es den WSGI-Anwendungen, die auf uWSGI laufen, auf die bestmögliche Weise mit Nginx zu kommunizieren. Was das für Sie bedeutet, ist die Möglichkeit von sehr einfach zu konfigurierenden Deployments, die hochflexibel (und funktional) sind und von vielen Optimierungen profitieren, die im Hintergrund durchgeführt werden. Insgesamt macht dies uWSGI in Kombination mit Nginx zu einer ausgezeichneten Wahl für viele Bereitstellungsszenarien.

uWSGI in Kürze

Folgendes ist ein Auszug aus dem oben genannten Artikel über den Vergleich von DigitalOcean-Python-Servern:

„Trotz seiner sehr verwirrenden Benennungskonventionen ist uWSGI ein umfassendes Projekt mit vielen Komponenten, das darauf abzielt, einen vollständigen Software-Stack für den Aufbau von Hosting-Diensten bereitzustellen. Eine dieser Komponenten, der uWSGI-Server, führt Python WSGI-Anwendungen aus. Er ist in der Lage, verschiedene Protokolle zu verwenden, einschließlich seines eigenen uwsgi-Drahtprotokolls, das quasi identisch mit SCGI ist. Um der nachvollziehbaren Anforderung nachzukommen, eigenständige HTTP-Server vor Anwendungsservern zu verwenden, sind die NGINX- und Cherokee-Webserver modularisiert, um uWSGIs [eigenes] leistungsstärkstes uwsgi-Protokoll zu unterstützen, um direkte Kontrolle über seine Prozesse zu haben.“

uWSGI Höhepunkte

  • uWSGI wird mit einem WSGI-Adapter geliefert und unterstützt vollständig Python-Anwendungen, die auf WSGI ausgeführt werden.

  • Es verbindet sich mit libpython. Es lädt den Anwendungscode beim Start und fungiert wie ein Python-Interpreter. Es analysiert die eingehenden Anfragen und ruft die Python-Funktion auf.

  • Es kommt mit direkter Unterstützung für den beliebten NGINX-Webserver (neben Cherokee+ und lighttpd).

  • Es ist in C geschrieben.

  • Die verschiedenen Komponenten können viel mehr als nur eine Anwendung auszuführen, was für eine Erweiterung nützlich sein könnte.

  • Derzeit (Stand Ende 2013) wird es aktiv weiterentwickelt und hat schnelle Veröffentlichungsgesetze.

  • Es hat verschiedene Engines zum Ausführen von Anwendungen (asynchron und synchron).

  • Es kann eine geringere Speichernutzung zum Ausführen bedeuten.

Webanwendungen mit Nginx bereitstellen

Nginx ist ein sehr leistungsstarker Webserver/(Reverse)-Proxy. Seine Popularität hat er aufgrund seiner Leichtigkeit, der relativ einfachen Handhabung und der einfachen Erweiterbarkeit (mit Add-Ons/Plug-Ins) erreicht. Dank seiner Architektur ist er in der Lage, eine Menge Anfragen (praktisch unbegrenzt) zu verarbeiten, was - abhängig von der Last Ihrer Anwendung oder Website - mit einigen anderen, älteren Alternativen wirklich schwierig zu bewältigen sein könnte.

Denken Sie daran: “Verwaltung ” von Verbindungen bedeutet technisch gesehen, sie nicht abzubrechen und sie mit etwas bedienen zu können. Sie benötigen immer noch, dass Ihre Anwendung und Datenbank gut funktionieren, um sicherzustellen, dass Nginx den Clients Antworten liefert, die keine Fehlermeldungen sind.

Nginx als Reverse-Proxy mit uWSGI verwenden

Viele Frameworks und Anwendungsserver können statische Dateien (z. B. Javascript, CSS, Bilder usw.) zusammen mit Antworten der eigentlichen Anwendungen ausliefern. Es ist jedoch besser, einen (Reverse-Proxy-)Server wie Nginx mit der Aufgabe zu betrauen, diese Dateien bereitzustellen und die Verbindungen (Anfragen) zu verwalten. Dies entlastet die Anwendungsserver erheblich und ermöglicht Ihnen eine viel bessere Gesamtleistung.

Wenn Ihre Anwendung wächst, möchten Sie sie optimieren und wenn die Zeit gekommen ist, sie auf Server (VPS) verteilen, um mehr Verbindungen gleichzeitig zu verarbeiten und eine allgemein robustere Architektur zu haben. Ein Reverse-Proxy vor Ihren Anwendungsserver(n) hilft Ihnen dabei von Anfang an.

Die Erweiterbarkeit von Nginx (z. B. natives Caching zusammen mit Failover- und anderen Mechanismen) ist ebenfalls eine großartige Errungenschaft, die Webanwendungen zugutekommt, im Gegensatz zu (einfacheren) Anwendungsservern.

Beispiel einer grundlegenden Serverarchitektur:

Client Request ----> Nginx (Reverse-Proxy)
                        |
                       /|\                           
                      | | `-> App. Server I.   127.0.0.1:8081
                      |  `--> App. Server II.  127.0.0.1:8082
                       `----> App. Server III. 127.0.0.1:8083

Hinweis: Wenn eine Anwendung so eingestellt ist, dass sie auf eingehende Verbindungen an 127.0.0.1 hört, ist es nur möglich, sie lokal zuzugreifen. Wenn Sie jedoch 0.0.0.0 verwenden, akzeptiert sie auch Verbindungen von außen.

Vorbereitung Ihres Droplets für die Produktion

In diesem Abschnitt werden wir unseren virtuellen Server für die Produktion vorbereiten (d.h. für die Bereitstellung unserer Anwendung).

Wir werden beginnen mit:

  • Aktualisierung des standardmäßigen Betriebssystems

  • Herunterladen und Installieren gängiger Python-Tools (d.h. pip, virtualenv)

  • eine virtuelle Umgebung zu erstellen, um die Anwendung zu enthalten (innerhalb derer ihre Abhängigkeiten wie uWSGI reside)

Hinweis: Die hier gegebenen Anweisungen sind kurz gehalten. Um mehr zu erfahren, lesen Sie unseren Artikel zum Thema pip und virtualenv: Häufige Python-Tools: Verwendung von virtualenv, Installation mit Pip und Verwaltung von Paketen.

Aktualisierung des Standardbetriebssystems

Hinweis: Wir werden die folgenden Einstellungen und Vorbereitungen auf einem neuen VPS durchführen, wobei wir aktuelle Versionen von Betriebssystemen verwenden. Theoretisch sollten Sie keine Probleme haben, sie auf Ihrem Server auszuprobieren. Wenn Sie es jedoch bereits aktiv nutzen, empfehlen wir dringend, vor dem Testen auf ein neues System umzusteigen.

Um sicherzustellen, dass wir die neuesten verfügbaren Versionen der Standardanwendungen haben, müssen wir unser System aktualisieren.

Für Debian-basierte Systeme (d.h. Ubuntu, Debian) führen Sie Folgendes aus:

aptitude    update
aptitude -y upgrade

Für RHEL-basierte Systeme (d.h. CentOS) führen Sie Folgendes aus:

yum -y update

Einrichten von Python, pip und virtualenv

Hinweis für CentOS/RHEL-Benutzer:

CentOS/RHEL kommt standardmäßig als ein sehr schlanker Server. Sein Werkzeugset, das wahrscheinlich für Ihre Bedürfnisse veraltet ist, ist nicht da, um Ihre Anwendungen auszuführen, sondern um die Systemwerkzeuge des Servers (z. B. YUM) zu betreiben.

Um Ihr CentOS-System vorzubereiten, muss Python eingerichtet werden (d.h. aus dem Quellcode kompiliert) und pip/virtualenv müssen mit diesem Interpreter installiert werden.

Um mehr über Wie man Python 2.7.6 und 3.3.3 auf CentOS 6.4 und 5.8 einrichtet, einschließlich pip und virtualenv, zu erfahren, beziehen Sie sich bitte auf: Wie man Python 2.7.6 und 3.3.3 auf CentOS einrichtet.

Unter Ubuntu und Debian kommt eine aktuelle Version des Python-Interpreters standardmäßig. Das lässt uns nur eine begrenzte Anzahl zusätzlicher Pakete, die wir installieren müssen:

  • python-dev (Entwicklungstools)

  • pip (um Pakete zu verwalten)

  • virtualenv (um isolierte, virtuelle Umgebungen zu erstellen)

python-dev:

python-dev ist ein betriebssystemweites Paket, das erweiterte Entwicklertools zum Erstellen von Python-Modulen enthält.

Führen Sie den folgenden Befehl aus, um python-dev mit aptitude zu installieren:

aptitude install python-dev

pip:

pip ist ein Paketmanager, der uns hilft, die benötigten Anwendungsprogramme zu installieren.

Führen Sie die folgenden Befehle aus, um pip zu installieren:

curl https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py | python -
curl https://raw.github.com/pypa/pip/master/contrib/get-pip.py | python -
export PATH="/usr/local/bin:$PATH"

Möglicherweise benötigen Sie sudo-Rechte.

virtuelle Umgebung:

Es ist am besten, eine Python-Anwendung in ihrer eigenen Umgebung zusammen mit all ihren Abhängigkeiten zu halten. Eine Umgebung kann am besten (in einfachen Worten) als ein isolierter Ort (ein Verzeichnis) beschrieben werden, in dem alles verweilt. Zu diesem Zweck wird ein Tool namens virtualenv verwendet.

Führen Sie Folgendes aus, um virtualenv mit pip zu installieren:

sudo pip install virtualenv

Erstellen einer eigenständigen virtuellen (Python) Umgebung

Mit allen notwendigen Werkzeugen, die uns zur Verfügung stehen, können wir eine Umgebung schaffen, um unsere Anwendung bereitzustellen.

Denken Sie daran: Wenn Sie auf Ihrem Entwicklungsrechner (lokal) für Ihr Projekt keine virtuelle Umgebung haben, sollten Sie in Betracht ziehen, eine zu erstellen und Ihre Anwendung (und deren Abhängigkeiten) dorthin zu verschieben.

Beginnen wir mit der Erstellung eines Ordners, der sowohl die virtuelle Umgebung als auch dein Anwendungsmodul enthalten wird:

Sie können hier jeden Namen verwenden, der Ihren Bedürfnissen entspricht.

mkdir my_app

Wir können fortfahren, indem wir diesen Ordner betreten und eine neue virtuelle Umgebung darin erstellen:

Sie können auch einen beliebigen Namen für Ihre virtuelle Umgebung wählen.

cd my_app
virtualenv my_app_venv

Lass uns dort einen neuen Ordner erstellen, um dein Python-Anwendungsmodul ebenfalls zu enthalten:

Dies ist der Ordner, in dem Ihr Anwendungsmodul gespeichert wird.

mkdir app

Und aktivieren Sie den Interpreter innerhalb der virtuellen Umgebung, um ihn zu verwenden:

Bitte stellen Sie sicher, dass Sie den Namen verwenden, den Sie für Ihre virtuelle Umgebung gewählt haben, falls Sie sich für etwas anderes als „my_app_venv“ entschieden haben.

source my_app_venv/bin/activate

Am Ende sollte Ihr Hauptanwendungsbereitstellungsverzeichnis folgendermaßen aussehen:

my_app              # Main Folder to Contain Everything Together
  |
  |=== my_app_venv  # V. Env. folder with the Python Int.
  |=== app          # Your application module
  |..
  |.

Herunterladen und Installieren von uWSGI

Es ist immer der empfohlene Weg, alle anwendungsbezogenen Elemente so weit wie möglich zusammen innerhalb der virtuellen Umgebung zu halten. Daher werden wir uWSGI entsprechend herunterladen und installieren.

Wenn Sie nicht in einer Umgebung arbeiten, wird uWSGI global installiert (d.h. systemweit verfügbar). Das wird nicht empfohlen. Entscheiden Sie sich immer für die Verwendung von virtualenv.

Um uWSGI mit pip zu installieren, führen Sie Folgendes aus:

pip install uwsgi

Denken Sie daran: Um mehr über pip zu erfahren, seine Verwendung und Funktionalität, lesen Sie den folgenden Artikel über gängige Python-Tools: Verwendung von virtualenv, Installation mit Pip und Verwaltung von Paketen.

Herunterladen und Installieren von Nginx

Hinweis für CentOS/RHEL-Benutzer:

Die folgenden Anweisungen funktionieren nicht auf CentOS-Systemen. Bitte siehe die Anweisungen hier für CentOS.

Führen Sie den folgenden Befehl aus, um den standardmäßigen Systempaketmanager aptitude zu verwenden, um Nginx zu installieren:

sudo aptitude install nginx

Um Nginx auszuführen, können Sie Folgendes verwenden:

sudo service nginx start

Um Nginx zu stoppen, können Sie Folgendes verwenden:

sudo service nginx stop

Um Nginx neu zu starten, können Sie Folgendes verwenden:

Nach jeder Konfiguration von Nginx ist ein Neustart oder ein Reload erforderlich, damit die neuen Einstellungen wirksam werden.

sudo service nginx restart

Hinweis: Um mehr über Nginx auf Ubuntu zu erfahren, lesen Sie bitte unseren Artikel: So installieren Sie Nginx auf Ubuntu 12.04.

Bereitstellung von Python WSGI-Anwendungen mit uWSGI

In diesem Abschnitt werden wir sehen, wie eine Python WSGI-Anwendung mit dem uWSGI-Webserver funktioniert. Die Arbeit mit uWSGI, um Python WSGI-Anwendungen bereitzustellen, ist nicht unähnlich zu anderen Anwendungscontainern. Was uWSGI benötigt, ist, wie bei anderen Servern, dass Ihre Anwendung ihm einen Einstiegspunkt (ein aufrufbares Objekt) bereitstellt. Während des Starts werden dieses aufrufbare Objekt zusammen mit Konfigurationsvariablen an uWSGI übergeben, und es beginnt, seine Aufgaben zu erledigen. Wenn eine Anfrage eingeht, verarbeitet es diese und übergibt sie an den Controller Ihrer Anwendung zur Bearbeitung.

Architektur:

........
      /|\                           
     | | `-> App. Server I.   127.0.0.1:8080  <--> Application
     |  `--> App. Server II.  127.0.0.1:8081  <--> Application
      .....

WSGI

WSGI ist kurz gesagt eine Schnittstelle zwischen einem Webserver und der Anwendung selbst. Sie existiert, um einen standardisierten Weg zwischen verschiedenen Servern und Anwendungen (Frameworks) zu gewährleisten, um miteinander zu arbeiten, was eine Austauschbarkeit ermöglicht, wenn notwendig (z. B. der Wechsel von der Entwicklungs- zur Produktionsumgebung), was heutzutage eine Notwendigkeit ist.

Hinweis: Wenn Sie mehr über WSGI und Python-Webserver erfahren möchten, lesen Sie unseren Artikel: Ein Vergleich von Webservern für auf Python basierende Webanwendungen.

WSGI-Anwendungsobjekt (aufrufbar): „wsgi.py“

Wie oben erwähnt, benötigen Webserver, die auf WSGI basieren, ein Anwendungsobjekt (d.h. das Ihrer Anwendung).

Bei den meisten Frameworks und Anwendungen besteht dies aus einer wsgi.py, die ein Anwendungsobjekt (oder callable) enthält und bereitstellt, das vom Server verwendet wird.

Wir werden damit beginnen, eine beispielhafte wsgi.py zu erstellen, die dann von uWSGI importiert und verwendet wird, um die Anwendung auszuführen.

Sie können jeden Namen anstelle von wsgi.py wählen. Dies sind jedoch die Namen, die üblicherweise verwendet werden (z. B. von Django).

Lassen Sie uns mit der Erstellung einer wsgi.py-Datei beginnen, um eine grundlegende WSGI-Anwendung zu enthalten.

Führen Sie den folgenden Befehl aus, um eine wsgi.py mit dem Texteditor nano zu erstellen:

nano wsgi.py

Und lassen Sie uns fortfahren, den grundlegenden WSGI-Anwendungscode (kopieren/einfügen) hinein zu bewegen (der durch den Callable Ihrer eigenen Anwendung für die Produktion ersetzt werden sollte):

def application(env, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return ["Hello!"]

Dies ist die Datei, die vom Server eingebunden wird, und jedes Mal, wenn eine Anfrage kommt, verwendet der Server diesen anwendbaren Aufruf, um die Anforderungsbehandler der Anwendung (d.h. Controller) nach dem Parsen der URL auszuführen (z.B. mysite.tld/controller/method/variable).

Nachdem Sie den Anwendungscode eingefügt haben, drücken Sie CTRL+X und bestätigen Sie dann mit Y, um diese Datei im Ordner "my_app" neben der virtuellen Umgebung und dem App-Modul, das Ihre eigentliche Anwendung enthält, zu speichern.

Hinweis: Diese WSGI-Anwendung ist das grundlegendste Beispiel ihrer Art. Sie müssen diesen Codeblock ersetzen, um Ihr eigenes Anwendungsobjekt aus dem Anwendungsmodul einzufügen.

Sobald wir fertig sind, sollte Ihr Hauptanwendungsbereitstellungsverzeichnis folgendermaßen aussehen:

my_app              # Main Folder to Contain Everything Together
  |
  |=== my_app_venv  # V. Env. folder with the Python Int.
  |=== app          # Your application module
  |
  |--- wsgi.py      # File containing application callable
  |..
  |.

Den Server betreiben

uWSGI hat viele Optionen und Konfigurationen mit vielen möglichen Verwendungsarten dank seiner Flexibilität. Ohne die Dinge von Anfang an zu komplizieren, werden wir damit beginnen, es so einfach wie möglich zu bedienen und dann mit fortgeschritteneren Methoden fortzufahren.

Einfaches Anwendungsbeispiel:

uwsgi [option] [option 2] .. -w [wsgi file with app. callable]

Um uWSGI einfach zu starten und die Anwendung von wsgi.py aus bereitzustellen, führen Sie Folgendes aus:

uwsgi --socket 127.0.0.1:8080 --protocol=http -w wsgi

Dies wird den Server im Vordergrund ausführen. Wenn Sie ihn stoppen möchten, drücken Sie CTRL+C.

Um den Server im Hintergrund auszuführen, führen Sie Folgendes aus:

uwsgi --socket 127.0.0.1:8080 --protocol=http -w wsgi &

[!] Wichtig: Wenn Sie den Server mit Nginx unter Verwendung der Konfiguration aus dem Abschnitt Konfigurieren von Nginx ausführen, stellen Sie sicher, dass Sie --protocol=http aus der Argumentenliste entfernen, da sonst Nginx und uWSGI nicht miteinander kommunizieren können.

Wenn Sie eine Anwendung im Hintergrund ausführen, müssen Sie einen Prozessmanager (z. B. htop) verwenden, um sie zu beenden (oder zu stoppen). Siehe den Abschnitt unten für weitere Details.

Verwaltung des uWSGI-Servers und der Prozesse mit Signalen

Das Verwalten von uWSGI besteht aus Aktionen, die zur Laufzeit durchgeführt werden. Es gibt verschiedene Befehle, die für diese Aufgabe festgelegt sind, um den Prozess zu manipulieren:

  • SIGHUP -HUP lädt die Arbeiter und die Anwendung anstandslos neu.

  • SIGTERM -TERM “brutal ” neu lädt

  • SIGINT -INT und SIGQUIT -QUIT beendet alle Arbeiter sofort.

  • SIGUSR1 -USR1 druckt Statistiken (stdout)

  • SIGUSR2 -USR2 druckt den Status des Arbeiters

  • SIGURG -URG stellt einen Snapshot wieder her

  • SIGTSTP -TSTP pausiert, unterbricht oder setzt eine Instanz fort.

  • SIGWINCH -WINCH weckt einen Arbeiter auf, der in einem Systemaufruf blockiert ist.

Beispielmanagement mit Signalen:

Den Server mit SIGHUP neu starten

Dieser Befehl startet den Server elegant neu. Das bedeutet, dass er darauf wartet, dass die aktuelle Aufgabe der Arbeiter abgeschlossen ist, bevor er sie beendet und dann erneut startet, wobei er deren Einstellungen übernimmt.

Verwendung: kill -HUP [PID]

Wenn Sie die PID nicht angeben möchten, können Sie die pidfile-Option verwenden, damit uWSGI sie in eine Datei schreibt, die Sie dann zur Verwaltung der Prozesse verwenden können.

Den Server mit SIGINT stoppen

Um den Server und seine Prozesse zu stoppen, müssen Sie das -INT Signal verwenden. Dies wird alles im Hintergrund beenden.

Beispiel: kill -INT [PID]

Nginx konfigurieren

Nachdem wir uWSGI eingerichtet haben, um unsere Anwendung auszuführen, müssen wir jetzt dasselbe mit Nginx tun, damit es mit dem uWSGI-Server kommunizieren kann. Dazu müssen wir die Konfigurationsdatei von Nginx modifizieren: nginx.conf

Führen Sie den folgenden Befehl aus, um nginx.conf zu öffnen und mit dem Texteditor nano zu bearbeiten:

sudo nano /etc/nginx/nginx.conf

Danach können Sie die Datei mit der folgenden Beispielkonfiguration ersetzen, um Nginx als Reverse-Proxy zu konfigurieren, der mit Ihrer Anwendung kommuniziert.

Hinweis: Um mehr über die Einbindung von SSL-Unterstützung zu erfahren, lesen Sie bitte zuerst diesen Artikel: Ein SSL-Zertifikat auf Nginx erstellen.

Beispielkonfiguration für Webanwendungen:

worker_processes 1;

events {

    worker_connections 1024;

}

http {

    sendfile on;
    
    gzip              on;
    gzip_http_version 1.0;
    gzip_proxied      any;
    gzip_min_length   500;
    gzip_disable      "MSIE [1-6]\.";
    gzip_types        text/plain text/xml text/css
                      text/comma-separated-values
                      text/javascript
                      application/x-javascript
                      application/atom+xml;

    # Configuration containing list of application servers
    upstream uwsgicluster {
    
        server 127.0.0.1:8080;
        # server 127.0.0.1:8081;
        # ..
        # .
    
    }

    # Configuration for Nginx
    server {
    
        # Running port
        listen 80;

        # Settings to by-pass for static files 
        location ^~ /static/  {
        
            # Example:
            # root /full/path/to/application/static/file/dir;
            root /app/static/;
        
        }
        
        # Serve a static file (ex. favico) outside static dir.
        location = /favico.ico  {
        
            root /app/favico.ico;
        
        }

        # Proxying connections to application servers
        location / {
        
            include            uwsgi_params;
            uwsgi_pass         uwsgicluster;

            proxy_redirect     off;
            proxy_set_header   Host $host;
            proxy_set_header   X-Real-IP $remote_addr;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header   X-Forwarded-Host $server_name;
        
        }
    }
}

Nachdem Sie die Konfiguration geändert haben, drücken Sie CTRL+X und bestätigen Sie mit Y, um zu speichern und zu beenden. Sie müssen Nginx neu starten, damit die Änderungen wirksam werden.

Führen Sie Folgendes aus, um Nginx neu zu starten:

sudo service nginx stop
sudo service nginx start

Hinweis: Um mehr über Nginx zu erfahren, lesen Sie bitte unseren Artikel: So konfigurieren Sie den Nginx-Webserver auf einem VPS.

Konfiguration von uWSGI

Beim Starten von uWSGI zur Bereitstellung von Anwendungen gibt es mehrere Möglichkeiten, es mit den notwendigen Konfigurationen zu versorgen, wie z.B. dem Socket, auf dem es laufen soll, der Anzahl der Prozesse, den Einstellungen für den Master-Prozess usw. In diesem Abschnitt werden wir über drei davon sprechen:

  • Konfigurationen als Argumente übergeben

  • Verwendung von .ini-Dateien für Konfigurationen

  • Verwendung von .json-Dateien für Konfigurationen

Hinweis: uWSGI unterstützt verschiedene Protokolle und Möglichkeiten, diese Konfigurationsdateien abzurufen, wie stdin und HTTP.

Option #1: Konfigurationen als Argumente übergeben:

Obwohl es manchmal verwirrend und schwer zu verwalten ist, ist der grundlegendste Weg, uWSGI auszuführen, einfach wie bei jedem anderen Shell-Skript - indem man ihm die notwendigen Konfigurationen als Argumente übergibt.

Verwendungsbeispiel:

uwsgi [option] [option 2] .. -w [wsgi.py with application callable]

Simple server running *wsgi*
uwsgi --socket 127.0.0.1:8080 -w wsgi

Running Pyramid (Paster) applications
uwsgi --ini-paste production.ini

Running web2py applications
uwsgi --pythonpath /path/to/app --module wsgihandler

Running WSGI application with specific module / callable names
uwsgi --module wsgi_module_name --callable application_callable_name
uwsgi -w wsgi_module_name:application_callable_name

Für weitere Beispiele zur Ausführung von uWSGI empfehle ich, die Dokumentation für Beispielkonfigurationen zu besuchen.

Option #2: Verwendung von .ini-Dateien für Konfigurationen

Eine andere (und wahrscheinlich bessere) Möglichkeit, uWSGI mit Konfigurationen zu versehen, sind .ini-Dateien. Diese Dateien haben eine einfache Struktur (siehe Beispiel unten) und müssen jedes Mal explizit übergeben werden, wenn das Startskript von uWSGI ausgeführt wird.

Beispiel .ini Struktur (beispiel_config.ini):

[uwsgi]
-------------
Settings:
key = value
Comments >> #
-------------

socket = [addr:port]
socket = 127.0.0.1:8080

Base application directory
chdir = /full/path
chdir  = /my_app

WSGI module and callable
module = [wsgi_module_name]:[application_callable_name]
module = app:application

master = [master process (true of false)]
master = true

processes = [number of processes]
processes = 5

..

Verwendungsbeispiel:

uwsgi --ini example_config.ini

Option #3: Verwendung von .json-Dateien für Konfigurationen

Die Arbeit mit .json-Dateien ist, abgesehen von der Struktur, dasselbe wie die oben gezeigten Beispiele.

Beispiel .json Struktur (beispiel_config.json):

{
    "uwsgi": {
        "socket": ["127.0.0.1:8080"],
        "module": "my_app:app",
        "master": true,
        "processes": 5,
    }
}

Verwendungsbeispiel:

uwsgi --json example_config.json

Um mehr über die Konfiguration von uWSGI zu erfahren, sollten Sie die Dokumentation zur Konfiguration lesen.

Häufige Konfigurationen für uWSGI

Standardmäßig ist dieser Server so konzipiert, dass er unabhängig von Rahmenbedingungen/Anwendungen/Plattformen funktioniert. Obwohl er wahrscheinlich alles unterstützt, was Sie benötigen, müssen bestimmte Optionen ausdrücklich festgelegt werden, um Ihren Anforderungen zu entsprechen.

Wie in der eigenen Dokumentation angegeben, ist die Anzahl der möglichen Konfigurationsmöglichkeiten für uWSGI nahezu unbegrenzt. In diesem Abschnitt werden wir versuchen, die am häufigsten verwendeten oder kritischen Optionen zu behandeln und die Implementierung zu erklären, die in Kombination mit dem vorherigen Abschnitt es Ihnen ermöglichen wird, uWSGI genau so auszuführen, wie Sie es benötigen.

Für Optimierungen verweisen Sie bitte auf den nächsten Abschnitt nach diesem.

Die in den folgenden Beispielen verwendete Syntax ist auf .ini-Dateien ausgerichtet. Sie können diese nach Ihren spezifischen Bedürfnissen anpassen (z. B. für .json-basierte Konfigurationen, wie im vorherigen Abschnitt erklärt).

Steckdosen

HTTP-Socket

Setzt uWSGI so, dass es an einen bestimmten HTTP-Socket gebunden ist.

Beispiel: http-socket=:8080

Stecker

Setzt uWSGI so, dass es an den angegebenen Socket mit dem Standardprotokoll gebunden ist.

Beispiel: socket=127.0.0.1:8080

Prozesse (Arbeiter)

Beide Begriffe können verwendet werden, um dasselbe zu bezeichnen: die Anzahl der Prozesse, die gestartet werden, um Anfragen anzunehmen.

Beispiel: prozesse=5

Protokoll

Standardmäßig läuft uWSGI mit seinem eigenen uwsgi-Protokoll. Diese Eigenschaft ermöglicht es Ihnen, es zu ändern.

Beispiel: protokoll=http

Management

Meister

Diese Option wird verwendet, um einen Master-uWSGI-Prozess zu aktivieren oder zu deaktivieren. Diese Prozesse werden zur Verwaltung von Workern eingesetzt, die die eingehenden Anfragen annehmen und bearbeiten. Die Vorteile sind zahlreich, einschließlich des sanften Neustarts von Workern, ohne die Sockets zu berühren, was Upgrades ohne Ausfallzeiten ermöglicht.

Beispiel: master=true

max-anfragen

Wenn Sie sich Sorgen über Speicherlecks machen und keine solidere Möglichkeit finden können, damit umzugehen, wird Ihnen diese Option erlauben, Ihre Prozesse automatisch neu zu starten, nachdem die festgelegte Anzahl an Anfragen bearbeitet wurde.

Beispiel: max-Anfragen=1001

Fäden

Einstellungen zum Ausführen jedes Prozesses mit der angegebenen Anzahl von Threads im Rethread-Modus. Es ist möglich, diese Option mit Prozessen zu kombinieren, um eine unterschiedliche Konkurrierbarkeit zu erreichen.

Beispiel: threads=2

Protokollierung

Protokollierung deaktivieren

Verwendet zum Deaktivieren der Protokollierungsfunktion.

Beispiel: disable-logging=true

uWSGI-Prozesse

Prozessname

Erlaubt es Ihnen, den Prozessnamen nach Ihren Wünschen festzulegen.

Beispiel: procname=Meine Anwendung

uid

Setzen Sie den Benutzer uid des uWSGI-Servers auf den angegebenen.

Beispiel: uid=1001

gid

Setzen Sie den uWSGI-Server gid auf den angegebenen Wert.

Beispiel: gid=555

Staubsauger

Entfernt alle generierten pid-Dateien/Sockets beim Beenden.

Daemonisieren

Diese Einstellung daemonisiert uWSGI und schreibt Nachrichten in die angegebenen Argumente (Protokolldatei).

Beispiel: daemonize=/tmp/uwsgi_daemonize.log

piddatei

Setzen Sie uWSGI so, dass die Prozess-PID in eine durch die Option angegebene Datei geschrieben wird. Diese Option ist sehr hilfreich für die Verwaltung von laufenden uWSGI-Prozessen (siehe den Abschnitt Verwaltung von uWSGI für weitere Informationen).

Beispiel: pidfile=/tmp/proj_pid.pid

Verschiedene

Harakiri

Diese Einstellung wird verwendet, um die maximale Zeit festzulegen, die ein Prozess benötigt, um seine Aufgabe zu erledigen bevor er beendet und für Speicher-/Managementzwecke recycelt wird.

Beispiel: harakiri=30

Um alles über Hunderte von verfügbaren Konfigurationen zu erfahren, sollten Sie die vollständige Liste in der offiziellen Dokumentation zu den Konfigurationsoptionen einsehen.

Verschiedene Tipps und Vorschläge

Firewall:

  • Einrichten einer Firewall mit IP Tables

SSH sichern:

  • Wie man SSH mit fail2ban auf Ubuntu schützt
  • Wie man SSH mit fail2ban auf CentOS 6 schützt

Alarme erstellen:

  • Wie man E-Mail-Alerts auf einem CentOS VPS für die Systemüberwachung sendet

Überwachen und tägliches Beobachten der Serverzugriffsprotokolle:

  • Wie man Logwatch Log-Analyzer und Reporter installiert und verwendet

Eingereicht von: O.S. Tezer