So installierst du das Django Python Framework auf Ubuntu 22.04

Django ist ein Python-Framework, das für die Entwicklung dynamischer Websites und Anwendungen verwendet wird. Es folgt der MVC-Architektur (Model-View-Controller). Die Verwendung von Django beschleunigt den Entwicklungsprozess, da es die meisten der zugrundeliegenden Aufgaben selbst übernimmt.

In diesem Lernprogramm lernst du, wie du das Django-Framework auf einem Ubuntu 22.04 Server installierst. Außerdem wirst du ein Demoprojekt erstellen und es testen.

Voraussetzungen

• Ein Server mit Ubuntu 22.04.
• Ein sudo-Benutzer ohne Root-Rechte.
• Stelle sicher, dass alles auf dem neuesten Stand ist.

  $ sudo apt update 
  $ sudo apt upgrade
  

Django installieren

Es gibt mehrere Methoden, mit denen du Django installieren kannst. Welche Methode für dich am besten geeignet ist, hängt davon ab, wie du deine Entwicklungsumgebung konfigurieren willst und welche Bedürfnisse du hast. Jede Methode hat ihre eigenen Vor- und Nachteile. Lass uns all diese Methoden durchgehen.

Installation aus den Ubuntu-Repositories

Die einfachste Methode, Django zu installieren, ist die Verwendung der Ubuntu Repositories. Ubuntu 22.04 wird mit Python 3.10 ausgeliefert. Du kannst es mit folgendem Befehl überprüfen.

$ python3 -V
Python 3.10.4

Installiere Django mit dem folgenden Befehl.

$ sudo apt install python3-django

Führe den folgenden Befehl aus, um die erfolgreiche Installation zu überprüfen.

$ django-admin --version
3.2.12

Die Django-Version, die mit Ubuntu ausgeliefert wird, ist die aktuelle LTS-Version, die bis 2024 unterstützt wird. Sie ist jedoch nicht die aktuelle Version. Wenn du eine aktuelle Version installieren möchtest, ist diese Methode nicht geeignet.

Mit pip installieren

Dies ist die gängigste Methode, um Django zu installieren. Es wird empfohlen, eine virtuelle Python-Umgebung zu erstellen. So kannst du Python-Pakete installieren, ohne dass das System beeinträchtigt wird.

Installiere die Module pip und venv. venv wird verwendet, um virtuelle Python-Umgebungen zu erstellen, und pip installiert Python-Pakete.

$ sudo apt install python3-pip python3-venv

Lass uns ein Verzeichnis für das Demoprojekt erstellen.

$ mkdir ~/sampleproject
$ cd ~/sampleproject

Erstelle eine virtuelle Umgebung mit dem folgenden Befehl. Ersetze sample_env durch den Namen, den du für deine virtuelle Umgebung verwenden möchtest.

$ python3 -m venv sample_env

Dadurch wird eine portable Version von Python, pip, in deinem Projektverzeichnis installiert. Um Pakete in das Projekt zu installieren, musst du die Umgebung mit dem folgenden Befehl aktivieren.

$ source sample_env/bin/activate

Deine Shell-Eingabeaufforderung wird sich ändern und die virtuelle Umgebung anzeigen.

(sample_env) navjot@django:~/sampleproject$

Jetzt, wo die virtuelle Umgebung aktiviert ist, kannst du Django mit pip installieren. Führe den folgenden Befehl aus, um Django zu installieren.

(sample_env) $ pip install django

Überprüfe die Installation.

(sample_env) $ django-admin --version
4.0.5

Je nach den Anforderungen deines Projekts kannst du auf folgende Weise eine andere Version von Django installieren.

(sample_env) $ pip install django==3.2.1

Überprüfe die Installation.

(sample_env) $ django-admin --version
3.2.1

Wie du siehst, wird bei dieser Methode eine neuere Version von Django installiert als die Version aus dem Ubuntu-Repository.

Um die virtuelle Umgebung zu verlassen, führe den folgenden Befehl aus.

(sample_env) $ deactivate

Installiere die Entwicklungsversion

Du kannst auch pip verwenden, um die Entwicklungsversion von Django zu installieren. Dazu holen wir uns die Entwicklungsversion aus dem Github-Repository von Django.

Klone das Repository mit folgendem Befehl in das Verzeichnis ~/django-dev.

$ git clone https://github.com/django/django ~/django-dev

Wechsle in das neu erstellte Verzeichnis.

$ cd ~/django-dev

Erstelle die virtuelle Umgebung.

$ python3 -m venv dev_django_env

Aktiviere die Umgebung.

$ source dev_django_env/bin/activate

Installiere Django mit pip. Das -e Flag installiert es in einem bearbeitbaren Modus, der erforderlich ist, wenn du von der Versionskontrolle aus installierst.

(dev_django_dev) $ pip install -e ~/django-dev

Überprüfe die Installation.

(dev_django_dev) $ django-admin --version
4.2.dev20220628195651

Wie du siehst, ist die Version hier die neueste Entwicklungsversion. Die Entwicklungsversion von Django ist für Produktionsumgebungen nicht geeignet.

Ein Beispielprojekt erstellen

Lass uns ein Django-Beispielprojekt erstellen. Erstelle ein Verzeichnis für das Beispielprojekt.

$ mkdir ~/dj-sample
$ cd ~/dj-sample

Erstelle eine virtuelle Python-Umgebung.

$ python3 -m venv sample_proj

Aktiviere die Umgebung.

$ source sample_proj/bin/activate

Installiere Django.

(sample_proj) $ pip install django

Um das Projekt zu erstellen, müssen wir den Befehl startproject verwenden. Dieser Befehl erstellt ein weiteres Verzeichnis, das Folgendes enthält:

• Ein Verwaltungsskript, manage.py, , das zur Verwaltung von Django-spezifischen Aufgaben verwendet wird.
• Ein Verzeichnis mit dem gleichen Namen wie das Projekt, das den Projektcode enthält.

Wir werden das Projektverzeichnis in unserem aktuellen Arbeitsverzeichnis erstellen. Verwende dazu das Zeichen Punkt(.) am Ende des folgenden Befehls.

(sample_proj) $ django-admin startproject demoproject .

Als Nächstes müssen wir die Datenbank mit dem Befehl migrate migrieren. Migrationen in Django übertragen die Änderungen, die du an deinen Modellen vornimmst, in dein Datenbankschema. Python verwendet standardmäßig die SQLite-Datenbank.

(sample_proj) $ python manage.py migrate

Du wirst die folgende Ausgabe erhalten.

Operations to perform:
  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 legst du einen administrativen Benutzer an, um auf die Verwaltungsoberfläche von Django zuzugreifen.

(sample_proj) $ python manage.py createsuperuser

Du wirst nach einem Benutzernamen, einer E-Mail-Adresse und einem Passwort gefragt.

Username (leave blank to use 'navjot'):
Email address: name@example.com
Password:
Password (again):
Superuser created successfully.

Teste den Entwicklungsserver

Jetzt ist es an der Zeit, die Anwendung zu testen. Dazu musst du die Direktive ALLOWED_HOSTS in den Django-Einstellungen ändern. Diese Direktive legt die Liste der IP-Adressen und Domainnamen fest, die Zugriff auf die Django-Anwendung erhalten.

Öffne die Einstellungsdatei mit dem folgenden Befehl.

(sample_proj) $ nano demoproject/settings.py

Suche den folgenden Eintrag.

ALLOWED_HOSTS = []

Gib die IP-Adresse deines Servers in die eckigen Klammern ein. Jeder Eintrag sollte in Anführungszeichen gesetzt werden und mehrere Einträge müssen durch Kommas getrennt werden. Die Eingabe von www.example.com wird genau abgeglichen. .example.com passt jedoch zu example.com und www.example.com sowie zu jeder anderen Subdomain von example.com. Es wird daher empfohlen, das Punktzeichen einem Domainnamen voranzustellen, um ihn und seine Subdomains abzugleichen.

ALLOWED_HOSTS = ['<yourserver_ip_address>']

Wir haben die IP-Adresse verwendet, um unseren Server zu finden. Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Bevor du den Entwicklungsserver testest, musst du die Firewall so konfigurieren, dass Django funktionieren kann. Django verwendet standardmäßig den Port 8000. Öffne den Port mit der Uncomplicated Firewall(UFW).

(sample_proj) $ sudo ufw allow 8000

Starte den Entwicklungsserver.

(sample_proj) $ python manage.py runserver 0.0.0.0:8000

Rufe die URL http://<yourserver_ip_address>:8000 in deinem Browser auf und du erhältst den folgenden Bildschirm.

Du kannst auf die Verwaltungsoberfläche zugreifen, indem du der URL http://<yourserver_ip_address>:8000/admin/ folgst und den folgenden Anmeldebildschirm aufrufst.

Gib die zuvor erstellten Anmeldedaten ein, um dich in das unten abgebildete Admin-Panel einzuloggen.

Sobald du dein Demoprojekt fertiggestellt hast, kannst du den Server mit der Tastenkombination Strg + C in deinem Terminal schließen.

Gunicorn installieren und testen

Persistenten Django-Server mit nohup starten

Bislang ist der Django-Dienst nicht persistent. Um den Dienst persistent zu machen, gibt es zwei Methoden. Bei der ersten Methode wird das Dienstprogramm nohup verwendet. nohup ist ein POSIX-Befehl, der “ no hang up“ bedeutet. Er wird verwendet, um Befehle so auszuführen, dass sie nicht aufhören, auch wenn sich ein Benutzer abmeldet.

Vergewissere dich, dass du den Server im Terminal mit der Tastenkombination Strg + C verlassen hast.

Führe den folgenden Befehl aus, um den Entwicklungsserver von Django zu starten.

(sample_proj) $ nohup python manage.py runserver 0.0.0.0:8000 &

Jetzt läuft dein Django-Server so lange, bis du ihn manuell beendest. Der Befehl gibt dir die Prozess-ID und einen weiteren Befehl aus.

[1] 42595
(sample_proj) $ nohup: ignoring input and appending output to 'nohup.out'
^C

Drücke Strg + C zum Beenden. Der ursprüngliche Django-Server wird weiterlaufen. Du kannst das überprüfen, indem du die URL in deinem Browser öffnest.

Wenn du fertig bist, musst du den Prozess beenden. Der Befehl nohup gibt dir eine Prozess-ID. In Wirklichkeit werden aber zwei Prozesse ausgeführt. Um die IDs beider Prozesse zu ermitteln, führe den folgenden Befehl aus.

(sample_proj) $ ps aux | grep manage.py
navjot     42650  3.6  1.8  47792 38168 pts/0    S    02:28   0:00 python manage.py runserver 0.0.0.0.:8000
navjot     42651  7.9  2.0 344904 41708 pts/0    Sl   02:28   0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000
navjot     42657  0.0  0.1   6612  2172 pts/0    S+   02:28   0:00 grep --color=auto manage.py

Wie du siehst, werden zwei Prozesse ausgeführt, einer mit der ID 42650 und der andere mit der ID 42651.

Führe den folgenden Befehl aus, um den Server unter Verwendung der oben ermittelten Prozess-IDs zu schließen.

(sample_proj) $ sudo kill -9 42650 42651

Gunicorn installieren

Für die zweite Methode, einen persistenten Django-Server zu betreiben, musst du Gunicorn und Nginx Webserver installieren. Gunicorn ist ein Python WSGI HTTP Server. Er verbindet sich mit der Django-Anwendung und Nginx fungiert als Reverse Proxy für Gunicorn. Diese Methode hat den zusätzlichen Vorteil, dass du die Sicherheit und Leistung von Nginx nutzen kannst.

Installiere Gunicorn.

(sample_proj) $ pip install gunicorn

Bevor wir fortfahren, müssen wir testen, ob Gunicorn in der Lage ist, das Projekt zu bedienen. Führe den folgenden Befehl aus, um Gunicorn zu starten.

(sample_proj) $ gunicorn --bind 0.0.0.0:8000 demoproject.wsgi

Dadurch wird Gunicorn auf der gleichen Schnittstelle gestartet, auf der auch Django läuft. Um das zu überprüfen, öffne die URL http://<yourserver_ip_address>:8000 in deinem Browser und du wirst die gleiche Django-Homepage erhalten. Das bedeutet, dass Gunicorn einwandfrei läuft.

Wenn du mit dem Testen fertig bist, drücke Strg + C auf dem Terminal, um Gunicorn zu beenden.

Deaktiviere die virtuelle Umgebung, um zu deiner normalen Shell zurückzukehren.

(sample_proj) $ deactivate

Socket und Service-Datei für Gunicorn erstellen

Der erste Schritt besteht darin, eine Socket-Datei für Gunicorn zu erstellen. Der Gunicorn-Socket wird beim Booten erstellt und wartet auf Verbindungen. Wenn eine Verbindung hergestellt wird, startet systems automatisch den Gunicorn-Prozess, um sie zu verarbeiten.

Erstelle und öffne die Gunicorn-Socket-Datei zum Bearbeiten.

$ sudo nano /etc/systemd/system/gunicorn.socket

Füge den folgenden Code in die Datei ein.

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Als Nächstes erstellst du die Gunicorn-Service-Datei und öffnest sie zum Bearbeiten.

$ sudo nano /etc/systemd/system/gunicorn.service

Füge den folgenden Code in die Datei ein.

[Unit]
Description=django gunicorn daemon
Requires=gunicorn.socket
After=network.target

[Service]
User=navjot
Group=nginx
WorkingDirectory=/home/navjot/dj-sample
ExecStart=/home/navjot/dj-sample/sample_proj/bin/gunicorn \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          demoproject.wsgi:application

[Install]
WantedBy=multi-user.target

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Ersetze navjot durch deinen Systembenutzernamen. Die Gruppe nginx ermöglicht es dem Nginx-Server, mit Django zu kommunizieren.

Starte den Systemdaemon neu, um die systemd-Dateien zu aktualisieren.

$ sudo systemctl daemon-reload

Aktiviere und starte die Socket-Datei von Gunicorn.

$ sudo systemctl start gunicorn.socket
$ sudo systemctl enable gunicorn.socket

Überprüfe den Status des Gunicorn-Sockets.

$ sudo systemctl status gunicorn.socket

Du wirst eine ähnliche Ausgabe erhalten.

? gunicorn.socket - gunicorn socket
     Loaded: loaded (/etc/systemd/system/gunicorn.socket; disabled; vendor preset: enabled)
     Active: active (listening) since Thu 2022-06-30 01:43:24 UTC; 20s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Jun 30 01:43:24 django systemd[1]: Listening on gunicorn socket.

Der Gunicorn-Dienst läuft immer noch nicht, wie du überprüfen kannst.

$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: inactive (dead)
TriggeredBy: ? gunicorn.socket

Um den Socket-Aktivierungsmechanismus zu testen, führe den folgenden Befehl aus.

$ curl --unix-socket /run/gunicorn.sock localhost

Du erhältst die HTML-Ausgabe der Django-Homepage in deinem Terminal. Dadurch wird auch Gunicorn gestartet, um die Anwendung zu bedienen. Überprüfe den Status des Dienstes erneut und du wirst sehen, dass er jetzt läuft.

$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: active (running) since Thu 2022-06-30 01:45:09 UTC; 12s ago
TriggeredBy: ? gunicorn.socket
   Main PID: 42365 (gunicorn)
      Tasks: 4 (limit: 2241)
     Memory: 91.7M
        CPU: 1.128s
     CGroup: /system.slice/gunicorn.service
             ??42365 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42366 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42367 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42368 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application

Jun 30 01:45:09 django systemd[1]: Started django gunicorn daemon.
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Starting gunicorn 20.1.0
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Listening at: unix:/run/gunicorn.sock (42365)
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Using worker: sync
Jun 30 01:45:09 django gunicorn[42366]: [2022-06-30 01:45:09 +0000] [42366] [INFO] Booting worker with pid: 42366
.......

Nginx installieren

Der letzte Schritt besteht darin, Nginx zu installieren und zu konfigurieren. Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Importiere den Signierschlüssel von Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Füge das Repository für die stabile Version von Nginx hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.0

Nginx konfigurieren

Erstelle und öffne die Datei /etc/nginx/conf.d/django-gunicorn.conf zum Bearbeiten.

$ sudo nano /etc/nginx/conf.d/django-gunicorn.conf

Füge den folgenden Code in die Datei ein.

server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/navjot/dj-sample;
    }

    location / {
        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:/run/gunicorn.sock;
    }
}

Ersetze das Stammverzeichnis in der obigen Datei durch das Verzeichnis auf deinem Server.

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Öffne die Datei /etc/nginx/nginx.conf zur Bearbeitung.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size  64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe deine Nginx-Konfiguration.

$ sudo nginx -t

Wenn du keine Fehler siehst, bist du startklar.

Du musst auch den Domänennamen zu deiner ALLOWED_HOSTS Direktive hinzufügen. Öffne die Datei settings.py.

$ nano ~/dj-sample/demoproject/settings.py

Ändere den Wert für die Variable ALLOWED_HOSTS.

ALLOWED_HOSTS = ['<yourserver_ip_address>','django.example.com']

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starte Gunicorn Socket und Service neu.

$ sudo systemctl restart gunicorn.socket
$ sudo systemctl restart gunicorn.service

Starte den Nginx-Server.

$ sudo systemctl start nginx

Öffne den HTTP-Port. Du kannst den Port 8000 auch löschen, wenn du ihn nicht mehr verwenden willst.

$ sudo ufw delete allow 8000
$ sudo ufw allow http

Überprüfe das, indem du die URL http://django.example.com öffnest und die Django-Homepage lädt.

SSL installieren

Bis jetzt wurde deine Django-Anwendung über eine Klartext-HTTP-Verbindung übertragen. Es wird dringend empfohlen, dass du sie mit einem SSL-Zertifikat schützt. Verwende dazu das Tool Certbot mit dem Tool Snapd. Auf einem Ubuntu 22.04-System ist es bereits installiert.

Installiere das zentrale Snapd-Repository.

$ sudo snap install core

Installiere Certbot.

$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Erstelle das Zertifikat. Mit dem folgenden Befehl wird auch Nginx automatisch konfiguriert.

$ sudo certbot --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d django.example.com

Öffne zunächst den HTTPS-Port.

$ sudo ufw allow https

Rufe die URL https://django.example.com in deinem Browser auf, um sie zu bestätigen.

Fazit

Damit ist unser Tutorial abgeschlossen. Du hast gelernt, wie du Django und Gunicorn sowie Nginx auf einem Ubuntu 22.04 Server installierst. Außerdem hast du ein SSL-Zertifikat installiert, um die Sicherheit deines Django-Projekts zu erhöhen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.