TOC

Einrichten von Django mit Postgres, Nginx und Gunicorn 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 eine PostgreSQL-Datenbank einrichten, anstatt die Standard-SQLite-Datenbank zu verwenden. Wir werden den Gunicorn-Anwendungsserver so konfigurieren, dass er mit unseren Anwendungen kommuniziert. Wir werden dann Nginx so einrichten, dass es den Proxy für Gunicorn umkehrt, wodurch wir Zugriff auf seine Sicherheits- und Leistungsmerkmale erhalten, 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 mit konfiguriertensudo-Berechtigungen haben. Sie können lernen, wie Sie dies einrichten, indem Sie unsereinitial server setup guide durchlaufen.

Wir werden Django in einer virtuellen 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 Datenbank und Anwendung zum Laufen gebracht haben, werden wir den Gunicorn-Anwendungsserver installieren und konfigurieren. Dies dient als Schnittstelle zu unserer Anwendung und übersetzt Client-Anforderungen in HTTP in Python-Aufrufe, die unsere Anwendung verarbeiten kann. Wir werden dann Nginx vor Gunicorn einrichten, um die Vorteile seiner hochleistungsfähigen Verbindungsbehandlungsmechanismen und seiner einfach zu implementierenden Sicherheitsfunktionen zu nutzen.

Lass uns anfangen.

Installieren Sie die Pakete aus den Ubuntu-Repositories

Zu Beginn des Vorgangs laden wir alle benötigten Elemente aus den Ubuntu-Repositorys herunter und installieren sie. Wir werden den Python-Paketmanagerpip verwenden, um zusätzliche Komponenten etwas später zu installieren.

Aktualisieren Sie zuerst den lokalen Paketindex und laden Sie dann die Pakete herunter und installieren Sie sie: 

sudo apt-get update
sudo apt-get install python-pip python-dev libpq-dev postgresql postgresql-contrib nginx

Dadurch werdenpip, die Python-Entwicklungsdateien, die zum späteren Erstellen von Gunicorn benötigt werden, das Postgres-Datenbanksystem und die für die Interaktion erforderlichen Bibliotheken sowie der Nginx-Webserver installiert.

Erstellen Sie die PostgreSQL-Datenbank und den Benutzer

Wir werden sofort loslegen und eine Datenbank und einen Datenbankbenutzer für unsere Django-Anwendung erstellen.

Um mit Postgres in seiner Standardkonfiguration zu arbeiten, ist es am besten, vorübergehend zum Systembenutzer vonpostgreszu wechseln. Tun Sie das jetzt, indem Sie Folgendes eingeben: 

sudo su - postgres

Wenn Sie als Benutzer vonpostgresarbeiten, können Sie sich ohne weitere Authentifizierung direkt bei einer interaktiven PostgreSQL-Sitzung anmelden, indem Sie Folgendes eingeben: 

psql

Sie erhalten eine PostgreSQL-Eingabeaufforderung, in der wir unsere Anforderungen festlegen können.

Erstellen Sie zunächst eine Datenbank für Ihr Projekt: 

CREATE DATABASE myproject;

Jeder Befehl muss mit einem Semikolon enden. Überprüfen Sie daher, ob Ihr Befehl mit einem endet, wenn Probleme auftreten.

Erstellen Sie als Nächstes einen Datenbankbenutzer für unser Projekt. Stellen Sie sicher, dass Sie ein sicheres Passwort wählen: 

CREATE USER myprojectuser WITH PASSWORD 'password';

Jetzt können wir unserem neuen Benutzer Zugriff auf die Verwaltung unserer neuen Datenbank gewähren: 

GRANT ALL PRIVILEGES ON DATABASE myproject TO myprojectuser;

Wenn Sie fertig sind, beenden Sie die PostgreSQL-Eingabeaufforderung, indem Sie Folgendes eingeben: 

\q

Beenden Sie nun die Shell-Sitzung des Benutzerspostgres, um zur Shell-Sitzung Ihres normalen Benutzers zurückzukehren, indem Sie Folgendes eingeben: 

exit

Erstellen Sie eine virtuelle Python-Umgebung für Ihr Projekt

Nachdem wir unsere Datenbank fertig haben, können wir den Rest unserer Projektanforderungen fertigstellen. Wir werden unsere Python-Anforderungen in einer virtuellen Umgebung installieren, um die Verwaltung zu vereinfachen.

Dazu benötigen wir zunächst Zugriff auf den Befehlvirtualenv. Wir können dies mitpip installieren: 

sudo pip install virtualenv

Wennvirtualenv installiert ist, können wir mit der Erstellung unseres Projekts beginnen. Erstellen Sie ein Verzeichnis, in dem Sie Ihr Projekt behalten möchten, und verschieben Sie es anschließend in das Verzeichnis: 

mkdir ~/myproject
cd ~/myproject

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

virtualenv myprojectenv

Dadurch wird ein Verzeichnis mit dem Namenmyprojectenv in Ihrem Verzeichnismyprojecterstellt. Im Inneren wird eine lokale Version von Python und eine lokale Version vonpip 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 myprojectenv/bin/activate

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

Installieren Sie bei aktivierter virtueller Umgebung Django, Gunicorn und den PostgreSQL-Adapterpsycopg2 mit der lokalen Instanzpip: 

pip install django gunicorn psycopg2

Erstelle und konfiguriere ein neues Django-Projekt

Mit unseren installierten Python-Komponenten 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 myproject .

Passen Sie die Projekteinstellungen an

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

nano myproject/settings.py

Suchen Sie zunächst den Abschnitt, der den Datenbankzugriff konfiguriert. Es beginnt mitDATABASES. Die Konfiguration in der Datei bezieht sich auf eine SQLite-Datenbank. Wir haben bereits eine PostgreSQL-Datenbank für unser Projekt erstellt, daher müssen wir die Einstellungen anpassen.

Ändern Sie die Einstellungen mit Ihren PostgreSQL-Datenbankinformationen. Wir weisen Django an, den mitpip installiertenpsycopg2-Adapter zu verwenden. Wir müssen den Datenbanknamen, den Datenbankbenutzernamen und das Kennwort des Datenbankbenutzernamens angeben und dann angeben, dass sich die Datenbank auf dem lokalen Computer befindet. Sie können die EinstellungPORTals leere Zeichenfolge belassen: 

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'myproject',
        'USER': 'myprojectuser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}

Bewegen Sie sich als Nächstes zum Ende der Datei und fügen Sie eine Einstellung hinzu, die angibt, wo die statischen Dateien abgelegt werden sollen. Dies ist erforderlich, damit Nginx Anfragen für diese Artikel bearbeiten kann. Die folgende Zeile weist Django an, sie in einem Verzeichnis namensstatic im Basisprojektverzeichnis abzulegen: 

STATIC_ROOT = os.path.join(BASE_DIR, "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 PostgreSQL-Datenbank migrieren: 

cd ~/myproject
./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 dann in einem Verzeichnis namensstatic in Ihrem Projektverzeichnis abgelegt.

Zum Schluss 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://server_domain_or_IP:8000

Sie sollten die Standard-Django-Indexseite sehen:

Django index page

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 Befehlcreatesuperuser erstellt haben:

Django admin login

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

Django admin interface

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

Testen von Gunicorns Fähigkeit, dem Projekt zu dienen

Das Letzte, was wir tun möchten, bevor wir unsere virtuelle Umgebung verlassen, ist Gunicorn zu testen, um sicherzustellen, dass es die Anwendung bedienen kann. Wir können dies leicht tun, indem wir Folgendes eingeben: 

cd ~/myproject
gunicorn --bind 0.0.0.0:8000 myproject.wsgi:application

Dadurch wird Gunicorn auf derselben Oberfläche gestartet, auf der der Django-Entwicklungsserver ausgeführt wurde. Sie können die App erneut testen. Beachten Sie, dass auf die Admin-Oberfläche kein Stil angewendet wird, da Gunicorn nicht über den dafür verantwortlichen statischen Inhalt informiert ist.

Wir haben Gunicorn ein Modul übergeben, indem wir den relativen Verzeichnispfad zu Djangoswsgi.py-Datei angegeben haben, die der Einstiegspunkt für unsere Anwendung ist, und dabei die Modulsyntax von Python verwendet haben. In dieser Datei ist eine Funktion namensapplication definiert, mit der mit der Anwendung kommuniziert wird. Um mehr über die WSGI-Spezifikation zu erfahren, klicken Sie aufhere.

Wenn Sie mit dem Testen fertig sind, drücken Sie STRG-C im Terminalfenster, um Gunicorn zu stoppen.

Wir sind jetzt mit der Konfiguration unserer Django-Anwendung fertig. Wir können unsere virtuelle Umgebung verlassen, indem wir Folgendes eingeben: 

deactivate

Erstellen Sie eine Gunicorn Upstart-Datei

Wir haben getestet, dass Gunicorn mit unserer Django-Anwendung interagieren kann, aber wir sollten eine robustere Methode zum Starten und Stoppen des Anwendungsservers implementieren. Um dies zu erreichen, erstellen wir ein Upstart-Skript.

Erstellen und öffnen Sie eine Upstart-Datei für Gunicorn mit den Berechtigungen vonsudoin Ihrem Texteditor: 

sudo nano /etc/init/gunicorn.conf

Wir beginnen mit einer einfachen Beschreibungszeichenfolge, die angibt, wofür unsere Servicedatei bestimmt ist. Anschließend werden die Runlevel des Systems festgelegt, auf denen dieser Dienst automatisch gestartet werden soll. Die normalen Runlevel zum Ausführen von Diensten sind 2, 3, 4 und 5. Wir werden unseren Service ausführen, wenn sich das System in einem dieser Systeme befindet. Wir werden es anweisen, anzuhalten, wenn es sich in einem anderen Runlevel befindet (z. B. wenn das System neu gestartet, heruntergefahren oder im Einzelbenutzermodus betrieben wird): 

description "Gunicorn application server handling myproject"

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

Als Nächstes weisen wir Upstart an, den Dienst automatisch neu zu starten, wenn er fehlschlägt. Wir möchten auch den Benutzer und die Gruppe angeben, unter denen ausgeführt werden soll. Wir verwenden unseren normalen Benutzer, da alle unsere Dateien diesem Benutzer gehören. Wir lassen diewww-data-Gruppe, zu der Nginx gehört, die Gruppeninhaber sein. Wir müssen auch in das Verzeichnis unseres Projekts wechseln, damit die Gunicorn-Befehle korrekt ausgeführt werden: 

description "Gunicorn application server handling myproject"

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

respawn
setuid user
setgid www-data
chdir /home/user/myproject

Jetzt müssen wir nur noch den Befehl geben, der den Gunicorn-Prozess startet. Wir müssen den Pfad zur ausführbaren Datei von Gunicorn angeben, die in unserer virtuellen Umgebung gespeichert ist. Wir werden es anweisen, einen Unix-Socket anstelle eines Netzwerkports für die Kommunikation mit Nginx zu verwenden, da beide Dienste auf diesem Server ausgeführt werden. Dies ist sicherer und schneller. Sie können hier auch jede andere Konfiguration für Gunicorn hinzufügen. Zum Beispiel geben wir an, dass wir 3 Worker-Prozesse wollen: 

description "Gunicorn application server handling myproject"

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

respawn
setuid user
setgid www-data
chdir /home/user/myproject

exec myprojectenv/bin/gunicorn --workers 3 --bind unix:/home/user/myproject/myproject.sock myproject.wsgi:application

Wenn Sie fertig sind, speichern und schließen Sie die Datei.

Starten Sie den Gunicorn-Dienst, indem Sie Folgendes eingeben: 

sudo service gunicorn start

Konfigurieren Sie Nginx für den Proxy-Pass für Gunicorn

Nachdem Gunicorn eingerichtet ist, müssen wir Nginx so konfigurieren, dass der Datenverkehr an den Prozess weitergeleitet wird.

Beginnen Sie mit dem Erstellen und Öffnen eines neuen Serverblocks imsites-available-Verzeichnis von Nginx: 

sudo nano /etc/nginx/sites-available/myproject

Öffnen Sie im Inneren einen neuen Serverblock. Wir beginnen mit der Angabe, dass dieser Block den normalen Port 80 überwachen und auf den Domainnamen oder die IP-Adresse unseres Servers reagieren soll: 

server {
    listen 80;
    server_name server_domain_or_IP;
}

Als Nächstes werden wir Nginx anweisen, Probleme beim Auffinden eines Favicons zu ignorieren. Wir werden auch mitteilen, wo sich die statischen Assets befinden, die wir in unserem Verzeichnis~/myproject/staticgesammelt haben. Alle diese Dateien haben das Standard-URI-Präfix "/ static", sodass wir einen Standortblock erstellen können, der diesen Anforderungen entspricht: 

server {
    listen 80;
    server_name server_domain_or_IP;

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

Schließlich erstellen wir einenlocation / {}-Block, der allen anderen Anforderungen entspricht. Innerhalb dieses Speicherorts fügen wir die Standarddateiproxy_paramsein, die in der Nginx-Installation enthalten ist, und leiten den Datenverkehr an den Socket weiter, den unser Gunicorn-Prozess erstellt hat: 

server {
    listen 80;
    server_name server_domain_or_IP;

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

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/user/myproject/myproject.sock;
    }
}

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Jetzt können wir die Datei aktivieren, indem wir sie mit dem Verzeichnissites-enabledverknüpfen: 

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

Testen Sie Ihre Nginx-Konfiguration auf Syntaxfehler, indem Sie Folgendes eingeben: 

sudo nginx -t

Wenn keine Fehler gemeldet werden, starten Sie Nginx neu, indem Sie Folgendes eingeben: 

sudo service nginx restart

Sie sollten nun in der Lage sein, die Domain oder IP-Adresse Ihres Servers aufzurufen, um Ihre Anwendung anzuzeigen.

Fazit

In diesem Handbuch haben wir ein Django-Projekt in einer eigenen virtuellen Umgebung eingerichtet. Wir haben Gunicorn so konfiguriert, dass Kundenanforderungen übersetzt werden, damit Django sie verarbeiten kann. 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.

Related