FastAPI 서버개발, DB 조작, C Create

FastAPI는 Python으로 웹 애플리케이션을 개발하기 위한 현대적인 프레임워크입니다. 이 글에서는 FastAPI를 사용하여 Docker와 PostgreSQL 데이터베이스를 결합한 RESTful API를 구축하는 방법을 소개하고, CRUD(Create, Read, Update, Delete) 중 Create 기능을 중점적으로 다룰 것입니다.

목차

  1. FastAPI 소개
  2. 환경 설정
  3. 데이터베이스 통합
  4. Create 작업 구현
  5. API 테스트
  6. 결론

FastAPI 소개

FastAPI는 Python의 비동기 처리를 활용하여 높은 성능을 자랑하는 웹 프레임워크입니다. FastAPI의 장점은 다음과 같습니다:

  • 비동기 처리 지원: 웹 서버와의 I/O 작업을 비동기로 처리하여 성능을 최적화합니다.
  • 자동화된 API 문서: Swagger UI와 ReDoc을 통한 자동화된 문서를 제공합니다.
  • 유형 검사: Python 3.6 이상의 타입 힌트를 활용하여 데이터 유효성을 검사합니다.

환경 설정

시작하기에 앞서 필요한 패키지를 설치합니다. FastAPI와 PostgreSQL을 사용하여 API를 구축할 것이므로, 아래와 같은 환경을 설정합니다.

bash
# 가상환경 생성
$ python -m venv venv
$ source venv/bin/activate  # macOS/Linux
$ venv\Scripts\activate     # Windows

# 필요한 패키지 설치
(venv) $ pip install fastapi[all] sqlalchemy psycopg2
    
주의: 필요에 따라 PostgreSQL을 설치하고 데이터베이스를 생성해야 합니다.

데이터베이스 통합

FastAPI에서 SQLAlchemy를 사용하여 PostgreSQL 데이터베이스와 통합할 것입니다. 아래는 데이터베이스 설정을 위한 코드입니다.

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

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

engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

class Item(Base):
    __tablename__ = "items"

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

Base.metadata.create_all(bind=engine)
    

위 코드에서, `DATABASE_URL`을 실제 데이터베이스의 사용자명, 비밀번호, 호스트 및 데이터베이스 이름으로 수정해야 합니다.

Create 작업 구현

이제 Create 작업을 구현해 보겠습니다. 이를 위해 FastAPI의 경로 연산자와 Pydantic을 사용하여 데이터 유효성을 검사할 수 있습니다.

python
from fastapi import Depends, FastAPI, HTTPException
from sqlalchemy.orm import Session
from pydantic import BaseModel

app = FastAPI()

class ItemCreate(BaseModel):
    name: str
    description: str = None

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

@app.post("/items/", response_model=ItemCreate)
def create_item(item: ItemCreate, db: Session = Depends(get_db)):
    db_item = Item(name=item.name, description=item.description)
    db.add(db_item)
    db.commit()
    db.refresh(db_item)
    return db_item
    

이번에는 클라이언트가 “/items/” 엔드포인트로 POST 요청을 전달하면, 새로운 아이템이 데이터베이스에 추가되도록 설정했습니다.

전체 코드 보기

python
from fastapi import Depends, FastAPI, HTTPException
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
from pydantic import BaseModel

# 데이터베이스 설정
DATABASE_URL = "postgresql://username:password@localhost/dbname"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

# 아이템 모델
class Item(Base):
    __tablename__ = "items"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True)
    description = Column(String, index=True)

Base.metadata.create_all(bind=engine)

# FastAPI 인스턴스 생성
app = FastAPI()

# Pydantic 모델
class ItemCreate(BaseModel):
    name: str
    description: str = None

# 데이터베이스 세션 생성
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# 아이템 생성 경로
@app.post("/items/", response_model=ItemCreate)
def create_item(item: ItemCreate, db: Session = Depends(get_db)):
    db_item = Item(name=item.name, description=item.description)
    db.add(db_item)
    db.commit()
    db.refresh(db_item)
    return db_item
    

API 테스트

FastAPI는 자동으로 Swagger UI 문서를 제공하므로, API를 테스트하기에 매우 용이합니다. 서버를 실행한 후 웹 브라우저에서 http://127.0.0.1:8000/docs로 이동하면 API 문서를 확인할 수 있습니다.

bash
# 서버 실행
(venv) $ uvicorn main:app --reload
    

POST 요청 보내기

API 문서에서 “POST /items/” 엔드포인트를 선택하고, JSON 형식으로 데이터를 입력하여 테스트할 수 있습니다. 예를 들어:

{
    "name": "example item",
    "description": "This is an example item"
}
    

위 데이터를 전송하면, 데이터베이스에 새로운 아이템이 추가됩니다.

결론

이번 글에서는 FastAPI를 사용하여 PostgreSQL 데이터베이스와 통합하고 새로운 데이터를 생성하는 방법에 대해 설명했습니다. FastAPI의 간결한 문법과 강력한 기능 덕분에 빠르게 API를 개발할 수 있었습니다. 다음 단계로서는 Read, Update, Delete 작업을 구현하고, 인증 및 권한 부여와 같은 보안 기능을 추가하는 것을 고려할 수 있습니다.

FastAPI 서버개발, 비동기 함수 및 코루틴 사용법

저자: AI 작성자

날짜: 2023년 10월

1. 서론

FastAPI는 Python으로 작성된 최신 웹 프레임워크로, 비동기 프로그래밍을 지원하여 높은 성능을 제공합니다. 본 강좌에서는 FastAPI를 사용하여 백엔드 서버를 개발하고, 비동기 함수 및 코루틴을 활용하는 방법에 대해 자세히 설명하겠습니다. 이 글에서는 FastAPI의 기본 개념뿐 아니라 비동기 프로그래밍의 원리와 장점, 그리고 이를 활용한 실제 예제 코드를 제공합니다.

2. FastAPI 소개

FastAPI는 Python의 비동기 기능을 최대한 활용하면서도 쉽고 빠르게 API를 구축할 수 있도록 설계되었습니다.

  • 비동기 지원: asyncio 라이브러리를 사용하여 비동기로 작동
  • 자동화된 문서화: OpenAPI 스펙에 따라 API 문서를 자동으로 생성
  • 유효성 검사: Pydantic을 사용하여 데이터 유효성 검사 및 직렬화를 제공
  • 성능: 비동기 처리를 통해 높은 성능을 자랑

3. 비동기 프로그래밍 개념

비동기 프로그래밍은 전통적인 동기 프로그래밍과 달리 여러 작업을 동시에 진행할 수 있는 구조입니다. 이는 네트워킹 및 I/O 작업과 같이 지연이 생기는 작업에서 속도 향상을 가져옵니다. 비동기 프로그래밍의 주요 개념은 다음과 같습니다.

  • 코루틴(Coroutine): Python의 async/await 구문을 사용하여 비동기 함수를 정의할 수 있습니다. 코루틴은 다른 코루틴에 의해 중단되고, 다시 재개될 수 있는 함수를 의미합니다.
  • 이벤트 루프(Event Loop): 비동기 프로그래밍의 핵심으로, 여러 비동기 작업을 스케줄링하고 관리하는 역할을 합니다.
  • Task: 코루틴을 이벤트 루프에서 실행하기 위해 생성되는 객체로, 실행할 코루틴을 감싸고 있습니다.

4. FastAPI 설치

FastAPI를 사용하기 위해서는 먼저 Python을 설치해야 합니다. 그 후, FastAPI와 필요한 라이브러리를 설치할 수 있습니다. 다음 명령어를 사용하여 FastAPI를 설치합니다.


pip install fastapi uvicorn
            

uvicorn은 ASGI 서버로 FastAPI 앱을 실행하는 데 필요합니다.

5. FastAPI의 기본 사용법

FastAPI의 기본 구조는 매우 간단합니다. 아래의 코드 예제는 기본적인 FastAPI 애플리케이션을 생성하는 예입니다.


from fastapi import FastAPI

app = FastAPI()

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

위의 예제에서 FastAPI 인스턴스를 생성하고, GET 요청에 대한 기본 응답을 정의하는 코루틴을 작성했습니다. 이제 서버를 실행해보겠습니다.


uvicorn main:app --reload
            

기본적으로 서버는 http://localhost:8000에서 실행됩니다. 웹 브라우저에서 해당 URL로 접속하면 JSON 형식의 {“Hello”: “World”} 응답을 확인할 수 있습니다.

6. 비동기 함수 및 코루틴

FastAPI에서는 비동기 함수와 코루틴을 쉽게 사용할 수 있습니다. 다음은 비동기 함수의 몇 가지 예제입니다. 이를 통해 비동기 작업을 어떻게 구현할 수 있는지 살펴보겠습니다.


import asyncio

async def fake_blocking_task():
    await asyncio.sleep(2)  # 2초 대기
    return "이 작업은 비동기적으로 실행됩니다."

@app.get("/async-task")
async def run_async_task():
    result = await fake_blocking_task()
    return {"result": result}
            

위 코드는 fake_blocking_task 함수를 비동기적으로 실행하며, 2초 후에 응답을 생성합니다. 클라이언트는 다른 요청을 처리하는 동안 이 작업이 백그라운드에서 진행됩니다.

7. 비동기 데이터베이스 작업

FastAPI는 데이터베이스와의 비동기 통신을 지원합니다. 예를 들어, SQLAlchemy를 사용해 비동기 작업을 수행할 수 있습니다. 다음은 SQLAlchemy를 사용하여 비동기적으로 데이터베이스와 상호작용하는 방법입니다.


from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "sqlite+aiosqlite:///./test.db"

engine = create_async_engine(DATABASE_URL, echo=True)
async_session = sessionmaker(
    bind=engine,
    expire_on_commit=False,
    class_=AsyncSession
)

async def get_items():
    async with async_session() as session:
        result = await session.execute(select(Item))
        return result.scalars().all()
            

위의 예제에서는 SQLAlchemy의 비동기 세션을 사용하여 데이터베이스에 접근하는 방법을 보여줍니다. 비동기적으로 SQL 쿼리를 실행하고 결과를 반환합니다.

8. FastAPI에서 종속성 주입 사용하기

FastAPI는 종속성 주입 시스템을 통해 코드의 재사용성과 구조적인 설계를 지원합니다. 예를 들어, 데이터베이스 세션을 전역 설정으로 주입할 수 있습니다.


from fastapi import Depends

async def get_db():
    async with async_session() as session:
        yield session

@app.get("/items/")
async def read_items(db: AsyncSession = Depends(get_db)):
    items = await get_items()
    return items
            

위 코드에서 Depends를 사용하여 종속성 주입을 구현합니다. 클라이언트 요청에 대해 데이터베이스 세션이 사용됩니다.

9. 테스트 작성하기

FastAPI는 테스트 작성도 간단하게 만들어 줍니다. 다음은 테스트 코드의 예입니다.


from fastapi.testclient import TestClient

client = TestClient(app)

def test_read_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"Hello": "World"}
            

FastAPI의 내장 TestClient를 사용하여 엔드포인트를 테스트할 수 있습니다.

10. 결론

FastAPI를 사용한 비동기 함수 및 코루틴 활용은 현대적인 웹 개발에서 필수적인 작업입니다. 이는 성능을 최적화하고, 확장 가능한 애플리케이션을 개발하는 데 큰 도움이 됩니다. 본 강좌를 통해 FastAPI의 기본 사용법부터 비동기 프로그래밍의 개념, 그리고 데이터베이스와의 상호작용까지 폭넓은 내용을 다루었습니다.

FastAPI는 지속적으로 발전하고 있으며, 앞으로도 많은 기능들이 추가될 것입니다. 여러분도 FastAPI를 활용하여 효율적이고 빠른 웹 애플리케이션을 개발해보시기 바랍니다.

본 글은 FastAPI를 활용한 서버 개발 및 비동기 프로그래밍에 대한 체계적인 안내서입니다. FastAPI의 공식 문서도 참고하시기 바랍니다.

문의 사항이 있으시면 댓글로 남겨주세요!

FastAPI 서버개발, Uvicorn으로 FastAPI 서버 실행하기

현대 웹 개발에서 효율성과 성능은 매우 중요합니다. 특히 백엔드 개발에서 이러한 요소들은 더욱 중요해지고 있습니다. FastAPI는 이러한 요구를 충족시키기 위해 설계된 Python 웹 프레임워크입니다. FastAPI는 비동기 프로그래밍을 지원하며, 빠른 API 개발을 위해 다양한 기능을 제공합니다. 이 글에서는 FastAPI를 사용하여 서버를 구축하고, Uvicorn을 사용하여 이를 실행하는 방법을 자세히 살펴보겠습니다.

1. FastAPI란?

FastAPI는 Python으로 작성된 최신 웹 프레임워크입니다. 그 주요 특징은 다음과 같습니다:

  • 비동기 지원: FastAPI는 비동기 프로그래밍을 지원하여 높은 성능을 구현할 수 있습니다.
  • 자동 문서화: FastAPI는 Swagger UI와 Redoc과 같은 자동 문서화 기능을 제공합니다.
  • 타입 힌트: Python의 타입 힌트를 기반으로 API의 데이터 모델과 유효성 검사를 자동으로 처리합니다.
  • 성능: Starlette와 Pydantic을 기반으로 구축되어 있어 매우 빠른 속도를 자랑합니다.

2. Uvicorn이란?

Uvicorn은 ASGI(Asynchronous Server Gateway Interface) 서버입니다. FastAPI와 같은 비동기 웹 프레임워크를 실행하기 위한 경량 웹 서버로, 다양한 비동기 처리를 지원합니다. FastAPI와 함께 사용할 때, 다음과 같은 장점이 있습니다:

  • 높은 성능: Uvicorn은 비동기 IO를 활용하여 요청을 처리할 수 있으므로 매우 빠릅니다.
  • 간단한 사용법: 명령어로 쉽게 서버를 실행할 수 있습니다.
  • 적은 자원 소모: 가벼운 서버이기 때문에 소모하는 자원이 적습니다.

3. FastAPI 설치하기

FastAPI를 설치하기 위해서는 Python이 설치되어 있어야 합니다. Python이 설치된 후, 다음의 명령어를 사용하여 FastAPI와 Uvicorn을 설치할 수 있습니다:

pip install fastapi uvicorn

4. FastAPI 기본 설정

설치가 완료되면, FastAPI를 이용하여 간단한 API 서버를 구축해보겠습니다. 아래는 기본적인 FastAPI 설정을 보여주는 코드 예제입니다:

from fastapi import FastAPI
    
app = FastAPI()

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

5. Uvicorn으로 FastAPI 서버 실행하기

FastAPI 애플리케이션을 실행하기 위해 Uvicorn을 사용할 수 있습니다. 위에서 작성한 코드를 main.py라는 파일에 저장한 후, 다음의 명령어로 Uvicorn 서버를 실행할 수 있습니다:

uvicorn main:app --reload

여기서 main은 파일 이름이고, app는 FastAPI 인스턴스의 이름입니다. --reload 플래그는 코드 변경 시 자동으로 서버를 다시 시작해줍니다.

5.1 실행 결과 확인하기

서버가 성공적으로 실행되면, 브라우저를 열고 http://127.0.0.1:8000에 접속하여 결과를 확인할 수 있습니다. JSON 형태로 {“message”: “Hello, FastAPI!”}가 출력됩니다. 또한, Swagger UI를 통해 API 문서에 접근할 수 있습니다. 주소는 http://127.0.0.1:8000/docs입니다.

6. FastAPI의 경로 매개변수

FastAPI는 경로 매개변수를 통해 URL의 일부를 변수로 사용할 수 있게 해줍니다. 예를 들어 사용자의 이름을 포함하는 간단한 API를 작성해보겠습니다:

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

위의 예제에서 user_id는 URL 경로에서 동적으로 추출되는 값입니다. 서버를 실행한 후 http://127.0.0.1:8000/users/1와 같은 경로에 접속하면 {"user_id": 1}와 같은 결과를 확인할 수 있습니다.

7. FastAPI의 쿼리 매개변수

쿼리 매개변수 역시 FastAPI에서 쉽게 처리할 수 있습니다. 다음은 쿼리 매개변수를 사용하는 예제입니다:

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

이 API에 접속하면서 쿼리 매개변수를 전달하면, 예를 들어 http://127.0.0.1:8000/items/?q=test로 접근 시 {"query": "test"}라는 결과를 반환합니다.

8. FastAPI에서 POST 요청 처리하기

FastAPI는 POST 요청을 통해 클라이언트로부터 데이터를 받을 수 있습니다. 아래는 JSON 형식의 요청 데이터를 처리하는 예제입니다:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

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

위와 같은 방식으로 POST 요청을 보내면, 전송된 데이터를 그대로 반환하는 API를 만들 수 있습니다. 예를 들어 요청을 보내는 방법은 다음과 같습니다:

import requests

response = requests.post("http://127.0.0.1:8000/items/", json={"name": "test", "price": 42.0})
print(response.json())

9. FastAPI와 데이터베이스 연동

FastAPI는 SQLAlchemy와 같은 ORM(Object Relational Mapping) 라이브러리와 함께 사용할 수 있습니다. 데이터베이스와의 연동을 통해 실제 데이터를 저장하고 불러오는 작업을 수행할 수 있습니다.

다음은 간단한 SQLAlchemy와 FastAPI를 연동한 코드 예제입니다:

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 User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True)

Base.metadata.create_all(bind=engine)

위의 코드는 SQLite 데이터베이스를 생성하고 users 테이블을 설정하는 작업을 수행합니다. FastAPI와 함께 데이터를 입력하고 조회하는 API를 작성할 수 있습니다.

10. 비동기 처리

FastAPI는 비동기 처리를 지원하므로, 예를 들어 여러 API를 동시에 호출해야 할 때 유용합니다. 비동기 함수를 사용하여 다음과 같이 작성할 수 있습니다:

import asyncio

async def fetch_data(url):
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        return response.json()

@app.get("/data/")
async def get_data():
    url = "http://api.example.com/data"
    data = await fetch_data(url)
    return data

11. FastAPI의 업데이트 및 삭제

FastAPI에서는 PUT 메서드를 사용하여 리소스를 업데이트하고, DELETE 메서드를 사용하여 리소스를 삭제할 수 있습니다. 다음은 업데이트와 삭제를 수행하는 간단한 예제입니다.

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    # 업데이트 로직
    return {"item_id": item_id, **item.dict()}

@app.delete("/items/{item_id}")
async def delete_item(item_id: int):
    # 삭제 로직
    return {"message": "Item has been deleted", "item_id": item_id}

12. FastAPI의 미들웨어

FastAPI는 미들웨어를 통해 요청과 응답을 가로채어 핸들링할 수 있는 기능을 제공합니다. 예를 들어, 모든 요청에 대해 로그를 기록하는 미들웨어를 작성할 수 있습니다:

from starlette.middleware.base import BaseHTTPMiddleware

class LogMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        response = await call_next(request)
        print(f"Request: {request.url}, Response Status: {response.status_code}")
        return response

app.add_middleware(LogMiddleware)

13. FastAPI와 보안

FastAPI는 OAuth2와 같은 인증 방법을 지원합니다. 이를 통해 안전하게 API를 보호하고 접근 제어를 할 수 있습니다. 아래는 간단한 보안 개요입니다:

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"}

14. 마치며

이 글에서는 FastAPI를 사용하여 백엔드 서버를 개발하고 Uvicorn을 통해 이를 실행하는 방법에 대해 살펴보았습니다. 비동기 처리, 데이터베이스 연동, RESTful API 설계 등 다양한 기능을 활용하여 강력한 웹 서버를 구축할 수 있음을 확인했습니다. FastAPI는 그 자체로도 훌륭하지만, 다양한 라이브러리와 함께 사용하여 진정한 강력함을 발휘합니다. 각자의 필요에 따라 FastAPI의 기능을 확장하여 자신만의 API 서버를 만들어 보세요!

부록: 관련 라이브러리 및 자료

FastAPI와 함께 잘 사용되는 여러 라이브러리와 자료를 소개합니다:

© 2023 FastAPI 블로그

FastAPI 서버개발, Jinja, 템플릿 상속

1. FastAPI 개요

FastAPI는 Python으로 작성된 현대적인 웹 프레임워크로, 빠르고 간편하게 API 서버를 구축할 수 있도록 설계되었습니다.
비동기 처리를 지원하고, 자동적인 문서화 (Swagger, ReDoc)을 제공하는 것이 큰 장점입니다.
FastAPI를 사용하면 개발자가 신속하게 RESTful API를 개발할 수 있습니다.
이번 포스트에서는 FastAPI의 기본적인 설정 방법과, Jinja2를 이용한 HTML 템플릿 랜더링, 그리고 템플릿 상속에 대해 알아보겠습니다.

2. FastAPI 설치 및 기본 설정

FastAPI를 사용하기 전에, 먼저 필요한 패키지를 설치해야 합니다. FastAPI는 Starlette 프레임워크 위에서 동작하기 때문에 Starlette도 함께 설치됩니다.
아래의 명령어를 사용하여 FastAPI와 uvicorn (ASGI 서버)를 설치합니다.

pip install fastapi uvicorn

2.1 기본 FastAPI 앱 작성

FastAPI 애플리케이션의 기본 코드는 다음과 같이 작성할 수 있습니다.
FastAPI 인스턴스를 생성하고, 간단한 GET 요청을 처리하는 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 응답을 받을 수 있습니다.

3. Jinja2 템플릿 엔진과의 통합

FastAPI는 Jinja2 템플릿 엔진과 쉽게 통합할 수 있습니다. Jinja2는 Python 코드 안에서 HTML을 생성할 수 있는 템플릿 엔진입니다.
먼저 다음 패키지를 설치하여 Jinja2를 사용할 수 있도록 합니다.

pip install jinja2

3.1 템플릿 디렉토리 설정 및 기본 HTML 파일 작성

템플릿 파일을 저장할 디렉토리를 생성합니다. 예를 들어, templates라는 디렉토리를 생성하겠습니다.
그 안에 index.html 파일을 작성합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>FastAPI와 Jinja</title>
</head>
<body>
    <h1>환영합니다!</h1>
    <p>FastAPI와 Jinja2 템플릿 엔진을 사용하는 방법을 배우고 있습니다.</p>
</body>
</html>

3.2 FastAPI에서 Jinja2 템플릿 사용하기

FastAPI 애플리케이션에 Jinja2 템플릿을 통합하는 방법은 다음과 같습니다.
아래의 코드를 main.py에 추가합니다.

from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
from fastapi.responses import HTMLResponse

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.get("/", response_class=HTMLResponse)
async def read_root(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

위와 같이 설정한 후 서버를 실행하면, 웹 브라우저에서 “http://127.0.0.1:8000″에 접속했을 때 index.html의 내용이 렌더링됩니다.

4. 템플릿 상속

Jinja2는 템플릿 상속 기능을 제공하여, 기본 템플릿을 정의하고 이를 상속해 서브 템플릿을 작성할 수 있습니다.
이는 코드의 재사용성을 높이고, 일관된 디자인을 유지하는 데 매우 유용합니다.

4.1 기본 템플릿 작성

먼저 base.html이라는 기본 템플릿 파일을 생성합니다. 이 파일은 페이지 레이아웃을 정의합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>FastAPI 템플릿 상속</title>
</head>
<body>
    <header>
        <h1>사이트 헤더</h1>
    </header>
    <main>
        {% block content %}{% endblock %}
    </main>
    <footer>
        <p>사이트 푸터</p>
    </footer>
</body>
</html>

4.2 서브 템플릿 작성

이제 아래와 같이 index.html 템플릿을 수정하여 base.html을 상속받도록 합니다.

{% extends "base.html" %}

{% block content %}
<h2>환영합니다!</h2>
<p>템플릿 상속의 예제입니다.</p>
{% endblock %}

4.3 FastAPI에서 템플릿 렌더링

이제 다시 main.py의 해당 엔드포인트로 돌아가서, 서브 템플릿이 올바르게 렌더링되는지 확인해보겠습니다.

from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
from fastapi.responses import HTMLResponse

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.get("/", response_class=HTMLResponse)
async def read_root(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

앞에서 작성한 서브 템플릿 index.htmlbase.html의 레이아웃을 상속받아 렌더링 됩니다.
이로써 코드의 재사용성이 보장되었습니다.

5. FastAPI의 Jinja2 활용 사례

FastAPI와 Jinja2의 조합은 동적인 웹 페이지를 만들 때 유용하게 사용됩니다.
예를 들어, 사용자 정보를 데이터베이스에서 가져와 템플릿에 렌더링하는 과정을 생각해볼 수 있습니다.
다음은 간단한 사용자 목록을 보여주는 예제입니다.

5.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"  # 간단한 SQLite 데이터베이스

engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

class User(Base):
    __tablename__ = "users"

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

Base.metadata.create_all(bind=engine)

5.2 사용자 목록 반환 엔드포인트 작성

사용자 목록을 반환하는 엔드포인트를 FastAPI에 추가합니다.
아래와 같이 작성합니다.

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

app = FastAPI()

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

@app.get("/users/", response_class=HTMLResponse)
async def read_users(request: Request, db: Session = Depends(get_db)):
    users = db.query(User).all()
    return templates.TemplateResponse("users.html", {"request": request, "users": users})

5.3 사용자 목록 템플릿 작성

사용자 목록을 보여주기 위한 users.html 템플릿을 작성합니다.

{% extends "base.html" %}

{% block content %}
<h2>사용자 목록</h2>
<ul>
    {% for user in users %}
        <li>{{ user.name }} ({{ user.email }})</li>
    {% endfor %}
</ul>
{% endblock %}

6. 결론

이번 포스트에서는 FastAPI로 백엔드 서버를 개발하고, Jinja2를 활용한 템플릿 렌더링 방법과 템플릿 상속에 대해 알아보았습니다.
FastAPI는 간단한 설정으로 API 서버를 구축할 수 있으며, Jinja2와 함께 사용하면 동적인 웹 페이지를 생성하는 데 강력한 도구가 됩니다.
이러한 조합을 통해 여러분의 웹 애플리케이션 개발에 많은 도움을 받을 수 있기를 바랍니다.

FastAPI 서버개발, APIRouter 클래스를 사용한 라우팅

오늘날의 웹 애플리케이션은 RESTful API를 통해 다양한 클라이언트 애플리케이션과 통신할 수 있는 기능이 필수적입니다. FastAPI는 Python으로 신속하게 웹 API를 구축할 수 있도록 설계된 최신 프레임워크입니다. 이번 글에서는 FastAPI의 APIRouter 클래스를 활용한 라우팅에 대해 심도 깊은 논의를 진행할 것입니다.

FastAPI란?

FastAPI는 Python의 비동기 프로그래밍을 지원하는 현대적인 웹 프레임워크로, 매우 빠른 속도를 자랑합니다. FastAPI는 또한 Pydantic과 Starlette를 기반으로 하여 데이터 검증과 처리에서 뛰어난 성능을 보여줍니다. FastAPI의 주요 특징은 다음과 같습니다:

  • 빠른 속도: Starlette를 기반으로 하여 비동기적으로 요청을 처리할 수 있습니다.
  • 자동 문서화: OpenAPI 및 JSON Schema를 통해 API 문서를 자동으로 생성합니다.
  • 데이터 검증: Pydantic을 사용하여 요청 데이터의 유효성을 검사합니다.
  • 비동기 작업 지원: async/await 문법을 지원하여 비동기 작업을 효율적으로 처리합니다.

APIRouter란?

APIRouter 클래스는 FastAPI에서 라우팅을 관리하는 데 유용한 도구입니다. 이를 통해 API 엔드포인트를 모듈화하여 코드의 재사용성과 가독성을 높일 수 있습니다. APIRouter는 특정 경로에 대한 엔드포인트를 그룹화하여 좀 더 깔끔한 구조의 코드를 작성할 수 있도록 도와줍니다.

APIRouter 사용하기

APIRouter를 사용하는 기본적인 방법은 다음과 같습니다:

from fastapi import FastAPI, APIRouter

app = FastAPI()
router = APIRouter()

@router.get("/items/")
async def read_items():
    return [{"item_id": 1}, {"item_id": 2}]

app.include_router(router)

위의 코드는 FastAPI 애플리케이션을 생성하고, APIRouter를 통해 /items/ 경로에 대한 GET 요청을 처리하는 간단한 예제입니다. router.get 데코레이터를 사용하여 HTTP GET 요청에 대한 핸들러 함수를 정의합니다.

APIRouter의 이점

  • 모듈화된 코드 구조: 라우터를 사용하여 관련된 엔드포인트를 그룹화함으로써 코드의 가독성과 관리 용이성이 향상됩니다.
  • 코드 재사용성: 라우터를 다른 파일이나 패키지에서 불러와서 사용할 수 있어, 규모가 큰 애플리케이션의 유지 보수가 용이합니다.
  • 명확한 API 문서화: 각 라우터에 대한 문서화를 개별적으로 진행할 수 있어, API 사용자가 이해하기 쉽습니다.

예제: APIRouter와 함께 복잡한 라우팅 사용하기

이번 절에서는 APIRouter를 사용하여 더 복잡한 API 라우팅 구조를 구현해보겠습니다. 다음 예제에서는 상품과 관련된 엔드포인트를 정의해 보겠습니다.

from fastapi import FastAPI, APIRouter
from typing import List

app = FastAPI()
router = APIRouter()

class Item:
    def __init__(self, item_id: int, name: str):
        self.item_id = item_id
        self.name = name

items_db = [
    Item(item_id=1, name="Item One"),
    Item(item_id=2, name="Item Two"),
]

@router.get("/items/", response_model=List[Item])
async def read_items():
    return items_db

@router.get("/items/{item_id}")
async def read_item(item_id: int):
    for item in items_db:
        if item.item_id == item_id:
            return item
    return {"message": "Item not found"}

app.include_router(router)

위의 코드는 /items/ 경로에서 모든 아이템의 목록을 반환하고, /items/{item_id} 경로에서 특정 아이템을 조회하는 엔드포인트를 제공합니다. FastAPI의 response_model 기능을 활용하여 반환되는 데이터 모델을 정의했습니다.

비동기 I/O로 성능 최적화하기

FastAPI의 장점 중 하나는 비동기 처리가 가능하다는 점입니다. 이를 통해 대규모 애플리케이션에서도 높은 성능을 유지할 수 있습니다. 데이터베이스와의 비동기 I/O 통신을 위해 다음과 같이 코드를 개선할 수 있습니다.

from fastapi import FastAPI, APIRouter
from pydantic import BaseModel
from typing import List
import asyncio

app = FastAPI()
router = APIRouter()

class Item(BaseModel):
    item_id: int
    name: str

items_db = [
    Item(item_id=1, name="Item One"),
    Item(item_id=2, name="Item Two"),
]

async def fake_db_fetch_all():
    await asyncio.sleep(1)  # Simulating a database query delay
    return items_db

@router.get("/items/", response_model=List[Item])
async def read_items():
    return await fake_db_fetch_all()

@router.get("/items/{item_id}", response_model=Item)
async def read_item(item_id: int):
    items = await fake_db_fetch_all()
    for item in items:
        if item.item_id == item_id:
            return item
    return {"message": "Item not found"}

app.include_router(router)

위의 예제는 비동기적으로 데이터를 처리하는 방법을 보여줍니다. fake_db_fetch_all 함수는 실제 데이터베이스를 사용하는 대신, `asyncio.sleep`을 통해 지연을 시뮬레이션하고 있습니다.

중간자 미들웨어를 통한 보안 및 인증 추가하기

애플리케이션의 보안성을 높이기 위해 인증 기능을 추가할 수 있습니다. FastAPI는 다양한 미들웨어를 지원하여 라우터의 요청을 가로챌 수 있습니다. 예를 들어 JWT(JSON Web Token)를 사용하여 인증을 처리할 수 있습니다.

from fastapi import FastAPI, APIRouter, Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
from pydantic import BaseModel
from typing import List

app = FastAPI()
router = APIRouter()
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

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

def fake_decode_token(token):
    return User(username=token + "user", email=token + "@example.com")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if not user:
        raise HTTPException(status_code=401, detail="Invalid authentication credentials")
    return user

@router.get("/users/me", response_model=User)
async def read_users_me(current_user: User = Depends(get_current_user)):
    return current_user

app.include_router(router)

위의 코드는 JWT 토큰을 사용하여 사용자를 인증하는 방법을 보여줍니다. Depends를 사용하여 엔드포인트에 의존성을 추가하고, OAuth2PasswordBearer를 통해 토큰을 처리합니다.

결론

FastAPI의 APIRouter 클래스를 사용하면 간결하고 구조화된 API를 구축할 수 있습니다. 모듈화된 라우팅 구조를 통해 재사용성을 높이고, 비동기 I/O를 활용하여 성능을 개선할 수 있습니다. 또한, 보안 미들웨어를 통해 중요한 정보와 자원을 보호할 수 있습니다. 이러한 기능들은 현대 웹 애플리케이션을 개발하는 데 필요한 핵심 요소입니다.

FastAPI는 개발자가 필요한 모든 기능을 갖춘 탄탄한 프레임워크입니다. 이 글을 통해 APIRouter 클래스를 효과적으로 사용하는 방법을 이해하고, 실무에 적용할 수 있기를 바랍니다.