Comment servir les applications Django avec Apache et mod_wsgi sur Debian 8

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 devriez avoir une nouvelle instance de serveur Debian 8 avec un utilisateur non root avec les privilèges + sudo + configurés. Vous pouvez apprendre à configurer ceci en parcourant 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 Debian

Pour commencer le processus, nous téléchargerons et installerons tous les éléments nécessaires dans les référentiels Debian. 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 et du paquetage + pip +. Les commandes appropriées dans ce cas sont:

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

Maintenant que nous avons les composants des référentiels Debian, nous pouvons commencer à travailler sur notre projet Django.

Configurer un environnement virtuel Python

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 obtenir ce paquet en utilisant + pip +.

Si vous utilisez * Python 2 *, tapez:

sudo pip install virtualenv

Si vous utilisez * Python 3 *, tapez:

sudo pip3 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 +:

pip install django

Cela installera le package Django dans votre environnement virtuel Python.

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 parent à + ​​~ / +, nous dirons à Django d’installer les fichiers ici. La commande créera un répertoire de second niveau contenant le code actuel. Il placera également un script de gestion dans le répertoire du projet en cours. La clé pour obtenir la structure de répertoire correcte consiste à répertorier le répertoire parent après le nom du projet:

django-admin.py startproject  ~/

Vous devriez vous retrouver avec une structure de répertoire qui ressemble à ceci:

.
└── ./myproject/          # parent project directory
   ├── manage.py         # Django management script
   ├── myproject/            # project code directory
   │   ├── __init__.py
   │   ├── settings.py
   │   ├── urls.py
   │   └── wsgi.py
   └── myprojectenv/     # project virtual environment directory
       └── . . .

Vérifier que votre structure de répertoires est alignée sur cela peut aider à minimiser les erreurs ultérieurement.

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 des hôtes autorisés afin de restreindre les domaines auxquels nous répondons et sur la configuration du répertoire de fichiers statiques, où Django placera des fichiers statiques afin que le serveur Web puisse les gérer facilement.

Commencez par trouver la ligne + ALLOWED_HOSTS +. Entre crochets, entrez l’adresse IP publique, le nom de domaine ou les deux de votre serveur. Chaque valeur doit être entourée de guillemets et séparée par une virgule, comme une liste Python normale. C’est une bonne idée d’ajouter des adresses locales comme + 127.0.0.1 + et + 127.0.1.1 +:

~ / monprojet / monprojet / settings.py

. . .
ALLOWED_HOSTS = ["", "127.0.0.1", "127.0.1.1"]
. . .

Au bas du fichier, nous allons définir + STATIC_ROOT + de Django. Django peut collecter et exporter tous les actifs statiques dans un répertoire connu, afin que le serveur Web puisse les servir directement. 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:

~ / monprojet / monprojet / settings.py

. . .

STATIC_URL = '/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 le répertoire que nous avons défini avec + STATIC_ROOT + en tapant:

./manage.py collectstatic

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

Vous devrez peut-être ajuster les paramètres de votre pare-feu pour autoriser le trafic sur notre serveur de développement Django, que nous exécuterons sur le port 8000.

Si vous utilisez un pare-feu + ufw +, vous pouvez autoriser le trafic sur le port 8000 en tapant:

sudo ufw allow 8000

Si vous exécutez + iptables +, la commande exacte dont vous avez besoin dépend de la configuration actuelle de votre pare-feu. Pour la plupart des configurations, cette commande devrait fonctionner:

sudo iptables -I INPUT -p tcp --dport 8000 -j ACCEPT

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

Le préfixe + () + de votre invite de shell devrait disparaître.

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:

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

<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:

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

<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 avons configuré la maison Python, où Apache peut trouver tous les composants nécessaires. Comme nous avons utilisé un environnement virtuel, nous pouvons le diriger directement vers notre répertoire d’environnement virtuel de base. Ensuite, nous avons défini le chemin Python pour qu’il pointe vers la base de notre projet Django.

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 +:

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

<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-home=/home/// python-path=/home//myproject
   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
chmod 775 ~/

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 ~/

Nous devons encore ajuster notre pare-feu. Nous n’avons plus besoin d’ouvrir le port 8000 car nous effectuons le proxy via Apache. Nous pouvons donc supprimer cette règle. Nous pouvons ensuite ajouter une exception pour autoriser le trafic vers le processus Apache.

Si vous utilisez + ufw +, vous pouvez le faire en tapant:

sudo ufw delete allow 8000
sudo ufw allow 'Apache Full'

Si vous utilisez + iptables +, les commandes appropriées ressembleront à ceci:

sudo iptables -D INPUT -p tcp --dport 8000 -j ACCEPT
sudo iptables -I INPUT -p tcp --dport 80 -j ACCEPT

Vérifiez vos fichiers Apache pour vous assurer que vous n’avez commis aucune erreur de syntaxe:

sudo apache2ctl configtest

Tant que la dernière ligne de sortie ressemble à ceci, vos fichiers sont en bon état:

Output. . .
Syntax OK

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 systemctl restart apache2

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.

Prochaines étapes

Après avoir vérifié que votre application est accessible, il est important de sécuriser le trafic sur votre application.

Si vous avez un nom de domaine pour votre application, le moyen le plus simple de sécuriser votre application consiste à utiliser un certificat SSL gratuit de Let’s Encrypt. Suivez notre Le guide de cryptage de Apache sur Debian 8 pour savoir comment pour mettre cela en place.

Si vous * n’avez * pas de nom de domaine pour votre application et que vous l’utilisez pour vos propres besoins ou pour des tests, vous pouvez toujours créer un certificat auto-signé. Vous pouvez apprendre comment configurer cela avec notre guide sur la création de soi certificats SSL signés par Apache pour Debian 8.

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.