Django en serveur - Sommaire : Site en Python (Django) chez OVH

(Voici la suite de ma petite série “faire mumuse avec python sur son serveur”.)

Nous avons vu précédemment comment configurer notre projet Django pour qu'il fonctionne sur un serveur Apache, en utilisant soit mod_python, soit mod_wsgi. Comme j'ai réalisé ce projet pour un client, je lui ai pris avec un forfait Start1G chez OVH.

Ce serait bête de ne pas l'utiliser ! :)

J'ai donc fait quelques recherches sur le web sur comment faire fonctionner un projet python sur un hébergeur qui, à la base, n'accepte que du Php. Heureusement pour moi, j'ai trouvé deux articles complémentaires qui m'ont permis de faire fonctionner mon site :

Le premier article est très complet et c'est parce que j'ai eu quelques difficultés à y arriver que je poste ma solution, sinon j'aurais juste mis le liens vers ce site. Le second peux donner quelques idées pour résoudre vos soucis, mais les liens vers les documents (.htaccess, django.cgi) retournent des erreurs 404.

Alors voilà, comme toujours, il faut respecter une certaine arborescence, qui dépends de vos goûts je doit dire.

Pour ma part, voici l'arborescence finale :

  • cgi-bin/ : dossier par défaut fournis par OVH, non modifié
  • projet/
  • [project_name]/ : le nom du projet, contient le code python, dont le settings.py
  • static/ : les fichiers statiques (css, js, images, etc)
  • templates/ : les templates nécessaires à l'affichage du site.
  • python-local/ : contient tout ce qui est nécessaire au fonctionnement du site, dans mon cas, juste Django
  • django/ : le framework Django
  • requetes/ : dossier par défaut fournis par OVH, non modifié
  • www/
  • media/ : copie du repertoire django/django/contrib/admin/media/ (medias utilisés par l'admin)
  • .htaccess
  • django.cgi

Voici le contenu des fichiers .htaccess et django.cgi

.htaccess : très simple, mais efficace ;)

RewriteEngine on
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^(.*)$ django.cgi/$1 [L]

django.cgi.
Vous pourrez trouver une version originale de ce fichier ici.

#!/usr/bin/env python
# encoding: utf-8
"""
django.cgi

A simple cgi script which uses the django WSGI to serve requests.

Code copy/pasted from PEP-0333 and then tweaked to serve django.
http://www.python.org/dev/peps/pep-0333/#the-server-gateway-side

This script assumes django is on your sys.path, and that your site code is at
/home/mycode/mysite. Copy this script into your cgi-bin directory (or do
whatever you need to to make a cgi script executable on your system), and then
update the paths at the bottom of this file to suit your site.

This is probably the slowest way to serve django pages, as the python
interpreter, the django code-base and your site code has to be loaded every
time a request is served. FCGI and mod_python solve this problem, use them if
you can.

In order to speed things up it may be worth experimenting with running
uncompressed zips on the sys.path for django and the site code, as this can be
(theorectically) faster. See PEP-0273 (specifically Benchmarks).
http://www.python.org/dev/peps/pep-0273/

Make sure all python files are compiled in your code base. See
http://docs.python.org/lib/module-compileall.html

"""

import os, sys

sys.path.append("/[racine]/python-local/django")
sys.path.append("/[racine]/[projet]")

import django.core.handlers.wsgi

def run_with_cgi(application):

    environ                      = dict(os.environ.items())
    environ['wsgi.input']        = sys.stdin
    environ['wsgi.errors']       = sys.stderr
    environ['wsgi.version']      = (1,0)
    environ['wsgi.multithread']  = False
    environ['wsgi.multiprocess'] = True
    environ['wsgi.run_once']     = True

    if environ.get('HTTPS','off') in ('on','1'):
        environ['wsgi.url_scheme'] = 'https'
    else:
        environ['wsgi.url_scheme'] = 'http'

    headers_set  = []
    headers_sent = []

    def write(data):
        if not headers_set:
             raise AssertionError("write() before start_response()")

        elif not headers_sent:
             # Before the first output, send the stored headers
             status, response_headers = headers_sent[:] = headers_set
             sys.stdout.write('Status: %s\r\n' % status)
             for header in response_headers:
                 sys.stdout.write('%s: %s\r\n' % header)
             sys.stdout.write('\r\n')

        sys.stdout.write(data)
        sys.stdout.flush()

    def start_response(status,response_headers,exc_info=None):
        if exc_info:
            try:
                if headers_sent:
                    # Re-raise original exception if headers sent
                    raise exc_info[0], exc_info[1], exc_info[2]
            finally:
                exc_info = None     # avoid dangling circular ref
        elif headers_set:
            raise AssertionError("Headers already set!")

        headers_set[:] = [status,response_headers]
        return write

    result = application(environ, start_response)
    try:
        for data in result:
            if data:    # don't send headers until body appears
                write(data)
        if not headers_sent:
            write('')   # send headers now if body was empty
    finally:
        if hasattr(result,'close'):
            result.close()

# Change mysite to the name of your site package
os.environ['DJANGO_SETTINGS_MODULE'] = '[projet].settings'

run_with_cgi(django.core.handlers.wsgi.WSGIHandler())

Bien évidement, vous modifierez les valeurs de [racine] et de [projet] par celle correspondantes.

Pour évaluer [racine], j'ai fait un simple script php qui me faisait un echo de $_SERVER["DOCUMENT_ROOT"] :

<?php
echo $_SERVER["DOCUMENT_ROOT"];
?>

Pour [projet], c'est le nom que vous avez donné à votre projet python.

Enfin, n'oubliez pas d'adapter les chemins dans votre fichier settings.py à votre structure.

Normalement, si vous tentez d'accéder à votre site maintenant, vous aurez une erreur 500. Si vous regardez les logs d'erreurs, voici le type d'erreur que vous aurez :

Premature end of script headers: django.cgi suexec policy violation: see suexec log for more details

En fait, l'erreur est très conne ici. Tout ce que vous avez à faire, c'est donner les bons droits à votre fichier django.cgi, notamment le fait qu'il soit exécutable.

Pour ma part, seul le droit -rwx------ (tous les droits pour l'utilisateur, et rien pour le groupe et les autres) fonctionne. A vous de voir.

Maintenant, un petit F5 sur votre site et il devrait-être opérationnel !

Voilà ! C'est la fin de ma petite série sur Django, j'espère que vous avez apprécié :) Si vous avez des questions n'hésitez pas, les commentaires sont fait pour ça !

Pour ma part, j'aurai préféré avoir un raccourcis de media dans www qui pointe sur le dossier django/contrib/admin/media, mais je n'ai pas trouvé comment faire cela dans FileZilla. Si c'est possible et que vous savez comment faire, je suis impatient d'avoir votre explication :)

Filed under  //  Development   Projects   Python   django   media   ovh   site  
Posted by Cyril Nicodème 

Django en serveur - Sommaire : Site en Python (Django) sous Apache avec mod_python.

(Voici la suite de ma petite série "faire mumuse avec python sur son serveur".)

Lorsque j'ai parlé du framework python Django, beaucoup d'entre vous m'ont fait la réfléxion du :

Ça à l'air cool (ça l'est ! :p), mais la dernière fois que j'ai tenté de faire marcher python avec apache, ça a été l'enfer !

Ce jour est révolu :) Bon, sur le site de Django, ils conseillent d'utiliser mod_wsgi, mais pour ce tutoriel, nous utiliserons mod_python.

Donc tout d'abord, nous allons l'installer (méthode pour Debian) :

apt-get install libapache2-mod-python

Ensuite, il va falloir l'activer :

a2enmod python

ou équivalent :

ln -s /etc/apache2/mods-available/python.load /etc/apache2/mods-enabled/

Ensuite, il va falloir créer un VirtualHost qui indiquera à Apache que pour ce domaine, il faut utiliser python. Voici un exemple de VirtualHost spécifique à Django :

<VirtualHost *:80>
        ServerAdmin postmaster@[domain].tld
        ServerName www.[domain].tld
        ServerAlias [domain].tld
        DocumentRoot /var/www/[domain]/www/[domain]

        ErrorLog /var/log/apache2/[domain]_error.log
        LogLevel warn
        CustomLog /var/log/apache2/[domain]_access.log combined
        ServerSignature Off

        <Location "/">
                SetHandler mod_python
                PythonHandler django.core.handlers.modpython
                SetEnv DJANGO_SETTINGS_MODULE [nom_du_projet_django].settings
                PythonPath "['/var/www/[domain]/www/'] + sys.path"
                PythonAutoReload Off
                PythonDebug Off
        </Location>
 
        Alias /media "/var/www/[domain]/www/media"
        <Location "/media/">
                SetHandler None
        </Location>
 
        Alias /static "/var/www/[domain]/www/static"
        <Location "/static/">
                SetHandler None
        </Location>
 
        <LocationMatch "\.(jpg|gif|png)$">
                SetHandler None
        </LocationMatch>
</VirtualHost>

Quelques explications s'imposent. Pour mes projets Django, j'ai choisis de faire un structure simple. Dans le dossier de mon projet (appelons le "domain"), j'ai le nom du sous-domaine (ici, www), et dedans, je crée trois dossiers :

  • [domain] (le même nom que son dossier parent aka le nom du projet) : il contiendra le code Django
  • static : il contiendra tous les fichiers nécéssaire au site : css, js, images, etc
  • template : il contient les templates utilisés par Django

Du coup, le fichier de configuration semble un peu plus clair : on définis un Handler de type python pour le répertoire qui contient le code python (/var/www/[domain]/www/[domain]), puis on définis un Handler null (donc aucune interprétation d'un quelconque code) pour les autres dossiers (media et static).

Maintenant, vous vous demandez à quoi sert "media".

En fait, ce répertoire est un liens symbolique que nous allons créer, et qui pointe sur le module admin de Django. En effet, dans la configuration actuelle, si vous tentez d'accéder à l'admin (en ajoutant un /admin/ sur l'url), vous verrez que les images, le style et le javascript ne sont pas présents.

Logique ! Comment apache peux deviner d'où ils viennent ?

Donc pour que notre admin soit fonctionnel, il faut faire un lien symbolique du module admin à notre projet (en supposant que vous avez installez Django comme indiquez dans notre précédent article) :

ln -s /opt/django/django/contrib/admin/media/ /var/www/[domain]/www/media

Du coup, la configuration dans votre VirtualHost prendra aussi effet pour ce répertoire.

Voilà !

Vous n'avez plus qu'à redémarrer, et si votre fichier settings.py de votre projet est correct (notamment au niveau des répertoires ;)), votre site devrait-être accessible !

Filed under  //  Apache   Development   Projects   Python   django   media   mod-python   server   static   template  
Posted by Cyril Nicodème