Udostępnij za pośrednictwem

Włączanie uwierzytelniania we własnej aplikacji internetowej w języku Python przy użyciu usługi Azure Active Directory B2C

Ważne

Od 1 maja 2025 r. usługa Azure AD B2C nie będzie już dostępna do zakupu dla nowych klientów. Dowiedz się więcej w naszych często zadawanych pytaniach.

Z tego artykułu dowiesz się, jak dodać uwierzytelnianie usługi Azure Active Directory B2C (Azure AD B2C) we własnej aplikacji internetowej w języku Python. Umożliwiasz użytkownikom logowanie się, wylogowywanie, aktualizowanie profilu i resetowanie hasła przy użyciu przepływów użytkowników usługi Azure AD B2C. W tym artykule użyto biblioteki Microsoft Authentication Library (MSAL) dla języka Python , aby uprościć dodawanie uwierzytelniania do aplikacji internetowej języka Python.

Celem tego artykułu jest zastąpienie przykładowej aplikacji użytej w temacie Konfigurowanie uwierzytelniania w przykładowej aplikacji internetowej w języku Python przy użyciu usługi Azure AD B2C z własną aplikacją języka Python.

W tym artykule tworzysz podstawową aplikację internetową przy użyciu języków Python 3.9+ i Flask 2.1 . Widoki aplikacji używają szablonów Jinja2.

Wymagania wstępne

Krok 1. Tworzenie projektu języka Python

  1. W systemie plików utwórz folder projektu dla tego samouczka, na przykład my-python-web-app.

  2. W terminalu zmień katalog na folder aplikacji języka Python, taki jak cd my-python-web-app.

  3. Uruchom następujące polecenie, aby utworzyć i aktywować środowisko wirtualne o nazwie .venv na podstawie bieżącego interpretera.

    sudo apt-get install python3-venv  # If needed
python3 -m venv .venv
source .venv/bin/activate

  4. Zaktualizuj pip w środowisku wirtualnym, uruchamiając następujące polecenie w terminalu:

    python -m pip install --upgrade pip

  5. Aby włączyć funkcje debugowania aplikacji Flask, przełącz ją na tryb środowiska deweloperskiego development. Aby uzyskać więcej informacji na temat debugowania aplikacji Platformy Flask, zapoznaj się z dokumentacją platformy Flask.

    export FLASK_ENV=development

  6. Otwórz folder projektu w programie VS Code, uruchamiając code . polecenie lub otwierając program VS Code i wybierając plik>Otwórz folder.

Krok 2. Instalowanie zależności aplikacji

W folderze głównym aplikacji internetowej utwórz requirements.txt plik. Plik wymagań zawiera pakiety do zainstalowania za pomocą polecenia pip install. Dodaj następującą zawartość do pliku requirements.txt:

Flask>=2
werkzeug>=2

flask-session>=0.3.2,<0.5
requests>=2,<3
msal>=1.7,<2

W terminalu zainstaluj zależności, uruchamiając następujące polecenia:

python -m pip install -r requirements.txt

Krok 3. Kompilowanie składników interfejsu użytkownika aplikacji

Platforma Flask to uproszczona struktura języka Python dla aplikacji internetowych, która udostępnia podstawowe informacje na potrzeby routingu adresów URL i renderowania stron. Używa on Jinja2 jako silnika szablonów do renderowania zawartości aplikacji. Aby uzyskać więcej informacji, zapoznaj się z dokumentacją projektanta szablonów. W tej sekcji dodasz wymagane szablony, które zapewniają podstawową funkcjonalność aplikacji internetowej.

Krok 3.1. Tworzenie szablonu podstawowego

Szablon strony podstawowej na platformie Flask zawiera wszystkie udostępnione części zestawu stron, w tym odwołania do plików CSS, plików skryptów itd. Szablony podstawowe definiują również jeden lub więcej tagów blokowych, które mają zastąpić inne szablony rozszerzające bazę. Tag bloku jest określony przez {% block <name> %} i {% endblock %} zarówno w szablonie podstawowym, jak i rozszerzonym.

W folderze głównym aplikacji internetowej utwórz templates folder . W folderze templates utwórz plik o nazwie base.html, a następnie dodaj poniższą zawartość:

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    {% block metadata %}{% endblock %}

    <title>{% block title %}{% endblock %}</title>
    <!-- Bootstrap CSS file reference -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.0-beta1/dist/css/bootstrap.min.css" rel="stylesheet"
        integrity="sha384-0evHe/X+R7YkIZDRvuzKMRqM+OrBnVFBL6DOitfPri4tjfHxaWutUpFmBp4vmVor" crossorigin="anonymous">
</head>

<body>
    <nav class="navbar navbar-expand-lg navbar-dark bg-dark">
        <div class="container-fluid">
            <a class="navbar-brand" href="{{ url_for('index')}}">Python Flask demo</a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse"
                data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false"
                aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>
            <div class="collapse navbar-collapse" id="navbarSupportedContent">
                <ul class="navbar-nav me-auto mb-2 mb-lg-0">
                    <li class="nav-item">
                        <a class="nav-link active" aria-current="page" href="{{ url_for('index')}}">Home</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link" href="{{ url_for('graphcall')}}">Graph API</a>
                    </li>
                </ul>
            </div>
        </div>
    </nav>

    <div class="container body-content">
        <br />
        {% block content %}
        {% endblock %}

        <hr />
        <footer>
            <p>Powered by MSAL Python {{ version }}</p>
        </footer>
    </div>
</body>

</html>

Krok 3.2. Tworzenie szablonów aplikacji internetowych

Dodaj następujące szablony w folderze templates. Te szablony rozszerzają base.html szablon:

  • index.html: strona główna aplikacji internetowej. Szablony używają następującej logiki: jeśli użytkownik nie zaloguje się, renderuje przycisk logowania. Jeśli użytkownik się zaloguje, renderuje oświadczenia tokenu dostępu, link do edycji profilu i wywoła interfejs API programu Graph.

    {% extends "base.html" %}
{% block title %}Home{% endblock %}
{% block content %}

<h1>Microsoft Identity Python Web App</h1>

{% if user %}
<h2>Claims:</h2>
<pre>{{ user |tojson(indent=4) }}</pre>


{% if config.get("ENDPOINT") %}
<li><a href='/graphcall'>Call Microsoft Graph API</a></li>
{% endif %}

{% if config.get("B2C_PROFILE_AUTHORITY") %}
<li><a href='{{_build_auth_code_flow(authority=config["B2C_PROFILE_AUTHORITY"])["auth_uri"]}}'>Edit Profile</a></li>
{% endif %}

<li><a href="/logout">Logout</a></li>

{% else %}
<li><a href='{{ auth_url }}'>Sign In</a></li>
{% endif %}

{% endblock %}

  • graph.html: demonstruje sposób wywoływania interfejsu API REST.

    {% extends "base.html" %}
{% block title %}Graph API{% endblock %}
{% block content %}
<a href="javascript:window.history.go(-1)">Back</a>
<!-- Displayed on top of a potentially large JSON response, so it will remain visible -->
<h1>Graph API Call Result</h1>
<pre>{{ result |tojson(indent=4) }}</pre> <!-- Just a generic json viewer -->
{% endblock %}

  • auth_error.html: obsługuje błędy uwierzytelniania.

    {% extends "base.html" %}
{% block title%}Error{% endblock%}

{% block metadata %}
{% if config.get("B2C_RESET_PASSWORD_AUTHORITY") and "AADB2C90118" in result.get("error_description") %}
<!-- See also https://learn.microsoft.com/azure/active-directory-b2c/active-directory-b2c-reference-policies#linking-user-flows -->
<meta http-equiv="refresh"
  content='0;{{_build_auth_code_flow(authority=config["B2C_RESET_PASSWORD_AUTHORITY"])["auth_uri"]}}'>
{% endif %}
{% endblock %}

{% block content %}
<h2>Login Failure</h2>
<dl>
  <dt>{{ result.get("error") }}</dt>
  <dd>{{ result.get("error_description") }}</dd>
</dl>

<a href="{{ url_for('index') }}">Homepage</a>
{% endblock %}

Krok 4. Konfigurowanie aplikacji internetowej

W folderze głównym aplikacji internetowej utwórz plik o nazwie app_config.py. Ten plik zawiera informacje o dostawcy tożsamości usługi Azure AD B2C. Aplikacja internetowa używa tych informacji do ustanawiania relacji zaufania z usługą Azure AD B2C, logowania użytkowników i wylogowywanie ich, uzyskiwanie tokenów i ich weryfikowanie. Dodaj następującą zawartość do pliku:

import os

b2c_tenant = "fabrikamb2c"
signupsignin_user_flow = "B2C_1_signupsignin1"
editprofile_user_flow = "B2C_1_profileediting1"

resetpassword_user_flow = "B2C_1_passwordreset1"  # Note: Legacy setting.

authority_template = "https://{tenant}.b2clogin.com/{tenant}.onmicrosoft.com/{user_flow}"

CLIENT_ID = "Enter_the_Application_Id_here" # Application (client) ID of app registration

CLIENT_SECRET = "Enter_the_Client_Secret_Here" # Application secret.

AUTHORITY = authority_template.format(
    tenant=b2c_tenant, user_flow=signupsignin_user_flow)
B2C_PROFILE_AUTHORITY = authority_template.format(
    tenant=b2c_tenant, user_flow=editprofile_user_flow)

B2C_RESET_PASSWORD_AUTHORITY = authority_template.format(
    tenant=b2c_tenant, user_flow=resetpassword_user_flow)

REDIRECT_PATH = "/getAToken"

# This is the API resource endpoint
ENDPOINT = '' # Application ID URI of app registration in Azure portal

# These are the scopes you've exposed in the web API app registration in the Azure portal
SCOPE = []  # Example with two exposed scopes: ["demo.read", "demo.write"]

SESSION_TYPE = "filesystem"  # Specifies the token cache should be stored in server-side session

Zaktualizuj powyższy kod przy użyciu ustawień środowiska usługi Azure AD B2C, jak wyjaśniono w sekcji Konfigurowanie przykładowej aplikacji internetowej w artykule Konfigurowanie uwierzytelniania w przykładowej aplikacji internetowej w języku Python .

Krok 5. Dodawanie kodu aplikacji internetowej

W tej sekcji dodasz funkcje widoku Flask i metody uwierzytelniania biblioteki MSAL. W folderze głównym projektu dodaj plik o nazwie app.py z następującym kodem:

import uuid
import requests
from flask import Flask, render_template, session, request, redirect, url_for
from flask_session import Session  # https://pythonhosted.org/Flask-Session
import msal
import app_config


app = Flask(__name__)
app.config.from_object(app_config)
Session(app)

# This section is needed for url_for("foo", _external=True) to automatically
# generate http scheme when this sample is running on localhost,
# and to generate https scheme when it is deployed behind reversed proxy.
# See also https://flask.palletsprojects.com/en/1.0.x/deploying/wsgi-standalone/#proxy-setups
from werkzeug.middleware.proxy_fix import ProxyFix
app.wsgi_app = ProxyFix(app.wsgi_app, x_proto=1, x_host=1)


@app.route("/anonymous")
def anonymous():
    return "anonymous page"

@app.route("/")
def index():
    #if not session.get("user"):
    #    return redirect(url_for("login"))

    if not session.get("user"):
        session["flow"] = _build_auth_code_flow(scopes=app_config.SCOPE)
        return render_template('index.html', auth_url=session["flow"]["auth_uri"], version=msal.__version__)
    else:
        return render_template('index.html', user=session["user"], version=msal.__version__)

@app.route("/login")
def login():
    # Technically we could use empty list [] as scopes to do just sign in,
    # here we choose to also collect end user consent upfront
    session["flow"] = _build_auth_code_flow(scopes=app_config.SCOPE)
    return render_template("login.html", auth_url=session["flow"]["auth_uri"], version=msal.__version__)

@app.route(app_config.REDIRECT_PATH)  # Its absolute URL must match your app's redirect_uri set in AAD
def authorized():
    try:
        cache = _load_cache()
        result = _build_msal_app(cache=cache).acquire_token_by_auth_code_flow(
            session.get("flow", {}), request.args)
        if "error" in result:
            return render_template("auth_error.html", result=result)
        session["user"] = result.get("id_token_claims")
        _save_cache(cache)
    except ValueError:  # Usually caused by CSRF
        pass  # Simply ignore them
    return redirect(url_for("index"))

@app.route("/logout")
def logout():
    session.clear()  # Wipe out user and its token cache from session
    return redirect(  # Also logout from your tenant's web session
        app_config.AUTHORITY + "/oauth2/v2.0/logout" +
        "?post_logout_redirect_uri=" + url_for("index", _external=True))

@app.route("/graphcall")
def graphcall():
    token = _get_token_from_cache(app_config.SCOPE)
    if not token:
        return redirect(url_for("login"))
    graph_data = requests.get(  # Use token to call downstream service
        app_config.ENDPOINT,
        headers={'Authorization': 'Bearer ' + token['access_token']},
        ).json()
    return render_template('graph.html', result=graph_data)


def _load_cache():
    cache = msal.SerializableTokenCache()
    if session.get("token_cache"):
        cache.deserialize(session["token_cache"])
    return cache

def _save_cache(cache):
    if cache.has_state_changed:
        session["token_cache"] = cache.serialize()

def _build_msal_app(cache=None, authority=None):
    return msal.ConfidentialClientApplication(
        app_config.CLIENT_ID, authority=authority or app_config.AUTHORITY,
        client_credential=app_config.CLIENT_SECRET, token_cache=cache)

def _build_auth_code_flow(authority=None, scopes=None):
    return _build_msal_app(authority=authority).initiate_auth_code_flow(
        scopes or [],
        redirect_uri=url_for("authorized", _external=True))

def _get_token_from_cache(scope=None):
    cache = _load_cache()  # This web app maintains one cache per session
    cca = _build_msal_app(cache=cache)
    accounts = cca.get_accounts()
    if accounts:  # So all account(s) belong to the current signed-in user
        result = cca.acquire_token_silent(scope, account=accounts[0])
        _save_cache(cache)
        return result

app.jinja_env.globals.update(_build_auth_code_flow=_build_auth_code_flow)  # Used in template

if __name__ == "__main__":
    app.run()

Krok 6. Uruchamianie aplikacji internetowej

W terminalu uruchom aplikację, wprowadzając następujące polecenie, które uruchamia serwer deweloperski platformy Flask. Serwer deweloperski szuka app.py domyślnie. Następnie otwórz przeglądarkę i przejdź do adresu URL aplikacji internetowej: http://localhost:5000.

python -m flask run --host localhost --port 5000

[Opcjonalnie] Debugowanie aplikacji

Funkcja debugowania umożliwia wstrzymanie uruchomionego programu w określonym wierszu kodu. W przypadku wstrzymania programu można sprawdzić zmienne, uruchomić kod w panelu Konsola debugowania, a w przeciwnym razie skorzystać z funkcji opisanych w temacie Debugowanie. Aby użyć debugera programu Visual Studio Code, zapoznaj się z dokumentacją programu VS Code.

Aby zmienić nazwę hosta i/lub numer portu, użyj args tablicy launch.json pliku. W poniższym przykładzie pokazano, jak skonfigurować nazwę hosta na localhost i numer portu na 5001. Pamiętaj, że jeśli zmienisz nazwę hosta lub numer portu, musisz zaktualizować identyfikator URI przekierowania lub aplikację. Aby uzyskać więcej informacji, zapoznaj się z krokiem Rejestrowanie aplikacji internetowej .

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Flask",
            "type": "python",
            "request": "launch",
            "module": "flask",
            "env": {
                "FLASK_APP": "app.py",
                "FLASK_ENV": "development"
            },
            "args": [
                "run",
                "--host=localhost",
                "--port=5001"
            ],
            "jinja": true,
            "justMyCode": true
        }
    ]
}

Treści powiązane

  • Last updated on