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

소개

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를 활용한 인증 방법에 대한 이해가 깊어지기를 바랍니다.

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의 보안을 강화하는 중요한 방법 중 하나입니다.

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

1. FastAPI란?

FastAPI는 Python으로 작성된 현대적인 웹 프레임워크입니다. 비동기 프로그래밍을 지원하며, 속도가 빠르고 코드 작성이 간단한 특징을 가지고 있습니다. FastAPI는 OpenAPI와 JSON Schema를 기반으로 하여, 자동으로 문서화된 API를 생성할 수 있습니다. 또한, 타입 힌팅(Type Hinting)을 활용하여 오류를 사전에 예방할 수 있는 장점이 있습니다.

2. Docker란?

Docker는 애플리케이션을 컨테이너라는 가벼운 격리된 환경에서 실행할 수 있게 해주는 플랫폼입니다. 개발자들은 의존성을 포함한 모든 패키지를 컨테이너에 포함시켜, ‘어디서나 일관된 환경에서 실행되도록’ 할 수 있습니다. Docker를 사용하면 생산성과 효율성을 크게 향상시킬 수 있습니다.

3. Docker Compose란?

Docker Compose는 여러 개의 Docker 컨테이너를 정의하고 관리할 수 있는 도구입니다. YAML 파일을 사용하여 애플리케이션의 서비스를 정의하고, 단일 명령으로 여러 컨테이너를 실행할 수 있습니다. Docker Compose를 사용하면 복잡한 애플리케이션의 관리가 훨씬 수월해집니다.

4. FastAPI 서버 만들기

이제 FastAPI로 간단한 웹 서버를 만들어 보겠습니다. 먼저 필요한 패키지를 설치합니다.

pip install fastapi uvicorn

다음으로, FastAPI 앱을 설정합니다. main.py라는 파일을 생성하고 아래 코드를 작성합니다.

from fastapi import FastAPI

app = FastAPI()

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

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

위의 코드는 간단한 FastAPI 애플리케이션을 생성합니다. 루트 경로(“/”)는 “Hello World”를 반환하고, “/items/{item_id}” 경로는 요청한 item_id와 쿼리 매개변수 q를 반환합니다.

5. Dockerfile 생성하기

Docker를 사용하여 FastAPI 애플리케이션을 배포하기 위해 Dockerfile을 생성합니다. 프로젝트의 루트 디렉토리에 Dockerfile을 생성하고 아래 내용을 작성합니다.

FROM python:3.9

WORKDIR /app

COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

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

위의 Dockerfile에서는 Python 3.9 이미지를 기반으로 애플리케이션을 위한 작업 디렉토리 /app를 설정합니다. 필요한 패키지를 설치하고 애플리케이션 코드를 복사한 후, uvicorn을 실행하여 FastAPI 서버를 시작합니다.

6. requirements.txt 생성하기

FastAPI와 Uvicorn을 설치하기 위한 requirements.txt 파일을 생성합니다. 다음 내용을 requirements.txt에 추가합니다.

fastapi
uvicorn

7. Docker Compose 설정하기

여러 서비스를 쉽게 관리하기 위해 docker-compose.yml 파일을 생성합니다. 프로젝트의 루트 디렉토리에 아래와 같이 docker-compose.yml 파일을 작성합니다.

version: '3.8'

services:
  app:
    build: .
    ports:
      - "80:80"

이 구성 파일은 “app”이라는 서비스를 정의하고, 현재 디렉토리에서 이미지를 빌드합니다. 또한, 호스트의 80 포트를 컨테이너의 80 포트에 매핑합니다.

8. Docker Compose를 통해 서버 실행하기

이제 모든 설정이 완료되었습니다. 다음 명령어로 Docker Compose를 통해 FastAPI 서버를 실행할 수 있습니다.

docker-compose up --build

위 명령어를 실행하면 Docker가 이미지를 빌드하고 컨테이너를 실행합니다. 브라우저에서 http://localhost로 접근하면 “Hello World” 메시지를 볼 수 있습니다.

9. 요약 및 결론

이 글에서는 FastAPI 서버를 개발하고 Docker Compose를 사용하여 이미지를 빌드하는 방법을 살펴보았습니다. FastAPI는 경량이며 비동기 처리를 지원하는 프레임워크로, Docker는 환경 구성을 통합하여 배포를 수월하게 만들어 줍니다. 이러한 도구들은 특히 복잡한 애플리케이션을 구축할 때 효과적입니다.

이제 여러분은 FastAPI와 Docker Compose를 활용하여 자신의 프로젝트에 맞게 서버를 구축하고 배포할 수 있는 능력을 갖추게 되었습니다.

추가적으로, 다양한 FastAPI의 기능 및 Docker의 고급 사용법을 탐구해보시기 바랍니다.