So bedienen Sie Django-Anwendungen mit uWSGI und Nginx unter Ubuntu 14.04

Einführung

Django ist ein leistungsstarkes Webframework, mit dem Sie Ihre Python-Anwendung oder -Website auf den Markt bringen können. Django enthält einen vereinfachten Entwicklungsserver zum Testen Ihres Codes vor Ort, aber für alles, was auch nur geringfügig mit der Produktion zu tun hat, ist ein sicherer und leistungsfähigerer Webserver erforderlich.

In diesem Handbuch wird gezeigt, wie einige Komponenten auf Ubuntu 14.04 installiert und konfiguriert werden, um Django-Anwendungen zu unterstützen und zu bedienen. Wir werden den uWSGI-Anwendungscontainerserver für die Schnittstelle mit unseren Anwendungen konfigurieren. Wir werden dann Nginx so einrichten, dass es den Proxy für uWSGI umkehrt und uns Zugriff auf seine Sicherheits- und Leistungsfunktionen gewährt, um unsere Apps bereitzustellen.

Voraussetzungen und Ziele

Um dieses Handbuch zu vervollständigen, sollten Sie eine neue Ubuntu 14.04-Serverinstanz mit einem Nicht-Root-Benutzer haben, der über die Berechtigung "+ sudo +" verfügt. Weitere Informationen zum Einrichten finden Sie in unserem initial server setup guide.

Wir werden Django in zwei verschiedenen virtuellen Umgebungen installieren. Auf diese Weise können Ihre Projekte und deren Anforderungen separat behandelt werden. Wir werden zwei Beispielprojekte erstellen, damit wir die Schritte in einer Umgebung mit mehreren Projekten ausführen können.

Sobald wir unsere Anwendungen haben, werden wir den uWSGI-Anwendungsserver installieren und konfigurieren. Dies wird als Schnittstelle zu unseren Anwendungen dienen, die Client-Anforderungen über HTTP in Python-Aufrufe übersetzen, die unsere Anwendung verarbeiten kann. Wir werden dann Nginx vor uWSGI einrichten, um die Vorteile seiner hochleistungsfähigen Verbindungsbehandlungsmechanismen und seiner einfach zu implementierenden Sicherheitsfunktionen zu nutzen.

Lass uns anfangen.

Installieren und konfigurieren Sie VirtualEnv und VirtualEnvWrapper

Wir werden unsere Django-Projekte in ihrer eigenen virtuellen Umgebung installieren, um die jeweiligen Anforderungen zu isolieren. Dazu installieren wir "+ virtualenv ", mit dem virtuelle Python-Umgebungen erstellt werden können, und " virtualenvwrapper ", mit dem der " virtualenv +" - Workflow um einige Verbesserungen der Benutzerfreundlichkeit erweitert wird.

Wir werden diese beiden Komponenten mit + pip +, dem Python-Paketmanager, installieren. Dies kann von den Ubuntu-Repositories bezogen werden:

sudo apt-get update
sudo apt-get install python-pip

In diesem Handbuch verwenden wir Python Version 2. Wenn Ihr Code Python 3 verwendet, können Sie das Paket + python3-pip + installieren. Sie müssen dann die in diesem Handbuch beschriebenen "+ pip " - Befehle durch den Befehl " pip3 +" ersetzen, wenn Sie außerhalb einer virtuellen Umgebung arbeiten.

Nachdem Sie "+ pip " installiert haben, können Sie " virtualenv " und " virtualenvwrapper +" global installieren, indem Sie Folgendes eingeben:

sudo pip install virtualenv virtualenvwrapper

Wenn diese Komponenten installiert sind, können wir unsere Shell jetzt mit den Informationen konfigurieren, die für die Arbeit mit dem Skript "+ virtualenvwrapper " erforderlich sind. Unsere virtuellen Umgebungen werden alle in einem Verzeichnis in unserem Home-Ordner mit dem Namen " Env " abgelegt, um einen einfachen Zugriff zu ermöglichen. Dies wird durch eine Umgebungsvariable namens " WORKON_HOME +" konfiguriert. Wir können dies zu unserem Shell-Initialisierungsskript hinzufügen und das Wrapper-Skript für die virtuelle Umgebung als Quelle verwenden.

Wenn Sie Python 3 und den Befehl "+ pip3 +" verwenden, müssen Sie Ihrem Shell-Initialisierungsskript auch eine zusätzliche Zeile hinzufügen:

echo "export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3" >> ~/.bashrc

Unabhängig davon, welche Version von Python Sie verwenden, müssen Sie die folgenden Befehle ausführen:

echo "export WORKON_HOME=~/Env" >> ~/.bashrc
echo "source /usr/local/bin/virtualenvwrapper.sh" >> ~/.bashrc

Versorgen Sie nun Ihr Shell-Initialisierungsskript mit einer Quelle, damit Sie diese Funktionalität in Ihrer aktuellen Sitzung verwenden können:

source ~/.bashrc

Sie sollten jetzt ein Verzeichnis mit dem Namen "+ Env +" in Ihrem Home-Ordner haben, das Informationen zur virtuellen Umgebung enthält.

Erstellen Sie Django-Projekte

Nachdem wir unsere Tools für die virtuelle Umgebung haben, werden wir zwei virtuelle Umgebungen erstellen, jeweils Django installieren und zwei Projekte starten.

Erstellen Sie das erste Projekt

Wir können auf einfache Weise eine virtuelle Umgebung erstellen, indem wir einige Befehle verwenden, die uns das Skript "+ virtualenvwrapper +" zur Verfügung stellt.

Erstellen Sie Ihre erste virtuelle Umgebung mit dem Namen Ihrer ersten Site oder Ihres ersten Projekts, indem Sie Folgendes eingeben:

mkvirtualenv

Dadurch wird eine virtuelle Umgebung erstellt, Python und "+ pip " darin installiert und die Umgebung aktiviert. Ihre Eingabeaufforderung ändert sich und zeigt an, dass Sie jetzt in Ihrer neuen virtuellen Umgebung arbeiten. Es sieht ungefähr so aus: ` () @: ~ $ `. Der Wert in Klammern ist der Name Ihrer virtuellen Umgebung. Jegliche über " pip +" installierte Software wird nun in der virtuellen Umgebung anstatt auf dem globalen System installiert. Dies ermöglicht es uns, unsere Pakete auf Projektbasis zu isolieren.

Unser erster Schritt wird sein, Django selbst zu installieren. Wir können dazu "+ pip" ohne "+ sudo" verwenden, da wir dies lokal in unserer virtuellen Umgebung installieren:

pip install django

Mit Django können wir unser erstes Beispielprojekt erstellen, indem wir Folgendes eingeben:

cd ~
django-admin.py startproject

Dadurch wird ein Verzeichnis mit dem Namen "++" in Ihrem Ausgangsverzeichnis erstellt. Darin befindet sich ein Verwaltungsskript, mit dem verschiedene Aspekte des Projekts behandelt werden, und ein anderes Verzeichnis mit demselben Namen, in dem der eigentliche Projektcode gespeichert ist.

Wechseln Sie in das Verzeichnis der ersten Ebene, damit Sie mit dem Einrichten der Mindestanforderungen für unser Beispielprojekt beginnen können.

cd ~/

Beginnen Sie mit der Migration der Datenbank, um die von unserem Projekt verwendete SQLite-Datenbank zu initialisieren. Sie können auf Wunsch eine alternative Datenbank für Ihre Anwendung einrichten. Dies liegt jedoch außerhalb des Geltungsbereichs dieses Handbuchs:

./manage.py migrate

Sie sollten jetzt eine Datenbankdatei mit dem Namen "+ db.sqlite3 +" in Ihrem Projektverzeichnis haben. Jetzt können wir einen Administrator erstellen, indem wir Folgendes eingeben:

./manage.py createsuperuser

Sie müssen einen Benutzernamen auswählen, eine Kontakt-E-Mail-Adresse angeben und anschließend ein Passwort auswählen und bestätigen.

Öffnen Sie als Nächstes die Einstellungsdatei für das Projekt mit Ihrem Texteditor:

nano /settings.py

Da wir Nginx für die Bereitstellung unserer Site einrichten, müssen wir ein Verzeichnis konfigurieren, in dem die statischen Ressourcen unserer Site gespeichert werden. Auf diese Weise kann Nginx diese direkt bedienen, was sich positiv auf die Leistung auswirkt. Wir werden Django anweisen, diese in ein Verzeichnis mit dem Namen "+ static +" im Basisverzeichnis unseres Projekts zu legen. Fügen Sie diese Zeile am Ende der Datei hinzu, um dieses Verhalten zu konfigurieren:

STATIC_ROOT = os.path.join(BASE_DIR, "static/")

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Sammeln Sie nun die statischen Elemente unserer Website und platzieren Sie sie in diesem Verzeichnis, indem Sie Folgendes eingeben:

./manage.py collectstatic

Sie können "yes" eingeben, um die Aktion zu bestätigen und den statischen Inhalt zu erfassen. Es wird ein neues Verzeichnis mit dem Namen "+ static +" in Ihrem Projektverzeichnis geben.

Mit all dem können wir unser Projekt testen, indem wir den Entwicklungsserver vorübergehend starten. Art:

./manage.py runserver 0.0.0.0:8080

Dies startet den Entwicklungsserver an Port "+ 8080 ". Besuchen Sie den Domainnamen oder die IP-Adresse Ihres Servers, gefolgt von " 8080 +" in Ihrem Browser:

http://:8080

Sie sollten eine Seite sehen, die so aussieht:

image: https://assets.digitalocean.com/articles/django_uwsgi_nginx_1404/sample_site.png [Django-Beispielsite]

Fügen Sie "+ / admin +" am Ende der URL in der Adressleiste Ihres Browsers ein, und Sie werden zur Anmeldeseite des Administrators weitergeleitet:

Bild: https://assets.digitalocean.com/articles/django_uwsgi_nginx_1404/admin_login.png [Django-Administratoranmeldung]

Melden Sie sich mit den Administratoranmeldeinformationen, die Sie mit dem Befehl "+ createduperuser +" ausgewählt haben, beim Server an. Sie haben dann Zugriff auf die Administrationsoberfläche:

Bild: https://assets.digitalocean.com/articles/django_uwsgi_nginx_1404/admin_interface.png [Django-Administrationsoberfläche]

Beenden Sie nach dem Testen dieser Funktion den Entwicklungsserver, indem Sie STRG-C in Ihr Terminal eingeben. Wir können jetzt mit unserem zweiten Projekt fortfahren.

Erstellen Sie das zweite Projekt

Das zweite Projekt wird genauso wie das erste erstellt. Wir werden die Erklärung in diesem Abschnitt abkürzen, da Sie dies bereits einmal ausgeführt haben.

Wechseln Sie zurück in Ihr Ausgangsverzeichnis und erstellen Sie eine zweite virtuelle Umgebung für Ihr neues Projekt. Installieren Sie Django in dieser neuen Umgebung, sobald es aktiviert ist:

cd ~
mkvirtualenv
pip install django

Die neue Umgebung wird erstellt und in geändert, wobei Ihre vorherige virtuelle Umgebung verlassen wird. Diese Django-Instanz ist völlig unabhängig von der anderen, die Sie konfiguriert haben. Auf diese Weise können Sie sie unabhängig verwalten und bei Bedarf anpassen.

Erstellen Sie das zweite Projekt und verschieben Sie es in das Projektverzeichnis:

django-admin.py startproject
cd ~/

Initialisieren Sie die Datenbank und erstellen Sie einen Administrator:

./manage.py migrate
./manage.py createsuperuser

Öffnen Sie die Einstellungsdatei:

nano /settings.py

Fügen Sie den Speicherort für die statischen Dateien wie im vorherigen Projekt hinzu:

STATIC_ROOT = os.path.join(BASE_DIR, "static/")

Speichern und schließen Sie die Datei. Sammeln Sie nun die statischen Elemente in diesem Verzeichnis, indem Sie Folgendes eingeben:

./manage.py collectstatic

Starten Sie abschließend den Entwicklungsserver, um die Site zu testen:

./manage.py runserver 0.0.0.0:8080

Sie sollten die reguläre Site unter folgender Adresse überprüfen:

http://:8080

Melden Sie sich auch auf der Admin-Site an:

http://:8080/admin

Wenn Sie bestätigt haben, dass alles wie erwartet funktioniert, geben Sie STRG-C in Ihr Terminal ein, um den Entwicklungsserver zu stoppen.

Sichern aus der virtuellen Umgebung

Da wir nun mit dem Django-Teil des Handbuchs fertig sind, können wir unsere zweite virtuelle Umgebung deaktivieren:

deactivate

Wenn Sie erneut an einer Ihrer Django-Sites arbeiten müssen, sollten Sie deren jeweilige Umgebungen reaktivieren. Sie können dies mit dem Befehl + workon + tun:

workon

Or:

workon

Deaktivieren Sie erneut, wenn Sie mit der Arbeit an Ihren Websites fertig sind:

deactivate

Einrichten des uWSGI-Anwendungsservers

Nachdem wir zwei Django-Projekte eingerichtet und einsatzbereit haben, können wir uWSGI konfigurieren. uWSGI ist ein Anwendungsserver, der über eine Standardschnittstelle namens WSGI mit Anwendungen kommunizieren kann. Weitere Informationen hierzu finden Sie unter https://www.digitalocean.com/community/tutorials/how-to-set-up-uwsgi-and-nginx-to-serve-python-apps-on-ubuntu-14-04 # Definitionen und Konzepte [dieser Abschnitt] unseres Handbuchs zum Einrichten von uWSGI und Nginx unter Ubuntu 14.04.

UWSGI installieren

Im Gegensatz zu der oben verlinkten Anleitung installieren wir in diesem Lernprogramm uWSGI global. Dies führt zu weniger Reibung bei der Bearbeitung mehrerer Django-Projekte. Bevor wir uWSGI installieren können, benötigen wir die Python-Entwicklungsdateien, auf die sich die Software stützt. Wir können dies direkt aus den Ubuntu-Repositories installieren:

sudo apt-get install python-dev

Nachdem die Entwicklungsdateien verfügbar sind, können wir uWSGI global über "+ pip +" installieren, indem wir Folgendes eingeben:

sudo pip install uwsgi

Wir können diesen Anwendungsserver schnell testen, indem wir ihm die Informationen für eine unserer Sites übergeben. Zum Beispiel können wir sagen, dass es unserem ersten Projekt dienen soll, indem wir Folgendes eingeben:

uwsgi --http :8080 --home /home//Env/ --chdir /home// -w .wsgi

Hier haben wir uWSGI angewiesen, unsere virtuelle Umgebung in unserem Verzeichnis "+ ~ / Env " zu verwenden, in das Verzeichnis unseres Projekts zu wechseln und die in unserem inneren Verzeichnis "+" gespeicherte Datei "+ wsgi.py " zu verwenden die Datei zu dienen. Zu unserer Demonstration haben wir ihn angewiesen, HTTP auf dem Port " 8080 " bereitzustellen. Wenn Sie in Ihrem Browser den Domain-Namen oder die IP-Adresse des Servers aufrufen, gefolgt von ": 8080 ", wird Ihre Site erneut angezeigt (die statischen Elemente in der " / admin +" - Oberfläche funktionieren noch nicht). Wenn Sie mit dem Testen dieser Funktionalität fertig sind, geben Sie im Terminal STRG-C ein.

Konfigurationsdateien erstellen

Das Ausführen von uWSGI über die Befehlszeile ist zum Testen hilfreich, für eine tatsächliche Bereitstellung jedoch nicht besonders hilfreich. Stattdessen führen wir uWSGI im „Emperor-Modus“ aus, der es einem Master-Prozess ermöglicht, separate Anwendungen automatisch anhand einer Reihe von Konfigurationsdateien zu verwalten.

Erstellen Sie ein Verzeichnis, in dem Ihre Konfigurationsdateien gespeichert werden. Da dies ein globaler Prozess ist, erstellen wir ein Verzeichnis mit dem Namen "+ / etc / uwsgi / sites", in dem Ihre Konfigurationsdateien gespeichert werden. Wechseln Sie in das Verzeichnis, nachdem Sie es erstellt haben:

sudo mkdir -p /etc/uwsgi/sites
cd /etc/uwsgi/sites

In diesem Verzeichnis werden wir unsere Konfigurationsdateien ablegen. Für jedes von uns betreute Projekt benötigen wir eine Konfigurationsdatei. Der uWSGI-Prozess kann Konfigurationsdateien in einer Vielzahl von Formaten verarbeiten, wir werden jedoch aufgrund ihrer Einfachheit "+ .ini +" - Dateien verwenden.

Erstellen Sie eine Datei für Ihr erstes Projekt und öffnen Sie sie in Ihrem Texteditor:

sudo nano .ini

Im Inneren müssen wir mit der Abschnittsüberschrift "+ [uwsgi] " beginnen. Alle unsere Informationen werden unter dieser Überschrift angezeigt. Wir werden auch Variablen verwenden, um unsere Konfigurationsdatei wiederverwendbarer zu machen. Setzen Sie nach dem Header eine Variable mit dem Namen " project " und dem Namen Ihres ersten Projekts. Fügen Sie eine Variable mit dem Namen " base +" und dem Pfad zum Ausgangsverzeichnis Ihres Benutzers hinzu:

[uwsgi]
project =
base = /home/

Als nächstes müssen wir uWSGI so konfigurieren, dass es unser Projekt korrekt handhabt. Wir müssen in das Root-Projektverzeichnis wechseln, indem wir die Option + chdir + setzen. Wir können die zuvor festgelegte Einstellung für das Basisverzeichnis und den Projektnamen mithilfe der Syntax +% () + kombinieren. Dies wird durch den Wert der Variablen ersetzt, wenn die Konfiguration gelesen wird.

In ähnlicher Weise geben wir die virtuelle Umgebung für unser Projekt an. Durch Einstellen des Moduls können wir genau angeben, wie die Schnittstelle zu unserem Projekt hergestellt werden soll (durch Importieren der "Anwendung", die aus der Datei "+ wsgi.py +" in unserem Projektverzeichnis aufgerufen werden kann). Die Konfiguration dieser Elemente sieht folgendermaßen aus:

[uwsgi]
project =
base = /home/

chdir = %(base)/%(project)
home = %(base)/Env/%(project)
module = %(project).wsgi:application

Wir wollen einen Masterprozess mit 5 Arbeitern erstellen. Wir können dies tun, indem wir Folgendes hinzufügen:

[uwsgi]
project =
base = /home/

chdir = %(base)/%(project)
home = %(base)/Env/%(project)
module = %(project).wsgi:application

master = true
processes = 5

Als nächstes müssen wir festlegen, wie uWSGI auf Verbindungen wartet. In unserem Test von uWSGI verwendeten wir HTTP und einen Netzwerkport. Da wir Nginx jedoch als Reverse-Proxy verwenden werden, haben wir bessere Optionen.

Anstatt einen Netzwerkport zu verwenden, können wir einen Unix-Socket verwenden, da alle Komponenten auf einem einzelnen Server ausgeführt werden. Dies ist sicherer und bietet eine bessere Leistung. Dieser Socket verwendet kein HTTP, sondern implementiert stattdessen das uWSGI-Protokoll "+ uwsgi ", ein schnelles Binärprotokoll für die Kommunikation mit anderen Servern. Nginx kann nativ Proxys mit dem " uwsgi +" - Protokoll erstellen, daher ist dies unsere beste Wahl.

Wir werden auch die Berechtigungen des Sockets ändern, da wir dem Webserver Schreibzugriff gewähren. Wir setzen die Option "+ vacuum +", damit die Socket-Datei automatisch bereinigt wird, wenn der Dienst beendet wird:

[uwsgi]
project =
base = /home/

chdir = %(base)/%(project)
home = %(base)/Env/%(project)
module = %(project).wsgi:application

master = true
processes = 5

socket = %(base)/%(project)/%(project).sock
chmod-socket = 664
vacuum = true

Damit ist die uWSGI-Konfiguration unseres ersten Projekts abgeschlossen. Speichern und schließen Sie die Datei.

Das Einrichten der Datei mit Variablen hat den Vorteil, dass die Wiederverwendung unglaublich einfach ist. Kopieren Sie die Konfigurationsdatei Ihres ersten Projekts, um sie als Grundlage für Ihre zweite Konfigurationsdatei zu verwenden:

sudo cp /etc/uwsgi/sites/.ini /etc/uwsgi/sites/.ini

Öffnen Sie die zweite Konfigurationsdatei mit Ihrem Texteditor:

sudo nano /etc/uwsgi/sites/.ini

Wir müssen nur einen einzelnen Wert in dieser Datei ändern, damit es für unser zweites Projekt funktioniert. Ändern Sie die Variable "+ project +" mit dem Namen, den Sie für Ihr zweites Projekt verwendet haben:

[uwsgi]
project =
base = /home/

chdir = %(base)/%(project)
home = %(base)/Env/%(project)
module = %(project).wsgi:application

master = true
processes = 5

socket = %(base)/%(project)/%(project).sock
chmod-socket = 664
vacuum = true

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Ihr zweites Projekt sollte jetzt fertig sein.

Erstellen Sie ein Upstart-Skript für uWSGI

Wir haben jetzt die Konfigurationsdateien, die wir für unsere Django-Projekte benötigen, aber wir haben den Prozess noch nicht automatisiert. Als Nächstes erstellen wir ein Upstart-Skript, um uWSGI beim Booten automatisch zu starten.

Wir erstellen ein Upstart-Skript im Verzeichnis "+ / etc / init +", in dem die folgenden Dateien überprüft werden:

sudo nano /etc/init/uwsgi.conf

Legen Sie zunächst eine Beschreibung für Ihren uWSGI-Dienst fest und geben Sie die Runlevel an, auf denen er automatisch ausgeführt werden soll. Wir werden unsere für Runlevel 2, 3, 4 und 5 einstellen, die die konventionellen Multi-User-Runlevel sind:

description "uWSGI application server in Emperor mode"

start on runlevel [2345]
stop on runlevel [!2345]

Als Nächstes müssen Sie den Benutzernamen und die Gruppe festlegen, unter denen der Prozess ausgeführt werden soll. Wir werden den Prozess unter unserem eigenen Benutzernamen ausführen, da wir alle Dateien besitzen. Für die Gruppe müssen wir die Gruppe "+ www-data" festlegen, unter der Nginx ausgeführt wird. Unsere Socket-Einstellungen aus der uWSGI-Konfigurationsdatei sollten es dem Webserver dann ermöglichen, in das Socket zu schreiben. Ändern Sie den unten stehenden Benutzernamen so, dass er Ihrem Benutzernamen auf dem Server entspricht:

description "uWSGI application server in Emperor mode"

start on runlevel [2345]
stop on runlevel [!2345]

setuid
setgid www-data

Schließlich müssen wir den tatsächlichen Befehl angeben, der ausgeführt werden soll. Wir müssen uWSGI im Emperor-Modus starten und das Verzeichnis übergeben, in dem wir unsere Konfigurationsdateien gespeichert haben. uWSGI wird die Dateien lesen und jedes unserer Projekte bedienen:

description "uWSGI application server in Emperor mode"

start on runlevel [2345]
stop on runlevel [!2345]

setuid
setgid www-data

exec /usr/local/bin/uwsgi --emperor /etc/uwsgi/sites

Wenn Sie fertig sind, speichern und schließen Sie die Datei. UWSGI wird noch nicht gestartet, da die Gruppe "+ www-data +" erst nach der Installation von Nginx verfügbar ist.

Installieren und konfigurieren Sie Nginx als Reverse Proxy

Nachdem uWSGI konfiguriert und einsatzbereit ist, können wir jetzt Nginx als unseren Reverse-Proxy installieren und konfigurieren. Dies kann von Ubuntus Standard-Repositorys heruntergeladen werden:

sudo apt-get install nginx

Sobald Nginx installiert ist, können wir für jedes unserer Projekte eine Serverblock-Konfigurationsdatei erstellen. Beginnen Sie mit dem ersten Projekt, indem Sie eine Serverblock-Konfigurationsdatei erstellen:

sudo nano /etc/nginx/sites-available/

Im Inneren können wir unseren Serverblock starten, indem wir die Portnummer und den Domainnamen angeben, auf die unser erstes Projekt zugreifen soll. Wir gehen davon aus, dass Sie für jede Domain einen Domainnamen haben:

server {
   listen 80;
   server_name .com www..com;
}

Als Nächstes können wir Nginx anweisen, sich keine Sorgen zu machen, wenn kein Favicon gefunden wird. Wir verweisen außerdem auf den Speicherort unseres statischen Dateiverzeichnisses, in dem wir die statischen Elemente unserer Website gesammelt haben:

server {
   listen 80;
   server_name .com www..com;

   location = /favicon.ico { access_log off; log_not_found off; }
   location /static/ {
       root /home//;
   }
}

Danach können wir die Direktive "+ uwsgi_pass " verwenden, um den Datenverkehr an unsere Socket-Datei zu übergeben. Die von uns konfigurierte Socket-Datei hieß " .sock " und befand sich in unserem Projektverzeichnis. Wir werden die Direktive " include " verwenden, um die notwendigen " uwsgi +" - Parameter für die Verbindungsverarbeitung einzuschließen:

server {
   listen 80;
   server_name .com www..com;

   location = /favicon.ico { access_log off; log_not_found off; }
   location /static/ {
       root /home//;
   }

   location / {
       include         uwsgi_params;
       uwsgi_pass      unix:/home///.sock;
   }
}

Das ist eigentlich die ganze Konfiguration, die wir brauchen. Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Wir werden dies als Grundlage für die Nginx-Konfigurationsdatei unseres zweiten Projekts verwenden. Kopieren Sie es jetzt:

sudo cp /etc/nginx/sites-available/ /etc/nginx/sites-available/

Öffnen Sie die neue Datei in Ihrem Texteditor:

sudo nano /etc/nginx/sites-available/

Hier müssen Sie einen Verweis auf "" durch einen Verweis auf "" ersetzen. Sie müssen auch "+ Servername +" ändern, damit Ihr zweites Projekt auf einen anderen Domainnamen reagiert. Wenn Sie fertig sind, sieht es ungefähr so aus:

server {
   listen 80;
   server_name .com www..com;

   location = /favicon.ico { access_log off; log_not_found off; }
   location /static/ {
       root /home//;
   }

   location / {
       include         uwsgi_params;
       uwsgi_pass      unix:/home///.sock;
   }
}

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Verknüpfen Sie anschließend Ihre beiden neuen Konfigurationsdateien mit dem Verzeichnis "+ sites-enabled +" von Nginx, um sie zu aktivieren:

sudo ln -s /etc/nginx/sites-available/ /etc/nginx/sites-enabled
sudo ln -s /etc/nginx/sites-available/ /etc/nginx/sites-enabled

Überprüfen Sie die Konfigurationssyntax, indem Sie Folgendes eingeben:

sudo service nginx configtest

Wenn keine Syntaxfehler erkannt werden, können Sie den Nginx-Dienst neu starten, um die neue Konfiguration zu laden:

sudo service nginx restart

Wenn Sie sich an früher erinnern, haben wir den uWSGI-Server nie gestartet. Tun Sie das jetzt, indem Sie Folgendes eingeben:

sudo service uwsgi start

Sie sollten nun in der Lage sein, Ihre beiden Projekte zu erreichen, indem Sie zu ihren jeweiligen Domain-Namen gehen. Sowohl die öffentliche als auch die Verwaltungsschnittstelle sollten wie erwartet funktionieren.

Fazit

In diesem Handbuch haben wir zwei Django-Projekte in jeweils eigenen virtuellen Umgebungen eingerichtet. Wir haben uWSGI so konfiguriert, dass jedes Projekt unabhängig von der jeweils konfigurierten virtuellen Umgebung bereitgestellt wird. Anschließend haben wir Nginx so eingerichtet, dass es als Reverse-Proxy für die Verarbeitung von Clientverbindungen fungiert und je nach Clientanforderung das richtige Projekt bereitstellt.

Django vereinfacht das Erstellen von Projekten und Anwendungen, indem es viele der gemeinsamen Elemente bereitstellt, sodass Sie sich auf die einzigartigen Elemente konzentrieren können. Indem Sie die in diesem Artikel beschriebene allgemeine Toolkette nutzen, können Sie die von Ihnen erstellten Anwendungen problemlos von einem einzelnen Server aus bereitstellen.

TOC