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

FastAPI 서버개발, Jinja, if문

FastAPI는 매우 빠르고 현대적인 웹 프레임워크로, Python 3.6+에서 타입 힌트를 사용하여 API를 쉽게 구축할 수 있는 강력한 도구입니다. 이 글에서는 FastAPI를 사용하여 서버를 개발하고, Jinja 템플릿을 사용하여 동적인 웹 페이지를 생성하는 방법을 알아보겠습니다. 특히, Jinja 템플릿에서 if 문을 활용해 조건부 렌더링을 실습할 것입니다.

FastAPI란?

FastAPI는 Python으로 작성된 비동기 웹 프레임워크로, RESTful API를 쉽게 개발할 수 있게 도와줍니다. FastAPI는 다음과 같은 특징을 가지고 있습니다:

  • 빠름: Starlette과 Pydantic을 기반으로 하여 비동기 처리를 지원하고, 빠른 성능을 자랑합니다.
  • 타입 힌트: Python 타입 힌트를 사용하여 코드의 가독성과 오류 검출을 향상시킬 수 있습니다.
  • 자동화된 문서화: API 문서가 자동으로 생성되며 사용자에게 쉽게 제공합니다.

FastAPI와 Jinja2

FastAPI는 템플릿을 사용할 수 있는 백엔드 프레임워크입니다. 이를 통해 클라이언트에게 동적인 HTML 페이지를 제공할 수 있습니다. FastAPI와 Jinja2를 함께 사용하는 방법을 살펴보겠습니다.

설치하기

우선, FastAPI와 Jinja2를 설치해야 합니다. 다음과 같은 명령어로 설치할 수 있습니다:

pip install fastapi[all] jinja2

FastAPI 서버 구성하기

다음은 기본적인 FastAPI 서버를 설정하는 예시 코드입니다:

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

여기서 우리는 FastAPI 인스턴스를 만들고 Jinja2 템플릿 디렉토리를 설정합니다. 기본적인 루트 경로(“/”)에 대한 GET 요청을 처리하는 함수를 정의하였습니다. 이 함수는 클라이언트에게 index.html 템플릿을 응답합니다.

템플릿 파일 생성하기

템플릿 파일은 templates/index.html에 생성합니다. 이 파일은 HTML로 구성된 페이지를 정의합니다. 기존 페이지를 위해 다음 내용을 추가할 수 있습니다:

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>FastAPI와 Jinja2 소개</title>
</head>
<body>
    <h1>안녕하세요!</h1>
    <p>FastAPI 및 Jinja2를 사용하여 동적인 웹 페이지를 만들고 있습니다.</p>
</body>
</html>

Jinja2의 if 문 사용하기

이제 동적인 콘텐츠를 추가해 보겠습니다. Jinja2의 if 문을 사용하여 페이지에서 조건부 로직을 사용할 수 있습니다. 다음은 간단한 예입니다:

<h2>환영합니다!</h2>
<ul>
    <li>오늘 날짜는 {{ date }}입니다.</li>
    <li>{% if user_logged_in %}로그인 상태입니다.{% else %}로그인하지 않았습니다.{% endif %}</li>
</ul>

여기서 user_logged_in 변수를 조건부로 사용하여 로그인 상태를 출력할 수 있습니다. 이를 위해 FastAPI 서버 코드에서 이 변수를 추가해야 합니다:

from datetime import datetime

@app.get("/", response_class=HTMLResponse)
async def read_root(request: Request):
    user_logged_in = True  # 예시로 로그인 상태를 true로 설정
    date_today = datetime.now().strftime("%Y-%m-%d")
    return templates.TemplateResponse("index.html", {"request": request, "user_logged_in": user_logged_in, "date": date_today})

전체 코드 정리하기

이제 지금까지 작성한 코드를 통합해 봅시다. FastAPI 서버 코드와 템플릿을 최종적으로 구성해보겠습니다:

FastAPI 서버 코드

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

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

@app.get("/", response_class=HTMLResponse)
async def read_root(request: Request):
    user_logged_in = True  # 예시로 로그인 상태를 true로 설정
    date_today = datetime.now().strftime("%Y-%m-%d")
    return templates.TemplateResponse("index.html", {"request": request, "user_logged_in": user_logged_in, "date": date_today})

templates/index.html 파일

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>FastAPI와 Jinja2 소개</title>
</head>
<body>
    <h1>안녕하세요!</h1>
    <h2>환영합니다!</h2>
    <ul>
        <li>오늘 날짜는 {{ date }}입니다.</li>
        <li>{% if user_logged_in %}로그인 상태입니다.{% else %}로그인하지 않았습니다.{% endif %}</li>
    </ul>
</body>
</html>

데모 실행하기

이제 모든 것이 준비되었습니다. 아래 명령어로 FastAPI 서버를 실행할 수 있습니다:

uvicorn main:app --reload

main.py 파일 이름으로 저장한 후, 위 명령어를 사용하여 서버를 시작할 수 있습니다. 웹 브라우저에서 http://127.0.0.1:8000를 열면, 우리가 만든 동적인 웹 페이지를 확인할 수 있습니다.

마무리

이 글에서는 FastAPI를 사용하여 간단한 서버를 구축하고, Jinja2의 if 문을 활용하여 조건부 렌더링을 구현하는 방법을 배웠습니다. FastAPI는 속도와 효율성을 자랑하는 훌륭한 웹 프레임워크이며 Jinja2와 함께 사용하면 동적인 웹 페이지를 쉽게 만들 수 있습니다. 이 강좌를 통해 FastAPI와 Jinja2에 대한 이해를 높이길 바랍니다.

향후 더 많은 기능과 복잡한 예제를 구현하는 방향으로 나아가길 권장합니다. FastAPI의 공식 문서와 Jinja2의 문서를 참고하여 더 깊이 있는 학습을 진행해 보세요.

FastAPI 서버개발, FastAPI Middleware 사용하기

오늘날 웹 애플리케이션 개발에서는 API 서버가 매우 중요한 역할을 하며, FastAPI는 그러한 API 서버를 빠르게 구축할 수 있는 효율적인 프레임워크입니다. 이번 강좌에서는 FastAPI의 기본적인 개념을 설명하고, Middleware의 개념과 사용법에 대해 심층적으로 알아보겠습니다.

1. FastAPI란 무엇인가?

FastAPI는 Python으로 개발된 현대적인 웹 프레임워크로, RESTful API를 빠르게 구축하는 데 초점을 맞추고 있습니다. FastAPI는 다음과 같은 주요 기능을 제공합니다:

  • 빠른 성능: Starlette와 Pydantic을 기반으로 하여 매우 빠른 처리 속도를 자랑합니다.
  • 자동화된 문서 생성: OpenAPI 및 JSON Schema를 사용하여 Swagger UI와 ReDoc 같은 문서를 자동으로 생성합니다.
  • 유효성 검사: Pydantic을 사용하여 데이터 유효성을 검사하고 문서화합니다.
  • 비동기 지원: 비동기 프로그래밍을 지원하여 높은 성능을 유지할 수 있습니다.

2. Middleware란 무엇인가?

Middleware는 요청(request)과 응답(response) 사이에서 작업을 수행하는 코드를 의미합니다. 기본적으로 웹 프레임워크의 ‘층'(layer) 사이에서 실행되며, 다음과 같은 작업을 수행할 수 있습니다:

  • 요청/응답의 로깅
  • 인증 및 권한 부여
  • 처리 시간 측정
  • 요청 데이터 변형
  • CORS 처리

FastAPI에서는 Middleware를 사용하여 이러한 작업을 효율적으로 처리할 수 있습니다. FastAPI는 Starlette 기반으로 구축되어 있으므로 Starlette의 Middleware를 그대로 사용할 수 있습니다.

3. FastAPI Middleware 기본 사용법

3.1 FastAPI 설치하기

먼저, FastAPI와 Uvicorn을 설치합니다. Uvicorn은 FastAPI 애플리케이션을 실행하기 위한 ASGI 서버입니다.

pip install fastapi uvicorn

3.2 기본 FastAPI 애플리케이션 만들기

기본 FastAPI 애플리케이션을 만들어 보겠습니다.

from fastapi import FastAPI

app = FastAPI()

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

이 코드는 기본적인 FastAPI 애플리케이션을 정의합니다. 웹 브라우저에서 http://127.0.0.1:8000/에 접근하면 {“message”: “Hello, FastAPI!”}라는 JSON 응답을 볼 수 있습니다.

3.3 Middleware 추가하기

이제 애플리케이션에 Middleware를 추가해 보겠습니다. 다음은 요청과 응답을 로그로 기록하는 Middleware의 예입니다.

from fastapi import FastAPI
from starlette.middleware.base import BaseHTTPMiddleware
import time

class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        start_time = time.time()
        
        # 요청 로그
        print(f"Request: {request.method} {request.url}")
        
        # 다음 미들웨어 또는 라우트를 호출하고 응답 받기
        response = await call_next(request)

        # 응답 로그
        duration = time.time() - start_time
        print(f"Response: {response.status_code} | Duration: {duration:.2f} seconds")

        return response

app = FastAPI()

# Middleware 등록
app.add_middleware(LoggingMiddleware)

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

위의 코드에서 우리는 LoggingMiddleware 클래스를 정의하여 요청과 응답을 로그로 기록합니다. dispatch 메서드 내에서 요청을 로그로 기록하고, call_next 함수를 호출하여 다음 미들웨어 또는 최종 라우트로 요청을 전달합니다. 마지막으로 응답을 받아 로그를 기록하고 클라이언트에게 반환합니다.

4. 여러 Middleware 사용하기

FastAPI에서 여러 가지 Middleware를 함께 사용할 수 있습니다. 예를 들어, 다음과 같이 CORS(Cross-Origin Resource Sharing) Middleware와 Logging Middleware를 함께 사용할 수 있습니다.

from fastapi import FastAPI
from starlette.middleware.cors import CORSMiddleware
from starlette.middleware.base import BaseHTTPMiddleware
import time

class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        start_time = time.time()
        print(f"Request: {request.method} {request.url}")
        response = await call_next(request)
        duration = time.time() - start_time
        print(f"Response: {response.status_code} | Duration: {duration:.2f} seconds")
        return response

app = FastAPI()

# CORS Middleware 등록
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # 모든 오리진 허용
    allow_credentials=True,
    allow_methods=["*"],  # 모든 HTTP 메서드 허용
    allow_headers=["*"],  # 모든 헤더 허용
)

# Logging Middleware 등록
app.add_middleware(LoggingMiddleware)

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

5. 실전 예제: 사용자 인증을 위한 Middleware 구현

이번에는 기본적인 사용자 인증을 위한 Middleware를 만들어 보고, 이를 사용하여 API에 접근할 수 있는 사용자 인증을 구현해 보겠습니다.

from fastapi import FastAPI, Depends, HTTPException, status
from starlette.middleware.base import BaseHTTPMiddleware

class AuthMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        token = request.headers.get("Authorization")
        
        # 기본적인 토큰 검증
        if token != "Bearer mysecrettoken":
            raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Unauthorized")
        
        response = await call_next(request)
        return response

app = FastAPI()

# 인증 Middleware 등록
app.add_middleware(AuthMiddleware)

@app.get("/protected")
async def protected_route():
    return {"message": "You are authorized!"}

위의 코드는 간단한 인증 Middleware를 구현한 것입니다. 요청의 헤더에 Authorization 필드가 있는지를 확인하고, 유효한 토큰이 아닐 경우 401 Unauthorized 에러를 반환합니다. 이를 통해 /protected 엔드포인트에 접근할 때 인증이 필요하게 됩니다.

6. 결론

FastAPI는 매우 강력한 웹 프레임워크로, Middleware를 통해 다양한 기능을 추가할 수 있습니다. 본 강좌에서는 Middleware의 기본 개념과 구현 방법, 그리고 여러 가지 사용 사례를 다루어 보았습니다. 이를 통해 API 서버를 더욱 유연하고 강력하게 만들 수 있습니다.

FastAPI와 Middleware에 대해 더 배우고 싶다면 공식 문서와 다양한 예제를 참고하시기 바랍니다. 짧은 코드로 강력한 웹 애플리케이션을 구축할 수 있는 FastAPI의 매력을 경험해 보세요!

FastAPI 서버개발, 요청 바디

1. FastAPI란?

FastAPI는 Python 기반의 웹 프레임워크로, API를 빠르고 쉽게 구축할 수 있도록 설계되었습니다. 비동기적이며, 타입 주석(type hint)을 지원하여 자동화된 문서화와 유효성 검사를 제공합니다. FastAPI를 사용하면 RESTful API를 빠르게 구현할 수 있으며, 높은 성능을 자랑합니다.

2. 요청 바디란?

HTTP 요청 바디는 클라이언트가 서버에 데이터를 전달할 때 사용하는 방법 중 하나입니다. 주로 POST, PUT, PATCH 등의 HTTP 메서드와 함께 사용됩니다. 요청 바디를 통해 JSON, XML, Form Data 등의 형식으로 데이터를 전송할 수 있습니다.

3. FastAPI의 요청 바디 처리

FastAPI에서는 요청 바디를 쉽게 처리할 수 있도록 다양한 방법을 제공합니다. 이 섹션에서는 FastAPI에서 요청 바디를 처리하는 기본적인 방법과 예제를 다루겠습니다.

3.1. Pydantic을 사용한 요청 바디의 정의

FastAPI는 Pydantic을 사용하여 유효한 데이터 모델을 정의합니다. Pydantic 모델을 정의하면 요청 바디의 구조를 강제로 지정할 수 있으며, 데이터 검증 및 직렬화/역직렬화를 쉽게 처리할 수 있습니다.


from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

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

위의 예제에서는 Item이라는 Pydantic 모델을 정의했습니다. 이 모델은 name, price, is_offer라는 세 가지 속성을 가지고 있습니다. create_item 함수는 POST 요청을 통해 Item 객체를 생성하고 반환합니다.

3.2. 요청 바디의 타입 지정

FastAPI는 요청 바디의 타입을 자동으로 지정하여 적절한 데이터 형식을 사용하도록 도와줍니다. 위의 예제에서 item: Item은 FastAPI에게 이 요청이 Item 모델에 의해 정의된 형식을 갖추어야 함을 알립니다.


from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

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

@app.post("/users/")
async def create_user(user: User):
    if user.username == "admin":
        raise HTTPException(status_code=400, detail="Username 'admin' is not allowed.")
    return user
        

위의 예제에서 create_user 함수는 User 모델의 인스턴스를 기대하며, 사용자가 ‘admin’이라는 이름을 사용할 경우 예외를 발생시킵니다.

4. 요청 바디와 다양한 MIME 타입

FastAPI는 여러 가지 MIME 타입을 지원합니다. 여기서는 JSON과 Form Data의 요청 바디를 처리하는 방법을 살펴보겠습니다.

4.1. JSON 요청 바디 처리

FastAPI는 기본적으로 JSON 형식의 요청 바디를 처리합니다. 클라이언트가 JSON 데이터를 요청 바디로 전송하면, FastAPI는 자동으로 이를 Python 객체로 변환합니다.


@app.post("/json/")
async def read_json(item: Item):
    return {"item_name": item.name, "item_price": item.price}
        

위의 예제에서 클라이언트가 JSON 형식으로 요청을 보내면 FastAPI가 이를 Item 객체로 변환하고, 서버는 해당 객체의 속성을 사용하여 응답을 구성합니다.

4.2. Form Data 요청 바디 처리

FastAPI는 Form Data 형식으로 데이터를 처리하는 방법도 제공합니다. 이 경우에는 Form 함수를 사용하여 요청 바디의 데이터를 얻을 수 있습니다.


from fastapi import Form

@app.post("/form/")
async def create_form(username: str = Form(...), password: str = Form(...)):
    return {"username": username, "password": password}
        

이 방법은 HTML 폼을 통해 데이터를 전달할 때 유용하게 사용될 수 있습니다. Form(...)는 필수 필드임을 나타냅니다.

5. 에러 처리

FastAPI는 데이터 유효성 검사를 통해 발생하는 오류를 자동으로 처리합니다. 잘못된 데이터 형식이 요청되면, FastAPI는 HTTP 422 상태 코드와 함께 오류 메시지를 반환합니다.


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

# 클라이언트가 잘못된 데이터 형식으로 요청할 경우:
# {"username": 123, "email": "invalid email"}
        

위와 같이 잘못된 데이터가 들어올 경우 FastAPI는 자동으로 에러 메시지를 생성하여 클라이언트에 전달합니다.

6. 요청 바디와 보안

요청 바디를 처리할 때는 보안 역시 중요한 요소입니다. 외부에서 들어오는 데이터는 항상 검증하고 종류를 정확히 파악해야 합니다. FastAPI는 SQL 인젝션, XSS와 같은 공격을 방지하기 위한 다양한 기능을 제공합니다.

추가적으로 FastAPI는 OAuth2, JWT 등의 보안 기능을 지원하여 인증 및 권한 부여를 제공할 수 있습니다.

7. FastAPI의 요청 바디 기능 요약

FastAPI는 요청 바디를 처리하는 데 있어 매우 유연하고 강력한 기능을 제공합니다. Pydantic 모델을 활용하여 데이터 구조를 정의하고, 다양한 형식의 데이터를 지원합니다. JSON, Form Data, Multipart 등의 형식을 쉽게 처리할 수 있으며, 오류 처리가 용이합니다.

또한 FastAPI는 비동기 처리를 지원하므로, 높은 성능을 유지하면서도 복잡한 데이터 요청을 처리할 수 있습니다.

8. 마치며

FastAPI를 사용하여 요청 바디를 처리하는 방법에 대해 알아보았습니다. 이 강좌를 통해 FastAPI의 기능을 활용하여 보다 안정적이고 효율적인 웹 API를 구축할 수 있기를 바랍니다.

이제 여러분은 FastAPI 서버에서 요청 바디를 효과적으로 처리할 수 있는 능력을 갖추었습니다. 앞으로의 프로젝트에서 이를 활용해 보세요!