Améliorez votre projet Django avec ces bonnes pratiques

par Ofir Chakon

Django est un framework robuste, open source, basé sur Python pour créer des applications Web. Sa popularité a augmenté au cours des deux dernières années, et il est déjà mature et largement utilisé avec une large communauté derrière lui.

Parmi les autres frameworks basés sur Python pour créer des applications Web (comme Flask et Pyramid), Django est de loin le plus populaire. Il prend en charge à la fois Python version 2.7 et Python 3.6. Mais au moment de cet article, Python 2.7 est toujours la version la plus accessible en termes de communauté, de packages tiers et de documentation en ligne. Django est sécurisé lorsqu’il est utilisé correctement et offre une grande flexibilité. C'est la voie à suivre lors du développement d'applications côté serveur à l'aide de Python.

En tant que développeur Python et Django expérimenté, je partagerai avec vous quelques bonnes pratiques pour une configuration Django que j'ai apprises et collectées au fil des années. Que vous ayez quelques projets Django à votre actif ou que vous soyez sur le point de démarrer votre premier à partir de zéro, les meilleures pratiques décrites ici pourraient vous aider à créer de meilleures applications à l'avenir.

J'ai écrit cet article dans un état d'esprit très pratique afin que vous puissiez ajouter immédiatement des outils à votre boîte à outils de développement. Vous pouvez même créer un passe-partout Django personnalisé avancé pour vos prochains projets.

Pour les besoins de cet article, je suppose que vous utilisez une machine Linux Ubuntu. Tout au long de l'article, certaines lignes de code commencent par un signe $. Ceux-ci sont utilisés pour souligner que cette ligne doit être insérée dans le terminal. Assurez-vous de copier la ligne sans le signe $.

Environnement virtuel

Lors du développement d'applications basées sur Python, l'utilisation de packages tiers est une activité permanente. Ces packages sont souvent mis à jour, il est donc essentiel de les garder organisés. Lorsque l’on développe de plus en plus de projets sur la même machine locale, il est difficile de suivre la version actuelle de chaque package. Il est impossible d’utiliser différentes versions du même package pour différents projets. De plus, la mise à jour d'un package sur un projet peut interrompre les fonctionnalités d'un autre, et vice versa.

C'est là que l'environnement virtuel Python s'avère utile. Pour installer l'environnement virtuel, utilisez :

$ apt-get update
$ apt-get install python-pip python-dev build-essential

$ export LC_ALL="en_US.UTF-8" # might be necessary in case you get an error from the next line

$ pip install --upgrade pip
$ pip install --upgrade virtualenv
$ mkdir ~/.virtualenvs
$ pip install virtualenvwrapper
$ export WORKON_HOME=~/.virtualenvs
$ nano ~/.bashrc

Ajoutez cette ligne à la fin du fichier :

. /usr/local/bin/virtualenvwrapper.sh

Exécutez ensuite :

$ . .bashrc

Après l'installation, créez un nouvel environnement virtuel pour votre projet en tapant :

$ mkvirtualenv project_name

Pendant que vous êtes dans le contexte de votre environnement virtuel, vous remarquerez qu'un préfixe est ajouté au terminal, comme :

(project_name) ofir@playground:~$

Afin de désactiver (quitter) l'environnement virtuel et revenir au contexte Python principal de votre machine locale, utilisez :

$ deactivate

Afin d'activer (démarrer) le contexte de l'environnement virtuel, utilisez :

$ workon project_name

Pour lister les environnements virtuels existants sur votre machine locale, utilisez :

$ lsvirtualenv

Conserver les dépendances de votre projet (packages) dans un environnement virtuel sur votre machine vous permet de les conserver dans un environnement isolé. Vous ne les utilisez que pour un seul (ou plusieurs) projets. Lors de la création d’un nouvel environnement virtuel, vous démarrez un nouvel environnement sans aucun package installé. Ensuite vous pouvez utiliser par exemple :

(project_name) $ pip install Django

pour installer Django dans votre environnement virtuel, ou :

(project_name) $ pip install Django==1.11

pour installer la version 1.11 de Django accessible uniquement depuis l'environnement.

Ni votre interpréteur Python principal ni les autres environnements virtuels de votre machine ne pourront accéder au nouveau package Django que vous venez d'installer.

Pour utiliser la commande runserver en utilisant votre environnement virtuel, dans le contexte de l'environnement virtuel, utilisez :

(project_name) $ cd /path/to/django/project
(project_name) $ ./manage.py runserver

De même, lorsque vous entrez dans l’interpréteur Python depuis l’environnement virtuel, tapez :

(project_name) $ python

Il aura accès aux packages que vous avez déjà installés dans l’environnement.

Exigences

Les exigences sont la liste des packages Python (dépendances) que votre projet utilise pendant son exécution, y compris la version de chaque package. Voici un exemple de fichier requirements.txt :

dicttoxml==1.7.4
Django==1.11.2
h5py==2.7.0
matplotlib==2.0.2
numpy==1.13.0
Pillow==4.1.1
psycopg2==2.7.1
pyparsing==2.2.0
python-dateutil==2.6.0
pytz==2017.2
six==1.10.0
xmltodict==0.11.0

Garder votre fichier requirements.txt à jour est essentiel pour collaborer correctement avec d'autres développeurs. C’est également important pour que votre environnement de production soit correctement configuré. Ce fichier, lorsqu'il est inclus dans votre référentiel de code, vous permet de mettre à jour tous les packages installés dans votre environnement virtuel en exécutant une seule ligne dans le terminal. Vous pourrez alors lancer de nouveaux développeurs en un rien de temps.

Afin de générer un nouveau requirements.txt ou d'en mettre à jour un existant, utilisez depuis votre environnement virtuel :

(project_name) $ pip freeze > requirements.txt

Pour votre commodité, assurez-vous d'exécuter cette commande dans un dossier suivi par votre référentiel Git. Cela permet à d'autres instances du code d'avoir également accès au fichier requirements.txt.

Si un nouveau développeur rejoint l'équipe, ou si vous souhaitez configurer un nouvel environnement en utilisant les mêmes packages répertoriés dans le fichier requirements.txt, exécutez dans le contexte de l'environnement virtuel :

(project_name) $ cd /path/to/requirements/file
(project_name) $ pip install -r requirements.txt

Toutes les exigences répertoriées dans le fichier seront immédiatement installées dans votre environnement virtuel. Les anciennes versions seront mises à jour et les versions plus récentes seront rétrogradées pour correspondre à la liste exacte de requirements.txt. Attention cependant : il peut y avoir des différences entre les environnements que vous souhaitez tout de même respecter.

Je recommande fortement d'intégrer ces commandes à votre flux de travail. Mettez à jour le fichier Requirements.txt avant de transférer le code vers le référentiel et installez le fichier Requirements.txt après avoir extrait le code du référentiel.

Meilleure configuration de settings.py

Django est livré prêt à l'emploi avec un fichier settings.py très basique mais utile. Celui-ci définit les configurations principales et les plus utiles pour votre projet. Le fichier settings.py est très simple. Mais parfois, en tant que développeur travaillant en équipe ou lors de la configuration d'un environnement de production, vous avez besoin de plusieurs fichiers settings.py de base.

Plusieurs fichiers de paramètres vous permettent de définir facilement des configurations sur mesure pour chaque environnement séparément, comme :

ALLOWED_HOSTS # for production environment
DEBUG
DATABASES # for different developers on the same team

Permettez-moi de vous présenter une approche étendue pour configurer votre fichier settings.py. Il vous permet de conserver différentes versions et d'utiliser celle que vous souhaitez à tout moment et dans n'importe quel environnement.

Tout d’abord, accédez au chemin de votre fichier settings.py :

(project_name) $ cd /path/to/settings/file

Créez ensuite un nouveau module appelé settings (le module est un dossier contenant un fichier __init__.py) :

(project_name) $ mkdir settings

Maintenant, renommez votre fichier settings.py en base.py et placez-le dans le nouveau module que vous avez créé :

(project_name) $ mv settings.py settings/base.py

Pour cet exemple, je suppose que vous souhaitez configurer un fichier de paramètres pour votre environnement de développement et un autre pour votre environnement de production. Différents développeurs d'une même équipe peuvent utiliser exactement la même approche pour définir différents fichiers de paramètres.

Pour votre environnement de développement, créez :

(project_name) $ nano settings/development.py

Tapez ensuite :

from .base import *

DEBUG = True

et enregistrez le fichier en appuyant sur Ctrl + O, Entrée puis Ctrl + X.

Pour votre environnement de production, créez :

(project_name) $ nano settings/production.py

et tapez :

from .base import *

DEBUG = False
ALLOWED_HOSTS = [‘app.project_name.com’, ]

Désormais, chaque fois que vous souhaitez ajouter ou mettre à jour les paramètres d'un environnement spécifique, vous pouvez facilement le faire dans son propre fichier de paramètres.

Vous vous demandez peut-être : comment Django sait-il quel fichier de paramètres charger sur chaque environnement ? C'est à cela que sert le fichier __init__.py. Lorsque Django recherche le settings.py qu'il chargeait lors de l'exécution du serveur, par exemple, il trouve désormais un module de paramètres plutôt qu'un fichier settings.py. Mais tant qu’il s’agit d’un module contenant un fichier __init__.py, pour Django, c’est exactement la même chose. Django chargera le fichier __init__.py et exécutera tout ce qui y est écrit.

Par conséquent, nous devons définir le fichier de paramètres que nous voulons charger dans le fichier __init__.py en exécutant :

(project_name) $ settings/__init__.py

puis, pour un environnement de production, par exemple, en tapant :

from .production import *

De cette façon, Django chargera tous les paramètres base.py et production.py à chaque démarrage. La magie?

Désormais, la seule configuration restante est de conserver le __init__.py dans votre fichier .gitignore afin qu'il ne soit pas inclus dans les push et les pulls. Une fois que vous avez configuré un nouvel environnement, n'oubliez pas de créer un nouveau fichier __init__.py dans le module de paramètres. Importez ensuite le fichier de paramètres requis exactement comme nous l’avons fait auparavant.

Dans cet article, nous avons couvert trois bonnes pratiques pour mieux configurer votre projet Django :

• Travailler dans un environnement virtuel
• Garder le fichier requirements.txt à jour et l'utiliser en continu dans votre flux de travail
• Configuration d'un meilleur tableau de paramètres de projet

Avez-vous suivi ces bonnes pratiques dans votre dernier projet ? Avez-vous des idées à partager ? Les commentaires sont très appréciés.

Avez-vous trouvé cela utile? Si c'est le cas, s'il vous plaît, applaudissez-moi pour que davantage de personnes voient l'article.

Ceci est la première partie de la série sur les meilleures pratiques pour le développement de Django. Suivez-moi pour obtenir une mise à jour immédiate une fois que les prochaines pièces seront disponibles.

Trouvez d’autres bons conseils pour les entrepreneurs technologiques sur CodingStartups.