TOC

Comment configurer Django avec Postgres, Nginx et Gunicorn sur Ubuntu 14.04

introduction

Django est un puissant framework Web qui peut vous aider à faire décoller 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 certains composants sous Ubuntu 14.04 pour prendre en charge et servir des applications Django. Nous allons configurer une base de données PostgreSQL au lieu d'utiliser la base de données SQLite par défaut. Nous allons configurer le serveur d’applications Gunicorn pour l’interface avec nos applications. Nous allons ensuite configurer Nginx pour inverser le proxy sur Gunicorn, nous donnant ainsi accès à ses fonctionnalités de sécurité et de performances pour servir nos applications.

Prérequis et objectifs

Afin de compléter ce guide, vous devez avoir une nouvelle instance de serveur Ubuntu 14.04 avec un utilisateur non root avec les privilègessudo configurés. Vous pouvez apprendre comment configurer cela en parcourant nosinitial server setup guide.

Nous installerons Django dans un environnement virtuel. 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 base de données et notre application seront opérationnelles, nous installerons et configurerons le serveur d’applications Gunicorn. Cela servira d'interface avec notre application, traduisant les requêtes client en HTTP en appels Python que notre application peut traiter. Nous installerons ensuite Nginx devant Gunicorn pour tirer parti de ses mécanismes de traitement des connexions hautes performances et de ses fonctionnalités de sécurité faciles à mettre en œuvre.

Commençons.

Installer les 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. Nous utiliserons le gestionnaire de packages Pythonpip pour installer des composants supplémentaires un peu plus tard.

Tout d'abord, mettez à jour l'index de paquet local, puis téléchargez et installez les paquets: 

sudo apt-get update
sudo apt-get install python-pip python-dev libpq-dev postgresql postgresql-contrib nginx

Cela installerapip, les fichiers de développement Python nécessaires pour construire Gunicorn plus tard, le système de base de données Postgres et les bibliothèques nécessaires pour interagir avec lui, et le serveur Web Nginx.

Créer la base de données et l'utilisateur PostgreSQL

Nous allons créer une base de données et un utilisateur de base de données pour notre application Django.

Pour travailler avec Postgres dans sa configuration par défaut, il est préférable de passer temporairement à l'utilisateur systèmepostgres. Faites-le maintenant en tapant: 

sudo su - postgres

Lorsque vous travaillez en tant qu'utilisateurpostgres, vous pouvez vous connecter directement à une session interactive PostgreSQL sans autre authentification en tapant: 

psql

Vous recevrez une invite PostgreSQL dans laquelle nous pourrons configurer nos exigences.

Commencez par créer une base de données pour votre projet: 

CREATE DATABASE myproject;

Chaque commande doit se terminer par un point-virgule. Vérifiez donc que votre commande se termine par un point si vous rencontrez des problèmes.

Ensuite, créez un utilisateur de base de données pour notre projet. Assurez-vous de sélectionner un mot de passe sécurisé: 

CREATE USER myprojectuser WITH PASSWORD 'password';

Maintenant, nous pouvons donner à notre nouvel utilisateur un accès pour administrer notre nouvelle base de données: 

GRANT ALL PRIVILEGES ON DATABASE myproject TO myprojectuser;

Lorsque vous avez terminé, quittez l'invite de PostgreSQL en tapant: 

\q

Maintenant, quittez la session shell de l’utilisateurpostgres pour revenir à la session shell de votre utilisateur normal en tapant: 

exit

Créer un environnement virtuel Python pour votre projet

Maintenant que notre base de données est prête, nous pouvons commencer à préparer le reste des exigences de notre projet. Nous allons installer nos exigences Python dans un environnement virtuel pour une gestion plus facile.

Pour ce faire, nous devons d'abord accéder à la commandevirtualenv. Nous pouvons l'installer avecpip: 

sudo pip install virtualenv

Avecvirtualenv installé, nous pouvons commencer à former notre projet. Créez un répertoire dans lequel vous souhaitez conserver votre projet et déplacez-vous ensuite dans le répertoire: 

mkdir ~/myproject
cd ~/myproject

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

virtualenv myprojectenv

Cela créera un répertoire appelémyprojectenv dans votre répertoiremyproject. À l'intérieur, il installera une version locale de Python et une version locale depip. 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 myprojectenv/bin/activate

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

Avec votre environnement virtuel actif, installez Django, Gunicorn et l'adaptateur PostgreSQLpsycopg2 avec l'instance locale depip: 

pip install django gunicorn psycopg2

Créer et configurer un nouveau projet Django

Avec nos composants Python installés, 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 myproject .

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 dans votre éditeur de texte: 

nano myproject/settings.py

Commencez par rechercher la section qui configure l'accès à la base de données. Il commencera parDATABASES. La configuration dans le fichier concerne une base de données SQLite. Nous avons déjà créé une base de données PostgreSQL pour notre projet, nous devons donc ajuster les paramètres.

Modifiez les paramètres avec les informations de votre base de données PostgreSQL. Nous disons à Django d'utiliser l'adaptateurpsycopg2 que nous avons installé avecpip. Nous devons donner le nom de la base de données, le nom d'utilisateur de la base de données, le mot de passe du nom d'utilisateur de la base de données, puis spécifier que la base de données se trouve sur l'ordinateur local. Vous pouvez laisser le paramètrePORT sous forme de chaîne vide: 

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'myproject',
        'USER': 'myprojectuser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}

Ensuite, déplacez-vous vers le bas du fichier et ajoutez un paramètre indiquant l'emplacement des fichiers statiques. Cela est nécessaire pour que Nginx puisse gérer les demandes relatives à ces éléments. La ligne suivante indique à Django de les placer dans un répertoire appeléstatic dans le répertoire du projet de base: 

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 PostgreSQL en utilisant le script de gestion: 

cd ~/myproject
./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 ensuite 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, accédez au nom de domaine ou à l’adresse IP de votre serveur suivi de:8000: 

http://server_domain_or_IP:8000

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

Django index page

Si vous ajoutez/admin à la fin de l'URL dans la barre d'adresse, vous serez invité à entrer le nom d'utilisateur et le mot de passe administratifs que vous avez créés avec la commandecreatesuperuser:

Django admin login

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

Django admin interface

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

Tester la capacité de Gunicorn à servir le projet

La dernière chose que nous voulons faire avant de quitter notre environnement virtuel est de tester Gunicorn pour s’assurer qu’il peut servir l’application. Nous pouvons le faire facilement en tapant: 

cd ~/myproject
gunicorn --bind 0.0.0.0:8000 myproject.wsgi:application

Ceci lancera Gunicorn sur la même interface que celle utilisée par le serveur de développement Django. Vous pouvez revenir en arrière et tester à nouveau l'application. Notez que le style ne sera pas appliqué à l'interface d'administration puisque Gunicorn ne connaît pas le contenu statique responsable de cela.

Nous avons transmis à Gunicorn un module en spécifiant le chemin du répertoire relatif au fichierwsgi.py de Django, qui est le point d’entrée de notre application, en utilisant la syntaxe du module de Python. À l'intérieur de ce fichier, une fonction appeléeapplication est définie, qui est utilisée pour communiquer avec l'application. Pour en savoir plus sur la spécification WSGI, cliquez surhere.

Lorsque vous avez terminé les tests, appuyez sur CTRL-C dans la fenêtre du terminal pour arrêter Gunicorn.

Nous avons maintenant fini de configurer notre application Django. Nous pouvons revenir en arrière de notre environnement virtuel en tapant: 

deactivate

Créer un fichier Gunicorn Upstart

Nous avons testé la capacité de Gunicorn à interagir avec notre application Django, mais nous devrions implémenter une méthode plus robuste de démarrage et d’arrêt du serveur d’applications. Pour ce faire, nous allons créer un script Upstart.

Créez et ouvrez un fichier Upstart pour Gunicorn avec les privilègessudo dans votre éditeur de texte: 

sudo nano /etc/init/gunicorn.conf

Nous allons commencer par une simple chaîne de description indiquant le type de fichier de service. Nous passerons ensuite à la définition des niveaux d’exécution du système où ce service devrait être démarré automatiquement. Les niveaux d'exécution normaux pour exécuter des services sont 2, 3, 4 et 5. Nous exécuterons notre service lorsque le système est dans l’un de ceux-ci. Nous lui dirons de s’arrêter à tout autre niveau d’exécution (par exemple, lorsque le système redémarre, s’arrête ou en mode mono-utilisateur): 

description "Gunicorn application server handling myproject"

start on runlevel [2345]
stop on runlevel [!2345]

Ensuite, nous dirons à Upstart de redémarrer automatiquement le service en cas d’échec. Nous voulons également spécifier l'utilisateur et le groupe à exécuter. Nous allons utiliser notre utilisateur normal, car tous nos fichiers appartiennent à cet utilisateur. Nous laisserons le groupewww-data auquel appartient Nginx être les propriétaires du groupe. Nous devons également modifier le répertoire de notre projet pour que les commandes Gunicorn s’exécutent correctement: 

description "Gunicorn application server handling myproject"

start on runlevel [2345]
stop on runlevel [!2345]

respawn
setuid user
setgid www-data
chdir /home/user/myproject

Maintenant, nous devons juste donner le commandement qui lancera le processus Gunicorn. Nous devons donner le chemin à l'exécutable Gunicorn, qui est stocké dans notre environnement virtuel. Nous lui indiquerons d'utiliser un socket Unix au lieu d'un port réseau pour communiquer avec Nginx, car les deux services seront exécutés sur ce serveur. Ceci est plus sécurisé et plus rapide. Vous pouvez également ajouter toute autre configuration pour Gunicorn. Par exemple, nous spécifierons que nous voulons 3 processus de travail: 

description "Gunicorn application server handling myproject"

start on runlevel [2345]
stop on runlevel [!2345]

respawn
setuid user
setgid www-data
chdir /home/user/myproject

exec myprojectenv/bin/gunicorn --workers 3 --bind unix:/home/user/myproject/myproject.sock myproject.wsgi:application

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

Démarrez le service Gunicorn en tapant: 

sudo service gunicorn start

Configurer Nginx to Proxy Pass to Gunicorn

Maintenant que Gunicorn est configuré, nous devons configurer Nginx pour transférer le trafic au processus.

Commencez par créer et ouvrir un nouveau bloc de serveur dans le répertoiresites-available de Nginx: 

sudo nano /etc/nginx/sites-available/myproject

À l'intérieur, ouvrez un nouveau bloc de serveur. Nous allons commencer par spécifier que ce bloc doit écouter sur le port normal 80 et qu’il doit répondre au nom de domaine ou à l’adresse IP de notre serveur: 

server {
    listen 80;
    server_name server_domain_or_IP;
}

Ensuite, nous dirons à Nginx d’ignorer tout problème lié à la recherche d’un favicon. Nous lui indiquerons également où trouver les actifs statiques que nous avons collectés dans notre répertoire~/myproject/static. Tous ces fichiers ont un préfixe d'URI standard «/ static». Nous pouvons donc créer un bloc d'emplacement correspondant à ces demandes: 

server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/user/myproject;
    }
}

Enfin, nous allons créer un bloclocation / {} pour correspondre à toutes les autres requêtes. À l'intérieur de cet emplacement, nous inclurons le fichier standardproxy_params inclus avec l'installation de Nginx, puis nous transmettrons le trafic au socket créé par notre processus Gunicorn: 

server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/user/myproject;
    }

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/user/myproject/myproject.sock;
    }
}

Enregistrez et fermez le fichier lorsque vous avez terminé. Maintenant, nous pouvons activer le fichier en le liant au répertoiresites-enabled: 

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

Testez votre configuration Nginx pour les erreurs de syntaxe en tapant: 

sudo nginx -t

Si aucune erreur n'est signalée, redémarrez Nginx en tapant: 

sudo service nginx restart

Vous devriez maintenant pouvoir accéder au domaine ou à l’adresse IP de votre serveur pour afficher votre application.

Conclusion

Dans ce guide, nous avons configuré un projet Django dans son propre environnement virtuel. Nous avons configuré Gunicorn pour traduire les demandes des clients afin que Django puisse les prendre en charge. Ensuite, nous avons configuré Nginx pour qu’il agisse en tant que proxy inverse pour gérer les connexions client et servir le projet approprié en fonction de la demande du client.

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