社区所有版块导航
Python
python开源   Django   Python   DjangoApp   pycharm  
DATA
docker   Elasticsearch  
aigc
aigc   chatgpt  
WEB开发
linux   MongoDB   Redis   DATABASE   NGINX   其他Web框架   web工具   zookeeper   tornado   NoSql   Bootstrap   js   peewee   Git   bottle   IE   MQ   Jquery  
机器学习
机器学习算法  
Python88.com
反馈   公告   社区推广  
产品
短视频  
印度
印度  
Py学习  »  Python

Python Flask msal示例应用程序移植到FastAPI

Richard • 4 年前 • 2127 次点击  

我没有做太多的网络工作,但我最近开始使用FastAPI,并正在使用jinja2模板构建一个MVC应用程序,该应用程序使用PowerBI嵌入式功能在应用程序中提供多个嵌入式分析数据。所有这些都很好地发挥了作用。然而,我想添加更多的模块,我想使用msal包来进行用户身份验证,方法是将用户路由到Microsoft登录页面,让他们登录我在Azure中设置的多租户应用程序服务,然后通过重定向URI重定向回我的页面,获取令牌,并进行授权。微软为我们保存了一个很好的例子 here 在烧瓶里做这件事。然而,我在将示例移植到FastAPI时遇到了麻烦。

我可以让用户进入登录屏幕并登录,但我无法在回拨URI中捕获令牌——这是正确的路由,但我无法从响应中捕获令牌。

有没有人(或者有人能)把这个超级简单的烧瓶示例移植到FastAPI?我在FAPI网上找到的所有东西都是API的后端令牌承载头,而不是MVC应用。

这是我目前的代码。混乱是因为我有内置的“测试”。

import msal
import requests
from fastapi import APIRouter, Request, Response
from fastapi.responses import RedirectResponse
from starlette.templating import Jinja2Templates

from config import get_settings

settings = get_settings()
router = APIRouter()
templates = Jinja2Templates('templates')


# Works
@router.get('/login', include_in_schema=False)
async def login(request: Request):
    request.session['flow'] = _build_auth_code_flow(scopes=settings.AUTH_SCOPE)
    login_url = request.session['flow']['auth_uri']
    return templates.TemplateResponse('error.html', {'request': request, 'message': login_url})


# DOES NOT WORK - Pretty sure error is in here --------------------
@router.get('/getAToken', response_class=Response, include_in_schema=False)
async def authorize(request: Request):
    try:
        cache = _load_cache(request)
        result = _build_msal_app(cache=cache).acquire_token_by_auth_code_flow(
            request.session.get('flow'), request.session
        )
        if 'error' in result:
            return templates.TemplateResponse('error.html', {'request': request, 'message': result})
        request.session['user'] = result.get('id_token_claims')
        _save_cache(cache)
    except Exception as error:
        return templates.TemplateResponse('error.html', {'request': request, 'message': f'{error}: {str(request.query_params)}'})
    return templates.TemplateResponse('error.html', {'request': request, 'message': result})
# -----------------------------------------------------

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


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


def _build_msal_app(cache=None, authority=None):
    return msal.ConfidentialClientApplication(
        settings.CLIENT_ID,
        authority=authority or settings.AUTH_AUTHORITY,
        client_credential=settings.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=settings.AUTH_REDIRECT)


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

非常感谢您的帮助。乐意回答任何问题。非常感谢。

Python社区是高质量的Python/Django开发社区
本文地址:http://www.python88.com/topic/130921
文章 [ 1 ]  |  最新文章 4 年前
Bran207
Reply   •   1 楼
Bran207    4 年前

这是因为FastAPI会话变量作为cookie存储在客户端,cookie的数据限制为4096字节。从重定向url存储的数据会将cookie大小推过此限制,并导致数据无法存储。 Starlette-session 是另一种SessionMiddleware,它在服务器端存储变量,消除了cookie限制。下面是一个基本的(但混乱的)实现:

from fastapi import FastAPI
from fastapi.templating import Jinja2Templates

from starlette.requests import Request
from starlette.responses import RedirectResponse

from starlette_session import SessionMiddleware
from starlette_session.backends import BackendType

from redis import Redis

import uvicorn
import functools
import msal


app_client_id = "sample_msal_client_id"
app_client_secret = "sample_msal_client_secret"
tenant_id = "sample_msal_tenant_id"

app = FastAPI()


redis_client = Redis(host="localhost", port=6379)
app.add_middleware(
    SessionMiddleware,
    secret_key="SECURE_SECRET_KEY",
    cookie_name="auth_cookie",
    backend_type=BackendType.redis,
    backend_client=redis_client,
)

templates = Jinja2Templates(directory="templates")

default_scope = ["https://graph.microsoft.com/.default"]
token_cache_key = "token_cache"

# Private Functions - Start
def _load_cache(session):
    cache = msal.SerializableTokenCache()
    if session.get(token_cache_key):
        cache.deserialize(session[token_cache_key])
    return cache

def _save_cache(cache,session):
    if cache.has_state_changed:
        session[token_cache_key] = cache.serialize()

def _build_msal_app(cache=None):
    return msal.ConfidentialClientApplication(
        app_client_id, 
        client_credential=app_client_secret,
        authority=f"https://login.microsoftonline.com/{tenant_id}",
        token_cache=cache
    )

def _build_auth_code_flow(request):
    return _build_msal_app().initiate_auth_code_flow(
        default_scope, #Scopes
        redirect_uri=request.url_for("callback") #Redirect URI
    )

def _get_token_from_cache(session):
    cache = _load_cache(session)  # 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(default_scope, account=accounts[0])
        _save_cache(cache,session)
        return result
# Private Functions - End


# Custom Decorators - Start
def authenticated_endpoint(func):
    @functools.wraps(func)
    def is_authenticated(*args,**kwargs):
        try:
            request = kwargs["request"]
            token = _get_token_from_cache(request.session)
            if not token:
                return RedirectResponse(request.url_for("login"))
            return func(*args,**kwargs)
        except:
            return RedirectResponse(request.url_for("login"))

    return is_authenticated
# Custom Decorators - End


# Endpoints - Start
@app.get("/")
@authenticated_endpoint
def index(request:Request):
    return {
        "result": "good"
    }

@app.get("/login")
def login(request:Request):
    return templates.TemplateResponse("login.html",{
        "version": msal.__version__,
        'request': request,
        "config": {
            "B2C_RESET_PASSWORD_AUTHORITY": False
        }
    })

@app.get("/oauth/redirect")
def get_redirect_url(request:Request):
    request.session["flow"] = _build_auth_code_flow(request)
    return RedirectResponse(request.session["flow"]["auth_uri"])

@app.get("/callback")
async def callback(request:Request):
    cache = _load_cache(request.session)
    result = _build_msal_app(cache=cache).acquire_token_by_auth_code_flow(request.session.get("flow", {}), dict(request.query_params))
    if "error" in result:
        return templates.TemplateResponse("auth_error.html",{
            "result": result,
            'request': request
        })
    request.session["user"] = result.get("id_token_claims")
    request.session[token_cache_key] = cache.serialize()
    return RedirectResponse(request.url_for("index"))
# Endpoints - End

if __name__ == "__main__":
    uvicorn.run("main:app",host='0.0.0.0', port=4557,reload=True)`