Comment configurer l'environnement de développement Django sur Ubuntu 18.04

Django est un framework Web puissant qui peut vous aider à faire décoller votre application Python ou votre site Web. Django inclut un serveur de développement simplifié pour tester votre code localement, mais pour tout ce qui concerne même légèrement la production, un serveur Web plus sécurisé et plus puissant est requis (Nginx - Apache).

Dans ce guide, nous montrerons comment installer et configurer certains composants sur Ubuntu 18.04 pour prendre en charge et servir les applications Django. Nous allons configurer une base de données PostgreSQL au lieu d'utiliser la base de données SQLite par défaut. Nous allons configurer le serveur d'application Gunicorn pour s'interfacer avec nos applications. Nous configurerons ensuite Nginx pour inverser le proxy vers Gunicorn, nous donnant accès à ses fonctionnalités de sécurité et de performance pour servir nos applications.

Créer un utilisateur non root avec les privilèges sudo configurés

Se connecter en tant que root
Création d'un nouvel utilisateur
```
# adduser bobby
```
Accorder des privilèges administratifs
Pour ajouter ces privilèges à notre nouvel utilisateur, nous devons ajouter le nouvel utilisateur au groupe sudo. Par défaut, sur Ubuntu 18.04, les utilisateurs appartenant au groupe sudo sont autorisés à utiliser la commande sudo.
```
# usermod -aG sudo bobby
```

Installez les packages à partir des référentiels Ubuntu

Pour commencer le processus, nous allons télécharger et installer tous les éléments dont nous avons besoin à partir des référentiels Ubuntu. Nous utiliserons le pip du gestionnaire de packages Python pour installer des composants supplémentaires un peu plus tard.
Nous devons mettre à jour l'index local des packages apt, puis télécharger et installer les packages. Les packages que nous installons dépendent de la version de Python que votre projet utilisera.
Installation de Django avec Python 3, tapez :

$ sudo apt-get update
$ sudo apt-get install python3-pip python3-dev libpq-dev postgresql postgresql-contrib nginx

Cela installera pip, les fichiers de développement Python nécessaires pour construire Gunicorn plus tard, le système de base de données Postgres et les bibliothèques nécessaires pour interagir avec lui, et le serveur Web Nginx.

Créer la base de données et l'utilisateur PostgreSQL

Nous allons nous lancer directement et créer une base de données et un utilisateur de base de données pour notre application Django. Par défaut, Postgres utilise un schéma d'authentification appelé authentification par les pairs pour les connexions locales. En gros, cela signifie que si le nom d'utilisateur du système d'exploitation de l'utilisateur correspond à un nom d'utilisateur Postgres valide, cet utilisateur peut se connecter sans autre authentification.

Lors de l'installation de Postgres, un utilisateur du système d'exploitation nommé postgres a été créé pour correspondre à l'utilisateur administratif postgres PostgreSQL. Nous devons utiliser cet utilisateur pour effectuer des tâches administratives. Nous pouvons utiliser sudo et transmettre le nom d'utilisateur avec l'option -u.

Connectez-vous à une session Postgres interactive en tapant :

$ sudo -u postgres psql

Vous recevrez une invite PostgreSQL où nous pourrons configurer nos exigences.

Tout d'abord, créez une base de données pour votre projet

Postgres=# CREATE DATABASE newproject;

Remarque : Chaque instruction Postgres doit se terminer par un point-virgule

Ensuite, créez un utilisateur de base de données pour notre projet. Assurez-vous de sélectionner un mot de passe sécurisé

Postgres=# CREATE USER newprojectuser WITH PASSWORD 'password';

Ensuite, nous modifierons quelques-uns des paramètres de connexion pour l'utilisateur que nous venons de créer. Cela accélérera les opérations de la base de données afin que les valeurs correctes n'aient pas à être interrogées et définies à chaque fois qu'une connexion est établie.

Nous définissons l'encodage par défaut sur UTF-8, ce que Django attend. Nous définissons également le schéma d'isolement des transactions par défaut sur lecture validée, ce qui bloque les lectures à partir de transactions non validées. Enfin, nous définissons le fuseau horaire. Par défaut, nos projets Django seront configurés pour utiliser UTC. Ce sont toutes des recommandations du projet Django lui-même.

Postgres=# ALTER ROLE newprojectuser SET client_encoding TO 'utf8';
Postgres=# ALTER ROLE newprojectuser SET default_transaction_isolation TO 'read committed';
Postgres=# ALTER ROLE newprojectuser SET timezone TO 'UTC';

Maintenant, nous pouvons donner à notre nouvel utilisateur l'accès pour administrer notre nouvelle base de données

Postgres=# GRANT ALL PRIVILEGES ON DATABASE newproject TO newprojectuser;

Lorsque vous avez terminé, quittez l'invite PostgreSQL en tapant :

Postgres=# \q

Créer un environnement virtuel Python 3 pour votre projet

Maintenant que nous avons notre base de données, nous pouvons commencer à préparer le reste des exigences de notre projet. Nous installerons nos exigences Python 3 dans un environnement virtuel pour une gestion plus facile.

Pour ce faire, nous devons d'abord accéder à la commande virtualenv. Nous pouvons l'installer avec pip3.

Mettez à niveau pip3 et installez le package en tapant :

  $ sudo -H pip3 install --upgrade pip
  $ sudo -H pip3 install virtualenv

Avec virtualenv installé, nous pouvons commencer à former notre projet. Créez et déplacez-vous dans un répertoire où nous pouvons conserver nos fichiers de projet :

  $ mkdir ~/djangoproject
  $ cd ~/djangoproject

Dans le répertoire du projet, créez un environnement virtuel Python en tapant :

$ virtualenv djangoprojectenv

Cela créera un répertoire appelé djangoprojectenv dans votre djangoproject annuaire. À l'intérieur, il installera une version locale de Python et une version locale de pip. Nous pouvons l'utiliser pour installer et configurer un environnement Python isolé pour notre projet.

Avant d'installer les exigences Python de notre projet, nous devons activer l'environnement virtuel. Vous pouvez le faire en tapant :

$ source djangoproject/bin/activate

Votre invite devrait changer pour indiquer que vous travaillez maintenant dans un environnement virtuel Python. Cela ressemblera à ceci :(djangoprojectenv)user@host:~/djangoproject$ .
Avec votre environnement virtuel actif, installez Django, Gunicorn et l'adaptateur psycopg2 PostgreSQL avec l'instance locale de pip :

Remarque : Quelle que soit la version de Python 3 ou Python 2 que vous utilisez, lorsque l'environnement virtuel est activé, vous devez utiliser la commande pip (pas pip3).

(djangoprojectenv)$ pip install django gunicorn psycopg2-binary

Vous devriez maintenant avoir tous les logiciels nécessaires pour démarrer un projet Django.

Créer et configurer un nouveau projet Django

Avec nos composants Python installés, nous pouvons créer les fichiers de projet Django réels.

Puisque nous avons déjà un répertoire de projet, nous dirons à Django d'installer les fichiers ici. Il créera un répertoire de second niveau avec le code réel, ce qui est normal, et placera un script de gestion dans ce répertoire. La clé est que nous définissons explicitement le répertoire au lieu de permettre à Django de prendre des décisions relatives à notre répertoire actuel :

(djangoprojectenv)$ django-admin.py startproject djangoproject ~/djangoproject

À ce stade, votre répertoire de projet (~/djangoproject dans notre cas) doit avoir le contenu suivant :

~/djangoproject/manage.py :Un script de gestion de projet Django.
~/djangoproject/myproject/ :Le package du projet Django. Cela devrait contenir le __init__.py , settings.py , urls.py , et wsgi.py fichiers.
~/djangoproject/djangoprojectenv/ :Le répertoire de l'environnement virtuel que nous avons créé précédemment.

La première chose que nous devrions faire avec nos fichiers de projet nouvellement créés est d'ajuster les paramètres. Ouvrez le fichier de paramètres dans votre éditeur de texte :

(djangoprojectenv)$ nano ~/djangoproject/djangoproject/settings.py

Commencez par localiser la directive ALLOWED_HOSTS. Cela définit une liste d'adresses de serveur ou de noms de domaine pouvant être utilisés pour se connecter à l'instance de Django. Toute demande entrante avec un en-tête Host qui ne figure pas dans cette liste déclenchera une exception. Django exige que vous définissiez ceci pour empêcher une certaine classe de vulnérabilité de sécurité.

Entre crochets, indiquez les adresses IP ou les noms de domaine associés à votre serveur Django. Chaque élément doit être répertorié entre guillemets avec des entrées séparées par une virgule. Si vous souhaitez des demandes pour un domaine entier et des sous-domaines, ajoutez un point au début de l'entrée. Dans l'extrait ci-dessous, il y a quelques exemples commentés utilisés pour démontrer.

~/djangoproject/djangoproject/settings.py
. . .
# The simplest case: just add the domain name(s) and IP addresses of your Django server
# ALLOWED_HOSTS = [ 'example.com', '203.0.113.5']
# To respond to 'example.com' and any subdomains, start the domain with a dot
# ALLOWED_HOSTS = ['.example.com', '103.25.111.5']
ALLOWED_HOSTS = ['your_server_domain_or_IP', 'second_domain_or_IP', . . .]

Ensuite, recherchez la section qui configure l'accès à la base de données. Cela commencera par DATABASES. La configuration dans le fichier est pour une base de données SQLite. Nous avons déjà créé une base de données PostgreSQL pour notre projet, nous devons donc ajuster les paramètres.

Modifiez les paramètres avec les informations de votre base de données PostgreSQL. Nous disons à Django d'utiliser le psycopg2adaptor que nous avons installé avec pip. Nous devons donner le nom de la base de données, le nom d'utilisateur de la base de données, le mot de passe de l'utilisateur de la base de données, puis spécifier que la base de données se trouve sur l'ordinateur local. Vous pouvez laisser le paramètre PORT sous forme de chaîne vide :

~/djangoproject/djangoproject/settings.py
. . .
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'newproject',
        'USER': 'newprojectuser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}
. . .

Ensuite, descendez au bas du fichier et ajoutez un paramètre indiquant où les fichiers statiques doivent être placés. Cela est nécessaire pour que Nginx puisse gérer les demandes de ces éléments. La ligne suivante indique à Django de les placer dans un répertoire appelé static dans le répertoire de base du projet :

~/djangoproject/djangoproject/settings.py
. . .
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Enregistrez et fermez en tapant Ctrl + x le fichier lorsque vous avez terminé.
Maintenant, nous pouvons migrer le schéma de base de données initial vers notre base de données PostgreSQL en utilisant le script de gestion :

(djangoprojectenv)$ ~/djangoproject/manage.py makemigrations
(djangoprojectenv)$ ~/djangoproject/manage.py migrate

Créez un utilisateur administratif pour le projet en tapant :

(djangoprojectenv)$ ~/djangoproject/manage.py createsuperuser

Vous devrez sélectionner un nom d'utilisateur, fournir une adresse e-mail, puis choisir et confirmer un mot de passe.
Nous pouvons collecter tout le contenu statique dans l'emplacement du répertoire que nous avons configuré en tapant :

(djangoprojectenv)$ ~/djangoproject/manage.py collectstatic

Vous devrez confirmer l'opération. Les fichiers statiques seront ensuite placés dans un répertoire appelé static au sein de votre répertoire de projet.

Si vous avez suivi le guide de configuration initiale du serveur, vous devriez avoir un pare-feu UFW protégeant votre serveur. Afin de tester le serveur de développement, nous devrons autoriser l'accès au port que nous utiliserons.

Créez une exception pour le port 8000 en tapant :

(djangoprojectenv)$ sudo ufw allow 8000

Enfin, vous pouvez tester votre projet en démarrant le serveur de développement Django avec cette commande :

(djangoprojectenv)$ ~/djangoproject/manage.py runserver 0.0.0.0:8000

Dans votre navigateur Web, visitez le nom de domaine ou l'adresse IP de votre serveur suivi de :8000:

http://server_domain_or_IP:8000

Vous devriez voir la page d'index Django par défaut pour Django 2.0.7 :

Si vous tapez http://server_domain_or_IP:8000/admin dans la barre d'adresse, vous serez invité à entrer le nom d'utilisateur et le mot de passe administratifs que vous avez créés avec la commande createsuperuser :

Après authentification, vous pouvez accéder à l'interface d'administration par défaut de Django :

Lorsque vous avez terminé d'explorer, appuyez sur CTRL-C dans la fenêtre du terminal pour arrêter le serveur de développement.

Tester la capacité de Gunicorn à servir le projet

La dernière chose que nous voulons faire avant de quitter notre environnement virtuel est de tester Gunicorn pour nous assurer qu'il peut servir l'application. Nous pouvons le faire en entrant dans notre répertoire de projet et en utilisant gunicorn pour charger le module WSGI du projet :

(djangoprojectenv)$ cd ~/djangoproject
(djangoprojectenv)$ gunicorn --bind 0.0.0.0:8000 djangoproject.wsgi

Cela démarrera Gunicorn sur la même interface que celle sur laquelle le serveur de développement Django fonctionnait. Vous pouvez revenir en arrière et tester à nouveau l'application.

Remarque : L'interface d'administration n'aura aucun style appliqué puisque Gunicorn ne connaît pas le contenu CSS statique responsable de cela.

Nous avons passé un module à Gunicorn en spécifiant le chemin relatif du répertoire vers le fichier wsgi.py de Django, qui est le point d'entrée de notre application, en utilisant la syntaxe de module de Python. À l'intérieur de ce fichier, une fonction appelée application est définie, qui est utilisée pour communiquer avec l'application.

Lorsque vous avez terminé les tests, appuyez sur CTRL-C dans la fenêtre du terminal pour arrêter Gunicorn.

Nous avons maintenant terminé la configuration de notre application Django. Nous pouvons sortir de notre environnement virtuel en tapant :

(myprojectenv)$ deactivate

L'indicateur d'environnement virtuel dans votre invite sera supprimé.

Créer un fichier de service Gunicorn systemd

Nous avons testé que Gunicorn peut interagir avec notre application Django, mais nous devrions implémenter une manière plus robuste de démarrer et d'arrêter le serveur d'application. Pour ce faire, nous allons créer un fichier de service systemd.

Créez et ouvrez un fichier de service systemd pour Gunicorn avec les privilèges sudo dans votre éditeur de texte :

$ sudo nano /etc/systemd/system/gunicorn.service

Commencez par le [Unit] section, qui est utilisée pour spécifier les métadonnées et les dépendances. Nous allons mettre une description de notre service ici et dire au système d'initialisation de ne le démarrer qu'une fois que l'objectif de mise en réseau a été atteint.

Ensuite, nous allons ouvrir le [Service] section. Nous allons spécifier l'utilisateur et le groupe sous lesquels nous voulons traiter. Nous donnerons à notre compte d'utilisateur habituel la propriété du processus puisqu'il possède tous les fichiers pertinents. Nous donnerons la propriété de groupe aux www-data groupe afin que Nginx puisse communiquer facilement avec Gunicorn.

Nous allons ensuite mapper le répertoire de travail et spécifier la commande à utiliser pour démarrer le service. Dans ce cas, nous devrons spécifier le chemin complet vers l'exécutable Gunicorn, qui est installé dans notre environnement virtuel. Nous allons le lier à un socket Unix dans le répertoire du projet puisque Nginx est installé sur le même ordinateur. C'est plus sûr et plus rapide que d'utiliser un port réseau. Nous pouvons également spécifier ici les ajustements facultatifs de Gunicorn. Par exemple, nous avons spécifié 3 processus de travail dans ce cas.

Enfin, nous ajouterons un [Install] section. Cela indiquera à systemd à quoi lier ce service si nous lui permettons de démarrer au démarrage. Nous souhaitons que ce service démarre lorsque le système multi-utilisateurs standard est opérationnel :

/etc/systemd/system/gunicorn.service
[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/djangoproject
ExecStart=/home/bobby/djangoproject/djangoproject/bin/gunicorn --access-logfile - --workers 3 --bind unix:/home/bobby/djangoproject/djangoproject.sock djangoproject.wsgi:application

[Install]
WantedBy=multi-user.target

Avec cela, notre fichier de service systemd est terminé. Enregistrez et fermez-le maintenant.

nous devrions ajouter l'utilisateur bobby au groupe www-data :

$ sudo usermod –a –G www-data bobby

Nous pouvons maintenant démarrer le service Gunicorn que nous avons créé et l'activer pour qu'il démarre au démarrage :

$ sudo systemctl start gunicorn
$ sudo systemctl enable gunicorn

Nous pouvons confirmer que l'opération a réussi en vérifiant le fichier socket.

Vérifiez l'état du processus pour savoir s'il a pu démarrer :

$ sudo systemctl status gunicorn

Ensuite, vérifiez l'existence du djangoproject.sock fichier dans votre répertoire de projet :

$ ls /home/bobby/djangoproject
Output
manage.py  djangoproject  djangoprojectenv  djangoproject.sock  static

Si la commande systemctl status a indiqué qu'une erreur s'est produite ou si vous ne trouvez pas le djangoproject.sock fichier dans le répertoire, c'est une indication que Gunicorn n'a pas pu démarrer correctement. Vérifiez les journaux de processus Gunicorn en tapant :

$ sudo journalctl -u gunicorn

Jetez un œil aux messages dans les journaux pour savoir où Gunicorn a rencontré des problèmes. Il existe de nombreuses raisons pour lesquelles vous avez pu rencontrer des problèmes, mais souvent, si Gunicorn n'a pas pu créer le fichier socket, c'est pour l'une des raisons suivantes :

Les fichiers du projet appartiennent à l'utilisateur root au lieu d'un utilisateur sudo
Le WorkingDirectory chemin dans /etc/systemd/system/gunicorn.service le fichier ne pointe pas vers le répertoire du projet
Les options de configuration données au processus gunicorn dans ExecStart directive ne sont pas correctes. Vérifiez les éléments suivants :
- Le chemin vers le binaire gunicorn pointe vers l'emplacement réel du binaire dans l'environnement virtuel
- Le --bind La directive définit un fichier à créer dans un répertoire auquel Gunicorn peut accéder
- Le djangoproject.wsgi:application est un chemin précis vers l'appelable WSGI. Cela signifie que lorsque vous êtes dans le répertoire de travail, vous devriez pouvoir accéder à l'application nommée appelable en regardant dans le djangoproject.wsgi module (qui se traduit par un fichier appelé ./djangoproject/wsgi.py )

Si vous apportez des modifications au fichier /etc/systemd/system/gunicorn.service, rechargez le démon pour relire la définition du service et redémarrez le processus Gunicorn en tapant :

$ sudo systemctl daemon-reload
$ sudo systemctl restart gunicorn

Assurez-vous de résoudre l'un des problèmes ci-dessus avant de continuer.

Configurer Nginx pour passer le proxy à Gunicorn

Maintenant que Gunicorn est configuré, nous devons configurer Nginx pour transmettre le trafic au processus. Commencez par créer et ouvrir un nouveau bloc de serveur dans le répertoire sites-available de Nginx :

$ sudo nano /etc/nginx/sites-available/djangoproject

À l'intérieur, ouvrez un nouveau bloc de serveur. Nous commencerons par préciser que ce bloc doit écouter sur le port normal 80 et qu'il doit répondre au nom de domaine ou à l'adresse IP de notre serveur.

Ensuite, nous dirons à Nginx d'ignorer tout problème de recherche de favicon. Nous lui indiquerons également où trouver les assets statiques que nous avons collectés dans notre ~/djangoproject/static annuaire. Tous ces fichiers ont un préfixe URI standard de "/static" , afin que nous puissions créer un bloc d'emplacement correspondant à ces demandes.

Enfin, nous allons créer un bloc location / {} pour correspondre à toutes les autres requêtes. À l'intérieur de cet emplacement, nous inclurons le standard proxy_params fichier inclus avec l'installation de Nginx, puis nous transmettrons le trafic au socket créé par notre processus Gunicorn :

/etc/nginx/sites-available/djangoproject
server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/bobby/djangoproject;
    }
    location / {
        include proxy_params;
        proxy_pass http://unix:/home/bobby/djangoproject/djangoproject.sock;
    }
}

Enregistrez et fermez le fichier lorsque vous avez terminé. Maintenant, nous pouvons activer le fichier en le liant au sites-enabled répertoire :

$ sudo ln -s /etc/nginx/sites-available/djangoproject /etc/nginx/sites-enabled

Testez votre configuration Nginx pour les erreurs de syntaxe en tapant :

$ sudo nginx -t

Si aucune erreur n'est signalée, continuez et redémarrez Nginx en tapant :

$ sudo systemctl restart nginx

Enfin, nous devons ouvrir notre pare-feu au trafic normal sur le port 80. Comme nous n'avons plus besoin d'accéder au serveur de développement, nous pouvons également supprimer la règle pour ouvrir le port 8000 :

$ sudo ufw delete allow 8000
$ sudo ufw allow 'Nginx Full'

Vous devriez maintenant pouvoir accéder au domaine ou à l'adresse IP de votre serveur pour afficher votre application.