``` FastAPI = Fast + API └── “빠른 API 개발” └── 실행 속도도 빠름 (Node.js, Go 수준) └── 개발 속도도 빠름 (타입 힌트 기반 자동화)
FastAPI 프레임워크이(가) 등장한 배경과 기존 한계를 정리한다.
이 주제를 이해하고 적용해야 하는 이유를 정리한다.
작성일: 2026-01-28 카테고리: Backend / Python / Web Framework 포함 내용: FastAPI, Pydantic, ASGI, 비동기, Starlette, Django/Flask 비교
FastAPI = Fast + API
└── "빠른 API 개발"
└── 실행 속도도 빠름 (Node.js, Go 수준)
└── 개발 속도도 빠름 (타입 힌트 기반 자동화)
정체: Python 웹 프레임워크 (API 특화)
창시자: Sebastián Ramírez (@tiangolo)
첫 릴리스: 2018년 12월
┌─────────────────────────────────────────────────────────┐
│ Python 웹 프레임워크의 역사 │
│ │
│ 2005: Django 등장 │
│ └── "풀스택" 프레임워크 │
│ └── ORM, 템플릿, 어드민 등 모든 것 포함 │
│ └── 무겁고, API만 만들기엔 과함 │
│ │
│ 2010: Flask 등장 │
│ └── "마이크로" 프레임워크 │
│ └── 가볍고 유연함 │
│ └── 하지만 비동기 미지원, 타입 힌트 없음 │
│ │
│ 2018년 당시 문제점: │
│ ├── Django/Flask = 동기식 (WSGI) │
│ ├── 비동기 필요 → 별도 프레임워크 (aiohttp, Sanic) │
│ ├── API 문서 자동화 부족 │
│ ├── 타입 검증 수동 구현 │
│ └── Python 3.6+ 타입 힌트 활용 미흡 │
│ │
│ 2018: FastAPI 등장 │
│ "현대적인 Python의 장점을 모두 활용하자!" │
│ │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ │
│ 1. 성능 문제 │
│ └── Starlette 기반 비동기 (ASGI) │
│ └── Node.js, Go 수준의 성능 │
│ │
│ 2. 타입 안정성 │
│ └── Pydantic으로 자동 검증 │
│ └── 타입 힌트 = 런타임 검증 │
│ │
│ 3. API 문서화 │
│ └── Swagger UI 자동 생성 │
│ └── OpenAPI 스펙 자동 생성 │
│ │
│ 4. 개발 생산성 │
│ └── 코드량 40% 감소 (공식 주장) │
│ └── IDE 자동완성 완벽 지원 │
│ │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ FastAPI 구성 │
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ FastAPI (최상위) │ │
│ │ API 라우팅, 의존성 주입 │ │
│ └─────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────────┼──────────────┐ │
│ ▼ ▼ ▼ │
│ ┌───────────┐ ┌───────────┐ ┌───────────┐ │
│ │ Starlette │ │ Pydantic │ │ Uvicorn │ │
│ │ (웹 코어) │ │ (검증) │ │ (서버) │ │
│ └───────────┘ └───────────┘ └───────────┘ │
│ │
│ Starlette: 비동기 웹 프레임워크 (ASGI) │
│ Pydantic: 데이터 검증 & 직렬화 │
│ Uvicorn: ASGI 서버 (실제 HTTP 처리) │
│ │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ │
│ WSGI (Web Server Gateway Interface) - 전통적 │
│ ├── 동기식 처리 │
│ ├── 요청 1개 = 스레드 1개 │
│ ├── Django, Flask │
│ └── I/O 대기 시 자원 낭비 │
│ │
│ ASGI (Asynchronous Server Gateway Interface) - 현대적 │
│ ├── 비동기 처리 (async/await) │
│ ├── 요청 N개 = 이벤트 루프 1개 │
│ ├── FastAPI, Starlette │
│ └── I/O 대기 중 다른 요청 처리 │
│ │
│ 비유: │
│ WSGI = 식당에서 웨이터 1명이 테이블 1개만 담당 │
│ ASGI = 웨이터 1명이 여러 테이블 동시에 담당 │
│ (주문 받고 → 다른 테이블 → 음식 나오면 서빙) │
│ │
└─────────────────────────────────────────────────────────┘
pip install fastapi
pip install uvicorn[standard] # ASGI 서버
# main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
uvicorn main:app --reload
# 접속:
# http://localhost:8000 → API
# http://localhost:8000/docs → Swagger UI (자동 생성!)
# http://localhost:8000/redoc → ReDoc (자동 생성!)
from fastapi import FastAPI
from pydantic import BaseModel, EmailStr
from typing import Optional
app = FastAPI()
# 요청/응답 모델 정의
class User(BaseModel):
name: str
email: EmailStr # 이메일 형식 자동 검증
age: int
is_active: bool = True # 기본값
bio: Optional[str] = None # 선택적 필드
@app.post("/users/")
def create_user(user: User):
# user는 이미 검증 완료된 상태!
# 잘못된 데이터면 자동으로 422 에러 반환
return user
┌─────────────────────────────────────────────────────────┐
│ │
│ Pydantic이 해주는 일: │
│ │
│ 1. 타입 검증 │
│ age: int ← "abc" 들어오면 자동 에러 │
│ │
│ 2. 타입 변환 │
│ age: int ← "25" 들어오면 자동으로 25로 변환 │
│ │
│ 3. 복잡한 검증 │
│ EmailStr ← 이메일 형식 검증 │
│ HttpUrl ← URL 형식 검증 │
│ │
│ 4. JSON 직렬화/역직렬화 │
│ 자동으로 JSON ↔ Python 객체 변환 │
│ │
└─────────────────────────────────────────────────────────┘
from fastapi import FastAPI, Depends, HTTPException, Header
app = FastAPI()
# 의존성 함수
def get_db():
db = DatabaseConnection()
try:
yield db
finally:
db.close()
def get_current_user(token: str = Header(...)):
user = decode_token(token)
if not user:
raise HTTPException(status_code=401)
return user
# 사용
@app.get("/users/me")
def read_current_user(
current_user: User = Depends(get_current_user),
db: Database = Depends(get_db)
):
return current_user
┌─────────────────────────────────────────────────────────┐
│ │
│ 의존성 주입의 장점: │
│ │
│ 1. 코드 재사용 │
│ └── 인증 로직을 여러 엔드포인트에서 재사용 │
│ │
│ 2. 테스트 용이성 │
│ └── 의존성을 Mock으로 교체 가능 │
│ │
│ 3. 관심사 분리 │
│ └── DB 연결, 인증 등을 엔드포인트에서 분리 │
│ │
└─────────────────────────────────────────────────────────┘
from fastapi import FastAPI
import httpx
import asyncio
app = FastAPI()
# 동기 함수 (일반)
@app.get("/sync")
def sync_endpoint():
return {"message": "sync"}
# 비동기 함수 (async)
@app.get("/async")
async def async_endpoint():
# 비동기 HTTP 요청
async with httpx.AsyncClient() as client:
response = await client.get("https://api.example.com")
return response.json()
# 여러 비동기 작업 동시 실행
@app.get("/parallel")
async def parallel_endpoint():
async with httpx.AsyncClient() as client:
# 동시에 3개 API 호출
results = await asyncio.gather(
client.get("https://api1.com"),
client.get("https://api2.com"),
client.get("https://api3.com"),
)
return [r.json() for r in results]
┌─────────────────────────────────────────────────────────┐
│ │
│ 코드만 작성하면 자동으로 생성되는 것들: │
│ │
│ 1. /docs (Swagger UI) │
│ └── 인터랙티브 API 테스트 가능 │
│ │
│ 2. /redoc (ReDoc) │
│ └── 깔끔한 문서 형태 │
│ │
│ 3. /openapi.json │
│ └── OpenAPI 스펙 JSON │
│ └── 다른 도구와 연동 가능 │
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ @app.get("/users/{user_id}") │ │
│ │ def get_user(user_id: int) -> User: │ │
│ │ ... │ │
│ └─────────────────────────────────────────────┘ │
│ ↓ 자동 변환 │
│ ┌─────────────────────────────────────────────┐ │
│ │ GET /users/{user_id} │ │
│ │ Parameters: user_id (integer, required) │ │
│ │ Response: User schema │ │
│ └─────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ 비교 │
│ │
│ 항목 │ FastAPI │ Flask │ Django │
│ ───────────┼───────────┼───────────┼──────────────── │
│ 타입 │ 마이크로 │ 마이크로 │ 풀스택 │
│ 비동기 │ ✅ 네이티브│ ❌ 제한적 │ ❌/⚠️ 3.1+ │
│ 타입 힌트 │ ✅ 필수 │ ❌ 선택 │ ❌ 선택 │
│ 자동 문서 │ ✅ 내장 │ ❌ 별도 │ ❌ 별도 │
│ 성능 │ 매우 빠름 │ 보통 │ 보통 │
│ 학습 곡선 │ 낮음 │ 낮음 │ 높음 │
│ ORM │ ❌ 별도 │ ❌ 별도 │ ✅ 내장 │
│ 어드민 │ ❌ 별도 │ ❌ 별도 │ ✅ 내장 │
│ │
│ 선택 기준: │
│ FastAPI → API 서버, 마이크로서비스, ML 서빙 │
│ Flask → 간단한 웹앱, 레거시 호환 │
│ Django → 풀스택 웹앱, 어드민 필요, 빠른 MVP │
│ │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ │
│ 결론: "부분적으로 Yes, 완전히는 No" │
│ │
│ ✅ FastAPI가 대체한 영역: │
│ ├── API 전용 서버 (REST API, GraphQL) │
│ ├── 마이크로서비스 백엔드 │
│ ├── ML 모델 서빙 │
│ └── 실시간 애플리케이션 │
│ │
│ ❌ Django가 여전히 강한 영역: │
│ ├── 풀스택 웹 애플리케이션 (템플릿 렌더링) │
│ ├── 어드민 패널이 필요한 서비스 │
│ ├── ORM + 마이그레이션 통합 필요 │
│ └── 빠른 MVP 개발 (배터리 포함) │
│ │
│ ⚠️ Flask의 현재 위치: │
│ ├── 레거시 프로젝트 유지보수 │
│ ├── 아주 간단한 웹앱 │
│ └── 새 프로젝트에서는 FastAPI 선호 추세 │
│ │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ │
│ GitHub Stars (2025년 기준): │
│ ├── Django: ~80k │
│ ├── Flask: ~68k │
│ └── FastAPI: ~78k ← 가장 빠르게 성장 │
│ │
│ 신규 프로젝트 선택 트렌드: │
│ ├── "API만 만들 거야" → FastAPI (거의 표준) │
│ ├── "웹사이트 + 어드민" → Django │
│ ├── "기존 Flask 확장" → Flask 유지 또는 FastAPI 전환 │
│ │
│ 채용 시장: │
│ ├── Django: 여전히 많음 (엔터프라이즈, 스타트업) │
│ ├── FastAPI: 급증 (특히 AI/ML 회사) │
│ └── Flask: 감소 추세 │
│ │
└─────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────┐
│ │
│ "API 서버" 영역에서는 FastAPI가 사실상 표준이 됨 │
│ │
│ 하지만 Django는 다른 영역에서 여전히 강력: │
│ → 풀스택, 어드민, 빠른 MVP │
│ │
│ Flask는 점점 입지가 줄어드는 중: │
│ → FastAPI가 Flask의 "가벼움" + 더 많은 기능 제공 │
│ → 새 프로젝트에서 Flask 선택 이유가 줄어듦 │
│ │
│ 비유: │
│ Django = SUV (풀옵션, 무거움, 만능) │
│ Flask = 경차 (가벼움, 기본만) → 점점 안 팔림 │
│ FastAPI = 스포츠카 (빠름, 현대적) → 요즘 인기 │
│ │
│ 각자 용도가 다르지만, │
│ "API 서버"만 놓고 보면 FastAPI가 승자 │
│ │
└─────────────────────────────────────────────────────────┘
my_project/
├── app/
│ ├── __init__.py
│ ├── main.py # FastAPI 앱 생성
│ ├── dependencies.py # 의존성 (DB, 인증 등)
│ ├── routers/ # API 라우터
│ │ ├── users.py
│ │ └── items.py
│ ├── models/ # Pydantic 모델
│ │ ├── user.py
│ │ └── item.py
│ ├── crud/ # DB 작업
│ │ └── user.py
│ └── core/ # 설정, 보안
│ ├── config.py
│ └── security.py
├── tests/
├── requirements.txt
└── Dockerfile
┌─────────────────────────────────────────────────────────┐
│ │
│ FastAPI = 현대적인 Python API 프레임워크 │
│ │
│ 핵심 특징: │
│ ├── 빠른 성능 (Starlette + ASGI) │
│ ├── 타입 힌트 기반 자동 검증 (Pydantic) │
│ ├── 자동 API 문서 (Swagger/OpenAPI) │
│ ├── 비동기 네이티브 지원 (async/await) │
│ └── 의존성 주입 내장 │
│ │
│ 등장 배경: │
│ ├── Flask/Django의 동기식 한계 │
│ ├── Python 3.6+ 타입 힌트 활용 │
│ ├── API 문서화 자동화 필요 │
│ └── Node.js/Go 수준 성능 필요 │
│ │
│ 사용 사례: │
│ ├── REST API 서버 │
│ ├── 마이크로서비스 │
│ ├── ML 모델 서빙 │
│ └── 실시간 애플리케이션 (WebSocket) │
│ │
│ 시장 위치: │
│ ├── API 서버 영역: 사실상 표준 │
│ ├── Flask 대체: 거의 완료 │
│ └── Django 대체: 영역이 달라서 공존 │
│ │
└─────────────────────────────────────────────────────────┘
FastAPI, Python, Pydantic, ASGI, Starlette, Uvicorn, 비동기, 타입 힌트, Swagger, OpenAPI, Django, Flask