TOC

Comment servir les applications Flask avec uWSGI et Nginx sur Ubuntu 16.04

introduction

Dans ce guide, nous allons configurer une application Python simple en utilisant le micro-framework Flask sur Ubuntu 16.04. La majeure partie de cet article portera sur la configuration du serveur d’applications uWSGI pour le lancement de l’application et sur Nginx pour qu’il agisse en tant que proxy inverse frontal.

Conditions préalables

Avant de commencer ce guide, vous devez avoir un utilisateur non root configuré sur votre serveur. Cet utilisateur doit disposer des privilèges sudo + pour pouvoir exécuter des tâches administratives. Pour savoir comment configurer cela, suivez notre https://www.digitalocean.com/community/tutorials/initial-server-setup-with-ubuntu-16-04 d’accueil guide de configuration du serveur initial].

Pour en savoir plus sur uWSGI, notre serveur d’applications et la spécification WSGI, vous pouvez consulter la section liée de https://www.digitalocean.com/community/tutorials/how-to-set-up-uwsgi-and-nginx-to. -serve-python-apps-on-ubuntu-14-04 # définitions-et-concepts [ce guide]. Comprendre ces concepts rendra ce guide plus facile à suivre.

Lorsque vous êtes prêt à continuer, lisez la suite.

Installer les composants à partir des référentiels Ubuntu

Notre première étape consistera à installer toutes les pièces dont nous avons besoin des référentiels. Nous allons installer + pip +, le gestionnaire de paquets Python, afin d’installer et de gérer nos composants Python. Nous aurons également les fichiers de développement Python nécessaires à la création de uWSGI et nous allons également installer Nginx.

Nous devons mettre à jour l’index de paquet local, puis installer les paquets. Les packages dont vous avez besoin varient selon que votre projet utilise Python 2 ou Python 3.

Si vous utilisez * Python 2 *, tapez:

sudo apt-get update
sudo apt-get install python-pip python-dev nginx

Si vous utilisez plutôt * Python 3 *, tapez:

sudo apt-get update
sudo apt-get install python3-pip python3-dev nginx

Créer un environnement virtuel Python

Nous allons ensuite configurer un environnement virtuel afin d’isoler notre application Flask des autres fichiers Python du système.

Commencez par installer le paquet + virtualenv en utilisant` + pip`.

Si vous utilisez * Python 2 *, tapez:

sudo pip install virtualenv

Si vous utilisez * Python 3 *, tapez:

sudo pip3 install virtualenv

Nous pouvons maintenant créer un répertoire parent pour notre projet Flask. Déplacez-vous dans le répertoire après l’avoir créé:

mkdir ~/
cd ~/

Nous pouvons créer un environnement virtuel pour stocker les exigences Python de notre projet Flask en tapant:

virtualenv

Cela installera une copie locale de Python et + pip + dans un répertoire appelé ++ dans votre répertoire de projet.

Avant d’installer des applications dans l’environnement virtuel, nous devons l’activer. Vous pouvez le faire en tapant:

source /bin/activate

Votre invite changera pour indiquer que vous travaillez maintenant dans l’environnement virtuel. Cela ressemblera à quelque chose comme ceci + () @: ~ / $ +.

Configurer une application de flacon

Maintenant que vous êtes dans votre environnement virtuel, nous pouvons installer Flask et uWSGI et commencer à concevoir notre application:

Installer Flask et uWSGI

Nous pouvons utiliser l’instance locale de + pip + pour installer Flask et uWSGI. Tapez les commandes suivantes pour obtenir ces deux composants:

Note

pip install uwsgi flask

Créer un exemple d’application

Maintenant que Flask est disponible, nous pouvons créer une application simple. Flask est un micro-cadre. Il n’inclut pas la plupart des outils que pourraient implémenter des infrastructures plus complètes, et existe principalement sous forme de module que vous pouvez importer dans vos projets pour vous aider à initialiser une application Web.

Bien que votre application soit peut-être plus complexe, nous allons créer notre application Flask dans un seul fichier, que nous appellerons + myproject.py +:

nano ~//.py

Dans ce fichier, nous placerons notre code d’application. Fondamentalement, nous devons importer Flask et instancier un objet Flask. Nous pouvons utiliser ceci pour définir les fonctions à exécuter lorsqu’un itinéraire spécifique est demandé:

~ / monprojet / monprojet.py

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
   return "<h1 style='color:blue'>Hello There!</h1>"

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

Cela définit essentiellement le contenu à présenter lors de l’accès au domaine racine. Enregistrez et fermez le fichier lorsque vous avez terminé.

Si vous avez suivi le guide de configuration initiale du serveur, vous devez activer un pare-feu UFW. Afin de tester notre application, nous devons autoriser l’accès au port 5000.

Ouvrez le port 5000 en tapant:

sudo ufw allow 5000

Maintenant, vous pouvez tester votre application Flask en tapant:

python .py

Visitez le nom de domaine ou l’adresse IP de votre serveur suivi de «+: 5000 +» dans votre navigateur Web:

http://:5000

Vous devriez voir quelque chose comme ça:

image: https: //assets.digitalocean.com/articles/nginx_uwsgi_wsgi_1404/test_app.png [Exemple d’application en flacon]

Lorsque vous avez terminé, appuyez plusieurs fois sur CTRL-C dans la fenêtre de votre terminal pour arrêter le serveur de développement Flask.

Créer le point d’entrée WSGI

Nous allons ensuite créer un fichier qui servira de point d’entrée pour notre application. Cela indiquera à notre serveur uWSGI comment interagir avec l’application.

Nous appellerons le fichier + wsgi.py +:

nano ~//wsgi.py

Le fichier est incroyablement simple, nous pouvons simplement importer l’instance Flask de notre application puis l’exécuter:

~ / myproject / wsgi.py

from myproject import app

if __name__ == "__main__":
   app.run()

Enregistrez et fermez le fichier lorsque vous avez terminé.

Configurer uWSGI

Notre application est maintenant écrite et notre point d’entrée établi. Nous pouvons maintenant passer à uWSGI.

Tester UWSGI Serving

La première chose que nous ferons est de tester pour nous assurer que uWSGI peut servir notre application.

Nous pouvons le faire en lui donnant simplement le nom de notre point d’entrée. Ceci est construit par le nom du module (moins l’extension + .py +, comme d’habitude) plus le nom de l’appelable dans l’application. Dans notre cas, ce serait + wsgi: app +.

Nous allons également spécifier le socket afin qu’il soit démarré sur une interface publique et le protocole afin qu’il utilise HTTP au lieu du protocole binaire + uwsgi +. Nous utiliserons le même numéro de port que celui que nous avons ouvert précédemment:

uwsgi --socket 0.0.0.0:5000 --protocol=http -w wsgi:app

Rendez-vous sur le nom de domaine ou l’adresse IP de votre serveur en ajoutant à nouveau la touche "+: 5000 +" à la fin de votre navigateur Web:

http://:5000

Vous devriez voir à nouveau la sortie de votre application:

image: https: //assets.digitalocean.com/articles/nginx_uwsgi_wsgi_1404/test_app.png [Exemple d’application en flacon]

Une fois que vous avez vérifié qu’il fonctionne correctement, appuyez sur CTRL-C dans la fenêtre de votre terminal.

Nous en avons terminé avec notre environnement virtuel. Nous pouvons donc le désactiver:

deactivate

Toutes les commandes Python utiliseront à nouveau l’environnement Python du système.

Création d’un fichier de configuration uWSGI

Nous avons testé la capacité de uWSGI à servir notre application, mais nous voulons quelque chose de plus robuste pour une utilisation à long terme. Nous pouvons créer un fichier de configuration uWSGI avec les options souhaitées.

Placez-le dans notre répertoire de projet et appelez-le + myproject.ini +:

nano ~//.ini

A l’intérieur, nous commencerons par l’en-tête + [uwsgi] + afin que uWSGI sache appliquer les paramètres. Nous spécifierons le module en nous référant à notre fichier + wsgi.py +, moins l’extension, et que l’appelable dans le fichier s’appelle «app»:

~ / monprojet / monprojet.ini

[uwsgi]
module = wsgi:app

Ensuite, nous dirons à uWSGI de démarrer en mode maître et d’engendrer cinq processus de travail pour répondre aux demandes réelles:

~ / monprojet / monprojet.ini

[uwsgi]
module = wsgi:app

master = true
processes = 5

Lors des tests, nous avons exposé uWSGI sur un port réseau. Cependant, nous allons utiliser Nginx pour gérer les connexions client réelles, qui transmettront ensuite les demandes à uWSGI. Étant donné que ces composants fonctionnent sur le même ordinateur, une prise Unix est préférable car elle est plus sécurisée et plus rapide. Nous allons appeler le socket + myproject.sock + et le placer dans ce répertoire.

Nous devrons également modifier les autorisations sur le socket. Nous attribuerons ultérieurement au groupe Nginx la propriété du processus uWSGI. Nous devons donc nous assurer que le propriétaire du groupe du socket peut lire les informations et écrire. Nous allons également nettoyer le socket lorsque le processus s’arrête en ajoutant l’option «vacuum»:

~ / monprojet / monprojet.ini

[uwsgi]
module = wsgi:app

master = true
processes = 5

socket = .sock
chmod-socket = 660
vacuum = true

La dernière chose à faire est de définir l’option `+ die-on-term + '. Cela peut aider à garantir que le système init et uWSGI ont les mêmes hypothèses sur la signification de chaque signal de processus. Ce paramètre aligne les deux composants du système et implémente le comportement attendu:

~ / monprojet / monprojet.ini

[uwsgi]
module = wsgi:app

master = true
processes = 5

socket = .sock
chmod-socket = 660
vacuum = true

die-on-term = true

Vous avez peut-être remarqué que nous n’avions pas spécifié de protocole, contrairement à la ligne de commande. En effet, par défaut, uWSGI utilise le protocole + uwsgi +, un protocole binaire rapide conçu pour communiquer avec les autres serveurs. Nginx peut parler ce protocole de manière native, il est donc préférable de l’utiliser plutôt que de forcer la communication par HTTP.

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Créer un fichier unité systemd

Le fichier suivant de l’unité de service systemd est le suivant. La création d’un fichier unité systemd permettra au système init d’Ubuntu de démarrer automatiquement uWSGI et de servir notre application Flask à chaque démarrage du serveur.

Créez un fichier unité se terminant par .service dans le répertoire / etc / systemd / system pour commencer:

sudo nano /etc/systemd/system/.service

A l’intérieur, nous commencerons par la section + [Unit] +, utilisée pour spécifier les métadonnées et les dépendances. Nous allons mettre une description de notre service ici et dire au système init de ne le démarrer que lorsque la cible réseau aura été atteinte:

/etc/systemd/system/myproject.service

[Unit]
Description=uWSGI instance to serve
After=network.target

Ensuite, nous ouvrirons la section + [Service] +. Nous spécifierons l’utilisateur et le groupe sous lesquels le processus doit s’exécuter. Nous allons donner à notre compte utilisateur habituel la propriété du processus puisqu’il possède tous les fichiers pertinents. Nous allons donner la propriété du groupe + www-data afin que Nginx puisse communiquer facilement avec les processus uWSGI.

Nous allons ensuite mapper le répertoire de travail et définir la variable d’environnement + PATH + afin que le système init sache où se trouvent les exécutables du processus (dans notre environnement virtuel). Nous allons ensuite spécifier le commandé pour démarrer le service. Systemd nécessite que nous donnions le chemin complet à l’exécutable uWSGI, qui est installé dans notre environnement virtuel. Nous allons passer le nom du fichier de configuration .ini que nous avons créé dans le répertoire de notre projet:

/etc/systemd/system/myproject.service

[Unit]
Description=uWSGI instance to serve
After=network.target

[Service]
User=
Group=www-data
WorkingDirectory=/home//
Environment="PATH=/home////bin"
ExecStart=/home////bin/uwsgi --ini .ini

Enfin, nous ajouterons une section + [Install] +. Cela indiquera à systemd à quoi lier ce service si nous lui permettons de démarrer au démarrage. Nous voulons que ce service démarre lorsque le système multi-utilisateurs normal est opérationnel:

/etc/systemd/system/myproject.service

[Unit]
Description=uWSGI instance to serve
After=network.target

[Service]
User=
Group=www-data
WorkingDirectory=/home//
Environment="PATH=/home////bin"
ExecStart=/home////bin/uwsgi --ini .ini

[Install]
WantedBy=multi-user.target

Avec cela, notre fichier de service systemd est complet. Enregistrez et fermez-le maintenant.

Nous pouvons maintenant démarrer le service uWSGI que nous avons créé et l’activer pour qu’il démarre au démarrage:

sudo systemctl start
sudo systemctl enable

Configuration de Nginx en requêtes proxy

Notre serveur d’applications uWSGI devrait maintenant être opérationnel et attendre les demandes sur le fichier de socket dans le répertoire du projet. Nous devons configurer Nginx pour transmettre les requêtes Web à cette socket en utilisant le protocole + uwsgi +.

Commencez par créer un nouveau fichier de configuration de bloc de serveur dans le répertoire + sites-available + de Nginx. Nous appellerons simplement ceci + myproject + pour rester en ligne avec le reste du guide:

sudo nano /etc/nginx/sites-available/

Ouvrez un bloc serveur et dites à Nginx d’écouter sur le port 80 par défaut. Nous devons également lui indiquer d’utiliser ce bloc pour les demandes de nom de domaine ou d’adresse IP de notre serveur:

/ etc / nginx / sites-available / myproject

server {
   listen 80;
   server_name ;
}

La seule autre chose que nous devons ajouter est un bloc d’emplacement qui correspond à chaque demande. Dans ce bloc, nous inclurons le fichier + uwsgi_params + qui spécifie certains paramètres uWSGI généraux à définir. Nous transmettrons ensuite les requêtes au socket que nous avons défini en utilisant la directive + uwsgi_pass +:

/ etc / nginx / sites-available / myproject

server {
   listen 80;
   server_name ;

   location / {
       include uwsgi_params;
       uwsgi_pass unix:/home///.sock;
   }
}

C’est tout ce dont nous avons besoin pour servir notre application. Enregistrez et fermez le fichier lorsque vous avez terminé.

Pour activer la configuration de bloc de serveur Nginx que nous venons de créer, liez le fichier au répertoire + sites-enabled +:

sudo ln -s /etc/nginx/sites-available/ /etc/nginx/sites-enabled

Avec le fichier dans ce répertoire, nous pouvons tester les erreurs de syntaxe en tapant:

sudo nginx -t

Si cela retourne sans indiquer de problème, nous pouvons redémarrer le processus Nginx pour lire notre nouvelle configuration:

sudo systemctl restart nginx

La dernière chose à faire est de réajuster notre pare-feu. Nous n’avons plus besoin d’accès via le port 5000, nous pouvons donc supprimer cette règle. Nous pouvons ensuite autoriser l’accès au serveur Nginx:

sudo ufw delete allow 5000
sudo ufw allow 'Nginx Full'

Vous devriez maintenant pouvoir accéder au nom de domaine ou à l’adresse IP de votre serveur dans votre navigateur Web:

http://

Vous devriez voir la sortie de votre application:

image: https: //assets.digitalocean.com/articles/nginx_uwsgi_wsgi_1404/test_app.png [Exemple d’application en flacon]

Note

Conclusion

Dans ce guide, nous avons créé une application Flask simple dans un environnement virtuel Python. Nous créons un point d’entrée WSGI de sorte que tout serveur d’application compatible WSGI puisse s’interfacer avec ce dernier, puis avons configuré le serveur d’applications uWSGI pour fournir cette fonction. Nous avons ensuite créé un fichier de service systemd pour lancer automatiquement le serveur d’applications au démarrage. Nous avons créé un bloc de serveur Nginx qui transmet le trafic du client Web au serveur d’applications, en relayant les demandes externes.

Flask est un framework très simple, mais extrêmement flexible, destiné à fournir des fonctionnalités à vos applications sans être trop restrictif en termes de structure et de conception. Vous pouvez utiliser la pile générale décrite dans ce guide pour servir les applications de flacon que vous concevez.

Related