Développement d'applications Web Python avec NGINX + NGINX Unit + Flask

Je voulais faire du développement Web avec Python, j'ai donc créé un environnement pour les applications Web Python. Jusqu'à présent, la configuration courante était NGINX <-> uwsgi <-> Flask, mais en avril 2018, NGINX a publié le serveur AP léger NGINX Unit. Cette fois, nous utiliserons NGINX Unit et créerons un environnement d'application Web avec la configuration NGINX <-> NGINX Unit <-> Flask.

environnement

Utilisez NGINX comme serveur Web, NGINX Unit comme serveur AP et Flask comme framework Web Python.

OS : CentOS7
Python : 3.7.4
NGINX : 1.16.1
NGINX Unit : 1.10.0
Flask : 1.1.1

Remarques

Le serveur utilise un environnement virtuel de Vagrant et VirtualBox. Veuillez activer le réseau privé.

$ vagrant init centos/7
$ vi Vagrantfile
- # config.vm.network "private_network", ip: "192.168.33.10"
+ config.vm.network "private_network", ip: "192.168.33.10"
$ vagrant up
$ vagrant ssh

Connectez-vous à l'environnement virtuel avec vagrant ssh et désactivez selinux.

$ sudo vi /etc/selinux/config
- SELINUX=enforcing
+ SELINUX=disabled
$ sudo reboot

Construire un environnement de développement Python

Créez un environnement de développement Python dans un environnement virtuel. Par défaut, CentOS a Python 2.7.5 installé.

$ python --version
Python 2.7.5

Cette fois, nous utiliserons Python 3.7.4.

Installez Python3 sur CentOS

Installez Python sur CentOS en vous référant à la procédure sur la [page officielle] de Python (https://www.python.jp/install/centos/index.html). Tout d'abord, installez les outils nécessaires.

$ sudo yum -y groupinstall "development tools"
$ sudo yum install -y bzip2-devel gdbm-devel libffi-devel libuuid-devel ncurses-devel openssl-devel readline-devel sqlite-devel tk-devel wget xz-devel zlib-devel

Téléchargez le programme d'installation depuis la page officielle de Python (https://www.python.org/downloads/release/python-374/) avec wget. Décompressez après le téléchargement.

$ wget https://www.python.org/ftp/python/3.7.4/Python-3.7.4.tgz
$ tar xzf Python-3.7.4.tgz

Construisez après avoir décompressé le code source.

$ cd Python-3.7.4
$ ./configure --enable-shared
$ make
$ sudo make install
$ sudo sh -c "echo '/usr/local/lib' > /etc/ld.so.conf.d/custom_python3.conf"
$ sudo ldconfig

La commande construite sera installée sous / usr / local / bin.

$ which python
/usr/bin/python
$ which python3
/usr/local/bin/python3
$ python3 --version
Python 3.7.4
$ which pip3
/usr/local/bin/pip3

Enfin, mettez à jour pip.

$ pip3 install --upgrade pip --user

La dernière version de la commande pip est installée dans le bin local.

$ which pip
~/.local/bin/pip
$ pip --version
pip 19.2.3 from /home/vagrant/.local/lib/python3.7/site-packages/pip (python 3.7)

C'est tout pour créer l'environnement Python.

Créer un environnement virtuel Python

Créez un environnement virtuel Python pour basculer et gérer les packages pour chaque projet. Python fournit venv comme module standard qui prend en charge la création d'environnements virtuels. Créez un environnement virtuel en utilisant venv.

# flask_Créer un environnement virtuel appelé sample
$ python3 -m venv flask_sample
$ ls
venv

Activez l'environnement virtuel créé par venv.

$ source flask_sample/bin/activate
(flask_sample)$

Vous pouvez activer l'environnement virtuel en exécutant le script ʻactivate dans le répertoire créé par le module venv. Lorsque vous activez l'environnement virtuel, (nom de l'environnement virtuel)` s'affiche au début de l'invite. Accédez au répertoire de l'environnement virtuel que vous avez créé et vérifiez la configuration.

(flask_sample)$ cd flask_sample
(flask_sample)$ ls
bin  include  lib  lib64  pyvenv.cfg

Le répertoire bin contient le script ʻactivate qui active l'environnement virtuel et la commande de l'outil de gestion de paquet Python pip. Lorsque vous exécutez la commande pipdans un environnement virtuel, les commandes de ce répertoire sont exécutées. Les packages installés sont installés danslib / python3.7 / site-packages et lib64 / python3.7 / site-packages. Dans l'environnement virtuel, ignorez le répertoire site-packages` de Python lui-même et utilisez les packages de ce répertoire. Vous pouvez développer des applications sans polluer le package de Python lui-même.

Créer un exemple de projet avec Flask

Flask est un petit microframework Python. Les fonctionnalités répertoriées en standard sont minimes et sont utilisées lors du développement de petites applications. Des plugins sont fournis afin que vous puissiez étendre vos fonctionnalités. Utilisez Django si vous souhaitez développer une grande application depuis le début.

Installation du flacon

Dans l'environnement virtuel venv, installez Flask.

(flask_sample)$  pip install Flask

Créer une application

La structure de l'exemple de projet est la suivante.

/sample
  |- app.py
  |- templates
        |- index.html
        |- post.html

Chaque code est implémenté comme suit.

`app.py`


from flask import Flask ,render_template,request

application = Flask(__name__)

@application.route('/')
def index():
    return render_template('index.html')

@application.route('/sample',methods=['POST'])
def sample():
    message = request.form['message']
    return render_template('post.html',message=message)

if __name__=="__main__":
    application.run(host='0.0.0.0')

`index.html`


<html>
  <head>
    <meta charset="utf-8" />
    <title>Flask Sample</title>
  </head>
  <body>
    <h1>Flask Smaple</h1>
    <form action="sample" method="post">
      <input type="text" name="message" />
      <input type="submit" value="Envoyer" />
    </form>
  </body>
</html>

`post.html`


<html>
  <head>
    <meta charset="utf-8" />
    <title>Flask Sample</title>
  </head>
  <body>
    <h1>Flask Smaple</h1>
message:{{message}}
  </body>
</html>

Après l'implémentation, exécutez ʻapp.py` pour lancer l'application Flask.

(flask_sample)$ python /sample/app.py
 * Serving Flask app "app" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

Si vous accédez à http: // IP privé de l'environnement virtuel: 5000 / avec un navigateur après le démarrage, ʻindex.htmlsera affiché. Si vous pouvez le confirmer, le contrôle de fonctionnement deFlaskest terminé. Ensuite, construisez un serveur AP avecNGINX Unit`.

NGINX Unit

NGINX Unit est un serveur d'applications léger développé par NGINX. Vous pouvez exécuter des applications dans plusieurs langues afin de pouvoir exécuter des applications dans différentes langues sur le même serveur. Le langage prend en charge Python, PHP, Go, Perl, Ruby, Node.js, Java. En outre, différentes versions de la langue peuvent coexister et fonctionner. (Python2.7 et Python3, etc.) Vous pouvez modifier les paramètres en temps réel sans arrêter le serveur via API ou JSON, vous pouvez donc modifier les paramètres de manière transparente sans arrêter le service.

Installation

Le Document officiel a publié la méthode d'installation pour chaque OS.

Sortez de l'environnement virtuel venv et ajoutez un référentiel yum.

(flask_sample)$ deactivate
$ sudo vi /etc/yum.repos.d/unit.repo
[unit]
name=unit repo
baseurl=https://packages.nginx.org/unit/centos/$releasever/$basearch/
gpgcheck=0
enabled=1

Installez-le.

$ sudo yum install -y unit
$ sudo yum install -y unit-devel unit-go unit-jsc8 unit-perl unit-php unit-python

Définit le démarrage automatique de l'unité NGINX.

$ sudo systemctl enable unit
Created symlink from /etc/systemd/system/multi-user.target.wants/unit.service to /usr/lib/systemd/system/unit.service.
$ sudo service unit start
Redirecting to /bin/systemctl start unit.service
$ sudo service unit status
Redirecting to /bin/systemctl status unit.service
● unit.service - NGINX Unit
   Loaded: loaded (/usr/lib/systemd/system/unit.service; enabled; vendor preset: disabled)
   Active: active (running)depuis mar.2019-11-05 15:42:47 UTC; 7h ago
 Main PID: 5714 (unitd)
   CGroup: /system.slice/unit.service
           ├─5714 unit: main v1.12.0 [/usr/sbin/unitd --log /var/log/unit/unit.log --pid /var/run/unit/unit.pid --no-daemon]
           ├─5716 unit: controller
           └─5717 unit: router

Vous pouvez confirmer que l'unité NGINX a démarré avec «état de l'unité de service».

Définir les paramètres de Flask

Configurez l'unité NGINX pour exécuter les applications Flask. Réglez le fichier de configuration sur «GET» à partir du socket de l'unité NGINX pour charger l'application Flask dans «NGINX Unit». Le socket Unix de contrôle de l'unité NGINX est situé à l'emplacement / var / run / unit / control.sock. (L'emplacement dépend du système d'exploitation)

$ cd /sample
$ sudo curl --unix-socket /var/run/unit/control.sock http://localhost/config/ > config.json
$ vi config.json

{
  "listeners": {
    "*:8080": {
      "pass": "applications/flask_app"
    }
  },

  "applications": {
    "flask_app": {
      "type": "python",
      "processes": 2,
      "path": "/sample/",
      "module": "app"
    }
  }
}

--listers: définissez le port. La valeur de «pass» of »*: 8080» est liée à la hiérarchie des «applications».

applications : --type: spécifiez le nom du module (langue) --process: nombre de travailleurs --path: le chemin où se trouve le programme Python --module: fichier à démarrer. Spécifié en supprimant l'extension du nom de fichier

METTEZ le fichier de réglage créé dans la prise de l'unité NGINX pour refléter le réglage.

$ sudo curl -X PUT --data-binary @config.json --unix-socket /var/run/unit/control.sock http://localhost/config
{
	"success": "Reconfiguration done."
}

Lorsque «success» revient, le réglage est terminé. Vous pouvez également vérifier les paramètres.

$ sudo curl --unix-socket /var/run/unit/control.sock http://localhost/
{
	"certificates": {},
	"config": {
		"listeners": {
			"*:8080": {
				"pass": "applications/flask_app"
			}
		},

		"applications": {
			"flask_app": {
				"type": "python",
        "processes": 2,
				"path": "/sample/",
				"module": "app"
			}
		}
	}
}

Démarrez l'environnement virtuel et accédez à http: // localhost: 8080 /.

$ source venv/bin/activate
(flask_sample)$ curl http://localhost:8080/
<html>
  <head>
    <meta charset="utf-8" />
    <title>Flask Sample</title>
  </head>
  <body>
    <h1>Flask Smaple</h1>
    <form action="sample" method="post">
      <input type="text" name="message" />
      <input type="submit" value="Envoyer" />
    </form>
  </body>
</html>

La construction est terminée lorsque ʻindex.htmlest affiché. Même si vous y accédez avec un navigateur, «index.html» s'affiche. C'est tout pour construire l'unité NGINX. Ensuite, construisez le serveur WebNGINX`.

NGINX

Il s'agit d'un serveur Web open source léger et rapide qui attire l'attention en tant qu'alternative potentielle à Apache. Comparé à Apache, il est supérieur en termes d'évolutivité et de fonctionnalités telles que les performances de traitement, le traitement parallèle et la faible utilisation de la mémoire. Cette fois, il sera utilisé comme serveur proxy.

Installez NGINX sur CentOS

NGINX publie officiellement un référentiel yum, alors installez-le à partir de ce référentiel. Ajoutez le référentiel et installez en vous référant à la description sur la page officielle.

Ajouter un référentiel

Une fois sorti de l'environnement virtuel Python. Ajoutez le référentiel yum. Ajoutez / etc / yum.repos.d / NGINX.repo.

$ sudo vi /etc/yum.repos.d/NGINX.repo
[NGINX]
name=NGINX repo
baseurl=http://NGINX.org/packages/centos/7/$basearch/
gpgcheck=0
enabled=1

Installation

Vérifiez le référentiel.

$ sudo yum info nginx
Available Packages
Name        : NGINX
Arch        : x86_64
Epoch       : 1
Version     : 1.16.1
Release     : 1.el7_4.ngx
Size        : 754 k
Repo        : NGINX/x86_64
Summary     : High performance web server
URL         : http://NGINX.org/
License     : 2-clause BSD-like license
Description : NGINX [engine x] is an HTTP and reverse proxy server, as well as
            : a mail proxy server.

Si vous pouvez confirmer que NGINX existe dans le référentiel avec la commande yum info, installez-le.

$ sudo yum install nginx

Définir le démarrage automatique, Démarrez NGINX.

$ sudo systemctl enable nginx
$ sudo service start nginx
$ ![nginx.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/239179/0d818e0a-7aee-8a07-af95-72d34dfaa824.png)
service status nginx
● NGINX.service - NGINX - high performance web server
   Loaded: loaded (/usr/lib/systemd/system/NGINX.service; enabled; vendor preset: disabled)
   Active: active (running)

Après avoir lancé NGINX, accédez à http: // IP privée de l'environnement virtuel avec votre navigateur. Si l'écran suivant s'affiche, le démarrage est terminé.

Coopération entre NGINX et NGINX Unit

Fichier de configuration NGINX

«NGINX» fonctionne comme un serveur WEB ou un serveur proxy devant «NGINX Unit». Demandes de proxy à l'application à l'unité Nginx Le fichier de configuration NGINX se trouve dans / etc / nginx / conf.d.

$ sudo vi /etc/nginx/conf.d/app.conf
upstream unit-python {
        server 127.0.0.1:8080;
}
server {
    listen 80;
    server_name localhost;

    location ~ / {
      proxy_pass http://unit-python;
      proxy_set_header Host $host;
    }
}

Redémarrez NGINX et accédez à http: // localhost /.

$ sudo service restart nginx
$ curl http://localhost/
<html>
  <head>
    <meta charset="utf-8" />
    <title>Flask Sample</title>
  </head>
  <body>
    <h1>Flask Smaple</h1>
    <form action="sample" method="post">
      <input type="text" name="message" />
      <input type="submit" value="Envoyer" />
    </form>
  </body>
</html>

Si «index.html» s'affiche, la configuration du proxy est terminée. Vous pouvez accéder à http: // IP privée de l'environnement virtuel avec un navigateur et vérifier ʻindex.html`. Ceci termine la construction de l'environnement d'application Web Python.

Résumé

Nous avons construit l'environnement de l'application WEB avec NGINX + NGINX Unit + Flask. Étant donné que «NGINX Unit» est spécialisée dans l'exploitation de micro-services, je pense qu'elle continuera à attirer l'attention à l'avenir. Je voudrais continuer à en parler.

Exécutez des applications Web Python avec NGINX + NGINX Unit + Flask

Développement d'applications Web Python avec NGINX + NGINX Unit + Flask

environnement

Remarques

Construire un environnement de développement Python

Installez Python3 sur CentOS

Créer un environnement virtuel Python

Créer un exemple de projet avec Flask

Installation du flacon

Créer une application

app.py

index.html

post.html

Installation

Définir les paramètres de Flask

Installez NGINX sur CentOS

Ajouter un référentiel

Installation

Coopération entre NGINX et NGINX Unit

Fichier de configuration NGINX

Résumé

`app.py`

`index.html`

`post.html`