Django Installation · 19 min read · Oct 13, 2025
Comment installer Django avec Postgres, Nginx et Gunicorn sur Rocky Linux 9
Django est un framework Python utilisé pour développer des sites Web et des applications dynamiques. Il suit l’architecture MVC (Modèle-Vue-Contrôleur). L’utilisation de Django accélère le processus de développement des applications, car la plupart des tâches sous-jacentes sont gérées par celui-ci.
Dans ce tutoriel, vous apprendrez comment installer le framework Django sur un serveur Rocky Linux 9. Vous créerez également un projet de démonstration et le testerez.
Prérequis
Un serveur exécutant Rocky Linux 9.
Un utilisateur non-root avec des privilèges sudo.
Un nom de domaine entièrement qualifié (FQDN) pointant vers votre serveur. Pour nos besoins, nous utiliserons
django.example.comcomme nom de domaine.Assurez-vous que tout est à jour.
$ sudo dnf updateInstallez des paquets utilitaires de base. Certains d’entre eux peuvent déjà être installés.
$ sudo dnf install wget curl nano unzip yum-utils -ySELinux est désactivé.
Étape 1 - Configurer le pare-feu
La première étape consiste à configurer le pare-feu. Rocky Linux utilise Firewalld Firewall. Vérifiez l’état du pare-feu.
$ sudo firewall-cmd --state
running
Le pare-feu fonctionne avec différentes zones, et la zone publique est celle par défaut que nous allons utiliser. Listez tous les services et ports actifs sur le pare-feu.
$ sudo firewall-cmd --permanent --list-services
Il devrait afficher la sortie suivante.
cockpit dhcpv6-client ssh
Django a besoin des ports HTTP et HTTPS pour fonctionner. Ouvrez-les.
$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent
Rechargez le pare-feu pour appliquer les modifications.
$ sudo firewall-cmd --reload
Étape 2 - Installer PostgreSQL et les utilitaires
Rocky Linux 9 est livré avec une version plus ancienne de PostgreSQL. Nous allons installer Postgres 14 pour notre tutoriel.
Installez le RPM du dépôt pour PostgreSQL.
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
Installez le serveur PostgreSQL 14.
$ sudo dnf install -y postgresql14-server postgresql14-contrib postgresql14-devel python3-psycopg2
Initialisez la base de données.
$ sudo /usr/pgsql-14/bin/postgresql-14-setup initdb
Activez et démarrez le service PostgreSQL.
$ sudo systemctl enable postgresql-14 --now
Vérifiez l’état du service.
$ sudo systemctl status postgresql-14
? postgresql-14.service - Serveur de base de données PostgreSQL 14
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...
Installons quelques utilitaires supplémentaires dont nous aurons besoin pour que Django fonctionne.
$ sudo dnf install -y python3 python3-devel python3-pip gcc
Pour résoudre d’éventuelles erreurs futures concernant pg_config non trouvé, vous devez ajouter le chemin vers le dossier bin de PostgreSQL. Ouvrez le fichier .bashrc pour l’édition.
$ nano ~/.bashrc
Ajoutez la ligne suivante à la fin du fichier.
export PATH=$PATH:/usr/pgsql-14/bin
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Étape 3 - Configurer PostgreSQL
Connectez-vous à l’interface en ligne de commande de PostgreSQL.
$ sudo -i -u postgres psql
Créez une nouvelle base de données pour Django.
postgres=# CREATE DATABASE djangoapp;
Créez un nouvel utilisateur de base de données avec un mot de passe fort.
postgres=# CREATE USER djangouser WITH ENCRYPTED PASSWORD 'dbpassword';
Accordez les droits à l’utilisateur d’utiliser la base de données.
postgres=# GRANT ALL PRIVILEGES ON DATABASE djangoapp TO djangouser;
Quittez l’interface en ligne de commande de Postgres.
postgres=# \q
Étape 4 - Installer Django
Il existe plusieurs méthodes pour installer Django. Le choix de la méthode qui vous convient le mieux dépend de la façon dont vous souhaitez configurer votre environnement de développement et de vos besoins. Chaque méthode a ses propres avantages et inconvénients. Passons en revue toutes ces méthodes.
Installer avec pip
C’est la méthode la plus courante pour installer Django. La méthode recommandée consiste à créer un environnement Python virtuel. Cela vous permet d’installer des paquets Python sans affecter le système.
Créons un répertoire de projet de démonstration.
$ mkdir ~/sampleproject
$ cd ~/sampleproject
Créez un environnement virtuel en utilisant la commande suivante. Remplacez sample_env par le nom que vous souhaitez donner à votre environnement virtuel.
$ python3 -m venv sample_env
Cela installe une version portable de Python, pip dans votre répertoire de projet. Pour installer des paquets dans le projet, vous devez activer l’environnement en utilisant la commande suivante.
$ source sample_env/bin/activate
Votre invite de commande changera pour refléter l’environnement virtuel.
(sample_env) navjot@django:~/sampleproject$
Maintenant que l’environnement virtuel est activé, utilisez pip pour installer Django. Exécutez la commande suivante pour installer Django.
(sample_env) $ pip install django
Vérifiez l’installation.
(sample_env) $ django-admin --version
4.1.2
En fonction des exigences de votre projet, vous pouvez installer une version différente de Django de la manière suivante.
(sample_env) $ pip install django==3.2.1
Vérifiez l’installation.
(sample_env) $ django-admin --version
3.2.1
Comme vous pouvez le voir, cette méthode installe une version plus récente de Django que la version obtenue à partir du dépôt Rocky Linux.
Pour quitter l’environnement virtuel, exécutez la commande suivante.
(sample_env) $ deactivate
Installer la version de développement
Vous pouvez également utiliser pip pour installer la version de développement de Django. Pour cela, nous allons récupérer la version de développement à partir du dépôt Github de Django.
Clonez le dépôt dans le répertoire ~/django-dev en utilisant la commande suivante.
$ git clone https://github.com/django/django ~/django-dev
Passez au répertoire nouvellement créé.
$ cd ~/django-dev
Créez l’environnement virtuel.
$ python3 -m venv dev_django_env
Activez l’environnement.
$ source dev_django_env/bin/activate
Installez Django en utilisant pip. Le drapeau -e l’installe en mode éditable, ce qui est nécessaire si vous installez à partir du contrôle de version.
(dev_django_dev) $ pip install -e ~/django-dev
Vérifiez l’installation.
(dev_django_dev) $ django-admin --version
4.2.dev20221012095013
Comme vous pouvez le voir, la version ici est la dernière version de développement. La version de développement de Django n’est pas utile pour les environnements de production.
Étape 5 - Créer un projet d’exemple
Construisons un projet Django d’exemple. Créez un répertoire pour le projet d’exemple.
$ mkdir ~/dj-sample
$ cd ~/dj-sample
Créez un environnement virtuel Python.
$ python3 -m venv sample_proj
Activez l’environnement.
$ source sample_proj/bin/activate
Installez le paquet Wheel.
(sample_proj) $ pip install wheel
Installez Django et les paquets requis.
(sample_proj) $ pip install django psycopg2 psycopg2-binary
Pour construire le projet, nous devons utiliser la commande startproject. Cette commande crée un autre répertoire qui inclut :
- Un script de gestion,
manage.py, utilisé pour administrer des tâches spécifiques à Django. - Un répertoire portant le même nom que le projet qui inclut le code du projet.
Nous allons créer le répertoire du projet dans notre répertoire de travail actuel. Pour ce faire, utilisez le caractère point (.) à la fin de la commande suivante.
(sample_proj) $ django-admin startproject demoproject .
Django utilise la variable SECRET_KEY pour fournir une signature cryptographique. Il génère une valeur par défaut lors de l’installation. Vous devez la remplacer par une valeur sécurisée. Exécutez la commande suivante pour générer la clé et la copier pour plus tard.
(sample_proj) $ python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'
Vous obtiendrez la sortie suivante avec une clé.
wm#dzb^ymuo3s3tza=f5cx^kan!$4sch1!b-q=v%)=d0pb(jqf
La première étape consiste à ajuster les paramètres du projet. Ouvrez le fichier de paramètres pour l’édition.
(sample_proj) $ nano demoproject/settings.py
Remplacez la valeur actuelle de la variable SECRET_KEY par la clé que vous avez générée.
SECRET_KEY = 's)3m=4s&!a=p#brttcqu@1s$8(z6e+u8(^tkpw28qyj0t#8ku2'
Changez les paramètres de la section DATABASES comme suit.
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'DATABASE_DB',
'USER': 'DATABASE_USER',
'PASSWORD': 'DATABASE_PASSWORD',
'HOST': 'DATABASE_HOST',
'PORT': 'DATABASE_PORT',
},
}
Ensuite, déplacez-vous en bas du fichier et ajoutez un paramètre pour l’emplacement des fichiers statiques. Cela est important pour que Nginx fonctionne et gère les demandes pour ces fichiers. Ajoutez la ligne suivante au-dessus de la variable STATIC_URL.
STATIC_ROOT = os.path.join(BASE_DIR, "static/")
Puisque la variable STATIC_ROOT utilise le module os, nous devons l’importer car il n’est pas importé par défaut. Ajoutez la ligne suivante au-dessus de la ligne from pathlib import Path.
import os
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Vérifiez les paramètres de la base de données.
(sample_proj) $ python manage.py check --database default
Vous devriez obtenir la sortie suivante.
System check identified no issues (0 silenced).
Ensuite, nous devons migrer la base de données en utilisant la commande migrate. Les migrations dans Django propagent les modifications que vous apportez à vos modèles dans le schéma de votre base de données.
(sample_proj) $ python manage.py makemigrations
(sample_proj) $ python manage.py migrate
Vous obtiendrez la sortie suivante.
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
Ensuite, créez un utilisateur administratif pour accéder à l’interface d’administration de Django.
(sample_proj) $ python manage.py createsuperuser
Vous serez invité à entrer un nom d’utilisateur, un e-mail et un mot de passe.
Username (leave blank to use 'navjot'):
Email address: [email protected]
Password:
Password (again):
Superuser created successfully.
Copiez les fichiers statiques dans le répertoire statique. Entrez yes lorsque vous y êtes invité.
(sample_proj) $ python manage.py collectstatic
130 static files copied to '/home/navjot/dj-sample/static'.
Étape 6 - Tester le serveur de développement
Il est temps de tester l’application. Pour cela, vous devez modifier la directive ALLOWED_HOSTS dans les paramètres de Django. Cette directive définit la liste des adresses IP et des noms de domaine qui ont accès à l’application Django.
Ouvrez le fichier de paramètres en utilisant la commande suivante.
(sample_proj) $ nano demoproject/settings.py
Trouvez l’entrée suivante.
ALLOWED_HOSTS = []
Entrez l’adresse IP de votre serveur dans les crochets. Chaque entrée doit être entourée de guillemets et plusieurs entrées doivent être séparées par des virgules. Entrer www.example.com sera exactement correspondant. Cependant, .example.com correspondra à example.com et www.example.com, et tout autre sous-domaine de example.com. Par conséquent, il est recommandé d’utiliser le point pour préfixer un nom de domaine afin de le faire correspondre et à ses sous-domaines.
ALLOWED_HOSTS = ['']
Nous avons utilisé l’adresse IP pour faire correspondre notre serveur. Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Avant de tester le serveur de développement, vous devez configurer le pare-feu pour permettre à Django de fonctionner. Django utilise le port 8000 par défaut. Ouvrez le port en utilisant le pare-feu simplifié (UFW).
(sample_proj) $ sudo firewall-cmd --add-port=8000/tcp --permanent
(sample_proj) $ sudo firewall-cmd --reload
Démarrez le serveur de développement.
(sample_proj) $ python manage.py runserver 0.0.0.0:8000
Lancez l’URL http:// dans votre navigateur et vous obtiendrez l’écran suivant.
Vous pouvez accéder à l’interface d’administration en suivant l’URL http:// et vous verrez l’écran de connexion suivant.
Entrez les identifiants créés précédemment pour vous connecter au panneau d’administration ci-dessous.
Une fois que vous avez terminé avec votre projet de démonstration, vous pouvez fermer le serveur en appuyant sur Ctrl + C dans votre terminal.
Étape 7 - Installer et tester Gunicorn
Exécuter le serveur Django persistant en utilisant nohup
Jusqu’à présent, le service Django n’est pas persistant. Pour rendre le service persistant, il existe deux méthodes. La première méthode consiste à utiliser l’utilitaire nohup. Le nohup est une commande POSIX qui signifie no hang up. Il est utilisé pour exécuter des commandes de manière à ne pas s’arrêter même lorsqu’un utilisateur se déconnecte.
Assurez-vous d’avoir quitté le serveur depuis le terminal en appuyant sur Ctrl + C.
Exécutez la commande suivante pour exécuter le serveur de développement de Django.
(sample_proj) $ nohup python manage.py runserver 0.0.0.0:8000 &
Maintenant, votre serveur Django continuera de fonctionner jusqu’à ce que vous le tuiez manuellement. La commande vous donnera l’ID de processus et affichera une autre commande.
[1] 42595
(sample_proj) $ nohup: ignoring input and appending output to 'nohup.out'
^C
Appuyez sur Ctrl + C pour quitter. Le serveur Django d’origine continuera de fonctionner. Vous pouvez vérifier en ouvrant l’URL dans votre navigateur.
Une fois que vous avez terminé, vous devez tuer le processus. La commande nohup vous donne un ID de processus. Mais en réalité, deux processus sont en cours d’exécution. Pour trouver les ID des deux processus, exécutez la commande suivante.
(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
Comme vous pouvez le voir, deux processus sont en cours d’exécution, l’un avec l’ID 153474 et l’autre avec l’ID 153475.
Exécutez la commande suivante pour arrêter le serveur en utilisant les ID de processus que vous avez obtenus ci-dessus.
(sample_proj) $ sudo kill -9 153474 153475
Installer Gunicorn
La deuxième méthode pour exécuter un serveur Django persistant nécessite d’installer Gunicorn et les serveurs Web Nginx. Gunicorn est un serveur HTTP WSGI Python. Il interagira avec l’application Django et ensuite Nginx agira comme un proxy inverse vers Gunicorn. Cette méthode a l’avantage supplémentaire de vous fournir la sécurité et la performance qui accompagnent l’utilisation de Nginx.
Installez Gunicorn.
(sample_proj) $ pip install gunicorn
Avant de continuer, nous devons tester la capacité de Gunicorn à servir le projet. Exécutez la commande suivante pour exécuter Gunicorn.
(sample_proj) $ gunicorn --bind 0.0.0.0:8000 demoproject.wsgi:application
Cela démarrera Gunicorn sur la même interface que celle sur laquelle Django fonctionnait. Pour vérifier, ouvrez l’URL http:// dans votre navigateur et vous obtiendrez la même page d’accueil Django. Cela signifie que Gunicorn fonctionne parfaitement.
Lorsque vous avez terminé les tests, appuyez sur Ctrl + C dans le terminal pour quitter Gunicorn.
Désactivez l’environnement virtuel pour revenir à votre shell habituel.
(sample_proj) $ deactivate
Étape 8 - Créer un fichier Socket et un fichier Service pour Gunicorn
La première étape consiste à créer un fichier socket Gunicorn. Le socket Gunicorn sera créé au démarrage et écoutera les connexions. Lorsqu’une connexion se produit, systemd démarrera automatiquement le processus Gunicorn pour le gérer.
Créez et ouvrez le fichier socket Gunicorn pour l’édition.
$ sudo nano /etc/systemd/system/gunicorn.socket
Collez le code suivant dedans.
[Unit]
Description=socket gunicorn
[Socket]
ListenStream=/run/gunicorn.sock
[Install]
WantedBy=sockets.target
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Ensuite, créez et ouvrez le fichier de service Gunicorn pour l’édition.
$ sudo nano /etc/systemd/system/gunicorn.service
Collez le code suivant dedans.
[Unit]
Description=daemon gunicorn django
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
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité. Remplacez navjot par votre nom d’utilisateur système. Le groupe nginx permettra au serveur Nginx de communiquer avec Django.
Rechargez le démon système pour rafraîchir les fichiers systemd.
$ sudo systemctl daemon-reload
Activez et démarrez le fichier socket Gunicorn.
$ sudo systemctl start gunicorn.socket
$ sudo systemctl enable gunicorn.socket
Vérifiez l’état du socket Gunicorn.
$ sudo systemctl status gunicorn.socket
Vous recevrez une sortie similaire.
? gunicorn.socket - socket gunicorn
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.
Le service Gunicorn n’est toujours pas en cours d’exécution comme vous pouvez le vérifier.
$ sudo systemctl status gunicorn.service
? gunicorn.service - daemon gunicorn django
Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
Active: inactive (dead)
TriggeredBy: ? gunicorn.socket
Pour tester le mécanisme d’activation du socket, exécutez la commande suivante.
$ curl --unix-socket /run/gunicorn.sock localhost
Vous recevrez la sortie HTML de la page d’accueil Django dans votre terminal. Cela démarre également Gunicorn pour servir l’application. Vérifiez à nouveau l’état du service et vous verrez qu’il fonctionne maintenant.
$ sudo systemctl status gunicorn.service
? gunicorn.service - daemon gunicorn django
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
.......
Étape 9 - Installer Nginx
La dernière étape consiste à installer et configurer Nginx. Rocky Linux est livré avec une version plus ancienne de Nginx. Vous devez télécharger le dépôt officiel de Nginx pour installer la dernière version.
Créez et ouvrez le fichier /etc/yum.repos.d/nginx.repo pour créer le dépôt officiel de Nginx.
$ sudo nano /etc/yum.repos.d/nginx.repo
Collez le code suivant dedans.
[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
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Installez le serveur Nginx.
$ sudo dnf install nginx -y
Vérifiez l’installation.
$ nginx -v
nginx version: nginx/1.22.1
Activez et démarrez le serveur Nginx.
$ sudo systemctl enable nginx --now
Vérifiez l’état du serveur.
$ sudo systemctl status nginx
? nginx.service - nginx - serveur web haute performance
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 - serveur web haute performance...
Étape 10 - Installer SSL
Jusqu’à présent, votre application Django est servie via une connexion HTTP en texte clair. Il est fortement recommandé de la protéger via un certificat SSL. Pour cela, utilisez l’outil Certbot en utilisant l’outil Snapd. Il nécessite le dépôt EPEL pour fonctionner.
$ sudo dnf install epel-release
Nous allons utiliser Snapd pour installer Certbot. Installez Snapd.
$ sudo dnf install snapd
Activez et démarrez le service Snap.
$ sudo systemctl enable snapd.socket --now
Créez les liens nécessaires pour que Snapd fonctionne.
$ 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
Installez le dépôt Snapd core.
$ sudo snap install core
$ sudo snap refresh core
Installez Certbot.
$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Générez le certificat. La commande suivante configurera également automatiquement Nginx.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d django.example.com
La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/django.example.com sur votre serveur.
Générez un certificat de groupe Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Pour vérifier si le renouvellement SSL fonctionne correctement, effectuez un essai à sec du processus.
$ sudo certbot renew --dry-run
Si vous ne voyez aucune erreur, vous êtes prêt. Votre certificat se renouvellera automatiquement.
Étape 11 - Configurer Nginx
Créez et ouvrez le fichier /etc/nginx/conf.d/django-gunicorn.conf pour l’édition.
$ sudo nano /etc/nginx/conf.d/django-gunicorn.conf
Collez le code suivant dedans.
# imposer 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; # Activer le serveur HTTP/2 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;
# Activer les versions TLS (TLSv1.3 est requis pour le prochain HTTP/3 QUIC).
ssl_protocols TLSv1.2 TLSv1.3;
# Activer le 0-RTT de TLSv1.3. Utilisez $ssl_early_data lors du proxy inverse pour
# éviter les attaques de rejeu.
#
# @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 ---
# récupérer les enregistrements OCSP à partir de l'URL dans ssl_certificate et les mettre en cache
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;
}
}
# Ce bloc est utile pour déboguer TLS v1.3. N'hésitez pas à le supprimer
# et à utiliser la variable `$ssl_early_data` exposée par NGINX directement si vous
# souhaitez le faire.
map $ssl_early_data $tls1_3_early_data {
"~." $ssl_early_data;
default "";
}
Remplacez l’emplacement racine dans le fichier ci-dessus par le répertoire sur votre serveur.
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Ouvrez le fichier /etc/nginx/nginx.conf pour l’édition.
$ sudo nano /etc/nginx/nginx.conf
Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Vérifiez votre configuration Nginx.
$ sudo nginx -t
Si vous ne voyez aucune erreur, cela signifie que vous êtes prêt à partir.
Vous devrez également ajouter le nom de domaine à votre directive ALLOWED_HOSTS. Ouvrez le fichier settings.py.
$ nano ~/dj-sample/demoproject/settings.py
Changez la valeur de la variable ALLOWED_HOSTS.
ALLOWED_HOSTS = ['','django.example.com']
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Redémarrez le socket et le service Gunicorn.
$ sudo systemctl restart gunicorn.socket
$ sudo systemctl restart gunicorn.service
Rechargez le serveur Nginx.
$ sudo systemctl reload nginx
Ouvrez le port HTTP. Vous pouvez également supprimer le port 8000 si vous ne comptez plus l’utiliser.
$ sudo firewall-cmd --remove-port=8000/tcp --permanent
$ sudo firewall-cmd --reload
Vérifiez en ouvrant l’URL http://django.example.com et la page d’accueil Django se chargera.
Conclusion
Cela conclut notre tutoriel où vous avez appris à installer Django avec Gunicorn et Nginx sur un serveur Rocky Linux 9. Vous avez également installé un certificat SSL pour améliorer la sécurité de votre projet Django. Si vous avez des questions, postez-les dans les commentaires ci-dessous.
Recevez de nouveaux articles dans votre boîte de réception.
Aucun spam. Désabonnez-vous à tout moment.