[PYTHON] Déployer l'application Django sur EC2 avec Nginx + Gunicorn + Supervisor
J'ai lancé une application Django avec une combinaison de Nginx + Gunicorn + Supervisor, donc un mémo de la procédure Cette fois, nous allons commencer avec rien dans l'OS
environnement
OS: Amazon Linux AMI Python: 3.6.1 Django: 1.11.4 Nginx: 1.10.3 Gunicorn: 19.7.1 Supervisor: 3.3.3
Installation de Nginx
installation de nginx
$ sudo yum install nginx
démarrer nginx
$ sudo nginx
paramètre de démarrage automatique de nginx
$ sudo chkconfig --add nginx
$ sudo chkconfig nginx on
Confirmer le réglage de démarrage automatique Si ça ressemble à ce qui suit, ça va
$ chkconfig | grep nginx
nginx 0:off 1:off 2:on 3:on 4:on 5:on 6:off
Accédez à http: // adresse IP et vérifiez s'il fonctionne correctement
OK si c'est comme suit
Construire un environnement Python
Cette fois, il a été construit avec Anaconda Téléchargez la version Python 3.6 depuis ici Téléchargez le package téléchargé sur / home / ec2-user avec un outil FTP tel que Cyberduck
Après le téléchargement, installez Anaconda avec la commande suivante
$ bash Anaconda3-4.4.0-Linux-x86_64.sh
Une fois l'installation terminée, placez-le dans votre PATH afin de pouvoir utiliser les commandes Anaconda.
$ export PATH="$PATH:/home/ec2-user/anaconda3/bin"
Confirmez en tapant la commande de conda
$ conda info -e
# conda environments:
#
root * /home/ec2-user/anaconda3
C'est bon
De plus, si le paramètre de variable d'environnement est ajouté à bashrc lors de l'installation d'annaconda
Do you wish the installer to prepend the Anaconda3 install location
to PATH in your /root/.bashrc ? [yes|no]
[no] >>> yes
L'environnement racine python est également 3.6
$ python --version
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
Créer un projet Django
Cette fois je vais créer un projet directement sur EC2 À l'origine, une application Django développée localement doit être clonée git La base de données utilise également le SQlite par défaut, mais utilise Postgresql ou MariaDB pour publier le service réel.
Tout d'abord, installez Django L'exécution ou non dans l'environnement racine est un peu controversée, et je pense qu'il vaut mieux créer un environnement séparé et exécuter Django, mais pour le moment, je vais l'installer dans l'environnement racine.
$ pip install django
Créez un projet s'il n'y a pas de problème
$ django-admin startproject test_project
Confirmez que le projet a été créé
$ ls -ltr
total 511032
-rw-rw-r-- 1 ec2-user ec2-user 523283080 Aug 3 04:50 Anaconda3-4.4.0-Linux-x86_64.sh
drwxrwxr-x 20 ec2-user ec2-user 4096 Aug 3 04:53 anaconda3
drwxrwxr-x 3 ec2-user ec2-user 4096 Aug 3 05:05 test_project
Modifiez ALLOW HOST de / test_project / test_project / settings.py comme suit
settings.py
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = ["Adresse IP du serveur"]
Démarrez Django avec la commande suivante
Par défaut, 127.0.0.1:8000 est utilisé comme adresse de liaison, vous devez donc ajouter 0.0.0.0: 8000 comme option
De plus, il est nécessaire d'ouvrir le port 8000 dans le groupe de sécurité AWS à l'avance.
$ cd test_project
$ python manage.py runserver 0.0.0.0:8000
Et si vous accédez à http: // adresse IP: 8000, vous pouvez accéder à l'application Django comme suit
Installer Gunicorn
Gunicorn est un serveur WSGI Python
Un serveur WSGI est un serveur qui connecte un serveur Web et une application Web.
Alors, imaginez une configuration comme Nginx <-> Gunicorn <-> Django.
Tout d'abord, installez Gunicorn
$ pip install gunicorn
Démarrez Django avec Gunicorn une fois installé
$ gunicorn test_project.wsgi --bind=0.0.0.0:8000
Comme précédemment, vous pouvez vous connecter à l'application Django en accédant à http: // adresse IP: 8000
Si settings.py est divisé en production et développement, il ressemble à ce qui suit.
$ gunicorn test_project.wsgi.wsgi --env DJANGO_SETTINGS_MODULE=test_project.settings_dev --bind=0.0.0.0:8000
Modifier les paramètres de Nginx
Modifiez /etc/nginx.conf comme suit
/etc/nginx.conf
~ Omis ~
http {
~ Omis ~
upstream app_server {
server 127.0.0.1:8000 fail_timeout=0;
}
server {
#Les 4 lignes suivantes sont commentées
#listen 80 default_server;
#listen [::]:80 default_server;
#server_name localhost;
#root /usr/share/nginx/html;
#Ajoutez les 3 lignes suivantes
listen 80;
server_nom adresse IP ou domaine;
client_max_body_size 4G;
# Load configuration files for the default server block.
include /etc/nginx/default.d/*.conf;
location / {
#Ajoutez les 4 lignes suivantes
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $http_host;
proxy_redirect off;
proxy_pass http://app_server;
}
~ Ce qui suit est omis ~
Après l'édition, redémarrez nginx avec la commande suivante
$ sudo service nginx restart
Stopping nginx: [ OK ]
Starting nginx: [ OK ]
Cela termine les paramètres de proxy inverse dans Nginx Cette fois, j'ai édité directement nginx.conf, mais il est également possible d'écrire le fichier de paramètres ailleurs et de le charger.
Puis lancez Django avec Gunicorn
$ gunicorn test_project.wsgi --bind=0.0.0.0:8000
Ensuite, lorsque vous accédez à «http: // adresse IP», vous devriez voir l'écran Django.
Démontrer un processus avec le superviseur
Dans l'état actuel, si vous arrêtez la commande Gunicorn ou vous déconnectez du serveur, l'application s'arrêtera. Pour résoudre ce problème, démonisez le processus Gunicorn avec Supervisor.
J'aimerais installer Supervisor immédiatement, mais Supervisor ne fonctionne qu'avec la série Python 2. Par conséquent, créez un environnement virtuel Python2 avec Anaconda et installez Supervisor dans cet environnement.
Tout d'abord, créez un environnement virtuel Python2 pour Supervisor avec la commande suivante
$ conda create -n supervisor python=2.7
Basculer vers l'environnement système python2 et installer le superviseur avec pip
$ source activate supervisor
$ pip install supervisor
Si vous pouvez l'installer sans problème, créez un fichier de paramétrage du superviseur et placez-le sous / etc.
$ echo_supervisord_conf > supervisord.conf
$ sudo mv supervisord.conf /etc
Ensuite, modifiez supervisord.conf comme suit pour définir le superviseur.
supervisord.conf
~ Omis ~
[supervisord]
logfile=/var/log/supervisord.log ;Modifier l'emplacement du journal
;logfile=/tmp/supervisord.log ; main log file; default $CWD/supervisord.log #Commenter
logfile_maxbytes=50MB ; max main logfile bytes b4 rotation; default 50MB
logfile_backups=10 ; # of main logfile backups; 0 means none, default 10
loglevel=info ; log level; default info; others: debug,warn,trace
pidfile=/var/run/supervisord.pid ;Postscript
;pidfile=/tmp/supervisord.pid ; supervisord pidfile; default supervisord.pid #Commenter
~ Omis ~
#include est commenté donc décommenter
[include]
files = supervisord.d/*.conf ;Emplacement du fichier de configuration du processus à démarrer
;files = relative/directory/*.ini
Créer un fichier journal et définir les autorisations
$ sudo touch /var/log/supervisord.log
$ sudo chown ec2-user /var/log/supervisord.log
$ sudo chgrp ec2-user /var/log/supervisord.log
$ sudo chmod 774 /var/log/supervisord.log
Définissez également la rotation du journal
$ sudo sh -c "echo '/var/log/supervisord.log {
missingok
weekly
notifempty
nocompress
}' > /etc/logrotate.d/supervisor"
Ensuite, créez un fichier décrivant les commandes du processus à démoniser. Tout d'abord, créez un répertoire pour placer ces fichiers
$ sudo mkdir /etc/supervisord.d
Créez django_app.conf sous /etc/supervisord.d Ici, écrivez les paramètres pour diaboliser le processus Gunicorn comme suit
django_app.conf
[program:django_app]
directory=/home/ec2-user/test_project
command=gunicorn test_project.wsgi --bind=0.0.0.0:8000
numprocs=1
autostart=true
autorestart=true
user=ec2-user
redirect_stderr=true
Spécifiez le répertoire à exécuter dans le répertoire et spécifiez la commande pour démarrer le processus dans command
Si vous pouvez le faire jusqu'à présent, démarrez le superviseur avec la commande suivante
$ supervisord
Ensuite, laissez le fichier conf être lu Ceci est toujours exécuté lors de la modification de conf etc.
$ supervisorctl reread
De plus, redémarrez le démon avec la commande suivante, et conf sera lu même à ce moment
$ supervisorctl reload
Démonisez le processus Gunicorn avec la commande suivante
$ supervisorctl start django_app
Si le message «django_app: ERROR (déjà commencé)» apparaît, utilisez la commande suivante pour redémarrer le processus ou l'arrêter avant de le démarrer.
$ supervisorctl stop django_app #Arrêtez
$ supervisorctl restart django_app #Redémarrer
Maintenant, essayez de vous déconnecter du serveur dans cet état Et lorsque vous accédez à «http: // adresse IP», l'écran Django s'affiche. Le processus Gunicorn est maintenant démonisé par le superviseur
C'était bon