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 スクリーンショット 2017-08-03 13.40.56.png

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 スクリーンショット 2017-08-03 15.23.25.png

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

Recommended Posts

Déployer l'application Django sur EC2 avec Nginx + Gunicorn + Supervisor
Déployer l'application Django avec Docker
Comment déployer une application Django dans le cloud Alibaba
Déployer l'application Django sur Google App Engine (Python3)
Lancer une application Web Python sur Nginx + Gunicorn avec Docker
Déployer l'application Django créée avec PTVS sur Azure
Déployer l'application Django sur Heroku
Lancement d'une application Web sur AWS avec django et modification des tâches
Remarques sur l'activation de PostgreSQL avec Django
J'ai fait une application WEB avec Django
Jusqu'à ce que l'application Web créée avec Bottle soit publiée (déployée) sur Heroku
# 1 Jusqu'au déploiement de l'application Web de Django (création d'une instance avec EC2 sur AWS)
Hello World avec nginx + uwsgi + python sur EC2
Exécutez Flask sur CentOS avec python3.4, Gunicorn + Nginx.
Créez une application Hello World avec un seul fichier avec django
Déployer des applications Web Python 3.6 / Django / Postgres sur Azure
Retour sur la création d'un service Web avec Django 1
Retour sur la création d'un service Web avec Django 2
Un mémo sur la création d'une application Django (Python) avec Docker
Créer un environnement django avec docker-compose (MariaDB + Nginx + uWSGI)
Déployer Django sans serveur avec Lambda
Créer une page d'accueil avec django
Créer une application Web avec Django
(Échec) Déployer une application Web créée avec Flask avec heroku
Créez rapidement un environnement d'exécution d'application Web Python3.4 + Nginx + uWSGI + Flask en utilisant pyenv sur Ubuntu 12.04
Créer une application Web de type Flask / Bottle sur AWS Lambda avec Chalice
# 3 Créez un environnement Python (Django) avec une instance EC2 (ubuntu18.04) d'AWS part2
Mesurer la couverture des applications Django avec Coverage.py
Django Tips-Créez un site de classement avec Django-
Application de publication sur Twitter réalisée avec Django
Implémenter l'application Django sur Hy
Exécutez python3 Django1.9 avec mod_wsgi (déployer)
Créer un filtre avec un modèle django
Créer un téléchargeur de fichiers avec Django
Exécuter un lot de Python 2.7 avec nohup sur Amazon Linux AMI sur EC2
Jusqu'à ce que l'application Django (+ MySQL) soit publiée sur AWS EC2 (+ RDS (+ S3))
J'ai fait une webAPI! Construire un environnement à partir de Django Rest Framework 1 avec EC2
Créer un serveur proxy avec nginx sur plusieurs serveurs distants à l'aide d'Ansible
Django + Apache avec mod_wsgi sur Windows Server 2016
Un mémo contenant Python2.7 et Python3 dans CentOS
Carte des informations de location sur une carte avec python
Déployer l'application Django sur Heroku [Partie 2]
Déployer l'application Django sur Heroku [Partie 1]
Lancer une demande avec un certificat sur httpie
Créer un écran de connexion dans Django all auth
[Python] Une application web rapide avec Bottle!
Exécutez une application Web Python avec Docker
Lancez l'application Flask avec Docker sur Heroku
Flacon + Gunicorn + Nginx + Supervisor jusqu'à ce que cela fonctionne
L'histoire de la création d'une application Web qui enregistre des lectures approfondies avec Django
Comment exécuter une application Django sur un conteneur Docker (environnement de développement et de production)
Essayez de créer une application Web avec Vue.js et Django (édition Mac) - (1) Construction d'environnement, création d'application
Créer un environnement de développement TensorFlow sur Amazon EC2 avec une copie de commande