Python est l’un des langages de développement les plus populaires. Sa syntaxe simple et ses faibles barrières à l’entrée en font un bon candidat pour les programmeurs novices qui souhaitent se faire une place dans le paysage du développement logiciel.
Une multitude de frameworks et de bibliothèques facilitent la mise en place et le fonctionnement d’une application Python. Il s’agit notamment de Django, FastAPI et Flask. Le framework Flask attire les développeurs Python en facilitant le prototypage et la personnalisation.
Cet article pratique montre comment développer une application Python simple connectée à une base de données à l’aide de Flask.
Les applications Python facilitées par Flask
Développé en 2010, Flask est bien adapté au développement d’applications web Python grâce à sa facilité d’utilisation et à sa flexibilité. Son architecture légère se concentre sur la fourniture des bases tout en facilitant l’ajout de bibliothèques pour les fonctionnalités dont vous avez besoin. Cette approche rend Flask idéal pour de nombreux projets, qu’il s’agisse d’applications simples ou de systèmes complexes.
Flask offre plusieurs outils et capacités pour soutenir le développement d’applications web, y compris :
- Bibliothèques et des outils pour gérer les requêtes et les réponses HTTP
- Possibilité d’acheminer les requêtes vers des fonctions désignées
- Prise en charge des modèles de rendu
- Prise en charge des bases de données
- Systèmes d’authentification et d’autorisation
Comment créer votre application Python Flask
Vous pouvez explorer les avantages de l’utilisation de Flask pour le développement d’applications Web en créant une application web Python à l’aide de Flask. Ensuite, vous pouvez construire et déployer l’application en utilisant le service d’hébergement d’applications web de Kinsta et la connecter à une base de données infogérée sur la plateforme Kinsta.
Pré-requis de l’application Python Flask
Pour suivre ce tutoriel, vous aurez besoin de :
- Python version 3 ou supérieure
- MySQL Workbench
- Des paquets pip et virtualenv de Python installés
- Un éditeur de code
- Un compte Bitbucket, GitHub ou GitLab pour héberger votre dépôt Git
- Un compte MyKinsta (inscription gratuite) pour servir l’application
Installation de Flask pour Python
Accédez à votre terminal (Linux ou macOS) ou à l’invite de commande (Windows). Commencez par créer un répertoire appelé flask_demo.
Allez dans le nouveau répertoire et créez un environnement virtuel Python à l’aide de la commande python3 -m venv venv. Dans ce cas, nous utilisons également venv comme nom pour le répertoire qui supportera l’environnement virtuel.
Activez l’environnement virtuel à l’aide de l’une des commandes suivantes :
venvScriptsactivatesous Windowssource venv/bin/activatesous Linux ou macOS
Maintenant, installez Flask à l’aide de pip en exécutant pip install flask.
Le travail effectué jusqu’à présent dans votre terminal devrait ressembler à ceci :
Création d’une application de base
Ensuite, créez l’application de base et examinez sa fonctionnalité en rendant le contenu dans le navigateur.
Dans le répertoire flask_demo, créez un fichier appelé demo.py et ajoutez le code suivant :
from flask import Flask
app = Flask(__name__)
# Routes
@app.route('/')
def index():
return "Happy Coding!"
if __name__ == '__main__':
app.run(debug=True)Ce code importe Flask à partir du module flask et crée une instance appelée app. Le code crée ensuite une route qui renvoie un texte affichant « Happy Coding ! » lorsque les utilisateurs visitent l’application dans un navigateur. Enfin, il exécute le serveur de développement une fois que le script démarre.
Lancez l’application en exécutant flask --app demo run dans le terminal. Le drapeau --app indique l’emplacement de l’application qui sera exécutée – ici, le fichier demo.py.
Ajout de modèles à votre application Python Flask
L’ajout de modèles à votre application renforcera votre contenu. Tout d’abord, créez un répertoire appelé templates à la racine de votre application. Ensuite, allez dans le répertoire templates et créez un fichier appelé index.html contenant le code HTML suivant :
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>HomePage</title>
</head>
<body>
<h3>Flask Demo Application</h3>
<p>My name is John Doe - learning about Application Deployment!</p>
</body>
</html>Dans demo.py, importez render_template du module flask et rendez le modèle index.html dans la fonction route comme suit :
from flask import Flask, render_template
app = Flask(__name__)
# Routes
@app.route('/')
def index():
return render_template('index.html')
if __name__ == '__main__':
app.run(debug=True)Servez ensuite votre application en exécutant flask --app demo run dans votre environnement local. Utilisez l’adresse locale indiquée dans le terminal pour lancer l’application dans votre navigateur. Vous devriez voir quelque chose comme ceci :
Connexion de votre application Flask à une base de données locale
Vous allez créer une connexion à une base de données locale – MySQL – qui stocke le contenu de l’application.
Pour connecter votre application Flask à MySQL, installez les éléments suivants :
- flask_mysqldb, le connecteur MySQL pour Flask, en utilisant
pip install flask_mysqldb - Python-dotenv, pour lire les variables d’environnement, à l’aide de
pip install python-dotenv - Le connecteur MySQL de Python, en utilisant
pip install mysql-connector-python - La dépendance MySQL, à l’aide de
pip install mysqlclient
Allez sur MySQL Workbench pour créer une base de données. Assurez-vous d’ajouter un utilisateur de base de données ayant les permissions d’accéder à la base de données et de créer des tables.
Créez un fichier .env dans le répertoire racine de votre application pour contenir les détails de connexion à la base de données. Vous devez ajouter à ce modèle les informations d’identification de l’utilisateur de la base de données et le nom de la base de données :
DB_HOST="localhost"
DB_USER="your-db-user"
DB_PASSWORD="your-db-password"
DB_NAME="your-db-name"Dans un script demo.py révisé, nous allons maintenant importer le connecteur MySQL et utiliser Python-dotenv pour lire les clés des variables d’environnement dans le fichier .env. Ce nouveau script demo.py vérifie également l’existence d’une table nommée persons dans la base de données et la crée et la remplit si elle n’existe pas.
import os
from flask import Flask, render_template
from flask_mysqldb import MySQL
from dotenv import load_dotenv
load_dotenv()
app = Flask(__name__)
app.config['MYSQL_HOST'] = os.getenv("DB_HOST")
app.config['MYSQL_USER'] = os.getenv("DB_USER")
app.config['MYSQL_PASSWORD'] = os.getenv("DB_PASSWORD")
app.config['MYSQL_DB'] = os.getenv("DB_NAME")
mysql = MySQL(app)
@app.route('/')
def index():
cursor = mysql.connection.cursor()
cursor.execute("SHOW TABLES LIKE 'persons'")
result = cursor.fetchone()
if not result:
cursor.execute(''' CREATE TABLE persons (id INTEGER, firstname VARCHAR(20), lastname VARCHAR(20)) ''')
cursor.execute(''' INSERT INTO persons VALUES(1, 'John', 'Doe') ''')
cursor.execute(''' INSERT INTO persons VALUES(2, 'Milly', 'Winfrerey') ''')
mysql.connection.commit()
cursor.execute('SELECT * FROM persons')
entry = cursor.fetchall()
cursor.close()
return render_template('index.html', entry=entry)Après l’instanciation de Flask, le code ci-dessus utilise les variables d’environnement pour capturer les attributs de la base de données à partir du fichier .env à la racine de votre application.
Ensuite, le code instancie MySQL et l’associe à Flask. Il crée un objet curseur dans la route index. Ensuite, le code vérifie la présence d’une table nommée persons dans la base de données. S’il ne la trouve pas, il la crée avec les attributs id, firstname et lastname et insère deux lignes de données.
Les trois lignes suivantes exécutent une commande SQL pour sélectionner toutes les lignes de la table persons et récupérer les résultats. L’objet curseur est fermé et les résultats de la requête sont transmis à la variable de contexte entry pour être rendus avec le modèle.
Voici un fichier modèle index.html révisé qui peut traiter les résultats de la requête de la base de données :
<!DOCTYPE html><html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>HomePage</title>
</head>
<body>
<h3>Flask Demo Application</h3>
{% for e in entry %}
<p>My name is {{e[1]}} {{e[2]}} - learning about Application Deployment!</p>
{% endfor %}
</body>
</html>Exécutez l’application, puis revenez à MySQL Workbench pour vérifier les données. Cela devrait ressembler à ce qui suit :
Lorsque vous interrogez la table, les deux entrées générées par l’application sont renvoyées. Votre application affiche maintenant dans le navigateur le contenu suivant, dérivé de la base de données :
Comment déployer votre application Python Flask sur Kinsta ?
Maintenant que votre application est opérationnelle localement, vous pouvez la rendre visible au monde entier en l’hébergeant sur Kinsta. Vous pouvez associer les services d’hébergement d’applications web et d’hébergement de bases de données infogérées de Kinsta pour donner vie à cette application (et à vos futurs efforts) dans le cloud. Et vous pouvez les essayer tous les deux gratuitement.
Préparer votre projet Python pour le déploiement
La plateforme d’hébergement d’applications Web de Kinsta déploie votre code à partir de votre hébergeur Git préféré. L’étape suivante consiste à configurer votre environnement d’application pour prendre en charge cette voie et permettre à Kinsta de déployer votre application avec toutes les dépendances nécessaires.
Commencez par créer un nouveau répertoire à la racine de votre projet flask_demo. Appelons-le myapp. Déplacez ensuite le répertoire templates et le fichier demo.py dans myapp.
Dans le répertoire myapp, créez un fichier wsgi.py avec le contenu suivant :
from myapp.demo import app as application
if __name__ == "__main__":
application.run(debug=True)Le processus de construction de Kinsta utilisera également pip pour générer votre application. Vous pouvez transmettre une liste des dépendances de votre application à pip du côté de la production en utilisant un fichier requirements.txt dans le répertoire racine du projet.
Tout en travaillant dans l’environnement virtuel venv et dans le répertoire racine flask_demo, vous pouvez générer un fichier requirements.txt spécifique à votre projet à l’aide de la commande suivante :
pip freeze > requirements.txtLe contenu du fichier texte résultant ressemblera à ceci :
blinker==1.7.0
click==8.1.7
Flask==3.0.0
Flask-MySQLdb==2.0.0
itsdangerous==2.1.2
Jinja2==3.1.2
MarkupSafe==2.1.3
mysql-connector-python==8.2.0
mysqlclient==2.2.1
protobuf==4.21.12
python-dotenv==1.0.0
Werkzeug==3.0.1Vous n’enverrez pas le fichier .env avec ses secrets de base de données au serveur de production. Puisque vous n’aurez pas besoin de la bibliothèque python-dotenv pour lire . env en production, vous pouvez supprimer sa référence dans requirements.txt et supprimer (ou commenter) ces lignes dans demo.py:
from dotenv import load_dotenv
load_dotenv()Ajouter un serveur HTTP WSGI Python au projet
Une chose qui manque aux exigences ci-dessus est un moyen de servir l’application via HTTP dans un environnement de production. Le serveur de développement utilisé sur votre machine locale ne suffira pas. Pour ce projet, vous utiliserez le paquet WSGI (Web Server Gateway Interface) Gunicorn entre l’application et les serveurs web Nginx de Kinsta.
Vous pouvez ajouter une exigence Gunicorn à votre projet en l’installant dans votre environnement virtuel comme suit :
pip install gunicornUne fois Gunicorn installé, utilisez pip pour générer à nouveau requirements.txt.
Une alternative à l’installation locale de Gunicorn est d’éditer le fichier requirements.txt et d’y ajouter une entrée comme celle-ci :
gunicorn==21.2.0Pour terminer le travail de base du serveur WSGI, créez un fichier dans le répertoire racine du projet nommé Procfile et ajoutez la ligne suivante :
web: gunicorn myapp.wsgiCe sera la base de la commande de démarrage de votre application en production.
Préparer votre projet pour Git
La structure de répertoire révisée est prête à être déployée chez Kinsta, mais vous ne voulez pas que tous ces fichiers soient envoyés en production. Créez un fichier .gitignore à la racine du projet avec un contenu comme celui-ci :
/venv
.envCela empêchera les fichiers du répertoire venv et les secrets de la base de données locale dans .env d’être téléversés sur votre hôte Git.
Vous pouvez maintenant lancer votre environnement Git local et pousser le code vers votre hôte Git en utilisant les outils de votre choix.
Déployer votre application Python Flask sur Kinsta
Connectez-vous à votre tableau de bord MyKinsta et assurez-vous que vous avez autorisé Kinsta à accéder à votre fournisseur de services Git. Suivez les étapes pour ajouter une application, en sélectionnant le dépôt et la branche sur l’hôte Git où Kinsta trouvera le code de ce projet Flask.
Lors de la configuration de l’environnement de construction, sélectionnez Utimiser Buildpacks pour configurer l’image du conteneur, mais laissez tous les autres réglages par défaut. (Vous ne fournirez pas de commande Start car celle-ci est déjà définie dans votre Procfile)
Après avoir pris connaissance des informations relatives à la facturation (vous pouvez toujours commencer gratuitement !), cliquez sur le bouton Construire maintenant et observez la progression dans le visualiseur de journaux :
Ajouter une base de données pour votre application Python Flask
Kinsta propose quatre options de bases de données infogérées pour répondre à vos besoins et aux exigences de votre application : Redis, PostgreSQL, MariaDB et MySQL. Pour ce tutoriel, nous avons construit pour le service de base de données MySQL.
Suivez les instructions officielles pour ajouter une base de données, en n’oubliant pas de sélectionner le même centre de données que celui que vous avez choisi pour votre application Flask.
Après avoir créé la base de données, sélectionnez-la dans la liste de vos serveurs de base de données disponibles et faites défiler vers le bas jusqu’à la section Connexions internes / Applications autorisées ) de l’onglet Vue d’ensemble. Lorsque vous cliquez sur le bouton Ajouter une connexion, votre service d’application Flask dans le même centre de données sera disponible à la sélection :
Cliquez sur la case à cocher Ajouter des variables d’environnement à l’application avant de créer la nouvelle connexion. Cela permet d’afficher les variables d’environnement qui contiendront les secrets de votre base de données – le tout géré de manière sécurisée sans avoir besoin du fichier .env.
En bas de la boîte de dialogue ci-dessus, les paramètres Disponible pendant l’exécution et Disponible pendant le processus de construction seront activés par défaut – et c’est exactement ce que vous voulez.
Après avoir cliqué sur le bouton Ajouter une connexion, les variables d’environnement requises pour l’accès à la base de données seront appliquées aux réglages de votre projet dans le tableau de bord Applications de MyKinsta :
Maintenant, même si vous reconstruisez votre application après de futures améliorations, les détails de la connexion à la base de données persisteront.
Félicitations ! Vous venez de créer une application Python Flask et de la déployer sur la plateforme Kinsta.
Résumé
Le framework personnalisable de Flask simplifie considérablement la création d’une application Python. L’utilisation de Kinsta pour déployer une application Flask rend les choses encore plus faciles, en accélérant le développement et le déploiement des applications.
Ici, nous avons appris à créer une application simple connectée à une base de données dans un environnement de développement local, puis à la mettre à la disposition du reste du monde sur les plateformes d’hébergement d’applications web et de bases de données de Kinsta.
Découvrez ce que vous pouvez construire sur notre plateforme en consultant nos modèles de démarrage rapide.
Steve Bonisteel est un rédacteur technique chez Kinsta qui a commencé sa carrière d'écrivain en tant que journaliste de presse écrite, chassant les ambulances et les camions de pompiers. Il couvre les technologies similaires à l'Internet depuis la fin des années 1990.
Laisser un commentaire