TOC

Comment servir les applications Flask avec Gunicorn 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 traitera de la configuration du serveur d’applications Gunicorn pour le lancement de l’application et de 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ègessudo pour pouvoir effectuer des fonctions administratives. Pour savoir comment configurer cela, suivez nosinitial server setup guide.

Pour en savoir plus sur la spécification WSGI que notre serveur d'application utilisera pour communiquer avec notre application Flask, vous pouvez lire la section liée dethis 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 installeronspip, 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 certains composants de Gunicorn. 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 packagevirtualenv en utilisantpip: 

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 ~/myproject
cd ~/myproject

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

virtualenv myprojectenv

Cela installera une copie locale de Python et depip dans un répertoire appelémyprojectenv dans le répertoire de votre projet.

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

source myprojectenv/bin/activate

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

Configurer une application de flacon

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

Installez Flask et Gunicorn

Nous pouvons utiliser l'instance locale depip pour installer Flask et Gunicorn. Tapez les commandes suivantes pour obtenir ces deux composants: 

pip install gunicorn 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 plus complexe, nous créerons notre application Flask dans un seul fichier, que nous appelleronsmyproject.py: 

nano ~/myproject/myproject.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 codeapplication pour reproduire les exemples que vous trouverez dans la spécification WSGI: 

from flask import Flask
application = Flask(__name__)

@application.route("/")
def hello():
    return "
Hello There!
"

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 myproject.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 (très probablement:5000) dans votre navigateur Web. Vous devriez voir quelque chose comme ça:

Flask sample app

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 Gunicorn comment interagir avec l'application.

Nous appellerons le fichierwsgi.py: 

nano ~/myproject/wsgi.py

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

from myproject import application

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

Enregistrez et fermez le fichier lorsque vous avez terminé.

Tester la capacité de Gunicorn à servir le projet

Avant de continuer, nous devrions vérifier que Gunicorn peut correctement.

Nous pouvons le faire en lui donnant simplement le nom de notre point d’entrée. Nous spécifierons également l’interface et le port auxquels vous souhaitez vous connecter afin qu’elle soit lancée sur une interface accessible au public: 

cd ~/myproject
gunicorn --bind 0.0.0.0:8000 wsgi

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

Flask sample app

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é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 Gunicorn et de servir notre application Flask à chaque démarrage du serveur.

Créez un fichier de script se terminant par.conf dans le répertoire/etc/init pour commencer: 

sudo nano /etc/init/myproject.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 "Gunicorn application server running myproject"

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

Nous dirons au système init qu'il doit redémarrer le processus s'il échoue un jour. Ensuite, nous devons définir l’utilisateur et le groupe sous lesquels Gunicorn 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 groupewww-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 "Gunicorn application server running myproject"

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

respawn
setuid user
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’application Gunicorn avec les options que nous souhaitons utiliser.

Nous lui dirons de démarrer 3 processus de travail (ajustez-le si nécessaire). Nous lui dirons également de créer et de se lier à un fichier socket Unix dans notre répertoire de projet appelémyproject.sock. Nous allons définir une valeur umask de007 afin que le fichier socket soit créé, donnant accès au propriétaire et au groupe, tout en restreignant les autres accès. Enfin, nous devons passer le nom du fichier de point d’entrée WSGI: 

description "Gunicorn application server running myproject"

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

respawn
setuid user
setgid www-data

env PATH=/home/user/myproject/myprojectenv/bin
chdir /home/user/myproject
exec gunicorn --workers 3 --bind unix:myproject.sock -m 007 wsgi

Enregistrez et fermez le fichier lorsque vous avez terminé.

Vous pouvez commencer le processus immédiatement en tapant: 

sudo start myproject

Configuration de Nginx en requêtes proxy

Notre serveur d’applications Gunicorn 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 à ce socket en apportant de petits ajouts à son fichier de configuration.

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

sudo nano /etc/nginx/sites-available/myproject

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 server_domain_or_IP;
}

La seule autre chose que nous devons ajouter est un bloc d’emplacement qui correspond à chaque demande. Dans ce bloc, nous inclurons le fichierproxy_params qui spécifie certains paramètres généraux de proxy qui doivent être définis. Nous passerons ensuite les requêtes au socket que nous avons défini à l'aide de la directiveproxy_pass: 

server {
    listen 80;
    server_name server_domain_or_IP;

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/user/myproject/myproject.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épertoiresites-enabled: 

sudo ln -s /etc/nginx/sites-available/myproject /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:

Flask sample app

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 Gunicorn 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 requêtes 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