Comment exécuter Django avec mod wsgi et Apache avec un environnement Python virtualenv sur un VPS Debian

De Get Docs
Aller à :navigation, rechercher

Introduction

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

L'un des moyens les plus populaires de déployer des applications Django sur le Web sur un serveur dédié consiste à utiliser Nginx associé à Gunicorn. Une excellente façon de le faire a déjà été décrite en détail dans cet article. C'est cependant un scénario assez courant d'héberger des applications Django à côté de sites Web existants servis à l'aide d'Apache. Nous essaierons de couvrir la voie 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 que certains aspects de la configuration ne sont pas abordés 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, par souci de clarté, nous nous concentrerons sur un serveur Debian.
  • Vous connaissez au moins un peu les 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 assez familier avec la structure du projet Django, car cet article n'est pas destiné à parcourir l'utilisation et la configuration de Django lui-même.
  • Vous êtes familiarisé avec l'administration de base d'Apache, car ce didacticiel ne couvrira que l'installation simple du serveur lui-même et les changements de configuration nécessaires pour coupler Django avec Apache.

Conditions préalables

Avant d'installer de nouveaux packages, il est toujours recommandé de mettre à jour vos packages système et vos index de packages. Pour ce faire, exécutez :

apt-get update
apt-get upgrade

Installation d'Apache

Étant donné que ce texte se concentre sur l'utilisation de 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 faisant pointer vers l'adresse IP du serveur. Vous devriez voir une simple page Ça marche! à 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 packages Python qui facilite l'installation de packages 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 pour séparer les bibliothèques nécessaires aux différentes applications et éviter les conflits de versions entre elles.

Pour ce faire, exécutez :

apt-get install python-pip python-virtualenv

Cette commande installera pip et virtualenv à partir du référentiel de packages Debian. Vous pouvez vérifier que les deux outils ont été correctement installés en les exécutant avec le commutateur --version.

[email protected]:~# virtualenv --version
1.7.1.2
[email protected]:~# pip --version
pip 1.1 from /usr/lib/python2.7/dist-packages (python 2.7)
[email protected]:~#

Créer un environnement virtuel avec virtualenv

Lors de l'installation de 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 entrons dans le 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 résident l'interpréteur Python et une instance locale de pip. L'instance locale de pip installe tous les packages dans 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 version de package dans un scénario hypothétique de deux applications exécutant deux versions différentes de Django ou de toute autre bibliothèque.

Pour créer un nouvel environnement virtuel, entrez :

virtualenv env

env est le nom de l'environnement virtuel - il peut s'agir de n'importe quel autre mot. La sortie de cette commande devrait ressembler à ceci :

[email protected]:/var/www/sampleapp# virtualenv env
New python executable in env/bin/python
Installing distribute.............................................................................................................................................................................................done.
Installing pip...............done.
[email protected]:/var/www/sampleapp#

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

Une façon consiste à exécuter directement des commandes à l'aide de l'interpréteur d'environnement virtuel. Avec cette méthode, il est nécessaire de toujours se rappeler d'exécuter le bon interpréteur ou l'instance pip, car il est possible d'en exécuter un à l'échelle du système.

[email protected]:/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)
[email protected]:/var/www/sampleapp# env/bin/python --version
Python 2.7.3
[email protected]:/var/www/sampleapp#

L'autre méthode consiste à activer l'environnement en premier, en utilisant

source env/bin/activate

le nom de l'environnement sera alors ajouté à la ligne de commande en tant que tel

[email protected]:/var/www/sampleapp# source env/bin/activate
(env)[email protected]:/var/www/sampleapp#

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

(env)[email protected]:/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)[email protected]:/var/www/sampleapp# python --version
Python 2.7.3
(env)[email protected]:/var/www/sampleapp#

c'est plus facile de travailler ainsi; cependant il est nécessaire de désactiver l'environnement une fois le travail effectué en utilisant la commande suivante

deactivate

cela ramènera le shell à la normale

(env)[email protected]:/var/www/sampleapp# deactivate
[email protected]:/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é ultérieurement par Apache et mod_wsgi pour servir l'application en utilisant les bonnes dépendances.

Installation de Django dans un environnement virtuel

La prochaine étape nécessaire consiste à installer Django dans 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 l'environnement virtuel et n'est pas disponible à partir de l'installation Python à l'échelle du système. Vous pouvez vérifier ce comportement en important le module django en utilisant les deux interpréteurs

[email protected]:/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 à l'aide de l'interpréteur à l'échelle du système a échoué, alors que

[email protected]:/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éation du premier projet Django

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

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

Veuillez noter la fin . dans la commande - sans elle, 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 les commandes Django pour ce projet particulier. L'une des utilisations possibles de manage.py consiste à exécuter 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 exécutera 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://<ip address>:8000/), vous devriez voir la page d'exemple Ça a fonctionné ! 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 au couplage de l'application avec Apache.

Installation de mod_wsgi pour Apache

Le moyen le plus simple et également recommandé de servir les applications Python à l'aide de Apache consiste à utiliser le module mod_wsgi. Il n'est pas installé par défaut avec Python ni Apache, nous devons donc 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 marche ! pour servir notre application Django.

Configuration de mod_wsgi dans un hôte virtuel par défaut

L'idée derrière la configuration de mod_wsgi pour tout 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 plus de simplicité, puisque c'est celui déjà fourni par une installation propre d'Apache.

Ouvrez le fichier de configuration de l'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 génère un processus démon WSGI appelé sampleapp qui sera chargé de servir notre application Django. Le nom du démon peut être pratiquement n'importe quoi, mais il est recommandé d'utiliser ici des noms descriptifs tels que les noms d'application.

Si nous utilisions une installation Python globale et une instance globale Django, 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ù rechercher 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 packages 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 en tant que tel, le nom du démon doit correspondre entre ces deux. 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 de base pour WSGI pour servir l'application Django qui fonctionne très bien et la modification de la configuration dans ce fichier est hors de portée de cet article .

Après ces changements il faut redémarrer Apache

service apache2 restart

Après cela, lors de l'ouverture du navigateur Web sur l'adresse IP de votre serveur, sans aucun port supplémentaire, vous devriez voir la même page Django qu'avant au lieu de la page initiale Ça marche ! que nous avons vu plus tôt.

Cela rend notre configuration complète.

Remarque : l'utilisation de l'hôte virtuel par défaut sans précaution supplémentaire n'est pas la méthode recommandée pour configurer un serveur de production. Il est utilisé à des fins de démonstration.

Lectures complémentaires

Le sujet de la configuration de mod_wsgi et Django lui-même est vaste. De nombreux aspects de la configuration sont spécifiques à l'application et difficiles à expliquer ou à démontrer sans travailler avec une application Django du monde réel. Ce guide n'est pas un guide complet pour le déploiement d'applications Django utilisant Apache, mais un guide de démarrage rapide sur la façon de commencer.

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

Article soumis par : [[“%3Ca|http://maticomp.net]] [[“%3C/a|”>Mateusz Papiernik]]