Bien démarrer avec Flask, un micro-framework Python

Dans cet article, nous introduirons Flask, un populaire micro-framework pour Python qui propose une alternative au géant qu’est Django.

Flask est conçu pour être léger et flexible, permettant aux développeurs de créer des applications web rapidement et facilement. Dans cet article, nous aborderons ce qu’est Flask, ses principales caractéristiques, les avantages de son API simple, sa flexibilité pour supporter les extensions tierces, les extensions Flask les plus courantes, et quand il est et n’est pas judicieux d’utiliser Flask.

Points Clés

Qu’est-ce que Flask ?

Flask est un micro-framework web écrit en Python utilisé pour développer des applications web. Il est construit sur une philosophie simple consistant à garder les choses simples et légères, donnant aux développeurs uniquement les outils les plus importants nécessaires pour construire des applications web sans complexité inutile.

Il est construit sur le toolkit WSGI Werkzeug, qui fournit la fonctionnalité du serveur web nécessaire pour gérer les requêtes et les réponses, et l’outil de templating Jinja2, qui donne à Flask la capacité de gérer les templates HTML, permettant aux développeurs de créer des applications web dynamiques.

Voici quelques-unes des caractéristiques clés de Flask qui en font un si grand framework à utiliser :

• Il possède une API simple pour créer des routes web et gérer les requêtes.
• Le moteur de template Jinja offre un support pour les templates HTML, permettant aux développeurs de créer des pages web facilement.
• Il est très extensible, en raison de son soutien aux extensions tierces, permettant ainsi aux développeurs d’installer des extensions en fonction des besoins de leur projet.
• Il est fourni avec un serveur de développement qui facilite la mise à l’essai et le débogage des applications.

Dans l’ensemble, Flask fournit un cadre puissant, flexible et simple pour la construction d’applications web. Il s’agit d’une bonne option pour les développeurs web débutants et expérimentés, et est l’un des frameworks web les plus populaires dans l’écosystème du développement web Python.

Avantages de Flask

Examinons maintenant de manière plus détaillée certains des avantages de l’utilisation de Flask dans le développement.

Simplicité. L’approche de conception de Flask met l’accent sur la simplicité, ce qui rend facile à comprendre et à utiliser pour les développeurs de tout niveau. Cela signifie également que les développeurs ont une courbe d’apprentissage très réduite, car ils n’ont besoin que d’apprendre quelques concepts et API pour commencer à construire des applications web.

Flexibilité. La nature micro de Flask — fournissant uniquement les fonctionnalités de base d’un framework web — donne aux développeurs le pouvoir de personnaliser et d’étendre en fonction de leurs besoins à l’aide d’extensions Flask ou de bibliothèques tierces.

Documentation. La documentation de Flask est très complète, avec une bonne couverture des sujets de base à avancés, ce qui facilite grandement l’apprentissage pour les développeurs sur l’utilisation du framework.

Compatibilité. Flask est compatible avec un large éventail de versions de Python, ce qui le rend facile à utiliser avec les bases de code Python existantes. Il prend également en charge plusieurs serveurs Web, ce qui le rend facile à déployer sur diverses plateformes d’hébergement.

Développement rapide. La simplicité et la flexibilité de Flask réduisent le code de base nécessaire pour mettre en place une application, permettant aux développeurs de commencer rapidement.

Sur le Web, Flask est utilisé de manière intéressante dans de nombreux cas. Voici quelques exemples notables :

• PgAdmin. L’interface d’administration Postgres fonctionne sur une instance Flask, offrant aux développeurs une interface où ils peuvent gérer leurs bases de données Postgres.
• Twilio. Il s’agit d’une plateforme de communication qui utilise Flask dans plusieurs de ses API.
• Pinterest. Cette application de partage de photos utilise Flask dans la pile de développement Web, permettant à son équipe de créer facilement certaines fonctionnalités et intégrations personnalisées.

Quand utiliser Flask

La simplicité et la facilité d’utilisation de Flask en font une excellente option pour une grande variété de projets Web :

• Prototypage. Sa facilité d’utilisation et sa flexibilité en font une excellente option pour créer rapidement des prototypes, permettant aux développeurs de construire et tester de nouvelles fonctionnalités rapidement.
• Création d’API RESTful. Sa propre API simple facilite la création et la gestion des requêtes HTTP.
• Applications e-commerce. Il est bien adapté pour la construction de marchés en ligne et de plateformes e-commerce.
• Finance. C’est utile pour la construction d’applications financières, avec la gestion des comptes, le traitement des transactions et le suivi des investissements.
• IA. Il offre un moyen utile et simple de construire et de déployer des modèles d’entraînement IA.

Quand Ne Pas Utiliser Flask

Bien que Flask soit un excellent framework et possède de nombreux avantages et de grandes fonctionnalités, il existe des situations où ces fonctionnalités fonctionnent contre lui. Explorons certains des projets qui conviennent mieux à d’autres types de frameworks.

Projets nécessitant des fonctionnalités intégrées. Étant un microframework, Flask ne fournit que les éléments de base nécessaires pour créer une application web. Si un projet nécessite, par exemple, une interface d’administration, une authentification ou un ORM, alors Django est une meilleure option.

Projets avec des exigences de sécurité strictes. Comme Flask est un framework flexible, nous devons nous fier à des extensions tierces pour mettre en œuvre un certain niveau de sécurité dans nos applications. Bien que cela fonctionne certainement, il est préférable de compter sur un framework plus expérimenté qui adopte une approche plus sécurisée, comme Tornado ou Twisted.

Projets qui imposent un certain standard de codage. En raison de la flexibilité de Flask, le développement d’applications sur celui-ci laisse aux développeurs le soin de créer des applications de manière à leur convenir. Cependant, des frameworks comme Django garantissent que les développeurs suivent une convention particulière, ce qui signifie que les développeurs peuvent passer d’un projet à un autre facilement.

Configuration d’un environnement de développement Flask

Examinons maintenant comment démarrer avec Flask, depuis la configuration de l’environnement de développement, l’installation, jusqu’à la création d’une application minimale.

Prérequis

Python doit être installé sur la machine de développement. Voici des instructions à ce sujet (bien que nous puissions déjà l’avoir installé).

Créer un Environnement Virtuel

A virtual environment is an isolated Python environment where we can install packages for a given project without affecting the global Python installation. (Here’s further discussion about why virtual environments are useful.) There are different packages for creating virtual environments in Python, such as virtualenv, venv, or Conda.

Dans cet article, nous utiliserons virtualenv. Nous pouvons l’installer avec la commande suivante:

pip install virtualenv

Une fois que virtualenv est installé, nous pouvons créer un répertoire où notre application Flask sera située. Nous pouvons appeler le répertoire comme nous le souhaitons — autrement que Flask, car cela causerait des conflits. Nous l’appellerons flask_intro:

mkdir flask_intro

Ensuite, changez dans ce répertoire afin de commencer à l’utiliser:

cd flask_intro

Dans ce répertoire, créons maintenant notre environnement virtuel, en utilisant la commande suivante:

virtualenv myenv

La commande ci-dessus crée un environnement virtuel et l’appelle myenv. Activons-le afin de pouvoir installer Flask dedans. Pour activer l’environnement virtuel sur Linux ou macOS, utilisez la commande suivante:

. myenv/bin/activate

Sur Windows, utilisez cette commande:

. myenv\Scripts\activate

Une fois que notre environnement virtuel est activé, il affichera le nom de l’environnement virtuel dans l’invite de commande, semblable à la sortie ci-dessous :

(myenv)/~(path to your project directory)$

Dans notre environnement virtuel activé, nous pouvons procéder à l’installation de Flask, en utilisant la commande suivante :

pip install Flask

Une fois Flask installé, créons une application minimale. Nous allons créer un module qui contiendra notre application Flask. Pour simplifier, appelons-le hello.py. Sur Linux ou macOS, nous pouvons utiliser la commande suivante pour créer le fichier dans notre répertoire flask_intro :

touch hello.py

La commande ci-dessus crée un fichier nommé hello.py. Nous pourrions également utiliser un environnement de développement pour créer le fichier. Une fois le fichier créé, insérez le code ci-dessous et enregistrez-le :

# hello.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello, World!'

Dans le code ci-dessus, nous importons la classe Flask du module flask, puis créons une instance de Flask que nous appelons app et passons la variable __name__.

Ensuite, nous avons le décorateur de route @app.route(“\”), ce qui signifie que la fonction hello_world() sera déclenchée lorsqu’une personne visitera la route racine de notre application une fois qu’elle sera lancée.

Il existe différentes manières de lancer l’application, examinons donc certaines d’entre elles. La première façon consiste à fournir la commande flask avec un certain nombre d’arguments : --app, puis le nom du module qui contient notre application Flask, et enfin run. Voir ci-dessous :

flask –app <the name of your module> run

En utilisant l’exemple ci-dessus pour exécuter notre application d’exemple :

flask –app hello run

Cela exécutera notre application sur le port par défaut 5000 de sorte que l’application soit disponible sur http://localhost:5000/ ou à http://127.0.0.1:5000/. Si nous voulons que l’application soit disponible sur un autre port, nous pouvons spécifier le port en utilisant l’option -p ou --port. Par exemple :

flask --app hello run --port=8080

Cela exécutera le serveur sur le port 8080. L’autre façon d’exécuter l’application est simplement en utilisant les commandes flask run. Cependant, pour pouvoir le faire, nous devons indiquer à Flask le nom du module qui contiendra l’instance Flask, et nous le faisons en définissant la variable d’environnement FLASK_APP. Dans notre cas, l’application Flask est contenue dans un fichier nommé hello.py. Nous pouvons donc le définir de cette façon :

export FLASK_APP=hello

Maintenant que nous avons défini la variable d’environnement FLASK_APP, nous pouvons exécuter le serveur de développement comme suit :

flask run

Avec ce code, nous avons maintenant une application web en cours d’exécution. Cela illustre la philosophie fondamentale de Flask : nous n’avons pas besoin de beaucoup de code de base pour démarrer. Cependant, l’application que nous avons configurée ci-dessus n’est pas très fonctionnelle ou utile, car elle ne rend que la chaîne « Hello World! » sur notre page web. Pour faire quelque chose de plus utile, nous pouvons nous tourner vers les modèles. Nous verrons ensuite comment les gérer.

Modèles Flask

Modèles Flask sont un moyen de créer des pages web dynamiques qui peuvent afficher différentes contenus en fonction de divers facteurs, tels que les données d’une base de données ou les entrées utilisateur. Les modèles dans Flask sont une combinaison d’HTML et de placeholders spéciaux appelés variables de modèle qui sont remplacés par des valeurs réelles à l’exécution.

Les modèles sont stockés dans le répertoire templates. Ainsi, pour utiliser des modèles, nous devons importer la méthode render_template() de flask. La méthode render_template() prend un nom de modèle et toutes les données optionnelles qui doivent être transmises au modèle.

Voyons un exemple d’une fonction qui utilise un modèle pour rendre une page web:

# index.py
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
    title = 'Welcome to my website!'
    message = 'This is an example of using Flask templates.'
    return render_template('index.html', title=title, message=message)

Dans l’exemple ci-dessus, nous avons une fonction de vue — index() — liée à l’URL racine (« / ») par le décorateur @app.route(). La fonction a deux variables, title et message. Enfin, nous passons le modèle index.html à la méthode render_template(), avec les variables title et message.

Pour que le code ci-dessus fonctionne, nous devons avoir un modèle index.html résidant dans un répertoire templates. Ainsi, le modèle ressemblera à ceci:

# index.html
<!doctype html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ title }}</h1>
    <p>{{ message }}</p>
</body>
</html>

Dans le fichier index.html, les espaces réservés {{title}} et {{ message }} sont remplacés par les valeurs transmises au modèle dans la méthode render_template().

Les modèles peuvent également inclure une logique plus complexe telle que les instructions if et les boucles for, ce qui permet de générer des pages plus dynamiques.

Ainsi, les modèles dans Flask offrent aux développeurs une option très puissante pour créer des pages web dynamiques riches en informations générées par l’utilisateur.

Routage Flask

La plupart des applications web auront plus d’une URL, donc nous avons besoin d’un moyen de savoir quelle fonction gère quelle URL. Dans Flask, cette correspondance est connue sous le nom de routage — le processus de liaison ou de mappage des URLs aux fonctions de vue. La liaison des URLs aux fonctions de vue permet à l’application de gérer différents types de requêtes, telles que GET, POST, PUT, DELETE, et plus encore. Cela permet également à l’application de gérer plusieurs requêtes provenant de différents clients.

Pour configurer les routes dans Flask, nous utilisons le route() décorateur. Le décorateur lie une URL à une fonction de vue — donc lorsqu’un utilisateur visite une URL qui existe dans notre application, Flask déclenche la fonction de vue associée pour gérer la requête.

Voyons un exemple:

# hello.py
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/about")
def about():
    return "This is the about page"

Dans l’exemple ci-dessus, nous définissons une URL à propos (/about). Lorsque l’application reçoit une requête pour l’URL about, Flask appelle la fonction about(), qui renvoie la chaîne « Ceci est la page à propos ».

Jusqu’à présent, bien que ces exemples renvoient des pages différentes, ils utilisent tous simplement la requête HTTP GET. Afin de pouvoir gérer toute requête spécifique, nous pouvons spécifier la méthode HTTP en tant qu’argument optionnel du route() décorateur.

Voyons un exemple d’une requête PUT :

from flask import Flask, request

app = Flask(__name__)

@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    # obtenir les données utilisateur à partir du corps de la requête
    data = request.get_json()
    # faire quelque chose avec les données utilisateur, comme mettre à jour l'utilisateur dans la base de données
    # ...
    # renvoyer une réponse indiquant le succès ou l'échec
    return {'message': f'User {user_id} updated successfully'}, 200

Dans cet exemple, nous définissons une route qui gère une requête PUT pour mettre à jour les détails d’un utilisateur en utilisant leur user_id. Nous utilisons <int:user_id> dans la route pour indiquer que l’identifiant utilisateur doit être un entier.

Dans la fonction update_user(), nous obtenons les données utilisateur à partir du corps de la requête en utilisant la méthode request.get_json(). Nous faisons quelque chose avec les données utilisateur, comme mettre à jour l’utilisateur dans la base de données, puis nous renvoyons une réponse indiquant le succès ou l’échec, ainsi qu’un code d’état HTTP (un 200 dans ce cas pour indiquer le succès).

Dans l’ensemble, la routage permet à Flask de pouvoir gérer différents types de requêtes et permet à notre application de gérer et d’agir différemment sur les données, en fonction de l’URL qu’un utilisateur visite.

Formulaires Flask et Validation

En plus de présenter des données aux utilisateurs, les modèles Flask peuvent également prendre des entrées des utilisateurs pour un traitement ou une stockage ultérieur. Pour cela, Flask fournit un support intégré pour le traitement des formulaires HTML et la gestion des entrées utilisateur. Les formulaires Flask sont basés sur la bibliothèque WTForms, qui fournit une manière flexible et puissante de gérer les données de formulaire et d’effectuer des validations. Cependant, la bibliothèque n’est pas une partie de l’installation standard de Flask, nous devons donc l’installer en utilisant la commande suivante :

pip install WTForms

Une fois que nous avons installé WTForms, pour utiliser des formulaires dans Flask, nous devons définir une classe de formulaire qui héritera de flask_wtf.FlaskForm. La classe contiendra les champs qui seront présents sur le formulaire et toutes les règles de validation qui devraient leur être appliquées.

Examinons un exemple de formulaire de connexion:

# forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, Length

class LoginForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired(), Length(min=6)])
    submit = SubmitField('Log In')

Dans l’exemple ci-dessus, nous définissons un formulaire de connexion avec deux champs — email et password — et un bouton de soumission. Nous avons également un argument validators utilisé pour spécifier les règles de validation pour chaque champ. Par exemple, dans ce cas, nous exigeons que le champ email contienne une adresse e-mail valide et que le champ password contienne un mot de passe d’au moins six caractères.

Une fois que nous avons défini la classe de formulaire, nous pouvons l’utiliser dans la fonction de vue de connexion pour rendre le formulaire et traiter les données du formulaire soumises par l’utilisateur. Voyons un exemple de la fonction de vue:

# views.py
from flask import render_template, request
from .forms import LoginForm

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        email = form.email.data
        password = form.password.data
        # faire quelque chose avec les données du formulaire
    return render_template('login.html', form=form)

Dans l’exemple ci-dessus, nous avons une vue login qui accepte deux méthodes HTTP (GET et POST), donc lorsque les utilisateurs accèdent à l’URL depuis un navigateur, le LoginForm est rendu sous forme de formulaire HTML en utilisant la méthode render_template, et lorsqu’un utilisateur soumet le formulaire, nous vérifions si le formulaire est valide en utilisant la méthode validate_on_submit. Si le formulaire est valide, nous accédons à l’e-mail et au mot de passe.

Le formulaire login.html pourrait ressembler à ceci :

# login.html
<h1>Login</h1>
<form method="POST">
  {{ form.csrf_token }}
  <div>
    {{ form.email.label }} {{ form.email() }}
    {% for error in form.email.errors %}
    <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  <div>
    {{ form.password.label }} {{ form.password() }}
    {% for error in form.password.errors %}
      <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  {{ form.submit() }}
</form>

Le modèle ci-dessus rendra les champs email et password, ainsi que leurs libellés, et un bouton de soumission avec le texte “Login”. Le champ form.csrf_token est inclus pour prévenir les attaques de falsification de requêtes entre sites (CSRF). Les boucles {% for %} sont utilisées pour afficher les erreurs de validation qui peuvent survenir.

En utilisant les formulaires Flask, nous disposons d’une manière puissante de gérer l’entrée utilisateur et nous pourrons valider les données qu’ils fournissent.

Extensions Flask

Comme nous l’avons vu, Flask est un micro-framework qui ne comprend que les parties les plus importantes nécessaires pour créer une application web. Cependant, si nous avons besoin d’ajouter des fonctionnalités qui ne sont pas fournies par défaut par Flask, nous devons ajouter des packages à l’installation. Les extensions Flask sont la façon dont nous fournissons cette fonctionnalité supplémentaire. Nous pouvons simplement installer le package dont nous avons besoin. Il existe de nombreuses extensions créées par la communauté Flask.

Voici quelques-unes des plus populaires :

• Flask-SQLAlchemy: fournit une intégration avec l’outil SQLAlchemy qui facilite l’interaction avec les bases de données.
• Flask-Login: fournit l’authentification des utilisateurs et la gestion des sessions à Flask.
• Flask-Mail: fournit une interface simple pour envoyer des emails depuis Flask.

Il existe des centaines d’extensions créées par la communauté Flask pour gérer différentes fonctionnalités. L’utilisation des extensions est généralement simple. Tout d’abord, nous devons installer l’extension que nous voulons utiliser avec pip.

Voyons un exemple d’utilisation de Flask-SQLAlchemy. Tout d’abord, nous devons l’installer :

pip install flask-sqlalchemy

Ensuite, nous devons le configurer. Par exemple :

# sqlalchemy_example.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
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)

    def __repr__(self):
        return '<User %r>' % self.username

Dans l’exemple ci-dessus, nous avons un modèle User avec un champ username et email. Nous configurons également SQLALCHEMY_DATABASE_URI, indiquant que nous utilisons une base de données SQLite située à example.db. Avec cela mis en place, nous avons maintenant accès à l’objet db qui nous permet d’interagir avec la base de données. Par exemple, nous pourrions créer un nouvel utilisateur et l’ajouter à la base de données, comme suit :

#views.py 
from app import db, User

user = User(username='john', email='[email protected]')
db.session.add(user)
db.session.commit()

Avec les extensions Flask, notre application est capable d’avoir plus de fonctionnalités qu’elle n’en aurait normalement avec l’implémentation de base de Flask.

Conclusion

Dans cet article, nous avons présenté Flask, un framework web léger et flexible pour Python. Nous avons discuté des avantages de l’utilisation de Flask pour le développement web, y compris sa simplicité, sa flexibilité et la facilité d’utilisation. Nous avons également couvert comment mettre en place un environnement de développement, créer des routes, utiliser des modèles, gérer les formulaires et utiliser des extensions comme Flask-SQLAlchemy.

Pour résumer, Flask est une excellente option pour la construction d’applications web de toute taille, depuis de petits projets personnels jusqu’à de grandes applications commerciales. Il est facile à apprendre et à utiliser, mais offre également des fonctionnalités avancées grâce à ses nombreuses extensions.

Si vous êtes intéressé à en savoir plus sur Flask, voici quelques ressources supplémentaires :

• Documentation Flask
• Flask Mega-Tutorial, par Miguel Grinberg
• Flask Web Development, par Miguel Grinberg
• A simple Flask app tutorial
• Tutoriels Flask de Real Python

Si vous souhaitez en savoir plus sur Django et Flask et leurs meilleurs cas d’utilisation, consultez Développement Web avec Python, Django et Flask.

FAQ sur Flask, le Framework Python