[카테고리:] FastAPI서버개발

FastAPI는 성능이 뛰어나고 사용하기 쉬운 웹 프레임워크로, Python으로 웹 API를 구축하는 데 많은 인기를 끌고 있습니다. 본 글에서는 FastAPI를 사용하여 파일 다운로드 및 스트리밍을 구현하는 방법에 대해 다루겠습니다. 파일 다운로드 기능은 웹 애플리케이션에서 사용자의 데이터를 쉽게 받을 수 있게 해주며, 대용량 파일 스트리밍 처리 또한 많은 경우에 중요합니다.

1. FastAPI 소개

FastAPI는 Python에서 API를 쉽고 빠르게 생성할 수 있도록 도와주는 모던한 웹 프레임워크입니다. 많은 기능이 내장되어 있으며, 특히 자동으로 문서화하는 기능과 유효성 검사를 지원합니다. FastAPI의 장점은 다음과 같습니다:

• 높은 성능과 비동기 처리를 지원
• 자동 문서화
• 유효성 검사 및 데이터 검사기 지원
• 간단한 설정과 직관적인 API 디자인

2. 필요한 라이브러리 설치

먼저 FastAPI와 파일 처리를 위한 Uvicorn 및 aiofiles를 설치해야 합니다. Uvicorn은 ASGI 서버로, FastAPI 앱을 실행하는 데 필요한 서버입니다. aiofiles는 비동기 파일 처리를 도와줍니다.

bash
pip install fastapi uvicorn aiofiles

3. 기본 FastAPI 서버 설정

FastAPI 애플리케이션을 설정하고 기본 엔드포인트를 생성하는 방법에 대해 설명하겠습니다.

python
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Welcome to FastAPI!"}

위의 코드를 사용하여 기본 FastAPI 서버를 생성했습니다. 이제 Uvicorn을 사용하여 이 앱을 실행할 수 있습니다.

bash
uvicorn main:app --reload

4. 파일 다운로드 구현

이제 파일 다운로드 기능을 구현해 보겠습니다. 사용자가 특정 파일을 요청할 때 해당 파일을 클라이언트로 다운로드할 수 있게 하는 API를 제작합니다.

python
import os
from fastapi import FastAPI
from fastapi.responses import FileResponse

app = FastAPI()

@app.get("/download/{file_name}")
async def download_file(file_name: str):
    file_path = os.path.join("files", file_name)  # 'files' 디렉토리에서 파일을 찾습니다.
    if os.path.exists(file_path):
        return FileResponse(file_path)
    return {"error": "File not found"}

위의 코드는 ‘files’ 디렉토리 내의 파일을 다운로드할 수 있도록 합니다. 파일이 존재하지 않을 경우 오류 메시지를 반환합니다. FastAPI의 FileResponse 클래스를 사용하여 파일을 클라이언트에 전송합니다.

5. 파일 스트리밍 처리

파일 스트리밍은 대용량 파일을 클라이언트에 전달할 때 중요합니다. FastAPI에서 파일 스트리밍을 구현하는 방법을 알아보겠습니다. 스트리밍 처리는 StreamingResponse 클래스를 사용하여 구현됩니다.

python
from fastapi import FastAPI
from fastapi.responses import StreamingResponse

@app.get("/stream/{file_name}")
async def stream_file(file_name: str):
    file_path = os.path.join("files", file_name)
    if os.path.exists(file_path):
        def iter_file():
            with open(file_path, "rb") as file:
                yield from file  # 파일을 읽어서 스트리밍합니다.
        
        return StreamingResponse(iter_file(), media_type="application/octet-stream")
    return {"error": "File not found"}

위 코드는 요청된 파일을 스트리밍 방식으로 전달합니다. iter_file 함수는 파일의 내용을 바이트 스트림 형태로 읽어 클라이언트에 전송하는 역할을 합니다. 이를 통해 고객은 대형 파일을 점진적으로 받을 수 있습니다.

6. 멀티프레드 다운로드

파일 다운로드를 최적화하기 위해 멀티프레드 다운로드를 구현할 수 있습니다. 이는 파일을 여러 개의 작은 조각으로 나누어 동시에 다운로드하도록 하는 것입니다. 하지만 FastAPI에는 기본적으로 멀티프레드 다운로드 기능이 제공되지 않으므로 클라이언트 측에서 이를 구현해야 합니다.

7. 결론

이글에서는 FastAPI를 사용하여 파일 다운로드 및 스트리밍 기능을 구현하는 방법에 대해 알아보았습니다. FastAPI는 이러한 기능을 쉽게 구현할 수 있게 해주며, 비동기 처리로 성능을 극대화할 수 있습니다. 여러분의 프로젝트에서도 FastAPI를 활용해 보시기 바랍니다.

이제 여러분은 FastAPI의 파일 다운로드 및 스트리밍 처리에 대한 기본적인 이해를 얻으셨습니다. 더 깊이 있는 조사를 통해 FastAPI의 모든 기능을 활용해 보시기 바랍니다.

FastAPI는 Python을 기반으로 한 비동기 웹 프레임워크로, RESTful API를 쉽게 개발할 수 있도록 지원합니다. 이 강좌에서는 FastAPI를 이용한 백엔드 서버 개발 과정에서 중요한 컴포넌트 중 하나인 데이터 스키마 및 타입 힌트에 대해 자세히 다루겠습니다. 특히, FastAPI의 데이터 검증, 직렬화, 그리고 명확한 API 문서를 생성하는 데 있어 스키마와 타입 힌트가 어떻게 사용되는지를 중점적으로 설명하겠습니다.

1. FastAPI 소개

FastAPI는 Starlette를 기반으로 하여 개발된 현대적인 웹 프레임워크입니다. 비동기 프로그래밍을 지원하며, Python의 타입 힌트를 사용하여 코드의 가독성과 유지보수성을 높입니다. FastAPI는 다음과 같은 주요 기능을 제공합니다:

• 자동으로 생성되는 OpenAPI 문서
• 데이터 검증 및 직렬화를 위한 Pydantic 모델
• 고속 비동기 요청 처리
• 의존성 주입 시스템

2. 데이터 스키마와 Pydantic

FastAPI에서 데이터 스키마는 Pydantic 모델을 통해 정의됩니다. Pydantic은 데이터 타입과 유효성을 검증하는 데 강력한 도구로, Python의 타입 힌트를 활용하여 코드의 명확성을 높여줍니다.

2.1 Pydantic 모델 생성

Pydantic 모델은 클래스를 정의하고, 변수에 타입 힌트를 작성하여 쉽게 생성할 수 있습니다. 예를 들어, 사용자 정보를 나타내는 모델을 만들어보겠습니다.

from pydantic import BaseModel

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

위 코드에서 BaseModel을 상속한 User 클래스는 사용자 정보를 나타내는 모델입니다. 각 필드는 타입 힌트와 함께 정의되어 있으며, FastAPI는 이 정보를 기반으로 요청 데이터의 유효성을 자동으로 검사합니다.

2.2 모델의 유효성 검사

Pydantic 모델은 요청 본문에서 전송된 데이터의 유효성을 자동으로 검사할 수 있습니다. 예를 들어, 잘못된 형식의 데이터가 전송된 경우, FastAPI는 422 Unprocessable Entity 에러를 반환합니다. 아래 예제를 살펴보겠습니다.

from fastapi import FastAPI, HTTPException

app = FastAPI()

@app.post("/users/")
async def create_user(user: User):
    return user

위와 같은 API 엔드포인트가 있을 때, 클라이언트가 잘못된 데이터 형식으로 요청을 보내면 FastAPI는 오류 메시지를 포함한 422 응답을 반환합니다.

3. 요청과 응답

FastAPI는 HTTP 요청을 수신하고 응답하는 과정을 매우 간단하게 만들어줍니다. 요청의 데이터 형식을 Pydantic 모델로 정의하는 것뿐만 아니라, 응답 데이터의 형식도 동일하게 정의할 수 있습니다.

3.1 데이터 응답 스키마 정의하기

응답 데이터를 위해 Pydantic 모델을 사용할 수 있으며, 이를 통해 클라이언트에게 반환되는 데이터의 형식을 명확하게 정의할 수 있습니다. 아래 예제를 살펴보겠습니다.

from typing import List

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

@app.get("/users/", response_model=List[UserResponse])
async def read_users():
    return [{"id": 1, "username": "user1", "email": "user1@example.com"},
            {"id": 2, "username": "user2", "email": "user2@example.com"}]

이 예제에서 response_model 매개변수를 사용하여 FastAPI에게 이 엔드포인트의 응답 데이터의 형식을 알려주고 있습니다. 클라이언트는 항상 정의된 형식에 따른 응답을 받게 되어있습니다.

3.2 상태 코드와 응답 메시지

FastAPI는 HTTP 상태 코드 및 메시지를 제어할 수 있는 유연성을 제공합니다. HTTPException 클래스를 사용하면 예외 상황에 맞게 상태 코드를 설정할 수 있습니다. 예시를 살펴보겠습니다.

@app.get("/users/{user_id}", response_model=UserResponse)
async def read_user(user_id: int):
    if user_id == 1:
        return {"id": 1, "username": "user1", "email": "user1@example.com"}
    elif user_id == 2:
        return {"id": 2, "username": "user2", "email": "user2@example.com"}
    else:
        raise HTTPException(status_code=404, detail="사용자를 찾을 수 없습니다.")

위의 코드에서 유효하지 않은 사용자 ID가 전달되면, FastAPI는 404 상태 코드와 함께 예외 메시지를 반환합니다.

4. 타입 힌트의 중요성

타입 힌트는 FastAPI를 포함한 Python 코드에서 중요한 역할을 합니다. 명확한 타입을 선언함으로써 코드의 가독성이 높아지고, IDE 또는 정적 분석 도구의 도움을 받아 코드를 작성할 때 더 많은 도움을 받을 수 있습니다.

4.1 IDE 통합

타입 힌트는 IDE에서 코드 자동 완성 기능을 지원하고, 코드 검사의 정확성을 높입니다. 예를 들어, 잘못된 타입의 인자를 전달하려고 할 때 미리 알림을 받을 수 있습니다.

4.2 문서화 자동화

FastAPI는 OpenAPI와 Swagger UI를 통해 자동 문서화를 지원합니다. 타입 힌트와 Pydantic 모델을 기반으로 API의 인터페이스가 자동으로 생성되므로, 개발자와 클라이언트 모두 API 사용법을 이해하기 쉽게 문서화할 수 있습니다.

@app.get("/docs/")
async def get_docs():
    return {"message": "Swagger UI를 통해 API 문서를 확인하세요."}

5. 결론

FastAPI는 데이터 유효성 검사, 직렬화, API 문서화를 쉽게 처리할 수 있는 현대적이고 강력한 웹 프레임워크입니다. Pydantic 모델을 사용하여 스키마를 정의하고, 이를 통해 타입 힌트를 제공함으로써 코드의 품질을 향상시킬 수 있습니다. 타입 힌트와 Pydantic은 FastAPI의 강력한 기능을 최대한 활용하게 해주며, 사용자에게 신뢰할 수 있는 API를 제공하는 데 기여합니다.

FastAPI를 활용한 프로젝트를 통해 데이터베이스와의 상호작용, 인증 및 배포 등 다양한 기능을 확장해 나가며, 더 나아가 복잡한 웹 응용 프로그램을 효과적으로 구축할 수 있을 것입니다. FastAPI의 장점을 최대한 활용하여 생산성과 개발 효율성을 증대시키길 바랍니다.

이 강좌를 통해 FastAPI와 Pydantic에 대해 깊이 이해하고, 이를 실제 프로젝트에 적용할 수 있는 기초를 다질 수 있기를 바랍니다.

서론

애플리케이션 개발에 있어서는 단일 서비스로 모든 요구 사항을 충족하는 것이 점점 더 어려워지고 있습니다. 또한, 다양한 기술 스택이 공존하고 있으며, 이는 이를 운영할 수 있는 복잡성을 증가시킵니다. 이러한 환경에서 FastAPI와 Docker 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 공식 문서
• Docker Compose 공식 문서
• Uvicorn 공식 사이트

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 호출 시 username과 email 필드를 포함해야 합니다.

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는 현대적인 웹 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 공식 문서
• Pydantic 공식 문서