So installierst du Django mit Postgres, Nginx und Gunicorn auf Rocky Linux 9

Django ist ein Python-Framework, das für die Entwicklung dynamischer Websites und Anwendungen verwendet wird. Es folgt der MVC-Architektur (Model-View-Controller). Der Einsatz von Django beschleunigt die Entwicklung von Anwendungen, da die meisten Aufgaben von Django übernommen werden.

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

Voraussetzungen

  • Ein Server, auf dem Rocky Linux 9 läuft.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Ein vollständig qualifizierter Domainname (FQDN), der auf deinen Server zeigt. Für unsere Zwecke werden wir django.example.com als Domänennamen verwenden.
  • Stelle sicher, dass alles auf dem neuesten Stand ist.
    $ sudo dnf update
    
  • Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon 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üfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.

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

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Django braucht HTTP- und HTTPS-Ports, um zu funktionieren. Öffne sie.

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

Lade die Firewall neu, um die Änderungen zu übernehmen.

$ sudo firewall-cmd --reload

Schritt 2 – PostgreSQL und Dienstprogramme installieren

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

Installiere 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

Installiere den PostgreSQL 14 Server.

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

Initialisiere die Datenbank.

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

Aktiviere und starte den PostgreSQL-Dienst.

$ sudo systemctl enable postgresql-14 --now

Überprüfe den Status des Dienstes.

$ sudo systemctl status postgresql-14
? postgresql-14.service - PostgreSQL 14 database server
     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 database server...

Installiere einige zusätzliche Hilfsprogramme, die wir benötigen, damit Django funktioniert.

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

Um zukünftige Fehler zu beheben, wenn pg_config nicht gefunden wird, musst du den Pfad zum PostgreSQL bin Ordner hinzufügen. Öffne die Datei .bashrc, um sie zu bearbeiten.

$ nano ~/.bashrc

Füge die folgende Zeile am Ende der Datei ein.

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

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

Schritt 3 – PostgreSQL konfigurieren

Melde dich in der PostgreSQL-Shell an.

$ sudo -i -u postgres psql

Erstelle eine neue Datenbank für Django.

postgres=# CREATE DATABASE djangoapp;

Erstelle einen neuen Datenbankbenutzer mit einem sicheren Passwort.

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

Erteile dem Benutzer die Rechte zur Nutzung der Datenbank.

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

Beende die Postgres-Shell.

postgres=# \q

Schritt 4 – 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. Gehen wir all diese Methoden durch.

Installation mit pip

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

Legen wir ein Verzeichnis für ein Demoprojekt an.

$ mkdir ~/sampleproject
$ cd ~/sampleproject

Erstelle eine virtuelle Umgebung mit dem folgenden Befehl. Ersetze sample_env durch den Namen, den du deiner virtuellen Umgebung geben 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$

Nachdem 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.1.2

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 Rocky Linux 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.dev20221012095013

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

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

(sample_proj) $ pip install wheel

Installiere Django und die benötigten 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, mit dem Django-spezifische Aufgaben verwaltet werden.
  • Ein Verzeichnis mit dem gleichen Namen wie das Projekt, das den Projektcode enthält.

Wir werden das Projektverzeichnis in unserem aktuellen Arbeitsverzeichnis erstellen. Dazu verwendest du das Zeichen Punkt(.) am Ende des folgenden Befehls.

(sample_proj) $ django-admin startproject demoproject .

Django verwendet die Variable SECRET_KEY für die kryptografische Signierung. Bei der Installation wird ein Standardwert generiert. Du solltest ihn durch einen sicheren Wert ersetzen. Führe den folgenden Befehl aus, um den Schlüssel zu erzeugen und kopiere ihn für später.

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

Du erhältst 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. Öffne die Einstellungsdatei zur Bearbeitung.

(sample_proj) $ nano demoproject/settings.py

Ersetze den aktuellen Wert der Variable SECRET_KEY durch den von dir erzeugten Schlüssel.

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

Ändere 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',
	},
}

Als Nächstes gehst du ans Ende der Datei und fügst eine Einstellung für den Speicherort der statischen Dateien hinzu. Dies ist wichtig, damit Nginx funktioniert und Anfragen für diese Dateien bearbeiten kann. Füge die folgende Zeile oberhalb der Variable STATIC_URL ein.

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

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

import os

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

Überprüfe die Datenbankeinstellungen.

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

Du solltest 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 übertragen die Änderungen, die du an deinen Modellen vornimmst, in dein Datenbankschema.

(sample_proj) $ python manage.py makemigrations
(sample_proj) $ python manage.py migrate

Du erhältst 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 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.

Kopiere die statischen Dateien in das Verzeichnis static. Gib yes ein, wenn du dazu aufgefordert wirst.

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

Schritt 6 – 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 firewall-cmd --add-port=8000/tcp --permanent
(sample_proj) $ sudo firewall-cmd --reload

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.

Django Homepage

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

Django Login Seite

Gib die Zugangsdaten ein, die du zuvor erstellt hast, um dich im unten abgebildeten Verwaltungsbereich anzumelden.

Django Admin Panel

Wenn du mit deinem Demoprojekt fertig bist, kannst du den Server mit der Tastenkombination Strg + C in deinem Terminal schließen.

Schritt 7 – 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 auch dann nicht aufhören, 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    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 du siehst, werden zwei Prozesse ausgeführt, einer mit der ID 153474 und der andere mit der ID 153475.

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

(sample_proj) $ sudo kill -9 153474 153475

Gunicorn installieren

Die zweite Methode, um einen persistenten Django-Server zu betreiben, erfordert die Installation von Gunicorn und Nginx Webservern. 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:application

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

Schritt 8 – Erstellen einer Socket- und Servicedatei für Gunicorn

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 systemd automatisch den Gunicorn-Prozess, um sie zu bearbeiten.

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

[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; 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 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 noch einmal den Status des Dienstes 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: 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. Du musst das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.

Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zur Erstellung des offiziellen Nginx-Repositorys.

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

Füge den folgenden Code in die Datei 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

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

Installiere den Nginx-Server.

$ sudo dnf install nginx -y

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.1

Aktiviere und starte den Nginx-Server.

$ sudo systemctl enable nginx --now

Überprüfe den Status des Servers.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     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 - high performance web server...

Schritt 10 – SSL installieren

Bis jetzt wird deine Django-Anwendung über eine Klartext-HTTP-Verbindung bedient. Es wird dringend empfohlen, dass du sie mit einem SSL-Zertifikat schützt. Verwende dazu das Certbot-Tool mit dem Snapd-Tool. Es benötigt das EPEL-Repository, um zu funktionieren.

$ sudo dnf install epel-release

Wir werden Snapd verwenden, um Certbot zu installieren. Installiere Snapd.

$ sudo dnf install snapd

Aktiviere und starte den Snap-Dienst.

$ sudo systemctl enable snapd.socket --now

Erstelle die notwendigen 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

Installiere das zentrale Snapd-Repository.

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

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/django.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.

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

# enforce HTTPS
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; # Enable HTTP/2 Server Push

    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;

    # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
    ssl_protocols TLSv1.2 TLSv1.3;

    # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
    # prevent replay attacks.
    #
    # @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 ---
    # fetch OCSP records from URL in ssl_certificate and cache them
    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;
    }
}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Ersetze den Root-Speicherort 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

Lade den Nginx-Server neu.

$ sudo systemctl reload nginx

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

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

Überprüfe, ob die URL http://django.example.com geöffnet ist und die Django-Homepage geladen wird.

Fazit

Damit hast du gelernt, wie du Django zusammen mit Gunicorn und Nginx auf einem Rocky Linux 9 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.

Das könnte dich auch interessieren …