FastAPI 서버개발, 스키마 – 응답, 응답 타입 정의

FastAPI는 현대적인 웹 API를 구축하는 데 최적화된 Python 웹 프레임워크로, 성능과 빠른 개발 속도를 제공합니다. FastAPI의 주요 장점 중 하나는 데이터 유효성 검사와 자동 문서 생성을 위한 Pydantic의 사용입니다. 본 글에서는 FastAPI에서 응답 스키마를 정의하는 방법과 다양한 응답 타입을 설정하는 방법에 대해 깊이 있게 알아보겠습니다.

1. FastAPI와 Pydantic 소개

FastAPI는 백엔드 서버 개발을 위한 고성능 프레임워크로, RESTful API를 간편하게 구축할 수 있게 도와줍니다. FastAPI의 핵심 특징 중 하나는 Pydantic을 통한 데이터 유효성 검사 및 직렬화입니다. Pydantic을 사용하면 데이터 모델을 선언적으로 정의할 수 있으며, 데이터의 유효성을 체크할 수 있습니다.

예를 들어, 사용자의 정보를 담는 데이터 모델을 아래와 같이 정의할 수 있습니다.

from pydantic import BaseModel

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

2. FastAPI에서의 응답 스키마 정의

FastAPI에서 API의 응답을 정의하려면 Pydantic 모델을 사용합니다. 이 모델은 API가 클라이언트에게 반환하는 데이터의 구조를 정의합니다. 이렇게 하면 일관된 응답 형식을 보장하고 클라이언트는 예측 가능한 방식으로 데이터를 처리할 수 있습니다.

다음은 사용자의 정보를 반환하는 API 엔드포인트를 만드는 예제입니다.

from fastapi import FastAPI

app = FastAPI()

@app.get("/users/{user_id}", response_model=User)
async def get_user(user_id: int):
    return User(id=user_id, name="John Doe", email="johndoe@example.com")

위 코드에서 response_model=User를 설정함으로써 FastAPI는 이 API가 반환하는 데이터가 User 모델의 형식에 맞도록 자동으로 유효성 검사를 수행합니다. 그리고 스웨거 문서에서도 이 모델의 구성 정보를 확인할 수 있습니다.

3. 복잡한 응답 모델 정의

API의 응답은 때로는 단순하지 않을 수 있습니다. 여러 개의 모델을 포함한 복잡한 응답 구조를 정의해야 할 수도 있습니다. 예를 들어, 게시물과 그에 대한 댓글을 포함하는 구조를 생각해 보겠습니다.

class Comment(BaseModel):
    id: int
    content: str
    user_id: int

class Post(BaseModel):
    id: int
    title: str
    content: str
    comments: List[Comment]  # 댓글 목록

이러한 모델을 사용하여 게시물 정보를 반환하는 엔드포인트를 정의할 수 있습니다.

from typing import List

@app.get("/posts/{post_id}", response_model=Post)
async def get_post(post_id: int):
    comments = [Comment(id=1, content="Great post!", user_id=1), 
                Comment(id=2, content="Thanks for sharing!", user_id=2)]
    return Post(id=post_id, title="My First Post", content="This is the content.", comments=comments)

4. 응답 타입 정의와 자동 문서화

FastAPI는 자동으로 API 문서를 생성합니다. 위의 예제에서 API의 메타데이터는 FastAPI가 자동으로 생성하여 스웨거(Swagger)와 ReDoc 문서화 도구에서 확인할 수 있습니다. 응답 모델을 정의함으로써 클라이언트는 API를 사용할 때 어떤 형태의 데이터를 받을 수 있는지 명확하게 알 수 있습니다.

또한, FastAPI는 충분한 API 문서를 자동으로 제공하므로 프론트엔드 개발자가 필요한 API 정보를 쉽게 확인할 수 있습니다. 아래와 같이 문서화된 내용을 확인할 수 있습니다.

uvicorn main:app --reload

브라우저에서 http://127.0.0.1:8000/docs를 열면 Swagger UI를 통해 API의 모든 엔드포인트와 그 응답 형태를 확인할 수 있습니다.

5. 응답 시나리오: 성공, 실패 응답

실제 애플리케이션에서는 성공적인 응답뿐만 아니라 오류 처리도 포함되어야 합니다. FastAPI는 HTTPException을 사용하여 오류 응답을 정의할 수 있습니다. 아래 예시는 사용자가 존재하지 않을 경우 404 오류 응답을 반환하는 방법을 보여줍니다.

from fastapi import HTTPException

@app.get("/users/{user_id}", response_model=User)
async def get_user(user_id: int):
    if user_id != 1:  # 존재하지 않는 사용자 ID
        raise HTTPException(status_code=404, detail="User not found")
    return User(id=user_id, name="John Doe", email="johndoe@example.com")

5.1. 커스텀 오류 응답 모델

또한, 오류 발생 시에 반환하는 커스텀 응답 모델을 정의할 수도 있습니다. 예를 들어, 오류 응답을 나타내는 모델을 정의하고 이를 사용하여 일관된 오류 메시지를 클라이언트에 전달할 수 있습니다.

class ErrorResponse(BaseModel):
    detail: str
    status_code: int

@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
    return JSONResponse(
        status_code=exc.status_code,
        content={"detail": exc.detail, "status_code": exc.status_code},
    )

위와 같이 설정하면, 모든 HTTPException에 대해 일관된 구조의 오류 응답을 제공할 수 있습니다. 클라이언트에서는 응답을 쉽게 처리할 수 있습니다.

6. 응답 스키마와 API 버전 관리

API를 운영하다 보면 스키마가 변경되는 경우가 발생할 수 있습니다. 이를 잘 관리하기 위해 API 버전 관리를 고려해야 합니다. FastAPI는 경로에 버전 정보를 추가하여 서로 다른 버전의 API를 동시에 운영할 수 있습니다.

app_v1 = FastAPI()
app_v2 = FastAPI()

@app_v1.get("/users/{user_id}", response_model=User)
async def get_user_v1(user_id: int):
    return User(id=user_id, name="John Doe", email="janedoe@example.com")

@app_v2.get("/users/{user_id}", response_model=User)
async def get_user_v2(user_id: int):
    return User(id=user_id, name="Jane Doe", email="johndoe@example.com")

# Uvicorn을 통해 앱 실행
# uvicorn main:app_v1 --reload
# uvicorn main:app_v2 --reload

이렇게 각각의 버전마다 다른 응답을 제공할 수 있으므로, 기존 API를 사용하는 클라이언트는 새로운 변화에 영향을 받지 않고, 점진적으로 업데이트할 수 있습니다.

7. 결론

FastAPI는 그 자체의 뛰어난 성능과 직관적인 문서화, 유효성 검사 기능으로 인해 데이터 기반 애플리케이션을 개발하는 데 매우 유용한 도구입니다. 본 포스트에서는 FastAPI에서 응답 스키마를 정의하는 방법과 다양한 응답 타입 처리 방식을 자세히 살펴보았습니다.

스키마 정의는 API의 안정성과 일관성을 보장하는 데 매우 중요하며, 특히 여러 클라이언트 앱에서 사용할 때 그 중요성이 더욱 두드러집니다. FastAPI를 통해 빠르고 효율적으로 API를 구축하고 관리하는 방법을 이해하는 데 도움이 되었기를 바랍니다. 이제 여러분은 FastAPI를 사용하여 강력한 백엔드 시스템을 구축할 준비가 되었습니다!

FastAPI 서버개발, 배포, 의존 라이브러리 관리

FastAPI는 현대 웹 API를 구축하기 위해 설계된 고속 웹 프레임워크로, 파이썬의 타입 힌트를 활용하여 개발 효율성과 코드 품질을 한층 끌어올립니다. 본 글에서는 FastAPI의 기본 개념부터 시작하여, 서버 배포, 의존 라이브러리 관리에 대한 체계적인 설명과 함께 실용적인 예제 코드를 제공합니다.

1. FastAPI 소개

FastAPI는 비동기 프로그래밍을 지원하며, Python 3.6 이상에서 작동합니다. 이는 Starlette와 Pydantic을 기반으로 하며, 다음과 같은 특징을 가지고 있습니다:

  • 빠른 성능: FastAPI는 NodeJS의 Express, Go의 Gin과 같은 다른 프레임워크와 유사한 성능을 자랑합니다.
  • 자동화된 문서화: OpenAPI 및 JSON Schema를 기반으로 하여 자동으로 API 문서화가 이루어집니다.
  • 유효성 검사 및 직렬화: Pydantic을 사용하여 데이터 유효성 검사 및 직렬화를 지원합니다.

2. FastAPI 설치 및 기본 설정

FastAPI를 설치하기 위해 아래의 pip 명령어를 사용할 수 있습니다.

pip install fastapi uvicorn

2.1. 간단한 FastAPI 애플리케이션 만들기

아래의 코드는 기본적인 FastAPI 서버의 구조를 보여줍니다. 이 예제에서는 ‘/items/{item_id}’ 경로로 GET 요청을 처리하는 간단한 애플리케이션을 생성합니다.

from fastapi import FastAPI

app = FastAPI()

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

2.2. 서버 실행

위 코드를 main.py로 저장한 후 아래의 명령어로 서버를 실행합니다.

uvicorn main:app --reload

3. API 문서 자동 생성

FastAPI는 자동으로 API 문서를 생성하며, 브라우저에서 http://127.0.0.1:8000/docs에 접속하여 Swagger UI를 확인할 수 있습니다. 또한 http://127.0.0.1:8000/redoc를 통해 ReDoc 형식으로도 확인할 수 있습니다. 이는 개발 시 큰 도움이 되며, 클라이언트와의 소통에도 유용합니다.

4. 데이터 모델링과 Pydantic

FastAPI는 Pydantic을 이용하여 데이터 유효성을 검사하고 모델링을 지원합니다. 다음은 Pydantic을 사용하여 데이터 모델을 정의하는 예제입니다.

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

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

5. 의존성 주입

FastAPI는 의존성 주입을 통해 필요한 부분에서 최적의 코드 재사용성을 제공합니다. 아래는 의존성을 사용하여 데이터베이스 연결을 처리하는 예제입니다.

from fastapi import Depends

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

@app.get("/items/")
async def read_items(q: str = Depends(get_query)):
    return {"q": q}

6. 배포

FastAPI 애플리케이션을 배포하기 위해 여러 방법이 있으며, 일반적으로는 Docker와 클라우드 서비스 (AWS, GCP, Azure 등)를 사용합니다. 아래는 Docker를 이용한 배포 예시입니다.

6.1. Dockerfile 작성하기

프로젝트 루트 디렉토리에 Dockerfile을 생성하고 아래와 같이 작성합니다.

FROM python:3.9

WORKDIR /app

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

COPY ./ ./

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

6.2. Docker Compose 설정

Docker Compose를 사용하면 여러 컨테이너를 관리하기 용이합니다. 아래는 예시 docker-compose.yml 파일입니다.

version: '3.8'

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

6.3. 배포하기

Docker를 이용한 애플리케이션의 배포는 다음과 같은 명령어로 실행할 수 있습니다:

docker-compose up --build

7. 의존 라이브러리 관리

의존 라이브러리를 관리하기 위해 requirements.txt 파일을 사용합니다. 필요한 패키지를 설치 후 pip freeze 명령어로 생성할 수 있습니다.

pip freeze > requirements.txt

7.1. 가상 환경 설정

가상 환경을 통해 프로젝트마다 라이브러리를 독립적으로 관리할 수 있습니다. 아래의 명령어로 가상 환경을 설정하고 활성화할 수 있습니다.

python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate  # Windows

8. 결론

FastAPI는 데이터 모델링, API 문서화, 의존성 주입 등 다양한 기능을 통해 개발자에게 혜택을 제공합니다. 또한 Docker와의 조합으로 배포 또한 원활하게 이뤄질 수 있습니다. FastAPI를 통해 클린하고 유지보수하기 쉬운 서버 측 애플리케이션을 빠르게 개발할 수 있습니다.

References

FastAPI 서버개발, 스키마 – 응답, 타입 정의의 강력함

FastAPI는 현대적인 웹 API를 구축하기 위한 고성능 Python 프레임워크로, Starlette과 Pydantic을 기반으로 하고 있습니다. FastAPI는 개발자가 빠르게 API를 구축할 수 있도록 도와주지만, 이 프레임워크의 진정한 힘은 스키마와 타입 정의에 있습니다. 이 글에서는 FastAPI의 스키마를 이해하고, 응답 및 타입 정의가 어떻게 API의 안정성, 문서화, 유용성을 높이는지를 살펴보겠습니다.

1. FastAPI란?

FastAPI는 빠르고 쉽게 API를 구축할 수 있도록 도와주는 Python 웹 프레임워크입니다. 비동기 프로그래밍 지원, 데이터 검증 및 자동 문서화의 강력한 기능을 제공합니다. FastAPI는 특히 RESTful API를 설계하는 데 매우 유용하며, Pydantic을 통해 데이터 검증, 직렬화 및 문서화를 지원합니다.

2. 스키마의 개념

스키마(Schema)는 데이터 구조를 정의하는 청사진입니다. API에서 스키마를 정의함으로써 요청과 응답에서 어떤 데이터가 사용되는지 명확하게 알 수 있습니다. FastAPI에서는 Pydantic 모델을 사용하여 쉽게 스키마를 정의할 수 있습니다. 이러한 모델은 데이터의 유효성 검사를 자동으로 수행하고, 비즈니스 로직을 단순화합니다.

2.1 Pydantic 소개

Pydantic은 Python 데이터 클래스를 기반으로 하는 데이터 검증 및 설정 관리 라이브러리입니다. FastAPI와 통합되어 유효성 검사, 데이터 변환 및 스키마 생성 기능을 제공합니다. Pydantic은 타입 힌트를 사용하여 데이터를 정의하고, 덕타이핑(duck typing)을 통해 데이터 타입의 유효성을 검사합니다.

3. 타입 정의의 힘

FastAPI에서 타입 시스템은 API의 신뢰성을 높이고, 자동 문서화를 가능하게 합니다. 타입을 명시하면, FastAPI는 이를 기반으로 자동으로 API 문서를 생성합니다. 예를 들어, 사용자가 잘못된 타입의 데이터를 요청하면 FastAPI는 자동으로 오류를 반환합니다. 이를 통해 개발자는 보다 안전하고 일관된 API를 유지할 수 있습니다.

3.1 예제 코드와 설명

아래는 간단한 FastAPI 앱을 만드는 예제입니다.

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

app = FastAPI()

class Item(BaseModel):
    id: int
    name: str
    price: float

class ResponseModel(BaseModel):
    message: str
    items: List[Item]

@app.get("/items/", response_model=ResponseModel)
async def get_items():
    fake_items = [
        {"id": 1, "name": "Item 1", "price": 10.5},
        {"id": 2, "name": "Item 2", "price": 20.0},
    ]
    return {"message": "Items retrieved successfully", "items": fake_items}
        

위의 코드는 FastAPI와 Pydantic을 사용하여 간단한 GET API를 정의합니다. Item 클래스는 개별 아이템의 구조를 정의합니다. ResponseModel 클래스는 API 응답의 구조를 정의합니다. get_items 함수는 아이템 목록을 반환하며, 이때 response_model 파라미터를 사용해 응답 모델을 정의합니다. 이는 FastAPI가 자동으로 JSON 응답을 생성하고 문서화를 제공하는 데 도움을 줍니다.

4. 데이터 검증

Pydantic을 사용하면 데이터 검증을 쉽게 수행할 수 있습니다. 모델 정의 시 타입 힌트를 추가하면 FastAPI는 이 정보를 활용하여 API 요청을 검증합니다. 요청 데이터가 유효하지 않으면 FastAPI는 적절한 오류 메시지를 반환합니다.

4.1 요청 데이터 검증 예제

아래는 POST 요청으로 아이템을 추가하는 API의 예제입니다.


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

app = FastAPI()

class Item(BaseModel):
    id: int
    name: str
    price: float

items = []

@app.post("/items/", response_model=Item)
async def create_item(item: Item):
    for existing_item in items:
        if existing_item.id == item.id:
            raise HTTPException(status_code=400, detail="Item with this ID already exists.")
    items.append(item)
    return item
        

위의 코드는 POST 요청을 통해 새로운 아이템을 추가하는 API를 정의합니다. Item이 이미 존재하는지 확인하는 로직을 추가하여 데이터 유효성을 관리합니다. FastAPI는 자동으로 요청(body)을 Item 타입으로 변환하고, 타입 검증을 수행합니다.

5. 자동 문서화

FastAPI는 OpenAPI 스펙에 따라 API 문서를 자동으로 생성합니다. 이 문서에는 모든 엔드포인트, 요청 및 응답 모델이 나열되며, 사용자 친화적인 UI를 제공합니다. FastAPI의 자동화된 문서화 기능은 API의 사용성을 극대화하고, 개발자가 API를 보다 쉽게 이해하도록 도와줍니다.

5.1 Swagger UI와 ReDoc

FastAPI는 기본적으로 Swagger UI와 ReDoc을 지원합니다. 브라우저에서 http://localhost:8000/docs에 접근하면 Swagger UI를 통해 API 문서를 볼 수 있습니다. /redoc 경로를 통해 ReDoc을 사용할 수도 있습니다. 이 문서들은 API의 모든 엔드포인트, 파라미터, 데이터 모델에 대한 정보를 제공합니다.

6. 실전 예제 – 간단한 블로그 API

이제 FastAPI의 타입 정의와 스키마의 강력함을 실제로 구현해보겠습니다. 간단한 블로그 API를 구축하고, 포스트 및 댓글을 관리하는 기능을 추가해보겠습니다.

6.1 블로그 모델 정의


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

app = FastAPI()

class Comment(BaseModel):
    username: str
    content: str

class Post(BaseModel):
    id: int
    title: str
    content: str
    comments: List[Comment] = []

posts = []

@app.post("/posts/", response_model=Post)
async def create_post(post: Post):
    for existing_post in posts:
        if existing_post.id == post.id:
            raise HTTPException(status_code=400, detail="Post with this ID already exists.")
    posts.append(post)
    return post

@app.get("/posts/", response_model=List[Post])
async def get_posts():
    return posts
        

위의 코드는 블로그 포스트와 댓글을 정의하는 모델을 생성합니다. 블로그 API에는 포스트를 생성하고 조회하는 엔드포인트가 포함되어 있습니다. create_post 함수는 포스트 객체를 리스트에 추가하고, 중복 ID를 처리하기 위해 오류 처리를 수행합니다.

7. 결론

FastAPI는 빠르고 간편한 API 구축을 위한 강력한 도구입니다. Pydantic을 활용한 타입 정의와 스키마 관리 기능은 API의 안정성 및 문서화의 질을 높입니다. 이러한 기능들은 개발자가 보다 안전하고 효율적인 API를 설계할 수 있도록 도와줍니다.

본 글에서는 FastAPI의 기본 개념과 함께 스키마와 타입 정의의 중요성을 설명하였습니다. 실전 예제를 통해 API를 작성하는 과정에서 발생하는 여러 가지 상황을 다루었습니다. FastAPI의 도구들을 사용하면 API 개발이 더욱 효율적이고 즐거운 경험이 될 것입니다.

작성자: {Your Name}

날짜: {Current Date}

FastAPI 서버개발, FastAPI 애플리케이션을 Docker 컨테이너로 배포하기

FastAPI는 최신 Python 웹 프레임워크 중 하나로, 빠른 개발 속도와 높은 성능을 제공합니다. 특히 RESTful API를 쉽게 만드는 데 적합하며, 비동기 프로그래밍 모델을 지원하여 고성능 웹 서비스를 구축할 수 있습니다. 이 블로그 글에서는 FastAPI 애플리케이션을 Docker 컨테이너로 배포하는 방법을 자세히 설명하도록 하겠습니다.

목차

1. FastAPI 애플리케이션 만들기

FastAPI 애플리케이션을 만들기 위해서는 먼저 필요한 라이브러리를 설치해야 합니다. 아래 명령어를 사용하여 FastAPI와 UVicorn (ASGI 서버)을 설치합니다.

pip install fastapi uvicorn

이제 간단한 FastAPI 애플리케이션을 만들어 보겠습니다. 아래 코드는 기본적인 “Hello, World!” API를 생성합니다.

from fastapi import FastAPI

app = FastAPI()

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

위 코드를 main.py라는 이름의 파일로 저장합니다. 이 애플리케이션을 실행하기 위해서는 다음 명령어를 입력합니다.

uvicorn main:app --reload

이제 웹 브라우저를 열어 http://127.0.0.1:8000에 접속하면 {“Hello”: “World”}라는 JSON 응답을 확인할 수 있습니다.

2. Docker 환경 설정

Docker를 사용하면 FastAPI 애플리케이션을 컨테이너화하여 쉽게 배포할 수 있습니다. Docker가 설치되어 있지 않다면, [Docker 공식 웹사이트](https://www.docker.com/get-started)에서 설치할 수 있습니다.

Docker 설치가 완료되면, Docker가 정상적으로 작동하는지 확인하기 위해 아래 명령어를 입력해보세요.

docker --version

정상적으로 설치되었다면 Docker 버전이 출력될 것입니다.

3. Dockerfile 작성

Dockerfile은 Docker 이미지를 생성하기 위한 명세서입니다. FastAPI 애플리케이션을 Docker로 실행하기 위한 Dockerfile을 아래와 같이 작성합니다.

# Dockerfile
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.9

COPY ./app /app

# 애플리케이션 디렉토리 설정
WORKDIR /app

# 필요한 패키지 설치
RUN pip install --no-cache-dir fastapi

# UVicorn 서버를 사용하여 애플리케이션 실행
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

위 Dockerfile에서는 FROM tiangolo/uvicorn-gunicorn-fastapi:python3.9를 사용하여 FastAPI를 위한 기본 이미지를 설정합니다. 그 다음, 애플리케이션 파일을 Docker 이미지로 복사하고, 필요한 패키지를 설치한 후 UVicorn을 통해 FastAPI 애플리케이션을 실행하도록 설정합니다.

4. Docker 이미지 빌드

Dockerfile을 작성한 후, 이제 Docker 이미지를 빌드합니다. 다음 명령어를 사용하여 Docker 이미지를 생성할 수 있습니다.

docker build -t myfastapiapp .

여기서 -t 플래그는 이미지를 태그하는 것으로, 후에 컨테이너를 실행할 때 이 태그를 사용하게 됩니다.

5. Docker 컨테이너 실행

성공적으로 Docker 이미지를 빌드한 후, 이제 컨테이너를 실행할 수 있습니다. 아래 명령어를 사용하여 컨테이너를 실행합니다.

docker run -d --name fastapi_container -p 8000:80 myfastapiapp

여기서 -d 플래그는 디태치드 모드로 컨테이너를 실행하며, --name 플래그는 컨테이너의 이름을 설정합니다. -p 플래그는 로컬의 8000 포트를 Docker 컨테이너의 80 포트와 연결합니다.

컨테이너가 실행 중인지 확인하려면 다음 명령어를 입력합니다.

docker ps

이제 웹 브라우저를 열고 http://127.0.0.1:8000에 접속하면 FastAPI 애플리케이션이 정상적으로 작동하는 것을 확인할 수 있습니다.

6. 결론

이번 글에서는 FastAPI 애플리케이션을 Docker 컨테이너로 배포하는 방법을 다뤄보았습니다. FastAPI의 설치부터 시작하여 Docker 환경 설정, Dockerfile 작성, 이미지 빌드, 컨테이너 실행까지의 모든 과정을 살펴보았습니다. 이제 여러분은 FastAPI 애플리케이션을 손쉽게 Docker로 배포할 수 있는 기반을 갖추게 되셨습니다.

Docker는 애플리케이션을 컨테이너화하여 실행 환경을 일관되게 제공해주는 강력한 도구입니다. 이를 통해 개발자는 다양한 플랫폼에서 애플리케이션을 쉽게 배포하고 관리할 수 있습니다. FastAPI와 Docker의 조합은 현대의 웹 개발에서 필수적인 기술 중 하나가 될 것입니다.

앞으로도 FastAPI와 같은 최신 기술을 활용하여 더욱 향상된 웹 서비스 개발에 도전해보시기 바랍니다!

FastAPI 서버개발, aiomysql 설치

FastAPI는 파이썬으로 작성된 현대적인 웹 프레임워크로, APIs를 빠르게 구축하고 문서화하는 데 있어 효율성을 제공합니다. 이 글에서는 FastAPI를 사용하여 백엔드 서버를 개발하는 방법과 함께 비동기 MySQL 데이터베이스 클라이언트인 aiomysql의 설치 및 활용 방법에 대해 알아보겠습니다.

1. FastAPI 소개

FastAPI는 비동기 지원을 제공하며, Starlette 및 Pydantic을 기반으로 개발되었습니다. 이 프레임워크의 가장 큰 장점 중 하나는 데이터 검증 및 직렬화가 자동으로 이루어진다는 점입니다. 이는 개발자가 API를 개발하는 데 드는 시간을 크게 단축시켜 줍니다.

1.1 FastAPI의 주요 특징

  • 비동기 지원: 매우 빠른 성능을 제공합니다.
  • 자동 API Documentation: Swagger와 ReDoc을 통해 문서화가 자동으로 이루어집니다.
  • 데이터 검증: Pydantic을 사용해 데이터 검증이 자동으로 이루어집니다.
  • 의존성 주입: 쉽게 의존성을 설정하고 관리할 수 있습니다.

2. FastAPI 설치

FastAPI를 설치하기 위해서는 pip를 사용하여 간단히 설치할 수 있습니다. 다음 명령어를 입력해 설치해 주세요:

pip install fastapi[all]

3. 기본 FastAPI 애플리케이션 만들기

FastAPI를 설치한 후, 기본 애플리케이션을 만들어 보겠습니다. 아래 예제 코드를 사용하여 main.py라는 파일을 생성하고, 다음 코드를 붙여 넣습니다:

from fastapi import FastAPI

app = FastAPI()

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

위 코드는 기본 FastAPI 애플리케이션을 설정하는 코드로, 루트 endpoint에 GET 요청을 보내면 {"Hello": "World"}라는 JSON 응답을 반환합니다. FastAPI 서버를 실행하려면 다음 명령어를 터미널에 입력하세요:

uvicorn main:app --reload

여기서 --reload 옵션은 코드 변경 시 서버를 자동으로 재시작해 주는 기능을 제공합니다. 서버가 실행되면 http://127.0.0.1:8000 주소에서 애플리케이션을 확인할 수 있습니다.

4. aiomysql 설치

이제 FastAPI 애플리케이션에 MySQL 데이터베이스를 연결하기 위해 aiomysql을 설치해 보겠습니다. aiomysql은 asyncio 기반의 MySQL 클라이언트로, 비동기적으로 MySQL과 상호작용할 수 있도록 해줍니다. aiomysql을 설치하기 위해 아래 명령어를 실행합니다:

pip install aiomysql

5. MySQL 데이터베이스 설정

설치가 완료되면 MySQL 서버를 준비해야 합니다. MySQL 서버를 실행하고, 아래 명령어를 사용하여 새 데이터베이스를 생성합니다:

CREATE DATABASE fastapi_db;

5.1 데이터베이스 테이블 생성

데이터베이스 안에 사용할 테이블을 생성해보겠습니다. 예를 들어 Users라는 테이블을 생성하고, 사용자 정보를 저장해보겠습니다:

CREATE TABLE Users (
        id INT AUTO_INCREMENT PRIMARY KEY,
        name VARCHAR(100) NOT NULL,
        email VARCHAR(100) NOT NULL UNIQUE
    );

6. FastAPI와 aiomysql 통합

이제 FastAPI 애플리케이션에서 MySQL에 연결해 보겠습니다. 아래 코드는 FastAPI와 aiomysql을 사용하여 데이터베이스에 연결하고, 데이터를 삽입하고 조회하는 기본적인 API를 만드는 방법을 보여줍니다. 아래 코드를 main.py에 추가하세요:

import aiomysql
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional

app = FastAPI()

# MySQL 데이터베이스 연결 설정
DB_CONFIG = {
    "host": "localhost",
    "port": 3306,
    "user": "your_username",
    "password": "your_password",
    "db": "fastapi_db"
}

# 데이터 모델 정의
class User(BaseModel):
    name: str
    email: str

# 비동기 함수: 데이터베이스 연결
async def get_db_connection():
    conn = await aiomysql.connect(**DB_CONFIG)
    return conn

# 사용자 추가
@app.post("/users/", response_model=User)
async def create_user(user: User):
    conn = await get_db_connection()
    async with conn.cursor() as cursor:
        await cursor.execute("INSERT INTO Users (name, email) VALUES (%s, %s)", (user.name, user.email))
        await conn.commit()
        user_id = cursor.lastrowid
    conn.close()
    return {**user.dict(), "id": user_id}

# 사용자 목록 조회
@app.get("/users/", response_model=List[User])
async def read_users():
    conn = await get_db_connection()
    async with conn.cursor(aiomysql.DictCursor) as cursor:
        await cursor.execute("SELECT * FROM Users")
        result = await cursor.fetchall()
    conn.close()
    return result
    

6.1 API 테스트

이제 FastAPI 애플리케이션을 다시 실행한 후 API를 테스트해보세요. 예를 들어, 사용자 추가를 위해 다음과 같은 POST 요청을 보낼 수 있습니다:

curl -X POST "http://127.0.0.1:8000/users/" -H "Content-Type: application/json" -d "{\"name\": \"John\", \"email\": \"john@example.com\"}"

이 후, 사용자 목록 조회를 위해 다음 GET 요청을 보낼 수 있습니다:

curl -X GET "http://127.0.0.1:8000/users/"

7. 에러 핸들링

FastAPI에서의 에러 핸들링은 매우 간단합니다. 예를 들어, 사용자가 이메일을 중복해서 추가하려 할 경우를 처리하기 위한 기능을 추가해 보겠습니다:

from fastapi import HTTPException

@app.post("/users/", response_model=User)
async def create_user(user: User):
    conn = await get_db_connection()
    async with conn.cursor() as cursor:
        await cursor.execute("SELECT * FROM Users WHERE email = %s", (user.email,))
        existing_user = await cursor.fetchone()
        if existing_user:
            raise HTTPException(status_code=400, detail="Email already registered")
        await cursor.execute("INSERT INTO Users (name, email) VALUES (%s, %s)", (user.name, user.email))
        await conn.commit()
        user_id = cursor.lastrowid
    conn.close()
    return {**user.dict(), "id": user_id}
    

8. 마치며

FastAPI는 간단하면서도 매우 강력한 웹 프레임워크입니다. aiomysql을 통해 비동기적으로 MySQL과 연결하는 방법을 배웠습니다. 이를 통해 데이터를 효율적으로 관리하고 빠른 성능을 구현할 수 있습니다. 추가적으로, FastAPI의 다양한 기능(예: 의존성 주입, 더 복잡한 데이터 모델 등)을 탐구하며 더 발전된 애플리케이션을 만들어보길 바랍니다.

감사합니다!