DokumentePreiseBlog
Kontaktieren Sie uns
AnmeldenKOSTENLOS anmelden
Back to Tech Articles

Flask 및 FastAPI를 위한 사용자 지정 데코레이터를 통한 권한 제어 및 로깅 기능 강화

9月 14, 2025
# Misc

Grace Collins

Solutions Engineer · Leapcell

Dieser Beitrag ist auch in English, 日本語 und Deutsch verfügbar
Cover of "Flask 및 FastAPI를 위한 사용자 지정 데코레이터를 통한 권한 제어 및 로깅 기능 강화"

소개: 데코레이터를 이용한 웹 애플리케이션 개발 향상

견고하고 안전한 웹 애플리케이션을 구축하는 것은 종종 사용자 인증, 접근 제어, 요청 로깅과 같은 공통 관심사를 처리해야 합니다. 이러한 기능들은 중요하지만, 코드베이스 전체에 구현을 분산시키면 반복, 가독성 저하, 유지보수 부담 증가로 이어질 수 있습니다. 모든 엔드포인트가 사용자가 관리자 권한을 가지고 있는지 확인해야 하거나 각 들어오는 요청에 특정 데이터를 기록해야 하는 시나리오를 상상해 보세요. 바로 이 지점에서 데코레이터의 힘이 빛을 발합니다. Python의 데코레이터는 함수의 핵심 로직을 변경하지 않고 동작을 수정하여 함수를 감싸는 우아하고 Python스러운 방법을 제공합니다. Flask 및 FastAPI와 같은 웹 프레임워크의 맥락에서 사용자 지정 데코레이터는 권한 검증 및 요청 로깅과 같은 공통 기능을 주입하는 간소화된 접근 방식을 제공하여 코드를 더 깔끔하고, 모듈화하며, 관리하기 훨씬 쉽게 만듭니다. 이 글에서는 Flask와 FastAPI 모두에서 이러한 일반적인 웹 개발 문제를 해결하기 위한 사용자 지정 데코레이터의 실용적인 적용에 대해 자세히 알아보겠습니다.

데코레이터 기반 웹 개발의 빌딩 블록 이해하기

구현에 들어가기 전에 사용자 지정 데코레이터의 여정을 뒷받침하는 핵심 개념을 명확히 이해해 봅시다.

데코레이터: Python에서 데코레이터는 다른 함수를 인수로 받아 소스 코드를 명시적으로 수정하지 않고 동작을 확장하거나 변경하는 함수입니다. 본질적으로 "래퍼(wrapper)" 함수입니다. @decorator_name 구문은 function = decorator_name(function)의 구문 설탕입니다.

미들웨어: 데코레이터와 직접적으로 동등하지는 않지만, 웹 프레임워크에서의 미들웨어는 공통 작업을 수행하기 위해 요청이나 응답을 가로채는 유사한 목적을 수행합니다. 데코레이터는 종종 함수 수준에서 작동하는 반면, 미들웨어는 더 전역적인 애플리케이션 수준에서 작동할 수 있습니다.

Flask: 단순성과 유연성으로 알려진 Python의 마이크로 웹 프레임워크입니다. 웹 개발에 필수적인 기능을 제공하며, 개발자가 다른 기능에 대해 선호하는 도구와 라이브러리를 선택할 수 있도록 합니다.

FastAPI: Python 3.7+를 기반으로 표준 Python 타입 힌트를 사용하는 API 구축을 위한 현대적이고 빠른(고성능) 웹 프레임워크입니다. 즉시 사용 가능한 자동 인터랙티브 API 문서, 데이터 검증 및 직렬화를 제공합니다.

권한 확인: 특정 작업이나 특정 리소스에 액세스할 수 있는 필요한 권한이 사용자 또는 개체에 있는지 확인하는 프로세스입니다.

요청 로깅: 애플리케이션으로 들어오는 HTTP 요청에 대한 세부 정보를 기록하는 행위로, 종종 요청 메서드, URL, 타임스탬프, 사용자 에이전트 및 잠재적으로 응답 상태와 같은 정보가 포함됩니다. 이는 디버깅, 모니터링 및 보안 감사에 중요합니다.

권한 부여 및 로깅을 위한 사용자 지정 데코레이터 만들기

Flask와 FastAPI에서 사용자 지정 데코레이터를 구현하여 강력한 권한 확인 및 포괄적인 요청 로깅을 달성하는 방법을 살펴보겠습니다.

Flask의 사용자 지정 데코레이터

Flask는 표준 Python 데코레이터를 원활하게 사용합니다. 이를 활용하여 requires_permission 및 log_request 데코레이터를 만들 것입니다.

Flask에서 권한 데코레이터 구현하기

특정 엔드포인트에는 인증된 "admin" 역할의 사용자만 액세스할 수 있다고 가정해 봅시다.

# app_flask.py
from flask import Flask, request, jsonify, abort, g
from functools import wraps
import datetime

app = Flask(__name__)

# 데모를 위한 모의 사용자 데이터 및 인증
USERS_DB = {
    "alice": {"password": "password123", "roles": ["admin", "user"]},
    "bob": {"password": "password456", "roles": ["user"]},
}

def authenticate_user(username, password):
    """매우 기본적인 인증 함수입니다."""
    user = USERS_DB.get(username)
    if user and user["password"] == password:
        return user
    return None

@app.before_request
def mock_auth():
    """간단함을 위해 헤더를 기반으로 사용자 인증을 모의합니다."""
    auth_header = request.headers.get("X-Auth-User")
    if auth_header:
        username, password = auth_header.split(":")
        user = authenticate_user(username, password)
        if user:
            g.user = user  # Flask의 전역 컨텍스트에 사용자 저장
        else:
            g.user = None
    else:
        g.user = None

def requires_permission(role):
    """
    현재 사용자가 필요한 역할을 가지고 있는지 확인하는 데코레이터입니다.
    """
    def decorator(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            if not hasattr(g, 'user') or g.user is None:
                abort(401, description="Authentication required")
            if role not in g.user.get("roles", []):
                abort(403, description=f"Permission denied: Requires '{role}' role")
            return f(*args, **kwargs)
        return decorated_function
    return decorator

@app.route("/admin_dashboard")
@requires_permission("admin")
def admin_dashboard():
    return jsonify({"message": f"Welcome to the admin dashboard, {g.user['username']}!"})

@app.route("/user_profile")
@requires_permission("user")
def user_profile():
    return jsonify({"message": f"Welcome to your profile, {g.user['username']}!"})

@app.route("/public_data")
def public_data():
    return jsonify({"data": "This is public data."})

설명:

  1. authenticate_user 및 mock_auth: 이러한 함수들은 사용자 인증을 시뮬레이션합니다. 실제 애플리케이션에서는 적절한 ID 관리 시스템과 통합될 것입니다. 인증된 사용자는 Flask에서 제공하는 스레드 로컬 객체인 g.user에 저장됩니다.
  2. requires_permission(role): 이것이 우리의 사용자 지정 데코레이터 팩토리입니다. role을 인수로 받습니다.
    • 실제 decorator 함수를 반환합니다.
    • decorator 내에서 functools의 @wraps(f)는 매우 중요합니다. 원본 함수의 메타데이터(예: __name__, __doc__)를 보존하여 디버깅 및 인스펙션에 유용합니다.
    • decorated_function은 g.user를 확인합니다. 인증된 사용자가 없거나 사용자에게 필요한 role이 없으면 401(Unauthorized) 또는 403(Forbidden) 상태 코드로 중단(abort)합니다.
    • 권한이 충족되면 원본 함수 f를 호출합니다.

Flask에서 요청 로깅 데코레이터 구현하기

특정 엔드포인트에 도달하는 모든 요청의 세부 정보를 기록하는 데코레이터를 만들어 보겠습니다.

# app_flask.py (계속)

def log_request(f):
    """
    들어오는 요청 세부 정보를 기록하는 데코레이터입니다.
    """
    @wraps(f)
    def decorated_function(*args, **kwargs):
        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        ip_address = request.remote_addr
        method = request.method
        path = request.path
        user_agent = request.headers.get("User-Agent", "N/A")

        log_message = (
            f"[{timestamp}] IP: {ip_address}, Method: {method}, Path: {path}, "
            f"User-Agent: {user_agent}"
        )
        if hasattr(g, 'user') and g.user:
            log_message += f", User: {g.user['username']}"

        print(f"REQUEST LOG: {log_message}") # 실제 앱에서는 적절한 로거를 사용하세요

        return f(*args, **kwargs)
    return decorated_function

@app.route("/protected_resource")
@log_request
@requires_permission("user") # 데코레이터는 쌓을 수 있습니다!
def protected_resource():
    return jsonify({"data": "This is a user-specific protected resource."})

# 예제 사용법 (디렉토리에서 `flask run`으로 실행):
# curl -X GET http://127.0.0.1:5000/public_data
# curl -X GET -H "X-Auth-User:alice:password123" http://127.0.0.1:5000/admin_dashboard
# curl -X GET -H "X-Auth-User:bob:password456" http://127.0.0.1:5000/protected_resource

설명:

  1. log_request(f): 이 데코레이터는 원본 뷰 함수 f를 받습니다.
  2. decorated_function은 관련 요청 세부 정보(타임스탬프, IP, 메서드, 경로, 사용자 에이전트 및 인증된 사용자(사용 가능한 경우))를 캡처합니다.
  3. 그런 다음 로그 메시지를 출력합니다. 프로덕션 환경에서는 이 기능을 로깅 라이브러리(예: Python의 logging 모듈)와 통합하여 파일이나 외부 로깅 서비스에 기록합니다.
  4. 마지막으로 원본 함수 f를 호출하여 요청을 처리합니다.
  5. 데코레이터 스태킹: log_request와 requires_permission이 /protected_resource에 쌓인 것을 확인하십시오. 데코레이터는 위에서부터 적용됩니다. 따라서 requires_permission이 먼저 실행되고, 그 다음 log_request, 마지막으로 실제 protected_resource 함수가 실행됩니다.

FastAPI의 사용자 지정 데코레이터

FastAPI는 라우트 정의(@app.get, @app.post 등)를 위한 자체 데코레이터를 제공합니다. 그러나 표준 Python 데코레이터를 사용하여 경로 작업 함수를 감쌀 수 있습니다. 더 강력하고 전역적인 요청/응답 가로채기를 위해 FastAPI의 종속성 및 미들웨어가 종종 선호되지만, 데코레이터는 함수별 관심사에 대해 여전히 실현 가능합니다.

FastAPI에서 권한 데코레이터 구현하기

FastAPI는 인증 및 권한 부여를 위해 종속성 주입 시스템을 사용하는 것을 권장합니다. 전통적인 데코레이터를 사용할 수도 있지만, FastAPI 종속성이 종종 더 관용적이고 요청 범위 객체를 처리하는 데 디자인과 더 잘 통합됩니다. 두 가지 모두 시연해 보겠습니다.

**1. 전통적인 Python 데코레이터 사용 (FastAPI에서 권한 부여에는 덜 관용적):

# app_fastapi.py
from fastapi import FastAPI, HTTPException, Depends, Header
from functools import wraps
import datetime
from typing import Optional

app = FastAPI()

# 데모를 위한 모의 사용자 데이터 및 인증
USERS_DB_FASTAPI = {
    "charlie": {"password": "testpass", "roles": ["admin", "user"]},
    "diana": {"password": "anotherpass", "roles": ["user"]},
}

class User:
    def __init__(self, username: str, roles: list[str]):
        self.username = username
        self.roles = roles

async def get_current_user_from_header(x_auth_user: Optional[str] = Header(None)) -> Optional[User]:
    """간단함을 위해 헤더를 기반으로 사용자 인증을 모의합니다."""
    if x_auth_user:
        try:
            username, password = x_auth_user.split(":")
            user_data = USERS_DB_FASTAPI.get(username)
            if user_data and user_data["password"] == password:
                return User(username=username, roles=user_data["roles"])
        except ValueError:
            pass # 잘못된 헤더 형식
    return None

def fastapi_requires_permission(role: str):
    """
    FastAPI에서 사용자 권한을 확인하는 전통적인 Python 데코레이터입니다.
    FastAPI의 Depends보다 권한 부여에는 덜 관용적입니다.
    """
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            # FastAPI의 종속성 시스템이나 전역 상태에서 사용자 정보를 얻어야 합니다.
            # 이것이 전통적인 데코레이터가 FastAPI에서 권한 부여에 덜 깔끔한 이유입니다.
            # 이 예제에서는 kwargs를 통해 전달되거나 전역 변수에 저장된다고 가정합니다.
            # 더 강력한 솔루션은 명시적으로 전달하거나 FastAPI의 Depends를 사용해야 합니다.
            
            current_user: Optional[User] = kwargs.get("current_user") # 주의 깊은 처리가 필요한 부분
            
            if not current_user:
                raise HTTPException(status_code=401, detail="Authentication required")
            if role not in current_user.roles:
                raise HTTPException(status_code=403, detail=f"Permission denied: Requires '{role}' role")
            return await func(*args, **kwargs)
        return wrapper
    return decorator

# 이것은 문제가 됩니다: 함수 시그니처를 직접 수정하지 않고 `current_user`를 데코레이터에 어떻게 전달할까요?
# FastAPI의 종속성 주입이 이를 위해 설계되었습니다.
# @app.get("/admin_area")
# @fastapi_requires_permission("admin")
# async def admin_area(current_user: User = Depends(get_current_user_from_header)):
#     return {"message": f"Hello admin {current_user.username}"}

주석 처리된 코드에서 볼 수 있듯이, current_user와 같은 요청 범위 값을 사용하는 전통적인 데코레이터를 직접 사용하는 것은 FastAPI에서 추가적인 트릭 없이는 어색해집니다.

**2. FastAPI의 종속성 주입을 사용한 권한 부여 (권장):

이것은 FastAPI에서 권한 부여를 처리하는 선호되고 가장 관용적인 방법입니다. Python의 @ 구문에서 "데코레이터"는 아니지만, Depends는 함수 수준에서 데코레이터와 유사한 확장 기능을 제공합니다.

# app_fastapi.py (계속)

def verify_role_dependency(required_role: str):
    """
    현재 사용자가 필요한 역할을 가지고 있는지 확인하는 FastAPI 종속성 팩토리입니다.
    이것은 FastAPI에서 권한 부여를 위한 관용적인 방법입니다.
    """
    async def _verify_role(current_user: User = Depends(get_current_user_from_header)):
        if not current_user:
            raise HTTPException(status_code=401, detail="Authentication required")
        if required_role not in current_user.roles:
            raise HTTPException(status_code=403, detail=f"Permission denied: Requires '{required_role}' role")
        return current_user # 필요한 경우 추가 사용을 위해 사용자 반환
    return _verify_role

@app.get("/admin_config")
async def get_admin_config(current_user: User = Depends(verify_role_dependency("admin"))):
    return {"message": f"Admin config for {current_user.username}"}

@app.get("/my_settings")
async def get_my_settings(current_user: User = Depends(verify_role_dependency("user"))):
    return {"message": f"User settings for {current_user.username}"}

설명 (FastAPI 종속성):

  1. get_current_user_from_header: 이것은 비동기 종속성 함수로, X-Auth-User 헤더에서 사용자 정보를 추출합니다. 성공하면 User 객체를 반환하고, 그렇지 않으면 None을 반환합니다.
  2. verify_role_dependency(required_role): 이것은 종속성 팩토리입니다. required_role을 받아 다른 비동기 함수(_verify_role)를 반환하는 함수입니다.
  3. _verify_role 자체도 종속성입니다. Depends(get_current_user_from_header)를 사용하여 current_user를 가져옵니다.
  4. 그런 다음 역할 확인을 수행하고 권한이 거부되면 HTTPException을 발생시킵니다.
  5. 사용법: 경로 작업 함수(admin_config, my_settings)에서 Depends(verify_role_dependency("admin"))을 사용합니다. FastAPI는 자동으로 verify_role_dependency("admin")을 호출하여 _verify_role 종속성을 가져와 실행하고, 통과하면 _verify_role이 반환한 current_user 객체를 함수의 매개변수에 주입합니다. 이것은 깔끔하고 테스트 가능하며 FastAPI의 핵심 강점을 활용합니다.

FastAPI에서 요청 로깅 데코레이터 구현하기

요청 로깅의 경우, 전통적인 Python 데코레이터가 FastAPI에서도 잘 작동합니다.

# app_fastapi.py (계속)

async def _get_current_username(current_user: Optional[User] = Depends(get_current_user_from_header)) -> Optional[str]:
    """로깅을 위한 현재 사용자 이름을 얻는 헬퍼 종속성입니다."""
    return current_user.username if current_user else None

def fastapi_log_request(func):
    """
    FastAPI에서 들어오는 요청 세부 정보를 기록하는 데코레이터입니다.
    """
    @wraps(func)
    async def wrapper(*args, **kwargs):
        request_obj = kwargs.get("request") # FastAPI가 요청을 키워드 인수로 전달합니다
        if not request_obj:
            # 요청이 직접 kwargs에 없는 경우 (예: 다른 비-FastAPI 데코레이터로 감싸진 경우) 폴백
            # 대부분의 FastAPI 컨텍스트에서는 사용 가능할 것입니다.
            return await func(*args, **kwargs)

        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        ip_address = request_obj.client.host if request_obj.client else "N/A"
        method = request_obj.method
        path = request_obj.url.path

        # 헤더에서 user_agent를 가져오려고 시도합니다.
        user_agent = request_obj.headers.get("user-agent", "N/A")

        log_message = (
            f"[{timestamp}] IP: {ip_address}, Method: {method}, Path: {path}, "
            f"User-Agent: {user_agent}"
        )
        # 참고: FastAPI에서 전통적인 데코레이터 내에서 현재 사용자를 얻는 것은
        # 까다로울 수 있습니다. 일반적으로 미들웨어로 처리하거나
        # 필요한 경우 뷰 함수에서 get_current_user_from_header에 명시적으로 종속하는 것이 좋습니다.
        # 이 예제에서는 간단하게 유지하거나 사용 가능한 경우 사용자 정보에 액세스할 수 있다고 가정합니다.

        # 만약 wrapped 함수에 current_user 매개변수로 명시적으로 전달했다면:
        current_username: Optional[str] = await _get_current_username(
            x_auth_user=request_obj.headers.get("X-Auth-User") # 종속성을 위해 다시 추출
        )
        if current_username:
            log_message += f", User: {current_username}"


        print(f"FASTAPI REQUEST LOG: {log_message}") # 실제 앱에서는 적절한 로거를 사용하세요

        response = await func(*args, **kwargs)
        return response
    return wrapper

@app.get("/product_info")
@fastapi_log_request
async def get_product_info():
    return {"name": "Super Widget", "price": 29.99}

# 예제 사용법 (`uvicorn app_fastapi:app --reload`로 실행):
# curl -X GET http://127.0.0.1:8000/product_info
# curl -X GET -H "X-Auth-User:charlie:testpass" http://127.0.0.1:8000/admin_config
# curl -X GET -H "X-Auth-User:diana:anotherpass" http://127.0.0.1:8000/my_settings

설명:

  1. fastapi_log_request(func): 이것은 표준 비동기 Python 데코레이터입니다.
  2. wrapper는 FastAPI가 암시적으로 경로 작업 함수에 전달하는 키워드 인수인 request 객체에 액세스합니다.
  3. Flask 예제와 유사하게 요청 세부 정보를 추출합니다.
  4. 로그 메시지를 출력합니다.
  5. 그런 다음 await func(*args, **kwargs)를 호출하여 원본 경로 작업 함수를 실행하고 그 결과를 기다립니다.
  6. 로깅을 위한 사용자 정보 얻기: 일반 데코레이터 내에서 인증된 사용자를 얻으려면 FastAPI에서는 인증이 일반적으로 Depends로 처리되므로 약간의 추가 노력이 필요합니다. 단순화를 위해 여기서 헤더에서 다시 추출했지만, 더 복잡한 시나리오에서는 kwargs.get("current_user")를 사용하여 데코레이션된 함수에 current_user를 매개변수로 명시적으로 전달하거나, 더 전역적인 로깅을 위해 FastAPI 미들웨어를 사용할 수 있습니다.

로깅 및 권한 부여 이외의 애플리케이션

여기서 시연된 개념은 접근 제어 및 로깅을 훨씬 뛰어넘어 확장됩니다. 사용자 지정 데코레이터는 다음과 같은 용도로 매우 유용합니다.

  • 캐싱: 함수의 반환 값을 캐시하도록 함수를 장식합니다.
  • 속도 제한: 사용자 또는 IP가 엔드포인트에 액세스할 수 있는 횟수를 제어합니다.
  • 입력 검증: 요청 본문 또는 쿼리 매개변수에 대한 추가 검증을 수행합니다.
  • 응답 변환: 응답의 구조나 내용을 수정합니다.
  • 오류 처리: 사용자 지정 오류 처리 로직으로 함수를 감싸줍니다.
  • 데이터베이스 트랜잭션 관리: 여러 데이터베이스 호출을 포함하는 작업에 대한 원자성(atomicity)을 보장합니다.

결론: 유지보수 및 안전한 애플리케이션 구축

Flask와 FastAPI의 사용자 지정 데코레이터는 개발자가 더 깔끔하고, 모듈화되며, 유지보수하기 쉬운 웹 애플리케이션을 작성할 수 있도록 지원합니다. 권한 확인 및 요청 로깅과 같은 공통 관심사를 재사용 가능한 데코레이터로 추상화함으로써 코드 중복을 크게 줄이고 비즈니스 로직의 가독성을 향상시킬 수 있습니다. FastAPI의 종속성 주입이 인증 및 권한 부여에 대해 종종 더 관용적인 접근 방식을 제공하지만, 전통적인 데코레이터는 두 프레임워크 모두에서 다양한 함수 수준 향상에 유용한 도구로 남아 있습니다. 이 패턴을 채택하면 더 강력하고, 안전하며, 쉽게 확장 가능한 웹 서비스를 만들 수 있습니다.

Share this article

HackerNews

More Posts from Leapcell

Popular Posts