Django Installation · 14 min read · Oct 14, 2025
Comment installer le framework Django Python sur Ubuntu 22.04
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 car la plupart des tâches sous-jacentes sont gérées par celui-ci.
Ce tutoriel vous apprendra à installer le framework Django sur un serveur Ubuntu 22.04. Vous créerez également un projet de démonstration et le testerez.
Prérequis
- Un serveur exécutant Ubuntu 22.04.
- Un utilisateur sudo non-root.
- Assurez-vous que tout est à jour.
$ sudo apt update $ sudo apt upgrade
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 depuis les dépôts Ubuntu
La méthode la plus simple pour installer Django est d’utiliser les dépôts d’Ubuntu. Ubuntu 22.04 est livré avec Python 3.10. Vous pouvez le vérifier en utilisant la commande suivante.
$ python3 -V
Python 3.10.4
Installez Django en utilisant la commande suivante.
$ sudo apt install python3-django
Exécutez la commande suivante pour vérifier l’installation réussie.
$ django-admin --version
3.2.12
La version de Django fournie avec Ubuntu est la version LTS actuelle qui est supportée jusqu’en 2024. Cependant, ce n’est pas la version actuelle. Si vous souhaitez installer une version récente, cette méthode n’est pas pour vous.
Installer en utilisant pip
C’est la méthode la plus courante pour installer Django. La méthode recommandée consiste à créer un environnement virtuel Python. Cela vous permet d’installer des paquets Python sans affecter le système.
Installez les modules pip et venv. venv est utilisé pour créer des environnements virtuels Python et pip pour installer des paquets Python.
$ sudo apt install python3-pip python3-venv
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.0.5
Selon les 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 depuis le dépôt Ubuntu.
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 depuis le 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 requis si vous installez depuis le contrôle de version.
(dev_django_dev) $ pip install -e ~/django-dev
Vérifiez l’installation.
(dev_django_dev) $ django-admin --version
4.2.dev20220628195651
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.
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 Django.
(sample_proj) $ pip install django
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 cela, utilisez le caractère point (.) à la fin de la commande suivante.
(sample_proj) $ django-admin startproject demoproject .
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. Python utilise par défaut la base de données SQLite.
(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.
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 égal. Cependant, .example.com correspondra à example.com et www.example.com, ainsi qu’à 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 ufw allow 8000
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 montré ci-dessous.
Une fois que vous avez terminé votre projet de démonstration, vous pouvez fermer le serveur en appuyant sur Ctrl + C dans votre terminal.
Installer et tester Gunicorn
Exécuter un 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. Elle est utilisée 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 à fonctionner jusqu’à ce que vous le tuiez manuellement. La commande vous donnera l’ID du 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 à 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 exécutés. Pour trouver les ID des deux processus, exécutez la commande suivante.
(sample_proj) $ ps aux | grep manage.py
navjot 42650 3.6 1.8 47792 38168 pts/0 S 02:28 0:00 python manage.py runserver 0.0.0.0.:8000
navjot 42651 7.9 2.0 344904 41708 pts/0 Sl 02:28 0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000
navjot 42657 0.0 0.1 6612 2172 pts/0 S+ 02:28 0:00 grep --color=auto manage.py
Comme vous pouvez le voir, deux processus sont exécutés, l’un avec l’ID 42650 et l’autre avec l’ID 42651.
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 42650 42651
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 les performances 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
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
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, le 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=gunicorn socket
[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=django gunicorn daemon
Requires=gunicorn.socket
After=network.target
[Service]
User=navjot
Group=nginx
WorkingDirectory=/home/navjot/dj-sample
ExecStart=/home/navjot/dj-sample/sample_proj/bin/gunicorn \
--access-logfile - \
--workers 3 \
--bind unix:/run/gunicorn.sock \
demoproject.wsgi:application
[Install]
WantedBy=multi-user.target
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 - gunicorn socket
Loaded: loaded (/etc/systemd/system/gunicorn.socket; disabled; vendor preset: enabled)
Active: active (listening) since Thu 2022-06-30 01:43:24 UTC; 20s ago
Triggers: ? gunicorn.service
Listen: /run/gunicorn.sock (Stream)
CGroup: /system.slice/gunicorn.socket
Jun 30 01:43:24 django systemd[1]: Listening on gunicorn socket.
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 - django gunicorn daemon
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 - django gunicorn daemon
Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
Active: active (running) since Thu 2022-06-30 01:45:09 UTC; 12s ago
TriggeredBy: ? gunicorn.socket
Main PID: 42365 (gunicorn)
Tasks: 4 (limit: 2241)
Memory: 91.7M
CPU: 1.128s
CGroup: /system.slice/gunicorn.service
??42365 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
??42366 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
??42367 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
??42368 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
Jun 30 01:45:09 django systemd[1]: Started django gunicorn daemon.
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Starting gunicorn 20.1.0
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Listening at: unix:/run/gunicorn.sock (42365)
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Using worker: sync
Jun 30 01:45:09 django gunicorn[42366]: [2022-06-30 01:45:09 +0000] [42366] [INFO] Booting worker with pid: 42366
.......
Installer Nginx
La dernière étape consiste à installer et configurer Nginx. Ubuntu 22.04 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.
Importez la clé de signature de Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Ajoutez le dépôt pour la version stable de Nginx.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list
Mettez à jour les dépôts du système.
$ sudo apt update
Installez Nginx.
$ sudo apt install nginx
Vérifiez l’installation.
$ nginx -v
nginx version: nginx/1.22.0
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.
server {
listen 80;
server_name server_domain_or_IP;
location = /favicon.ico { access_log off; log_not_found off; }
location /static/ {
root /home/navjot/dj-sample;
}
location / {
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_pass http://unix:/run/gunicorn.sock;
}
}
Remplacez l’emplacement racine dans le fichier ci-dessus par le répertoire de 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 pas d’erreurs, 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
Démarrez le serveur Nginx.
$ sudo systemctl start nginx
Ouvrez le port HTTP. Vous pouvez également supprimer le port 8000 si vous ne comptez plus l’utiliser.
$ sudo ufw delete allow 8000
$ sudo ufw allow http
Vérifiez en ouvrant l’URL http://django.example.com et la page d’accueil Django se chargera.
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 est déjà installé sur un système Ubuntu 22.04.
Installez le dépôt Snapd de base.
$ sudo snap install 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 --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d django.example.com
Ouvrez d’abord le port HTTPS.
$ sudo ufw allow https
Visitez l’URL https://django.example.com dans votre navigateur pour confirmer.
Conclusion
Cela conclut notre tutoriel, où vous avez appris à installer Django, Gunicorn et Nginx sur un serveur Ubuntu 22.04. Vous avez également installé un certificat SSL pour améliorer la sécurité de votre projet Django. Si vous avez des questions, posez-les dans les commentaires ci-dessous.
Recevez de nouveaux articles dans votre boîte de réception.
Aucun spam. Désabonnez-vous à tout moment.