Django Installation · 13 min read · Oct 14, 2025

So installieren Sie das Django Python-Framework auf Ubuntu 22.04

Django ist ein Python-Framework, das zur Entwicklung dynamischer Websites und Anwendungen verwendet wird. Es folgt der MVC (Model-View-Controller)-Architektur. Die Verwendung von Django beschleunigt den Entwicklungsprozess, da die meisten der zugrunde liegenden Aufgaben von ihm übernommen werden.

Dieses Tutorial zeigt Ihnen, wie Sie das Django-Framework auf einem Ubuntu 22.04-Server installieren. Sie werden auch ein Demoprojekt erstellen und es testen.

Voraussetzungen

  • Ein Server, der Ubuntu 22.04 ausführt.
  • Ein nicht-root sudo-Benutzer.
  • Stellen Sie sicher, dass alles aktualisiert ist. $ sudo apt update $ sudo apt upgrade

Django installieren

Es gibt mehrere Methoden, um Django zu installieren. Welche für Sie am besten geeignet ist, hängt davon ab, wie Sie Ihre Entwicklungsumgebung konfigurieren möchten und welche Anforderungen Sie haben. Jede Methode hat ihre eigenen Vor- und Nachteile. Lassen Sie uns alle diese Methoden durchgehen.

Aus den Ubuntu-Repositories installieren

Die einfachste Methode zur Installation von Django ist die Verwendung der Repositories von Ubuntu. Ubuntu 22.04 wird mit Python 3.10 ausgeliefert. Sie können dies mit dem folgenden Befehl überprüfen.

$ python3 -V
Python 3.10.4

Installieren Sie Django mit dem folgenden Befehl.

$ sudo apt install python3-django

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

$ django-admin --version
3.2.12

Die mit Ubuntu ausgelieferte Django-Version ist die aktuelle LTS-Version, die bis 2024 unterstützt wird. Es ist jedoch nicht die aktuelle Version. Wenn Sie eine aktuelle Version installieren möchten, ist diese Methode nicht für Sie geeignet.

Mit pip installieren

Dies ist die gängigste Methode zur Installation von Django. Der empfohlene Weg ist, eine virtuelle Python-Umgebung zu erstellen. Dies ermöglicht es Ihnen, Python-Pakete zu installieren, ohne das System zu beeinträchtigen.

Installieren Sie das pip- und venv-Modul. venv wird verwendet, um Python-virtuelle Umgebungen zu erstellen, und pip installiert Python-Pakete.

$ sudo apt install python3-pip python3-venv

Lassen Sie uns ein Verzeichnis für das Demoprojekt erstellen.

$ mkdir ~/sampleproject
$ cd ~/sampleproject

Erstellen Sie eine virtuelle Umgebung mit dem folgenden Befehl. Ersetzen Sie sample_env durch den Namen, den Sie Ihrer virtuellen Umgebung geben möchten.

$ python3 -m venv sample_env

Dies installiert eine tragbare Version von Python, pip innerhalb Ihres Projektverzeichnisses. Um Pakete in das Projekt zu installieren, müssen Sie die Umgebung mit dem folgenden Befehl aktivieren.

$ source sample_env/bin/activate

Ihr Shell-Prompt ändert sich, um die virtuelle Umgebung widerzuspiegeln.

(sample_env) navjot@django:~/sampleproject$

Jetzt, da die virtuelle Umgebung aktiviert ist, verwenden Sie pip, um Django zu installieren. Führen Sie den folgenden Befehl aus, um Django zu installieren.

(sample_env) $ pip install django

Überprüfen Sie die Installation.

(sample_env) $ django-admin --version
4.0.5

Je nach den Anforderungen Ihres Projekts können Sie eine andere Version von Django auf folgende Weise installieren.

(sample_env) $ pip install django==3.2.1

Überprüfen Sie die Installation.

(sample_env) $ django-admin --version
3.2.1

Wie Sie sehen können, installiert diese Methode eine neuere Version von Django als die Version, die aus dem Ubuntu-Repository erhalten wurde.

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

(sample_env) $ deactivate

Die Entwicklungsversion installieren

Sie können auch pip verwenden, um die Entwicklungsversion von Django zu installieren. Dazu werden wir die Entwicklungsversion aus dem Github-Repository von Django abrufen.

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

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

Wechseln Sie in das neu erstellte Verzeichnis.

$ cd ~/django-dev

Erstellen Sie die virtuelle Umgebung.

$ python3 -m venv dev_django_env

Aktivieren Sie die Umgebung.

$ source dev_django_env/bin/activate

Installieren Sie Django mit pip. Das -e-Flag installiert es im bearbeitbaren Modus, was erforderlich ist, wenn Sie aus der Versionskontrolle installieren.

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

Überprüfen Sie die Installation.

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

Wie Sie sehen können, ist die Version hier die neueste Entwicklungsversion. Die Entwicklungsversion von Django ist für Produktionsumgebungen nicht nützlich.

Erstellen eines Beispielprojekts

Lassen Sie uns ein Beispiel-Django-Projekt erstellen. Erstellen Sie ein Verzeichnis für das Beispielprojekt.

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

Erstellen Sie eine Python-virtuelle Umgebung.

$ python3 -m venv sample_proj

Aktivieren Sie die Umgebung.

$ source sample_proj/bin/activate

Installieren Sie 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 Django-spezifischer 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. Um dies zu tun, verwenden Sie das Punkt(.)-Zeichen 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 Änderungen, die Sie an Ihren Modellen vornehmen, in Ihr Datenbankschema. Python verwendet standardmäßig die SQLite-Datenbank.

(sample_proj) $ python manage.py migrate

Sie erhalten die folgende Ausgabe.

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 erstellen Sie einen Administrationsbenutzer, um auf die Admin-Oberfläche von Django zuzugreifen.

(sample_proj) $ python manage.py createsuperuser

Sie werden nach einem Benutzernamen, einer E-Mail-Adresse und einem Passwort gefragt.

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

Den Entwicklungsserver testen

Es ist Zeit, die Anwendung zu testen. Dazu müssen Sie die Direktive ALLOWED_HOSTS in den Django-Einstellungen ändern. Diese Direktive definiert die Liste von IP-Adressen und Domainnamen, die Zugriff auf die Django-Anwendung haben.

Öffnen Sie die Einstellungsdatei mit dem folgenden Befehl.

(sample_proj) $ nano demoproject/settings.py

Suchen Sie den folgenden Eintrag.

ALLOWED_HOSTS = []

Geben Sie Ihre Server-IP-Adresse 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 übereinstimmen. .example.com hingegen wird example.com, www.example.com und jede andere Subdomain von example.com übereinstimmen. Daher wird empfohlen, das Punktzeichen zu verwenden, um einen Domainnamen voranzustellen, um ihn und seine Subdomains abzugleichen.

ALLOWED_HOSTS = ['']

Wir haben die IP-Adresse verwendet, um unseren Server abzugleichen. Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Bevor Sie den Entwicklungsserver testen, müssen Sie die Firewall konfigurieren, um Django zu ermöglichen, zu arbeiten. Django verwendet standardmäßig den Port 8000. Öffnen Sie den Port mit der Uncomplicated Firewall (UFW).

(sample_proj) $ sudo ufw allow 8000

Starten Sie den Entwicklungsserver.

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

Starten Sie die URL http://:8000 in Ihrem Browser, und Sie erhalten den folgenden Bildschirm. Django-Homepage

Sie können auf die Admin-Oberfläche zugreifen, indem Sie die URL http://:8000/admin/ folgen, und Sie sehen den folgenden Anmeldebildschirm. Django-Anmeldeseite

Geben Sie die zuvor erstellten Anmeldeinformationen ein, um sich im Admin-Panel anzumelden, das unten angezeigt wird. Django-Admin-Panel

Sobald Sie Ihr Demoprojekt abgeschlossen haben, können Sie den Server schließen, indem Sie Ctrl + C in Ihrem Terminal drücken.

Gunicorn installieren und testen

Persistenten Django-Server mit nohup ausführen

Bisher ist der Dienst von Django nicht persistent. Um den Dienst persistent zu machen, gibt es zwei Methoden. Die erste Methode besteht darin, das nohup-Dienstprogramm zu verwenden. Das nohup ist ein POSIX-Befehl, der no hang up bedeutet. Es wird verwendet, um Befehle so auszuführen, dass sie nicht gestoppt werden, selbst wenn ein Benutzer sich abmeldet.

Stellen Sie sicher, dass Sie den Server im Terminal mit Ctrl + C verlassen haben.

Führen Sie den folgenden Befehl aus, um den Entwicklungsserver von Django auszuführen.

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

Jetzt wird Ihr Django-Server weiterlaufen, bis Sie ihn manuell beenden. Der Befehl gibt Ihnen die Prozess-ID und gibt einen weiteren Befehl aus.

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

Drücken Sie Ctrl + C, um zu beenden. Der ursprüngliche Django-Server wird weiterlaufen. Sie können dies überprüfen, indem Sie die URL in Ihrem Browser öffnen.

Sobald Sie fertig sind, müssen Sie den Prozess beenden. Der nohup-Befehl gibt Ihnen eine Prozess-ID. In Wirklichkeit werden jedoch zwei Prozesse ausgeführt. Um die IDs für beide Prozesse zu finden, führen Sie 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 Sie sehen können, werden zwei Prozesse ausgeführt, einer mit der ID 42650 und der andere mit der ID 42651.

Führen Sie den folgenden Befehl aus, um den Server mit den oben erhaltenen Prozess-IDs zu beenden.

(sample_proj) $ sudo kill -9 42650 42651

Gunicorn installieren

Die zweite Methode, um einen persistenten Django-Server auszuführen, erfordert die Installation von Gunicorn und Nginx-Webservern. Gunicorn ist ein Python WSGI HTTP-Server. Er wird mit der Django-Anwendung kommunizieren, und Nginx wird als Reverse-Proxy zu Gunicorn fungieren. Diese Methode hat den zusätzlichen Vorteil, dass sie Ihnen die Sicherheit und Leistung bietet, die mit der Verwendung von Nginx einhergeht.

Installieren Sie Gunicorn.

(sample_proj) $ pip install gunicorn

Bevor Sie fortfahren, müssen wir die Fähigkeit von Gunicorn testen, das Projekt zu bedienen. Führen Sie den folgenden Befehl aus, um Gunicorn auszuführen.

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

Dies startet Gunicorn auf demselben Interface, auf dem Django ausgeführt wurde. Um dies zu überprüfen, öffnen Sie die URL http://:8000 in Ihrem Browser, und Sie erhalten die gleiche Django-Homepage. Das bedeutet, dass Gunicorn perfekt läuft.

Wenn Sie mit dem Testen fertig sind, drücken Sie Ctrl + C im Terminal, um Gunicorn zu beenden.

Deaktivieren Sie die virtuelle Umgebung, um zu Ihrer regulären Shell zurückzukehren.

(sample_proj) $ deactivate

Erstellen Sie eine Socket- und Dienstdatei für Gunicorn

Der erste Schritt besteht darin, eine Gunicorn-Socket-Datei zu erstellen. Der Gunicorn-Socket wird beim Booten erstellt und hört auf Verbindungen. Wenn eine Verbindung erfolgt, wird der systemd-Prozess automatisch den Gunicorn-Prozess starten, um sie zu bearbeiten.

Erstellen und öffnen Sie die Gunicorn-Socket-Datei zur Bearbeitung.

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

Fügen Sie den folgenden Code ein.

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Als nächstes erstellen und öffnen Sie die Gunicorn-Dienstdatei zur Bearbeitung.

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

Fügen Sie den folgenden Code 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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden. Ersetzen Sie navjot durch Ihren Systembenutzernamen. Die Gruppe nginx ermöglicht es dem Nginx-Server, mit Django zu kommunizieren.

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

$ sudo systemctl daemon-reload

Aktivieren und starten Sie die Gunicorn-Socket-Datei.

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

Überprüfen Sie den Status des Gunicorn-Sockets.

$ sudo systemctl status gunicorn.socket

Sie erhalten eine ähnliche Ausgabe.

? 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 noch nicht, wie Sie überprüfen können.

$ 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ühren Sie den folgenden Befehl aus.

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

Sie erhalten die HTML-Ausgabe der Django-Homepage in Ihrem Terminal. Dies startet auch Gunicorn, um die Anwendung zu bedienen. Überprüfen Sie den Status des Dienstes erneut, und Sie werden 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. Sie müssen das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.

Importieren Sie den Signaturschlü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ügen Sie 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

Aktualisieren Sie die Systemrepositories.

$ sudo apt update

Installieren Sie Nginx.

$ sudo apt install nginx

Überprüfen Sie die Installation.

$ nginx -v
nginx version: nginx/1.22.0

Nginx konfigurieren

Erstellen und öffnen Sie die Datei /etc/nginx/conf.d/django-gunicorn.conf zur Bearbeitung.

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

Fügen Sie den folgenden Code 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;
    }
}

Ersetzen Sie den Stammstandort in der obigen Datei durch das Verzeichnis auf Ihrem Server.

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Öffnen Sie die Datei /etc/nginx/nginx.conf zur Bearbeitung.

$ sudo nano /etc/nginx/nginx.conf

Fügen Sie die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; hinzu.

server_names_hash_bucket_size  64;

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Überprüfen Sie Ihre Nginx-Konfiguration.

$ sudo nginx -t

Wenn Sie keine Fehler sehen, sind Sie bereit zu gehen.

Sie müssen auch den Domainnamen in Ihrer ALLOWED_HOSTS-Direktive hinzufügen. Öffnen Sie die Datei settings.py.

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

Ändern Sie den Wert der Variablen ALLOWED_HOSTS.

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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und Y eingeben, wenn Sie dazu aufgefordert werden.

Starten Sie den Gunicorn-Socket und -Dienst neu.

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

Starten Sie den Nginx-Server.

$ sudo systemctl start nginx

Öffnen Sie den HTTP-Port. Sie können auch den 8000-Port löschen, wenn Sie ihn nicht mehr verwenden möchten.

$ sudo ufw delete allow 8000
$ sudo ufw allow http

Überprüfen Sie, indem Sie die URL http://django.example.com öffnen, und die Django-Homepage wird geladen.

SSL installieren

Bisher wird Ihre Django-Anwendung über eine unverschlüsselte HTTP-Verbindung bereitgestellt. Es wird dringend empfohlen, sie über ein SSL-Zertifikat zu schützen. Verwenden Sie dazu das Certbot-Tool mit dem Snapd-Tool. Es ist bereits auf einem Ubuntu 22.04-System installiert.

Installieren Sie das Kern-Snapd-Repository.

$ sudo snap install core

Installieren Sie Certbot.

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

Generieren Sie das Zertifikat. Der folgende Befehl konfiguriert auch Nginx automatisch.

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

Öffnen Sie zuerst den HTTPS-Port.

$ sudo ufw allow https

Besuchen Sie die URL https://django.example.com in Ihrem Browser, um dies zu bestätigen.

Fazit

Damit endet unser Tutorial, in dem Sie gelernt haben, wie Sie Django, Gunicorn und Nginx auf einem Ubuntu 22.04-Server installieren. Sie haben auch ein SSL-Zertifikat installiert, um die Sicherheit Ihres Django-Projekts zu erhöhen. Wenn Sie Fragen haben, posten Sie diese in den Kommentaren unten.

Share: X/Twitter LinkedIn
#Django Installation

Erhalte neue Beiträge in deinem Posteingang.

Kein Spam. Jederzeit abmelden.