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

introduction

Dans ce guide, nous allons configurer une application Python simple à l’aide du micro-framework Flask sur Ubuntu 14.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 initial initial guide de configuration du serveur.

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.

Mettez à jour votre index de package local, puis installez les packages en tapant:

sudo apt-get update
sudo apt-get install python-pip python-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`:

sudo pip 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:

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 un flacon et instancier un objet Flask. Nous pouvons utiliser cela pour définir les fonctions à exécuter lorsqu’un itinéraire spécifique est demandé. Nous appellerons notre application Flask dans le code + application + pour répliquer les exemples que vous avez trouvés dans la spécification WSGI:

from flask import Flask
application = Flask(__name__)

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

if __name__ == "__main__":
   application.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é.

Vous pouvez tester votre application Flask en tapant:

python .py

Accédez au nom de domaine ou à l’adresse IP de votre serveur, suivi du numéro de port spécifié dans la sortie du terminal (vraisemblablement +: 5000 +) dans votre navigateur Web. 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:

from  import application

if __name__ == "__main__":
   application.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. 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 +:

uwsgi --socket 0.0.0.0:8000 --protocol=http -w wsgi

Si vous visitez le nom de domaine ou l’adresse IP de votre serveur avec «+: 8000 +» ajouté à la fin de votre navigateur Web, vous devriez voir une page qui ressemble à ceci:

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 opérations maintenant seront effectuées sur 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 +, sans l’extension:

[uwsgi]
module = wsgi

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:

[uwsgi]
module = wsgi

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»:

[uwsgi]
module = wsgi

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 est nécessaire car le système Upstart init et uWSGI ont des idées différentes sur la signification des différents signaux de processus. Ce paramètre aligne les deux composants du système et implémente le comportement attendu:

[uwsgi]
module = wsgi

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 script de démarrage

Le prochain élément à prendre en compte est le script Upstart. La création d’un script Upstart 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 script se terminant par + .conf + dans le répertoire + / etc / init + pour commencer:

sudo nano /etc/init/.conf

À l’intérieur, nous commencerons par une description simple du but du script. Immédiatement après, nous définirons les conditions dans lesquelles ce script sera lancé et arrêté par le système. Les numéros d’exécution système normaux sont 2, 3, 4 et 5; nous lui indiquerons donc de lancer notre script lorsque le système atteint l’un de ces niveaux d’exécution. Nous lui dirons de s’arrêter à n’importe quel autre niveau d’exécution (par exemple, lorsque le serveur redémarre, s’arrête ou en mode mono-utilisateur):

description "uWSGI server instance configured to serve "

start on runlevel [2345]
stop on runlevel [!2345]

Ensuite, nous devons définir l’utilisateur et le groupe sous lesquels uWSGI doit être exécuté. Nos fichiers de projet sont tous la propriété de notre propre compte utilisateur. Nous nous définirons donc comme l’utilisateur à exécuter. Le serveur Nginx s’exécute sous le groupe + www-data. Nginx doit être capable de lire et d’écrire dans le fichier de socket, nous allons donc donner à ce groupe le contrôle du processus:

description "uWSGI server instance configured to serve "

start on runlevel [2345]
stop on runlevel [!2345]

setuid
setgid www-data

Ensuite, nous devons configurer le processus afin qu’il puisse correctement trouver nos fichiers et les traiter. Nous avons installé tous nos composants Python dans un environnement virtuel. Nous devons donc définir une variable d’environnement avec ce chemin comme chemin. Nous devons également passer à notre répertoire de projet. Ensuite, nous pouvons simplement appeler l’exécutable uWSGI et lui transmettre le fichier de configuration que nous avons écrit:

description "uWSGI server instance configured to serve "

start on runlevel [2345]
stop on runlevel [!2345]

setuid
setgid www-data

env PATH=/home////bin
chdir /home//
exec uwsgi --ini .ini

Enregistrez et fermez le fichier lorsque vous avez terminé.

Vous pouvez commencer le processus immédiatement en tapant:

sudo start

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:

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 +:

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 service nginx restart

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

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

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 script Upstart 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