Comment exécuter Django avec mod_wsgi et Apache avec un environnement virtuel Python sur un VPS Debian

Introduction

Travailler avec des applications Django, et des applications Python en général, est une affaire complexe avec de nombreux outils en usage. Il existe plusieurs manières d'atteindre le même objectif et souvent il n'y a pas une seule façon de faire les choses.

L'une des façons les plus populaires de déployer des applications Django sur le web sur un serveur dédié est d'utiliser Nginx associé à Gunicorn. Une excellente façon de le faire a déjà été décrite en profondeur dans cet article. Cependant, il est assez courant d'héberger des applications Django aux côtés de sites web existants servis avec Apache. Nous allons essayer de couvrir la solution rapide pour atteindre cet objectif particulier. Veuillez noter, cependant, qu'il ne s'agit pas d'un guide définitif sur l'association Django et Apache et qu'il y a des aspects de configuration non couverts ici.

Ce texte fera plusieurs hypothèses :

• Vous avez déjà configuré votre droplet avec Debian 7.0 ou une version ultérieure. Il existe de nombreuses différences entre les différentes distributions Linux ; par conséquent, pour plus de clarté, nous nous concentrerons sur un serveur Debian.

• Vous êtes au moins un peu familiarisé avec des outils Python courants tels que le gestionnaire de packages pip et virtualenv pour créer des environnements virtuels. Ces outils sont merveilleusement expliqués dans cet article.

• Vous êtes au moins quelque peu familiarisé avec la structure des projets Django, car cet article n'a pas pour but de vous guider dans l'utilisation et la configuration de Django lui-même.

• Vous êtes familiarisé avec l'administration de base d'Apache, car ce tutoriel ne couvrira que l'installation simple du serveur lui-même et les modifications de configuration nécessaires pour associer Django à Apache.

Conditions préalables

Avant d'installer de nouveaux paquets, il est toujours bon de mettre à jour les paquets de votre système et les index des paquets. Pour ce faire, exécutez :

apt-get update
apt-get upgrade

Installation d'Apache

Puisque ce texte se concentre sur l'utilisation d'Apache pour servir l'application, le serveur lui-même est nécessaire. Pour installer les packages nécessaires, exécutez :

apt-get install apache2

Juste après l'installation, Apache sera déjà en cours d'exécution. Vous pouvez vérifier si le serveur web Apache a été correctement configuré en ouvrant votre navigateur web et en le dirigeant vers l'adresse IP du serveur. Vous devriez voir une simple page Ça fonctionne ! à l'écran.

Installer pip et virtualenv

Pour commencer à travailler avec Python et Django sur un serveur web, pip et virtualenv doivent d'abord être installés. Pip est un gestionnaire de paquets Python qui facilite l'installation des paquets logiciels Python tels que Django lui-même, tandis que virtualenv permet de créer des environnements virtuels séparés pour les applications Python afin de séparer les bibliothèques nécessaires pour différentes applications et d'éviter les conflits de version entre elles.

Pour ce faire, exécutez :

apt-get install python-pip python-virtualenv

Cette commande installera pip et virtualenv à partir du dépôt de paquets Debian. Vous pouvez vérifier que les deux outils ont été correctement installés en les exécutant avec l'option --version.

root@django:~# virtualenv --version
1.7.1.2
root@django:~# pip --version
pip 1.1 from /usr/lib/python2.7/dist-packages (python 2.7)
root@django:~#

Créer un environnement virtuel en utilisant virtualenv

Lors de l'installation d'Apache, un répertoire /var/www est automatiquement créé, dans lequel la racine du serveur Web par défaut est configurée. Nous y mettrons notre nouvelle application Django avec toutes ses dépendances.

Créons un nouveau répertoire appelé sampleapp à l'intérieur de ce répertoire et accédons au nouveau répertoire :

cd /var/www
mkdir sampleapp
cd sampleapp

Créons ensuite un nouvel environnement virtuel en utilisant virtualenv. Un environnement virtuel Python est essentiellement un répertoire dans lequel l'interpréteur Python et une instance locale de pip résident. L'instance locale de pip installe tous les packages à l'intérieur de l'environnement virtuel. De cette façon, aucun package installé ne pollue l'installation globale de Python et il n'y a également aucune possibilité de conflit de versions de package dans un scénario hypothétique où deux applications exécutent deux versions différentes de Django ou de toute autre bibliothèque.

Pour créer un nouvel environnement virtuel, saisissez :

virtualenv env

où env est le nom de l'environnement virtuel - cela pourrait être n'importe quel autre mot. La sortie de cette commande devrait ressembler à ceci :

root@django:/var/www/sampleapp# virtualenv env
New python executable in env/bin/python
Installing distribute.............................................................................................................................................................................................done.
Installing pip...............done.
root@django:/var/www/sampleapp#

L'environnement virtuel est maintenant prêt et peut être utilisé de deux manières différentes.

Une façon est d'exécuter des commandes en utilisant directement l'interpréteur de l'environnement virtuel. Avec cette méthode, il est nécessaire de toujours se souvenir d'exécuter le bon interpréteur ou instance de pip, car il y a une possibilité d'exécuter un interpréteur d'envergure système.

root@django:/var/www/sampleapp# env/bin/pip --version
pip 1.1 from /var/www/sampleapp/env/lib/python2.7/site-packages/pip-1.1-py2.7.egg (python 2.7)
root@django:/var/www/sampleapp# env/bin/python --version
Python 2.7.3
root@django:/var/www/sampleapp#

L'autre moyen est d'activer d'abord l'environnement, en utilisant

source env/bin/activate

le nom de l'environnement sera ensuite préfixé à la ligne de commande de cette manière

root@django:/var/www/sampleapp# source env/bin/activate
(env)root@django:/var/www/sampleapp#

et toutes les commandes exécutées utiliseront les versions de l'environnement virtuel local

(env)root@django:/var/www/sampleapp# pip --version
pip 1.1 from /var/www/sampleapp/env/lib/python2.7/site-packages/pip-1.1-py2.7.egg (python 2.7)
(env)root@django:/var/www/sampleapp# python --version
Python 2.7.3
(env)root@django:/var/www/sampleapp#

il est plus facile de travailler de cette façon ; cependant, il est nécessaire de désactiver l'environnement après que le travail est terminé en utilisant la commande suivante

deactivate

cela ramènera le shell à la normale

(env)root@django:/var/www/sampleapp# deactivate
root@django:/var/www/sampleapp#

L'environnement fraîchement créé sera utilisé pour stocker toutes les dépendances nécessaires, y compris Django et les bibliothèques associées. Il sera également utilisé par Apache et mod_wsgi plus tard pour servir l'application en utilisant les dépendances correctes.

Installer Django dans un environnement virtuel

La prochaine étape nécessaire est d'installer Django à l'intérieur de l'environnement virtuel. Faisons cela sans activer l'environnement au préalable en utilisant :

env/bin/pip install django

Les derniers messages affichés après l'exécution de cette commande devraient ressembler à ceci.

Successfully installed django
Cleaning up...

Django est maintenant installé dans un environnement virtuel et n'est pas disponible dans l'installation Python système. Vous pouvez vérifier ce comportement en important le module django en utilisant les deux interpréteurs.

root@django:/var/www/sampleapp# python
Python 2.7.3 (default, Mar 13 2014, 11:03:55)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named django
>>> exit()

L'importation en utilisant l'interpréteur système a échoué, alors que

root@django:/var/www/sampleapp# env/bin/python
Python 2.7.3 (default, Mar 13 2014, 11:03:55)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>>

celui exécuté à l'intérieur de l'environnement virtuel a réussi.

Créer le premier projet Django

Pour créer un projet d'exemple simple et basique, nous pouvons utiliser le script django-admin.py comme suit.

 env/bin/django-admin.py startproject sampleapp .

Veuillez noter le . à la fin de la commande - sans cela, le projet sera créé dans un sous-répertoire supplémentaire. Après avoir exécuté cette commande, un nouveau répertoire sampleapp et un script manage.py seront créés dans /var/www/sampleapp. Le script manage.py est utilisé pour exécuter des commandes Django pour ce projet particulier. L'une des utilisations possibles de manage.py est de faire fonctionner une instance de serveur de test pour vérifier que tout fonctionne comme prévu.

Veuillez exécuter :

env/bin/python manage.py runserver 0.0.0.0:8000

Cela lancera un serveur de test lié à toutes les interfaces sur le port 8000. La sortie devrait ressembler à ceci :

Validating models...

0 errors found
April 08, 2014 - 12:29:31
Django version 1.6.2, using settings 'sampleapp.settings'
Starting development server at http://0.0.0.0:8000/
Quit the server with CONTROL-C.

Si vous ouvrez l'adresse IP de votre serveur avec le port 8000 dans votre navigateur (l'adresse devrait ressembler à http://<adresse ip>:8000/), vous devriez voir la page exemple Ça fonctionne ! de Django. C'est le résultat vers lequel nous allons travailler en utilisant le serveur web Apache au lieu du serveur de développement Django intégré.

Puisque l'application Django fonctionne correctement, nous pouvons procéder à l'association de l'application avec Apache.

Installer mod_wsgi pour Apache

La manière la plus simple et également recommandée de servir des applications Python en utilisant Apache est d'utiliser le module mod_wsgi. Il n'est pas installé par défaut avec Python ni avec Apache, donc nous devons installer un package supplémentaire.

apt-get install libapache2-mod-wsgi

La prochaine étape consistera à configurer l'hôte virtuel Apache par défaut qui, au début de l'article, servait la page Ça fonctionne ! pour servir notre application Django.

Configurer mod_wsgi dans un hôte virtuel par défaut

L'idée derrière la configuration de mod_wsgi pour n'importe quel autre hôte virtuel dans Apache est la même que celle présentée ici. Nous utiliserons l'hôte virtuel par défaut pour des raisons de simplicité, puisque c'est celui déjà fourni par une installation Apache propre.

Ouvrez le fichier de configuration du hôte virtuel par défaut dans l'éditeur nano

nano /etc/apache2/sites-enabled/000-default 

et ajoutez trois lignes suivantes juste en dessous de <VirtualHost *:80>

WSGIDaemonProcess sampleapp python-path=/var/www/sampleapp:/var/www/sampleapp/env/lib/python2.7/site-packages
WSGIProcessGroup sampleapp
WSGIScriptAlias / /var/www/sampleapp/sampleapp/wsgi.py

La première ligne crée un processus de démon WSGI appelé sampleapp qui sera responsable de servir notre application Django. Le nom du démon peut être à peu près n'importe quoi, mais il est de bonne pratique d'*utiliser des noms descriptifs comme des noms d'application ici.

Si nous utilisions une installation Python globale et une instance Django globale, la directive python-path ne serait pas nécessaire. Cependant, l'utilisation d'un environnement virtuel rend obligatoire la spécification du chemin Python alternatif afin que mod_wsgi sache où chercher les packages Python.

Le chemin doit contenir deux répertoires : le répertoire du projet Django lui-même - /var/www/sampleapp - et le répertoire des paquets Python dans notre environnement virtuel pour ce projet - /var/www/sampleapp/env/lib/python2.7/site-packages. Les répertoires dans la définition du chemin sont délimités par un signe deux-points.

La deuxième ligne indique à cet hôte virtuel particulier d'utiliser le démon WSGI créé au préalable, et par conséquent, le nom du démon doit correspondre entre ces deux lignes. Nous avons utilisé sampleapp dans les deux lignes.

La troisième ligne est la plus importante, car elle indique à Apache et mod_wsgi où trouver la configuration WSGI. Le wsgi.py fourni par Django contient la configuration par défaut minimale pour WSGI pour servir l'application Django, qui fonctionne très bien et changer la configuration dans ce fichier est en dehors du scope de cet article.

Après ces modifications, il est nécessaire de redémarrer Apache

service apache2 restart

Après cela, en ouvrant le navigateur web sur l'adresse IP de votre serveur, sans ports supplémentaires, vous devriez voir la même page Django qu'auparavant au lieu de la page initiale Ça fonctionne ! que nous avons vue plus tôt.

Cela rend notre configuration complète.

Veuillez noter : utiliser l'hôte virtuel par défaut sans précautions supplémentaires n'est pas la façon recommandée de configurer un serveur de production. Cela est utilisé à des fins de démonstration.

Lectures supplémentaires

Le sujet de la configuration de mod_wsgi et de Django en lui-même est vaste. De nombreux aspects de configuration sont spécifiques à l'application et difficiles à expliquer ou à démontrer sans travailler avec une véritable application Django. Ce guide n'est pas un manuel complet pour le déploiement d'applications Django utilisant Apache, mais un guide de démarrage rapide sur la manière de commencer.

L'une des meilleures ressources est la documentation officielle de Django. Il existe également d'excellents articles sur DigitalOcean qui peuvent être trouvés en utilisant Django comme mot-clé de recherche.