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 sous CentOS 7. 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
Pour compléter ce guide, vous devez disposer d’une nouvelle instance de serveur CentOS 7 avec un utilisateur non root doté des privilèges sudo + configurés. Vous pouvez apprendre à configurer ceci 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 packages à partir des dépôts CentOS et EPEL
Pour commencer, nous allons télécharger et installer tous les éléments dont nous avons besoin à partir des référentiels de notre distribution. 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 + pip +, nous devrons activer le référentiel EPEL, qui est un paquet supplémentaire. Vous pouvez le faire facilement en tapant:
sudo yum install epel-releaseLorsque EPEL est activé, nous pouvons installer les composants nécessaires en tapant:
sudo yum install python-pip httpd mod_wsgiConfigurer un environnement virtuel Python
Maintenant que nous avons les composants des référentiels, 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 virtualenvAvec + 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:
virtualenvCela 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/activateVotre 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 djangoCré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.pyDans 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 migrateCréez un utilisateur administratif pour le projet en tapant:
./manage.py createsuperuserVous 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 collectstaticVous 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:8000Dans votre navigateur Web, visitez le nom de domaine ou l’adresse IP de votre serveur suivi de «+: 8000 +»:
http://:8000Vous devriez voir la page d’index par défaut de Django:
image: https: //assets.digitalocean.com/articles/django_centos7/django_default.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_centos7/django_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_centos7/django_admin_page.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:
deactivateConfigurer 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 le passage WSGI, nous devons créer un nouveau fichier de configuration définissant le passage WSGI. Créez et ouvrez un fichier avec les privilèges + sudo + dans le répertoire + / etc / httpd / conf.d +. Nous appellerons ce fichier + django.conf +:
sudo nano /etc/httpd/conf.d/django.confCommenç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:
Alias /static /home///static
<Directory /home///static>
Require all granted
</Directory>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:
Alias /static /home///static
<Directory /home///static>
Require all granted
</Directory>
<Directory /home///>
<Files wsgi.py>
Require all granted
</Files>
</Directory>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 dans lequel Apache peut trouver tous les composants nécessaires. Comme nous avons utilisé un environnement virtuel, nous devrons configurer deux composants de chemin. Le premier est le répertoire parent de notre projet, où se trouvent les fichiers du projet. Le second est le chemin + lib / python. / Site-packages + dans notre dossier d’environnement virtuel (où les X sont remplacés par les composants du numéro de version Python). 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 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 +:
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//:/home////lib/python./site-packages
WSGIProcessGroup
WSGIScriptAlias / /home////wsgi.pyLorsque vous avez terminé ces modifications, enregistrez et fermez le fichier.
Résoudre certains problèmes d’autorisations
Ensuite, nous devons corriger quelques ensembles d’autorisations afin que le service Apache puisse accéder à nos fichiers. Par défaut, CentOS verrouille de manière très restrictive le répertoire de base de chaque utilisateur. Pour résoudre ce problème, nous allons ajouter l’utilisateur + apache + au groupe de notre propre utilisateur. Cela nous permettra d’ouvrir les autorisations juste assez pour qu’il puisse accéder aux fichiers appropriés.
Ajoutez l’utilisateur + apache + à votre groupe à l’aide de la commande suivante. Remplacez votre propre nom d’utilisateur par le ++ dans la commande:
sudo usermod -a -G apacheNous pouvons maintenant donner à votre groupe d’utilisateurs des autorisations d’exécution sur votre répertoire de base. Cela permettra au processus Apache d’entrer et d’accéder au contenu dans:
chmod 710 /home/Cela donnera à Apache la possibilité d’entrer dans notre répertoire personnel.
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 au fichier de base de données lui-même.
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.sqlite3Ensuite, nous devons donner au groupe sous lequel Apache s’exécute, le groupe + apache +, la propriété du fichier:
sudo chown :apache ~//db.sqlite3Pour é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 :apache ~/Une fois ces étapes terminées, vous êtes prêt à démarrer le service Apache. Pour ce faire, tapez:
sudo systemctl start httpdVous 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.
Si tout fonctionne comme prévu, vous pouvez activer le service Apache pour qu’il démarre automatiquement au démarrage:
sudo systemctl enable httpdConclusion
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.