FastAPI 서버개발, Docker Compose를 이용한 다중 서비스 배포

서론

애플리케이션 개발에 있어서는 단일 서비스로 모든 요구 사항을 충족하는 것이 점점 더 어려워지고 있습니다. 또한, 다양한 기술 스택이 공존하고 있으며, 이는 이를 운영할 수 있는 복잡성을 증가시킵니다. 이러한 환경에서 FastAPIDocker Compose를 활용하여 간단하고 효과적으로 다중 서비스를 배포하는 방법을 알아보겠습니다.

FastAPI란?

FastAPI는 Python으로 작성된 현대적인 웹 프레임워크로, 빠르고 쉽게 RESTful API를 구축할 수 있게 도와줍니다. FastAPI는 다음과 같은 주요 기능을 가지고 있습니다:

  • 자동 생성되는 API 문서: Swagger UI와 ReDoc을 사용하여 간편하게 API 문서를 생성합니다.
  • 높은 성능: asyncio 기반으로 설계되어 비동기 요청을 처리할 수 있습니다.
  • 유효성 검사: Pydantic 모델을 활용하여 데이터 유효성 검사를 자동으로 수행합니다.

Docker Compose란?

Docker Compose는 여러 Docker 컨테이너를 정의하고 실행할 수 있는 도구입니다. 이를 사용하면 여러 서비스가 서로 어떻게 연결되는지를 정의할 수 있는 docker-compose.yml 파일을 작성하게 됩니다. 이러한 기능은 마이크로서비스 아키텍처를 구현하는 데 유용합니다.

프로젝트 구조 설정

FastAPI와 Docker를 사용한 예제를 위해, 다음과 같은 폴더 구조를 설정하겠습니다:

    my_fastapi_project/
    ├── app/
    │   ├── main.py
    │   └── requirements.txt
    ├── docker-compose.yml
    ├── .env
    └── Dockerfile
    

1. FastAPI 애플리케이션 구현

먼저 app/main.py 파일에 FastAPI 애플리케이션을 구현하겠습니다.

from fastapi import FastAPI

app = FastAPI()

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

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

이 코드는 기본적인 FastAPI 애플리케이션을 구현하고 있으며, 두 개의 경로를 제공합니다:

  • /: “Hello, World” 메시지를 반환합니다.
  • /items/{item_id}: 지정된 아이템 ID와 쿼리 매개변수를 반환합니다.

2. 의존성 설정

FastAPI를 실행하기 위해 필요한 패키지들을 requirements.txt 파일에 정의합니다.

fastapi
uvicorn[standard]

3. Dockerfile 작성

Dockerfile을 통해 FastAPI 애플리케이션을 Docker 이미지로 설정합니다. Dockerfile을 생성하고 다음 내용을 추가하세요:

FROM python:3.9

WORKDIR /app

COPY ./app /app

RUN pip install --no-cache-dir -r requirements.txt

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

위의 Dockerfile은 다음 단계를 수행합니다:

  1. python:3.9 이미지를 사용합니다.
  2. 작업 디렉토리를 설정합니다.
  3. 애플리케이션 코드를 컨테이너에 복사합니다.
  4. 의존성을 설치합니다.
  5. 8000 포트를 열고, Uvicorn 서버를 실행합니다.

4. Docker Compose 파일 작성

이제 Docker Compose 파일을 작성합니다. docker-compose.yml을 생성하고 다음 내용을 추가하세요:

version: '3.8'

services:
  fastapi:
    build: .
    ports:
      - "8000:8000"

이 Docker Compose 파일은 FastAPI 서비스를 설정하고, 외부에서 8000 포트로 접근할 수 있도록 합니다.

5. 환경 변수 관리

추가적으로 .env 파일을 생성하여 환경 변수를 관리할 수 있습니다. 다음과 같이 작성합니다:

FASTAPI_ENV=production

6. Docker Compose 실행

모든 설정이 완료되었다면 Docker Compose를 실행하여 FastAPI 애플리케이션을 시작할 수 있습니다. 다음 명령어를 사용합니다:

docker-compose up --build

브라우저에서 http://localhost:8000에 접근하여 FastAPI 애플리케이션이 정상적으로 실행되는지 확인합니다. Swagger UI로 접속하려면 http://localhost:8000/docs를 입력하면 됩니다.

7. 결론

FastAPI와 Docker Compose를 사용하면 다중 서비스를 간편하게 배포할 수 있다는 점을 살펴보았습니다. 이제 여러분은 FastAPI와 Docker를 기반으로 한 강력한 개발 환경을 구축하고, 다양한 마이크로서비스 아키텍처를 구현할 준비가 되었습니다. 이러한 도구들을 활용하여 더 복잡한 시스템을 설계하고 배포해봅시다.

8. 다음 단계

다음 단계로는 FastAPI의 다양한 기능을 이용해 더 복잡한 API를 구성하고, OAuth2와 같은 인증 방식을 도입하는 방법에 대해 학습할 수 있습니다. 또한, PostgreSQL과 같은 데이터베이스와의 연동도 이어질 주요 주제입니다.

참고자료

FastAPI 서버개발, 스키마 – 요청, 나머지 요청과 응답을 모두 정의하기

FastAPI는 현대적인 웹 API를 구축하기 위한 매우 효율적인 프레임워크입니다. 이 글에서는 FastAPI를 사용하여 요청과 응답을 정의하는 방법, 그리고 Pydantic을 이용한 스키마 정의 방식을 중점적으로 다룰 것입니다. 이러한 구성 요소들은 API의 신뢰성과 데이터 유효성을 높여줍니다.

1. FastAPI 소개

FastAPI는 Python 기반의 웹 프레임워크로, 빠르고 비동기식 HTTP 서비스 개발을 가능하게 합니다. 이 프레임워크의 가장 큰 장점은 데이터 유효성을 검사할 수 있는 강력한 스키마 정의 기능입니다. FastAPI는 비동기 처리를 기본으로 하며, 이는 성능을 높이고 더욱 효율적인 서버를 구축하는 데 크게 기여합니다.

2. Pydantic: 데이터 유효성 검사의 기본

Pydantic은 Python 데이터 유효성 검사 및 설정 관리를 위한 라이브러리로, FastAPI와 직접적으로 통합되어 사용됩니다. Pydantic의 모델을 활용하면 요청과 응답에서 사용하는 데이터 구조를 쉽게 정의하고, 자동으로 유효성을 검사할 수 있습니다.

2.1 Pydantic 모델 생성

Pydantic 모델을 생성하려면 먼저 BaseModel 클래스를 상속받아야 합니다. 다음은 간단한 Pydantic 모델의 예제입니다.


from pydantic import BaseModel

class User(BaseModel):
    id: int
    username: str
    email: str

위의 코드에서 User 클래스는 세 가지 필드를 가진 모델을 정의합니다. 각각의 필드는 데이터 타입을 명시하여 FastAPI가 요청의 유효성을 검사할 수 있도록 해줍니다.

2.2 요청 스키마 정의하기

FastAPI에서 API 엔드포인트를 정의할 때, 요청 바디에 사용될 스키마를 클래스 형태로 정의할 수 있습니다. 예를 들어, 사용자 정보를 생성하는 엔드포인트를 다음과 같이 구현할 수 있습니다.


from fastapi import FastAPI

app = FastAPI()

class UserCreate(BaseModel):
    username: str
    email: str

@app.post("/users/")
async def create_user(user: UserCreate):
    return {"username": user.username, "email": user.email}

위 코드에서 /users/ 엔드포인트는 POST 요청을 처리하며, UserCreate 모델을 요구합니다. 클라이언트가 이 API 호출 시 usernameemail 필드를 포함해야 합니다.

3. 응답 스키마 정의하기

응답 스키마도 Pydantic 모델로 정의할 수 있습니다. 요청 처리 후 클라이언트에 반환할 데이터의 구조를 명확히 함으로써 API 사용자가 예상할 수 있는 응답을 보장할 수 있습니다.

3.1 응답 모델 정의

동일한 모델을 응답으로 사용해도 되지만, 경우에 따라 다른 응답 모델이 필요할 수 있습니다. 따라서 아래와 같이 각각의 요청과 응답에 맞는 모델을 정의하는 것이 좋습니다.


class UserResponse(BaseModel):
    id: int
    username: str
    email: str

@app.post("/users/", response_model=UserResponse)
async def create_user(user: UserCreate):
    dummy_id = 1  # 실제 데이터베이스 쿼리가 필요한 부분
    return UserResponse(id=dummy_id, username=user.username, email=user.email)

여기서 response_model 매개변수를 통해 FastAPI는 자동으로 응답 JSON을 UserResponse에 맞춰서 반환하고, 그 구조를 문서화합니다.

4. 전체 구현 예제

지금까지의 내용을 종합하여 간단한 FastAPI 애플리케이션을 구현해 보겠습니다. 이 예제는 사용자 정보를 관리하는 API를 포함하고 있습니다.


from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

class UserCreate(BaseModel):
    username: str
    email: str

class UserResponse(BaseModel):
    id: int
    username: str
    email: str

users_db = {}

@app.post("/users/", response_model=UserResponse)
async def create_user(user: UserCreate):
    user_id = len(users_db) + 1
    users_db[user_id] = user
    return UserResponse(id=user_id, username=user.username, email=user.email)

@app.get("/users/", response_model=List[UserResponse])
async def get_users():
    return [UserResponse(id=user_id, username=user.username, email=user.email) for user_id, user in users_db.items()]

위의 코드는 두 개의 엔드포인트를 구현합니다. 하나는 사용자 생성 엔드포인트이고, 다른 하나는 모든 사용자를 조회하는 엔드포인트입니다. 데이터베이스를 사용하지 않고 간단한 파이썬 딕셔너리로 데이터를 관리할 수 있습니다.

5. 데이터 유효성 검사

FastAPI는 Pydantic 모델에 정의된 타입에 따라 자동으로 데이터의 유효성을 검사합니다. 예를 들어, 클라이언트가 잘못된 데이터 타입 또는 필수 필드를 누락하여 요청하면 FastAPI는 422 Unprocessable Entity 오류로 응답합니다.

5.1 유효성 검사와 에러 처리

FastAPI는 유효성 검사 오류를 자동으로 처리하며, 상황에 맞는 오류 메시지를 제공합니다. 이를 통해 사용자에게 좀 더 친절한 API를 제공할 수 있습니다.


{
    "detail": [
        {
            "loc": ["body", "username"],
            "msg": "field required",
            "type": "value_error.missing"
        }
    ]
}

위와 같은 JSON 형식의 에러 메시지는 클라이언트가 어떤 필드를 누락했는지 쉽게 이해할 수 있도록 도와줍니다.

6. 문서화

FastAPI의 장점 중 하나는 Swagger UI와 ReDoc을 자동으로 생성하여 API 문서를 쉽게 확인할 수 있는 기능입니다. 이를 통해 관리자는 API의 사용법을 직관적으로 이해하고, 클라이언트도 API 사용법을 쉽게 파악할 수 있습니다.

서버를 실행한 후, http://127.0.0.1:8000/docs에 접속하면 Swagger UI를 통해 API 문서를 확인할 수 있습니다.

7. 결론

이번 글에서는 FastAPI를 사용하여 스키마를 정의하고, 요청과 응답을 처리하는 방법에 대해 자세히 알아보았습니다. Pydantic 모델을 활용하여 데이터의 유효성을 체크하고, 다양한 API 설계를 통해 안정적이고 효율적인 백엔드를 구축할 수 있습니다.

FastAPI는 생태계가 활발하고, 지속적으로 발전하는 프레임워크로, 모든 Python 개발자에게 유용한 도구가 될 것입니다. 효과적으로 FastAPI를 활용하여 고품질의 웹 서비스 또는 API를 구축해보세요!

이글이 FastAPI를 사용하는 데 도움이 되었길 바랍니다. 추가적인 질문이 있다면 언제든지 댓글로 남겨주세요!

FastAPI 서버개발, Pydantic을 이용한 데이터 모델링

FastAPI는 현대적인 웹 API를 빠르게 구축할 수 있도록 도와주는 경량의 웹 프레임워크입니다. Python의 비동기 기능을 활용하여 매우 높은 성능을 제공하며, 개발자에게는 사용의 용이성과 명확한 문서화를 제공합니다. 본 글에서는 FastAPI 서버 개발과 Pydantic을 이용한 데이터 모델링에 대해 자세히 설명하겠습니다.

1. FastAPI란?

FastAPI는 Python 3.6 이상의 타입 힌트를 적극적으로 활용하여 API 문서를 자동으로 생성할 수 있는 프레임워크입니다. RESTful API, GraphQL API를 쉽게 만들 수 있으며, 비동기 처리를 지원하여 높은 성능을 제공합니다.

1.1 특징

  • 높은 성능: 스타트업과 규모가 큰 프로젝트에서 동시에 사용할 수 있을 정도로 빠릅니다.
  • 간편한 사용법: Flask와 유사한 방식으로 쉽게 배울 수 있습니다.
  • 자동 문서화: OpenAPI와 JSON Schema를 기반으로 API 문서가 자동으로 생성됩니다.
  • 타입 안전성: Pydantic과의 통합을 통해 데이터 검증과 변환이 매우 쉽고 안전합니다.

2. Pydantic이란?

Pydantic은 Python 데이터 검증 및 설정 관리 도구입니다. Python의 타입 힌트를 활용하여 입력된 데이터의 유효성을 검사하고, 데이터 변환 및 직렬화를 관리합니다. FastAPI는 Pydantic을 모델의 입력 및 출력을 다루는 데 활용합니다.

2.1 Pydantic의 주요 기능

  • 데이터 유효성 검사: 입력된 데이터가 지정된 형식에 맞는지 확인합니다.
  • 데이터 직렬화 및 역직렬화: 모델 인스턴스를 JSON과 같은 형식으로 쉽게 변환할 수 있습니다.
  • 에러 메시지: 데이터 검증 시 쉽게 이해할 수 있는 에러 메시지를 제공합니다.
  • 환경 변수 지원: .env 파일을 통해 환경 변수를 쉽게 로드할 수 있습니다.

3. FastAPI 및 Pydantic 설치하기

FastAPI와 Pydantic은 pip를 통해 쉽게 설치할 수 있습니다. 다음 명령어를 사용하여 설치합니다:

pip install fastapi uvicorn pydantic

여기서 uvicorn은 ASGI 서버로 FastAPI 애플리케이션을 실행하는 데 사용됩니다.

4. FastAPI 서버 개발하기

우선 FastAPI 애플리케이션을 생성한 후, Pydantic 모델을 사용하여 데이터 모델링을 시작합니다. 간단한 예제로 북(Book) API를 만들어보겠습니다.

4.1 FastAPI 애플리케이션 생성

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello, FastAPI!"}

4.2 Pydantic 모델 생성

이제 API에 사용할 Pydantic 모델을 정의해 보겠습니다. 북(Book) 모델을 정의하려면 다음과 같이 작성할 수 있습니다:

from pydantic import BaseModel
from typing import Optional

class Book(BaseModel):
    id: int
    title: str
    author: str
    description: Optional[str] = None
    year: Optional[int] = None

4.3 API 엔드포인트 추가하기

이제 FastAPI 애플리케이션에 북 데이터를 추가하고 가져오는 엔드포인트를 추가합니다:

books = []

@app.post("/books/", response_model=Book)
async def create_book(book: Book):
    books.append(book)
    return book

@app.get("/books/{book_id}", response_model=Book)
async def read_book(book_id: int):
    for book in books:
        if book.id == book_id:
            return book
    return {"error": "Book not found"}

5. API 테스트하기

API를 테스트하기 위해서는 Uvicorn 서버를 실행하고, Postman이나 curl과 같은 도구를 사용할 수 있습니다. 아래 명령어로 서버를 실행합니다:

uvicorn main:app --reload

이제 브라우저에서 http://127.0.0.1:8000/docs에 접속하면 FastAPI가 자동으로 생성한 API 문서를 확인할 수 있습니다.

6. Pydantic의 고급 기능

Pydantic은 단순한 데이터 모델링 외에도 다음과 같은 여러 고급 기능을 제공합니다:

6.1 Validation (유효성 검사)

Pydantic은 유효성 검사기를 사용자 정의하여 제대로 사용하지 않은 형식이나 잘못된 값에 대해 쉽게 제어할 수 있습니다:

from pydantic import constr

class User(BaseModel):
    username: constr(min_length=4, max_length=20)
    email: EmailStr

    class Config:
        anystr_strip_whitespace = True

6.2 Nested Models (중첩 모델)

Pydantic 모델은 서로 중첩될 수 있어 복잡한 데이터 구조를 작업하는 데 매우 유용합니다:

class Publisher(BaseModel):
    name: str
    address: Optional[str] = None

class BookWithPublisher(BaseModel):
    title: str
    author: str
    publisher: Publisher

7. 결론

FastAPI와 Pydantic을 함께 사용하면 효율적이고 강력한 웹 API를 쉽게 구축할 수 있습니다. FastAPI의 비동기 처리 능력과 Pydantic의 데이터 유효성 검사는 개발 생산성을 극대화하는 데 주요한 요소입니다. 본 강좌에서는 간단한 예제를 통해 FastAPI와 Pydantic을 사용하여 데이터 모델링의 기초를 살펴봤습니다. 이를 바탕으로 더 복잡한 API를 설계하고 구현할 수 있습니다. FastAPI와 Pydantic을 통해 여러분의 프로젝트에 강력한 웹 API를 추가해보시기 바랍니다.

8. 참고 자료

FastAPI 서버개발, 경로 매개변수와 쿼리 매개변수

FastAPI는 Python으로 만든 웹 프레임워크로, 빠른 성능과 쉬운 사용성을 자랑합니다. 특히 RESTful API를 구축하는 데 강력한 도구를 제공합니다. 본 글에서는 FastAPI의 경로 매개변수와 쿼리 매개변수의 개념과 이들의 활용 방식에 대해 자세히 살펴보겠습니다.

1. FastAPI 개요

FastAPI는 스타트업부터 대규모 애플리케이션까지 다양한 환경에서 사용되는 현대적인 웹 프레임워크입니다. 이 프레임워크는 비동기 프로그래밍을 기본으로 하며, 자동 문서화 및 타입 검사를 지원합니다. 이러한 특징 덕분에 개발자는 효율적으로 API를 설계하고 구축할 수 있습니다.

1.1 FastAPI 설치하기

FastAPI를 사용하기 위해 먼저 FastAPI와 ASGI 서버(Uvicorn)를 설치해야 합니다. 아래의 명령어를 사용하여 설치할 수 있습니다.

pip install fastapi uvicorn

2. 경로 매개변수

경로 매개변수는 URL 경로의 일부로, 사용자가 요청하는 리소스를 동적으로 지정할 수 있게 해줍니다. URL 경로에서 변하는 부분을 변수처럼 설정하고, 이를 FastAPI 함수의 매개변수로 받아 처리할 수 있습니다.

2.1 경로 매개변수 사용 예제

다음은 경로 매개변수를 사용하는 간단한 FastAPI 애플리케이션의 예제입니다.

from fastapi import FastAPI

app = FastAPI()

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

위의 예에서 @app.get("/items/{item_id}")는 URL 경로의 item_id 부분을 매개변수로 받아, 이를 read_item 함수에서 사용할 수 있도록 합니다. 클라이언트가 /items/42와 같은 요청을 보내면, item_id는 42로 설정되고, JSON 형식으로 응답됩니다.

2.2 여러 경로 매개변수 사용하기

FastAPI에서는 여러 개의 경로 매개변수를 동시에 사용할 수 있습니다. 예를 들어, 다음과 같은 코드를 작성할 수 있습니다.

@app.get("/users/{user_id}/items/{item_id}")
async def read_user_item(user_id: int, item_id: int):
    return {"user_id": user_id, "item_id": item_id}

위의 예제는 사용자의 ID와 항목의 ID를 동시에 받아서 응답합니다. 클라이언트가 /users/1/items/10와 같은 요청을 보낼 경우, user_iditem_id는 각각 1과 10으로 설정됩니다.

3. 쿼리 매개변수

쿼리 매개변수는 URL 경로 뒤에 추가되는 파라미터로, 클라이언트가 특정 데이터를 필터링하거나 페이지네이션할 때 종종 사용됩니다. URL의 물음표(?) 뒤에 설정되며, 여러 개의 매개변수를 “&”로 구분할 수 있습니다.

3.1 쿼리 매개변수 사용 예제

다음은 쿼리 매개변수를 사용하는 예제입니다.

@app.get("/items/")
async def read_items(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

위 코드는 기본적으로 skiplimit 값을 받는 요청을 처리하며, 기본값은 각각 0과 10입니다. 클라이언트에서 /items/?skip=10&limit=5와 같은 요청을 보내면, skip은 10, limit은 5로 설정됩니다.

3.2 쿼리 매개변수와 경로 매개변수 혼용하기

FastAPI에서는 경로 매개변수와 쿼리 매개변수를 동시에 사용할 수 있습니다. 아래는 그 예제입니다.

@app.get("/users/{user_id}/items/")
async def read_user_items(user_id: int, skip: int = 0, limit: int = 10):
    return {"user_id": user_id, "skip": skip, "limit": limit}

이 예제에서는 사용자의 ID를 경로 매개변수로 받고, skiplimit를 쿼리 매개변수로 사용합니다. 클라이언트가 /users/1/items/?skip=5&limit=10와 같은 요청을 보내면, 서버는 해당 사용자 ID와 쿼리 매개변수 값을 기반으로 응답을 처리합니다.

4. 경로 및 쿼리 매개변수의 유효성 검사

FastAPI는 Pydantic을 기반으로 하여 경로 및 쿼리 매개변수에 대한 유효성 검사를 자동으로 수행합니다. 타입 힌트를 사용하여 데이터 타입을 지정하면, 잘못된 형식의 데이터가 들어오는 경우 자동으로 422 Unprocessable Entity 응답이 발생합니다.

4.1 유효성 검사 예제

다음은 유효성 검사를 포함한 간단한 예제입니다.

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id <= 0:
        return {"error": "item_id는 1 이상의 정수여야 합니다."}
    return {"item_id": item_id}

위의 예제에서 item_id가 1보다 작거나 같을 경우 오류 메시지를 반환하며, 클라이언트에서는 항상 올바른 입력값을 제공해야 합니다.

5. 결론

FastAPI는 경로 매개변수와 쿼리 매개변수를 통해 RESTful API를 더욱 유연하고 편리하게 설계할 수 있는 강력한 기능을 제공합니다. 본 글에서 설명한 내용을 토대로 FastAPI를 활용하여 다양한 API 엔드포인트를 구축하고, 데이터 필터링 및 요청 처리를 보다 효율적으로 처리할 수 있습니다.

이제 여러분은 FastAPI에서 경로 매개변수와 쿼리 매개변수의 사용법을 익혔습니다. 이 기능을 바탕으로 더 복잡한 애플리케이션을 개발해 보시기 바랍니다. FastAPI의 높은 성능과 사용성을 경험하면서, 여러분의 프로젝트에 맞는 최적의 RESTful API를 구현해 보세요.

이 글이 FastAPI 서버 개발에 대한 실질적인 도움이 되었기를 바랍니다. 궁금한 점이나 추가적인 질문이 있다면 댓글로 남겨주십시오.

FastAPI 서버개발, FastAPI 애플리케이션 구조화

FastAPI는 현대적이고, 빠르며, 비동기적이며, 쉬운 RESTful API를 만드는 데 사용할 수 있는 훌륭한 프레임워크입니다. FastAPI를 사용하여 서버를 개발할 때, 애플리케이션 구조화는 확장성, 유지 보수성 및 팀 작업을 고려할 때 매우 중요한 요소입니다. 이 글에서는 FastAPI 애플리케이션을 구조화하는 방법에 대해 자세히 탐구해 보겠습니다.

1. FastAPI 소개

FastAPI는 Python 3.7 이상에서 사용할 수 있는 웹 프레임워크입니다. Starlette과 Pydantic을 기반으로 하여 빠른 속도와 높은 성능을 자랑합니다. FastAPI는 데이터 검증, 순서 매기기, 문서화 등의 기능을 내장하고 있어 개발자가 API를 더 쉽게 만들 수 있도록 도와줍니다. 또한, OpenAPI 스펙을 자동으로 생성하여 API 문서화를 빠르고 쉽게 할 수 있습니다.

FastAPI의 주요 특징

  • 비동기 지원: FastAPI는 비동기 프로그래밍을 지원하여 높은 성능을 제공합니다.
  • 자동화된 데이터 검증: Pydantic을 사용하여 입력 데이터를 자동으로 검증합니다.
  • 자동 생성된 API 문서: Swagger UI 및 ReDoc을 사용하여 API 문서를 자동으로 생성합니다.
  • 사용의 용이성: 개발자가 최소한의 코드로 API를 개발할 수 있도록 설계되었습니다.

2. FastAPI 애플리케이션 구조화의 필요성

대규모 애플리케이션에서 코드의 유지 보수성 및 확장성을 높이기 위해서는 명확한 구조화가 필수적입니다. FastAPI 애플리케이션을 구조화하는 방법은 다음과 같습니다:

  • 모듈화: 관련 성격을 가진 구성 요소들을 모아서 모듈 단위로 관리합니다.
  • 디렉토리 구조: 명확한 디렉토리 구조를 설계하여 코드의 가독성을 높입니다.
  • 프레임워크 활용: FastAPI의 내장 기능을 최대한 활용하여 반복된 코드를 줄입니다.

2.1 모듈화

모듈화를 통해 애플리케이션의 특정 기능이나 역할을 별도의 파일이나 디렉토리로 나누어 관리할 수 있습니다. 예를 들어, 사용자 인증, 데이터베이스 접근, API 라우팅 등을 각각의 모듈로 나누어 관리합니다.

2.2 디렉토리 구조

애플리케이션의 디렉토리 구조는 다음과 같은 형태로 구성할 수 있습니다:


my_fastapi_app/
├── app/
│   ├── main.py
│   ├── models/
│   │   └── user.py
│   ├── schemas/
│   │   └── user.py
│   ├── routes/
│   │   └── user.py
│   ├── database/
│   │   └── db.py
│   └── services/
│       └── user.py
└── requirements.txt

위의 디렉토리 구조는 FastAPI 애플리케이션의 기본적인 구조를 보여줍니다. 각 디렉토리의 역할은 다음과 같습니다:

  • main.py: FastAPI 애플리케이션의 진입점입니다. 모든 라우터를 포함하고, 데이터베이스 연결 등의 초기 설정을 수행합니다.
  • models: 데이터베이스 모델을 정의하는 곳입니다.
  • schemas: 데이터 검증 및 직렬화를 위한 Pydantic 모델을 정의합니다.
  • routes: API 엔드포인트를 설정합니다.
  • database: 데이터베이스 연결 및 세션 관리 관련 코드를 포함합니다.
  • services: 비즈니스 로직을 구현한 것입니다.

3. FastAPI 애플리케이션 구축 예제

이제 FastAPI 애플리케이션을 실제로 구축하는 과정을 단계별로 살펴보겠습니다.

3.1 환경 설정

먼저 FastAPI와 데이터베이스 클라이언트인 SQLAlchemy를 설치합니다. requirements.txt 파일에 다음과 같은 내용을 작성합니다:


fastapi
uvicorn
pydantic
sqlalchemy
databases

이제 다음 명령어를 통해 패키지를 설치합니다:

pip install -r requirements.txt

3.2 데이터베이스 설정

PostgreSQL 데이터베이스를 사용할 경우, 먼저 .env 파일을 만들어 환경 변수를 설정해야 합니다. .env 파일의 내용은 다음과 같습니다:


DATABASE_URL=postgresql://username:password@localhost/dbname

database/db.py 파일을 작성하여 데이터베이스 연결을 설정합니다:


from sqlalchemy import create_engine, MetaData
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
import databases
import os

DATABASE_URL = os.getenv('DATABASE_URL')

database = databases.Database(DATABASE_URL)
metadata = MetaData()
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

3.3 모델 만들기

models/user.py 파일에서 User 모델을 정의합니다:


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

class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    email = Column(String, unique=True, index=True)

3.4 스키마 만들기

schemas/user.py 파일에서 Pydantic 모델을 정의합니다:


from pydantic import BaseModel

class UserBase(BaseModel):
    username: str
    email: str

class UserCreate(UserBase):
    password: str

class User(UserBase):
    id: int

    class Config:
        orm_mode = True

3.5 라우터 만들기

routes/user.py 파일에서 라우터를 정의합니다:


from fastapi import APIRouter, Depends
from ..models.user import User
from ..schemas.user import UserCreate, User
from ..database.db import SessionLocal

router = APIRouter()

@router.post("/users/", response_model=User)
async def create_user(user: UserCreate):
    async with SessionLocal() as db:
        db_user = User(username=user.username, email=user.email)
        db.add(db_user)
        await db.commit()
        await db.refresh(db_user)
        return db_user

3.6 메인 애플리케이션 설정

app/main.py 파일에서 FastAPI 애플리케이션을 구성합니다:


from fastapi import FastAPI
from .database.db import database
from .routes import user

app = FastAPI()

app.include_router(user.router)

@app.on_event("startup")
async def startup():
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

3.7 서버 실행

이제 Uvicorn를 사용하여 서버를 실행할 준비가 되었습니다. 다음 명령어로 서버를 실행합니다:

uvicorn app.main:app --reload

3.8 Swagger UI로 테스트하기

서버가 실행되면 http://localhost:8000/docs에서 Swagger UI를 통해 API를 테스트할 수 있습니다. 이곳에서 생성한 API 엔드포인트를 자동으로 확인하고, 요청을 수행할 수 있습니다.

4. 결론

FastAPI는 현대적인 API를 개발하는 데 매우 유용한 프레임워크입니다. 애플리케이션을 구조화하는 것은 코드의 가독성, 유지 보수성 및 확장성을 높이는 데 중요한 역할을 합니다. 위에서 설명한 방법으로 FastAPI 애플리케이션의 구조를 설계하고 구현하면, 더욱 체계적이고 효율적인 백엔드 서버를 개발할 수 있습니다.

FastAPI의 다양한 기능을 최대한 활용하고, 모듈화 및 디렉토리 구조를 잘 설계하여 안정적이고 확장 가능한 애플리케이션을 구축해 보세요. 추가적인 조언과 도움을 원하신다면 FastAPI 문서 및 커뮤니티를 참고하시기 바랍니다.