Flask : léger, flexible, puissant – construisez des applications web en Python
Flask s’est imposé comme le micro‑framework web Python de référence. Simple à prendre en main, il ne vous impose ni structure rigide ni composants lourds. Pourtant, sa richesse et son écosystème d’extensions permettent de construire des applications allant de la simple API au site complet intégrant base de données, authentification et tâches asynchrones. Trois concepts forment le trépied de toute application Flask : les routes (découpage des URLs), les templates (génération HTML côté serveur) et les extensions (SQLAlchemy, Flask‑Login, etc.). Sans leur maîtrise, difficile de développer des applications web maintenables. Chez ISOSET, organisme de formation aux métiers du numérique, nous constatons chaque jour que les apprenants qui comprennent profondément ces trois piliers sont capables de passer très vite à des architectures plus complexes (APIs REST, GraphQL, microservices). Cet article vous propose un tour d’horizon complet, nourri de notre expérience pédagogique, pour vous aider à maîtriser Flask.
Développé par Armin Ronacher, Flask est un framework web écrit en Python, qualifié de « micro » car il reste minimaliste et flexible. Il fournit les outils essentiels (routage, requête/réponse, sessions, moteur de templates) sans imposer de couche ORM ou de couche d’administration. À la différence de Django, Flask ne force pas de structure de projet. On peut commencer par un simple fichier `app.py` et ajouter progressivement des extensions selon ses besoins. Cette approche le rend très populaire pour les APIs REST, les prototypes, les microservices, mais aussi pour des applications web complètes une fois enrichi avec des bibliothèques comme Flask‑SQLAlchemy, Flask‑Migrate ou Flask‑Login. ISOSET consacre un module entier à la construction d’applications Flask, de la route zéro au déploiement.
- Minimalisme assumé – seulement ce dont vous avez besoin.
- Extensible – plus de 300 extensions officiellement répertoriées.
- Communauté dynamique – documentation excellente, support réactif.
Une route associe une URL (et des méthodes HTTP) à une fonction Python (la « vue »). Quand un utilisateur accède à cette URL, Flask appelle la fonction et renvoie la réponse (généralement du HTML, du JSON, ou une redirection). Le décorateur `@app.route` est la manière la plus simple de déclarer une route.
# Exemple basique
from flask import Flask
app = Flask(__name__)
@app.route('/')
def accueil():
return '<h1>Bienvenue sur mon site</h1>'
@app.route('/api/hello/<nom>')
def api_hello(nom):
return {'message': f'Bonjour {nom}'}
if __name__ == '__main__':
app.run(debug=True)
Flask supporte les méthodes HTTP : `@app.route(‘/login’, methods=[‘GET’, ‘POST’])`. On peut extraire des paramètres d’URL (`
Chez ISOSET, nous insistons sur une analogie simple : la route, c’est comme une adresse postale ; la vue, c’est le facteur qui délivre le contenu. Si vous changez d’adresse, le facteur ne trouve plus le contenu. Organiser ses routes avec des blueprints (cf. section plus loin) permet de structurer des applications de taille réelle.
Écrire du HTML en dur dans les vues devient vite ingérable. Flask s’appuie sur le moteur de templates Jinja2, qui permet d’injecter des variables, des boucles, des conditions et même d’hériter d’un template de base (layout). Les templates sont placés dans un dossier `templates/`.
# Vue utilisant un template
from flask import render_template
@app.route('/hello/<nom>')
def hello(nom):
return render_template('hello.html', nom=nom)
<!-- templates/hello.html -->
<!DOCTYPE html>
<html>
<body>
<h1>Bonjour {{ nom }}</h1>
{% if nom == 'admin' %}
<p>Vous avez les droits administrateur.</p>
{% endif %}
</body>
</html>
Jinja2 intègre aussi des filtres (`{{ variable|upper }}`), des macros et l’héritage de templates (blocs `{% block content %}`). Cela permet de factoriser l’en‑tête, le pied de page, la barre de navigation dans un seul fichier `base.html`. ISOSET enseigne l’organisation des templates comme une compétence essentielle pour maintenir des projets web sur la durée.
Pour des applications dynamiques, il faut stocker des données. L’extension Flask‑SQLAlchemy intègre l’ORM SQLAlchemy, qui permet de manipuler la base de données via des classes Python (modèles) plutôt que des requêtes SQL brutes. Elle gère les connexions, les sessions, les migrations (avec Flask‑Migrate).
# Modèle User
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
@app.route('/users')
def list_users():
users = User.query.all()
return render_template('users.html', users=users)
SQLAlchemy supporte plusieurs bases (SQLite, PostgreSQL, MySQL) et offre des requêtes avancées via `filter`, `join`, `group_by`. Associé à Flask‑Migrate (basé sur Alembic), on peut versionner les schémas de base de données. ISOSET propose des ateliers complets sur la modélisation de données avec SQLAlchemy, de la création des modèles aux migrations en production.
Le slogan de Flask est « micro » mais on peut l’enrichir de façon modulaire. Quelques extensions phares :
- Flask‑Login – gestion des sessions utilisateur (connexion, déconnexion, utilisateur courant).
- WTForms – validation et génération de formulaires HTML, protection CSRF.
- Flask‑Admin – interface d’administration automatique à partir de vos modèles SQLAlchemy.
- Flask‑Mail – envoi d’emails (confirmation, alertes).
- Flask‑CORS – gestion des en‑têtes CORS pour les APIs.
- Flask‑RESTful / Flask‑RESTx – construction rapide d’APIs REST avec validation.
# Exemple d’authentification basique avec Flask‑Login
from flask_login import LoginManager, login_user, login_required, logout_user
login_manager = LoginManager(app)
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
@app.route('/login', methods=['POST'])
def login():
user = User.query.filter_by(username=request.form['username']).first()
if user and check_password_hash(user.password, request.form['password']):
login_user(user)
return redirect('/dashboard')
return 'Identifiants invalides', 401
@app.route('/logout')
@login_required
def logout():
logout_user()
return redirect('/')
ISOSET forme également les jeunes développeurs à l’intégration de ces extensions, en construisant pas à pas des applications complètes (blog, boutique en ligne, tableau de bord).
Dès que l’application grandit, il est nécessaire de découper le code par fonctionnalités. Les `blueprints` permettent de regrouper des routes, des templates et des fichiers statiques en modules réutilisables. On utilise aussi le pattern “factory” (`create_app`) pour créer l’application en plusieurs environnements (développement, test, production).
# Structure de projet recommandée
monprojet/
├── app/
│ ├── __init__.py # factory create_app
│ ├── models.py # base de données
│ ├── auth/ # blueprint authentification
│ │ ├── __init__.py
│ │ └── routes.py
│ ├── main/ # blueprint principal
│ └── templates/
├── migrations/ # Flask‑Migrate
├── config.py
└── run.py
Ce découpage facilite la réutilisation, les tests unitaires et la maintenance. ISOSET forme à l’architecture modulaire, indispensable pour tout projet Flask en entreprise.
Le serveur intégré de Flask (`app.run()`) n’est pas adapté à la production (mono‑processus, non sécurisé). On utilise plutôt un serveur WSGI (Gunicorn, uWSGI, Waitress) derrière un reverse proxy (Nginx, Apache). Les bonnes pratiques incluent :
- Définir `FLASK_ENV=production` et `FLASK_DEBUG=0`.
- Lever les secrets dans des variables d’environnement (ne pas les coder en dur).
- Utiliser un gestionnaire de processus (systemd, supervisord) pour garantir le redémarrage.
- Conteneuriser avec Docker pour une reproductibilité parfaite.
# Exemple de Dockerfile pour Flask
FROM python:3.11-slim
RUN pip install gunicorn
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "app:create_app()"]
Les plateformes cloud (Azure App Service, AWS Elastic Beanstalk, Heroku) sont également très utilisées. ISOSET accompagne les apprenants dans le déploiement réel de leurs applications Flask sur des serveurs cloud, avec CI/CD (GitHub Actions).
- Utiliser un environnement virtuel – éviter les conflits de dépendances.
- Configurations externalisées – classes de config séparées (DevConfig, ProdConfig).
- Sécuriser les sessions – clé secrète forte, HTTPS en production.
- Protéger contre les attaques – CSRF avec WTForms, échappement automatique dans Jinja2.
- Écrire des tests unitaires – avec pytest et le client de test intégré.
- Documenter son code – docstrings des vues, README pour l’installation.
📘 La pédagogie ISOSET : du prototype à la production
ISOSET enseigne ces bonnes pratiques dès les premiers ateliers, afin que les apprenants ne prennent pas de mauvaises habitudes.
# app/api/products.py (blueprint)
from flask import Blueprint, request, jsonify
from app.models import Product, db
api = Blueprint('api', __name__)
@api.route('/products', methods=['GET'])
def get_products():
products = Product.query.all()
return jsonify([p.to_dict() for p in products])
@api.route('/products', methods=['POST'])
def create_product():
data = request.get_json()
new_product = Product(name=data['name'], price=data['price'])
db.session.add(new_product)
db.session.commit()
return jsonify(new_product.to_dict()), 201
Cet exemple simple avec Flask, SQLAlchemy et JSON montre comment exposer une API RESTful. Les apprenants de ISOSET réalisent ce genre d’exercice lors de la deuxième journée du module Flask.
Les témoignages d’anciens élèves d’ISOSET : *« La formation Flask m’a permis de passer du script Python à une application web complète, avec authentification, base de données et API. Je l’ai déployée sur un serveur cloud en moins d’une semaine. »*
🚀 ISOSET : devenez expert en développement web avec Flask
L’institut ISOSET propose des formations complètes sur Flask : routes et vues, templates Jinja2, SQLAlchemy, extensions (Login, Admin, Mail), blueprints, déploiement (Gunicorn, Docker, cloud). Avec des projets concrets et des formateurs développeurs expérimentés, vous saurez construire des applications web Python robustes, maintenables et prêtes pour la production.
👉 Découvrez les formations ISOSET en développement web – construisez des sites et APIs avec Flask.