- À propos des environnements virtuels pour un projet Flask
- Créer le dossier du projet Flask
- Créer et activer l'environnement virtuel Python
- Installer Flask dans l'environnement virtuel
- Créer une première application Flask
- Lancer le serveur de développement Flask
- Ajouter des routes et développer le projet Flask
- Créer et utiliser requirements.txt
- Désactiver et réutiliser l'environnement virtuel Flask
- À retenir !
1. À propos des environnements virtuels pour un projet Flask
Flask est un framework Web Python léger permettant de développer des sites, des applications Web et des API. Comme de nombreux projets Python, une application Flask peut utiliser plusieurs bibliothèques externes dont les versions varient d'un projet à un autre. Il est donc recommandé d'utiliser un environnement virtuel Python pour isoler les dépendances de chaque projet.
Un environnement virtuel possède son propre emplacement pour les packages Python. Nous pouvons ainsi installer Flask et les autres bibliothèques nécessaires à une application sans modifier les dépendances des autres projets présents sur l'ordinateur.
Le programme suivant permet de vérifier quel interpréteur Python est actuellement utilisé et de déterminer s'il appartient à un environnement virtuel.
1 2 3 4 5 6 | import sys print("Interpréteur :", sys.executable) print("Environnement :", sys.prefix) print("Python de base :", sys.base_prefix) print("Environnement virtuel :", sys.prefix != sys.base_prefix) |
Sortie possible :
1 2 3 4 | Interpréteur : C:\projets\monflask\.venv\Scripts\python.exe Environnement : C:\projets\monflask\.venv Python de base : C:\Python314 Environnement virtuel : True |
Lorsque sys.prefix et sys.base_prefix sont différents, le programme est ici exécuté avec l'interpréteur de l'environnement virtuel.
2. Créer le dossier du projet Flask
Avant de créer l'environnement virtuel, nous allons préparer un dossier destiné à contenir notre projet Flask. Cette organisation permet de conserver au même endroit les fichiers Python, les templates, les fichiers statiques, le fichier requirements.txt et l'environnement de développement.
La commande suivante crée un dossier nommé monflask.
1 | mkdir monflask |
Sortie possible :
1 | Le dossier monflask est créé. |
Nous devons ensuite entrer dans le dossier nouvellement créé avant de préparer l'environnement du projet.
1 | cd monflask |
Sortie possible :
1 | C:\projets\monflask> |
Au début du projet, la structure est donc très simple.
1 | monflask/ |
Sortie :
1 | Le dossier monflask constitue la racine de notre projet Flask. |
3. Créer et activer l'environnement virtuel Python
Depuis le dossier du projet, le module standard venv permet de créer un environnement virtuel. Nous utiliserons le nom .venv, fréquemment choisi pour identifier facilement l'environnement associé au projet.
La commande suivante crée le nouvel environnement virtuel à partir de l'interpréteur Python utilisé pour exécuter la commande.
1 | python -m venv .venv |
Sortie :
1 2 | Aucun message n'est généralement affiché. Le dossier .venv est créé dans le projet. |
Activer l'environnement sous Windows avec CMD
Dans l'invite de commandes Windows, le script activate.bat permet d'activer l'environnement virtuel.
1 | .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\projets\monflask> |
Activer l'environnement sous Windows avec PowerShell
Lorsque nous utilisons PowerShell, l'environnement peut être activé avec le script Activate.ps1.
1 | .venv\Scripts\Activate.ps1 |
Sortie possible :
1 | (.venv) PS C:\projets\monflask> |
Activer l'environnement sous Linux et macOS
Sous Linux et macOS, le script d'activation se trouve dans le dossier bin de l'environnement.
1 | source .venv/bin/activate |
Sortie possible :
1 | (.venv) utilisateur@ordinateur:~/projets/monflask$ |
La présence de (.venv) devant l'invite du terminal indique généralement que l'environnement est actif pour cette session.
4. Installer Flask dans l'environnement virtuel
Une fois l'environnement virtuel activé, nous pouvons installer Flask avec pip. L'utilisation de python -m pip permet d'exécuter pip avec l'interpréteur Python actuellement utilisé.
La commande suivante installe Flask et ses dépendances dans l'environnement .venv.
1 | python -m pip install Flask |
Sortie possible :
1 2 3 4 5 6 7 8 | Collecting Flask Collecting Werkzeug Collecting Jinja2 Collecting itsdangerous Collecting click Collecting blinker ... Successfully installed Flask-... Jinja2-... Werkzeug-... blinker-... click-... itsdangerous-... |
Après l'installation, nous pouvons vérifier la version de Flask disponible dans l'environnement.
1 | python -m flask --version |
Sortie possible :
1 2 3 | Python 3.14.1 Flask 3.x.x Werkzeug 3.x.x |
La commande suivante permet également d'afficher les informations détaillées concernant le package Flask installé.
1 | python -m pip show Flask |
Sortie possible :
1 2 3 4 | Name: Flask Version: 3.x.x Summary: A simple framework for building complex web applications. ... |
Flask est maintenant installé uniquement dans l'environnement virtuel associé à notre projet.
5. Créer une première application Flask
Contrairement à certains frameworks qui génèrent automatiquement une structure complète de projet, Flask permet de commencer avec un simple fichier Python. Nous allons créer un fichier nommé app.py contenant notre première application Web.
Le code suivant importe la classe Flask, crée l'application puis définit une route correspondant à la page d'accueil.
1 2 3 4 5 6 7 | from flask import Flask app = Flask(__name__) @app.route("/") def accueil(): return "Bonjour ! Mon application Flask fonctionne." |
Sortie attendue dans le navigateur :
1 | Bonjour ! Mon application Flask fonctionne. |
L'instruction Flask(__name__) crée l'application. Le décorateur @app.route("/") associe l'URL racine à la fonction accueil(). Lorsque cette URL est demandée, Flask exécute la fonction et retourne son contenu au navigateur.
À ce stade, la structure du projet peut être représentée de la manière suivante.
1 2 3 | monflask/ ├── .venv/ └── app.py |
Sortie :
1 | Le projet contient l'environnement .venv et le fichier principal app.py. |
6. Lancer le serveur de développement Flask
Pour tester notre application, Flask fournit un serveur de développement. Lorsque le fichier principal s'appelle app.py, Flask peut généralement détecter automatiquement l'application et la démarrer avec la commande suivante.
1 | python -m flask run |
Sortie possible :
1 2 3 4 5 | * Serving Flask app 'app' * Debug mode: off WARNING: This is a development server. Do not use it in a production deployment. * Running on http://127.0.0.1:5000 Press CTRL+C to quit |
Nous pouvons maintenant ouvrir l'adresse indiquée par Flask dans un navigateur afin d'afficher la page d'accueil de l'application.
Pendant le développement, le mode debug permet notamment de recharger automatiquement l'application lorsque le code est modifié et fournit des informations de débogage. Il peut être activé avec l'option suivante.
1 | python -m flask run --debug |
Sortie possible :
1 2 3 4 5 6 | * Serving Flask app 'app' * Debug mode: on * Running on http://127.0.0.1:5000 Press CTRL+C to quit * Restarting with stat * Debugger is active! |
Le mode debug et le serveur intégré de Flask sont destinés au développement. Ils ne doivent pas être utilisés comme serveur de production exposé aux utilisateurs.
7. Ajouter des routes et développer le projet Flask
Une application Flask peut contenir plusieurs routes. Chaque route associe une URL à une fonction Python chargée de produire la réponse correspondante. Nous pouvons par exemple ajouter une page d'accueil, une page À propos et une route utilisant une valeur dynamique.
Le programme suivant définit trois routes dans notre application.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | from flask import Flask app = Flask(__name__) @app.route("/") def accueil(): return "Bienvenue sur mon site Flask !" @app.route("/apropos") def apropos(): return "À propos de notre application Flask." @app.route("/bonjour/<nom>") def bonjour(nom): return f"Bonjour {nom} !" |
Sortie possible pour la page d'accueil :
1 | Bienvenue sur mon site Flask ! |
Si nous consultons la route /apropos, la fonction correspondante retourne son propre contenu.
1 | http://127.0.0.1:5000/apropos |
Sortie :
1 | À propos de notre application Flask. |
La route dynamique permet quant à elle de récupérer une valeur directement depuis l'URL. Par exemple, nous pouvons utiliser le prénom Younes dans l'adresse suivante.
1 | http://127.0.0.1:5000/bonjour/Younes |
Sortie :
1 | Bonjour Younes ! |
Cette architecture peut ensuite être enrichie avec des templates Jinja, des formulaires, une base de données, des fichiers statiques, des blueprints ou des API.
8. Créer et utiliser requirements.txt
À mesure que le projet Flask grandit, plusieurs bibliothèques peuvent être installées dans son environnement. Le fichier requirements.txt permet d'enregistrer les dépendances afin de pouvoir reconstruire l'environnement sur un autre ordinateur ou après sa suppression.
Avec l'environnement virtuel actif, la commande suivante génère requirements.txt à partir des distributions actuellement installées.
1 | python -m pip freeze > requirements.txt |
Sortie :
1 2 | Aucun message n'est normalement affiché. Le fichier requirements.txt est créé ou remplacé. |
Après l'installation de Flask, requirements.txt peut contenir Flask ainsi que les distributions dont il dépend.
1 2 3 4 5 6 7 | blinker==... click==... Flask==... itsdangerous==... Jinja2==... MarkupSafe==... Werkzeug==... |
Sortie :
1 | Les distributions installées et leurs versions sont enregistrées dans requirements.txt. |
Si nous récupérons le projet sur un autre ordinateur, nous pouvons créer un nouvel environnement virtuel puis réinstaller les dépendances à partir de requirements.txt.
1 | python -m pip install -r requirements.txt |
Sortie possible :
1 2 3 4 5 6 7 | Collecting blinker==... Collecting click==... Collecting Flask==... Collecting Jinja2==... Collecting Werkzeug==... ... Successfully installed Flask-... Jinja2-... Werkzeug-... ... |
Nous pouvons ensuite contrôler les dépendances installées avec pip check.
1 | python -m pip check |
Sortie possible :
1 | No broken requirements found. |
Le fichier requirements.txt constitue ainsi un élément important pour partager et reconstruire l'environnement d'un projet Flask.
9. Désactiver et réutiliser l'environnement virtuel Flask
Lorsque nous avons terminé une session de développement, la commande deactivate permet de quitter l'environnement virtuel sans supprimer celui-ci.
La commande suivante désactive l'environnement actuellement actif.
1 | deactivate |
Sortie possible :
1 2 3 4 5 | Avant : (.venv) C:\projets\monflask> Après : C:\projets\monflask> |
Lorsque nous souhaitons reprendre le développement sous Windows avec CMD, nous retournons dans le dossier du projet puis nous réactivons simplement l'environnement existant.
1 2 | cd C:\projets\monflask .venv\Scripts\activate.bat |
Sortie possible :
1 | (.venv) C:\projets\monflask> |
Sous Linux ou macOS, l'environnement existant peut être réactivé depuis la racine du projet avec la commande suivante.
1 | source .venv/bin/activate |
Sortie possible :
1 | (.venv) utilisateur@ordinateur:~/projets/monflask$ |
Après la réactivation, nous pouvons immédiatement relancer l'application Flask en mode développement.
1 | python -m flask run --debug |
Sortie possible :
1 2 3 4 | * Serving Flask app 'app' * Debug mode: on * Running on http://127.0.0.1:5000 Press CTRL+C to quit |
Il n'est donc pas nécessaire de recréer l'environnement à chaque utilisation du projet. Il suffit de réactiver .venv avant de reprendre le développement.
10. À retenir !
Créer un environnement virtuel pour un projet Flask permet d'isoler Flask et les autres dépendances de l'application. Cette organisation évite les conflits entre plusieurs projets Python et facilite le partage, la maintenance et la reconstruction de l'environnement de développement.
- python -m venv .venv crée un environnement virtuel dans le projet.
- L'environnement doit être activé avant d'installer Flask et les autres dépendances.
- python -m pip install Flask installe Flask dans l'environnement utilisé.
- python -m flask --version permet de vérifier la version de Flask installée.
- Une application Flask simple peut commencer avec un unique fichier app.py.
- @app.route() permet d'associer une URL à une fonction Python.
- python -m flask run démarre le serveur de développement Flask.
- python -m flask run --debug active le mode de développement avec débogage.
- requirements.txt permet d'enregistrer et de réinstaller les dépendances du projet.
- deactivate quitte l'environnement virtuel sans le supprimer.
Le processus suivant résume les principales commandes nécessaires pour créer sous Windows avec CMD un environnement virtuel, installer Flask et préparer une nouvelle application.
1 2 3 4 5 6 | mkdir monflask cd monflask python -m venv .venv .venv\Scripts\activate.bat python -m pip install Flask python -m flask --version |
Sortie possible :
1 2 3 | Python 3.14.1 Flask 3.x.x Werkzeug 3.x.x |
Après avoir créé le fichier app.py, nous pouvons lancer le serveur, enregistrer les dépendances et vérifier leur cohérence avec les commandes suivantes.
1 2 3 | python -m flask run --debug python -m pip freeze > requirements.txt python -m pip check |
Sortie possible :
1 2 3 4 5 | * Serving Flask app 'app' * Debug mode: on * Running on http://127.0.0.1:5000 ... No broken requirements found. |
Enfin, le programme suivant permet à tout moment de vérifier que l'application utilise bien l'interpréteur de l'environnement virtuel du projet.
1 2 3 4 5 6 | import sys print("Version Python :", sys.version.split()[0]) print("Interpréteur :", sys.executable) print("Environnement :", sys.prefix) print("Environnement virtuel :", sys.prefix != sys.base_prefix) |
Sortie possible :
1 2 3 4 | Version Python : 3.14.1 Interpréteur : C:\projets\monflask\.venv\Scripts\python.exe Environnement : C:\projets\monflask\.venv Environnement virtuel : True |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
