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