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

FastAPI는 현대의 API 서버 개발에 최적화된 웹 프레임워크로, 비동기 프로그래밍을 지원하며 자동 문서화 기능이 뛰어나기 때문에 많은 개발자와 기업들이 선택하고 있습니다. 본 강좌에서는 FastAPI로 간단한 서버를 구현하고, 이를 컨테이너화하여 AWS App Runner에 배포하는 과정을 알아보겠습니다.

1. FastAPI 소개

FastAPI는 Python으로 작성된 비동기 RESTful API 웹 프레임워크입니다. 다음과 같은 주요 기능을 가지고 있습니다:

• 빠른 성능: Starlette와 Pydantic을 기반으로 하여 경량이면서도 성능이 뛰어납니다.
• 자동 API 문서화: OpenAPI와 JSON Schema를 기반으로 하여 자동으로 API 문서를 생성합니다.
• 엄격한 데이터 검증: Pydantic을 통해 요청 및 응답 데이터에 대한 검증을 지원합니다.

2. FastAPI 서버 개발

2.1 프로젝트 환경 설정

먼저 FastAPI와 필요한 라이브러리를 설치합니다. 다음 명령어를 사용하여 가상 환경을 설정하고 FastAPI를 설치하세요:

python -m venv venv
source venv/bin/activate  # UNIX / MacOS
venv\Scripts\activate  # Windows
pip install fastapi uvicorn

2.2 기본 FastAPI 애플리케이션 작성

이제 FastAPI 애플리케이션의 기본 구조를 작성해 보겠습니다. 다음은 간단한 API 서버의 코드입니다:

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}

2.3 API 실행하기

Uvicorn을 사용하여 FastAPI 애플리케이션을 실행할 수 있습니다. 다음 명령어를 사용하세요:

uvicorn main:app --reload

이제 http://127.0.0.1:8000에 접속하여 API를 테스트할 수 있습니다. 기본적으로 제공되는 OpenAPI 문서에 접근하기 위해 http://127.0.0.1:8000/docs를 입력하세요.

3. 컨테이너화와 Docker

3.1 Docker 설치

FastAPI 서버를 컨테이너화하기 위해 Docker를 설치해야 합니다. Docker를 설치한 후, 다음 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"]

3.2 Docker 이미지 빌드

Dockerfile이 있는 디렉토리에서 다음 명령어를 실행하여 이미지를 빌드합니다:

docker build -t fastapi-app .

3.3 Docker 컨테이너 실행

이제 Docker 이미지를 기반으로 컨테이너를 실행합니다:

docker run -d --name my-fastapi -p 8080:80 fastapi-app

이제 http://localhost:8080에서 FastAPI 서버에 접근할 수 있습니다.

4. AWS App Runner 설정 및 실행

AWS App Runner는 컨테이너화된 웹 애플리케이션을 쉽고 빠르게 배포할 수 있도록 도와주는 서비스입니다. 다음 단계에 따라 FastAPI 서버를 AWS App Runner에 배포할 수 있습니다.

4.1 AWS CLI 설치 및 설정

AWS CLI가 설치되어 있지 않다면 아래의 명령어로 설치하세요:

pip install awscli

설치가 완료되면, 다음 명령어로 AWS CLI를 설정할 수 있습니다:

aws configure

AWS Access Key, Secret Access Key, 그리고 기본 리전 등을 설정합니다.

4.2 ECR(Elastic Container Registry) 생성

FastAPI 이미지를 저장할 레포지토리를 ECR에서 생성합니다. 아래의 명령어를 사용하세요:

aws ecr create-repository --repository-name fastapi-app

레포지토리가 생성된 후, ECR URI를 확인합니다.

4.3 Docker 이미지 푸시

앞서 생성한 ECR에 로그인을 합니다:

aws ecr get-login-password --region  | docker login --username AWS --password-stdin .dkr.ecr..amazonaws.com

그 다음, 이미지를 ECR에 태그하고 푸시합니다:

docker tag fastapi-app:latest .dkr.ecr..amazonaws.com/fastapi-app:latest
docker push .dkr.ecr..amazonaws.com/fastapi-app:latest

4.4 App Runner 서비스 생성

이제 AWS Management Console에 로그인하여 App Runner를 선택한 후, “Create Service”를 클릭합니다. ECR에서 이미지를 선택하고, 필요한 설정을 합니다.

서비스 이름, 인스턴스 수, 스케일링 정책 등을 설정한 후 “Create”를 클릭하면 App Runner가 컨테이너를 배포합니다.

4.5 서비스 접근하기

서비스가 성공적으로 배포되면 URL이 생성됩니다. 이 URL을 통해 FastAPI 서버에 접근할 수 있습니다.

5. 마무리

FastAPI를 사용하여 간단한 API 서버를 만들고, Docker를 사용하여 컨테이너로 패키징한 후, AWS App Runner를 통해 배포하는 방법에 대해 알아보았습니다. FastAPI의 강력한 기능과 AWS 서비스를 결합하면 쉽고 빠르게 API를 제공할 수 있는 백엔드를 구축할 수 있습니다.

이제 여러분도 FastAPI를 활용하여 다양한 웹 애플리케이션과 API를 개발해 보세요!

본 강좌에서는 FastAPI를 사용하여 백엔드 서버를 개발하고, 도커를 이용하여 이 서버를 패키징 및 배포하며, 데이터베이스를 포함한 전체적인 배포 과정에 대해 상세히 설명하겠습니다. FastAPI는 빠르고 현대적인 웹 프레임워크로, 비동기 API를 쉽게 개발할 수 있도록 돕습니다. 이와 더불어 도커는 애플리케이션을 컨테이너화하여 어디서든 실행할 수 있도록 해주는 도구입니다. 마지막으로 데이터베이스 배포에 대해 논의할 것입니다.

1. FastAPI 소개

FastAPI는 Python으로 작성된 웹 프레임워크이며, RESTful API를 작성하는 데 유용한 도구입니다. FastAPI의 주요 특징은 다음과 같습니다:

• 고속: Starlette를 기반으로 하여 비동기 처리를 지원해 빠른 성능을 제공합니다.
• 자동화된 문서화: OpenAPI를 기반으로 자동으로 생성된 API 문서를 제공합니다.
• 데이터 유효성 검사: Pydantic을 통해 데이터 모델과 유효성 검사를 자동으로 수행합니다.

1.1 FastAPI 설치

pip install fastapi uvicorn

위 명령어를 통해 FastAPI와 Uvicorn(ASGI 서버)를 설치할 수 있습니다.

2. FastAPI 서버 개발

이제 FastAPI를 사용하여 간단한 API 서버를 만들어 보겠습니다. 예를 들어, 사용자의 정보를 관리하는 API를 구축한다고 가정하겠습니다.

2.1 기본 구조

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# Pydantic 모델 정의
class User(BaseModel):
    id: int
    name: str
    age: int

# In-memory 데이터 저장소
users = []

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

@app.get("/users/{user_id}")
def read_user(user_id: int):
    return users[user_id]

@app.get("/users/")
def list_users():
    return users

위 코드는 간단한 사용자 API를 구현한 예제입니다. POST 요청을 통해 사용자를 추가하고, GET 요청을 통해 사용자 정보를 조회할 수 있습니다.

2.2 실행

uvicorn main:app --reload

서버를 실행하려면 위 명령어를 입력하시면 됩니다. 브라우저에서 http://127.0.0.1:8000/docs에 접속하면 자동 생성된 API 문서를 확인할 수 있습니다.

3. 도커를 이용한 배포

이제 FastAPI 애플리케이션을 도커를 사용하여 패키징하고 배포하는 과정을 알아보겠습니다.

3.1 Dockerfile 작성

프로젝트 루트 디렉토리에 Dockerfile을 생성합니다.

FROM python:3.9

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

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

Dockerfile의 구성은 다음과 같습니다:

• FROM

: Python 이미지를 기반으로 합니다.

• WORKDIR

: 작업 디렉토리를 설정합니다.

• COPY

: 현재 디렉토리의 파일을 도커 이미지로 복사합니다.

• RUN

: 필요한 패키지를 설치합니다.

• CMD

: 컨테이너가 시작될 때 실행될 명령어를 지정합니다.

3.2 도커 이미지 빌드

docker build -t fastapi-app .

위 명령어를 통해 도커 이미지를 빌드합니다.

3.3 도커 컨테이너 실행

docker run -d -p 80:80 fastapi-app

컨테이너를 백그라운드에서 실행합니다. 이 후 http://localhost에서 API에 접근할 수 있습니다.

4. 데이터베이스 배포

FastAPI와 도커를 사용한 기본 API 서버 구축이 완료되었습니다. 이제 데이터베이스를 추가하여 데이터를 지속적으로 저장할 수 있는 기능을 구현해보겠습니다. 여기서는 SQLite를 사용하겠습니다.

4.1 SQLAlchemy 및 데이터베이스 설정

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

class UserModel(Base):
    __tablename__ = "users"

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

Base.metadata.create_all(bind=engine)

위 코드는 SQLAlchemy를 사용하여 SQLite 데이터베이스를 설정하는 방법입니다. UserModel 클래스가 데이터베이스의 사용자 테이블을 정의합니다.

4.2 FastAPI에 통합

from fastapi import Depends
from sqlalchemy.orm import Session

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/users/", response_model=User)
def create_user(user: User, db: Session = Depends(get_db)):
    db_user = UserModel(**user.dict())
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

@app.get("/users/{user_id}", response_model=User)
def read_user(user_id: int, db: Session = Depends(get_db)):
    return db.query(UserModel).filter(UserModel.id == user_id).first()

@app.get("/users/", response_model=List[User])
def list_users(db: Session = Depends(get_db)):
    return db.query(UserModel).all()

위 코드는 FastAPI에서 SQLAlchemy를 사용하여 데이터베이스와의 상호작용을 추가하는 방법을 보여줍니다. 이제 사용자를 데이터베이스에 추가하고 조회할 수 있습니다.

5. 도커에 데이터베이스 배포

도커를 사용하여 데이터베이스와 함께 FastAPI 애플리케이션을 배포하는 방법에 대해 알아보겠습니다. 이를 위해 PostgreSQL 데이터베이스를 사용할 것입니다.

5.1 Docker Compose 설정

다음으로 docker-compose.yml 파일을 생성하여 FastAPI와 PostgreSQL을 함께 실행 할 수 있도록 설정합니다.

version: '3.8'
services:
  web:
    build: .
    ports:
      - "80:80"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgresql://user:password@db/dbname

  db:
    image: postgres:latest
    environment:
      POSTGRES_DB: dbname
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"

위 구성에서는 FastAPI 웹 애플리케이션이 PostgreSQL 데이터베이스에 의존하고 있음을 보여줍니다. 데이터베이스 컨테이너가 실행되면 FastAPI 애플리케이션이 이를 사용할 수 있습니다.

5.2 컨테이너 실행

docker-compose up --build

위 명령어를 사용하여 모든 서비스를 한 번에 실행합니다. FastAPI는 PostgreSQL과 연결되고, API를 통해 사용자를 관리할 수 있습니다.

결론

이번 강좌에서는 FastAPI를 사용하여 간단한 백엔드 API를 개발하고, 도커를 통해 이 API를 패키징 및 배포하며, 데이터베이스를 설정하는 방법에 대해 설명하였습니다. FastAPI와 도커를 활용하면 효율적으로 애플리케이션을 개발하고 배포할 수 있습니다. 이를 통해 현대적인 웹 애플리케이션을 손쉽게 구축할 수 있는 기초를 다질 수 있습니다.

본 포스트에서는 FastAPI를 활용하여 간단한 CRUD 애플리케이션을 개발하는 방법을 다룹니다. FastAPI는 최신 Python 웹 프레임워크 중 하나로, 비동기 프로그래밍을 지원하며, 자동으로 API 문서를 생성하는 기능이 포함되어 있어 개발자들에게 좋은 선택입니다. 이번 강좌에서는 FastAPI의 기본 개념을 설명하고, 실제로 쉽게 사용할 수 있는 CRUD(Create, Read, Update, Delete) 애플리케이션을 만들어 보겠습니다.

FastAPI 소개

FastAPI는 Python 3.6 이상에서 사용할 수 있는 웹 프레임워크입니다. 여기서 “Fast”라는 이름은 성능이 매우 뛰어나기 때문에 붙여졌습니다. FastAPI는 Pydantic을 통해 데이터 검증을 수행하고, Starlette를 기반으로 하여 비동기 기능을 제공합니다. API 문서는 Swagger UI와 ReDoc을 통해 자동으로 생성되며, 이는 개발자와 사용자가 API를 쉽게 이해하고 사용할 수 있도록 돕습니다.

특징

• 빠른 성능: FastAPI는 우수한 성능을 제공하며, 이로 인해 높은 처리량을 요구하는 애플리케이션에 적합합니다.
• 데이터 검증: Pydantic을 활용한 강력한 데이터 검증이 가능합니다.
• 비동기 지원: 비동기식 프로그래밍이 가능하여, 높은 효율성을 보장합니다.
• 자동 문서화: Swagger UI와 ReDoc을 통해 API 문서가 자동으로 생성됩니다.

프로젝트 설정

FastAPI를 사용하기 위해 먼저 환경을 설정해야 합니다. 아래의 단계에 따라 FastAPI 애플리케이션을 만들 준비를 하겠습니다.

1. Python 설치

FastAPI는 Python을 기반으로 하므로, 우선 Python 3.6 이상이 설치되어 있어야 합니다. Python을 설치한 후, 아래의 명령어로 FastAPI와 Uvicorn(ASGI 서버)를 설치합니다:

pip install fastapi uvicorn

2. 프로젝트 디렉토리 생성

다음으로, 프로젝트를 위한 디렉토리를 생성합니다. 예를 들어, fastapi_crud라는 이름으로 디렉토리를 만들고 이동합니다:

mkdir fastapi_crud
cd fastapi_crud

3. 애플리케이션 파일 생성

애플리케이션의 메인 파일인 main.py를 생성합니다:

touch main.py

간단한 CRUD 애플리케이션 구현

이제 FastAPI를 사용하여 간단한 CRUD 애플리케이션을 구현해 보겠습니다. 이 예제에서는 사용자 정보를 관리하는 API를 만들 것입니다. 사용자 정보는 이름과 나이로 구성되어 있습니다. 아래에 구체적인 코드를 설명합니다.

1. FastAPI 앱 설정

아래의 코드는 FastAPI 애플리케이션을 설정하고 시작하는 방법을 보여줍니다:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

2. 데이터 저장소

이 예제에서는 메모리에 사용자 데이터를 저장하는 단순한 방식으로 리스트를 사용합니다:

users = []

3. Create: 사용자 생성 API

사용자를 생성하는 API를 정의합니다. 이 API는 JSON 형식의 사용자 정보를 POST 방식으로 받아 새로운 사용자를 리스트에 추가합니다:

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

4. Read: 모든 사용자 조회 API

모든 사용자 정보를 반환하는 API를 정의합니다:

@app.get("/users/")
async def read_users():
    return users

5. Read: 특정 사용자 조회 API

특정 사용자의 정보를 조회하는 API를 아래와 같이 정의할 수 있습니다:

@app.get("/users/{user_id}")
async def read_user(user_id: int):
    for user in users:
        if user.id == user_id:
            return user
    return {"error": "User not found"}

6. Update: 사용자 정보 수정 API

특정 사용자의 정보를 수정하는 API를 만듭니다:

@app.put("/users/{user_id}")
async def update_user(user_id: int, user: User):
    for idx, existing_user in enumerate(users):
        if existing_user.id == user_id:
            users[idx] = user
            return user
    return {"error": "User not found"}

7. Delete: 사용자 삭제 API

특정 사용자를 삭제하는 API를 정의합니다:

@app.delete("/users/{user_id}")
async def delete_user(user_id: int):
    for idx, existing_user in enumerate(users):
        if existing_user.id == user_id:
            del users[idx]
            return {"message": "User removed"}
    return {"error": "User not found"}

전체 코드

위에서 설명한 모든 코드를 하나의 main.py 파일에 합쳐보겠습니다:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

users = []

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

@app.get("/users/")
async def read_users():
    return users

@app.get("/users/{user_id}")
async def read_user(user_id: int):
    for user in users:
        if user.id == user_id:
            return user
    return {"error": "User not found"}

@app.put("/users/{user_id}")
async def update_user(user_id: int, user: User):
    for idx, existing_user in enumerate(users):
        if existing_user.id == user_id:
            users[idx] = user
            return user
    return {"error": "User not found"}

@app.delete("/users/{user_id}")
async def delete_user(user_id: int):
    for idx, existing_user in enumerate(users):
        if existing_user.id == user_id:
            del users[idx]
            return {"message": "User removed"}
    return {"error": "User not found"}

애플리케이션 실행

이제 애플리케이션을 실행할 시간입니다. 아래의 명령어를 사용하여 Uvicorn 서버를 시작합니다:

uvicorn main:app --reload

서버가 성공적으로 실행되면, 웹 브라우저에서 http://127.0.0.1:8000/docs로 이동하여 Swagger UI를 통해 API를 테스트할 수 있습니다.

테스트

Swagger UI를 사용하여 상세하게 API를 테스트하는 방법에 대해 설명합니다. 각각의 엔드포인트에서 POST, GET, PUT, DELETE 요청을 통해 사용자 정보를 추가, 조회, 수정 및 삭제할 수 있습니다.

사용자 생성

POST 요청을 통해 사용자를 생성할 수 있습니다. JSON 형식으로 아래와 같은 데이터를 입력합니다:

{
    "id": 1,
    "name": "홍길동",
    "age": 30
}

모든 사용자 조회

GET 요청을 통해 모든 사용자의 리스트를 볼 수 있습니다.

특정 사용자 조회

GET 요청을 통해 특정 사용자의 ID로 조회할 수 있습니다. 예: /users/1

사용자 수정

PUT 요청을 통해 특정 사용자의 정보를 수정할 수 있습니다. JSON 형식으로 업데이트된 데이터를 입력합니다:

{
    "id": 1,
    "name": "홍길동 업데이트",
    "age": 31
}

사용자 삭제

DELETE 요청을 통해 특정 사용자를 삭제할 수 있습니다. 예: /users/1

결론

이번 포스트에서는 FastAPI를 사용하여 간단한 CRUD 애플리케이션을 개발하는 방법을 배웠습니다. FastAPI는 매우 직관적이고 사용하기 쉬우며, 이를 통해 효율적인 웹 API를 쉽게 구축할 수 있습니다. 또한, Swagger UI와 같은 도구를 통해 API 문서를 자동으로 생성하고 테스트할 수 있는 점은 개발 과정을 더욱 효율적으로 만들어 줍니다.

이제 여러분도 FastAPI를 사용하여 더 복잡한 애플리케이션을 만들어 볼 수 있는 기초를 쌓았길 바랍니다. FastAPI가 제공하는 다양한 기능들을 탐험해 보세요!

FastAPI는 최신 Python 웹 프레임워크 중 하나로, 고성능과 빠른 개발 속도를 자랑하며 비동기 기능을 지원하여 효율적인 서버 애플리케이션을 만들 수 있게 해줍니다. 본 강좌에서는 FastAPI를 사용하여 데이터베이스와 연동하는 방법에 대해 자세히 설명하겠습니다. 올바른 방법으로 DB와 연결하기 위해 필요한 준비 단계와 예제 코드를 통해 실습할 수 있도록 준비했습니다.

1. FastAPI 소개

FastAPI는 Python 3.6+ 버전에서 사용할 수 있으며, 이 프레임워크는 ASGI(Asynchronous Server Gateway Interface)를 기반으로 하고 있습니다. FastAPI의 주요 장점 중 일부는 다음과 같습니다.

• 빠른 성능: FastAPI는 Starlette와 Pydantic을 기반으로 하여 높은 성능을 자랑합니다.
• 비동기 지원: 비동기 프로그래밍을 지원하여 I/O 작업을 효율적으로 처리합니다.
• 자동 문서화: OpenAPI 스펙을 사용하여 자동으로 API 문서를 생성합니다.

2. 데이터베이스와의 연결 준비

FastAPI를 통해 데이터베이스와 연결하기 위해, 다음과 같은 준비 작업이 필요합니다.

2.1. 데이터베이스 선택

일반적으로 사용하는 데이터베이스로는 MySQL, PostgreSQL, SQLite 등이 있습니다. 이 강좌에서는 SQLite를 사용하여 데이터베이스를 설정하겠습니다. SQLite는 파일 기반의 경량 데이터베이스로, 개발 및 테스트 용도로 적합합니다.

2.2. 필요한 패키지 설치

FastAPI와 데이터베이스 연결을 위해 몇 가지 패키지를 설치해야 합니다. 아래의 명령어를 사용하여 필요한 패키지를 설치합니다.

pip install fastapi uvicorn sqlalchemy databases

2.3. 데이터베이스 모델 정의

SQLAlchemy를 사용하여 데이터베이스 모델을 정의합니다. 모델은 데이터베이스의 테이블과 매핑되는 클래스입니다. 아래는 사용자 정보를 저장하기 위한 User 모델을 정의한 예제입니다.

from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_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)

DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(DATABASE_URL)
Base.metadata.create_all(bind=engine)
    

3. FastAPI 기본 서버 설정

FastAPI 애플리케이션을 구성하고, 데이터베이스와의 연결 설정을 진행합니다. FastAPI 인스턴스를 생성하고, 필요한 라우터를 추가하는 방법에 대해 살펴보겠습니다.

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session

app = FastAPI()

def get_db():
    db = sessionmaker(bind=engine)()
    try:
        yield db
    finally:
        db.close()

@app.post("/users/")
def create_user(user: User, db: Session = Depends(get_db)):
    db.add(user)
    db.commit()
    db.refresh(user)
    return user
    

4. FastAPI와의 데이터베이스 상호작용

이제 FastAPI와 데이터베이스 상호작용을 위한 API 엔드포인트를 정의할 시간입니다. 사용자 생성, 조회, 조회 및 삭제와 같은 기본 CRUD 기능을 다음과 같이 구현할 수 있습니다.

@app.get("/users/{user_id}")
def read_user(user_id: int, db: Session = Depends(get_db)):
    return db.query(User).filter(User.id == user_id).first()

@app.get("/users/")
def read_users(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
    users = db.query(User).offset(skip).limit(limit).all()
    return users

@app.delete("/users/{user_id}")
def delete_user(user_id: int, db: Session = Depends(get_db)):
    user = db.query(User).filter(User.id == user_id).first()
    if user:
        db.delete(user)
        db.commit()
        return {"message": "User deleted"}
    return {"message": "User not found"}
    

5. 데이터베이스 연결 테스트

모든 구성이 완료되었으면 이제 FastAPI 서버를 실행하고 데이터베이스 연결이 제대로 작동하는지 테스트해보는 것이 중요합니다. 아래 명령어로 FastAPI 서버를 실행할 수 있습니다.

uvicorn main:app --reload

서버가 실행된 후, Swagger 문서를 통해 API 엔드포인트를 테스트해 볼 수 있습니다. 사용자를 생성하고, 조회하고, 삭제하는 테스트를 통해 데이터베이스 연결이 정상임을 확인할 수 있습니다.

6. FastAPI의 비동기 데이터베이스 연동

FastAPI는 비동기 기능을 제공하므로, 비동기 데이터베이스 프레임워크를 사용하여 효율적으로 데이터베이스와 상호작용할 수 있습니다. 아래는 async/await 패턴을 사용하여 비동기적으로 데이터베이스 쿼리를 수행하는 방법에 대한 간단한 예제입니다.

from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from fastapi import FastAPI

DATABASE_URL = "sqlite+aiosqlite:///./test.db"
async_engine = create_async_engine(DATABASE_URL, echo=True)
Base = declarative_base()

async def get_db() -> AsyncSession:
    async_session = sessionmaker(async_engine, expire_on_commit=False, class_=AsyncSession)
    async with async_session() as session:
        yield session

@app.post("/users/", response_model=User)
async def create_user(user: User, db: AsyncSession = Depends(get_db)):
    db.add(user)
    await db.commit()
    await db.refresh(user)
    return user
    

비동기 데이터베이스 연동을 통해 성능을 더욱 최적화할 수 있습니다. 이러한 방법을 통해 더 많은 클라이언트 요청을 처리하면서 서버 자원을 효율적으로 사용할 수 있습니다.

7. 결론

FastAPI와 데이터베이스를 함께 사용하는 방법을 살펴보았습니다. FastAPI 서버를 설정하고, 데이터베이스와의 연결을 위한 준비 과정을 통해 기본적인 CRUD 기능을 구현했습니다. 이 과정에서 FastAPI의 비동기 처리 기능을 활용했다면 더욱 효과적인 웹 애플리케이션을 구축할 수 있습니다.

이제 여러분들은 FastAPI와 데이터베이스를 연동한 시스템을 구축하는 기초적인 방법을 배우셨습니다. 이 지식을 바탕으로 더 복잡한 애플리케이션을 설계하고 개발해보세요.

FastAPI는 현대적인 웹 애플리케이션 개발을 쉽게 하고 효율적으로 할 수 있도록 돕는 python 웹 프레임워크입니다.
이 글에서는 FastAPI를 활용하여 서버를 개발하는 방법, 애플리케이션을 구조화하는 방법, 그리고 모델을 구현하는 방법에 대해 이야기하겠습니다.
이 글은 FastAPI에 대한 기본적인 이해가 있는 독자들을 대상으로 하며,
고급 개발 기법과 모범 사례를 포함하여 실제 애플리케이션 구현 과정 전반을 다룰 것입니다.

FastAPI란?

FastAPI는 Asynchronous Python 웹 프레임워크로, Python 3.6 이상을 지원하며,
고속의 웹 API를 구축하는 데 적합합니다. FastAPI는 다음과 같은 주요 특징을 가지고 있습니다:

• 자동 문서화: OpenAPI 및 Swagger UI를 사용하여 API를 쉽게 문서화합니다.
• 비동기 지원: async/await 구문을 통해 비동기 처리를 구현하여 성능을 극대화합니다.
• 입력 검증: Pydantic을 사용한 요청 및 응답 데이터 검증이 가능합니다.
• 사용이 용이: 간결한 코드 작성과 쉬운 학습 곡선으로 빠르게 시작할 수 있습니다.

FastAPI 설치

FastAPI를 사용하기 위해서는 우선 FastAPI 라이브러리와 ASGI 서버인 uvicorn을 설치해야 합니다.

bash
pip install fastapi uvicorn

FastAPI 애플리케이션 구조화

FastAPI 애플리케이션을 구조화하는 것은 애플리케이션을 유지보수하고 확장 가능하게 만드는 데 중요한 요소입니다.
일반적인 프로젝트 구조는 다음과 같이 구성됩니다:

my_fastapi_app/
├── app/
│   ├── main.py                   # 애플리케이션의 진입점
│   ├── api/                      # API 라우터
│   │   ├── __init__.py
│   │   └── endpoints/
│   │       ├── __init__.py
│   │       ├── items.py          # 아이템 관련 API
│   │       └── users.py          # 사용자 관련 API
│   ├── models/                   # Pydantic 모델 정의
│   │   ├── __init__.py
│   │   ├── item.py               # 아이템 모델
│   │   └── user.py               # 사용자 모델
│   └── database.py               # 데이터베이스 연결 및 설정
├── requirements.txt              # 필요한 패키지 목록
└── README.md                     # 프로젝트 설명

main.py

FastAPI 애플리케이션의 진입점인 main.py 파일을 작성합니다.
이 파일은 애플리케이션을 시작하고 API 라우터를 포함하는 역할을 합니다.

python
from fastapi import FastAPI
from app.api.endpoints import items, users

app = FastAPI()

# API 라우터 포함
app.include_router(items.router)
app.include_router(users.router)

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

API 라우터 – items.py

이 파일에서는 아이템에 대한 API 엔드포인트를 정의합니다.

python
from fastapi import APIRouter
from app.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, "name": "sample item"}

모델 구현 – item.py

Pydantic 모델을 정의하여 데이터 유효성을 검사합니다.

python
from pydantic import BaseModel

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

API 라우터 – users.py

사용자 관련 API 엔드포인트를 정의합니다.

python
from fastapi import APIRouter
from app.models.user import User

router = APIRouter()

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

@router.get("/users/{user_id}")
async def read_user(user_id: int):
    return {"user_id": user_id, "name": "sample user"}

모델 구현 – user.py

사용자 관련 모델을 정의합니다.

python
from pydantic import BaseModel

class User(BaseModel):
    username: str
    email: str
    full_name: str = None

데이터베이스 설정

FastAPI에서 SQLAlchemy와 같은 ORM을 사용하여 데이터베이스와의 상호작용을 설정할 수 있습니다.
database.py 파일을 작성하여 데이터베이스 연결을 구성합니다.

python
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"  # SQLite 데이터베이스 사용
engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

FastAPI 애플리케이션 실행

이제 FastAPI 애플리케이션을 실행해 봅시다. 아래와 같은 명령어로 uvicorn을 통해 서버를 시작합니다.

bash
uvicorn app.main:app --reload

서버가 실행되면 http://127.0.0.1:8000/docs에서 자동으로 생성된 Swagger UI를 통해 API를 테스트할 수 있습니다.

결론

FastAPI는 매우 강력하고 유연한 웹 프레임워크로, 데이터 검증 및 비동기 처리를 지원하여 현대적인 웹 API를 구축하는 데 적합합니다.
이 글에서는 FastAPI 서버 개발의 기초와 애플리케이션 구조화, 모델 구현 방법에 대해 알아보았습니다.
FastAPI의 추가 기능과 고급 주제에 대해서는 공식 문서를 참조하여 더욱 깊이 있는 학습을 이어가시기 바랍니다.

성공적인 FastAPI 개발을 기원합니다!