TOC

Comment déployer des applications Web Falcon avec Gunicorn et Nginx sur Ubuntu 16.04

introduction

Falcon est un framework Python minimal pour la construction d’applications Web. Il convient parfaitement à la construction d’API respectant le style architectural REST. C’est un framework de bas niveau et de haute performance qui essaie de faire le moins possible sans sacrifier la vitesse de développement.

Dans ce didacticiel, vous allez créer et déployer une application Web Falcon. Falcon est un framework WSGI, vous allez donc installer et utiliser Gunicorn, un serveur d’applications WSGI, pour servir l’application. . Vous créerez ensuite un environnement prêt à la production en utilisant Nginx en tant que serveur proxy inverse pour traiter les demandes entrantes avant qu’elles ne parviennent à Gunicorn.

Conditions préalables

Pour compléter ce tutoriel, vous aurez besoin de:

Étape 1 - Création de l’environnement virtuel Python

Avant de nous lancer dans l’écriture de code ou la configuration de services, nous allons créer un environnement virtuel Python pour notre application sur le serveur.

Connectez-vous à votre serveur en tant qu’utilisateur non root:

ssh @

Falcon fonctionne avec Python 2.x et Python 3.x mais nous allons utiliser la dernière version de Python disponible dans Ubuntu 16.04, qui est Python 3.5.

Nous allons utiliser pip et virtualenv pour configurer notre application Falcon. Pour en savoir plus sur ces outils, consultez notre tutoriel à l’adresse common Outils Python .

Tout d’abord, installez virtualenv:

sudo apt-get install virtualenv

Créez ensuite un répertoire qui contiendra le code source de votre application et l’environnement virtuel, puis accédez à ce répertoire:

mkdir
cd

Ensuite, créez l’environnement virtuel:

virtualenv venv -p /usr/bin/python3

Cette commande crée un environnement virtuel dans le répertoire + venv +. L’indicateur + -p + spécifie quelle version de Python est utilisée dans l’environnement virtuel.

Vous verrez cette sortie:

OutputAlready using interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in /home/sammy/falcon_app/venv/bin/python3
Also creating executable in /home/sammy/falcon_app/venv/bin/python
Installing setuptools, pkg_resources, pip, wheel...done.

Activez maintenant l’environnement virtuel:

. venv/bin/activate

Maintenant que vous avez configuré votre environnement virtuel Python, installons les packages Python requis.

Étape 2 - Installation de Falcon et Gunicorn avec pip

Nous devons installer le package + falcon +, et comme nous utilisons Gunicorn pour servir notre application, nous devons également l’installer. Les deux sont disponibles via + pip +,

Vous pouvez installer Falcon de deux manières. Falcon a un fichier binaire que vous pouvez installer avec + pip install falcon +, mais Falcon peut obtenir un gain de vitesse supplémentaire lorsqu’il est compilé avec Cython. Exécutez les commandes suivantes pour installer Cython, puis demandez à Falcon de le détecter et de se compiler à l’aide du compilateur C du système:

sudo apt-get install build-essential python3-dev
pip install cython
pip install --no-binary :all: falcon

Ensuite, installez Gunicorn:

pip install gunicorn

Passons maintenant à l’écriture de notre simple application Falcon.

Étape 3 - Écriture d’une application Web simple à l’aide de Falcon

Créons une simple application Falcon à fichier unique. Créez le fichier + main.py + dans le répertoire + falcon_app +:

nano main.py

Remplissez le fichier avec le contenu suivant, ce qui crée une application Falcon qui affiche un simple message de test lorsque les utilisateurs visitent la route + / test +:

main.py

import falcon

class TestResource(object):
   def on_get(self, req, res):
       """Handles all GET requests."""
       res.status = falcon.HTTP_200  # This is the default status
       res.body = ('This is me, Falcon, serving a resource!')

# Create the Falcon application object
app = falcon.API()

# Instantiate the TestResource class
test_resource = TestResource()

# Add a route to serve the resource
app.add_route('/test', test_resource)

Dans ce fichier, nous créons une classe appelée + TestResource +. Cette classe contient une méthode + on_get + qui définit la réponse que nous voulons envoyer. Ensuite, nous créons des instances de l’API Falcon et + TestResource +. Ensuite, nous ajoutons la route + / test + à l’API et y attachons l’objet ressource + test_resource +.

Chaque fois qu’une requête + GET + est envoyée à l’URL + / test +, la méthode + on_get () + de + TestResource + est invoquée. Le statut et le corps de la réponse sont définis à l’aide des variables + res.status + et + res.body +.

Enregistrez le fichier et fermez votre éditeur. Testons l’application.

Étape 4 - Servir une application Falcon avec Gunicorn

Avant de commencer à préparer notre application pour la production en utilisant Nginx, assurons-nous que notre application fonctionne en la servant avec Gunicorn.

Assurez-vous que vous vous trouvez dans le répertoire + falcon_app +. Démarrez Gunicorn avec la commande suivante:

gunicorn -b :5000 main:app --reload

Cela démarre Gunicorn et sert notre application Web à «+` sur le port ` 5000 +`, comme vous pouvez le voir à la sortie:

Output[2016-11-14 16:33:41 +0000] [9428] [INFO] Starting gunicorn 19.6.0
[2016-11-14 16:33:41 +0000] [9428] [INFO] Listening at:  (9428)
[2016-11-14 16:33:41 +0000] [9428] [INFO] Using worker: sync
[2016-11-14 16:33:41 +0000] [9431] [INFO] Booting worker with pid: 9431

Vous pouvez utiliser n’importe quel numéro de port de votre choix, mais assurez-vous qu’il est supérieur à «+ 1024 +» et qu’il n’est utilisé par aucun autre programme.

L’option + main: app + indique à Gunicorn d’appeler l’objet d’application + app + disponible dans le fichier + main.py +.

Gunicorn fournit un commutateur optionnel + - reload + qui indique à Gunicorn de détecter tout changement de code à la volée. De cette façon, vous pouvez changer votre code sans avoir à redémarrer Gunicorn.

Testez votre application en ouvrant votre navigateur Web sur votre ordinateur local et en visitant + http: //: 5000 / test + dans votre navigateur. Vous verrez les résultats suivants à partir de votre application Web:

image: https: //assets.digitalocean.com/articles/falcon_gunicorn_nginx_1604/drw9BfS.png [réponse de Falcon]

Arrêtez Gunicorn en appuyant sur + CTRL + C +. Mettons cela en ordre de marche pour la production.

Étape 5 - Utilisation de Nginx pour les demandes de proxy auprès de Gunicorn

Nous allons configurer et configurer Nginx pour qu’il envoie toutes les demandes Web à Gunicorn au lieu de laisser Gunicorn répondre directement aux demandes du monde extérieur. Ainsi, toutes les demandes de votre application Web sont d’abord rencontrées par Nginx, puis acheminées vers le serveur d’applications.

Commencez par installer Nginx en exécutant la commande suivante:

sudo apt-get install nginx

Ensuite, créez un nouveau fichier de configuration appelé + falcon_app.conf + dans le répertoire + / etc / nginx / sites-available +. Ce fichier configurera Nginx pour envoyer par proxy toutes les demandes arrivant à l’adresse IP de votre serveur sur le serveur Gunicorn de notre application Falcon.

sudo nano /etc/nginx/sites-available/falcon_app.conf

Ajoutez le contenu suivant au fichier:

/etc/nginx/sites-available/falcon_app.conf

server {
   listen 80;
   server_name ;

   location / {
       include proxy_params;
       proxy_pass http://localhost:5000;
   }
}

Cette configuration demande à Nginx d’écouter sur le port + 80 + et de mettre en proxy toutes les requêtes HTTP envoyées à + ​​http: // localhost: 5000 +, où Gunicorn écoutera.

Activez cette configuration en créant un lien symbolique vers ce fichier dans le répertoire + / etc / nginx / sites-enabled +:

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

Désactivez ensuite le fichier de configuration Nginx par défaut en supprimant son lien symbolique dans le répertoire + / etc / nginx / sites-enabled +:

sudo rm /etc/nginx/sites-enabled/default

Assurez-vous qu’il n’y a pas d’erreur de syntaxe dans vos fichiers Nginx:

sudo nginx -t

Vous verrez ce message si votre configuration est opérationnelle:

Outputnginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Si vous voyez des erreurs, corrigez-les et testez à nouveau.

Redémarrez Nginx pour que la nouvelle configuration prenne effet.

sudo systemctl restart nginx

Maintenant, redémarrez Gunicorn, mais changez l’adresse d’écoute de + 0.0.0.0 + en + + localhost + pour empêcher le public d’accéder à Gunicorn:

gunicorn -b  main:app --reload

Autorisez l’accès au port + 80 + via le pare-feu du serveur si vous l’avez activé:

sudo ufw allow 80

Enfin, testez l’application en visitant + http: /// test + et vous verrez la même sortie que celle que vous avez vue auparavant.

Notez que vous n’avez plus besoin du numéro de port dans l’URL, car vos demandes passent maintenant par Nginx, qui s’exécute sur le port + 80 +, le port HTTP par défaut. Vous verrez la sortie suivante dans votre navigateur:

image: https: //assets.digitalocean.com/articles/falcon_gunicorn_nginx_1604/6pKlicT.png [Le Falcon est maintenant mandaté par l’intermédiaire de Nginx]

Arrêtez le serveur d’applications en appuyant sur les touches + CTRL + C +. Configurons notre application Falcon pour qu’elle démarre automatiquement en arrière-plan, à l’instar de nos autres services.

Étape 7 - Gérer Gunicorn avec Systemd

Nous devons nous assurer que notre application démarre automatiquement à chaque démarrage du serveur, exactement comme Nginx. Si notre serveur a été redémarré par inadvertance ou a dû être redémarré pour une raison quelconque, nous ne devrions pas avoir à démarrer Gunicorn manuellement.

Pour configurer cela, nous allons créer un fichier système_systemd pour notre application Gunicorn afin de pouvoir le gérer.

Pour commencer, nous créons un fichier pour notre application dans le répertoire + / etc / systemd / system avec une extension` + .service`:

sudo nano /etc/systemd/system/

Un fichier d’unité est composé de sections. La section + [Unit] + est utilisée pour spécifier les métadonnées et les dépendances de notre service, y compris une description de notre service et le début de notre service.

Ajoutez cette configuration au fichier:

/etc/systemd/system/falcon_app.service

[Unit]
Description=Gunicorn instance to serve the falcon application
After=network.target

Nous spécifions que le service doit démarrer après la cible réseau a été atteinte. En d’autres termes, nous ne démarrons ce service que lorsque les services de réseau sont prêts.

Après la section + [Unit] +, nous définissons la section + [Service] + où nous spécifions comment démarrer le service. Ajoutez ceci au fichier de configuration:

/etc/systemd/system/falcon_app.service

[Service]
User=
Group=
PIDFile=
Environment="PATH=/home/sammy//venv/bin"
WorkingDirectory=/home/sammy/
ExecStart=/home///venv/bin/gunicorn --workers 3 -b
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID

Nous définissons d’abord l’utilisateur et le groupe sous lesquels le service est exécuté. Ensuite, nous définissons un fichier pour stocker le PID (ID de processus) du service; Ce PID est utilisé pour arrêter ou recharger le service.

Nous spécifions également l’environnement virtuel Python, le répertoire de travail de l’application. et la commande à exécuter pour démarrer l’application. Nous assignons la commande pour démarrer Gunicorn à la variable + ExecStart +. Le drapeau + - workers + est utilisé pour définir le nombre de travailleurs avec lesquels Gunicorn doit commencer. La documentation Gunicorn vous suggère de définir le nombre de travailleurs sur «+ 2n + 1 », où « n » représente le nombre de cœurs de processeur. En supposant que votre serveur ne possède qu'un seul cœur de processeur, nous arrivons au nombre ` 3 +`.

Les variables + ExecReload + et + ExecStop + définissent le mode de démarrage et d’arrêt du service.

Enfin, nous ajoutons la section + [Install] +, qui ressemble à ceci:

/etc/systemd/system/falcon_app.service

[Install]
WantedBy=multi-user.target

La section + Install + vous permet d’activer et de désactiver le service. La directive + WantedBy + crée un répertoire nommé + multi -user.target + dans + / etc / systemd / system + et un lien symbolique de ce fichier y sera créé. La désactivation de ce service supprimera ce fichier du répertoire.

Enregistrez le fichier, fermez l’éditeur et démarrez le nouveau service:

sudo systemctl start

Activez ensuite ce service afin que chaque fois que le serveur démarre, Gunicorn commence à servir l’application Web:

sudo systemctl enable

Encore une fois, pointez votre navigateur sur + http: /// test pour voir votre application. Nginx et Gunicorn fonctionnent en arrière-plan. Si vous devez mettre à jour votre application Falcon, redémarrez le service + falcon_app +:

sudo systemctl restart

Pour en savoir plus sur les fichiers d’unité, lisez le didacticiel Comprendre les unités et les fichiers d’unités.

Conclusion

Dans ce guide, vous avez configuré et déployé votre première application Web Falcon. Vous avez configuré l’environnement Python et écrit le code de votre application sur le serveur, puis servi l’application Web avec Gunicorn. Ensuite, vous avez configuré Nginx pour qu’il passe les requêtes Web à notre application Gunicorn. Enfin, vous avez écrit un fichier Systemd Unit et activé le service afin que votre application Web démarre au démarrage du serveur.

Lorsque vous mettez vos propres applications en production, vous souhaiterez y accéder avec un nom d’hôte au lieu de l’adresse IP. Consultez la page Comment définir un nom d’hôte avec DigitalOcean pour pointer votre domaine nom sur votre serveur.

Related