Wie man Django mit PostgreSQL und Nginx auf Ubuntu 16.04 installiert
Django ist ein kostenloses Open-Source-Web-Framework auf Basis von Python. Es handelt sich um ein High-Level-Python-Web-Framework mit einem MVT (Model-View-Template) Architekturmuster. Django wird von der Django Software Foundation (DSF) verwaltet. Das Django Web-Framework ist schnell, es hilft Entwicklern, Anwendungen schnell zu erstellen (RAD).
In diesem Tutorial zeige ich Ihnen, wie Sie das Django Web-Framework installieren und so konfigurieren, dass es eine PostgreSQL-Datenbank für die Entwicklung verwendet. Wir werden Nginx aus Geschwindigkeits- und Sicherheitsgründen als Reverse-Proxy für das Django-Web-Framework einsetzen. Django wird unter dem python WSGI HTTP-Server ‚Gunicorn‘ laufen, wir werden ‚Gunicorn‘ mit ‚Supervisor‘ als Prozessleitsystem verwalten und kontrollieren.
Voraussetzung
- Ubuntu 16.04.
- Root-Privilegien
Schritt 1 – Installieren Sie Django, Virtualenv und Gunicorn.
Ich werde python3 als Standard-Python-Version für das System verwenden. Wir werden python3 und pip3 auf Ubuntu 16.04 installieren. Pip3 ist ein Paketmanagementsystem zur Installation und Verwaltung von in Python geschriebenen Softwarepaketen.
Verbinden Sie sich mit Ihrem Server als Root-Benutzer auf dem Terminal oder per SSH (wie ich es hier mache) und aktualisieren Sie das Ubuntu-Repository:
ssh root@192.168.1.115 sudo apt-get update
Installiere python3 und pip3 mit diesem apt-Befehl:
sudo apt-get install python3-pip python3-dev
Erstellen Sie einen neuen Symlink für den Befehl pip3, um ihn als „pip“ anstelle von „pip3“ verwenden zu können und aktualisieren Sie ihn:
ln -s /usr/bin/pip3 /usr/bin/pip pip install --upgrade pip
Als nächstes installieren Sie die benötigten Python-Pakete mit dem Befehl pip. Ich werde hier Django, Virtualenv und Gunicorn installieren:
pip install django virtualenv gunicorn
Schritt 2 – Installation und Konfiguration von PostgreSQL
Wir werden PostgreSQL als Datenbank für unser Django-Projekt verwenden. Installieren Sie PostgreSQL mit diesem apt-Befehl.
sudo apt-get install postgresql postgresql-contrib libpq-dev
Wenn die Installation abgeschlossen ist, installieren Sie das neue Python-Paket namens’psycopg2′ mit pip. Es ist der Python-postgreSQL-Datenbankadapter.
pip install psycopg2
Greifen Sie nun auf den postgres-Benutzer zu und öffnen Sie die PostgreSQL-Shell mit dem Befehl psql:
su - postgres psql
Setzt ein neues Passwort für den postgres-Benutzer mit dem folgenden Befehl:
\password postgres Enter new password:
Als nächstes erstellen Sie eine neue Datenbank und einen neuen Benutzer/Rolle für das Django-Projekt in PostgreSQL. Ich werde neue Datenbanken namens’django_db‘ mit Benutzer/Rolle’python_dev‘ erstellen. Geben Sie den Befehl unten in der PostgreSQL-Shell ein.
CREATE USER python_dev WITH PASSWORD 'aqwe123'; CREATE DATABASE django_db OWNER python_dev;
Siehe die Liste der Datenbanken und die Rolle:
\list
Schritt 3 – Neues Django-Projekt starten
Starten Sie das erste Django-Projekt mit dem Namen’hello_django‘. Wir werden keine Root-Rechte für das Projekt verwenden, ich werde einen normalen Linux-Benutzer ’natsume‘ für das Projekt verwenden. Du kannst gerne einen anderen Benutzernamen verwenden, der dein Projekt beschreibt.
Einen neuen Benutzer anlegen
Erstellen Sie einen neuen Linux-Benutzer mit dem folgenden Befehl:
useradd -m -s /bin/bash natsume passwd natsume
m = Automatisches Erstellen des Home-Verzeichnisses.
s = Definiert die Standard-Shell für den Benutzer.
Neue Virtualenv erstellen und Django installieren
Melden Sie sich beim natsume Benutzer an:
su - natsume
Erstellen Sie eine neue virtuelle Umgebung im Verzeichnis ‚myproject‘ für unser Django-Projekt mit python3 als Standard-Python-Version.
mkdir myproject virtualenv --python=python3 myproject/
Gehen Sie in das Verzeichnis’myproject‘ und aktivieren Sie den virtualenv.
cd myproject/ source bin/activate
Als nächstes installieren Sie Django, gunicorn und psycopg2 mit pip-Befehl in dieser Umgebung.
pip install django gunicorn psycopg2
Neues Projekt mit PostgreSQL starten
Starten Sie das Django-Projekt’hello_django‘ mit dem Befehl django-admin unten:
django-admin startproject hello_django
Es wird ein neues Verzeichnis’hello_django‘ erstellt, in dieses Verzeichnis gehen und die Konfigurationsdatei’setting.py‘ mit vim bearbeiten.
cd hello_django/ vim hello_django/settings.py
Ändern Sie die Datenbankeinstellungen auf Zeile 76 mit der folgenden Konfiguration:
'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'django_db', 'USER': 'python_dev', 'PASSWORD': 'aqwe123', 'HOST': 'localhost', 'PORT': '',
Konfigurieren Sie am Ende der Datei die statische URL, indem Sie die untenstehende Konfigurationszeile STATIC_ROOT hinzufügen:
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')
Speichern und beenden.
Als nächstes migrieren Sie die Datenbank in unsere PostgreSQL-Datenbank und erstellen Sie einen neuen Admin-Benutzer. Sammle dann alle statischen Dateien in dem statischen Verzeichnis, das automatisch erstellt wird, wenn wir den Befehl ausführen.
python manage.py migrate python manage.py createsuperuser python manage.py collectstatic
Stellen Sie sicher, dass kein Fehler vorliegt und führen Sie einen Testlauf des Django-Projektservers mit dem Befehl runserver durch.
python manage.py runserver 0.0.0.0:8080
Öffnen Sie Ihren Webbrowser und besuchen Sie die Server-IP-Adresse auf Port 8080, in meinem Fall http://192.168.1.115:8080. Sie sehen die Django-Standardseite.
Drücken Sie Strg + c, um das Menü zu verlassen.
Schritt 4 – Konfigurieren des Django-Projekts mit Gunicorn
Gunicorn oder Green Unicorn ist ein Python WSGI HTTP Server, der aus dem Ruby Unicorn Projekt stammt. Es unterstützt verschiedene Web-Frameworks und ist einfach zu konfigurieren.
Gehen Sie in das Verzeichnis’myproject‘ und aktivieren Sie die virtuelle Umgebung für das Heimatverzeichnis des natsume Benutzers.
cd ~/myproject/ source bin/activate
Erstellen Sie eine neue Datei ‚gunicorn_start‘ im bin-Verzeichnis mit vim:
vim bin/gunicorn_start
Füge die Konfiguration unten ein:
#!/bin/bash
# Project Name
NAME="hello_django"
# Django Project Directory
DJANGODIR=/home/natsume/myproject/hello_django
# Run gunicorn on the socket file
SOCKFILE=/home/natsume/myproject/hello_django/run/gunicorn.sock
# Gunicorn running as user and group
USER=natsume
GROUP=natsume
# Workers
NUM_WORKERS=3
#Module Setting
#replace hello_django with your project name
DJANGO_SETTINGS_MODULE=hello_django.settings
DJANGO_WSGI_MODULE=hello_django.wsgi
echo "Starting $NAME as `whoami`"
# Activate the virtual environment
cd $DJANGODIR
source ../bin/activate
export DJANGO_SETTINGS_MODULE=$DJANGO_SETTINGS_MODULE
export PYTHONPATH=$DJANGODIR:$PYTHONPATH
# Create the run directory if it doesn't exist
RUNDIR=$(dirname $SOCKFILE)
test -d $RUNDIR || mkdir -p $RUNDIR
# Start your Django Unicorn
# Programs meant to be run under supervisor should not daemonize themselves (do not use --daemon)
exec ../bin/gunicorn ${DJANGO_WSGI_MODULE}:application \
--name $NAME \
--workers $NUM_WORKERS \
--user=$USER --group=$GROUP \
--bind=unix:$SOCKFILE \
--log-level=debug \
--log-file=-Speichern und beenden.
Machen Sie die Datei mit dem Befehl chmod ausführbar.
chmod u+x bin/gunicorn_start
Schritt 5 – Installation und Konfiguration des Supervisors
Supervisor ist ein Prozessleitsystem für Linux-Betriebssysteme. Es ermöglicht die Konfiguration, Überwachung und Kontrolle einer Reihe von Prozessen unter Linux. Der Supervisor basiert auf Python, wir können ihn aus dem Python-Repository pypi mit dem Befehl pip oder aus dem Ubuntu-Repository mit apt installieren.
Ich werde den Supervisor mit diesem apt-Befehl installieren:
sudo apt-get install supervisor
Der Supervisor hat eine Standardkonfigurationsdatei im Verzeichnis’/ect/supervisor/‘. Gehen Sie zu diesem Verzeichnis und erstellen Sie eine neue Konfiguration für unser Django-Projekt, damit wir es mit dem Supervisor steuern können.
cd /etc/supervisor/conf.d/ vim hello-django.conf
Fügen Sie die untenstehende Supervisor-Konfiguration ein:
[program:hello_django] command = sh /home/natsume/myproject/bin/gunicorn_start user = natsume stdout_logfile = /home/natsume/myproject/logs/gunicorn_supervisor.log redirect_stderr = true environment=LANG=en_US.UTF-8,LC_ALL=en_US.UTF-8
Speichern und beenden.
Als nächstes melden Sie sich beim natsume-Benutzer an und erstellen Sie einige Verzeichnisse, die für die gunicorn socket file und die supervisor log file benötigt werden.
su - natsume
# Directory for gunicorn sock file
mkdir -p myproject/hello_django/run/
# Directory and file for supervisor log files
mkdir -p myproject/logs/
touch myproject/logs/gunicorn_supervisor.log
Zurück zum Root-Benutzer mit „exit“ und starten Sie Supervisor:
exit systemctl start supervisor
Überprüfen Sie den Status und das Protokoll des Prozesses:
supervisorctl tail -f hello_django
Schritt 6 – Nginx für das Django-Projekt installieren und konfigurieren
In diesem Schritt werden wir Nginx installieren und als Reverse-Proxy für unser Django-Projekt konfigurieren.
Installieren Sie Nginx aus dem Ubuntu-Repository:
sudo apt-get install nginx
Gehen Sie zum Nginx Virtual Host Konfigurationsverzeichnis und erstellen Sie eine hello_django Virtual Host Datei:
cd /etc/nginx/sites-available/ vim hello_django
Füge die Konfiguration unten ein:
# Django running with Gunicorn Sock file
upstream hello_django_project {
server unix:/home/natsume/myproject/hello_django/run/gunicorn.sock fail_timeout=0;
}
server {
listen 80;
server_name www.django-nginx.com;
client_max_body_size 4G;
access_log /home/natsume/myproject/logs/nginx-access.log;
error_log /home/natsume/myproject/logs/nginx-error.log;
location /static/ {
alias /home/natsume/myproject/hello_django/static/;
}
location /media/ {
alias /home/natsume/myproject/hello_django/media/;
}
location / {
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;
# Try to serve static files from nginx, no point in making an
# *application* server like Unicorn/Rainbows! serve static files.
if (!-f $request_filename) {
proxy_pass http://hello_django_project;
break;
}
# Error pages
error_page 500 502 503 504 /500.html;
location = /500.html {
root /home/natsume/myproject/hello_django/static/;
}
}
}Speichern und beenden.
Aktivieren Sie den virtuellen Host und testen Sie die Nginx-Konfiguration.
ln -s /etc/nginx/sites-available/hello_django /etc/nginx/sites-enabled/ nginx -t
Stellen Sie sicher, dass kein Fehler vorliegt, und starten Sie dann Nginx neu:
systemctl restart nginx
Schritt 7 – Django testen
In Schritt 5 haben wir einen virtuellen Host für unser Django-Projekt mit dem Domainnamen’www.django-nginx.com‘ erstellt. Öffnen Sie Ihren Browser und besuchen Sie den Domainnamen, den Sie für Ihr Projekt gewählt haben.
www.django-nginx.com/admin/
Sie werden dann zum Django-Administrations-Dashboard weitergeleitet.
Überprüfen Sie, ob alle Dienste, die wir eingerichtet haben, mit dem Befehl unten ausgeführt werden:
netstat -pl
Sie sehen die pid-, port und sock-Datei, die von allen Diensten verwendet wird.
Die Django-Installation und -Konfiguration mit PostgreSQL und Nginx auf Ubuntu 16.04 war erfolgreich.