TOC

Einrichten von Django mit Postgres, Nginx und Gunicorn unter CentOS 7

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 unter CentOS 7 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, sollte eine neue CentOS 7-Serverinstanz mit einem Nicht-Root-Benutzer mit konfiguriertensudo-Berechtigungen vorhanden sein. 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 von EPEL und den CentOS-Repositorys

Zu Beginn des Vorgangs werden alle benötigten Elemente aus den CentOS-Repositorys heruntergeladen und installiert. Wir müssen auch das EPEL-Repository verwenden, das zusätzliche Pakete enthält, die nicht in den Haupt-CentOS-Repositorys enthalten sind. Später werden wir den Python-Paketmanagerpip verwenden, um einige zusätzliche Komponenten zu installieren.

Aktivieren Sie zuerst das EPEL-Repository, damit wir die benötigten Komponenten erhalten können: 

sudo yum install epel-release

Mit dem neuen Repository können wir alle benötigten Teile in einem Befehl installieren: 

sudo yum install python-pip python-devel postgresql-server postgresql-devel postgresql-contrib gcc nginx

Dadurch wirdpip, der Python-Paketmanager, installiert. Es wird auch das PostgreSQL-Datenbanksystem und einige Bibliotheken und andere Dateien installieren, die wir benötigen, um damit zu interagieren und daraus aufzubauen. Wir haben den GCC-Compiler eingefügt, damitpip Software erstellen kann, und wir haben Nginx installiert, um es als Reverse-Proxy für unsere Installation zu verwenden.

Richten Sie PostgreSQL für Django ein

Wir werden sofort loslegen und PostgreSQL für unsere Installation einrichten.

Konfigurieren und starten Sie PostgreSQL

Zu Beginn müssen wir die PostgreSQL-Datenbank initialisieren. Wir können das tun, indem wir Folgendes eingeben: 

sudo postgresql-setup initdb

Nachdem die Datenbank initialisiert wurde, können wir den PostgreSQL-Dienst starten, indem wir Folgendes eingeben: 

sudo systemctl start postgresql

Nachdem die Datenbank gestartet wurde, müssen wir die Werte in einer der Konfigurationsdateien anpassen, die ausgefüllt wurden. Verwenden Sie Ihren Editor und den Befehlsudo, um die Datei jetzt zu öffnen: 

sudo nano /var/lib/pgsql/data/pg_hba.conf

Diese Datei ist für die Konfiguration der Authentifizierungsmethoden für das Datenbanksystem verantwortlich. Derzeit ist es so konfiguriert, dass Verbindungen nur zugelassen werden, wenn der Systembenutzer mit dem Datenbankbenutzer übereinstimmt. Dies ist für lokale Wartungsaufgaben in Ordnung, aber in unserer Django-Instanz ist ein anderer Benutzer mit einem Kennwort konfiguriert.

Wir können dies konfigurieren, indem wir die zweihost-Zeilen am Ende der Datei ändern. Ändern Sie die letzte Spalte (die Authentifizierungsmethode) inmd5. Dies ermöglicht die Kennwortauthentifizierung: 

. . .

# TYPE  DATABASE        USER            ADDRESS                 METHOD

# "local" is for Unix domain socket connections only
local   all             all                                     peer
# IPv4 local connections:
#host    all             all             127.0.0.1/32            ident
host    all             all             127.0.0.1/32            md5
# IPv6 local connections:
#host    all             all             ::1/128                 ident
host    all             all             ::1/128                 md5

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

Mit unseren neuen Konfigurationsänderungen müssen wir den Dienst neu starten. Wir werden auch PostgreSQL aktivieren, damit es beim Booten automatisch startet: 

sudo systemctl restart postgresql
sudo systemctl enable postgresql

Erstellen Sie die PostgreSQL-Datenbank und den Benutzer

Nachdem wir PostgreSQL so eingerichtet haben, wie wir es möchten, können wir eine Datenbank und einen Datenbankbenutzer für unsere Django-Anwendung erstellen.

Um lokal mit Postgres 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 alspostgres-Benutzer arbeiten, können Sie sich ohne weitere Authentifizierung direkt bei einer interaktiven PostgreSQL-Sitzung anmelden. Dies ist auf die Änderung der Zeiledidn’tin der Dateipg_hba.confzurückzuführen: 

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.

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://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 Systemd-Servicedatei

Wir haben getestet, dass Gunicorn mit unserer Django-Anwendung interagieren kann, aber wir sollten eine robustere Methode zum Starten und Stoppen des Anwendungsservers implementieren. Zu diesem Zweck erstellen wir eine Systemd-Servicedatei.

Erstellen und öffnen Sie eine Systemd-Servicedatei für Gunicorn mit den Berechtigungensudoin Ihrem Texteditor: 

sudo nano /etc/systemd/system/gunicorn.service

Beginnen Sie mit dem Abschnitt[Unit], in dem Metadaten und Abhängigkeiten angegeben werden. Wir werden hier eine Beschreibung unseres Dienstes einfügen und das init-System anweisen, diese erst zu starten, nachdem das Netzwerkziel erreicht wurde: 

[Unit]
Description=gunicorn daemon
After=network.target

Als Nächstes öffnen wir den Abschnitt[Service]. Wir geben den Benutzer und die Gruppe an, unter denen die Ausführung erfolgen soll. Wir geben unserem regulären Benutzerkonto den Besitz des Prozesses, da ihm alle relevanten Dateien gehören. Wir geben der Nginx-Benutzergruppe den Besitz, damit sie problemlos mit Gunicorn kommunizieren kann.

Anschließend ordnen wir das Arbeitsverzeichnis zu und geben den Befehl zum Starten des Dienstes an. In diesem Fall müssen wir den vollständigen Pfad zur ausführbaren Datei von Gunicorn angeben, die in unserer virtuellen Umgebung installiert ist. Wir binden es an einen Unix-Socket im Projektverzeichnis, da Nginx auf demselben Computer installiert ist. Dies ist sicherer und schneller als die Verwendung eines Netzwerkports. Wir können hier auch optionale Gunicorn-Anpassungen festlegen. In diesem Fall haben wir beispielsweise drei Worker-Prozesse angegeben: 

[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=user
Group=nginx
WorkingDirectory=/home/user/myproject
ExecStart=/home/user/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:/home/user/myproject/myproject.sock myproject.wsgi:application

Schließlich fügen wir einen Abschnitt[Install]hinzu. Dies teilt Systemd mit, mit was dieser Dienst verknüpft werden soll, wenn er beim Start gestartet werden kann. Wir möchten, dass dieser Dienst gestartet wird, wenn das reguläre Mehrbenutzersystem ausgeführt wird: 

[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=user
Group=nginx
WorkingDirectory=/home/user/myproject
ExecStart=/home/user/myproject/myprojectenv/bin/gunicorn --workers 3 --bind unix:/home/user/myproject/myproject.sock myproject.wsgi:application

[Install]
WantedBy=multi-user.target

Damit ist unsere Systemd-Servicedatei vollständig. Speichern und schließen Sie es jetzt.

Wir können jetzt den von uns erstellten Gunicorn-Dienst starten und aktivieren, sodass er beim Booten startet: 

sudo systemctl start gunicorn
sudo systemctl enable gunicorn

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.

Ändern Sie die Nginx-Konfigurationsdatei

Wir können fortfahren und die Serverblockkonfiguration ändern, indem wir die Nginx-Hauptkonfigurationsdatei bearbeiten: 

sudo nano /etc/nginx/nginx.conf

Öffnen Sie im Inneren einen neuen Serverblock direkt über dem bereits vorhandenen Serverblock: 

http {
    . . .

    include /etc/nginx/conf.d/*.conf;

    server {
    }

    server {
        listen 80 default_server;

        . . .

Wir werden die gesamte Konfiguration für unsere Django-Anwendung in diesen neuen Block einfügen. 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 werden einige HTTP-Header für die Standard-Proxys festgelegt, damit Gunicorn Informationen über die Remoteclient-Verbindung erhalten kann. Wir leiten den Datenverkehr dann an den Socket weiter, den wir in unserer Gunicorn Systemd-Einheitendatei angegeben haben: 

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 / {
        proxy_set_header Host $http_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-Proto $scheme;
        proxy_pass http://unix:/home/user/myproject/myproject.sock;
    }
}

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

Passen Sie die Gruppenmitgliedschaft und die Berechtigungen an

Der Benutzer vonnginxmuss Zugriff auf unser Anwendungsverzeichnis haben, damit er statische Dateien bereitstellen, auf die Socket-Dateien zugreifen usw. kann. CentOS sperrt das Home-Verzeichnis jedes Benutzers sehr restriktiv, sodass wir den Benutzernginxzur Gruppe unseres Benutzers hinzufügen, damit wir dann die Mindestberechtigungen öffnen können, die erforderlich sind, damit dies funktioniert.

Fügen Sie den Benutzernginxmit dem folgenden Befehl zu Ihrer Gruppe hinzu. Ersetzen Sie dieuser im Befehl durch Ihren eigenen Benutzernamen: 

sudo usermod -a -G user nginx

Jetzt können wir unserer Benutzergruppe Ausführungsberechtigungen für unser Ausgangsverzeichnis erteilen. Auf diese Weise kann der Nginx-Prozess Inhalte in folgenden Bereichen eingeben und darauf zugreifen: 

chmod 710 /home/user

Mit den eingerichteten Berechtigungen können wir unsere Nginx-Konfigurationsdatei auf Syntaxfehler testen: 

sudo nginx -t

Wenn keine Fehler vorliegen, starten Sie den Nginx-Dienst neu, indem Sie Folgendes eingeben: 

sudo systemctl start nginx

Weisen Sie das init-System an, den Nginx-Server beim Booten zu starten, indem Sie Folgendes eingeben: 

sudo systemctl enable nginx

Sie sollten nun über den Domainnamen oder die IP-Adresse Ihres Servers Zugriff auf Ihre Django-Anwendung in Ihrem Browser haben, ohne einen Port anzugeben.

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