So installierst du das Django Framework unter Debian 11

Django ist ein freies und quelloffenes Webentwicklungs-Framework, das in Python geschrieben ist. Es wird für die Entwicklung komplexer und datenbankgestützter Python-Anwendungen verwendet. Es wird mit einer Reihe von Python-Skripten für die Erstellung von Python-Projekten geliefert. Es kann auf jedem Betriebssystem ausgeführt werden, auf dem Python läuft, einschließlich Windows, macOS, Linux/Unix und Solaris. Es hilft Entwicklern, weniger Code zu schreiben und in kurzer Zeit eine neue Website zu erstellen.

In diesem Tutorial erkläre ich dir, wie du Django in einer virtuellen Python-Umgebung mit einer PostgreSQL-Datenbank unter Debian 11 einrichtest. Anschließend werden wir Nginx als Reverse Proxy für Django installieren und konfigurieren.

Voraussetzungen

  • Ein Server, auf dem Debian 11 läuft.
  • Ein gültiger Domainname, der auf die IP deines Servers zeigt.
  • Ein Root-Passwort ist auf dem Server konfiguriert.

Erste Schritte

Bevor du beginnst, solltest du deine Systempakete auf die neueste Version aktualisieren. Das kannst du mit dem folgenden Befehl tun:

apt-get update -y

Sobald alle Pakete aktualisiert sind, installierst du andere Python-Tools und das Nginx-Paket mit dem folgenden Befehl:

apt-get install python3-pip python3-dev libpq-dev curl nginx -y

Wenn alle erforderlichen Pakete installiert sind, kannst du mit dem nächsten Schritt fortfahren.

PostgreSQL Datenbankserver installieren

Hier werden wir PostgreSQL als Datenbank-Backend verwenden. Also installieren wir ihn mit dem folgenden Befehl:

apt-get install postgresql postgresql-contrib -y

Sobald PostgreSQL installiert ist, verbindest du dich mit folgendem Befehl mit der PostgreSQL-Shell:

su - postgres
psql

Als Nächstes erstellst du eine Datenbank und einen Benutzer für Django mit dem folgenden Befehl:

CREATE DATABASE django;
CREATE USER django WITH PASSWORD 'password';

Als Nächstes erteilst du mit dem folgenden Befehl einige erforderliche Rollen:

ALTER ROLE django SET client_encoding TO 'utf8';
ALTER ROLE django SET default_transaction_isolation TO 'read committed';
ALTER ROLE django SET timezone TO 'UTC';
GRANT ALL PRIVILEGES ON DATABASE django TO django;

Verlasse die PostgreSQL-Shell mit folgendem Befehl:

\q
exit

Jetzt ist die PostgreSQL-Datenbank bereit für Django. Du kannst nun mit dem nächsten Schritt fortfahren.

Eine virtuelle Python-Umgebung erstellen

Als Nächstes musst du eine virtuelle Python-Umgebung erstellen, um ein Django-Projekt zu erstellen.

Aktualisiere zunächst das PIP-Paket mit dem folgenden Befehl auf die neueste Version:

pip3 install --upgrade pip

Als Nächstes überprüfst du die PIP-Version mit folgendem Befehl:

pip --version

Beispielhafte Ausgabe:

pip 21.2.4 from /usr/local/lib/python3.9/dist-packages/pip (python 3.9)

Als Nächstes installierst du das Paket Virtuelle Umgebung mit dem folgenden Befehl:

pip3 install virtualenv

Als Nächstes legst du ein Verzeichnis für das Django-Projekt an und erstellst eine virtuelle Django-Umgebung:

mkdir ~/djangoapp
cd ~/djangoapp
virtualenv djangoenv

Aktiviere die virtuelle Django-Umgebung mit dem folgenden Befehl:

source djangoenv/bin/activate

Als Nächstes installierst du die Pakete Django, Gunicorn und andere mit folgendem Befehl:

pip install django gunicorn psycopg2-binary

Jetzt ist Django in der virtuellen Python-Umgebung installiert. Jetzt kannst du mit dem nächsten Schritt fortfahren.

Django installieren und konfigurieren

Django stellt ein Skript django-admin.py zur Verfügung, um ein Projekt zu erstellen. Du kannst den folgenden Befehl ausführen, um ein Django-Projekt zu erstellen:

django-admin.py startproject djangoapp ~/djangoapp

Als Nächstes musst du die Datei settings.py bearbeiten und deine Datenbankeinstellungen festlegen:

nano ~/djangoapp/djangoapp/settings.py

Ändere die folgende Zeile mit deinem Domainnamen:

ALLOWED_HOSTS = ['django.example.com', 'localhost']

Entferne das Kommentarzeichen für das Standard-Datenbank-Backend und füge die PostgreSQL-Datenbankeinstellungen hinzu:

#DATABASES = {
#    'default': {
#        'ENGINE': 'django.db.backends.sqlite3',
#        'NAME': BASE_DIR / 'db.sqlite3',
#    }
#}

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

    }
}

Füge die folgenden Zeilen am Ende der Datei hinzu:

STATIC_URL = '/static/'
import os
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Speichere und schließe die Datei und migriere das ursprüngliche Datenbankschema in die PostgreSQL-Datenbank:

./manage.py makemigrations
./manage.py migrate

Beispiel outputL:

  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK

Als Nächstes erstellst du ein Superuser-Konto für Django mit dem folgenden Befehl:

./manage.py createsuperuser

Lege deinen Admin-Benutzernamen und dein Passwort wie unten gezeigt fest:

Username (leave blank to use 'root'): dadmin
Email address: [email protected]
Password: 
Password (again): 
Superuser created successfully.

Als Nächstes sammelst du alle statischen Inhalte in dem Verzeichnis:

./manage.py collectstatic

Starten Sie den Django Development Server

Jetzt ist Django installiert und konfiguriert. Jetzt kannst du den Django-Entwicklungsserver mit dem folgenden Befehl starten:

./manage.py runserver 0.0.0.0:8000

Wenn alles in Ordnung ist, solltest du die folgende Ausgabe erhalten:

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
August 27, 2021 - 10:02:05
Django version 3.2.6, using settings 'djangoapp.settings'
Starting development server at http://0.0.0.0:8000/
Quit the server with CONTROL-C.

Öffne nun deinen Webbrowser und rufe dein Django-Projekt über die URL http://django.example.com:8000/admin/ auf. Du wirst auf die Anmeldeseite von Django weitergeleitet:

Django Anmeldung

Gib deinen Admin-Benutzernamen und dein Passwort ein und klicke auf “ Login“. Auf der folgenden Seite solltest du das Django-Dashboard sehen:

Django Admin Dashboard

Gehe nun zurück zu deinem Terminal und drücke die Tastenkombination STRG + C, um den Django-Entwicklungsserver zu beenden.

Django mit Gunicorn verifizieren

Als Nächstes musst du testen, ob Gunicorn Django bedienen kann oder nicht. Du kannst Django mit dem Gunicorn-Server mit dem folgenden Befehl starten:

gunicorn --bind 0.0.0.0:8000 djangoapp.wsgi

Wenn alles in Ordnung ist, solltest du die folgende Ausgabe erhalten:

[2021-08-27 10:04:22 +0000] [47383] [INFO] Starting gunicorn 20.1.0
[2021-08-27 10:04:22 +0000] [47383] [INFO] Listening at: http://0.0.0.0:8000 (47383)
[2021-08-27 10:04:22 +0000] [47383] [INFO] Using worker: sync
[2021-08-27 10:04:22 +0000] [47384] [INFO] Booting worker with pid: 47384

Drücke STRG + C, um den Gunicorn-Server zu beenden.

Als Nächstes deaktivierst du die virtuelle Python-Umgebung mit folgendem Befehl:

deactivate

Erstelle eine Systemd-Dienstdatei für Gunicorn

Als Nächstes musst du eine systemd-Dienstdatei für Gunicorn erstellen, um den Django-Anwendungsserver zu starten und zu stoppen.

Du kannst einen Gunicorn mit folgendem Befehl erstellen:

nano /etc/systemd/system/gunicorn.socket

Füge die folgenden Zeilen ein:

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Speichere und schließe die Datei und erstelle dann eine Servicedatei für Gunicorn:

nano /etc/systemd/system/gunicorn.service

Füge die folgenden Zeilen hinzu, die mit dem Pfad deines Django-Projekts übereinstimmen:

[Unit]
Description=gunicorn daemon
Requires=gunicorn.socket
After=network.target
[Service]
User=root
Group=www-data
WorkingDirectory=/root/djangoapp
ExecStart=/root/djangoapp/djangoenv/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock          djangoapp.wsgi:application

[Install]
WantedBy=multi-user.target

Speichere und schließe die Datei und setze dann die richtigen Rechte für das Django-Projektverzeichnis:

chown -R www-data:root ~/djangoapp

Als Nächstes lädst du den systemd-Daemon mit dem folgenden Befehl neu:

systemctl daemon-reload

Starte als Nächstes den Gunicorn-Dienst und aktiviere ihn so, dass er beim Neustart des Systems startet:

systemctl start gunicorn.socket
systemctl enable gunicorn.socket

Als Nächstes überprüfst du den Status von Gunicorn mit dem folgenden Befehl:

systemctl status gunicorn.socket

Du solltest die folgende Ausgabe erhalten:

? gunicorn.socket - gunicorn socket
     Loaded: loaded (/etc/systemd/system/gunicorn.socket; disabled; vendor preset: enabled)
     Active: active (listening) since Fri 2021-08-27 10:05:46 UTC; 6s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Aug 27 10:05:46 debian11 systemd[1]: Listening on gunicorn socket.

Nginx als Reverse Proxy für Django konfigurieren

Als Nächstes musst du Nginx als Reverse Proxy konfigurieren, um Django zu bedienen.

Dazu erstellst du eine Nginx-Konfigurationsdatei:

nano /etc/nginx/conf.d/django.conf

Füge die folgenden Zeilen ein:

server {
     listen 80;
     server_name django.example.com;
    location = /favicon.ico { access_log off; log_not_found off; }


    location /static/ {
         root /root/djangoapp;
     }

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

Speichere und schließe die Datei und überprüfe Nginx auf Konfigurationsfehler:

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

Starte schließlich den Nginx-Dienst neu, um die Änderungen zu übernehmen:

systemctl restart nginx

Um den Status von Nginx zu überprüfen, führe aus:

systemctl status nginx

Beispielhafte Ausgabe:

? nginx.service - A high performance web server and a reverse proxy server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; vendor preset: enabled)
     Active: active (running) since Fri 2021-08-27 10:06:59 UTC; 6s ago
       Docs: man:nginx(8)
    Process: 47494 ExecStartPre=/usr/sbin/nginx -t -q -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
    Process: 47495 ExecStart=/usr/sbin/nginx -g daemon on; master_process on; (code=exited, status=0/SUCCESS)
   Main PID: 47496 (nginx)
      Tasks: 2 (limit: 2341)
     Memory: 2.5M
        CPU: 49ms
     CGroup: /system.slice/nginx.service
             ??47496 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
             ??47497 nginx: worker process

Aug 27 10:06:59 debian11 systemd[1]: Starting A high performance web server and a reverse proxy server...
Aug 27 10:06:59 debian11 systemd[1]: nginx.service: Failed to parse PID from file /run/nginx.pid: Invalid argument
Aug 27 10:06:59 debian11 systemd[1]: Started A high performance web server and a reverse proxy server.

Jetzt kannst du die Django-Anwendung über die URL http://django.example.com/admin aufrufen. Du kannst auch über die URL http://django.example.com/ auf die Django-Anwendung zugreifen.

Django-Anwendung

Fazit

Glückwunsch! Du hast erfolgreich eine Django-Anwendung mit Gunicorn und Nginx als Reverse Proxy installiert. Du kannst jetzt damit beginnen, deine Python-Anwendung mit dem Django-Framework einzusetzen.

Das könnte dich auch interessieren …