[PYTHON] Déployer des applications Django sur Ubuntu + Nginx + MySQL (Build)

J'ai signé un contrat avec GMO Cloud ALTUS et déployé l'application Django développée dans l'environnement de Nginx + uWSGI + MySQL + Python3, je souhaite donc conserver un mémorandum de l'opération exécutée. Veuillez noter qu'il ne s'agit que d'une note de travail et pas nécessairement d'une meilleure pratique. N'hésitez pas à signaler d'éventuelles erreurs ou pénuries (rires)

Environnement d'exploitation

Tout d'abord, WSGI (Web Server Gateway Interface) est une interface standard (PEP333) entre une application écrite en Python et un serveur Web, et uWSGI est un serveur Web capable d'exécuter des applications Web conformes aux spécifications WSGI.

L'application créée avec Django est conçue pour fonctionner avec WSGI et peut être utilisée avec différentes configurations, mais cette fois, Yuri Umezaki de Pycon 2015 a été annoncé ([opération de service Web utilisant uWSGI / Docker] Exemple](https://www.youtube.com/watch?v=zsoqAf-c3_s&index=23&list=PLMkWB0UjwFGkE3BIm4qpwaK5oPrmLLJoT)) a été généré avec la configuration suivante.

--GMO Cloud ALTUS Basic Plan

• Ubuntu 16.04.1 LTS (GNU/Linux 4.4.0-47-generic x86_64)
• Nginx 1.11.6
• uWSGI 2.0.14
• MySQL 5.7.16
• Python 3.5.2
• Django 1.10.3

Configuration de l'application

Web Browser <--> Nginx <--> socket <--> uWSGI <--> Djnago <--> MySQL

Structure du répertoire

/
└── var/
    └── www/
        └── example.jp/           <-Dossier de destination du déploiement
            ├── venv/             <-Répertoire d'environnement virtuel
            │   ├── app           <-Racine du projet de l'application Django(django-Créé avec l'application admin startproject)
            │   │   └ main        <-Racine d'application de l'application Django(python manage.py startapp main)
            │   ├── uwsgi.ini     <-Fichier INI qui gère les options de démarrage uwsgi
            │   └── uwsgi_params  <-Fichier qui stocke les variables uwsgi
            └── static            <-Répertoire de stockage des fichiers statiques

Initialisation du serveur

1. Paramètres du pare-feu

GMO Cloud ALTUS a une fonction qui vous permet de définir le pare-feu à partir de l'écran, donc [GMO Cloud ALTUS Altus Basic Series Guide-Create a new security group](https://support.gmocloud.com/pf/guide/basic/console/ Défini selon make_security.html). Premièrement, seuls «22» et «80» ont ouvert les ports.

2. Connectez-vous au serveur virtuel

GMO Cloud ALTUS-Créez un serveur virtuel avec le modèle Ubuntu pour le plan de base. Une fois créé, vous pouvez vous connecter en tant qu'utilisateur appelé "cloud". Après avoir créé le serveur virtuel, le mot de passe de connexion du serveur virtuel s'affiche dans la boîte de dialogue. Notez-le car vous ne pouvez pas le voir sur les autres écrans.

3. Changez le port SSH et interdisez la connexion par l'utilisateur root

Le numéro de port SSH "22" est souvent piraté, alors changez-le de 22 en un autre numéro (2222 cette fois). De plus, en ce qui concerne l'authentification par mot de passe par l'utilisateur root, "PermitRootLogin prohibit-password" est dans un état où cela ne peut pas être fait même par défaut, donc les paramètres minimum requis sont terminés, mais juste au cas où, la connexion SSH par l'utilisateur root est interdite du tout. Faire.

# sshd_Modifier le fichier de configuration
[cloud]$ sudo vi /etc/ssh/sshd_config
[sudo] password for cloud:          <-Entrez le mot de passe de l'utilisateur cloud

/etc/ssh/sshd_config

# What ports, IPs and protocols we listen for
-Port 22
+Port 2222
(Omission)

# Authentication:
(Omission)
-PermitRootLogin prohibit-password
+PermitRootLogin no

4. Redémarrez le service SSH

Redémarrez le service SSH pour que les modifications apportées jusqu'à présent prennent effet.

[cloud]$ sudo service ssh restart

Après le redémarrage, fermez le port "22" dans le pare-feu et ouvrez le port "2222". Une fois que vous pouvez ouvrir et fermer le port

--Deny connexion via le port "22" --Port "2222", impossible de se connecter en tant qu'utilisateur root --Port "2222", l'utilisateur du cloud peut se connecter

Assure-toi.

5. Connexion SSH avec authentification par clé publique

[Changer le port SSH et interdire la connexion par l'utilisateur root](# 3-Changer le port ssh et interdire la connexion par l'utilisateur root) interdit la connexion directe en tant qu'utilisateur root et définit de sorte que seuls les utilisateurs généraux puissent se connecter. Je l'ai changé, mais je vais le configurer pour se connecter à l'aide de l'authentification par clé publique pour une utilisation plus sécurisée.

Pour ceux qui veulent en savoir plus sur l'authentification par clé publique, "Authentification par clé publique familière" - même les débutants peuvent comprendre! Veuillez vous référer au cours sur l'utilisation du serveur Web par VPS (2).

De plus, j'utilise Tera Term en tant que client SSH, mais pour savoir comment définir l'authentification par clé publique dans Tera Term, voir Connexion SSH par authentification par clé publique - Comment utiliser Tera Term / linux / tera-term-ssh-login-public-key /) et [SSH public key encryption method-public key authentication login with Tera Term](http://www.j-oosk.com/teraterm/authorized_keys/ Veuillez vous référer à 306 /).

Suivez le lien ci-dessus pour terminer les paramètres d'authentification par clé publique dans Tera Term.

/etc/ssh/sshd_config

# Change to no to disable tunnelled clear text passwords
-#PasswordAuthentication yes
+PasswordAuthentication no

Éditer.

Après modification, redémarrez le service SSH comme dans [4. Redémarrez le service SSH](# 4-Redémarrez le service ssh) et confirmez que la méthode d'authentification est passée de l'authentification par mot de passe à l'authentification par clé publique. Je vais.

6. Mettez à jour le système de gestion des packages

apt-get est une commande pour exploiter et gérer les paquets à l'aide de la bibliothèque APT (Advanced Package Tool), qui est un système de gestion de paquets pour les distributions basées sur Debian (Debian et Ubuntu), et inclut les dépendances des applications que vous souhaitez installer. Vous pouvez installer / désinstaller avec.

#Mettez à jour la base de données qui gère le package (ne mettez pas à jour le package lui-même)
[cloud]$ sudo apt-get update

#Mettre à jour les packages installés
[cloud]$ sudo apt-get upgrade

référence: [Ubuntu] Installer / désinstaller / mettre à niveau le package avec apt-get Comment utiliser apt-get apt-get - Fonctionnement et gestion du paquet - Commande Linux APT HOWTO (Documentation obsolète) Chapitre 3-Gestion des paquets [Emplacement et méthode de confirmation du journal des opérations de la commande Ubuntu / apt](http://linux.just4fun.biz/Ubuntu/apt%E3%82%B3%E3%83%9E%E3%83%B3%E3%83] % 89% E3% 81% AE% E6% 93% 8D% E4% BD% 9C% E3% 83% AD% E3% 82% B0% E3% 81% AE% E5% 9C% A8% E5% 87% A6 % E3% 81% A8% E7% A2% BA% E8% AA% 8D% E6% 96% B9% E6% B3% 95.html)

7. Modifier les paramètres régionaux (langue, etc.) pour le Japon

Les paramètres régionaux par défaut sont pour les pays anglophones, et les messages et les dates sont affichés pour les pays anglophones, changez donc les paramètres régionaux pour le Japon.

#Vérifiez les paramètres régionaux avant le changement
[cloud]$ locale

#Confirmez qu'il s'agit d'un environnement local anglophone
[cloud]$ date
Fri Dec 16 10:01:01 JST 2016

#Installer le pack japonais
[cloud]$ sudo apt-get install language-pack-ja

#Mettre à jour les paramètres régionaux
[cloud]$ sudo update-locale LANG=ja_JP.UTF-8

#Redémarrage du système d'exploitation
[cloud]$ sudo shutdown -r now

#Vérifiez les paramètres régionaux modifiés
[cloud]$ locale

#Confirmez qu'il a changé pour une langue japonaise
[cloud]$ date

8. Synchronisation de l'heure

Jusqu'au 15.04, Ubuntu utilisait ntpdate pour synchroniser l'heure, mais à partir du 15.10, il utilise la fonction Systemd pour synchroniser l'heure. Par défaut, un serveur NTP appelé "ntp.ubuntu.com" est utilisé pour la synchronisation de l'heure, changez-le donc en serveur NTP NICT (Information and Communication Research Organization) (ntp.nict.jp).

#Vérifiez les paramètres de synchronisation de l'heure
[cloud]$ systemctl -l status systemd-timesyncd

#Changer la destination d'acquisition du temps
[cloud]$ sudo sed -i 's/#NTP=/NTP=ntp.nict.jp/g' /etc/systemd/timesyncd.conf

? #Redémarrage du système d'exploitation
? sudo shutdown -r now

#Redémarrez le service de synchronisation de l'heure
[cloud]$ sudo systemctl restart systemd-timesyncd.service

#Vérifiez les paramètres de synchronisation de l'heure
[cloud]$ systemctl -l status systemd-timesyncd

#Temps d'affichage
[cloud]$ date

※référence: Modifier le paramètre d'ajustement de l'heure dans Ubuntu 16.04 et 15.10 systemd je ne sais pas

Créer un utilisateur Nginx

Plus tard, lors de l'installation de Nginx, nous créerons un groupe appelé Nginx et un utilisateur qui ne peut pas se connecter appelé Nginx. Définissez l'ID de groupe et l'ID utilisateur 100s conformément à la politique d'allocation ci-dessous.

#Vérifier l'ID de groupe utilisé
[cloud]$ cat /etc/group

#Créer un groupe nginx
[cloud]$ sudo groupadd -g [ID de groupe] nginx

#Vérifier l'ID utilisateur utilisé
[cloud]$ cat /etc/passwd

#Créer un utilisateur nginx qui appartient au groupe nginx
[cloud]$ sudo useradd -g nginx -u [Identifiant d'utilisateur] -d /nonexistent -s /bin/false nginx

Créer un utilisateur partagé

Créez un utilisateur d'application en tant qu'utilisateur qui exécute l'application.

#Ajouter un utilisateur d'application
[cloud]$ sudo useradd app -g nginx

#Confirmer l'utilisateur de l'application
[cloud]$ sudo cat /etc/passwd

#Vérifiez le groupe auquel appartient l'utilisateur de l'application
[cloud]$ sudo groups app

#Définir le mot de passe de l'utilisateur de l'application
[cloud]$ sudo passwd app

#Confirmez que vous pouvez passer à l'utilisateur de l'application
[cloud]$ su app

#Se déconnecter de l'utilisateur de l'application
[app]$ exit

Paramètres Python

Je souhaite installer et utiliser des packages indépendamment pour chaque projet, plutôt que de les installer globalement. Puisqu'il semble que pyvenv puisse être utilisé à la place de virtualenv de Python 3.3, utilisez pyvenv.

#Ubuntu 16 de GMO Cloud ALTUS.Python est déjà installé dans le modèle 04.
#Vérifiez le Python installé.
[cloud]$ python3 -V

#Installer pip
[cloud]$ sudo apt install python3-pip

#Mettre à jour pip
[cloud]$ pip3 install --upgrade pip

#Installez pyvenv
[cloud]$ sudo apt install python3-venv

référence: Préparer l'environnement de développement Python3 avec pyenv et venv Notes sur ce que j'ai appris lorsque j'ai pensé à utiliser pyenv ou virtualenv sous Windows

Paramètres Nginx

Plus tard, j'aimerais accélérer et optimiser le site Web, donc cette fois j'utiliserai le module PageSpeed (ngx_pagespeed) développé par Google en l'incorporant dans Nginx. Installez Nginx + ngx_pagespeed à partir de la source à l'aide d'un script shell fourni par Google.

#Installer la commande de décompression
[cloud]$ sudo apt-get install unzip

#Installer la bibliothèque OpenSSL
[cloud]$ sudo apt-get install libssl-dev

#La bibliothèque PCRE est une bibliothèque d'expressions régulières
#La correspondance par expression régulière devient possible en réécrivant l'URL et en spécifiant l'emplacement
[cloud]$ sudo apt-get install libpcre3-dev

#Créer un répertoire de destination du cache pour le tampon
[cloud]$ sudo mkdir -p /var/cache/nginx/client_temp

#Changer le propriétaire du répertoire de destination du cache du tampon
[cloud]$ sudo chown nginx:root /var/cache/nginx/client_temp

#Modifier les autorisations du répertoire de destination du cache du tampon
[cloud]$ sudo chmod 700 /var/cache/nginx/client_temp

#Passer à l'utilisateur root
[cloud]$ sudo su -

#Derniers modules Nginx et PageSpeed(ngx_pagespeed)Installer
[root]$ bash <(curl -f -L -sS https://ngxpagespeed.com/install) --nginx-version latest -b /usr/local/src

#Une boîte de dialogue apparaît au milieu où vous pouvez spécifier des options de configuration supplémentaires, spécifiez donc des options supplémentaires.
(Omission)
About to build nginx.  Do you have any additional ./configure
arguments you would like to set?  For example, if you would like
to build nginx with https support give --with-http_ssl_module
If you don't have any, just press enter.
> --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=nginx --group=nginx --with-file-aio --with-threads --with-ipv6 --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_ssl_module --with-cc-opt='-g -O2 -fstack-protector-strong -Wformat -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2' --with-ld-opt='-Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-z,now -Wl,--as-needed'

#Se déconnecter de l'utilisateur root
[root]$ exit

#Vérifiez la version de Nginx
[cloud]$ nginx -V

#Lancez Nginx
[cloud]$ sudo nginx

Après avoir démarré Nginx, connectez-vous à http: // [adresse IP] avec un navigateur et si vous pouvez afficher la page d'accueil de Nginx, c'est OK!

Je vais introduire le réglage de ngx_pagespeed dans la section opération qui sera mise à jour plus tard, mais cette fois je voudrais vérifier uniquement la partie qui active la fonction pour le moment.

Ajoutez le paramètre pour activer PageSpeed à la directive serveur dans /etc/nginx/nginx.conf. Dans la directive serveur de nginx.conf

/etc/nginx/nginx.conf

http {
    (Omission)
    server {
         (Omission)
+        pagespeed on;
+        pagespeed RewriteLevel CoreFilters;
+        pagespeed FileCachePath /var/cache/ngx_pagespeed_cache;
+        pagespeed EnableFilters collapse_whitespace,trim_urls,remove_comments;
         (Omission)
    }

}

Si vous pouvez ajouter, redémarrez Nginx et vérifiez la réponse à la demande. S'il y a "X-Page-Speed: 1.11.33.4-0" dans l'en-tête de la réponse, c'est OK!

#Redémarrez Nginx
[cloud]$ sudo nginx -s reload

#Lancer une requête et vérifier l'en-tête de la réponse
[cloud]$ curl -I 'http://localhost/' | grep X-Page-Speed
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
X-Page-Speed: 1.11.33.4-0

référence: Build ngx_pagespeed From Source Comment accélérer le site Web en introduisant Nginx + PageSpeed (ngx_pagespeed) 1ère sérialisation de nginx: introduction de nginx Utilisez PageSpeed pour optimiser et accélérer votre site Web NGINX-1.5.12. Procédure de compilation et d'installation [Debian] [CentOS] [Ubuntu] Vérifiez les politiques d'ID utilisateur et les règles d'allocation Ubuntu Policy Manual - 9.2.2 UID and GID classes

Paramètres MySQL

# MySQL5.Installer 7
$ sudo apt-get -y install mysql-server-5.7

#Connectez-vous en tant qu'utilisateur root
$ mysql -u root -p

#Créer une base de données
mysql> CREATE DATABASE `[Nom de la base de données]` DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_general_ci;

#Sélectionnez la base de données mysql
mysql> USE 'mysql';

#Afficher les informations utilisateur
mysql> select user,host from mysql.user;

#Autorisation pour la base de données créée et créée par l'utilisateur(CREATE, ALTER, REFERENCES, INDEX, SELECT, UPDATE, INSERT, DELETE)Subvention
mysql> GRANT CREATE,ALTER,REFERENCES,INDEX,SELECT,UPDATE,INSERT,DELETE ON [Nom de la base de données].* TO '[Nom d'utilisateur]'@'localhost' IDENTIFIED BY '[mot de passe]';

#Vérifiez les autorisations de l'utilisateur créé
mysql> SHOW GRANTS for '[Nom d'utilisateur]'@'localhost';

#Déconnectez-vous de MySQL
mysql> exit

※référence Installation MySQL Using MySQL with Django - Access denied for user '@'localhost [MySQL / Création d'utilisateurs et de bases de données](http://wiki.minaco.net/index.php?MySQL%2F%E3%83%A6%E3%83%BC%E3%82%B6%E3%81%A8DB % E4% BD% 9C% E6% 88% 90)

Création d'un répertoire de destination de déploiement

#Créer un répertoire de destination de déploiement
[cloud]$ sudo mkdir -p /var/www/example.jp

#Changer le propriétaire du répertoire de destination
[cloud]$ sudo chown root:nginx /var/www/example.jp

#Modifier les autorisations du répertoire de destination du déploiement
[cloud]$ sudo chmod g+w /var/www/example.jp

#Passer à l'utilisateur de l'application
$ su app

#Créez un environnement virtuel appelé venv.
[app]$ /usr/bin/pyvenv /var/www/example.jp/venv

#Activez l'environnement virtuel créé. Lorsque l'environnement virtuel est activé, "([nom evn])Est ajouté au début du shell.
[app]$ source /var/www/example.jp/venv/bin/activate

#Mettre à jour le pip de l'environnement virtuel à la dernière
(venv)[app]$ pip install --upgrade pip

#Installer Django dans un environnement virtuel
(venv)[app]$ pip install Django

#Installez uWSGI dans un environnement virtuel
(venv)[app]$ pip install uwsgi

#Installez PyMySQL dans un environnement virtuel pour que Django puisse se connecter à MySQL
(venv)[app]$ pip install PyMySQL

#Désactivez l'environnement virtuel une fois
(venv)[app]$ deactivate

Je pense qu'il existe différentes manières de déployer l'application Django créée, comme l'utilisation du logiciel Git ou FTP, mais cette fois je la téléchargerai sur le serveur à l'aide du logiciel FTP.

Téléchargez l'application Django créée en tant qu'utilisateur de l'application sous "/var/www/example.jp/venv/" avec le logiciel FTP. Cependant, j'ai changé pour interdire l'authentification par mot de passe dans [connexion SSH par authentification par clé publique](connexion # 5-ssh par authentification par clé publique) et me connecter avec l'authentification par clé publique, donc je l'ai paramétrée de sorte que l'authentification par clé publique puisse également être effectuée avec le logiciel FTP. Devoir.

J'utilise WinSCP comme logiciel FTP, mais comme WinSCP ne prend en charge que les clés privées au format PuTTY, je l'ai créé avec [connexion SSH par authentification par clé publique](connexion # 5-ssh par authentification par clé publique). J'ai converti la clé privée au format PuTTY.

Cliquez sur le bouton Modifier dans l'écran de connexion pour afficher l'écran "Paramètres avancés du site". Cliquez sur "SSH" ⇒ "Authentification" dans la navigation, et cliquez sur le bouton "Sélectionner un fichier" pour "Clé privée". L'écran "Sélectionner la clé privée" apparaîtra. [Connexion SSH par authentification par clé publique](# 5-Sélectionnez la clé privée créée par connexion ssh par authentification par clé publique), et elle sera automatiquement convertie en clé privée au format PuTTY.

Paramètres uWSGI

#Se déconnecter de l'utilisateur de l'application
[app]$ exit

#Créez un répertoire pour stocker les fichiers socket uWSGI et pid
[cloud]$ sudo mkdir -p /var/run/uwsgi

#Changer le propriétaire du répertoire qui stocke le socket uWSGI et les fichiers pid
[cloud]$ sudo chown root:nginx /var/run/uwsgi

#Modifiez les autorisations du répertoire qui stocke le socket uWSGI et les fichiers pid
[cloud]$ sudo chmod g+w /var/run/uwsgi

#Créer un répertoire pour stocker les fichiers journaux uWSGI
[cloud]$ sudo mkdir -p /var/log/uwsgi

Créez un fichier (uwsgi_params) qui définit les variables pour uWSGI sous /var/www/example.jp/venv/.

/var/www/example.jp/venv/uwsgi_params

uwsgi_param  QUERY_STRING       $query_string;
uwsgi_param  REQUEST_METHOD     $request_method;
uwsgi_param  CONTENT_TYPE       $content_type;
uwsgi_param  CONTENT_LENGTH     $content_length;

uwsgi_param  REQUEST_URI        $request_uri;
uwsgi_param  PATH_INFO          $document_uri;
uwsgi_param  DOCUMENT_ROOT      $document_root;
uwsgi_param  SERVER_PROTOCOL    $server_protocol;
uwsgi_param  REQUEST_SCHEME     $scheme;
uwsgi_param  HTTPS              $https if_not_empty;

uwsgi_param  REMOTE_ADDR        $remote_addr;
uwsgi_param  REMOTE_PORT        $remote_port;
uwsgi_param  SERVER_PORT        $server_port;
uwsgi_param  SERVER_NAME        $server_name;

Créez uwsgi.ini avec les options de démarrage uWSGI.

vim:/var/www/example.jp/venv/uwsgi.ini

[uwsgi]
uid = nginx
gid = nginx

# Django-related settings
# the base directory (full path)
#Veuillez le changer en fonction de votre environnement
chdir = /var/www/example.jp/venv/app

# Django's wsgi file
#Veuillez le changer en fonction de votre environnement(En gros, "nom du projet Django.ensemble wsgi ")
module = app.wsgi

# the virtualenv (full path)
#Veuillez le changer en fonction de votre environnement
home = /var/www/example.jp/venv


# process-related settings
# master
master = true

# maximum number of worker processes
processes = 2

threads = 1

# the socket (use the full path to be safe
socket = /var/run/uwsgi/master.sock

pidfile = /var/run/uwsgi/master.pid

# ... with appropriate permissions - may be needed
chmod-socket = 666

# clear environment on exit
vacuum = true

thunder-lock = true

max-requests = 6000
max-requests-delta = 300

# log
logto = /var/log/uwsgi/uwsgi.log
deamonize = /var/log/uwsgi/uwsgi-@(exec://date +%Y-%m-%d).log
log-reopen = true

Paramètres Nginx

À l'avenir, définissez l'hôte virtuel en supposant que plusieurs applications seront exploitées sur le même serveur.

Créer les répertoires "/ etc / nginx / sites-available" et "/ etc / nginx / sites-enabled" Le fichier de configuration de l'hôte virtuel est stocké dans "/ etc / nginx / sites-available".

Au démarrage de Nginx, lisez sous "/ etc / nginx / sites-enabled" et dans "/ etc / nginx / sites-enabled", créez un lien symbolique vers le fichier de configuration sous "/ etc / nginx / sites-available" Vous pouvez activer ou désactiver les paramètres de l'hôte virtuel en le définissant ou en le supprimant, ce qui facilite la gestion.

#Créer un répertoire pour stocker le fichier de configuration d'hôte virtuel
[cloud]$ sudo mkdir /etc/nginx/sites-available

#Créez un répertoire pour stocker le lien symbolique vers le fichier de configuration de l'hôte virtuel que vous souhaitez activer
[cloud]$ sudo mkdir /etc/nginx/sites-enabled

Créez un fichier de configuration d'hôte virtuel sous "/ etc / nginx / sites-available /".

/etc/nginx/sites-available/example.jp

# the upstream component nginx needs to connect to
upstream django {
    # for a file socket
    server unix:///var/run/uwsgi/master.sock;
}

# configuration of the server
server {
    # the port your site will be served on
    listen      80;
    # the domain name it will serve for
    # substitute your machine's IP address or FQDN
    server_name [Adresse IP ou domaine];
    charset     utf-8;

    # max upload size
    # Django media
    location /static {
        # your Django project's static files - amend as required
        #Veuillez le modifier en fonction de votre environnement.
        alias /var/www/example.jp/static;
    }

    # Finally, send all non-media requests to the Django server.
    location / {
        uwsgi_pass  django;
        # the uwsgi_params file you installed
        #Veuillez le modifier en fonction de votre environnement.
        include     /var/www/example.jp/venv/uwsgi_params;
    }
}

Une fois que vous avez créé le fichier de configuration d'hôte virtuel, créez un lien symbolique.

#Créez un lien symbolique vers le fichier de configuration de l'hôte virtuel que vous souhaitez activer
[cloud]$ sudo ln -s /etc/nginx/sites-available/example.jp /etc/nginx/sites-enabled/example.jp

Ajoutez à la directive http pour lire sous "/ etc / nginx / sites-enabled /".

/etc/nginx/nginx.conf

http {
     (Omission)
     #gzip  on;
+    include /etc/nginx/sites-enabled/*;
     (Omission)
}

Configurez Nginx pour qu'il démarre automatiquement même si le système d'exploitation est redémarré. Créez "/etc/systemd/system/nginx.service".

/etc/systemd/system/nginx.service

[Unit]
Description=The NGINX HTTP and reverse proxy server
After=syslog.target network.target remote-fs.target nss-lookup.target

[Service]
Type=forking
PIDFile=/run/nginx.pid
ExecStartPre=/usr/sbin/nginx -t
ExecStart=/usr/sbin/nginx
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s QUIT $MAINPID
PrivateTmp=true

[Install]
WantedBy=multi-user.target

Une fois que vous avez créé "/etc/systemd/system/nginx.service"

#Nginx est en cours d'exécution, alors arrêtez-le
#Si vous obtenez une erreur telle que "Impossible d'ouvrir le fichier PID", redémarrez le système d'exploitation
[cloud]$ sudo nginx -s stop

#Début de service
[cloud]$ sudo systemctl start nginx

#Panne de service
[cloud]$ sudo systemctl stop nginx

#Activer le démarrage automatique du service
[cloud]$ sudo systemctl enable nginx

#Début de service
[cloud]$ sudo systemctl start nginx

Après avoir confirmé que le service peut être démarré / arrêté en exécutant, enregistrez Nginx en tant que service.

Autres commandes pour le service

#Redémarrage du service
$ sudo systemctl restart [Nom du service]

#Désactiver le démarrage automatique du service
$ sudo systemctl disable [Nom du service]

#Vérifier l'état de fonctionnement du service
$ sudo systemctl status [Nom du service]

#Tuez tous les processus inclus dans le service
$ sudo systemctl kill -s9 [Nom du service]

référence: [Introduisez le serveur Web léger et rapide Nginx dans Ubuntu 12.04 (partie 1 des paramètres)](http://blog.kondoyoshiyuki.com/2012/12/09/setting-1-nginx-on-ubuntu-12 -04 /) NGINX systemd service file

Paramètres initiaux de Django

Je souhaite créer une base de données et des tables dans MySQL, je vais donc effectuer une migration DB de Django.

#Activer l'environnement virtuel
[app]$ source /var/www/example.jp/venv/bin/activate

#Créer un fichier de migration
(venv)[app]$ python /var/www/example.jp/venv/pornstar/manage.py makemigrations app

#Vérifiez la migration à exécuter au format SQL
(venv)[app]$ python /var/www/example.jp/venv/pornstar/manage.py sqlmigrate app 0001

#Effectuer la migration
(venv)[app]$ python /var/www/example.jp/venv/pornstar/manage.py migrate

En outre, les fichiers statiques sont collectés en les copiant de chaque application dans un répertoire spécifique afin qu'ils puissent être facilement publiés dans l'environnement de production. Copiez le fichier statique dans le répertoire spécifié dans avec la commande suivante.

Modifiez settings.py dans votre application Django, ajoutez STATIC_ROOT et commentez STATICFILES_DIRS.

diff:/var/www/example.jp/venv/app/app/settings.py

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.10/howto/static-files/

STATIC_URL = '/static/'
+STATIC_ROOT = '/var/www/example.jp/static/'
(Omission)
-STATICFILES_DIRS = (
-    os.path.join(BASE_DIR, "static"),
-)
+#STATICFILES_DIRS = (
+#    os.path.join(BASE_DIR, "static"),
+#)

#Copier le fichier statique
(venv)[app]$ python /var/www/example.jp/venv/app/manage.py collectstatic

#Désactiver l'environnement virtuel
(venv)[app]$ deactivate

référence: Comment publier des fichiers statiques

Paramètres de démarrage automatique uWSGI

Comme Nginx, créez "/etc/systemd/system/uwsgi.service" pour que uWSGI démarre automatiquement même si le système d'exploitation est redémarré.

/etc/systemd/system/uwsgi.service

# uwsgi.service
[Unit]
Description=uWSGI
After=syslog.target

[Service]
ExecStartPre=/bin/bash -c 'mkdir -p /var/run/uwsgi; chown root:nginx /var/run/uwsgi; chmod g+w /var/run/uwsgi;'
ExecStart=/bin/bash -c 'source /var/www/example.jp/venv/bin/activate; uwsgi --ini /var/www/example.jp/venv/uwsgi.ini'
#Restart=always
Restart=on-failure
KillSignal=SIGQUIT
Type=notify
StandardError=syslog
NotifyAccess=all

[Install]
WantedBy=multi-user.target

"ExecStartPre" est une option pour spécifier la commande à exécuter avant de démarrer le service, mais il est spécifié pour créer le répertoire (/ var / run / uwsgi) pour stocker le fichier pid uWSGI et le fichier socket comme commande à exécuter.

Parce que "/ var / run" est un lien symbolique vers "/ run", et "/ run" est monté dans le système de fichiers tmpfs. Ensuite, lorsque le système d'exploitation est redémarré, tous les fichiers sous "/ run (= / var / run)" seront supprimés, donc une commande pour créer un répertoire est spécifiée au cas où le répertoire n'existe pas.

Assurez-vous que vous pouvez démarrer / arrêter le service et activer le démarrage automatique.

#Début de service
[cloud]$ sudo systemctl start uwsgi

#Panne de service
[cloud]$ sudo systemctl stop uwsgi

#Activer le démarrage automatique du service
[cloud]$ sudo systemctl enable uwsgi

#Début de service
[cloud]$ sudo systemctl start uwsgi

Fichier de configuration Django mis à jour

diff:/var/www/example.jp/venv/app/app/settings.py

(Omission)
# SECURITY WARNING: don't run with debug turned on in production!
-DEBUG = True
+DEBUG = False
-ALLOWED_HOSTS = []
+ALLOWED_HOSTS = ['Adresse IP ou domaine']
(Omission)

Si vous pouvez accéder à http: // [adresse IP ou domaine] avec un navigateur et afficher l'application, c'est OK!

Quand ça ne marche pas

--Erreur interne

Vérifiez le fichier journal des erreurs Nginx (/var/log/nginx/error.log) et le fichier journal uWSGI (/var/log/uwsgi/uwsgi.log) pour identifier l'erreur.

Les références

1. Incorporer l'application uWSGI + Django dans Nginx
2. Essayez nginx + uWSGI + Flask
3. Procédure de publication de l'application Django sur CentOS 7 + Nginx
4. Comment utiliser Django avec uWSGI
5. Django Best Practice-Deployment-Server
6. [Construction de l'environnement Django (Ubuntu Server, Apache, PostgreSQL)](http://yura2.hateblo.jp/entry/2015/04/05/Django%E3%81%AE%E7%92%B0%E5 % A2% 83% E6% A7% 8B% E7% AF% 89 (Ubuntu_Server, _Apache, _PostgreSQL))
7. De l'installation d'Apache au déploiement de Django
8. Utilisons uWSGI, un serveur WSGI pratique et super puissant
9. Notez que l'application Python Flask a été déployée sous l'environnement nginx + uWSGI
10. Setting up Django and your web server with uWSGI and nginx