[Python] FastAPI와 Dependency Injector

🚀 들어가며

소프트웨어를 설계하다보면 DI 패턴을 적용해야하는 경우 있습니다. python 기준으로 객체의 의존성 주입은 다양한 방식으로 구현할 수 있지만, Python에서 DI 패턴을 프레임워크 형태로 구현한 Dependency Injector 라이브러리를 통해 의존성 주입과 제어의 역전(IoC)기능을 사용할 수 있습니다.

이번 포스팅에서는 FastAPI와 Dependency Injector를 활용해 Layered 아키택처를 구현하는 방법에 대해 알아보겠습니다.

---

🔍 의존성 주입에 대한 간단 설명

이번 포스팅에서 의존성 주입에 대한 개념에 대해 설명하지 않지만, 간단히 짚고 넘어가겠습니다. DI, IoC, DIP와 같은 개념은 Spring과 같은 프레임워크를 사용한다거나, 객체 지향 설계에 대해 공부하셨다면 많이 들어봤을 내용일 겁니다.

의존성 주입이란 말 그대로 특정 객체(A)에서 필요한 객체(B)를 A에서 클래스를 import 해서 객체로 만들어 사용하는 것이 만드는 것이 아닌, A객체를 생성할 때 생성자를 통해 B객체를 전달(주입)해주는 방식입니다. 

IoC 즉 의존 제어 역전의 원칙은 이러한 의존성을 관리와 흐름 제어를 A객체, B객체가 아닌 제 3의 방식(의존 제어 컨테이너, 프레임워크 등)으로 관리하는 것 입니다. 스프링에서는 Bean 컨테이너가, 그리고 python Dependency Injector에서 Container라는 객체를 통해 의존 제어 역전 기능을 제공합니다.

---

 📦 Dependency Injector 소개

Dependency Injector는 python 생태계에서 가장 많이 사용되는 DI 프레임워크 중 하나입니다. DI 패턴을 위한 핵심 기능인 IoC 컨테이너를 제공하고 문서를 통해 유즈케이스에 대한 예시 코드를 보여주기 때문에 프로젝트에 적용하기 쉽습니다. 또한 많은 프로덕션 환경에서 사용되어 안정성이 검증되었다는 장점이 있습니다.

 📚 주요 개념

Providers: 주입할 객체를 제공하는 객체입니다. 객체를 주입할 방법(Singleton, Factory, Callable, Object...)등 객체를 주입할 수 있는 다양한 방법을 제공합니다. 예를들어 Singleton으로 정의된 Provider를 사용한다면 컨테이너에 정의된 해당 객체를 사용할 때 객체가 다시 생성되지 않습니다. 반명 Factory로 정의되었다면, 주입된 객체를 사용할 때 마다 다른 객체가 생성됩니다.

Containers : 의존성이 정의된 Provider의 집합입니다. Container를 통해 객체들의 의존성을 명시적으로 관리할 수 있습니다. 또한 의존성 주입이 필요한 부분에서 Container를 통해 Provider 객체를 참조해서 의존성을 주입받을 수 있습니다.

Wiring: 의존성을 주입하는 부분입니다. Provider를 통해 명시된 주입방식으로, 객체를 주입할 Class의 위치를 명시합니다.

 

 

🔧 예시 코드

가령 다음과 같은 클래스간 관계가 있다고 했을 때, Dependency Injector를 사용해 의존성 주입을 하는 코드를 예시로 살펴보겠습니다.
간단한 블로그의 글을 포스팅하는 클래스의 의존관계를 그려보겠습니다.

 

BlogService 클래스는 PostRepository의 기능을 사용해 포스팅을 관리하게 됩니다. 먼저 BlogService 코드를 살펴볼까요?

class BlogService: 
    def __init__(self, repository: PostRepository): 
    	self._repository = repository 

    def create_post(self, title, content): 
    	post = Post(title, content)
    	self._repository.add_post(post) 

    def get_posts(self): 
    	return self._repository.list_posts()

BlogService에서는 Post의 영속성을 관리하는 Repository를 생성자를 통해 주입받습니다. 해당 repository 속성을 사용해서 post를 생성(create_post), 조회(get_posts) 하는 기능을 구현합니다.

PostRepository 코드를 확인해보면

class PostRepository: 
    def __init__(self): 
    	self._posts = [] 

    def add_post(self, post): 
    	self._posts.append(post) 

    def list_posts(self): 
    	return self._posts

간단하게 list형태로 Post를 넘겨받고 관리하는 repository입니다. add_post를 통해 _post변수에 에 Post 인스턴스를 저장하고 list_posts 함수를 통해 불러오는 코드입니다.

위 두 함수의 의존관계를 Container에 명시하는 코드는 다음과 같습니다.

from dependency_injector import containers, providers

class Container(containers.DeclarativeContainer): 
    post_repository = providers.Singleton(PostRepository) 
    blog_service = providers.Factory(BlogService, repository=post_repository)

 

post_repository를 Signleton으로 정의했고, blog_service에 주입시켜 주었습니다. blog_service는 Factory로 정의되어있으니 Provicer를 통해 매번 다른 blog_service 인스턴스를 얻을 수 있습니다.

의존관계를 명시했으니 container를 통해 blog_service를 주입해볼까요? 

 

main 함수에서 해당 컨테이너를 통해 의존관계를 주입해보겠습니다.

from dependency_injector import containers, providers
from dependency_injector.wiring import Provide, inject

class Container(containers.DeclarativeContainer):
    post_repository = providers.Singleton(PostRepository) 
    blog_service = providers.Factory(BlogService, repository=post_repository)

@inject
def main(blog_service: BlogService = Provide[Container.service]) -> None:
    blog_service.creade_post(Post("제목", "내용"))
    print(blog_service.get_posts()) # Post(제목, 내용)

if __name__ == "__main__":
    container = Container()
    container.wire(modules=[__name__])

    main()

main 함수의 인자로 blog_service를 주입해 줬습니다. @inject 데코레이터를 사용해서 주입이 될 main 함수의 위치를 명시해주었고, container에서는 inject될 모듈의 위치를 명시했습니다.(@inject 데코레이터는 없어도 잘 작동합니다.)

 

위처럼 main 함수에서 인자를 Provide 디스패처를 통해 주입해준다면, main 함수를 생성할 때 인자로 blog_service를 넘겨주지 않아도 Provider가 적절한 blog_service 인스턴스를 주입시켜 주게 됩니다.

---

🌐 FastAPI와 의존성 주입

FastAPI는 자체적인 의존성 주입 디스패처인 Depends가 있습니다. Depends를 통해 의존관계에 있는 인스턴스를 주입하거나 의존성을 주입하는 방식을 명시적으로 사용할 수 있습니다.

다음은 FastAPI에서 Depends를 통해 의존성을 주입하는 예시입니다.

위에서 사용한 블로그 포스팅 예제를 FastAPI의 Router함수에서 BlogService의 인스턴스를 주입받아 사용하는 예시를 구현해보았습니다.

from fastapi import FastAPI, Depends

app = FastAPI()

# 의존성을 정의하는 함수
def get_post_repository():
    return PostRepository()

def get_blog_service(repository: PostRepository = Depends(get_post_repository)):
    return BlogService(repository)

# 라우트 예시
@app.get("/posts")
def list_blog_posts(blog_service: BlogService = Depends(get_blog_service)):
    return blog_service.list_posts()

@app.post("/posts")
def create_blog_post(post_data: dict, blog_service: BlogService = Depends(get_blog_service)):
    blog_service.add_post(post_data)

FastAPI의 라우터 함수에 Depends를 사용해 get_blog_service 함수를 호출할 수 있도록 인자의 디스패처를 정의합니다. 

get_blog_service 함수에서는 BlogService를 객체로 만들고 해당 함수의 인자에서는 get_post_repository를 전달받습니다. 인자를 통해 넘겨받은 PostRepository의 객체를 BlogService의 생성자로 넘겨주는 코드입니다.

이처럼 FastAPI의 Depends 함수를 통해 의존성을 주입할 수 있지만, Depends 만으로 의존성을 관리했을 때 느껴지는 문제점이 있습니다.

 

1. API의 path/query 인자를 통해 생성되는 공유 로직과 의존성 주입을 통해 생성해야하는 객체 관계가 얽히게 됩니다.
2. 의존 관계를 한번에 파악하기 힘듭니다. Depends를 계속 참조하며 함수마다 어떤 객체가 주입되었는지 확인해야합니다.
3. 의존관계를 명시하는 부분과 실제 코드로직이 섞이게 됩니다.

---

🤝 FastAPI와 Dependency Injector를 함께 사용한다면?

FastAPI와 의존성 주입 프레임워크를 함께 사용한다면, 위에서 명시한 문제점을 해결할 수 있습니다.

1. 의존성 주입 Container를 통해 의존관계를 하나의 파일에서 의존관계를 관리할 수 있습니다.
2. Depends와 같은 의존관계를 주입하는 디스패처를 사용하지 않고 순수한 파이썬 클래스를 정의할 수 있습니다.
3. 필요 시 Container를 수정하거나 다른 Container를 통해 의존관계를 바꿀 수 있습니다.

코드를 통해서 FastAPI의 의존성을 Dependency Injector를 사용해 주입해보겠습니다. 블로그 포스팅 예제를 계속 사용해보겠습니다.

 

📂 디렉토리 구조 

.
├── main.py # 실행 코드
├── container.py # 의존성 컨테이너
├── router.py # fastAPI 라우터
├── service.py # 서비스 클래스 모듈
└── repository.py # 저장소 클래스 모듈

의존관계가 형성된 service, repository 클래스 입니다. 의존관계를 외부에서 주입하기 때문에 Depends 같은 디스패처를 사용하지 않은 순수한 python 클래스 입니다.

# service.py
class BlogService: 
    def __init__(self, repository: PostRepository): 
    self._repository = repository 

def create_post(self, title, content): 
    post = Post(title, content)
    self._repository.add_post(post) 

def get_posts(self): 
	return self._repository.list_posts()

# repository.py
class PostRepository: 
    def __init__(self): 
    self._posts = [] 

def add_post(self, post):
	self._posts.append(post) 

def list_posts(self):
	return self._posts

다음은 의존성 객체를 관리하는  Container클래스 입니다. BlogService에 PostRepository가 주입되었음을 명시적으로 확인할 수 있습니다.

# container.py
from dependency_injector import containers, providers
from repository import PostRepository
from service import BlogService

class Container(containers.DeclarativeContainer):
    post_repository = providers.Singleton(PostRepository) 
    blog_service = providers.Factory(BlogService, repository=post_repository)

 

@inject를 통해 fastAPI로 만들어진 Router 함수에 필요한 blog_service 객체를 주입해줬습니다.

눈여겨봐야하는 부분은 fastAPI의 Depends와 dependency injector의 Provide를 함께 사용했고, Provide내에 Container에서 주입받아야하는 객체를 명시한 부분입니다.

# router.py
from fastapi import FastAPI, Depends
from repository import PostRepository
from service import BlogService

from dependency_injector import containers, providers
from dependency_injector.wiring import Provide, inject
from container import Container

router = APIRouter()

# 라우트
@router.get("/posts")
@inject
def list_blog_posts(
    blog_service: BlogService = Depends(Provide[Container.blog_service])
):
    return blog_service.list_posts()

@router.post("/posts")
@inject
def create_blog_post(
    post_data: dict, 
    blog_service: BlogService = Depends(Provide[Container.blog_service])
):
    blog_service.add_post(post_data)

마지막으로 main.py 에 대한 코드입니다.

# main.py
import uvicorn
from fastAPI import FastAPI
from container import Container
from router import router


if __name__ == "__main__":
    container = Container()
    container.wire(modules=[.router])

    app = FastAPI()
    app.container = container
    app.include_router(router.router)

	uvicorn.run(app, host="0.0.0.0", port=8080)

main파일에서 container를 인스턴스화 시키고 의존성을 주입할 부분을 wiring 합니다. FastAPI 객체를 만들고 해당 객체에서 사용되는 container를 Dependency Injector의 Container로 바꿔줍니다. 

---

🌟 의존성 주입을 통해 얻을 수 있는 이점

지금까지 FastAPI에서 Dependency Injector를 사용한 코드를 살펴봤습니다. 그렇다면 의존성 주입, 그리고 의존성 주입 프레임워크를 사용했을 때 얻을 수 있는 이점이 뭐가 있을까요?

낮은 결합력 높은 응집력

 

각 객체간 관계가 늦은 결합을 갖게됩니다. 의존성을 주입받은 클래스의 인스턴스는 생성자로 부터 전달받은 객체의 구현에 의존하지 않습니다. 다만 전달받은 객체의 속성, 함수를 사용할 뿐 입니다. 개발자는 각 클래스의 의존관계에 얽매이지 않고 코드를 작성할 수 있습니다.

테스트 가능성

의존성을 외부에서 주입하기 때문에 테스트 작성이 용이합니다. 예를 들어 테스트 시에 사용할 Container를 따로 정의해 사용한다면, 의존성 주입이 필요한 부분을 Stub 객체 혹은 Mock 객체로 바꿔서 단위테스트를 수행할 수 있습니다.

명시적 의존성 관리

DI 프레임워크를 사용한다면, 의존관계를 명시적으로 하나의 파일내에서 관리할 수 있습니다. 여러 파일에서 정의되어있던 의존관계를 하나의 파일에서 관리할 수 있게 됩니다. Provider를 사용해 의존관계를 주입하는 방식도 명시적으로 선택해서 사용할 수 있습니다.

---

🏁 마치며

동적 타입 언어인 python은 의존성을 주입하지 않아도, 런타임에 객체를 갈아끼울 수 있기 때문에 DI 프레임워크를 사용할 필요는 없습니다. 직접 IoC 컨테이너를 구현하고, wire 로직을 구현해 객체를 주입할 수 있기 때문이죠. 의존성 주입 프레임워크가 필요한지, 필요하지 않은지는 개인의 선택이지만 저는 바퀴를 다시 발명하는 것 보다 이미 존재하는 DI 프레임워크를 사용하고 프레임워크를 사용해 일관된 방식으로 의존성을 주입할 수 있는 장점이 있다고 생각합니다 :)

 

🔗 참고자료

포스팅을 작성하기 위해 Dependeny Injector 공식문서와 한바름님의 블로그 글을 많이 참고했습니다.

 

https://python-dependency-injector.ets-labs.org/
https://rumbarum.oopy.io/post/review-python-dependency-injector