라이브스마트

FastAPI는 최신 웹 프레임워크로, Python으로 작성된 API를 만드는 데 매우 효율적입니다. 이 강좌에서는 FastAPI를 사용하여 기본적인 백엔드 서버를 개발하고 Google Cloud Platform(GCP)에 배포하는 과정을 단계별로 안내할 것입니다.

1. FastAPI란?

FastAPI는 Python으로 작성된 비동기 웹 프레임워크로, RESTful API를 쉽게 제작할 수 있게 해줍니다. FastAPI의 주요 특징은 높은 성능, 쉬운 사용법, 자동화된 문서화 기능입니다. Starlette를 기반으로 하며, Pydantic을 사용하여 데이터 검증과 직렬화를 지원합니다.

1.1 FastAPI의 주요 기능

• 비동기 지원: FastAPI는 비동기 프로그래밍을 지원하여 높은 성능을 제공합니다.
• 자동 문서화: OpenAPI를 기반으로 한 자동 API 문서화 기능을 제공합니다.
• 유효성 검사: Pydantic을 이용하여 데이터 유효성 검사와 직렬화를 간편하게 처리할 수 있습니다.
• 경량화: 기본적인 사용법이 간단하여 작은 규모의 애플리케이션부터 대규모 서비스까지 적합합니다.

2. FastAPI 서버 개발하기

이번 섹션에서는 FastAPI를 이용하여 간단한 REST API 서버를 구축해 보겠습니다. 예제를 통해 FastAPI의 기본적인 사용법을 익힐 수 있습니다.

2.1 FastAPI 설치하기

FastAPI와 Uvicorn(ASGI 서버)을 설치하기 위해 다음 명령어를 사용합니다:

pip install fastapi uvicorn

2.2 간단한 API 예제

다음은 기본적인 FastAPI 서버 코드입니다. 이 코드는 간단한 GET 및 POST 요청을 처리하는 API를 정의하고 있습니다.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# 데이터 모델 정의
class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

# GET 요청 처리
@app.get("/")
def read_root():
    return {"Hello": "World"}

# POST 요청 처리
@app.post("/items/")
def create_item(item: Item):
    return {"item": item}

위 코드는 FastAPI를 사용하여 기본적인 API를 설정하는 방법을 보여줍니다. Item이라는 데이터 모델을 만들고, GET 요청과 POST 요청을 처리하는 두 개의 엔드포인트를 설정했습니다.

2.3 서버 실행하기

다음 명령어를 사용하여 FastAPI 서버를 실행할 수 있습니다:

uvicorn main:app --reload

서버가 시작되면 http://localhost:8000/docs에서 자동 생성된 API 문서를 확인할 수 있습니다.

3. Google Cloud Platform에 배포하기

이제 FastAPI 서버를 GCP에 배포하는 방법을 알아보겠습니다. GCP의 Cloud Run 서비스를 사용하면 컨테이너화된 애플리케이션을 간편하게 배포할 수 있습니다.

3.1 GCP 프로젝트 생성

GCP에 접속하여 새로운 프로젝트를 생성합니다. 다음 단계로 진행하기 전에 GCP에서 결제 계정을 설정해야 할 수도 있습니다.

3.2 Dockerfile 작성하기

FastAPI 애플리케이션을 컨테이너화하기 위해 Dockerfile을 작성합니다. 다음은 간단한 Dockerfile 예제입니다:

# 베이스 이미지 선택
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

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

# requirements.txt 복사
COPY requirements.txt .

# 의존성 설치
RUN pip install --no-cache-dir -r requirements.txt

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

# 애플리케이션 실행
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

3.3 requirements.txt 파일 작성

requirements.txt 파일은 다음과 같이 작성합니다:

fastapi
uvicorn
pydantic

3.4 Docker 이미지 빌드하기

Docker 이미지를 빌드하기 위해 다음 명령어를 실행합니다:

docker build -t my-fastapi-app .

3.5 GCP에 Docker 이미지 푸시

GCP의 Container Registry에 Docker 이미지를 푸시해야 합니다. 먼저 GCP에 로그인한 후, 다음 명령어를 실행하여 이미지 푸시를 진행합니다:

# GCP에 로그인
gcloud auth configure-docker

# 이미지 태깅
docker tag my-fastapi-app gcr.io/[PROJECT_ID]/my-fastapi-app

# 이미지 푸시
docker push gcr.io/[PROJECT_ID]/my-fastapi-app

3.6 Cloud Run에 배포하기

이제 Cloud Run을 통해 애플리케이션을 배포합니다. 다음 명령어를 사용하여 GCP Cloud Run에 배포합니다:

gcloud run deploy my-fastapi-app --image gcr.io/[PROJECT_ID]/my-fastapi-app --platform managed

배포가 완료되면 URL이 제공됩니다. 제공된 URL을 통해 FastAPI 애플리케이션에 접근할 수 있습니다.

4. 결론

이번 강좌에서는 FastAPI를 이용하여 기본적인 REST API 서버를 개발하고, 이를 Google Cloud Platform에 배포하는 방법을 알아보았습니다. FastAPI는 강력하고 사용하기 쉬운 웹 프레임워크로, GCP와의 통합을 통해 강력한 클라우드 기반 애플리케이션을 구축할 수 있습니다. 더 많은 기능과 고급 기술을 익히는 데 있어 FastAPI의 공식 문서를 참조해 보시기 바랍니다.

최근 몇 년간 웹 개발의 트렌드는 변화해왔으며, Python 언어의 인기도 그에 힘입어 나란히 증가하고 있습니다. FastAPI는 비동기 프로그래밍을 지원하는 현대적인 웹 프레임워크로, 성능과 사용 편의성을 모두 갖춘 특징을 가지고 있습니다. 본 강좌에서는 FastAPI를 이용하여 백엔드 서버를 개발하는 방법과 함께, Jinja 템플릿 엔진을 사용하여 동적인 HTML 페이지를 생성하는 방법에 대해 깊이 있게 다루어보겠습니다.

목차

• 1. FastAPI 개요
• 2. Jinja 템플릿 엔진 이해하기
• 3. FastAPI와 Jinja 연동하기
• 4. 실제 예제: 기본 FastAPI 서버 구축하기
• 5. Jinja를 활용한 동적 HTML 페이지 생성하기
• 6. 결론 및 향후 학습 방향

1. FastAPI 개요

FastAPI는 Python 3.6+부터 사용할 수 있는 웹 프레임워크로, RESTful API를 쉽게 개발할 수 있도록 도와줍니다. FastAPI는 다음과 같은 주요 특징들이 있습니다:

• 자동 문서화: Swagger UI를 통해 API 문서를 자동으로 생성합니다.
• 높은 성능: Starlette를 기반으로 하여 비동기 러닝을 지원합니다.
• 타입 힌트: Python의 타입 힌트를 활용하여 코드의 가독성과 안전성을 향상시킵니다.

2. Jinja 템플릿 엔진 이해하기

Jinja는 Python에서 사용할 수 있는 가장 인기 있는 템플릿 엔진으로, HTML 페이지를 동적으로 생성하는 데 유용합니다. Jinja의 주된 기능은 다음과 같습니다:

• 템플릿 상속: 기본 구조를 설정하고, 필요에 따라 자식 템플릿에서 이를 상속받아 사용할 수 있습니다.
• 조건문 및 반복문 지원: Jinja는 데이터의 조건에 따라 HTML을 구성할 수 있는 기능을 제공합니다.
• 필터 기능: 템플릿에서 데이터를 원하는 형태로 변환할 수 있는 다양한 필터를 제공합니다.

3. FastAPI와 Jinja 연동하기

FastAPI는 Jinja 템플릿 엔진과의 통합이 용이하여, HTML 페이지를 생성하는 데 필요한 설정이 간단합니다. 다음은 FastAPI와 Jinja를 연동하는 기본적인 방법입니다:

3.1. FastAPI 설치하기

pip install fastapi uvicorn jinja2

3.2. 기본 프로젝트 구조

프로젝트의 기본 폴더 구조는 다음과 같이 설정합니다:

• /your_project
  • main.py
  • /templates
    • index.html

3.3. FastAPI 앱과 Jinja 설정하기

이제 FastAPI 애플리케이션을 설정하고 Jinja 템플릿 엔진을 등록해 보겠습니다:

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

app = FastAPI()

templates = Jinja2Templates(directory="templates")

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

4. 실제 예제: 기본 FastAPI 서버 구축하기

이제 기본 FastAPI 서버를 구축하는 방법을 알아보겠습니다. 이전에 설정한 main.py 파일에 아래의 코드를 추가하면 됩니다:

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

app = FastAPI()

templates = Jinja2Templates(directory="templates")

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

# 예외 처리
@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

위 코드는 FastAPI 애플리케이션을 설정하고, 두 개의 경로를 정의하는 작업을 수행합니다. 첫 번째 경로는 루트 경로이고, 두 번째 경로는 동적 경로로, 특정 item ID를 입력받아 해당 값을 JSON 형태로 반환합니다.

5. Jinja를 활용한 동적 HTML 페이지 생성하기

이제 Jinja 템플릿을 활용하여 HTML 페이지를 동적으로 생성해보겠습니다. templates/index.html 파일을 아래와 같이 생성합니다:

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>FastAPI와 Jinja 예제</title>
</head>
<body>
    <h1>안녕하세요, FastAPI와 Jinja를 사용하여 동적으로 생성된 페이지입니다.</h1>
    <p>현재 접속한 경로: {{ request.url.path }}</p>
</body>
</html>

이 HTML 파일은 FastAPI에서 전달한 request 객체의 URL 경로를 출력합니다. 이제 FastAPI 서버를 실행하고 웹 브라우저에서 확인해보겠습니다:

uvicorn main:app --reload

이제 http://127.0.0.1:8000/ 에 접근할 수 있습니다. 위에서 설정한 HTML 페이지가 렌더링 되어 표시될 것입니다. 또한, /items/1와 같은 경로에 접근하면 JSON 형태로 아이템 ID를 확인할 수 있습니다.

6. 결론 및 향후 학습 방향

FastAPI와 Jinja 템플릿 엔진을 활용하여 동적인 웹 페이지를 쉽게 구축하는 방법에 대해 살펴보았습니다. FastAPI의 강력한 기능은 REST API 개발 뿐만 아니라 효율적인 웹 애플리케이션 작성에도 큰 도움을 줍니다. 향후 이 주제로 더 깊이 있는 학습을 원하신다면, 다음과 같은 주제를 고려해 보시기 바랍니다:

• FastAPI의 OAuth2 및 JWT 인증
• 데이터베이스와의 통합 (SQLAlchemy, Tortoise-ORM 등)
• 비동기 작업 처리 (Celery 등)

최신 트렌드에 맞추어 FastAPI의 기능을 활용하여 더욱 발전하는 웹 개발자가 되어보시기 바랍니다!

작성일: 2023년 10월 1일

소개

FastAPI는 현대의 웹 API를 빠르고 쉽게 개발할 수 있게 해주는 파워풀한 프레임워크입니다.
Python 3.6 이상을 지원하며, 자동 문서 생성, 데이터 검증, 비동기 프로그래밍 등 다양한 기능을 제공합니다.
이번 글에서는 FastAPI를 이용해 로그인 API를 만들고, 이후에 이를 변경하는 방법에 대해 상세히 설명하겠습니다.
우리는 기본적인 사용자 인증 로직을 구현한 후, 이를 안전하게 변경하는 방법에 대해 단계별로 살펴보겠습니다.

FastAPI 시작하기

FastAPI를 설치하기 위해서는 Python이 설치되어 있어야 합니다. 아래의 명령어를 터미널에 입력하여 FastAPI와 Uvicorn을 설치할 수 있습니다:

pip install fastapi uvicorn

설치가 완료되면, 아래와 같이 기본적인 FastAPI 애플리케이션을 생성할 수 있습니다:

from fastapi import FastAPI

app = FastAPI()

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

이 코드를 main.py라는 파일에 저장하고, 아래의 명령어를 통해 서버를 실행해볼 수 있습니다:

uvicorn main:app --reload

로그인 라우트 구현하기

이제 사용자가 이메일과 비밀번호를 통해 로그인할 수 있는 API 라우트를 구현해보겠습니다. 먼저, 사용자 정보를 저장하기 위한 간단한 데이터 모델을 만들어야 합니다.

from pydantic import BaseModel

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

다음으로, 로그인 API를 추가합니다:

@app.post("/login")
async def login(user: User):
    # 일반적으로 데이터베이스와의 상호작용이 필요합니다.
    fake_db = {"user@example.com": "hashed_password"}
    
    if user.email in fake_db and user.password == fake_db[user.email]:
        return {"message": "로그인 성공!"}
    return {"message": "잘못된 이메일 또는 비밀번호입니다."}

위 코드는 기본적인 로그인 검증을 수행하고, 성공 여부에 따라 다른 메시지를 반환합니다.

보안 강화

로그인 API의 보안을 강화하기 위해 비밀번호를 해싱하여 저장하면 사용자 정보를 보다 안전하게 보호할 수 있습니다. 비밀번호 해싱에는 bcrypt 라이브러리를 사용할 수 있습니다. 아래를 통해 설치합니다:

pip install bcrypt

그리고 아래와 같이 비밀번호를 해싱하고 확인하는 함수를 구현합니다:

import bcrypt

def hash_password(password: str) -> str:
    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')

def verify_password(plain_password: str, hashed_password: str) -> bool:
    return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))

로그인 라우트에서는 이제 해시된 비밀번호를 사용하여 비밀번호 확인을 수행합니다:

@app.post("/login")
async def login(user: User):
    fake_db = {"user@example.com": hash_password("securepassword")}
    
    if user.email in fake_db and verify_password(user.password, fake_db[user.email]):
        return {"message": "로그인 성공!"}
    return {"message": "잘못된 이메일 또는 비밀번호입니다."}

라우트 변경하기

이제 로그인 라우트를 변경하는 방법을 설명하겠습니다. 예를 들어, 사용자 인증을 JWT(JSON Web Token)를 통해 처리하도록 변경할 수 있습니다. JWT는 클라이언트와 서버 간의 안전한 통신을 가능하게 해주는 토큰 기반 인증 시스템입니다.

우선, 필요한 라이브러리인 pyjwt를 설치합니다:

pip install pyjwt

JWT 토큰을 생성하고 검증하는 유틸리티 함수를 만듭니다:

import jwt
from datetime import datetime, timedelta

SECRET_KEY = "your_secret_key"  # 안전하게 보관해야 합니다.
ALGORITHM = "HS256"

def create_access_token(data: dict, expires_delta: timedelta = None):
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=15)
    to_encode.update({"exp": expire})
    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)

def verify_token(token: str):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        return payload
    except jwt.PyJWTError:
        return None

이제 로그인 라우트를 변경하여 JWT를 반환하도록 하겠습니다:

@app.post("/login")
async def login(user: User):
    fake_db = {"user@example.com": hash_password("securepassword")}
    
    if user.email in fake_db and verify_password(user.password, fake_db[user.email]):
        access_token = create_access_token(data={"sub": user.email})
        return {"access_token": access_token, "token_type": "bearer"}
    return {"message": "잘못된 이메일 또는 비밀번호입니다."}

토큰 인증을 위한 보호 라우트

이제 JWT를 사용한 보호 라우트를 추가해보겠습니다. 사용자가 로그인 후 발급받은 토큰을 통해 접근할 수 있는 API 엔드포인트를 만들어볼 것입니다.

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    payload = verify_token(token)
    if payload is None:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="유효하지 않은 토큰입니다.",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return payload

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

위 코드는 사용자가 JWT를 통해 인증된 경우에만 사용자 정보를 반환하는 방법을 보여줍니다.

결론 및 요약

이 글에서는 FastAPI를 이용하여 로그인 API를 구현하고, 이를 JWT를 통해 변경하는 방법을 단계별로 설명했습니다. 보안이 중요한 현대의 웹 애플리케이션에서 사용자 인증은 필수적이며, FastAPI는 이를 간편하게 처리할 수 있는 다양한 기능을 제공합니다. 다음 단계로는 데이터베이스와의 연동, 사용자 등록 등의 기능을 추가하여 보다 복잡한 시스템을 구축하는 것일 수 있습니다.

FastAPI는 직관적이고 강력한 API 개발을 가능하게 하며, 다양한 라이브러리와의 통합으로 이를 더욱 확장할 수 있습니다. 이 글을 통해 FastAPI의 기능과 JWT를 활용한 인증 방법에 대한 이해가 깊어지기를 바랍니다.

FastAPI는 Python으로 작성된 현대적인 웹 프레임워크로, 빠르고 효율적인 API를 구축하는 데 최적화되어 있습니다. 이 글에서는 FastAPI를 사용해 간단한 이벤트 플래너 애플리케이션을 개발하는 과정을 상세히 설명하겠습니다. 이 과정은 FastAPI 서버의 구조화, RESTful API 설계, 데이터베이스 연동, 인증 및 권한 부여 등을 포함합니다.

FastAPI 소개

FastAPI는 다음과 같은 특징을 가지고 있습니다:

• ⚡ 신속한 성능: Starlette로 구축된 비동기 기반이므로 매우 빠릅니다.
• 🔄 자동 문서화: Swagger UI와 ReDoc을 사용하여 API 문서를 자동 생성합니다.
• 📦 타입 힌팅: Python 타입 힌트를 사용하여 코드 품질과 가독성을 높입니다.
• 🔒 보안 & 인증: OAuth2와 JWT를 통해 강력한 인증과 인가 기능을 제공합니다.

환경 설정

FastAPI 애플리케이션을 개발하기 위해 필요한 기본 환경을 설정해보겠습니다. 먼저, FastAPI와 Uvicorn을 설치해야 합니다.

pip install fastapi uvicorn

프로젝트 구조화

이벤트 플래너 애플리케이션의 코드를 구조화하는 방법은 다음과 같습니다:

event_planner/
├── app/
│   ├── main.py
│   ├── models.py
│   ├── schemas.py
│   ├── database.py
│   └── routes/
│       └── events.py
└── requirements.txt

1. main.py

FastAPI 애플리케이션의 엔트리 포인트인 main.py 파일에서는 FastAPI 인스턴스를 생성하고, 중간웨어 및 라우터를 설정합니다.

from fastapi import FastAPI
from .routes import events

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "이벤트 플래너 API에 오신 것을 환영합니다!"}

app.include_router(events.router)

2. models.py

models.py 파일은 SQLAlchemy 데이터 모델을 정의합니다. 이벤트 플래너 애플리케이션에서는 이벤트에 대한 기본적인 모델을 설정합니다.

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

class Event(Base):
    __tablename__ = "events"
    
    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, index=True)
    description = Column(String)
    location = Column(String)
    time = Column(String)

3. schemas.py

schemas.py에서는 Pydantic을 사용하여 데이터 검증 및 직렬화를 합니다. 이 파일은 API의 요청 바디와 응답 모델을 정의합니다.

from pydantic import BaseModel

class EventBase(BaseModel):
    title: str
    description: str
    location: str
    time: str

class EventCreate(EventBase):
    pass

class Event(EventBase):
    id: int

    class Config:
        orm_mode = True

4. database.py

database.py에서는 데이터베이스 연결을 설정하고 세션을 관리합니다. SQLAlchemy를 통한 데이터베이스 설정을 진행합니다.

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

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

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

Base = declarative_base()

5. routes/events.py

이벤트 관련 API 엔드포인트를 담당하는 events.py 파일에서는 CRUD 기능을 작성합니다.

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from .. import models, schemas
from ..database import SessionLocal

router = APIRouter()

# 의존성 주입을 위한 함수
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@router.post("/events/", response_model=schemas.Event)
async def create_event(event: schemas.EventCreate, db: Session = Depends(get_db)):
    db_event = models.Event(**event.dict())
    db.add(db_event)
    db.commit()
    db.refresh(db_event)
    return db_event

@router.get("/events/{event_id}", response_model=schemas.Event)
async def read_event(event_id: int, db: Session = Depends(get_db)):
    db_event = db.query(models.Event).filter(models.Event.id == event_id).first()
    if db_event is None:
        raise HTTPException(status_code=404, detail="이벤트를 찾을 수 없습니다.")
    return db_event

@router.get("/events/", response_model=list[schemas.Event])
async def read_events(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
    events = db.query(models.Event).offset(skip).limit(limit).all()
    return events

FastAPI 애플리케이션 실행

모든 설정이 완료되면 Uvicorn을 통해 애플리케이션을 실행할 수 있습니다.

uvicorn app.main:app --reload

브라우저에서 http://127.0.0.1:8000/docs를 열어 자동 생성된 API 문서와 Swagger UI를 확인하며 API를 테스트할 수 있습니다.

데이터베이스 설정

SQLite 데이터베이스를 사용할 경우, 데이터베이스를 초기화하고 테이블을 생성해야 합니다. 다음 코드를 main.py에 추가하여 처음 실행할 때 테이블을 생성합니다.

from fastapi import FastAPI
from .database import engine, Base

# DB 초기화
Base.metadata.create_all(bind=engine)

인증 및 권한 부여

이번 애플리케이션에서는 간단한 사용자 인증을 추가할 수 있습니다. FastAPI는 OAuth2와 JWT를 지원하므로, 이를 이용해 보호된 엔드포인트를 만들 수 있습니다. 예를 들어, 이벤트 삭제 엔드포인트에 인증을 추가하는 방식으로 접근할 수 있습니다.

from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from fastapi import Depends
from .. import models, schemas
import bcrypt

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

def fake_hash_password(password: str):
    return "fakehashed" + password

@router.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
    user = db.query(models.User).filter(models.User.username == form_data.username).first()
    if not user or not bcrypt.checkpw(form_data.password.encode('utf-8'), user.hashed_password.encode('utf-8')):
        raise HTTPException(status_code=400, detail="잘못된 사용자명 또는 비밀번호")
    return {"access_token": user.username, "token_type": "bearer"}

결론

이러한 단계를 통해 FastAPI와 SQLAlchemy를 활용하여 이벤트 플래너 애플리케이션의 기본 구조를 설정했습니다. 이 애플리케이션에서 더 발전된 기능을 추가해보며 FastAPI의 다양한 특징을 경험할 수 있습니다. FastAPI의 문서화와 비동기 처리가 효율적이기 때문에, 복잡한 웹 애플리케이션 개발의 도전 과제를 쉽게 극복할 수 있습니다. 이 프로젝트를 통해 FastAPI의 실제 사용 사례를 접해보길 바랍니다!

작성자: 조광형

날짜: 2024년 11월 26일

1. 서론

FastAPI는 Python을 기반으로 하는 현대적인 웹 프레임워크로, 비동기 프로그래밍을 지원하며 최적화된 성능을 자랑합니다. RESTful API를 쉽게 구축할 수 있도록 돕는 FastAPI의 특징 중 하나는 데이터 검증과 자동 문서 생성 기능입니다. 이 강좌에서는 FastAPI를 사용하여 액세스 토큰을 생성하고 검증하는 방법에 대해 다룹니다. 액세스 토큰은 인증 및 권한 부여에 필수적이며, 깔끔하고 안전한 API를 만드는 데 중요한 요소입니다.

2. FastAPI 기본 설정

FastAPI를 사용하기 위해 먼저 필요한 라이브러리를 설치해야 합니다. 아래 명령어를 통해 FastAPI와 필요한 종속성을 설치합니다.

pip install fastapi[all] python-jose

다음으로 FastAPI 애플리케이션을 생성합니다. 아래의 코드는 가장 기본적인 FastAPI 서버를 설정하는 방법을 보여줍니다.

from fastapi import FastAPI

app = FastAPI()

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

위 코드를 실행한 후 웹 브라우저에서 http://localhost:8000에 접속하면 “Hello, FastAPI!”라는 메시지를 확인할 수 있습니다.

3. JWT(Json Web Token) 이해하기

액세스 토큰을 구현하기 위해서는 JWT를 사용합니다. JWT는 클라이언트와 서버 간의 안전한 정보를 전달하기 위한 표준으로, 세 부분으로 구성됩니다: 헤더, 페이로드, 서명. 이를 통해 데이터를 안전하게 전송할 수 있습니다.

• 헤더: 토큰의 타입과 사용되는 알고리즘을 정의합니다.
• 페이로드: 전달할 정보를 포함합니다. 예를 들어, 사용자 ID, 만료 시간 등의 정보를 담을 수 있습니다.
• 서명: 헤더와 페이로드를 비밀키로 해시하여 생성된 값으로, 데이터의 무결성을 확인하는 데 사용됩니다.

4. 액세스 토큰 생성 및 검증 구현하기

이제 액세스 토큰을 생성하고 검증하는 작업을 진행해 보겠습니다. 이를 위해 Python의 python-jose 라이브러리를 사용할 것입니다. 먼저, 토큰을 생성하는 함수를 만들어 보겠습니다.

from datetime import datetime, timedelta
from jose import JWTError, jwt
from fastapi import Depends, HTTPException, status, Security
from fastapi.security import OAuth2PasswordBearer
from typing import Optional

SECRET_KEY = "mysecretkey"  # 비밀키
ALGORITHM = "HS256"  # 알고리즘
ACCESS_TOKEN_EXPIRE_MINUTES = 30  # 만료 시간 설정

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=15)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt
            

위 코드는 액세스 토큰을 생성하는 함수입니다. 사용자가 로그인 할 때 이 함수를 호출하여 액세스 토큰을 생성합니다.

5. 액세스 토큰을 사용하는 사용자 인증

다음으로 사용자 인증을 위한 엔드포인트를 만들어 보겠습니다. 사용자 로그인을 처리하고, 액세스 토큰을 반환하는 API 를 작성합니다.

from pydantic import BaseModel

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

fake_users_db = {
    "testuser": {
        "username": "testuser",
        "full_name": "Test User",
        "email": "testuser@example.com",
        "hashed_password": "fakehashedpassword",
        "disabled": False,
    }
}

def fake_hash_password(password: str):
    return "fakehashed" + password

@app.post("/token")
async def login(user: User):
    user_dict = fake_users_db.get(user.username)
    if not user_dict or user_dict["hashed_password"] != fake_hash_password(user.password):
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(data={"sub": user.username}, expires_delta=access_token_expires)
    return {"access_token": access_token, "token_type": "bearer"}
            

위 코드는 로그인을 처리하고 액세스 토큰을 반환하는 /token 엔드포인트입니다. 사용자가 올바른 사용자 이름과 비밀번호를 제공하면, 액세스 토큰이 생성되어 반환됩니다.

6. 토큰 검증

액세스 토큰이 생성되면, 이를 검증하는 것이 중요합니다. 특정 엔드포인트에 액세스하기 위해서는 유효한 토큰이 필요합니다. 아래 코드를 통해 이를 구현할 수 있습니다.

async def get_current_user(token: str = Depends(oauth2_scheme)):
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
    except JWTError:
        raise credentials_exception
    user = fake_users_db.get(username)
    if user is None:
        raise credentials_exception
    return user

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

위의 코드는 액세스 토큰을 검증하고 해당 사용자 정보를 반환하는 /users/me 엔드포인트입니다. 요청에서 토큰을 추출하여 사용자 정보를 확인합니다.

7. 테스트

API를 테스트하기 위해, curl이나 Postman과 같은 도구를 사용할 수 있습니다. 아래는 Postman에서의 테스트 방법입니다:

1. POST 요청을 통해 사용자 로그인:

   POST http://localhost:8000/token

   Body에 JSON 형태로 사용자 이름과 비밀번호를 입력합니다:

   {"username": "testuser", "password": "testpassword"}

2. 응답으로 받은 액세스 토큰을 이용하여 사용자 정보 요청:

   GET http://localhost:8000/users/me

   Authorization 헤더에 Bearer {access_token}을 추가합니다.

8. 결론

이번 강좌에서는 FastAPI를 사용하여 액세스 토큰을 생성하고 검증하는 방법에 대해 학습했습니다. FastAPI의 강력한 기능은 다양한 인증 방법을 구현하는 데 유용합니다. JWT를 통한 인증은 API의 보안을 강화하는 중요한 방법 중 하나입니다.

추가적인 개선 사항으로는 사용자 데이터베이스 통합, 비밀번호 해싱 강화, 그리고 에러 처리 로직을 추가할 수 있습니다.