Dela via

Självstudie: Lägga till inloggning i en Python Flask-webbapp

  • Artikel

Den här självstudien är den tredje delen i en självstudieserie som visar hur du skapar en Python Flask-webbapp från grunden och integrerar autentisering med hjälp av Microsofts identitetsplattform. I den här självstudien lägger du till kod för att autentisera användare i den app som du skapade.

  • Importera nödvändiga moduler och konfigurationer
  • Skapa en instans av en Flask-webbapp
  • Konfigurera ProxyFix-mellanprogram för lokal utveckling
  • Lägga till kod för att logga in och logga ut användare
  • Definiera en startpunkt för webbappen

Importera nödvändiga paket och konfigurationer

Webbappen som du skapar använder paketet som bygger på MSAL Python för att autentisera identity.web användare i webbappar. Om du vill importera identity.web paketet, Flask Framework, Flask-moduler, Flask-sessionen och appkonfigurationerna som definierades i föregående självstudie lägger du till följande kod i 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

I det här kodfragmentet importerar redirectdu funktionerna , render_template, request, sessionoch url_for: och : för hantering av webbbegäranden och sessioner i Flask. Du importerar app_configockså , som innehåller konfigurationsinställningarna för din app.

Skapa en instans av Flask-webbappen

När du har importerat de moduler som krävs initierar vi webbappen med hjälp av konfigurationerna i app-config. Om du vill skapa en instans av webbappen lägger du till följande kodfragment i app.py:

app = Flask(__name__)
app.config.from_object(app_config)
assert app.config["REDIRECT_PATH"] != "/", "REDIRECT_PATH must not be /"
Session(app)

I kodfragmentet ovan initierar du ett nytt Flask-program och läser in konfigurationsinställningarna med hjälp av app.config.from_object(app_config). Med hjälp from_objectav ärver appen konfigurationerna från angiven i (app_config).

Du utför också en kontroll för att säkerställa att omdirigeringssökvägen för din app inte är inställd på rotsökvägen ("/"). Session(app) initierar sessionshantering för din app, vilket gör att du kan hantera sessioner och lagra data, till exempel användarautentiseringstillstånd för flera begäranden.

Konfigurera ProxyFix-mellanprogram för lokal utveckling

Eftersom exempelwebbappen körs på den ProxyFix lokala värden använder vi mellanprogrammet för att åtgärda URL-schemat och värdinformationen i begäranderubrikerna. Lägg till följande kod för att app.py tillämpa ProxyFix:

from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)

Initiera ett autentiseringsobjekt

Sedan initierar du ett autentiseringsobjekt genom att skapa en instans av [identity.web.Auth](https://identity-library.readthedocs.io/en/latest/#identity.web.Auth) klassen. Du skickar även parametrarna session, authority, client_idoch client_credential i konstruktorn när du initierar Auth-objektet enligt följande:

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"],
)

I det här kodfragmentet app.jinja_env.globals.update(Auth=identity.web.Auth)lägger du till en ny global variabel med namnet Auth och tilldelar den värdet identity.web.Auth. Detta gör Authdet tillgängligt i alla mallar som återges av Flask-programmet.

Logga in användare

Auktoriseringsflödet som du skapar i den här appen består av två ben. I den första delen anropar auth.log_in du funktionen för att logga in användare, enligt följande:

@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.
        ))

När en användare navigerar till /login URL:en i din app anropar Flask den vyfunktion som hanterar begäran om att återge mallen login.html . I login()anropar auth.log_in du funktionen med en lista över omfång som användaren bör godkänna under inloggningsprocessen. Du anger redirect_uri även i parametrarna, som ska matcha appens omdirigerings-URI i administrationscentret för Microsoft Azure.

Du kan också lägga till parametrar som prompt, som styr beteendet för loggen i prompten genom att begära omautentisering, användarmedgivande eller val av konto bland konton med aktiva sessioner.

I den andra delen av auktoriseringsflödet hanterar du autentiseringssvaret genom att anropa auth.complete_log_in funktionen i den redirect_uri kontrollanten, enligt följande:

@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"))

Funktionen complete_log_in() använder den inkommande auth_response ordlistan som frågeparametrar. Om det lyckas omdirigerar funktionen användaren till "index"-vägen med hjälp av redirect(url_for("index")). Det innebär att användaren har loggat in sin information är tillgänglig som en ordlista som innehåller anspråk från en redan verifierad ID-token.

Om resultatet innehåller ett fel som bestäms av villkoret if "error" in result:återger du mallen "auth_error.html" till användaren.

Logga ut användare

Om du vill logga ut användare från flaskprogrammet anropar du metoden på auth.log_out() följande sätt:

@app.route("/logout")
def logout():
    return redirect(auth.log_out(url_for("index", _external=True)))

När en användare navigerar till /logout URL-vägen i appen anropar Flask utloggningsfunktionen som loggar ut dem från den aktuella appen. Du anger också den sida som användarna ska omdirigeras till när de loggar ut. I kodfragmentet omdirigerar vi användare till appens startsida med hjälp av url_for("index", _external=True).

Definiera en startpunkt för webbappen

När du har implementerat inloggnings- och utloggningslogik lägger du till en startpunkt på appens startsida genom att skapa funktionen på index() följande sätt:

@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__)

Funktionen index() anropas när en användare navigerar till appens rot-URL("/"). Den hanterar konfigurationskontroller och validerar användarautentisering innan appens startsida återges. Den kontrollerar om klient-ID och klienthemlighet saknas i konfigurationen, och om något av eller båda värdena saknas renderar Flask mallen "config_error.html" .

Funktionen anropar auth.get_user() också för att kontrollera om användaren är autentiserad eller inte. Om användaren inte autentiseras omdirigeras de till "login" vägen. Om den autentiseras renderar Flask mallen "index.html" och skickar användarobjektet (hämtat från auth.get_user()) för återgivning.

Nästa steg

Självstudie: Anropa ett skyddat API och visa resultatet i en Python Flask-webbapp