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 16.04 avec un utilisateur non root avec les privilèges + sudo +
configurés. Vous pouvez apprendre à le configurer en parcourant notre https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-16-04 guide de configuration du serveur initial].
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 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
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 +
.
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 +
:
Note
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 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:
~ / monprojet / monprojet / settings.py
. . .
ALLOWED_HOSTS = [""]
. . .
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:
~ / 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 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.
Nous pouvons maintenant ajuster les paramètres de votre pare-feu pour autoriser le trafic sur notre serveur de développement Django, que nous appelons exécuté sur le port 8000. Si vous avez suivi le guide de configuration initiale du serveur dans les conditions préalables, un pare-feu UFW doit être activé pour le moment.
Autorisez les connexions au serveur de développement en tapant:
sudo ufw allow 8000
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:
/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 le répertoire de notre 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 sélectionné 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
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:
sudo ufw delete allow 8000
sudo ufw allow 'Apache Full'
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 pour Apache le 16.04 pour apprendre comment 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 https://www.digitalocean.com/community/tutorials/how-to-create-a-self-signed-ssl-certificate-for-apache-in-ubuntu-16- 04 [guide sur la création de certificats SSL auto-signés pour Apache sur Ubuntu 16.04].
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.