Delen via

Zelfstudie: Aanmelden toevoegen aan een Python Flask-web-app

  • Artikel

Deze zelfstudie is het derde deel van een reeks zelfstudies die laat zien hoe u een volledig nieuwe Python Flask-web-app bouwt en verificatie integreert met behulp van het Microsoft Identity Platform. In deze zelfstudie voegt u code toe om gebruikers te verifiëren in de app die u hebt gebouwd.

  • De vereiste modules en configuratie importeren
  • Een exemplaar van een Flask-web-app maken
  • ProxyFix-middleware configureren voor lokale ontwikkeling
  • Code toevoegen om gebruikers aan te melden en af te melden
  • Een toegangspunt voor de web-app definiëren

Vereiste pakketten en configuraties importeren

De web-app die u bouwt, maakt gebruik van het identity.web pakket dat is gebouwd op MSAL Python om gebruikers in web-apps te verifiëren. Als u het identity.web pakket, Flask Framework, Flask-modules, Flask-sessie en de app-configuraties die in de vorige zelfstudie zijn gedefinieerd, wilt importeren, voegt u de volgende code toe aan 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

In dit codefragment importeert u de functies en render_templaterequestsessionurl_forobjecten voor het redirectverwerken van webaanvragen en -sessies in Flask. U importeert app_configook, dat de configuratie-instellingen voor uw app bevat.

Een exemplaar van de Flask-web-app maken

Na het importeren van de vereiste modules initialiseren we de web-app met behulp van de configuraties in app-config. Als u een exemplaar van uw web-app wilt maken, voegt u het volgende codefragment toe aan app.py:

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

In het bovenstaande codefragment initialiseert u een nieuwe Flask-toepassing en laadt u de configuratie-instellingen met behulp van app.config.from_object(app_config). Met behulp van from_object, neemt de app de configuraties over van de opgegeven in (app_config).

U voert ook een assertiecontrole uit om ervoor te zorgen dat het omleidingspad van uw app niet is ingesteld op het hoofdpad ("/"). Session(app) initialiseert sessiebeheer voor uw app, waarmee u sessies kunt afhandelen en gegevens kunt opslaan, zoals gebruikersverificatiestatussen voor meerdere aanvragen.

ProxyFix-middleware configureren voor lokale ontwikkeling

Omdat de voorbeeldweb-app wordt uitgevoerd op de lokale host, gebruiken we de ProxyFix middleware om het URL-schema en hostgegevens in de aanvraagheaders op te lossen. Voeg de volgende code toe om ProxyFix toe te app.py passen:

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

Een verificatieobject initialiseren

Vervolgens initialiseert u een verificatieobject door een exemplaar van de [identity.web.Auth](https://identity-library.readthedocs.io/en/latest/#identity.web.Auth) klasse te maken. U geeft ook de parameterssession, authorityen client_idclient_credential in de constructor door bij het initialiseren van het verificatieobject, als volgt:

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

In dit codefragment app.jinja_env.globals.update(Auth=identity.web.Auth)voegt u een nieuwe globale variabele toe met de naam Auth en wijst u deze de waarde toe van identity.web.Auth. Dit maakt Authtoegankelijk in alle sjablonen die worden weergegeven door de Flask-toepassing.

Gebruikers aanmelden

De autorisatiestroom die u in deze app bouwt, bestaat uit twee benen. In het eerste deel roept u de auth.log_in functie aan om gebruikers aan te melden, zoals wordt weergegeven:

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

Wanneer een gebruiker naar de /login URL in uw app navigeert, roept Flask de weergavefunctie aan waarmee de aanvraag wordt verwerkt om de login.html sjabloon weer te geven. Binnen login()roept u de auth.log_in functie aan met een lijst met bereiken waarvoor de gebruiker toestemming moet geven tijdens het aanmeldingsproces. U geeft redirect_uri ook de parameters op, die overeenkomen met de omleidings-URI van de app in het Microsoft Azure-beheercentrum.

U kunt eventueel parameters toevoegen, zoals prompt, waarmee het gedrag van de aanmeldingsprompt wordt bepaald door opnieuw te verifiëren, gebruikerstoestemming of accountselectie tussen accounts met actieve sessies aan te vragen.

In het tweede deel van de autorisatiestroom verwerkt u het verificatieantwoord door de auth.complete_log_in functie in de redirect_uri controller aan te roepen, zoals wordt weergegeven:

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

De complete_log_in() functie neemt de binnenkomende auth_response woordenlijst in als de queryparameters. Als dit lukt, wordt de gebruiker door de functie omgeleid naar de 'index'-route met behulp van redirect(url_for("index")). Dit betekent dat de gebruiker zijn gegevens heeft aangemeld als een woordenlijst met claims van een al gevalideerd id-token.

Als het resultaat een fout bevat zoals bepaald door de voorwaarde if "error" in result:, geeft u de "auth_error.html" sjabloon weer aan de gebruiker.

Gebruikers afmelden

Als u gebruikers wilt afmelden bij uw Flask-toepassing, roept u de auth.log_out() methode als volgt aan:

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

Wanneer een gebruiker naar de /logout URL-route in de app navigeert, roept Flask de afmeldingsfunctie aan waarmee deze worden afgemeld bij de huidige app. U geeft ook de pagina op waarnaar gebruikers moeten worden omgeleid bij het afmelden. In het codefragment leiden we gebruikers om naar de startpagina van de app met behulp van url_for("index", _external=True).

Een toegangspunt voor de web-app definiëren

Nadat u de logica voor aanmelden en afmelden hebt geïmplementeerd, voegt u een toegangspunt toe aan de startpagina van uw app door de index() functie als volgt te maken:

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

De index() functie wordt aangeroepen wanneer een gebruiker naar de hoofd-URL van de app navigeert("/"). Het verwerkt configuratiecontroles en valideert gebruikersverificatie voordat de startpagina van de app wordt weergegeven. Er wordt gecontroleerd of de client-id en het clientgeheim ontbreken in de configuratie en of er een of beide waarden ontbreken, geeft Flask de "config_error.html" sjabloon weer.

De functie roept auth.get_user() ook aan om te controleren of de gebruiker is geverifieerd of niet. Als de gebruiker niet is geverifieerd, wordt deze omgeleid naar de "login" route. Indien geverifieerd, geeft Flask de sjabloon 'index.html' weer en geeft het gebruikersobject (opgehaald uit auth.get_user()) door voor rendering.

Volgende stappen

Zelfstudie: Een beveiligde API aanroepen en de resultaten weergeven in een Python Flask-web-app