TOC

Wie man Django mit Postgres, Nginx und Gunicorn unter Debian 8 einrichtet

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 werden wir zeigen, wie einige Komponenten auf Debian 8 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 Debian 8-Serverinstanz mit einem Nicht-Root-Benutzer haben, der über die Berechtigung "+ sudo +" verfügt. Informationen zum Einrichten finden Sie in unserem initial server setup guide.

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 Debian-Repositories

Zu Beginn des Prozesses werden wir alle benötigten Elemente aus den Debian-Repositories herunterladen und installieren. Wir werden den Python-Paketmanager + pip + verwenden, um zusätzliche Komponenten etwas später zu installieren.

Wir müssen den lokalen "+ apt +" - Paketindex aktualisieren und dann die Pakete herunterladen und installieren. Welche Pakete wir installieren, hängt davon ab, welche Python-Version Ihr Projekt verwenden wird.

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

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

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

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

Dadurch werden + pip +, die Python-Entwicklungsdateien, die für die spätere Erstellung von Gunicorn benötigt werden, das Postgres-Datenbanksystem und die Bibliotheken, die für die Interaktion erforderlich sind, 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.

Standardmäßig verwendet Postgres ein Authentifizierungsschema mit der Bezeichnung "Peer-Authentifizierung" für lokale Verbindungen. Grundsätzlich bedeutet dies, dass sich der Benutzer ohne weitere Authentifizierung anmelden kann, wenn der Benutzername des Betriebssystems des Benutzers mit einem gültigen Postgres-Benutzernamen übereinstimmt.

Während der Postgres-Installation wurde ein Betriebssystembenutzer mit dem Namen "+ postgres " erstellt, der dem administrativen Benutzer " postgres " PostgreSQL entspricht. Wir müssen diesen Benutzer verwenden, um administrative Aufgaben auszuführen. Wir können sudo verwenden und den Benutzernamen mit der Option " -u +" übergeben.

Melden Sie sich bei einer interaktiven Postgres-Sitzung an, indem Sie Folgendes eingeben:

sudo -u postgres psql

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

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

Note

CREATE DATABASE ;
OutputCREATE DATABASE

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

CREATE USER  WITH PASSWORD '';
OutputCREATE ROLE

Als Nächstes ändern wir einige der Verbindungsparameter für den soeben erstellten Benutzer. Dies beschleunigt die Datenbankoperationen, sodass nicht bei jedem Verbindungsaufbau die richtigen Werte abgefragt und eingestellt werden müssen.

Wir setzen die Standardkodierung auf UTF-8, was Django erwartet. Wir setzen außerdem das Standard-Transaktionsisolationsschema auf "read commit", wodurch Lesevorgänge für nicht festgeschriebene Transaktionen blockiert werden. Zuletzt stellen wir die Zeitzone ein. Standardmäßig verwenden Ihre Django-Projekte "+ UTC". Dies sind alles Empfehlungen von das Django-Projekt selbst:

ALTER ROLE  SET client_encoding TO 'utf8';
ALTER ROLE  SET default_transaction_isolation TO 'read committed';
ALTER ROLE  SET timezone TO 'UTC';
OutputALTER ROLE
ALTER ROLE
ALTER ROLE

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

GRANT ALL PRIVILEGES ON DATABASE  TO ;
OutputGRANT

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

\q

Sie sollten zu Ihrer Shell-Sitzung zurückkehren.

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

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

Dazu benötigen wir zunächst den Befehl "+ virtualenv". Wir können dies mit + pip + installieren.

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 und verschieben Sie es in ein Verzeichnis, in dem wir unsere Projektdateien aufbewahren können:

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 bei aktivierter virtueller Umgebung Django, Gunicorn und den PostgreSQL-Adapter + psycopg2 + mit der lokalen Instanz von + pip +:

Note

pip install django gunicorn psycopg2

Diese Komponenten werden in unserer virtuellen Umgebung installiert und von unseren globalen Paketen isoliert.

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. Wir können jetzt ein Django-Projekt in unserem + myproject + Verzeichnis starten. Dadurch wird ein gleichnamiges untergeordnetes Verzeichnis erstellt, in dem sich der Code selbst befindet, und im aktuellen Verzeichnis wird ein Verwaltungsskript erstellt:

django-admin.py startproject  .

Ihre aktuelle Verzeichnisstruktur sollte ungefähr so ​​aussehen:

.
└── ./myproject/
   ├── manage.py
   ├── myproject/
   │   ├── __init__.py
   │   ├── settings.py
   │   ├── urls.py
   │   └── wsgi.py
   └── venv/
       └── . . .

Wie Sie sehen, haben wir ein übergeordnetes Projektverzeichnis, das ein Skript "+ manage.py" enthält, ein inneres Projektverzeichnis und das virtuelle Umgebungsverzeichnis "+ venv", das wir zuvor erstellt haben.

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 ~///settings.py

Suchen Sie zunächst die Direktive + ALLOWED_HOSTS +. Dies definiert eine Whitelist mit Adressen oder Domänennamen, die zum Herstellen einer Verbindung mit der Django-Instanz verwendet werden können. Alle eingehenden Anforderungen mit einem * Host * -Header, der nicht in dieser Liste enthalten ist, lösen eine Ausnahme aus. Django erfordert, dass Sie dies einstellen, um eine bestimmte Sicherheitslücke zu vermeiden.

Listen Sie in den eckigen Klammern die IP-Adressen oder Domänennamen auf, die Ihrem Django-Server zugeordnet sind. Jeder Artikel sollte in Anführungszeichen * mit durch Komma * getrennten Einträgen * aufgeführt werden. Wenn Sie auf Anfragen nach einer Domain und Subdomains antworten möchten, stellen Sie einen Punkt vor den Anfang des Eintrags. Im folgenden Snippet sind einige Beispiele auskommentiert, um die korrekte Formatierung von Einträgen zu demonstrieren:

~ / myproject / myproject / settings.py

. . .
# The simplest case: just add the domain name(s) and IP addresses of your Django server
# ALLOWED_HOSTS = [ 'example.com', '203.0.113.5']
# To respond to 'example.com' and any subdomains, start the domain with a dot
# ALLOWED_HOSTS = ['.example.com', '203.0.113.5']
ALLOWED_HOSTS = ['', '', ]

Suchen Sie als Nächstes den Abschnitt, der den Datenbankzugriff konfiguriert. Es beginnt mit + DATABASES +. 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 Adapter "+ psycopg2 " zu verwenden, den wir mit " pip " installiert haben. Wir müssen den Datenbanknamen, den Datenbankbenutzernamen und das Kennwort des Datenbankbenutzers angeben und dann angeben, dass sich die Datenbank auf dem lokalen Computer befindet. Sie können die Einstellung " PORT +" als leere Zeichenfolge belassen:

~ / myproject / myproject / settings.py

. . .

DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.',
       'NAME': '',
       'USER': '',
       '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 mit dem Namen "+ static +" im Basisprojektverzeichnis abzulegen:

~ / 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 PostgreSQL-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 dann in einem Verzeichnis mit dem Namen "+ static +" 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://:8000

Sie sollten die Standard-Django-Indexseite sehen:

Bild: https://assets.digitalocean.com/articles/django_gunicorn_nginx_1404/django_index.png [Django-Indexseite]

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_gunicorn_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_gunicorn_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.

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 ~/
gunicorn --bind 0.0.0.0:8000 .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.

Wir haben Gunicorn ein Modul übergeben, indem wir den relativen Verzeichnispfad zu Djangos "+ wsgi.py " - Datei, die der Einstiegspunkt für unsere Anwendung ist, mithilfe der Modulsyntax von Python angegeben haben. In dieser Datei ist eine Funktion mit dem Namen " application +" definiert, die für die Kommunikation mit der Anwendung verwendet wird. Weitere Informationen zur WSGI-Spezifikation 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 [hier].

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

Das Präfix für die virtuelle Umgebung sollte aus Ihrer Shell-Eingabeaufforderung entfernt werden, um anzuzeigen, dass Sie sich nicht mehr in der virtuellen Umgebung befinden.

Erstellen Sie eine Gunicorn System- und 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 Rechten "+ sudo +" in 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:

/etc/systemd/system/gunicorn.service

[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 Gruppe " www-data" den Besitz einer Gruppe, damit Nginx 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:

/etc/systemd/system/gunicorn.service

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

[Service]
User=
Group=www-data
WorkingDirectory=/home//
ExecStart=/home////bin/gunicorn --workers 3 --bind unix:/home///.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 Booten gestartet werden kann. Wir möchten, dass dieser Dienst gestartet wird, wenn das reguläre Mehrbenutzersystem ausgeführt wird:

/etc/systemd/system/gunicorn.service

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

[Service]
User=
Group=www-data
WorkingDirectory=/home//
ExecStart=/home////bin/gunicorn --workers 3 --bind unix:/home///.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
OutputCreated symlink from /etc/systemd/system/multi-user.target.wants/gunicorn.service to /etc/systemd/system/gunicorn.service.

Überprüfen Sie den Status des Dienstes, indem Sie Folgendes eingeben:

sudo systemctl status gunicorn
Output● gunicorn.service - gunicorn daemon
  Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled)
   since Wed 2016-12-21 21:05:07 UTC; 49s ago
Main PID: 10154 (gunicorn)
  CGroup: /system.slice/gunicorn.service
          ├─10154 /home/sammy/myproject/venv/bin/python3 /home/sammy/myproject/venv/bin/gunicorn --workers 3 --bind unix:/home/sammy/myproject/myproject.sock myproject.wsgi:application
          ├─10157 /home/sammy/myproject/venv/bin/python3 /home/sammy/myproject/venv/bin/gunicorn --workers 3 --bind unix:/home/sammy/myproject/myproject.sock myproject.wsgi:application
          ├─10158 /home/sammy/myproject/venv/bin/python3 /home/sammy/myproject/venv/bin/gunicorn --workers 3 --bind unix:/home/sammy/myproject/myproject.sock myproject.wsgi:application
          └─10159 /home/sammy/myproject/venv/bin/python3 /home/sammy/myproject/venv/bin/gunicorn --workers 3 --bind unix:/home/sammy/myproject/myproject.sock myproject.wsgi:application

Dec 21 21:05:07 debian-512mb-nyc3-01 systemd[1]: Started gunicorn daemon.
Dec 21 21:05:07 debian-512mb-nyc3-01 gunicorn[10154]: [2016-12-21 21:05:07 +0000] [10154] [INFO] Starting gunicorn 19.6.0
Dec 21 21:05:07 debian-512mb-nyc3-01 gunicorn[10154]: [2016-12-21 21:05:07 +0000] [10154] [INFO] Listening at: unix:/home/sammy/myproject/myproject.sock (10154)
Dec 21 21:05:07 debian-512mb-nyc3-01 gunicorn[10154]: [2016-12-21 21:05:07 +0000] [10154] [INFO] Using worker: sync
Dec 21 21:05:07 debian-512mb-nyc3-01 gunicorn[10154]: [2016-12-21 21:05:07 +0000] [10157] [INFO] Booting worker with pid: 10157
Dec 21 21:05:07 debian-512mb-nyc3-01 gunicorn[10154]: [2016-12-21 21:05:07 +0000] [10158] [INFO] Booting worker with pid: 10158
Dec 21 21:05:07 debian-512mb-nyc3-01 gunicorn[10154]: [2016-12-21 21:05:07 +0000] [10159] [INFO] Booting worker with pid: 10159

Das Wichtigste ist, dass das Gerät aktiv ist.

Dies ist jetzt auch ein guter Zeitpunkt, um zu überprüfen, ob die Socket-Datei erstellt wurde. Wenn Sie den Inhalt Ihres "+ ~ / +" -Verzeichnisses auflisten, sollten Sie die Unix-Socket-Datei sehen:

ls -l ~/
Outputtotal 16
-rwxr-xr-x 1 sammy sammy     807 Dec 21 20:46 manage.py
drwxr-xr-x 3 sammy sammy    4096 Dec 21 20:54 myproject

drwxr-xr-x 3 sammy sammy    4096 Dec 21 20:54 static
drwxr-xr-x 5 sammy sammy    4096 Dec 21 20:41 venv

Wie Sie sehen, befindet sich der Socket dort und die Gruppe "+ www-data" hat Gruppeneigentum.

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 im Verzeichnis "+ sites-available +" von Nginx:

sudo nano /etc/nginx/sites-available/

Ö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:

/ etc / nginx / sites-available / myproject

server {
   listen 80;
   server_name ;
}

Als nächstes können wir Nginx anweisen, Fehler zu ignorieren, wenn kein Favicon gefunden wird. Wir werden ihm auch mitteilen, wo sich die statischen Assets befinden, die wir in unserem + ~ // static + - Verzeichnis gesammelt haben. Alle diese Dateien haben das Standard-URI-Präfix "/ static", sodass wir einen Standortblock erstellen können, der diesen Anforderungen entspricht:

/ etc / nginx / sites-available / myproject

server {
   listen 80;
   server_name ;

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

Schließlich erstellen wir einen "+ location / {} " - Block, der allen anderen Anforderungen entspricht. Innerhalb dieses Speicherorts wird die Standarddatei " proxy_params +" eingefügt, die in der Nginx-Installation enthalten ist. Anschließend leiten wir den Datenverkehr an den Socket weiter, den unser Gunicorn-Prozess erstellt hat:

/ etc / nginx / sites-available / myproject

server {
   listen 80;
   server_name ;

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

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

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Jetzt können wir die Datei aktivieren, indem wir sie mit dem Verzeichnis + sites-enabled + verknüpfen:

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

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

sudo nginx -t
Outputnginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

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

sudo systemctl restart nginx

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

Note

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