Tutoriel Flask : bases, fonc­tion­ne­ment et premiers pas avec Python

Flask est un framework Web par­ti­cu­liè­re­ment léger, in­té­res­sant aussi bien pour les débutants que pour les pro­fes­sion­nels. Flask se concentre sur l’essentiel et permet l’im­plé­men­ta­tion de bi­blio­thèques externes pour étendre ses fonc­tion­na­li­tés.

Python et les fra­me­works Web

Python est l’un des langages de pro­gram­ma­tion Web les plus po­pu­laires, notamment car il encourage l’uti­li­sa­tion de code court et simple. Son style de pro­gram­ma­tion bien structuré réduit les erreurs et les uti­li­sa­teurs sont, en règle générale, vite à même de com­prendre un tutoriel Python. Développé par Guido van Rossum en 1991, il est désormais utilisé et maintenu par une vaste com­mu­nauté sous l’égide de l’as­so­cia­tion à but non lucratif Python Software Foun­da­tion. Python est open source et in­dé­pen­dant de toute pla­te­forme. En tant que langage dynamique, Python supporte entre autres la pro­gram­ma­tion orientée objet et fonc­tion­nelle, ainsi que la jour­na­li­sa­tion et peut être exécuté comme script CGI.

Pour la création et le dé­ve­lop­pe­ment de sites Web dy­na­miques et d’autres ap­pli­ca­tions Web, dif­fé­rents fra­me­works Web sont proposés pour Python. Ils four­nis­sent le code né­ces­saire pour faciliter le processus de dé­ve­lop­pe­ment et sim­pli­fier les tâches ré­cur­rentes. Les erreurs ou éventuels problèmes Python peuvent ainsi être évités et les services Web fonc­tion­nent de manière plus sécurisée et rapide. Les fonctions fré­quem­ment requises peuvent être adoptées di­rec­te­ment et ne né­ces­si­tent pas de pro­gram­ma­tion in­dé­pen­dante. L’un des fra­me­works les plus connus pour Python est Django, qui, en tant que solution full stack comparée à Flask vs Django, offre une large gamme d’outils dif­fé­rents, mais est également re­la­ti­ve­ment fixé et rigide. L’al­ter­na­tive peut-être la plus connue à cela est Flask.

Qu’est-ce que le framework Flask ?

Si les fra­me­works full stack tels que Django offrent aux dé­ve­lop­peurs leurs propres bi­blio­thèques, Flask suit une approche dif­fé­rente. Ce framework Web, lancé par le dé­ve­lop­peur au­tri­chien Armin Ronacher en 2010, adopte une approche plus mi­ni­ma­liste. Flask se limite vo­lon­tai­re­ment à l’essentiel en intégrant le moteur de templates Jinja et la bi­blio­thèque « Werkzeug », tout en offrant la pos­si­bi­lité d’ajouter fa­ci­le­ment des fonc­tion­na­li­tés tierces. Le framework Flask est distribué sous licence BSD, il est gratuit et open source. Conçu comme une al­ter­na­tive aux fra­me­works plus complets comme Django, Flask Python a ra­pi­de­ment séduit une large com­mu­nauté d’uti­li­sa­teurs et de dé­ve­lop­peurs.

Con­fi­gu­rer Flask et créer une ap­pli­ca­tion Web

Avant de con­fi­gu­rer Flask pour Python, assurez-vous que vous disposez de la con­fi­gu­ra­tion requise. Cela inclut l’ins­tal­la­tion de Python 3. De plus, vous aurez besoin d’un éditeur de texte ou d’un en­vi­ron­ne­ment de dé­ve­lop­pe­ment et d’un accès à Internet. Il est aussi utile de disposer de con­nais­sances de base sur Python : com­prendre la pro­gram­ma­tion, les types de données, et les boucles for peut être avan­ta­geux. Flask constitue un bon point de départ pour apprendre comment dé­ve­lop­per des ap­pli­ca­tions Web. Vous con­fi­gu­rez le framework comme suit :

1. Créez un en­vi­ron­ne­ment virtuel afin de séparer le nouveau projet de vos autres bi­blio­thèques ou projets Python. Sinon, cela peut entraîner des problèmes avec votre système. Pour cela, le code est le suivant :

$ python -m venv nouveauprojet

2. Installez Flask. Pour cela, il est pré­fé­rable d’utiliser le ges­tion­naire de paquets pip. La commande ap­pro­priée est la suivante :

$ pip install flask

3. Pour vérifier si l’ins­tal­la­tion a réussi, utilisez cette commande :

python -c "import flask; print(flask.__version__)"

4. Vous pouvez main­te­nant tester Flask et créer une ap­pli­ca­tion de base simple. Pour cela, ouvrez un fichier dans votre ré­per­toire. Dans notre exemple, nous l’appelons start.py et utilisons nano pour l’ouvrir :

$ nano start.py

5. Dans ce fichier, écrivez le code suivant :

from flask import Flask
app = Flask(__name__)
@app.route("/")
def home():
    return "Hello World!"

6. En­re­gis­trez et fermez le fichier.

7. Avec la variable d’en­vi­ron­ne­ment FLASK_APP, indiquez à Flask où se trouve le fichier cor­res­pon­dant :

$ export FLASK_APP=start

8. Avec FLASK_ENV, exécutez le fichier en mode dé­ve­lop­pe­ment :

$ export FLASK_ENV=development

9. Exécutez ensuite l’ap­pli­ca­tion :

$ flask run

La sortie ressemble alors à ceci :

- Serving Flask app "start" (lazy loading)
- Environment: development
- Debug mode: on
- Running on [IP address]/ (Press CTRL+C to quit)
- Restarting with stat
- Debugger is active!
- Debugger PIN [PIN]

Avantages et in­con­vé­nients du framework Flask

Il y a de très bonnes raisons d’utiliser Flask. Néanmoins, il n’est pas exempt de défauts. Par con­sé­quent, cela vaut la peine d’examiner de plus près les atouts et les limites de ce framework Web.

Avantages

✓ Son périmètre : il y a peu de chances que vous trouviez un framework plus léger que Flask en Python. Flask s’installe et s’utilise ra­pi­de­ment. ✓ Sa flexi­bi­lité : Flask se distingue aussi par sa grande flexi­bi­lité. Vous pouvez résoudre des problèmes et intégrer les bi­blio­thèques dont vous avez besoin, tout en traitant chaque projet in­di­vi­duel­le­ment. ✓ La courbe d’ap­pren­tis­sage : Flask est maî­tri­sable très ra­pi­de­ment à l’aide d’un tutoriel Flask. Ce framework est in­dé­nia­ble­ment simple, mais peut aussi être utilisé pour des projets ambitieux. Flask est une option de choix, tant pour les débutants que pour les pro­fes­sion­nels. ✓ Open source : le framework Flask est open source et dis­po­nible gra­tui­te­ment. Vous n’avez qu’à l’essayer et décider si c’est le bon outil pour vos besoins. ✓ La com­mu­nauté : Flask rassemble une gi­gan­tesque com­mu­nauté qui fournit conseils et soutien aux néophytes et aux dé­ve­lop­peurs plus avancés. Les questions et erreurs trouvent ra­pi­de­ment des réponses et des solutions.

In­con­vé­nients

✗ Son périmètre : selon l’uti­li­sa­tion prévue, son périmètre mi­ni­ma­liste peut s’avérer être une limite. Chaque outil requiert une ins­tal­la­tion in­di­vi­duelle. Les fra­me­works con­cur­rents donnent accès à un nombre beaucoup plus élevé de fonc­tion­na­li­tés. ✗ Dé­pen­dance vis-à-vis des four­nis­seurs tiers : l’uti­li­sa­tion de bi­blio­thèques externes est toujours une possible source d’erreurs, mais Flask est dépendant de ces dernières. ✗ La main­te­nance : tandis que d’autres fra­me­works sont maintenus au­to­ma­ti­que­ment, Flask délègue cette res­pon­sa­bi­lité à l’uti­li­sa­teur. Ceci signifie un contrôle plus élevé, mais crée plus de travail.

Exemple Flask « Hello World! » : routage, modèles et API

Pour mieux com­prendre le fonc­tion­ne­ment de base de Flask, voici un exemple simple il­lus­trant les concepts fon­da­men­taux du framework Web. Nous allons créer une ap­pli­ca­tion Web basique afin de montrer comment le routage, les modèles et une API REST in­te­ra­gis­sent. L’exemple se compose de deux fichiers :

• app.py : ce fichier contient le code Python.
• templates/hello.html : ce fichier cor­res­pond à un modèle Jinja2 per­met­tant d’afficher dy­na­mi­que­ment la page Web.

Le fichier app.py se présente comme suit :

from flask import Flask, jsonify, render_template, request
app = Flask(__name__)
@app.route("/")
def home():
    return "Hello World!"
@app.route("/greet/<name>")
def greet(name):
    return render_template("hello.html", name=name)
@app.route("/api/square", methods=["GET"])
def square():
    number = request.args.get("number", default=0, type=int)
    result = number ** 2
    return jsonify({"number": number, "square": result})
if __name__ == "__main__":
    app.run(debug=True)

Ceci est le fichier hello.html, qui sert de modèle :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Greeting</title>
</head>
<body>
    <h1>Hello, {{ name }}!</h1>
    <p>Welcome to Flask with Jinja2 template.</p>
</body>
</html>

À l’aide de @app.route, nous dé­fi­nis­sons dif­fé­rents points de ter­mi­nai­son. Il s’agit d’URL aux­quelles le serveur peut répondre. La page d’accueil (/) affiche sim­ple­ment le texte « Hello World! ». Grâce à un chemin dynamique (greet/<name>), il est possible d’afficher une sa­lu­ta­tion per­son­na­li­sée. Le nom est extrait de l’URL et transmis au modèle Jinja2, qui l’insère dans le code HTML (voir le code du fichier templates/hello.html).

Nous montrons également comment créer une petite API REST. À l’aide du point de ter­mi­nai­son /api/square, l’uti­li­sa­teur peut trans­mettre un nombre comme paramètre d’URL, et l’ap­pli­ca­tion renvoie le carré de ce nombre sous forme de réponse JSON. Cet exemple illustre que Flask permet aussi bien de gérer des pages Web clas­siques que des points de ter­mi­nai­son API. Les contenus dy­na­miques peuvent être intégrés fa­ci­le­ment dans le HTML à l’aide de modèles, sans devoir modifier ma­nuel­le­ment la page.

Ex­ten­sions Flask cou­ram­ment utilisées

Comme Flask adopte une approche très mi­ni­ma­liste, de nom­breuses fonc­tion­na­li­tés courantes, telles que la connexion à une base de données, l’au­then­ti­fi­ca­tion ou la va­li­da­tion de for­mu­laires, ne sont pas intégrées par défaut. Pour ajouter ces fonctions, on s’appuie sur des ex­ten­sions Flask, dé­ve­lop­pées et main­te­nues par la com­mu­nauté. Celles-ci s’intègrent fa­ci­le­ment dans une ap­pli­ca­tion Flask et per­met­tent d’élargir con­si­dé­ra­ble­ment les fonc­tion­na­li­tés dis­po­nibles, sans avoir à modifier le framework lui-même. Les dé­ve­lop­peurs peuvent ainsi sé­lec­tion­ner pré­ci­sé­ment les com­po­sants dont ils ont réel­le­ment besoin et concevoir leur ap­pli­ca­tion de manière modulaire. Les ex­ten­sions suivent gé­né­ra­le­ment la phi­lo­so­phie de Flask et bé­né­fi­cient d’une do­cu­men­ta­tion complète.

Exemples d’ex­ten­sions Flask im­por­tantes :

• Flask-SQ­LAl­chemy : extension dédiée à la connexion aux bases de données. Elle intègre l’ORM SQ­LAl­chemy dans Flask et permet de tra­vail­ler sim­ple­ment avec des bases de données à l’aide de classes Python.
• Flask-WTF : cette extension facilite la création et la va­li­da­tion de for­mu­laires Web. Elle inclut des mé­ca­nismes de sécurité, comme la pro­tec­tion contre les attaques CSRF, et simplifie la gestion des données saisies par les uti­li­sa­teurs.
• Flask-Login : comme son nom l’indique, Flask-Login simplifie la gestion des uti­li­sa­teurs et de l’au­then­ti­fi­ca­tion. L’extension prend en charge le statut de connexion, les sessions ainsi que la pro­tec­tion de l’accès à certaines routes.
• Flask-Migrate : Flask-Migrate fournit des fonctions de migration de base de données per­met­tant de gérer au­to­ma­ti­que­ment les mo­di­fi­ca­tions de structure. Elle est par­ti­cu­liè­re­ment adaptée lorsqu’elle est utilisée avec Flask-SQ­LAl­chemy pour appliquer des mises à jour de manière struc­tu­rée.
• Flask-RESTful : cette extension simplifie la création d’API REST. Elle met à dis­po­si­tion des res­sources, des routes et des méthodes HTTP telles que GET, POST, PUT ou DELETE selon une approche stan­dar­di­sée.

Structure d’un projet Flask et bonnes pratiques

Pour les projets Flask, il est re­com­mandé de choisir dès le départ une or­ga­ni­sa­tion de projet claire et struc­tu­rée. Même si, d’un point de vue technique, de petites ap­pli­ca­tions peuvent fonc­tion­ner dans un seul fichier, une structure propre facilite con­si­dé­ra­ble­ment la main­te­nance et l’évolution de l’ap­pli­ca­tion.

Dans les projets de plus grande envergure, on crée gé­né­ra­le­ment des ré­per­toires comme templates pour les fichiers HTML, static pour les feuilles de style CSS, le Ja­vaS­cript et les images, ainsi que app ou src pour les modules Python. À l’intérieur du dossier app, des sous-dossiers dédiés aux blue­prints, aux modèles, aux for­mu­laires et aux uti­li­taires per­met­tent de séparer clai­re­ment les dif­fé­rentes fonc­tion­na­li­tés. Les blue­prints servent à struc­tu­rer l’ap­pli­ca­tion de manière modulaire, par exemple pour la gestion des uti­li­sa­teurs ou pour un blog.

Les bonnes pratiques re­com­man­dent également de stocker les valeurs de con­fi­gu­ra­tion sensibles, comme les URL de bases de données ou les clés secrètes, dans un fichier config.py séparé ou via des variables d’en­vi­ron­ne­ment. Une jour­na­li­sa­tion continue aide à iden­ti­fier ra­pi­de­ment les erreurs et à mieux com­prendre le com­por­te­ment de l’ap­pli­ca­tion. L’uti­li­sa­tion d’en­vi­ron­ne­ments virtuels est aussi con­seil­lée afin de gérer pro­pre­ment les dé­pen­dances. Enfin, la gestion des versions avec Git fait partie des pratiques standard pour assurer la tra­ça­bi­lité des mo­di­fi­ca­tions.

Sécurité et tests dans Flask

La sécurité et les tests ne sont pas de simples options, mais des com­po­santes es­sen­tielles d’une ap­pli­ca­tion Flask pro­fes­sion­nelle. Ils ne devraient donc être négligés dans aucun tutoriel Flask. En accordant dès le départ une attention par­ti­cu­lière au chif­fre­ment, à la va­li­da­tion des entrées, aux con­fi­gu­ra­tions sé­cu­ri­sées et aux tests au­to­ma­ti­sés, il est possible de dé­ve­lop­per des ap­pli­ca­tions Web stables et fiables, qui pourront ensuite être étendues sans dif­fi­culté.

Sécurité dans Flask

En raison de la structure mi­ni­ma­liste de Flask, la res­pon­sa­bi­lité de la sécurité de l’ap­pli­ca­tion incombe aux dé­ve­lop­peurs. Une pro­tec­tion de base réside dans l’uti­li­sa­tion de la pro­tec­tion CSRF pour les for­mu­laires, notamment lors des saisies uti­li­sa­teur. À cet effet, l’extension Flask-WTF propose des mé­ca­nismes éprouvés.

Les mots de passe ne doivent jamais être stockés en clair, mais toujours chiffrés ou hachés.. À cet effet, les bi­blio­thèques werkzeug.security ou bcrypt sont adaptées. La va­li­da­tion des entrées est tout aussi cruciale pour prévenir les in­jec­tions SQL, les attaques XSS ou d’autres types de ma­ni­pu­la­tions.

Pour les sessions et les cookies, il est important de définir les in­di­ca­teurs HttpOnly et Secure pour protéger les données sensibles. Les con­fi­gu­ra­tions sensibles, telles que les URL de bases de données ou les clés API, doivent être gérées via des variables d’en­vi­ron­ne­ment ou des fichiers de con­fi­gu­ra­tion séparés, plutôt que d’être di­rec­te­ment incluses dans le code.

Tests dans Flask

Comme dans toute ap­pli­ca­tion lo­gi­cielle, les tests dans Flask sont in­dis­pen­sables pour assurer la stabilité de l’ap­pli­ca­tion. Les tests unitaires servent à vérifier sé­pa­ré­ment des fonctions in­di­vi­duelles, tandis que les tests d’in­té­gra­tion évaluent l’in­te­rac­tion entre plusieurs com­po­sants.

Flask met à dis­po­si­tion un client de test intégré qui permet de simuler des requêtes HTTP sans démarrer réel­le­ment le serveur. Il devient ainsi possible de tester au­to­ma­ti­que­ment les routes, les templates et les points de ter­mi­nai­son API. La rédaction régulière de cas de test est par­ti­cu­liè­re­ment im­por­tante, notamment lors de l’ajout de nouvelles fonc­tion­na­li­tés, afin d’éviter les ré­gres­sions. Combinée à l’In­té­gra­tion Continue, cette approche contribue à maintenir la fiabilité de l’ap­pli­ca­tion, même en cas d’évo­lu­tions fré­quentes.