종속성 주입을 통한 FastAPI 인증

FastAPI는 Python으로 API를 구축하기 위한 최신 웹 프레임워크입니다. OpenAPI 사양을 기본적으로 지원하고(즉, 백엔드 코드를 작성하고 여기에서 모든 것을 생성할 수 있음) 종속성 주입을 지원하므로 제가 개인적으로 가장 좋아하는 웹 프레임워크 중 하나입니다.

이번 게시물에서는 FastAPI의 종속성이 어떻게 작동하는지 간략하게 살펴보겠습니다. 그런 다음 인증 및 승인에 왜 그렇게 잘 적용되는지 살펴보겠습니다. 또한 이를 인증의 또 다른 일반적인 옵션인 미들웨어와 대조해 보겠습니다. 마지막으로 FastAPI의 인증에 대한 몇 가지 고급 패턴을 살펴보겠습니다.

의존성 주입이란 무엇인가요?

FastAPI의 더욱 강력한 기능 중 하나는 종속성 주입에 대한 최고 수준의 지원입니다. 여기에 더 긴 가이드가 있습니다. 사용 방법에 대한 간단한 예를 살펴보겠습니다.

페이지가 매겨진 API를 구축한다고 가정해 보겠습니다. 각 API 호출에는 page_number 및 page_size가 포함될 수 있습니다. 이제 API를 생성하고 다음 매개변수를 직접 가져올 수 있습니다.

@app.get("/things/")
async def fetch_things(page_number: int = 0, page_size: int = 100):
    return db.fetch_things(page_number, page_size)

하지만 아무도 page_number -1 또는 page_size 10,000,000을 요구하지 않도록 몇 가지 유효성 검사 논리를 추가하고 싶을 것입니다.

@app.get("/things/")
async def fetch_things(page_number: int = 0, page_size: int = 100):
    if page_number < 0:
        raise HTTPException(status_code=400, detail="Invalid page number")
    elif page_size <= 0:
        raise HTTPException(status_code=400, detail="Invalid page size")
    elif page_size > 100:
        raise HTTPException(status_code=400, detail="Page size can be at most 100")
    return db.fetch_things(page_number, page_size)

이건... 괜찮습니다. 하지만 모두 동일한 페이징 매개변수가 필요한 10개의 API 또는 100개의 API가 있다면 약간 지루할 것입니다. 여기서 종속성 주입이 시작됩니다. 이 모든 논리를 함수로 이동하고 해당 함수를 API에 주입할 수 있습니다.

async def paging_params_dep(page_number: int = 0, page_size: int = 100):
    if page_number < 0:
        raise HTTPException(status_code=400, detail="Invalid page number")
    elif page_size <= 0:
        raise HTTPException(status_code=400, detail="Invalid page size")
    elif page_size > 100:
        raise HTTPException(status_code=400, detail="Page size can be at most 100")
    return PagingParams(page_number, page_size)

@app.get("/things/")
async def fetch_things(paging_params: PagingParams = Depends(paging_params_dep)):
    return db.fetch_things(paging_params)

@app.get("/other_things/")
async def fetch_other_things(paging_params: PagingParams = Depends(paging_params_dep)):
    return db.fetch_other_things(paging_params)

여기에는 몇 가지 좋은 이점이 있습니다.

• PagingParams를 사용하는 각 경로는 자동으로 검증되며 기본값이 있습니다.

• 각 경로의 첫 번째 줄을 verify_paging_params(page_number, page_size)로 지정하는 것보다 덜 장황하고 오류가 발생하기 쉽습니다.

• 이는 여전히 FastAPI의 OpenAPI 지원과 함께 작동합니다. 해당 매개변수는 OpenAPI 사양에 표시됩니다.

이것이 인증과 어떤 관련이 있나요?

이것은 모델 인증을 위한 좋은 방법이기도 합니다! 다음과 같은 기능이 있다고 상상해 보세요.

async def validate_token(token: str):
    try:
        # This could be JWT validation, looking up a session token in the DB, etc.
        return await get_user_for_token(token)
    except:
        return None

이를 API 경로에 연결하려면 종속성으로 래핑하기만 하면 됩니다.

async def require_valid_token_dep(req: Request):
    # This could also be a cookie, x-api-key header, etc.
    token = req.headers["Authorization"]
    user = await validate_token(token)
    if user == None:
        raise HTTPException(status_code=401, detail="Unauthorized")
    return user

그러면 모든 보호 경로에 다음 종속성을 추가할 수 있습니다.

@app.get("/protected")
async def do_secret_things(user: User = Depends(require_valid_token_dep)):
    # do something with the user

사용자가 유효한 토큰을 제공하면 이 경로가 실행되고 사용자가 설정됩니다. 그렇지 않으면 401이 반환됩니다.

참고: OpenAPI/Swagger는 인증 토큰 지정을 위한 최고 수준의 지원을 제공하지만 이를 위해서는 전용 클래스 중 하나를 사용해야 합니다. req.headers["Authorization"] 대신 HTTPAuthorizationCredentials를 반환하는 fastapi.security의 HTTPBearer(auto_error=False)를 사용할 수 있습니다.

미들웨어와 인증에 따라 다름

FastAPI는 대부분의 프레임워크와 마찬가지로 미들웨어라는 개념을 가지고 있습니다. 미들웨어에는 요청 전후에 실행되는 코드가 포함될 수 있습니다. 요청이 경로에 도달하기 전에 요청을 수정할 수 있으며 사용자에게 반환되기 전에 응답을 수정할 수 있습니다.

다른 많은 프레임워크에서 미들웨어는 인증 확인이 이루어지는 매우 일반적인 장소입니다. 그러나 이는 미들웨어가 사용자를 경로에 "주입"하는 작업도 수행하기 때문인 경우가 많습니다. 예를 들어 Express의 일반적인 패턴은 다음과 같은 작업을 수행하는 것입니다.

app.get("/protected", authMiddleware, (req, res) => {
    // req.user is set by the middleware
    // as there's no good way to pass in extra information into this route,
    // outside of the request
});

FastAPI에는 주입 개념이 내장되어 있으므로 미들웨어를 전혀 사용할 필요가 없을 수도 있습니다. 인증 토큰을 주기적으로 "새로 고침"하고(활성 상태를 유지하기 위해) 응답을 쿠키로 설정해야 하는 경우 미들웨어 사용을 고려해 보겠습니다.

이 경우 request.state를 사용하여 미들웨어의 정보를 경로로 전달할 수 있습니다(원하는 경우 종속성을 사용하여 request.state를 확인할 수 있습니다).

그렇지 않으면 사용자가 request.state를 거치지 않고 경로에 직접 주입되므로 저는 계속 의존성을 사용하겠습니다.

승인 - 다중 테넌시, 역할 및 권한

지금까지 배운 모든 내용을 적용하면 멀티 테넌시, 역할 또는 권한을 추가하는 것이 매우 간단할 수 있습니다. 각 고객에 대해 고유한 하위 도메인이 있다고 가정하고 이 하위 도메인에 대한 종속성을 만들 수 있습니다.

async def tenant_by_subdomain_dep(request: Request) -> Optional[str]:
    # first we get the subdomain from the host header
    host = request.headers.get("host", "")
    parts = host.split(".")
    if len(parts) <= 2:
        raise HTTPException(status_code=404, detail="Not found")
    subdomain = parts[0]

    # then we lookup the tenant by subdomain
    tenant = await lookup_tenant_for_subdomain(subdomain)
    if tenant == None:
        raise HTTPException(status_code=404, detail="Not found")
    return tenant

이 아이디어를 이전 아이디어와 결합하여 새로운 "다중 테넌트" 종속성을 만들 수 있습니다.

async def get_user_and_tenant_for_token(
    user: User = Depends(require_valid_token_dep),
    tenant: Tenant = Depends(tenant_by_subdomain_dep),
) -> UserAndTenant:
    is_user_in_tenant = await check_user_is_in_tenant(tenant, user)
    if is_user_in_tenant:
        return UserAndTenant(user, tenant)
    raise HTTPException(status_code=403, detail="Forbidden")

그런 다음 이 종속성을 경로에 삽입할 수 있습니다.

@app.get("/protected")
async def do_secret_things(user_and_tenant: UserAndTenant = Depends(get_user_and_tenant_for_token)):
    # do something with the user and tenant

이것은 결국 몇 가지 주요 작업을 수행하게 됩니다.

• 사용자가 유효한 토큰을 가지고 있는지 확인

• 사용자가 유효한 하위 도메인에 요청하고 있는지 확인

• 사용자가 해당 하위 도메인에 액세스할 수 있는지 확인

If any of those invariants aren’t met - an error is returned and our route will never run. We can extend this to include other things like roles & permissions (RBAC) or making sure the user has a certain property set (active paid subscription vs no active subscription).

PropelAuth <3 FastAPI

At PropelAuth, we’re big fans of FastAPI. We have a FastAPI library that will enable you to set up authentication and authorization quickly - including SSO, Enterprise SSO / SAML, SCIM Provisioning, and more.

And it all works with dependencies like the ones you’ve seen above, e.g.:

@app.get("/")
async def root(current_user: User = Depends(auth.require_user)):
    return {"message": f"Hello {current_user.user_id}"}

You can find out more here.

Summary

• FastAPI's dependency injection provides a powerful way to handle authentication and authorization in web applications.

• The Depends feature allows for clean, reusable code for validating tokens, checking user permissions, and handling multi-tenancy.

• Compared to middleware, using dependencies for auth offers more flexibility and direct integration with route functions.

• Complex authorization scenarios like multi-tenancy and role-based access control can be efficiently implemented using nested dependencies.

• PropelAuth offers a FastAPI library that simplifies the implementation of advanced authentication and authorization features.

위 내용은 종속성 주입을 통한 FastAPI 인증의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!