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.comals 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.
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 Zugangsdaten ein, die du zuvor erstellt hast, um dich im unten abgebildeten Verwaltungsbereich anzumelden.
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.