TOC

Comment servir les applications Django avec Apache et mod_wsgi sur Ubuntu 14.04

introduction

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

Dans ce guide, nous montrerons comment installer et configurer Django dans un environnement virtuel Python. Nous allons ensuite configurer Apache devant notre application afin qu’il puisse gérer les demandes des clients directement avant de transmettre les demandes nécessitant une logique d’application à l’application Django. Nous allons faire cela en utilisant le module Apache + mod_wsgi + qui peut communiquer avec Django via la spécification d’interface WSGI.

Prérequis et objectifs

Afin de compléter ce guide, vous devez disposer d’une nouvelle instance de serveur Ubuntu 14.04 avec un utilisateur non root avec les privilèges + sudo + configurés. Vous pouvez apprendre à configurer cela en suivant notre initial initial guide de configuration du serveur.

Nous installerons Django dans un environnement virtuel Python. L’installation de Django dans un environnement spécifique à votre projet permettra à vos projets et à leurs exigences d’être traités séparément.

Une fois que notre application sera opérationnelle, nous configurerons Apache pour l’interface avec l’application Django. Cela se fera avec le module Apache + mod_wsgi +, qui peut traduire les requêtes HTTP dans un format d’application prévisible défini par une spécification appelée WSGI. Vous pouvez en savoir plus sur WSGI en lisant la section liée à https://www.digitalocean.com/community/tutorials/how-to-set-up-uwsgi-and-nginx-to-serve-python-apps-on -ubuntu-14-04 # définitions-et-concepts [ce guide].

Commençons.

Installer des paquets à 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. Cela inclura le serveur Web Apache, le module + mod_wsgi + utilisé pour l’interface avec notre application Django, et + pip +, le gestionnaire de paquets Python qui peut être utilisé pour télécharger nos outils liés à Python.

Pour obtenir tout ce dont nous avons besoin, mettez à jour l’index de paquetage local de votre serveur, puis installez les paquetages appropriés.

Si vous utilisez Django avec Python 2, les commandes nécessaires sont les suivantes:

sudo apt-get update
sudo apt-get install python-pip apache2 libapache2-mod-wsgi

Si vous utilisez plutôt Django avec Python 3, vous aurez besoin d’un autre module Apache. Les commandes appropriées dans ce cas sont:

sudo apt-get update
sudo apt-get install python3-pip apache2 libapache2-mod-wsgi-py3

Si vous utilisez outside d’un environnement virtuel pour le reste du tutoriel, si vous utilisez Python 3, remplacez + pip + par + + pip3 +.

Configurer un environnement virtuel Python

Maintenant que nous avons les composants des référentiels Ubuntu, nous pouvons commencer à travailler sur notre projet Django. La première étape consiste à créer un environnement virtuel Python afin que notre projet Django soit séparé des outils système et de tout autre projet Python sur lequel nous pourrions travailler.

Nous devons installer la commande + virtualenv + pour créer ces environnements. Nous pouvons l’obtenir en utilisant + pip +:

sudo pip install virtualenv

Avec + virtualenv + installé, nous pouvons commencer à former notre projet. Créez un répertoire dans lequel vous souhaitez conserver votre projet et accédez au répertoire suivant:

mkdir ~/
cd ~/

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

virtualenv

Cela créera un répertoire appelé ` dans votre répertoire `. À 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 /bin/activate

Votre invite devrait changer pour indiquer que vous travaillez maintenant dans un environnement virtuel Python. Cela ressemblera à quelque chose comme ceci: + () @: ~ / $ +.

Avec votre environnement virtuel actif, installez Django avec l’instance locale de + pip + en tapant:

pip install django

Créer et configurer un nouveau projet Django

Maintenant que Django est installé dans notre environnement virtuel, nous pouvons créer les fichiers de projet Django réels.

Créer le projet Django

Comme nous avons déjà un répertoire de projet, nous demanderons à 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 le point à la fin qui indique à Django de créer les fichiers dans le répertoire actuel:

django-admin.py startproject  .

Ajuster les paramètres du projet

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

nano /settings.py

Dans ce guide, nous allons utiliser la base de données SQLite par défaut dans un souci de simplicité. Nous n’avons donc pas besoin de trop changer. Nous allons nous concentrer sur la configuration du répertoire de fichiers statiques, où Django placera les fichiers statiques de manière à ce que le serveur Web puisse les gérer facilement.

Au bas du fichier, nous allons ajouter une ligne pour configurer ce répertoire. Django utilise le paramètre + STATIC_ROOT + pour déterminer le répertoire dans lequel ces fichiers doivent être placés. Nous allons utiliser un peu de Python pour lui dire d’utiliser un répertoire appelé «statique» dans le répertoire principal de notre projet:

STATIC_ROOT = os.path.join(BASE_DIR, "static/")

Enregistrez et fermez le fichier lorsque vous avez terminé.

Terminer la configuration initiale du projet

Maintenant, nous pouvons migrer le schéma de base de données initial vers notre base de données SQLite en utilisant le script de gestion:

cd ~/
./manage.py makemigrations
./manage.py migrate

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

./manage.py createsuperuser

Vous devrez sélectionner un nom d’utilisateur, fournir une adresse électronique, 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:

./manage.py collectstatic

Vous devrez confirmer l’opération. Les fichiers statiques seront placés dans un répertoire appelé + static + dans le répertoire de votre projet.

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

./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://:8000

Vous devriez voir la page d’index par défaut de Django:

image: https: //assets.digitalocean.com/articles/django_uwsgi_nginx_1404/sample_site.png [Index par défaut de Django]

Si vous ajoutez + / admin + à la fin de l’URL dans la barre d’adresse, le nom d’utilisateur et le mot de passe administrateur que vous avez créés à l’aide de la commande + createuperuser + vous seront demandés:

image: https: //assets.digitalocean.com/articles/django_uwsgi_nginx_1404/admin_login.png [Connexion à l’administrateur Django]

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

image: https: //assets.digitalocean.com/articles/django_uwsgi_nginx_1404/admin_interface.png [Interface d’administration Django]

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

Nous en avons terminé avec Django pour le moment. Nous pouvons donc sortir de notre environnement virtuel en tapant:

deactivate

Configurer Apache

Maintenant que votre projet Django fonctionne, nous pouvons configurer Apache en tant que serveur frontal. Les connexions client reçues seront traduites au format WSGI attendu par l’application Django à l’aide du module + mod_wsgi +. Cela aurait dû être activé automatiquement lors de l’installation précédente.

Pour configurer la passe WSGI, nous devons éditer le fichier d’hôte virtuel par défaut:

sudo nano /etc/apache2/sites-available/000-default.conf

Nous pouvons conserver les directives déjà présentes dans le fichier. Nous avons juste besoin d’ajouter quelques éléments supplémentaires.

Commençons par configurer les fichiers statiques. Nous utiliserons un alias pour indiquer à Apache de mapper toutes les demandes commençant par + / static + vers le répertoire «static» de notre dossier de projet. Nous avons collecté les actifs statiques plus tôt. Nous allons configurer l’alias, puis accorder l’accès au répertoire en question avec un bloc de répertoire:

<VirtualHost *:80>
   . . .

   Alias /static /home///static
   <Directory /home///static>
       Require all granted
   </Directory>

</VirtualHost>

Ensuite, nous allons accorder l’accès au fichier + wsgi.py + dans le répertoire de projet de second niveau où le code Django est stocké. Pour ce faire, nous allons utiliser une section de répertoire contenant une section de fichier. Nous allons accorder l’accès au fichier à l’intérieur de cette construction imbriquée:

<VirtualHost *:80>
   . . .

   Alias /static /home///static
   <Directory /home///static>
       Require all granted
   </Directory>

   <Directory /home///>
       <Files wsgi.py>
           Require all granted
       </Files>
   </Directory>

</VirtualHost>

Une fois que cela est configuré, nous sommes prêts à construire la partie du fichier qui gère réellement la passe WSGI. Nous allons utiliser le mode démon pour exécuter le processus WSGI, qui est la configuration recommandée. Nous pouvons utiliser la directive + WSGIDaemonProcess + pour le configurer.

Cette directive prend un nom arbitraire pour le processus. Nous allons utiliser ++ pour rester cohérent. Ensuite, nous définissons le chemin Python vers le répertoire parent du projet. Ce sera + / home // + dans ce guide. Comme nous avons utilisé un environnement virtuel, nous devrons également définir la maison Python sur la racine de notre environnement virtuel. De cette façon, Apache peut trouver tous les autres codes Python nécessaires à l’exécution de notre projet.

Ensuite, nous devons spécifier le groupe de processus. Cela devrait indiquer le même nom que nous avons choisi pour la directive + WSGIDaemonProcess + (+ myproject + dans notre cas). Enfin, nous devons définir l’alias de script pour qu’Apache transmette les demandes du domaine racine au fichier + wsgi.py +:

<VirtualHost *:80>
   . . .

   Alias /static /home///static
   <Directory /home///static>
       Require all granted
   </Directory>

   <Directory /home///>
       <Files wsgi.py>
           Require all granted
       </Files>
   </Directory>

   WSGIDaemonProcess  python-path=/home// python-home=/home///
   WSGIProcessGroup
   WSGIScriptAlias / /home////wsgi.py

</VirtualHost>

Lorsque vous avez terminé ces modifications, enregistrez et fermez le fichier.

Résoudre certains problèmes d’autorisations

Si vous utilisez la base de données SQLite, qui est la valeur par défaut utilisée dans cet article, vous devez autoriser le processus Apache à accéder à ce fichier.

Pour ce faire, la première étape consiste à modifier les autorisations afin que le propriétaire du groupe de la base de données puisse lire et écrire. Le fichier de base de données s’appelle par défaut + db.sqlite3 + et il devrait être situé dans le répertoire de votre projet de base:

chmod 664 ~//db.sqlite3

Ensuite, nous devons donner au groupe sous lequel Apache s’exécute, le groupe + www-data, la propriété du fichier par le groupe:

sudo chown :www-data ~//db.sqlite3

Pour écrire dans le fichier, nous devons également attribuer la propriété du groupe Apache au répertoire parent de la base de données:

sudo chown :www-data ~/

Une fois ces étapes terminées, vous êtes prêt à redémarrer le service Apache pour implémenter les modifications que vous avez apportées. Redémarrez Apache en tapant:

sudo service apache2 restart

Vous devriez maintenant pouvoir accéder à votre site Django en accédant au nom de domaine ou à l’adresse IP de votre serveur sans spécifier de port. Le site habituel et l’interface d’administration doivent fonctionner comme prévu.

Conclusion

Dans ce guide, nous avons configuré un projet Django dans son propre environnement virtuel. Nous avons configuré Apache avec + mod_wsgi + pour gérer les demandes des clients et assurer l’interface avec l’application Django.

Django facilite la création de projets et d’applications en fournissant de nombreux éléments communs, vous permettant de vous concentrer sur des éléments uniques. En exploitant la chaîne d’outils générale décrite dans cet article, vous pouvez facilement desservir les applications que vous créez à partir d’un seul serveur.

Related