Tutoriel : Ajouter une connexion à une application web Python Flask
Ce tutoriel est la troisième partie d’une série de tutoriels qui montre comment créer une application web Python Flask à partir de zéro et intégrer l’authentification à l’aide de la plateforme d’identités Microsoft. Dans ce tutoriel, vous ajoutez du code pour authentifier les utilisateurs dans l’application que vous avez créée.
- Importer les modules et la configuration requis
- Créer une instance d’une application web Flask
- Configurer l’intergiciel ProxyFix pour le développement local
- Ajouter du code pour se connecter et déconnecter des utilisateurs
- Définir un point d’entrée pour l’application web
Importer les packages et configurations requis
L’application web que vous créez utilise le package identity.web basé sur MSAL Python pour authentifier les utilisateurs dans les applications web. Pour importer le package identity.web, l’infrastructure Flask, les modules Flask, la session Flask et les configurations d’application définies dans le didacticiel précédent, ajoutez le code suivant à app.py:
import identity.web
import requests
from flask import Flask, redirect, render_template, request, session, url_for
from flask_session import Session
import app_config
Dans cet extrait de code, vous importez les redirect, render_template, request, sessionet url_for: fonctions et objets pour la gestion des requêtes et sessions web dans Flask. Vous importez également app_config, qui contient les paramètres de configuration de votre application.
Créer une instance de l’application web Flask
Après avoir importé les modules requis, nous initialisons l’application web à l’aide des configurations dans app-config. Pour créer une instance de votre application web, ajoutez l’extrait de code suivant à app.py:
app = Flask(__name__)
app.config.from_object(app_config)
assert app.config["REDIRECT_PATH"] != "/", "REDIRECT_PATH must not be /"
Session(app)
Dans l’extrait de code ci-dessus, vous initialisez une nouvelle application Flask et chargez les paramètres de configuration à l’aide de app.config.from_object(app_config). En utilisant from_object, l’application hérite des configurations spécifiées dans (app_config).
Vous effectuez également une vérification d’assertion pour vous assurer que le chemin de redirection de votre application n’est pas défini sur le chemin racine (« / »). Session(app) initialise la gestion des sessions pour votre application, ce qui vous permet de gérer des sessions et de stocker des données telles que des états d’authentification utilisateur sur plusieurs requêtes.
Configurer l’intergiciel ProxyFix pour le développement local
Étant donné que l’exemple d’application web s’exécute sur l’hôte local, nous utilisons le middleware ProxyFix pour corriger le schéma d’URL et les informations d’hôte dans les en-têtes de requête. Ajoutez le code suivant à app.py pour appliquer ProxyFix :
from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)
Initialiser un objet d’authentification
Ensuite, vous initialisez un objet d’authentification en créant une instance de la classe identity.web.Auth. Vous transmettez également les paramètres session, authority, client_idet client_credential dans le constructeur lors de l’initialisation de l’objet Auth, comme suit :
app.jinja_env.globals.update(Auth=identity.web.Auth) # Useful in template for B2C
auth = identity.web.Auth(
session=session,
authority=app.config["AUTHORITY"],
client_id=app.config["CLIENT_ID"],
client_credential=app.config["CLIENT_SECRET"],
)
Dans cet extrait de code, app.jinja_env.globals.update(Auth=identity.web.Auth)ajoute une nouvelle variable globale nommée Auth et lui affecte la valeur de identity.web.Auth. Cela rend Authaccessible dans tous les modèles rendus par l’application Flask.
Connexion des utilisateurs
Le flux d’autorisation que vous générez dans cette application se compose de deux jambes. Dans la première étape, vous appelez la fonction auth.log_in pour connecter des utilisateurs, comme indiqué :
@app.route("/login")
def login():
return render_template("login.html", version=__version__, **auth.log_in(
scopes=app_config.SCOPE, # Have user consent to scopes during log-in
redirect_uri=url_for("auth_response", _external=True), # Optional. If present, this absolute URL must match your app's redirect_uri registered in Microsoft Entra admin center
prompt="select_account", # Optional.
))
Lorsqu’un utilisateur accède à l’URL /login dans votre application, Flask appelle la fonction d’affichage qui gère la requête pour afficher le modèle login.html. Dans login(), vous appelez la fonction auth.log_in avec une liste d’étendues auxquelles l’utilisateur doit donner son consentement pendant le processus de connexion. Vous fournissez également redirect_uri comme paramètre, qui doit correspondre à l’URI de redirection de l’application dans le Centre d’administration Microsoft Azure.
Vous pouvez éventuellement ajouter des paramètres tels que prompt, qui contrôle le comportement de l’invite de connexion en demandant une réauthentification, un consentement utilisateur ou une sélection de compte parmi les comptes avec des sessions actives.
Dans la deuxième étape du flux d’autorisation, vous gérez la réponse d’authentification en appelant la fonction auth.complete_log_in à l’intérieur du contrôleur redirect_uri, comme indiqué :
@app.route(app_config.REDIRECT_PATH)
def auth_response():
result = auth.complete_log_in(request.args)
if "error" in result:
return render_template("auth_error.html", result=result)
return redirect(url_for("index"))
La fonction complete_log_in() prend le dictionnaire auth_response entrant en tant que paramètres de la requête. Si elle réussit, la fonction redirige l’utilisateur vers l’itinéraire « index » à l’aide de redirect(url_for("index")). Cela signifie que l’utilisateur s'est connecté avec succès et que ses informations sont disponibles sous la forme d'un dictionnaire contenant des données issues d’un jeton d’identification déjà validé.
Si le résultat contient une erreur telle que déterminée par la condition if "error" in result:, affichez le modèle "auth_error.html" à l’utilisateur.
Déconnecter les utilisateurs
Pour déconnecter les utilisateurs de votre application Flask, appelez la méthode auth.log_out() comme suit :
@app.route("/logout")
def logout():
return redirect(auth.log_out(url_for("index", _external=True)))
Lorsqu’un utilisateur accède à l’itinéraire d’URL /logout dans l’application, Flask appelle la fonction de déconnexion qui les déconnecte de l’application actuelle. Vous spécifiez également la page vers laquelle les utilisateurs doivent être redirigés lors de la déconnexion. Dans l’extrait de code, nous redirigeons les utilisateurs vers la page d’accueil de l’application à l’aide de url_for("index", _external=True).
Définir un point d’entrée pour l’application web
Après avoir implémenté la logique de connexion et de déconnexion, ajoutez un point d’entrée à la page d’accueil de votre application en créant la fonction index() comme suit :
@app.route("/")
def index():
if not (app.config["CLIENT_ID"] and app.config["CLIENT_SECRET"]):
# This check is not strictly necessary.
# You can remove this check from your production code.
return render_template('config_error.html')
if not auth.get_user():
return redirect(url_for("login"))
return render_template('index.html', user=auth.get_user(), version=__version__)
La fonction index() est appelée lorsqu’un utilisateur accède à l’URL racine de l’application(« / »). Il gère les vérifications de configuration et valide l’authentification de l’utilisateur avant de rendre la page d’accueil de l’application. Elle vérifie si l’ID client et la clé secrète client sont manquants dans la configuration, et si les deux valeurs sont manquantes, Flask affiche le modèle "config_error.html".
La fonction appelle également auth.get_user() pour vérifier si l’utilisateur est authentifié ou non. Si l’utilisateur n’est pas authentifié, il les redirige vers l’itinéraire "login". S’il est authentifié, Flask affiche le modèle «index.html» et transmet l’objet utilisateur (récupéré à partir de auth.get_user()) pour le rendu.