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 개발을 기원합니다!

FastAPI 서버개발, FastAPI 테스트 클라이언트로 API 테스트하기

return item

@app.get(“/items/”, response_model=List[Item])
async def read_items():
return list(items.values())

@app.get(“/items/{item_name}”, response_model=Item)
async def read_item(item_name: str):
if item_name in items:
return items[item_name]
return {“error”: “Item not found”}

@app.put(“/items/{item_name}”, response_model=Item)
async def update_item(item_name: str, item: Item):
if item_name in items:
items[item_name] = item
return item
return {“error”: “Item not found”}

@app.delete(“/items/{item_name}”, response_model=Item)
async def delete_item(item_name: str):
if item_name in items:
return items.pop(item_name)
return {“error”: “Item not found”}

코드 설명

위의 코드는 Create, Read, Update, Delete 기능을 갖춘 엔드포인트를 정의합니다. POST 메서드는 새로운 아이템을 생성하며, GET 메서드로 모든 아이템을 조회하거나 특정 아이템을 조회할 수 있습니다. PUT 메서드는 기존 아이템을 수정할 때 사용되고, DELETE 메서드는 아이템을 삭제하는 역할을 합니다.

3. CRUD API 테스트하기

CRUD 기능을 테스트하는 테스트 케이스도 추가해보겠습니다.


def test_create_item():
    response = client.post("/items/", json={"name": "Item1", "price": 10.0})
    assert response.status_code == 200
    assert response.json() == {"name": "Item1", "description": None, "price": 10.0, "tax": None}

def test_read_items():
    response = client.get("/items/")
    assert response.status_code == 200
    assert isinstance(response.json(), list)

def test_update_item():
    response = client.put("/items/Item1", json={"name": "Item1", "price": 12.0})
    assert response.status_code == 200
    assert response.json() == {"name": "Item1", "description": None, "price": 12.0, "tax": None}

def test_delete_item():
    response = client.delete("/items/Item1")
    assert response.status_code == 200
    assert response.json() == {"name": "Item1", "description": None, "price": 12.0, "tax": None}

코드 설명

각 테스트 함수는 API의 CRUD 기능을 검증합니다. test_create_item 함수는 새로운 아이템을 생성하고, test_read_items 함수는 모든 아이템을 조회합니다. test_update_item은 특정 아이템을 수정하며, test_delete_item은 아이템을 삭제하는 기능을 테스트합니다.

FastAPI의 보안과 인증

FastAPI는 OAuth2와 JWT 토큰 기반 인증을 지원합니다. 보안이 필요한 API 엔드포인트에 대한 인증 방법을 설명하겠습니다.

1. OAuth2PasswordBearer 사용하기


from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
    # 사용자 인증 로직 (여기서는 생략)
    return {"access_token": form_data.username, "token_type": "bearer"}

2. 보호된 엔드포인트 만들기

로그인 후 액세스 토큰을 통해 보호된 엔드포인트를 만들어보겠습니다.


@app.get("/secure-data")
async def read_secure_data(token: str = Depends(oauth2_scheme)):
    return {"data": "This is protected data"}

코드 설명

위 코드는 /token 경로에서 로그인 시 액세스 토큰을 생성하고, 생성된 토큰을 통해 /secure-data 경로에 접근하도록 설정합니다. Depends()를 사용하여 인증이 필요한 기능을 구현했습니다.

3. 보안 테스트

보호된 엔드포인트를 테스트하기 위해 인증 후 토큰을 사용할 수 있습니다.


def test_secure_data():
    response = client.post("/token", data={"username": "testuser", "password": "testpassword"})
    token = response.json().get("access_token")

    response = client.get("/secure-data", headers={"Authorization": f"Bearer {token}"})
    assert response.status_code == 200
    assert response.json() == {"data": "This is protected data"}

결론

이 포스트에서는 FastAPI를 사용하여 간단한 API 서버를 구축하고, FastAPI의 테스트 클라이언트를 활용하여 다양한 API 엔드포인트를 테스트하는 방법에 대해 배웠습니다. FastAPI를 통해 고성능의 API를 쉽게 생성할 수 있으며, TestClient를 이용해 안정적이고 신뢰성 있는 테스트를 진행할 수 있습니다. 다양한 기능과 확장성을 바탕으로 FastAPI를 활용한 프로젝트를 진행해보시길 바랍니다.

FastAPI 서버개발, FastAPI의 비동기 요청 처리 이해하기

FastAPI는 빠르고 현대적인 웹 프레임워크로, Python 3.7 이상에서 사용할 수 있습니다. FastAPI는 ASGI를 기반으로 하여 비동기 프로그래밍을 쉽게 활용할 수 있도록 도와줍니다. 이 글에서는 FastAPI를 사용하여 비동기 요청 처리를 구현하는 방법을 상세히 설명하고, 예제 코드를 통해 이해를 돕겠습니다.

1. FastAPI와 비동기 프로그래밍의 이해

비동기 프로그래밍은 주로 I/O 작업이 많은 작업에서 성능을 크게 개선할 수 있는 기술입니다. 동기식 프로그래밍에서는 요청이 완료될 때까지 해당 요청을 처리하는 스레드가 대기하게 됩니다. 하지만 비동기 프로그래밍에서는 자원이 낭비되지 않도록 다른 작업을 동시에 수행할 수 있습니다.

1.1 FastAPI의 비동기 지원

FastAPI는 비동기 함수(`async def`)를 사용하여 I/O 바운드 작업을 처리할 수 있게 지원합니다. FastAPI의 경로 작업(route handler)에서 비동기 함수를 사용하면, 비동기적으로 요청을 처리할 수 있어 다른 요청이 대기하지 않고 곧바로 처리됩니다.

1.2 비동기와 동기 함수 비교

FastAPI에서 비동기 경로 작업을 구현하는 방법은 동기 함수와 유사하지만, 반드시 `async` 키워드를 사용하여 정의해야 합니다. 아래는 비동기와 동기 함수의 예제 코드입니다.

from fastapi import FastAPI
import time

app = FastAPI()

# 동기 경로 작업
@app.get("/sync")
def read_sync():
    time.sleep(2)  # 2초 대기
    return {"message": "동기 요청 처리 완료"}

# 비동기 경로 작업
@app.get("/async")
async def read_async():
    await asyncio.sleep(2)  # 2초 대기
    return {"message": "비동기 요청 처리 완료"}

위의 코드는 `/sync` 경로를 통해 동기적으로 요청을 처리하고, `/async` 경로를 통해 비동기적으로 요청을 처리합니다. 요청이 들어온 순서에 따라 동기 요청은 처리하는 동안 다른 요청이 대기하게 되지만, 비동기 요청은 대기하는 동안 다른 요청을 처리할 수 있습니다.

2. FastAPI에서 비동기 I/O 작업 처리하기

FastAPI에서 비동기 I/O 작업은 데이터베이스의 CRUD 작업, 웹 API 호출, 파일 업로드 등 다양한 경우에 활용됩니다. 각 I/O 작업이 비동기적으로 수행되면, 애플리케이션의 성능을 높일 수 있습니다.

2.1 비동기 데이터베이스 작업

다양한 비동기 데이터베이스 드라이버가 FastAPI와 함께 사용될 수 있습니다. 예를 들어, databases라는 비동기 ORM 라이브러리와 함께 사용하여 비동기적으로 데이터베이스와 상호작용할 수 있습니다.

import asyncio
from fastapi import FastAPI
import databases

DATABASE_URL = "sqlite:///./test.db"
database = databases.Database(DATABASE_URL)

app = FastAPI()

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

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

@app.get("/items/")
async def read_items():
    query = "SELECT * FROM items"
    return await database.fetch_all(query)

위의 코드는 `databases` 라이브러리를 사용하여 SQLite 데이터베이스에 비동기적으로 연결하고, 아이템을 읽어오는 예시입니다. FastAPI의 생명주기 이벤트를 통해 서버가 시작할 때와 종료할 때 데이터베이스 연결을 관리할 수 있습니다.

2.2 비동기 HTTP 요청 처리

FastAPI에서는 httpx 같은 라이브러리를 사용하여 비동기 HTTP 요청도 쉽게 처리할 수 있습니다. 비동기 HTTP 요청은 외부 API와의 통신이 필요할 때 매우 유용합니다.

import httpx

@app.get("/external/")
async def read_external():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://api.example.com/data')
    return response.json()

위의 코드는 외부 API에서 데이터를 가져와서 반환하는 비동기 경로 작업입니다. 비동기 클라이언트를 사용함으로써, 데이터 요청 도중 서버가 다른 요청을 처리할 수 있도록 합니다.

3. 비동기 작업에서의 오류 처리

비동기 작업을 구현할 때, 오류 처리 또한 중요합니다. 비동기 작업이 실패할 경우, 적절한 오류 메시지를 반환해야 하며, 이때 HTTPException을 사용할 수 있습니다.

from fastapi import HTTPException

@app.get("/data/")
async def read_data(param: str):
    if param not in ["valid1", "valid2"]:
        raise HTTPException(status_code=404, detail="데이터를 찾을 수 없습니다.")
    return {"message": f"{param}에 대한 데이터"}

위의 코드는 파라미터가 유효하지 않을 때 HTTP 404 오류를 반환하는 예제입니다. FastAPI의 예외 처리 메커니즘은 비동기 방식에서도 동일하게 작동합니다.

4. FastAPI의 비동기 요청 처리 성능 비교

비동기 요청 처리와 동기 요청 처리의 성능 차이를 비교할 수 있는 방법도 중요합니다. 아래는 FastAPI의 비동기 및 동기 경로 작업에 대한 성능 테스트 예제입니다.

import time
import asyncio
from fastapi import FastAPI

app = FastAPI()

@app.get("/sync-test/")
def sync_test():
    time.sleep(1)  # 1초 대기
    return {"message": "비동기 요청이 아닙니다."}

@app.get("/async-test/")
async def async_test():
    await asyncio.sleep(1)  # 1초 대기
    return {"message": "비동기 요청입니다."}

이제 이 두 경로를 동시에 호출하여 성능을 비교할 수 있습니다. 테스트 도구(예: Apache Bench 또는 wrk)를 사용하여 두 경로에서의 응답 시간을 측정해보세요.

5. 결론

FastAPI는 비동기 요청 처리를 지원하여 높은 성능을 기록할 수 있는 프레임워크입니다. I/O 작업을 비동기적으로 처리함으로써, 서버의 자원을 효율적으로 활용할 수 있습니다. 이번 글에서는 FastAPI의 비동기 요청 처리 방식에 대해 설명하고 여러 예제를 통해 이해를 도왔습니다.

FastAPI를 사용하면 비동기적 아키텍처를 쉽게 구현할 수 있으며, 이에 따라 생산성과 성능이 향상됩니다. 비동기 함수를 적절히 활용하여 비즈니스 로직을 구현하고, 다양한 응용 프로그램을 개발해보세요!

FastAPI 서버개발, 도커, 로컬에 애플리케이션 배포

최근 몇 년 간 웹 애플리케이션 개발에서 Python의 인기가 급격히 증가하고 있습니다. 특히, FastAPI는 비동기식 프로그래밍을 지원하고, 높은 성능과 쉬운 작성 구조 덕분에 많은 개발자들 사이에서 각광받고 있습니다. 이번 글에서는 FastAPI를 사용하여 서버 개발을 하고, 도커(Docker)를 사용하여 애플리케이션을 배포하는 방법에 대해 자세히 알아보겠습니다.

1. FastAPI란?

FastAPI는 Python으로 작성된 현대적인 웹 프레임워크로, RESTful API를 쉽고 빠르게 개발할 수 있도록 도와줍니다. 중요한 특징 중 하나는 데이터 검증과 직렬화를 위한 Pydantic을 내장하고 있다는 점입니다. 빠른 속도와 쉬운 사용법 덕분에 많은 스타트업과 대기업에서 채택하고 있습니다.

1.1 FastAPI의 주요 특징

  • 비동기 프로그래밍 지원
  • 자동으로 API 문서화(Swagger UI 및 ReDoc 사용)
  • 데이터 검증 및 직렬화 기능 제공
  • 빠른 처리 속도(Starlette 기반)
  • 주요 데이터베이스와의 통합 지원

2. FastAPI 개발 환경 설정

FastAPI 프로젝트를 시작하기 위해 필요한 개발 환경을 설정해보겠습니다. Python 3.6 이상이 필요하며, FastAPI와 Uvicorn을 설치해야 합니다.

2.1 FastAPI 및 Uvicorn 설치

pip install fastapi uvicorn

2.2 간단한 FastAPI 서버 구현

간단한 “Hello World” API를 만들어 보겠습니다. 아래 코드를 main.py 파일에 작성합니다:


from fastapi import FastAPI

app = FastAPI()

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

이제 서버를 실행해보겠습니다. 터미널에서 아래 명령어를 입력합니다:

uvicorn main:app --reload

서버가 정상적으로 실행되면 http://127.0.0.1:8000 에 접속하여 “Hello World” 메시지를 확인할 수 있습니다.

3. FASTAPI API Endpoint 구성

이제 FastAPI의 다양한 API 엔드포인트를 추가해 보겠습니다. 사용자 정보를 관리하는 간단한 API를 설계해보겠습니다.

3.1 데이터 모델 정의

Pydantic을 사용하여 데이터 모델을 정의합니다:


from pydantic import BaseModel
from typing import List

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

3.2 사용자 목록과 API 엔드포인트 추가

사용자 목록을 저장하고, 사용자 정보를 CRUD할 수 있는 기능을 추가합니다:


users = []

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

@app.get("/users/", response_model=List[User])
async def read_users():
    return users

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

4. 도커(Docker) 설정

이제 FastAPI 애플리케이션을 도커를 사용하여 컨테이너화해보겠습니다. 도커는 애플리케이션을 패키징, 배포 및 실행할 수 있는 플랫폼입니다.

4.1 도커 설치

도커는 아래 링크에서 다운로드하여 설치할 수 있습니다:

4.2 도커파일 작성

애플리케이션을 컨테이너화하기 위해 도커파일을 생성합니다. 프로젝트 루트에 Dockerfile이라는 이름으로 아래 내용을 작성합니다:


# 사용하고자 하는 이미지를 지정
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.9

# 작업 디렉토리 설정
WORKDIR /app

# 의존성 파일 복사
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 애플리케이션 코드 복사
COPY ./app /app

# 컨테이너가 시작될 때 실행할 커맨드
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]
    

4.3 requirements.txt 작성

프로젝트에 필요한 패키지 목록을 작성합니다. 아래는 requirements.txt의 예시입니다:


fastapi
uvicorn
pydantic
    

4.4 도커 이미지 빌드 및 실행

이제 도커 이미지를 빌드하고 실행해 보겠습니다. 터미널에서 아래 명령어를 입력합니다:


# 도커 이미지 빌드
docker build -t fastapi-app .

# 도커 컨테이너 실행
docker run -d -p 80:80 fastapi-app
    

이제 웹 브라우저에서 http://localhost 에 접속하여 FastAPI 애플리케이션이 도커에서 잘 실행되고 있는지 확인할 수 있습니다.

5. 로컬 배포 및 테스트

FastAPI 애플리케이션을 로컬 환경에서 배포하기 위해서는 앞서 설정한 도커 컨테이너를 사용할 수 있습니다. 하지만 배포 후 테스트도 필요합니다. Postman과 같은 도구를 사용하여 API 엔드포인트를 테스트할 수 있습니다.

5.1 Postman 사용하기

Postman을 사용하여 API 요청을 보내고 응답을 확인해보겠습니다. 먼저 Postman을 설치합니다.

5.2 사용자 생성 테스트

새로운 사용자를 추가하기 위해 POST 요청을 보냅니다:

  • 메소드: POST
  • URL: http://localhost/users/
  • Body(Nuclei):
  • 
    {
        "id": 1,
        "name": "홍길동",
        "email": "hong@example.com"
    }
    

사용자 정보를 확인하기 위해 GET 요청을 보내어 생성한 사용자를 조회해봅니다.

6. 결론

이번 포스트에서는 FastAPI를 사용하여 간단한 웹 애플리케이션을 개발하고, 도커를 통해 로컬 환경에서 배포하는 과정을 알아보았습니다. FastAPI의 비동기 지원과 데이터 검증 기능 덕분에 더욱 생산적인 개발이 가능했습니다. 도커를 사용하여 애플리케이션을 컨테이너화함으로써 배포와 관리를 더욱 효율적으로 수행할 수 있습니다. 실제 적용 시에는 CI/CD 파이프라인을 추가하여 더 나은 배포 프로세스를 구축할 수 있습니다.

이 글을 통해 FastAPI와 도커의 이점을 이해하고, 실제 프로젝트에 적용해보시길 바랍니다. 감사합니다!

FastAPI 서버개발, AWS, GCP 또는 Azure에 FastAPI 애플리케이션 배포하기

FastAPI는 Python으로 작성된 현대적인 웹 프레임워크로, 빠르고 효율적으로 API를 구축할 수 있는 강력한 기능을 제공합니다. 이 글에서는 FastAPI 서버를 개발한 후, 이를 AWS, GCP 및 Azure와 같은 클라우드 플랫폼에 배포하는 방법에 대해 자세히 설명하겠습니다.

1. FastAPI 소개

FastAPI는 Python으로 RESTful API를 만들기 위해 설계된 웹 프레임워크입니다. 주요 특징으로는 다음과 같습니다:

  • 비동기 프로그래밍 지원: FastAPI는 비동기 프로그래밍을 지원하며, 이를 통해 높은 성능을 발휘할 수 있습니다.
  • 자동화된 문서화: OpenAPI 및 JSON Schema를 기반으로 API 문서화를 자동으로 생성합니다.
  • 타입 힌트 지원: Python의 타입 힌트를 사용하여 코드의 가독성을 높이고, 입력 및 출력 데이터의 유효성을 검증합니다.

1.1 FastAPI 설치

FastAPI를 설치하려면 pip를 사용할 수 있습니다. Terminal 또는 Command Prompt에 다음 명령어를 입력합니다:

pip install fastapi uvicorn

2. FastAPI 애플리케이션 개발

FastAPI를 사용하여 간단한 애플리케이션을 만들어 보겠습니다. 이 예제에서는 간단한 사용자 관리 API를 작성합니다.

2.1 기본 애플리케이션 구조


- app/
    - main.py
    - models.py
    - schemas.py

2.2 models.py

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

class User(Base):
    __tablename__ = 'users'

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

2.3 schemas.py

from pydantic import BaseModel

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

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

    class Config:
        orm_mode = True

2.4 main.py

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session
from database import SessionLocal, engine
from models import User
from schemas import UserCreate, UserOut

app = FastAPI()

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

2.5 데이터베이스 연결 설정

이 예제에서는 SQLAlchemy를 사용하여 데이터베이스와 연결합니다. database.py 파일을 생성하고 데이터베이스 연결을 설정합니다.

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

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

3. FastAPI 애플리케이션 배포

애플리케이션이 준비되면, 이를 클라우드 서비스에 배포하는 첫 단계로 플랫폼을 선택해야 합니다. AWS, GCP, Azure 각각의 장단점이 있으며, 필요한 요구 사항에 따라 적절한 플랫폼을 선택해야 합니다.

3.1 AWS에 FastAPI 배포하기

AWS에서 FastAPI 애플리케이션을 배포하기 위해 Amazon EC2 인스턴스를 사용할 수 있습니다. 배포 과정은 다음과 같습니다:

  1. EC2 인스턴스 생성: AWS Management Console에 로그인하여 EC2 대시보드로 이동한 후 인스턴스를 만듭니다. 적절한 AMI(Amazon Machine Image)와 인스턴스 유형을 선택하십시오.
  2. SSH로 EC2 인스턴스에 접속: 생성한 인스턴스에 SSH로 접속하여 애플리케이션 파일을 전송합니다.
  3. Dependencies 설치: 접속 후, 필요한 패키지를 설치합니다:
  4. sudo apt update
    sudo apt install python3-pip
    pip3 install fastapi uvicorn sqlalchemy sqlite
  5. 애플리케이션 실행: uvicorn을 사용하여 애플리케이션을 실행합니다:
  6. uvicorn main:app --host 0.0.0.0 --port 8000

3.2 GCP에 FastAPI 배포하기

Google Cloud Platform(GCP)을 사용하여 FastAPI 애플리케이션을 배포하는 과정은 다음과 같습니다:

  1. Google Cloud Console에 로그인: GCP 프로젝트를 생성하고, Cloud Shell을 엽니다.
  2. App Engine 설정: App Engine에 대해 Python 환경을 설정합니다:
  3. gcloud app create --project YOUR_PROJECT_ID
  4. requirements.txt 파일 생성: 필요한 패키지를 명시합니다:
  5. fastapi
    uvicorn
    sqlalchemy
  6. app.yaml 파일 설정: GCP에서의 배포를 설정합니다:
  7. runtime: python39
    entrypoint: uvicorn main:app --host=0.0.0.0 --port=8080
    
    handlers:
    - url: /.*
      script: auto
  8. GCP에 배포: 다음 명령어를 사용하여 애플리케이션을 GCP에 배포합니다:
  9. gcloud app deploy

3.3 Azure에 FastAPI 배포하기

Azure에 FastAPI 애플리케이션을 배포하는 과정은 다음과 같습니다:

  1. Azure Portal에 로그인: App Service를 생성합니다.
  2. App Service의 환경 설정: Linux와 Python 스택을 선택합니다.
  3. 배포 준비: Azure CLI 또는 Git을 사용하여 코드를 푸시합니다.
  4. requirements.txt 파일 생성: GCP와 같이 dependencies를 명시합니다:
  5. fastapi
    uvicorn
    sqlalchemy
  6. 애플리케이션 실행: Azure Portal의 Console에서 uvicorn 명령어를 통해 애플리케이션을 실행합니다:
  7. uvicorn main:app --host=0.0.0.0 --port=8000

4. 결론

FastAPI는 현대적인 웹 애플리케이션에 적합한 강력한 프레임워크입니다. AWS, GCP, Azure와 같은 클라우드 플랫폼에 배포하는 과정은 각 플랫폼에 따라 다르지만, 기본 원리는 유사합니다. 이 글에서는 FastAPI 애플리케이션을 개발하는 방법과 AWS, GCP, Azure로 배포하는 방법에 대해 설명했습니다. 자신에게 맞는 플랫폼에서 효율적으로 FastAPI 애플리케이션을 운영할 수 있을 것입니다.

5. 추가 References