Flask est un framework très simple mais extrêmement flexible destiné à fournir à vos applications des fonctionnalités sans être trop restrictif sur la structure et la conception. Vous pouvez utiliser la pile générale décrite dans cet article pour servir les applications flask que vous concevez.
Dans cet article, nous allons configurer une application Python simple à l'aide du micro-framework Flask sur Ubuntu 18.04.
La majeure partie de cet article portera sur la configuration du serveur d'applications Gunicorn pour lancer l'application et Nginx pour agir en tant que proxy inverse frontal.
Prérequis
Avant de commencer cet article, vous devez avoir configuré un utilisateur non root sur votre serveur. Cet utilisateur doit disposer des privilèges sudo pour pouvoir exécuter des fonctions administratives.
Créez un utilisateur non root avec les privilèges sudo configurés :
1- Connexion en tant que root
2- Créer un nouvel utilisateur
# adduser bobby3- Octroi de privilèges administratifs
Pour ajouter ces privilèges à notre nouvel utilisateur, nous devons ajouter le nouvel utilisateur au groupe sudo. Par défaut, sur Ubuntu 18.04, les utilisateurs appartenant au groupe sudo sont autorisés à utiliser la commande sudo.
# usermod -aG sudo bobbyInstallez les composants à partir des dépôts Ubuntu
La première étape consistera à installer toutes les pièces dont nous avons besoin à partir des référentiels. Nous allons installer pip, le gestionnaire de packages Python 3, afin d'installer et de gérer nos composants Python 3. Nous obtiendrons également les fichiers de développement Python 3 nécessaires pour construire certains des composants Gunicorn. Nous allons également installer Nginx maintenant.
Mettez à jour votre index de package local, puis installez les packages. Les packages spécifiques dont vous avez besoin dépendront de la version de Python que vous utilisez pour votre projet.
Lors de l'installation de Python 3, saisissez :
$ sudo apt-get update
$ sudo apt-get install python3-pip python3-dev nginxCréer un environnement virtuel Python 3
Ensuite, nous allons configurer un environnement virtuel afin d'isoler notre application Flask des autres fichiers Python du système.
Commencez par installer le package virtualenv à l'aide de pip.
Si vous utilisez Python 3, saisissez :
sudo pip3 install virtualenvMaintenant, nous pouvons créer un répertoire parent pour notre projet Flask. Accédez au répertoire après l'avoir créé :
mkdir ~/flaskproject
cd ~/flaskprojectNous pouvons créer un environnement virtuel pour stocker les exigences Python de notre projet Flask en tapant :
virtualenv flaskprojectenv
Cela installera une copie locale de Python et pip dans un répertoire appelé flaskprojectenv 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 flaskprojectenv/bin/activate
Votre invite changera pour indiquer que vous travaillez maintenant dans l'environnement virtuel. Cela ressemblera à quelque chose comme ceci (flaskprojectenv)user@host:~/flaskproject$ .
Configurer une application Flask
Maintenant que vous êtes dans votre environnement virtuel, nous pouvons installer Flask et Gunicorn et commencer à concevoir notre application :
Installer Flask et Gunicorn
Nous pouvons utiliser l'instance locale de pip pour installer Flask et Gunicorn. Tapez les commandes suivantes pour obtenir ces deux composants :
Remarque : Quelle que soit la version de Python que vous utilisez, lorsque l'environnement virtuel est activé, vous devez utiliser le pip commande (pas pip3 ).
(flaskprojectenv) $ pip install gunicorn flaskCréer un exemple d'application
Maintenant que Flask est disponible, nous pouvons créer une application simple. Flask est un micro-framework. Il n'inclut pas de nombreux outils que des frameworks plus complets pourraient avoir et existe principalement sous la forme d'un module que vous pouvez importer dans vos projets pour vous aider à initialiser une application Web.
Bien que votre application puisse être plus complexe, nous créerons notre application Flask dans un seul fichier, que nous appellerons flaskproject.py :
(flaskprojectenv) $ nano ~/flaskproject/flaskproject.pyDans ce fichier, nous placerons notre code d'application. Fondamentalement, nous devons importer un flacon et instancier un objet Flask. Nous pouvons l'utiliser pour définir les fonctions qui doivent être exécutées lorsqu'une route spécifique est demandée :
~/flaskproject/flaskproject.py
from flask import Flask
app = Flask(__name__)
@app.route("/")
def greeting():
return "<h1 style='color:green'>Hello World!</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 devriez avoir un pare-feu UFW activé. Afin de tester notre application, nous devons autoriser l'accès au port 5000.
Ouvrez le port 5000 en tapant :
(flaskprojectenv) $ sudo ufw allow 5000Maintenant, vous pouvez tester votre application Flask en tapant :
(flaskprojectenv) $ python flaskproject.py
Visitez le nom de domaine ou l'adresse IP de votre serveur suivi de :5000 dans votre navigateur Web :
http://server_domain_or_IP:5000
Vous devriez voir quelque chose comme ceci :
Lorsque vous avez terminé, appuyez sur CTRL-C dans la fenêtre de votre terminal plusieurs fois pour arrêter le serveur de développement Flask.
Créer le point d'entrée WSGI
Ensuite, nous allons 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 fichier wsgi.py :
(flaskprojectenv) $ nano ~/flaskproject/wsgi.pyLe fichier est incroyablement simple, nous pouvons simplement importer l'instance Flask depuis notre application, puis l'exécuter :
~/flaskproject/wsgi.py
from flaskproject import app
if __name__ == "__main__":
app.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 passant simplement le nom de notre point d'entrée. Ceci est construit par le nom du module (moins le .py extension, comme d'habitude) plus le nom de l'appelable dans l'application. Dans notre cas, ce serait wsgi:app .
Nous spécifierons également l'interface et le port auxquels se connecter afin qu'il soit démarré sur une interface accessible au public :
(flaskprojectenv) $ cd ~/flaskproject
(flaskprojectenv) $ gunicorn --bind 0.0.0.0:5000 wsgi:appVisitez à nouveau le nom de domaine ou l'adresse IP de votre serveur avec :5000 ajouté à la fin dans votre navigateur Web :
http://server_domain_or_IP:5000
Vous devriez voir à nouveau la sortie de votre application :
Lorsque vous avez confirmé qu'il fonctionne correctement, appuyez sur CTRL-C dans la fenêtre de votre terminal.
Nous en avons maintenant terminé avec notre environnement virtuel, nous pouvons donc le désactiver :
(flaskprojectenv) $ deactivateToutes les commandes Python utiliseront à nouveau l'environnement Python du système.
Créer un fichier d'unité systemd
La prochaine pièce dont nous devons nous occuper est le fichier d'unité de service systemd. La création d'un fichier d'unité systemd permettra au système d'initialisation d'Ubuntu de démarrer automatiquement Gunicorn et de servir notre application Flask à chaque démarrage du serveur.
Créez un fichier unité se terminant par .service dans le /etc/systemd/system répertoire pour commencer :
$ sudo nano /etc/systemd/system/flaskproject.service
À l'intérieur, nous commencerons par le [Unit] section, qui est utilisée pour spécifier les métadonnées et les dépendances. Nous mettrons une description de notre service ici et indiquerons le init système pour ne le démarrer qu'une fois l'objectif de mise en réseau atteint
Ensuite, nous allons ouvrir le [Service] section. Nous allons spécifier l'utilisateur et le groupe sous lesquels nous voulons que le processus s'exécute. Nous donnerons à notre compte d'utilisateur habituel la propriété du processus puisqu'il possède tous les fichiers pertinents. Nous donnerons la propriété de groupe aux www-data groupe afin que Nginx puisse communiquer facilement avec les processus Gunicorn.
Nous allons ensuite mapper le répertoire de travail et définir la variable d'environnement PATH afin que le init système sait où se trouvent nos exécutables pour le processus (dans notre environnement virtuel). Nous spécifierons ensuite la commande pour démarrer le service. Systemd exige que nous donnions le chemin complet à l'exécutable Gunicorn, qui est installé dans notre environnement virtuel.
Nous lui dirons de démarrer 3 processus de travail (ajustez cela si nécessaire). Nous lui dirons également de créer et de se lier à un fichier de socket Unix dans notre répertoire de projet appelé flaskproject.sock . Nous allons définir une valeur umask de 007 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 transmettre le nom du fichier du point d'entrée WSGI et le Python pouvant être appelé à l'intérieur.
Enfin, nous ajouterons un [Install] section. Cela indiquera à systemd à quoi lier ce service si nous lui permettons de démarrer au démarrage. Nous souhaitons que ce service démarre lorsque le système multi-utilisateurs standard est opérationnel :
/etc/systemd/system/flaskproject.service
[Unit]
Description=Gunicorn instance to serve flaskproject
After=network.target
[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/flaskproject
Environment="PATH=/home/bobby/flaskproject/flaskprojectenv/bin"
ExecStart=/home/bobby/flaskproject/flaskprojectenv/bin/gunicorn --workers 3 --bind unix:flaskproject.sock -m 007 wsgi:app
[Install]
WantedBy=multi-user.targetAvec cela, notre fichier de service systemd est terminé. Enregistrez et fermez-le maintenant.
Nous pouvons maintenant démarrer le service Gunicorn que nous avons créé et l'activer pour qu'il démarre au démarrage :
$ sudo systemctl start flaskproject
$ sudo systemctl enable flaskprojectConfiguration de Nginx pour les requêtes proxy
Notre serveur d'application Gunicorn devrait maintenant être opérationnel et attendre les requêtes sur le fichier socket dans le répertoire du projet. Nous devons configurer Nginx pour transmettre les requêtes Web à ce socket en faisant quelques petits ajouts à son fichier de configuration.
Commencez par créer un nouveau fichier de configuration de bloc de serveur dans le sites-available de Nginx annuaire. Nous appellerons simplement ce projet de flacon pour rester en ligne avec le reste de l'article :
$ sudo nano /etc/nginx/sites-available/flaskproject
Ouvrir un server bloquer et dire à Nginx d'écouter sur le port 80 par défaut. Nous devons également lui dire d'utiliser ce blocage pour les demandes de nom de domaine ou d'adresse IP de notre serveur.
La seule autre chose que nous devons ajouter est un location bloc qui correspond à chaque demande. Dans ce bloc, nous inclurons les proxy_params fichier qui spécifie certains paramètres généraux de proxy qui doivent être définis. Nous transmettrons ensuite les requêtes au socket que nous avons défini à l'aide du proxy_pass instruction :
/etc/nginx/sites-available/flaskproject
server {
listen 80;
server_name server_domain_or_IP;
location / {
include proxy_params;
proxy_pass http://unix:/home/bobby/flaskproject/flaskproject.sock;
}
}C'est en fait tout ce dont nous avons besoin pour servir notre application. Enregistrez et fermez le fichier lorsque vous avez terminé.
Pour activer le server Nginx configuration de bloc que nous venons de créer, liez le fichier au sites-enabled répertoire :
$ sudo ln -s /etc/nginx/sites-available/flaskproject /etc/nginx/sites-enabledAvec le fichier dans ce répertoire, nous pouvons tester les erreurs de syntaxe en tapant :
$ sudo nginx -tSi cela revient sans indiquer de problème, nous pouvons redémarrer le processus Nginx pour lire notre nouvelle configuration :
$ sudo systemctl restart nginxLa dernière chose que nous devons faire est d'ajuster à nouveau notre pare-feu. Nous n'avons plus besoin d'accéder via le port 5000, nous pouvons donc supprimer cette règle. On peut alors 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://server_domain_or_IPVous devriez voir le résultat de votre application :
Remarque :Après avoir configuré Nginx, l'étape suivante doit consister à sécuriser le trafic vers le serveur à l'aide de SSL/TLS. Ceci est important car sans cela, toutes les informations, y compris les mots de passe, sont envoyées sur le réseau en texte brut. Le moyen le plus simple d'obtenir un certificat SSL pour sécuriser votre trafic est d'utiliser Let's Encrypt.
A lire aussi
- Comment installer les certificats SSL Let's Encrypt sur Ubuntu 18.04
- Comment configurer l'environnement de développement Django sur Ubuntu 18.04
- Comment installer LEMP sur Ubuntu 18.04
Conclusion : Dans cet article, nous avons créé une application Flask simple dans un environnement virtuel Python. Nous créons un point d'entrée WSGI afin que tout serveur d'application compatible WSGI puisse s'interfacer avec lui, puis nous configurons le serveur d'application Gunicorn pour fournir cette fonction. Ensuite, nous avons créé un fichier d'unité 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'application, relayant les requêtes externes.