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

Installieren Sie Django, Gunicorn und Virtualenv mit pip.

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

Konfiguriert PostgreSQL für Django.

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

Virtualenv für Django konfigurieren

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

Migration der Django-Datenbank nach PostgreSQL

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.

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

Betriebs- und Überwachungsaufsicht

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.

Django, der hinter einem Nginx-Proxy läuft.

www.django-nginx.com/admin/

Das Django-Administrator-Login

Sie werden dann zum Django-Administrations-Dashboard weitergeleitet.

Das Django Admin Dashboard

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

Überprüfen Sie, ob alle Dienste ausgeführt werden.

Die Django-Installation und -Konfiguration mit PostgreSQL und Nginx auf Ubuntu 16.04 war erfolgreich.

Links

Das könnte Dich auch interessieren …