So installieren Sie Django mit Postgres, Nginx und Gunicorn auf Rocky Linux 9

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.

In diesem Tutorial lernen Sie, wie Sie das Django-Framework auf einem Rocky Linux 9-Server installieren. Sie werden auch ein Demoprojekt erstellen und es testen.

Voraussetzungen

Ein Server, der Rocky Linux 9 ausführt.
Ein Nicht-Root-Benutzer mit Sudo-Rechten.
Ein vollständig qualifizierter Domainname (FQDN), der auf Ihren Server verweist. Für unsere Zwecke verwenden wir django.example.com als Domainnamen.
Stellen Sie sicher, dass alles aktualisiert ist. $ sudo dnf update
Installieren Sie grundlegende Dienstprogramme. Einige davon sind möglicherweise bereits installiert. $ sudo dnf install wget curl nano unzip yum-utils -y
SELinux ist deaktiviert.

Schritt 1 - Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld-Firewall. Überprüfen Sie den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, und die öffentliche Zone ist die Standardzone, die wir verwenden werden. Listen Sie alle aktiven Dienste und Ports in der Firewall auf.

$ sudo firewall-cmd --permanent --list-services

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Django benötigt HTTP- und HTTPS-Ports, um zu funktionieren. Öffnen Sie diese.

$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent

Laden Sie die Firewall neu, um die Änderungen anzuwenden.

$ sudo firewall-cmd --reload

Schritt 2 - PostgreSQL und Dienstprogramme installieren

Rocky Linux 9 wird mit einer älteren Version von PostgreSQL ausgeliefert. Wir werden PostgreSQL 14 für unser Tutorial installieren.

Installieren Sie das Repository-RPM für PostgreSQL.

$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm

Installieren Sie den PostgreSQL 14-Server.

$ sudo dnf install -y postgresql14-server postgresql14-contrib postgresql14-devel python3-psycopg2

Initialisieren Sie die Datenbank.

$ sudo /usr/pgsql-14/bin/postgresql-14-setup initdb

Aktivieren und starten Sie den PostgreSQL-Dienst.

$ sudo systemctl enable postgresql-14 --now

Überprüfen Sie den Status des Dienstes.

$ sudo systemctl status postgresql-14
? postgresql-14.service - PostgreSQL 14-Datenbankserver
     Loaded: loaded (/usr/lib/systemd/system/postgresql-14.service; enabled; vendor preset: disabled)
     Active: active (running) since Mon 2022-09-12 01:17:24 UTC; 2s ago
       Docs: https://www.postgresql.org/docs/14/static/
    Process: 87995 ExecStartPre=/usr/pgsql-14/bin/postgresql-14-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
   Main PID: 88000 (postmaster)
      Tasks: 8 (limit: 5915)
     Memory: 16.5M
        CPU: 60ms
     CGroup: /system.slice/postgresql-14.service
             ??88000 /usr/pgsql-14/bin/postmaster -D /var/lib/pgsql/14/data/
             ??88001 "postgres: logger "
             ??88003 "postgres: checkpointer "
             ??88004 "postgres: background writer "
             ??88005 "postgres: walwriter "
             ??88006 "postgres: autovacuum launcher "
             ??88007 "postgres: stats collector "
             ??88008 "postgres: logical replication launcher "

Sep 12 01:17:24 board.example.com systemd[1]: Starting PostgreSQL 14-Datenbankserver...

Lassen Sie uns einige zusätzliche Dienstprogramme installieren, die wir für Django benötigen.

$ sudo dnf install -y python3 python3-devel python3-pip gcc

Um zukünftige Fehler bezüglich pg_config, die nicht gefunden werden, zu beheben, müssen Sie den Pfad zum PostgreSQL-Bin-Ordner hinzufügen. Öffnen Sie die .bashrc-Datei zur Bearbeitung.

$ nano ~/.bashrc

Fügen Sie die folgende Zeile am Ende der Datei hinzu.

export PATH=$PATH:/usr/pgsql-14/bin

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

Schritt 3 - PostgreSQL konfigurieren

Melden Sie sich an der PostgreSQL-Shell an.

$ sudo -i -u postgres psql

Erstellen Sie eine neue Datenbank für Django.

postgres=# CREATE DATABASE djangoapp;

Erstellen Sie einen neuen Datenbankbenutzer mit einem starken Passwort.

postgres=# CREATE USER djangouser WITH ENCRYPTED PASSWORD 'dbpassword';

Gewähren Sie dem Benutzer die Rechte zur Nutzung der Datenbank.

postgres=# GRANT ALL PRIVILEGES ON DATABASE djangoapp TO djangouser;

Verlassen Sie die Postgres-Shell.

postgres=# \q

Schritt 4 - Django installieren

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

Installation mit pip

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

Lassen Sie uns ein Demoprojektverzeichnis 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 in Ihrem Projektverzeichnis. 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.1.2

Je nach Ihren Projektanforderungen 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 Rocky Linux-Repository erhalten wurde.

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

(sample_env) $ deactivate

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.

Klonen Sie 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, der 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.dev20221012095013

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

Schritt 5 - 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 das Wheel-Paket.

(sample_proj) $ pip install wheel

Installieren Sie Django und die erforderlichen Pakete.

(sample_proj) $ pip install django psycopg2 psycopg2-binary

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 .

Django verwendet die Variable SECRET_KEY, um kryptografische Signaturen bereitzustellen. Es generiert während der Installation einen Standardwert. Sie sollten ihn durch einen sicheren Wert ersetzen. Führen Sie den folgenden Befehl aus, um den Schlüssel zu generieren und ihn für später zu kopieren.

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

Sie erhalten die folgende Ausgabe mit einem Schlüssel.

wm#dzb^ymuo3s3tza=f5cx^kan!$4sch1!b-q=v%)=d0pb(jqf

Der erste Schritt besteht darin, die Projekteinstellungen anzupassen. Öffnen Sie die Einstellungsdatei zur Bearbeitung.

(sample_proj) $ nano demoproject/settings.py

Ersetzen Sie den aktuellen Wert der Variable SECRET_KEY durch den Schlüssel, den Sie generiert haben.

SECRET_KEY = 's)3m=4s&!a=p#brttcqu@1s$8(z6e+u8(^tkpw28qyj0t#8ku2'

Ändern Sie die Einstellungen für den Abschnitt DATABASES wie folgt.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'DATABASE_DB',
        'USER': 'DATABASE_USER',
        'PASSWORD': 'DATABASE_PASSWORD',
        'HOST': 'DATABASE_HOST',
        'PORT': 'DATABASE_PORT',
    },
}

Bewegen Sie sich als Nächstes zum Ende der Datei und fügen Sie eine Einstellung für den Speicherort der statischen Dateien hinzu. Dies ist wichtig, damit Nginx funktioniert und Anfragen für diese Dateien bearbeitet. Fügen Sie die folgende Zeile über der Variable STATIC_URL hinzu.

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

Da die Variable STATIC_ROOT das os-Modul verwendet, müssen wir es importieren, da es standardmäßig nicht importiert wird. Fügen Sie die folgende Zeile über der Zeile from pathlib import Path hinzu.

import os

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

Überprüfen Sie die Datenbankeinstellungen.

(sample_proj) $ python manage.py check --database default

Sie sollten die folgende Ausgabe erhalten.

System check identified no issues (0 silenced).

Als Nächstes müssen wir die Datenbank mit dem Befehl migrate migrieren. Migrationen in Django propagieren Änderungen, die Sie an Ihren Modellen vornehmen, in Ihr Datenbankschema.

(sample_proj) $ python manage.py makemigrations
(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

Erstellen Sie als Nächstes 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.

Kopieren Sie die statischen Dateien in das statische Verzeichnis. Geben Sie yes ein, wenn Sie dazu aufgefordert werden.

(sample_proj) $ python manage.py collectstatic
130 static files copied to '/home/navjot/dj-sample/static'.

Schritt 6 - Testen des Entwicklungsservers

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 die IP-Adresse Ihres 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 übereinstimmen. .example.com wird jedoch example.com und www.example.com sowie 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 so konfigurieren, dass Django funktioniert. Django verwendet standardmäßig den Port 8000. Öffnen Sie den Port mit der Uncomplicated Firewall (UFW).

(sample_proj) $ sudo firewall-cmd --add-port=8000/tcp --permanent
(sample_proj) $ sudo firewall-cmd --reload

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 der 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 mit Ihrem Demoprojekt fertig sind, können Sie den Server schließen, indem Sie Ctrl + C in Ihrem Terminal drücken.

Schritt 7 - Gunicorn installieren und testen

Führen Sie den persistenten Django-Server mit nohup aus

Bisher ist der Dienst von Django nicht persistent. Um den Dienst persistent zu machen, gibt es zwei Methoden. Die erste Methode besteht darin, das Dienstprogramm nohup zu verwenden. Das nohup ist ein POSIX-Befehl, was bedeutet, dass es nicht aufhören wird. 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 aus dem Terminal verlassen haben, indem Sie Ctrl + C drücken.

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 anderen 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. Aber in Wirklichkeit werden 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    153474  1.6  3.9  46264 39016 pts/0    S    04:15   0:00 python manage.py runserver 0.0.0.0:8000
navjot    153475  3.0  4.4 196060 43500 pts/0    Sl   04:15   0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000
navjot    153483  0.0  0.2   6420  2248 pts/0    S+   04:15   0:00 grep --color=auto manage.py

Wie Sie sehen können, werden zwei Prozesse ausgeführt, einer mit der ID 153474 und der andere mit der ID 153475.

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

(sample_proj) $ sudo kill -9 153474 153475

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 interagieren, 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 wir 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:application

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

Schritt 8 - 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 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.

Erstellen Sie als Nächstes 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 \
          -t 3000 \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          demoproject.wsgi:application -w 2

[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; enabled; vendor preset: disabled)
     Active: active (listening) since Thu 2022-10-13 04:19:28 UTC; 14s ago
      Until: Thu 2022-10-13 04:19:28 UTC; 14s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Oct 13 04:19:28 django.nspeaks.xyz 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: disabled)
     Active: active (running) since Thu 2022-10-13 06:13:55 UTC; 1min 34s ago
TriggeredBy: ? gunicorn.socket
   Main PID: 157742 (gunicorn)
      Tasks: 4 (limit: 5915)
     Memory: 96.2M
        CPU: 1.198s
     CGroup: /system.slice/gunicorn.service
             ??157742 /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 -w 2
             ??157746 /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 -w 2
             ??157747 /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 -w 2
             ??157748 /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 -w 2
.......

Schritt 9 - Nginx installieren

Der letzte Schritt besteht darin, Nginx zu installieren und zu konfigurieren. Rocky Linux wird mit einer älteren Version von Nginx ausgeliefert. Sie müssen das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.

Erstellen und öffnen Sie die Datei /etc/yum.repos.d/nginx.repo, um das offizielle Nginx-Repository zu erstellen.

$ sudo nano /etc/yum.repos.d/nginx.repo

Fügen Sie den folgenden Code ein.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

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

Installieren Sie den Nginx-Server.

$ sudo dnf install nginx -y

Überprüfen Sie die Installation.

$ nginx -v
nginx version: nginx/1.22.1

Aktivieren und starten Sie den Nginx-Server.

$ sudo systemctl enable nginx --now

Überprüfen Sie den Status des Servers.

$ sudo systemctl status nginx
? nginx.service - nginx - Hochleistungs-Webserver
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
     Active: active (running) since Thu 2022-10-13 06:17:24 UTC; 1s ago
       Docs: http://nginx.org/en/docs/
    Process: 157900 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 157901 (nginx)
      Tasks: 2 (limit: 5915)
     Memory: 1.9M
        CPU: 18ms
     CGroup: /system.slice/nginx.service
             ??157901 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??157902 "nginx: worker process"

Oct 13 06:17:24 django.example.com systemd[1]: Starting nginx - Hochleistungs-Webserver...

Schritt 10 - 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 Tool Certbot mit dem Snapd-Tool. Es erfordert das EPEL-Repository, um zu funktionieren.

$ sudo dnf install epel-release

Wir werden Snapd verwenden, um Certbot zu installieren. Installieren Sie Snapd.

$ sudo dnf install snapd

Aktivieren und starten Sie den Snap-Dienst.

$ sudo systemctl enable snapd.socket --now

Erstellen Sie die erforderlichen Links, damit Snapd funktioniert.

$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh

Installieren Sie das Kern-Snapd-Repository.

$ sudo snap install core
$ sudo snap refresh 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 certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d django.example.com

Der obige Befehl lädt ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/django.example.com auf Ihrem Server herunter.

Generieren Sie ein Diffie-Hellman-Gruppe-Zertifikat.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führen Sie einen Testlauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn Sie keine Fehler sehen, sind Sie bereit. Ihr Zertifikat wird automatisch erneuert.

Schritt 11 - 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.

# HTTPS durchsetzen
server {
  listen 80 default_server;
  server_name django.example.com;
  return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name django.example.com;

    access_log  /var/log/nginx/django.access.log;
    error_log   /var/log/nginx/django.error.log;

    http2_push_preload on; # HTTP/2 Server Push aktivieren

    ssl_certificate /etc/letsencrypt/live/django.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/django.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/django.example.com/chain.pem;
    ssl_session_timeout 1d;

    # TLS-Versionen aktivieren (TLSv1.3 ist für das kommende HTTP/3 QUIC erforderlich).
    ssl_protocols TLSv1.2 TLSv1.3;

    # TLSv1.3's 0-RTT aktivieren. Verwenden Sie $ssl_early_data, wenn Sie als Reverse-Proxy fungieren, um Wiederholungsangriffe zu verhindern.
    #
    # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
    ssl_early_data on;

    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:50m;

    # OCSP Stapling ---
    # Holen Sie sich OCSP-Datensätze aus der URL in ssl_certificate und cachen Sie sie
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    add_header X-Early-Data $tls1_3_early_data;

    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;
    }
}

# Dieser Block ist nützlich zur Fehlersuche bei TLS v1.3. Bitte entfernen Sie dies und verwenden Sie die direkt von NGINX bereitgestellte `$ssl_early_data`-Variable, wenn Sie dies wünschen.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Ersetzen Sie den Stammort 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.

Sie müssen auch den Domainnamen in Ihre Direktive ALLOWED_HOSTS einfügen. Öffnen Sie die Datei settings.py.

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

Ändern Sie den Wert der Variable 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 den Dienst neu.

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

Laden Sie den Nginx-Server neu.

$ sudo systemctl reload nginx

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

$ sudo firewall-cmd --remove-port=8000/tcp --permanent
$ sudo firewall-cmd --reload

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

Fazit

Damit endet unser Tutorial, in dem Sie gelernt haben, wie Sie Django zusammen mit Gunicorn und Nginx auf einem Rocky Linux 9-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.

Voraussetzungen

Schritt 1 - Firewall konfigurieren

Schritt 2 - PostgreSQL und Dienstprogramme installieren

Schritt 3 - PostgreSQL konfigurieren

Schritt 4 - Django installieren

Installation mit pip

Entwicklungsversion installieren

Schritt 5 - Erstellen eines Beispielprojekts

Schritt 6 - Testen des Entwicklungsservers

Schritt 7 - Gunicorn installieren und testen

Führen Sie den persistenten Django-Server mit nohup aus

Gunicorn installieren

Schritt 8 - Erstellen Sie eine Socket- und Dienstdatei für Gunicorn

Schritt 9 - Nginx installieren

Schritt 10 - SSL installieren

Schritt 11 - Nginx konfigurieren

Fazit

Erhalte neue Beiträge in deinem Posteingang.