[작성자:] root

FastAPI는 현대적인 웹 API 개발을 위한 프레임워크로, Python 언어를 기반으로 하여 비동기 프로그래밍을 지원합니다. FastAPI의 주요 장점 중 하나는 높은 성능을 유지하면서도 개발자가 직관적으로 이해하고 사용할 수 있도록 돕는 강력한 타입 시스템과 자동화된 문서 생성 기능입니다. 이 글에서는 FastAPI 서버를 개발하고 애플리케이션 구조화 방법, 그리고 라우트 구현에 대해 자세히 설명하고 예제 코드를 제공합니다.

1. FastAPI란?

FastAPI는 웹 애플리케이션의 백엔드 API를 쉽게 구축할 수 있도록 해주는 Python 프레임워크입니다. 다음과 같은 특징이 있습니다:

• 빠른 성능: Starlette를 기반으로 하며, 비동기적이고 빠른 실행 속도를 가지고 있습니다.
• 자동 문서 생성: Swagger UI 및 ReDoc을 통한 자동 API 문서화를 지원합니다.
• 타입 힌팅: Python 3.6 이상의 타입 힌팅을 사용하여 코드 가독성과 유지 보수성을 높입니다.

2. FastAPI로 서버 개발 시작하기

FastAPI 설치는 간단합니다. pip를 사용하여 FastAPI와 uvicorn을 설치할 수 있습니다:

pip install fastapi uvicorn

3. 기본 FastAPI 애플리케이션 구조

FastAPI 애플리케이션은 다음과 같은 구조로 구성될 수 있습니다:

• main.py: FastAPI 애플리케이션의 진입점입니다.
• routers: 다양한 API 라우트를 정의하는 모듈입니다.
• models: 데이터베이스 모델 및 Pydantic 모델을 정의하는 모듈입니다.
• schemas: 요청 및 응답 모델을 정의하는 Pydantic 스키마입니다.
• services: 비즈니스 로직을 처리하는 모듈입니다.

3.1 기본 FastAPI 애플리케이션 코드

아래 코드는 FastAPI의 기본 애플리케이션 구조를 보여줍니다:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

4. FastAPI 애플리케이션 라우팅

FastAPI에서 라우팅은 웹 경로와 HTTP 메서드(GET, POST, PUT, DELETE 등)에 따라 클라이언트의 요청을 처리하는 방식을 정의합니다. FastAPI는 각 라우트에 대한 HTTP 메서드를 데커레이터 형태로 작성할 수 있게 해줍니다.

4.1 라우트 구현하기

라우트를 구현하기 위해 FastAPI에 내장된 여러 데커레이터를 사용할 수 있습니다. 예를 들어, 클라이언트가 “/items/{item_id}” 경로로 GET 요청을 보낼 때 특정 아이템을 반환하는 라우트를 아래와 같이 정의할 수 있습니다:

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

4.2 다양한 HTTP 메서드 사용하기

FastAPI는 GET, POST, PUT, DELETE와 같은 다양한 HTTP 메서드를 지원합니다. 아래 예제는 POST 요청을 처리하여 클라이언트로부터 입력 받은 데이터를 반환하는 라우트를 보여줍니다:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

@app.post("/items/")
async def create_item(item: Item):
    return item

5. FastAPI 라우터로 애플리케이션 구조화하기

대규모 애플리케이션에서는 모든 라우트를 main.py 파일에 정의하는 것보다 모듈화하여 관리하는 것이 효율적입니다. FastAPI에서는 `APIRouter`를 사용하여 라우트 그룹을 만들 수 있습니다.

5.1 라우터 설정하기

프로젝트 구조를 다음과 같이 설정합니다:

• app/
  • main.py
  • routers/
    • items.py
  • models/
    • item.py

5.2 items.py 라우터 구현

items.py 파일에서 아이템 관련 모든 라우트를 정의합니다:

from fastapi import APIRouter
from models.item import Item

router = APIRouter()

@router.post("/items/")
async def create_item(item: Item):
    return item

@router.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

5.3 main.py 파일에서 라우터 포함시키기

라우터를 main.py에 포함시켜 사용합니다:

from fastapi import FastAPI
from routers.items import router as items_router

app = FastAPI()

app.include_router(items_router, prefix="/items", tags=["items"])

6. FastAPI와 데이터베이스 연동하기

FastAPI 애플리케이션에서 데이터베이스와 연동하는 것은 자주 필요하는 기능입니다. 아래 코드는 SQLAlchemy와 FastAPI를 통합하여 데이터베이스와 상호작용하는 방법을 보여줍니다.

6.1 SQLAlchemy 설치하기

SQLAlchemy와 데이터베이스 드라이버를 설치합니다:

pip install sqlalchemy databases

6.2 데이터베이스 연결 설정

database.py 파일을 생성하고 데이터베이스 연결을 설정합니다:

from sqlalchemy import create_engine, MetaData
from sqlalchemy.ext.declarative import declarative_base

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
metadata = MetaData()
Base = declarative_base()

6.3 모델 정의하기

models/item.py에서 데이터베이스 모델을 정의합니다:

from sqlalchemy import Column, Integer, String
from database import Base

class Item(Base):
    __tablename__ = "items"

    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True)
    price = Column(Integer)

6.4 CRUD 작동 구현하기

서비스 계층에 CRUD 작동을 구현합니다:

from sqlalchemy.orm import Session
from models.item import Item

def get_item(db: Session, item_id: int):
    return db.query(Item).filter(Item.id == item_id).first()

def create_item(db: Session, item: Item):
    db.add(item)
    db.commit()
    db.refresh(item)
    return item

7. FastAPI 애플리케이션 실행하기

FastAPI 애플리케이션을 실행하기 위해 다음 명령어를 사용합니다:

uvicorn main:app --reload

8. 결론

FastAPI는 훌륭한 성능과 직관적인 코드 작성을 제공하는 웹 API 프레임워크입니다. 본 강좌에서는 FastAPI를 사용하여 서버를 개발하고 애플리케이션 구조화 방법, 라우트 구현에 대해 다루었습니다. FastAPI가 제공하는 다양한 기능들을 활용하여 보다 나은 웹 애플리케이션을 구축할 수 있기를 바랍니다.

9. 추가 자료

FastAPI 공식 문서에서 더 많은 정보와 자료를 확인할 수 있습니다: FastAPI Documentation

웹 애플리케이션을 개발할 때, 코드의 중복을 줄이는 것은 소프트웨어의 유지보수성과 확장성을 높이는 중요한 작업입니다. FastAPI는 이러한 작업을 효율적으로 처리하기 위한 다양한 방법을 제공하며, 특히 의존성 주입(Dependency Injection)의 개념을 통해 중복 코드를 줄일 수 있는 뛰어난 기능을 갖추고 있습니다.

1. FastAPI 소개

FastAPI는 Python으로 작성된 현대적인 웹 프레임워크로, 빠른 성능과 개발 생산성을 자랑합니다. ASGI(Asynchronous Server Gateway Interface)를 기반으로 하며, 비동기 프로그래밍을 지원합니다. 데이터 검증, 직렬화, OpenAPI 및 JSON Schema에 대한 자동화된 문서화를 쉽게 처리할 수 있습니다.

2. 의존성 주입(Dependency Injection)란?

의존성 주입이란 객체나 함수가 필요로 하는 외부의 의존 객체를 주입받아 사용하는 디자인 패턴입니다. 이를 통해 객체 간의 결합도가 낮아져 코드의 재사용성이 증가하고, 테스트가 쉬워지는 장점이 있습니다.

2.1 FastAPI에서 의존성 주입 사용하기

FastAPI에서는 의존성을 정의하고 주입하는 것이 매우 간단합니다. 의존성을 정의하기 위해서는 Depends 클래스를 사용합니다. 아래 코드 예제를 통해 이를 살펴보겠습니다.

from fastapi import FastAPI, Depends, HTTPException

app = FastAPI()

def get_query_param(q: str = None):
    return q

@app.get("/items/")
async def read_item(q: str = Depends(get_query_param)):
    if q:
        return {"query": q}
    return {"query": "No query provided"}

위 예제에서는 get_query_param이라는 함수를 정의하고 여기서 query parameter를 받아옵니다. Depends를 사용하여 이를 read_item 함수에 주입하고 있습니다.

3. 중복 코드 줄이기의 필요성

웹 애플리케이션의 크기가 커질수록, 비슷한 기능을 갖는 코드 블록이 여러 곳에서 반복되는 경우가 많습니다. 이러한 중복 코드는 코드의 복잡성을 증가시키고, 유지보수의 어려움을 초래합니다. 의존성 주입을 통해 이러한 중복 코드를 줄임으로써 효율적인 코드 작성을 할 수 있습니다.

4. 의존성 재사용을 통한 코드 최적화

의존성 재사용은 FastAPI의 핵심 특징 중 하나입니다. 기본적인 의존성을 여러 라우터에 재사용할 수 있고, 이를 통해 코드의 일관성을 유지하며 중복을 제거할 수 있습니다.

4.1 공통 의존성 정의하기

예를 들어, 사용자의 인증을 처리하는 공통 의존성을 정의할 수 있습니다. 아래 코드는 JWT 인증을 위한 예시입니다.

from fastapi import Security, Depends
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    # 여기에 JWT 검증 로직을 추가합니다.
    if token != "valid-token":
        raise HTTPException(status_code=401, detail="Invalid authentication credentials")
    return {"username": "user1"}

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

여기서 get_current_user 함수는 JWT 토큰을 검증하는 역할을 하며, 여러 라우터에서 재사용될 수 있습니다.

4.2 동적으로 의존성 주입하기

FastAPI에서는 동적으로 의존성을 주입할 수도 있습니다. 이를 통해 상황에 따라 다른 의존성을 사용할 수 있습니다. 예를 들어, 환경에 따라 다른 데이터베이스 연결을 사용할 수 있습니다.

from fastapi import Depends

def get_database_connection():
    if app.state.environment == "production":
        return "Production DB Connection"
    return "Development DB Connection"

@app.get("/db/")
async def read_db(connection: str = Depends(get_database_connection)):
    return {"connection": connection}

위 코드에서 환경 변수를 통해 서로 다른 데이터베이스 연결을 주입받을 수 있습니다.

5. 의존성 재사용의 이점

• 유지보수성: 중복이 제거됨으로써 코드 전반에 걸쳐 더 쉽게 수정할 수 있습니다.
• 테스트 용이성: 더 적은 코드로 더 많은 기능을 구현할 수 있어, 테스트와 디버깅을 쉽게 할 수 있습니다.
• 일관성: 의존성이 각기 다른 라우터에서 재사용됨으로써 코드의 일관성을 유지할 수 있습니다.

6. 고급 의존성 주입

FastAPI에서는 의존성 주입의 고급 기능도 제공하여, 클래스와 함께 사용할 수 있습니다. 이를 통해 더 복잡한 비즈니스 로직을 캡슐화할 수 있습니다. 아래는 클래스 기반의 의존성 주입 예제입니다.

class UserService:
    def get_user(self, user_id: int):
        # 데이터베이스에서 사용자 정보를 가져오는 로직
        return {"user_id": user_id, "name": "John Doe"}

def get_user_service() -> UserService:
    return UserService()

@app.get("/users/{user_id}")
async def read_user(user_id: int, user_service: UserService = Depends(get_user_service)):
    return user_service.get_user(user_id)

이 예제에서 UserService 클래스는 사용자의 정보를 제공하는 로직을 담당하며, 이를 의존성으로 주입받아 사용할 수 있습니다.

7. 결론

FastAPI는 의존성 주입을 통해 중복 코드를 최소화하고 코드의 재사용성을 극대화할 수 있는 훌륭한 도구입니다. 의존성을 통해 작성된 코드는 더 간결하고, 유지보수하기 쉬우며, 테스트가 용이합니다. 여러 가지 예제를 통해 의존성 재사용의 중요성과 이를 FastAPI에서 구현하는 방법을 살펴보았습니다.

참고 자료

• FastAPI 공식 문서
• FastAPI GitHub 레포지토리
• Learn Python