Anleitung zur Installation des Django Web Frameworks unter Debian 12

Django ist ein kostenloses und quelloffenes Python-Webframework, das für die Entwicklung dynamischer Websites und Anwendungen verwendet wird. Es wird für die Entwicklung komplexer und datenbankgestützter Python-Anwendungen verwendet.

Django folgt der MVC-Architektur (Model-View-Controller), die es Entwicklern ermöglicht, weniger Code zu schreiben und eine neue Website in kurzer Zeit zu erstellen. Django kann auf allen Betriebssystemen installiert werden, auf denen Python läuft, darunter Windows, macOS, Linux/Unix und Solaris.

Dieser Leitfaden zeigt dir, wie du das Web-Framework Django auf einem Debian 12-Server installierst. Du beginnst mit Django, indem du dein erstes Django-Projekt mit PostgreSQL als Standarddatenbank, dem Gunicorn WSGI Server und Nginx als Reverse Proxy erstellst.

Voraussetzungen

Um loszulegen, musst du die folgenden Voraussetzungen erfüllen:

• Einen Debian 12 Rechner.
• Einen Nicht-Root-Benutzer mit sudo-Administrator-Rechten.

Installieren der Abhängigkeiten

Im ersten Schritt installierst du die Paketabhängigkeiten für deine Django-Webframework-Installation, dazu gehören die folgenden Pakete

• PostgreSQL-Server: Standardmäßig verwendet Django SQLite. Dieses Beispiel zeigt dir, wie du PostgreSQL als Datenbank für dein Django-Projekt verwenden kannst.
• Supervisor: Das ist ein Prozessmanager, und du wirst deine Django-Anwendung mit Gunicorn und Supervisor ausführen.
• Nginx Webserver: In diesem Beispiel zeige ich dir, wie du Nginx als Reverse Proxy für dein Django-Projekt nutzen kannst. So kannst du dein Django-Projekt über einen lokalen Domainnamen erreichen

Führe zunächst den unten stehenden apt-Befehl aus, um deinen Paketindex zu aktualisieren und aufzufrischen.

sudo apt update

Installiere nun die Paketabhängigkeiten wie die virtuelle Python-Umgebung, den pip-Paketmanager, PostgreSQL und den libpq5-Treiber, Nginx und Supervisor.

sudo apt install build-essential python3-dev python3-pip python3-venv nginx supervisor postgresql libpq5 libpq-dev

Bestätige mit y und fahre mit der Installation fort.

Sobald die Abhängigkeiten installiert sind, führe die folgenden Befehle aus, um die PostgreSQL-, Nginx- und Supervisor-Dienste zu überprüfen und sicherzustellen, dass diese Dienste laufen und aktiviert sind.

Überprüfe den PostgreSQL-Dienst mit dem unten stehenden Befehl.

sudo systemctl is-enabled postgresql
sudo systemctl status postgresql

Wenn PostgreSQL läuft und aktiviert ist, siehst du unten die Ausgabe, die du erhalten solltest.

Überprüfe den Nginx-Dienst mit dem unten stehenden Befehl.

sudo systemctl is-enabled nginx
sudo systemctl status nginx

Wenn Nginx läuft und aktiviert ist, solltest du die folgende Ausgabe erhalten.

Überprüfe schließlich den Supervisor mit dem unten stehenden Befehl.

sudo systemctl is-enabled supervisor
sudo systemctl status supervisor

Du solltest sehen, dass der Supervisor läuft und aktiviert ist.

Installation von Django über Pip

Das Web-Framework Django kann auf verschiedene Arten installiert werden: manuell über Git, über den Python-Paketmanager Pip oder in Kombination mit einer isolierten Umgebung mit dem venv-Modul und Pip. In diesem Beispiel wirst du Django über den Pip-Paketmanager in der isolierten Python-Umgebung installieren.

Melde dich mit dem unten stehenden Befehl bei deinem Benutzer an.

su - username

Erstelle nun ein neues Projektverzeichnis ~/testdjango und wechsle in dieses Verzeichnis.

mkdir -p ~/testdjango; cd ~/testdjango

Als Nächstes führst du den folgenden Befehl aus, um eine neue virtuelle Python-Umgebung namens venv in deinem aktuellen Projektverzeichnis zu erstellen.

python3 -m venv venv

Aktiviere sie dann mit dem unten stehenden Befehl. Sobald die virtuelle Umgebung aktiviert ist, sieht deine aktuelle Eingabeaufforderung wie (venv) bob@hostname: aus.

source venv/bin/activate

In der virtuellen Umgebung venv führst du den folgenden pip-Befehl aus, um das Web-Framework Django zu installieren. Dadurch wird Django in deiner virtuellen Python-Umgebung installiert, nicht systemweit.

pip install django

or

pip install django==4.2.4

Unten wird die Django-Installation ausgeführt.

Überprüfe deine Django-Version, sobald die Installation abgeschlossen ist, indem du den Befehl django-admin ausführst.

django-admin --version

Die folgende Ausgabe bestätigt, dass Django 4.2.4 über den Pip Python-Paketmanager in der virtuellen Umgebung venv installiert ist.

Das erste Django-Projekt erstellen

In diesem Abschnitt lernst du, wie du das erste Django-Projekt erstellst und den PostgreSQL-Server als Standarddatenbank verwendest. Um das zu erreichen, musst du die folgenden Schritte ausführen:

• Datenbank und Benutzer vorbereiten.
• Django-Projekt über django-admin erstellen.
• Datenbank migrieren und statische Dateien erzeugen.
• Admin-Benutzer anlegen und Django starten.

Datenbank und Benutzer vorbereiten

Führe den folgenden pip-Befehl aus, um das Python-Paket psycopg2 in deiner virtuellen Umgebung zu installieren. Dies ist der Python-Treiber, der von Django für die Verbindung mit dem PostgreSQL-Datenbankserver verwendet wird.

pip install psycopg2
exit

Führe nun den folgenden Befehl aus, um dich an der PostgreSQL-Shell anzumelden.

sudo -u postgres psql

Führe die folgenden Abfragen aus, um eine neue Datenbank und einen neuen Benutzer für dein Django-Projekt zu erstellen. Das folgende Beispiel erstellt eine neue Datenbank djangodb, den Benutzer django und das Passwort p4ssw0rd.

CREATE USER django WITH PASSWORD 'p4ssw0rd';
CREATE DATABASE djangodb OWNER django;

Als Nächstes führst du die folgenden Abfragen aus, um die Datenbank und den Benutzer auf deinem PostgreSQL-Server zu überprüfen.

\du
\l

Du solltest sehen, dass die Datenbank djangodb und der Benutzer django erstellt wurden.

Gib quit ein, um den PostgreSQL-Server zu verlassen.

Django-Projekt erstellen

Bevor du das Django-Projekt erstellst, melde dich mit deinem Benutzer an und aktiviere die virtuelle Umgebung venv.

su - bob
cd testdjango; source venv/bin/activate

Um ein neues Django-Projekt zu erstellen, führst du den unten stehenden Befehl django-admin aus. In diesem Fall wirst du ein neues Projekt testapp in deinem aktuellen Arbeitsverzeichnis erstellen.

django-admin startproject testapp .

Sobald das Projekt erstellt ist, wird das neue Verzeichnis testapp in deinem Arbeitsverzeichnis angelegt.

Als Nächstes führst du den folgenden Befehl aus, um ein zufälliges Geheimnis für dein Django-Projekt zu generieren. Achte darauf, dass du die Ausgabe kopierst, denn du wirst sie zur Sicherung deiner Django-Installation verwenden.

python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'

Öffne nun mit deinem bevorzugten Editor die Datei testapp/settings.py.

nano testapp/settings.py

Füge am Anfang der Zeile die folgende Konfiguration ein.

import os

Füge deinen geheimen Schlüssel in den Parameter SECRET_KEY ein.

SECRET_KEY = 'fzahzbm*wrxoleqb0^-3%%tf^y!b6lsc5-c#2^@#s6gkyrl2ef'

Gib deine lokale IP-Adresse und deinen lokalen Domainnamen in den Parameter ALLOWED_HOSTS ein.

ALLOWED_HOSTS = ['127.0.0.1','192.168.10.15','first-django.dev']

Ändere die Standard-Datenbankkonfiguration mit den PostgreSQL-Serverdetails wie folgt:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'djangodb',
        'USER': 'django',
        'PASSWORD': 'p4ssw0rd',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

Zuletzt fügst du den Parameter STATIC_ROOT hinzu, um ein Verzeichnis für die Speicherung statischer Dateien zu definieren.

STATIC_ROOT = os.path.join(BASE_DIR, "static/")

Speichere die Datei und beende den Editor, wenn du fertig bist.

Datenbank migrieren und statische Dateien generieren

Bevor du die Datenbank migrierst, führe den folgenden Befehl aus, um sicherzustellen, dass deine Datenbank richtig konfiguriert ist.

python3 manage.py check --database default

Wenn kein Fehler auftritt, führe den folgenden Befehl aus, um die Datenbank zu migrieren.

python3 manage.py makemigrations
python3 manage.py migrate

Wenn alles gut läuft, solltest du den Migrationsprozess der Datenbank wie folgt sehen:

Zum Schluss führst du den folgenden Befehl aus, um statische Dateien für dein Django-Projekt zu erstellen. Nachdem der Befehl ausgeführt wurde, wird das neue Verzeichnis static erstellt und die statischen Dateien werden in diesem Verzeichnis generiert.

python3 manage.py collectstatic

Unten siehst du die Ausgabe, wenn du statische Dateien generierst.

Admin-Benutzer anlegen und Django starten

Führe den folgenden Befehl aus, um den Admin-Benutzer für dein Django-Projekt anzulegen.

python3 manage.py createsuperuser

Gib deine E-Mail-Adresse und dein Passwort ein, wenn du dazu aufgefordert wirst.

Sobald der Admin-Benutzer erstellt ist, führe den folgenden Befehl aus, um dein Django-Projekt zu starten.

python3 manage.py runserver 0.0.0.0:8080

Nachdem der Befehl ausgeführt wurde, wird dein Django-Projekt auf deiner lokalen IP-Adresse auf Port 8080 ausgeführt.

Öffne nun deinen Webbrowser und rufe die IP-Adresse des Servers auf, gefolgt von Port 8080, http://192.168.10.15:8080/. Wenn deine Django-Installation erfolgreich war, solltest du die standardmäßige Django index.html Seite wie die folgende sehen:

Rufe nun deine Django-Administration über den URL-Pfad /admin, http://192.168.10.15:8080/admin auf . Gib deinen Django-Admin-Benutzer und dein Passwort ein und klicke dann auf Anmelden.

Du solltest ein Beispiel für ein Django-Benutzer-Dashboard wie das folgende sehen:

Drücke Strg+c, um den Prozess zu beenden.

Django mit Gunicorn und Supervisor ausführen

Jetzt hast du die Installation von Django abgeschlossen und dein erstes Django-Projekt erstellt. Im nächsten Schritt wirst du Django so konfigurieren, dass es im Hintergrund läuft, indem du den Gunicorn WSGI Server und den Supervisor Prozessmanager verwendest.

Gunicorn installieren

Führe in der virtuellen Umgebung venv den folgenden pip-Befehl aus, um Gunicorn zu installieren.

pip install gunicorn

Führe nun den folgenden Befehl aus, um die virtuelle Umgebung venv zu deaktivieren und zu deinem Root-Benutzer zurückzukehren.

deactivate
exit

Django mit Gunicorn und Supervisor ausführen

Erstelle eine neue Supervisor-Konfiguration /etc/supervisor/conf.d/testapp.conf mit dem folgenden nano-Editor-Befehl.

sudo nano /etc/supervisor/conf.d/testapp.conf

Füge die folgende Konfiguration ein und achte darauf, dass du die detaillierten Informationen über den Anwendungsnamen, den Pfad des Projekts und den Benutzer mit deinen Angaben änderst. In diesem Beispiel wirst du dein Django-Projekt unter dem UNIX-Socket /home/bob/testdjango/testapp.sock ausführen.

[program:testapp] 
command=/bin/bash -c 'source /home/bob/testdjango/venv/bin/activate; gunicorn -t 3000 --workers 3 --bind unix:unix:/home/bob/testdjango/testapp.sock testapp.wsgi:application -w 2'
directory=/home/bob/testdjango
user=bob
group=www-data
autostart=true 
autorestart=true 
stdout_logfile=/home/bob/testdjango/testapp.log 
stderr_logfile=/home/bob/testdjango/error.log

Speichere und beende die Datei, wenn du fertig bist.

Zum Schluss führst du den folgenden Befehl aus, um den Supervisor-Dienst neu zu starten und die Änderungen zu übernehmen. Überprüfe dann den Dienst des Supervisors, um sicherzustellen, dass der Dienst läuft.

sudo systemctl restart supervisor
sudo systemctl status supervisor

Überprüfen von Django über Supervisorctl

Führe den folgenden supervisorctl-Befehl aus, um den Status der Anwendung zu überprüfen, die im Supervisor läuft.

sudo supervisorctl status

Du solltest sehen, dass die Anwendung testapp unter der PID 2577 läuft.

Überprüfe schließlich deine Django-Anwendung mit dem unten stehenden curl-Befehl.

curl --unix-socket /home/bob/testdjango/testapp.sock 127.0.0.1

Wenn alles klappt, solltest du den Quellcode der index.html-Seite deines Django-Projekts sehen.

Nginx als Reverse Proxy für Django konfigurieren

Jetzt, wo dein Django-Projekt im Hintergrund läuft, musst du im nächsten Schritt Nginx als Reverse-Proxy für Django einrichten. Im folgenden Beispiel wird ein lokaler Domainname verwendet.

Erstelle eine neue Nginx-Serverblockkonfiguration /etc/nginx/sites-available/django mit dem folgenden nano-Editor.

sudo nano /etc/nginx/sites-available/django

Füge die folgende Konfiguration ein und achte darauf, dass du den Domainnamen im Parameter server_name änderst.

server {
    listen 80;
    server_name first-django.dev;
location = /favicon.ico { access_log off; log_not_found off; }
try_files $uri @django;
location /static {
alias /home/bob/testdjango/static/;
}

location @django {
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/bob/testdjango/testapp.sock;
}
}

Speichere und beende die Datei, wenn du fertig bist.

Führe nun den folgenden Befehl aus, um den Serverblock /etc/nginx/sites-available/django zu aktivieren, und überprüfe dann die Nginx-Syntax, um sicherzustellen, dass du die richtige Syntax hast.

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

Du solltest die Ausgabe syntax is ok erhalten – der Test ist erfolgreich, wenn die Nginx-Syntax korrekt ist.

Starte schließlich deinen Nginx-Dienst neu, indem du den folgenden Befehl ausführst und die vorgenommenen Änderungen anwendest.

sudo systemctl restart nginx

Damit ist dein Django-Projekt über einen lokalen Domainnamen erreichbar.

Bearbeite auf deinem lokalen Rechner die Datei /etc/hosts für Linux oder C:\Windows\System32\drivers\etc\hosts für Windows. Lege dann die IP-Adresse und den Domänennamen deines Servers wie folgt fest.

192.168.10.15  first-django.dev

Speichere und beende die Datei, wenn du fertig bist.

Gehe zurück in deinen Webbrowser und rufe deinen lokalen Domainnamen auf. Du solltest die Standardseite index.html deines Django-Projekts sehen.

Fazit

Zusammenfassend lässt sich sagen, dass du mit dieser Schritt-für-Schritt-Anleitung das Django-Webframework mit PostgreSQL, Nginx, Gunicorn und Supervisor unter Debian 12 installiert hast. Du hast gelernt, wie du ein Django-Projekt mit PostgreSQL als Standarddatenbank erstellst und Django mit Gunicorn und Supervisor ausführst. Jetzt kannst du deine Anwendung mit Django erstellen und entwickeln.