TOC

So servieren Sie Django-Anwendungen mit Apache und mod_wsgi unter Ubuntu 16.04

Einführung

Django ist ein leistungsstarkes Webframework, mit dem Sie Ihre Python-Anwendung oder -Website schnell in Betrieb nehmen 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 Sie Django in einer virtuellen Python-Umgebung installieren und konfigurieren. Wir richten Apache dann vor unserer Anwendung ein, damit es Client-Anforderungen direkt verarbeiten kann, bevor Anforderungen, die Anwendungslogik erfordern, an die Django-App übergeben werden. Wir werden dazu das Apache-Modul + mod_wsgi + verwenden, das über die WSGI-Schnittstellenspezifikation mit Django kommunizieren kann.

Voraussetzungen und Ziele

Um dieses Handbuch zu vervollständigen, sollten Sie eine neue Ubuntu 16.04-Serverinstanz mit einem Nicht-Root-Benutzer mit konfigurierten + sudo + - Berechtigungen haben. Weitere Informationen zum Einrichten finden Sie in unserem initial server setup guide.

Wir werden Django in einer virtuellen Python-Umgebung installieren. Durch die Installation von Django in einer für Ihr Projekt spezifischen Umgebung können Ihre Projekte und deren Anforderungen separat behandelt werden.

Sobald wir unsere Anwendung zum Laufen gebracht haben, werden wir Apache so konfigurieren, dass er mit der Django-App kommuniziert. Dies geschieht mit dem Apache-Modul + mod_wsgi +, das HTTP-Anforderungen in ein vorhersagbares Anwendungsformat übersetzen kann, das durch eine Spezifikation namens WSGI definiert wird. Weitere Informationen zu WSGI finden Sie im verlinkten Abschnitt 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 [diese Anleitung].

Lass uns anfangen.

Installieren Sie Pakete aus den Ubuntu-Repositories

Zu Beginn des Vorgangs laden wir alle benötigten Elemente aus den Ubuntu-Repositorys herunter und installieren sie. Dazu gehören der Apache-Webserver, das "+ mod_wsgi " -Modul für die Schnittstelle zu unserer Django-App und " pip +", der Python-Paketmanager, mit dem Sie unsere Python-Tools herunterladen können.

Aktualisieren Sie den lokalen Paketindex Ihres Servers und installieren Sie die entsprechenden Pakete, um alles zu erhalten, was wir benötigen.

Wenn Sie Django mit * Python 2 * verwenden, benötigen Sie folgende Befehle:

sudo apt-get update
sudo apt-get install python-pip apache2 libapache2-mod-wsgi

Wenn Sie stattdessen Django mit * Python 3 * verwenden, benötigen Sie ein alternatives Apache-Modul und das Paket + pip +. Die entsprechenden Befehle sind in diesem Fall:

sudo apt-get update
sudo apt-get install python3-pip apache2 libapache2-mod-wsgi-py3

Konfigurieren Sie eine virtuelle Python-Umgebung

Nachdem wir die Komponenten aus den Ubuntu-Repositories haben, können wir mit der Arbeit an unserem Django-Projekt beginnen. Der erste Schritt besteht darin, eine virtuelle Python-Umgebung zu erstellen, damit unser Django-Projekt von den Tools des Systems und allen anderen Python-Projekten, an denen wir arbeiten, getrennt ist.

Wir müssen den Befehl "+ virtualenv " installieren, um diese Umgebungen zu erstellen. Wir können das mit ` pip +` bekommen.

Wenn Sie * Python 2 * verwenden, geben Sie Folgendes ein:

sudo pip install virtualenv

Wenn Sie * Python 3 * verwenden, geben Sie Folgendes ein:

sudo pip3 install virtualenv

Wenn "+ virtualenv +" installiert ist, können wir mit der Gestaltung unseres Projekts beginnen. Erstellen Sie ein Verzeichnis, in dem Sie Ihr Projekt behalten möchten, und wechseln Sie in das Verzeichnis:

mkdir ~/
cd ~/

Erstellen Sie im Projektverzeichnis eine virtuelle Python-Umgebung, indem Sie Folgendes eingeben:

virtualenv

Dadurch wird ein Verzeichnis mit dem Namen "" in Ihrem "" - Verzeichnis erstellt. Im Inneren wird eine lokale Version von Python und eine lokale Version von + pip + installiert. Damit können wir eine isolierte Python-Umgebung für unser Projekt installieren und konfigurieren.

Bevor wir die Python-Anforderungen unseres Projekts installieren, müssen wir die virtuelle Umgebung aktivieren. Sie können dies tun, indem Sie Folgendes eingeben:

source /bin/activate

Ihre Eingabeaufforderung sollte sich ändern, um anzuzeigen, dass Sie jetzt in einer virtuellen Python-Umgebung arbeiten. Es sieht ungefähr so ​​aus: + () @: ~ / $ +.

Installieren Sie Django bei aktivierter virtueller Umgebung mit der lokalen Instanz von "+ pip +":

Note

pip install django

Erstelle und konfiguriere ein neues Django-Projekt

Nachdem Django in unserer virtuellen Umgebung installiert ist, können wir die eigentlichen Django-Projektdateien erstellen.

Erstellen Sie das Django-Projekt

Da wir bereits ein Projektverzeichnis haben, werden wir Django anweisen, die Dateien hier zu installieren. Es wird ein Verzeichnis der zweiten Ebene mit dem tatsächlichen Code erstellt, der normal ist, und ein Verwaltungsskript wird in dieses Verzeichnis eingefügt. Der Schlüssel dazu ist der Punkt am Ende, der Django anweist, die Dateien im aktuellen Verzeichnis zu erstellen:

django-admin.py startproject  .

Passen Sie die Projekteinstellungen an

Das erste, was wir mit unseren neu erstellten Projektdateien tun sollten, ist, die Einstellungen anzupassen. Öffnen Sie die Einstellungsdatei mit Ihrem Texteditor:

nano /settings.py

Wir werden der Einfachheit halber die Standard-SQLite-Datenbank in diesem Handbuch verwenden, damit wir nicht zu viel ändern müssen. Wir konzentrieren uns auf die Konfiguration der zulässigen Hosts, um die Domänen, auf die wir reagieren, einzuschränken, und auf die Konfiguration des Verzeichnisses für statische Dateien, in dem Django statische Dateien ablegt, damit der Webserver diese problemlos bereitstellen kann.

Suchen Sie zunächst die Zeile + ALLOWED_HOSTS +. Geben Sie in die eckigen Klammern die öffentliche IP-Adresse, den Domainnamen oder beides Ihres Servers ein. Jeder Wert sollte in Anführungszeichen eingeschlossen und wie eine normale Python-Liste durch ein Komma getrennt werden:

~ / myproject / myproject / settings.py

. . .
ALLOWED_HOSTS = [""]
. . .

Am Ende der Datei fügen wir eine Zeile hinzu, um dieses Verzeichnis zu konfigurieren. Django verwendet die Einstellung "+ STATIC_ROOT +", um das Verzeichnis zu bestimmen, in das diese Dateien verschoben werden sollen. Wir werden ein bisschen Python verwenden, um es anzuweisen, ein Verzeichnis mit dem Namen "static" im Hauptverzeichnis unseres Projekts zu verwenden:

~ / myproject / myproject / settings.py

. . .

STATIC_URL = '/static/'

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

Schließen Sie die anfängliche Projekteinrichtung ab

Jetzt können wir das anfängliche Datenbankschema mithilfe des Verwaltungsskripts in unsere SQLite-Datenbank migrieren:

cd ~/
./manage.py makemigrations
./manage.py migrate

Erstellen Sie einen Administrator für das Projekt, indem Sie Folgendes eingeben:

./manage.py createsuperuser

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

Wir können den gesamten statischen Inhalt in dem von uns konfigurierten Verzeichnis speichern, indem wir Folgendes eingeben:

./manage.py collectstatic

Sie müssen den Vorgang bestätigen. Die statischen Dateien werden in einem Verzeichnis mit dem Namen "+ static +" in Ihrem Projektverzeichnis abgelegt.

Jetzt können wir Ihre Firewall-Einstellungen anpassen, um Datenverkehr zu unserem Django-Entwicklungsserver zuzulassen, der auf Port 8000 ausgeführt wird. Wenn Sie in den Voraussetzungen die Anleitung zur Ersteinrichtung des Servers befolgt haben, sollte derzeit eine UFW-Firewall aktiviert sein.

Ermöglichen Sie Verbindungen zum Entwicklungsserver, indem Sie Folgendes eingeben:

sudo ufw allow 8000

Zuletzt können Sie Ihr Projekt testen, indem Sie den Django-Entwicklungsserver mit folgendem Befehl starten:

./manage.py runserver 0.0.0.0:8000

Besuchen Sie in Ihrem Webbrowser den Domainnamen oder die IP-Adresse Ihres Servers, gefolgt von "+: 8000 +":

http://:8000

Sie sollten die Standard-Django-Indexseite sehen:

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

Wenn Sie "+ / admin " an das Ende der URL in der Adressleiste anhängen, werden Sie aufgefordert, den Administrator-Benutzernamen und das Kennwort einzugeben, die Sie mit dem Befehl " createduperuser" erstellt haben:

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

Nach der Authentifizierung können Sie auf die standardmäßige Django-Administrationsoberfläche zugreifen:

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

Wenn Sie mit dem Durchsuchen fertig sind, drücken Sie STRG-C im Terminalfenster, um den Entwicklungsserver herunterzufahren.

Mit Django sind wir vorerst fertig, sodass wir unsere virtuelle Umgebung verlassen können, indem wir Folgendes eingeben:

deactivate

Konfigurieren Sie Apache

Jetzt, da Ihr Django-Projekt funktioniert, können wir Apache als Front-End konfigurieren. Erhaltene Client-Verbindungen werden mit dem + mod_wsgi + - Modul in das von der Django-Anwendung erwartete WSGI-Format übersetzt. Dies sollte bei der früheren Installation automatisch aktiviert worden sein.

Um den WSGI-Pass zu konfigurieren, müssen wir die Standarddatei des virtuellen Hosts bearbeiten:

sudo nano /etc/apache2/sites-available/000-default.conf

Wir können die Anweisungen, die bereits in der Datei vorhanden sind, beibehalten. Wir müssen nur einige zusätzliche Elemente hinzufügen.

Konfigurieren Sie zunächst die statischen Dateien. Wir werden einen Alias ​​verwenden, um Apache anzuweisen, alle Anfragen, die mit "+ / static +" beginnen, dem "static" -Verzeichnis in unserem Projektordner zuzuordnen. Wir haben die statischen Vermögenswerte dort früher gesammelt. Wir werden den Alias ​​einrichten und dann mit einem Verzeichnisblock Zugriff auf das betreffende Verzeichnis gewähren:

/etc/apache2/sites-available/000-default.conf

<VirtualHost *:80>
   . . .

   Alias /static /home///static
   <Directory /home///static>
       Require all granted
   </Directory>

</VirtualHost>

Als Nächstes gewähren wir Zugriff auf die Datei "+ wsgi.py +" im Projektverzeichnis der zweiten Ebene, in dem der Django-Code gespeichert ist. Dazu verwenden wir einen Verzeichnisabschnitt mit einem Dateibereich darin. Wir gewähren Zugriff auf die Datei in diesem verschachtelten Konstrukt:

/etc/apache2/sites-available/000-default.conf

<VirtualHost *:80>
   . . .

   Alias /static /home///static
   <Directory /home///static>
       Require all granted
   </Directory>

   <Directory /home///>
       <Files wsgi.py>
           Require all granted
       </Files>
   </Directory>

</VirtualHost>

Nachdem dies konfiguriert wurde, können wir den Teil der Datei erstellen, der den WSGI-Durchlauf tatsächlich verarbeitet. Wir verwenden den Daemon-Modus, um den WSGI-Prozess auszuführen. Dies ist die empfohlene Konfiguration. Wir können die Direktive "+ WSGIDaemonProcess +" verwenden, um dies einzurichten.

Diese Direktive hat einen beliebigen Namen für den Prozess. Wir werden "++" verwenden, um konsistent zu bleiben. Anschließend richten wir das Python-Home ein, in dem Apache alle erforderlichen Komponenten finden kann. Da wir eine virtuelle Umgebung verwendet haben, können wir diese direkt auf unser Basisverzeichnis für die virtuelle Umgebung verweisen. Anschließend legen wir den Python-Pfad so fest, dass er auf die Basis unseres Django-Projekts verweist.

Als nächstes müssen wir die Prozessgruppe angeben. Dies sollte auf denselben Namen verweisen, den wir für die Direktive "+ WSGIDaemonProcess " ausgewählt haben (in unserem Fall " myproject "). Schließlich müssen wir den Script-Alias ​​so einstellen, dass Apache Anforderungen für die Root-Domain an die Datei ` wsgi.py +` weiterleitet:

/etc/apache2/sites-available/000-default.conf

<VirtualHost *:80>
   . . .

   Alias /static /home///static
   <Directory /home///static>
       Require all granted
   </Directory>

   <Directory /home///>
       <Files wsgi.py>
           Require all granted
       </Files>
   </Directory>

   WSGIDaemonProcess  python-home=/home/// python-path=/home//myproject
   WSGIProcessGroup
   WSGIScriptAlias / /home////wsgi.py

</VirtualHost>

Wenn Sie mit diesen Änderungen fertig sind, speichern und schließen Sie die Datei.

Zusammenfassung einiger Berechtigungsprobleme

Wenn Sie die SQLite-Datenbank verwenden, die in diesem Artikel standardmäßig verwendet wird, müssen Sie dem Apache-Prozess den Zugriff auf diese Datei gewähren.

Zu diesem Zweck müssen Sie zunächst die Berechtigungen ändern, damit der Gruppeneigentümer der Datenbank lesen und schreiben kann. Die Datenbankdatei heißt standardmäßig + db.sqlite3 + und sollte sich in Ihrem Basisprojektverzeichnis befinden:

chmod 664 ~//db.sqlite3

Danach müssen wir der Gruppe, unter der Apache läuft, die Gruppe "+ www-data" und den Gruppeneigentum an der Datei geben:

sudo chown :www-data ~//db.sqlite3

Um in die Datei zu schreiben, müssen wir der Apache-Gruppe auch den Besitz über das übergeordnete Verzeichnis der Datenbank erteilen:

sudo chown :www-data ~/

Wir müssen uns erneut über unsere Firewall anpassen. Wir brauchen Port 8000 nicht mehr offen zu haben, da wir über Apache einen Proxy-Server betreiben, damit wir diese Regel entfernen können. Wir können dann eine Ausnahme hinzufügen, um Datenverkehr zum Apache-Prozess zuzulassen:

sudo ufw delete allow 8000
sudo ufw allow 'Apache Full'

Überprüfen Sie Ihre Apache-Dateien, um sicherzustellen, dass Sie keine Syntaxfehler gemacht haben:

sudo apache2ctl configtest

Solange die letzte Ausgabezeile so aussieht, sind Ihre Dateien in gutem Zustand:

Output. . .
Syntax OK

Nachdem Sie diese Schritte ausgeführt haben, können Sie den Apache-Dienst neu starten, um die vorgenommenen Änderungen zu implementieren. Starten Sie Apache neu, indem Sie Folgendes eingeben:

sudo systemctl restart apache2

Sie sollten nun in der Lage sein, auf Ihre Django-Site zuzugreifen, indem Sie den Domainnamen oder die IP-Adresse Ihres Servers aufrufen, ohne einen Port anzugeben. Die reguläre Site und die Administrationsoberfläche sollten wie erwartet funktionieren.

Nächste Schritte

Nachdem Sie überprüft haben, ob auf Ihre Anwendung zugegriffen werden kann, ist es wichtig, den Datenverkehr für Ihre Anwendung zu sichern.

Wenn Sie einen Domainnamen für Ihre Anwendung haben, können Sie Ihre Anwendung am einfachsten mit einem kostenlosen SSL-Zertifikat von Let’s Encrypt sichern. Folgen Sie unserer Let’s Encrypt-Anleitung für Apache am 16.04, um mehr darüber zu erfahren wie man das einrichtet.

Wenn Sie * keinen * Domainnamen für Ihre Anwendung haben und diesen für Ihre eigenen Zwecke oder zum Testen verwenden, können Sie jederzeit ein selbstsigniertes Zertifikat erstellen. Informationen zum Einrichten finden Sie unter https://www.digitalocean.com/community/tutorials/how-to-create-a-self-signed-ssl-certificate-for-apache-in-ubuntu-16-. 04 [Anleitung zum Erstellen von selbstsignierten SSL-Zertifikaten für Apache unter Ubuntu 16.04].

Fazit

In diesem Handbuch haben wir ein Django-Projekt in einer eigenen virtuellen Umgebung eingerichtet. Wir haben Apache mit "+ mod_wsgi +" konfiguriert, um Client-Anfragen zu bearbeiten und eine Schnittstelle mit der Django-App herzustellen.

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.

Related