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 서버에서 요청 바디를 효과적으로 처리할 수 있는 능력을 갖추었습니다. 앞으로의 프로젝트에서 이를 활용해 보세요!

FastAPI 서버개발, GCP 계정 작성

소개

FastAPI는 현대적인 웹 API를 빠르고 쉽게 개발할 수 있도록 돕는 파이썬 기반의 프레임워크입니다.
비동기 프로그래밍을 지원하여 높은 성능을 제공하며, 부트스트랩이 쉬운 문서화 지원이 특징입니다.
GCP(Google Cloud Platform)는 다양한 클라우드 서비스와 도구를 제공하는 구글의 플랫폼으로, FastAPI 애플리케이션을
배포하기에 적합한 환경입니다. 본 블로그 포스트에서는 FastAPI 서버를 개발하고 이를 GCP에 배포하기 위해 필요한
GCP 계정을 만드는 방법에 대해 자세히 설명합니다.

1. GCP 계정 생성하기

GCP 서비스를 사용하기 위해서는 먼저 Google 계정을 생성해야 하며, 이후 GCP에 로그인하여 계정을 생성할 수 있습니다.

Step 1: Google 계정 만들기

GCP에 접근하기 위해서는 Google 계정이 필요합니다. Google 계정이 없는 경우, [Google 계정 만들기](https://accounts.google.com/signup) 페이지를 방문하여 계정을 생성하세요.
계정 생성 후에는 이메일 인증을 완료해야 합니다.

Step 2: GCP에 로그인하기

Google 계정을 생성한 후, [GCP 콘솔](https://console.cloud.google.com/)에 로그인합니다.
GCP의 대시보드에 접근할 수 있습니다.

Step 3: GCP 프로젝트 생성하기

GCP 콘솔에 로그인한 후, 새로운 프로젝트를 생성해야 합니다. 상단의 드롭다운 메뉴에서 “프로젝트 만들기”를 클릭하여
프로젝트 이름을 입력하고 “만들기” 버튼을 클릭합니다.

GCP 프로젝트 생성 화면

Step 4: GCP 무료 사용 등록하기

GCP는 새 사용자에게 90일 동안 사용할 수 있는 무료 크레딧을 제공합니다.
이를 통해 다양한 GCP 서비스를 사용해 볼 수 있습니다. GCP에 가입할 때 무료 사용등록 절차를 따라야 합니다.

2. FastAPI 프로젝트 개발하기

GCP 계정을 생성하고 프로젝트를 만들었다면, 본격적으로 FastAPI 프로젝트를 시작해 보겠습니다.
FastAPI는 Python의 async/await 문법을 활용하여 비동기 처리를 지원합니다.
아래는 간단한 FastAPI 애플리케이션을 만드는 방법입니다.

Step 1: 환경 설정

FastAPI를 설치하기 위해서는 Python과 pip가 필요합니다. Python 3.6 이상이 설치되어 있어야 하며, 아래의 명령어로
FastAPI 및 Uvicorn 서버를 설치합니다.

pip install fastapi uvicorn

Step 2: FastAPI 애플리케이션 작성

간단한 Hello World API를 작성해 보겠습니다. 아래의 코드를 app.py 파일에 저장하세요.


from fastapi import FastAPI

app = FastAPI()

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

Step 3: 애플리케이션 실행하기

아래의 명령어를 통해 FastAPI 애플리케이션을 로컬에서 실행할 수 있습니다.

uvicorn app:app --reload

로컬에서 실행하면, http://127.0.0.1:8000/docs에서 Swagger UI를 통해 API를 테스트할 수 있습니다.

3. FastAPI 애플리케이션 GCP에 배포하기

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

Step 1: Dockerfile 작성하기

FastAPI 애플리케이션을 Docker 이미지를 생성하기 위해 Dockerfile을 작성합니다. 아래의 내용을 가진 Dockerfile을 생성하세요.


# Dockerfile

FROM python:3.9

WORKDIR /app

COPY . .

RUN pip install fastapi uvicorn

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

Step 2: Docker 이미지 빌드하기

아래의 명령어를 통해 Docker 이미지를 빌드합니다.

docker build -t fastapi-gcp .

Step 3: Google Container Registry에 이미지 푸시하기

Google Container Registry에 로그인하고 빌드한 이미지를 푸시합니다.

docker tag fastapi-gcp gcr.io/[PROJECT-ID]/fastapi-gcp
docker push gcr.io/[PROJECT-ID]/fastapi-gcp

Step 4: Cloud Run을 통해 애플리케이션 배포하기

GCP 콘솔에서 Cloud Run을 선택하고 “배포”를 클릭합니다.
이미지 URL에 위의 GCR URL을 입력하고 배포를 완료합니다.

Cloud Run 배포 화면

배포가 완료된 후 제공된 URL로 FastAPI 애플리케이션에 접근할 수 있습니다.

결론

본 포스트에서는 FastAPI 서버개발과 GCP 계정 작성, 그리고 이를 GCP에 배포하는 과정에 대해 알아보았습니다.
FastAPI를 사용하면 웹 API를 빠르고 쉽게 개발할 수 있으며, GCP는 이러한 애플리케이션을 클라우드에서 손쉽게 호스팅할 수 있는
강력한 플랫폼입니다. 여러분의 프로젝트에 FastAPI와 GCP를 활용해 보세요!

FastAPI 서버개발, SQLAlchemy와 FastAPI를 이용한 데이터베이스 연동

소개

FastAPI는 Python기반의 현대적인 웹 프레임워크로, 비동기 프로그래밍을 지원하고 자동 생성된 API 문서와 유효성 검사를 제공합니다.
본 글에서는 FastAPI와 SQLAlchemy를 사용하여 데이터베이스와 연동하는 방법에 대해 자세히 알아보겠습니다.

FastAPI와 SQLAlchemy 개요

SQLAlchemy는 Python용 SQL 툴킷이자 Object Relational Mapper(ORM)이다.
ORM은 데이터를 클래스로 표현하고, 데이터베이스의 테이블을 객체로 매핑하여 SQL 쿼리를 객체지향적으로 처리할 수 있게 해준다.
FastAPI는 이러한 SQLAlchemy와 잘 통합되어 강력한 RESTful API를 쉽게 구축할 수 있도록 지원한다.

필요한 패키지 설치하기

pip install fastapi uvicorn sqlalchemy databases

프로젝트 구조

이번 예제에서는 다음과 같은 파일 구조를 사용할 것입니다:


    project/
    ├── main.py
    ├── models.py
    ├── database.py
    └── schemas.py
    

1. 데이터베이스 설정

이제 데이터베이스에 연결하기 위한 설정을 해보겠습니다.

database.py


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

    # 데이터베이스 URL 설정
    DATABASE_URL = "sqlite:///./test.db"  # SQLite 데이터베이스 사용

    # 데이터베이스 엔진을 생성
    engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})

    # 세션을 설정
    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

    # 기본 클래스 생성
    Base = declarative_base()

    # 데이터베이스 메타데이터
    metadata = MetaData()
    

2. 모델 정의하기

이제 SQLAlchemy 모델을 정의할 차례입니다. 모델은 데이터베이스의 테이블 구조를 정의한 것입니다.

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)  # ID 필드
        name = Column(String, index=True)  # Name 필드
        email = Column(String, unique=True, index=True)  # Email 필드
    

3. Pydantic 스키마 생성하기

FastAPI는 데이터 유효성 검사 및 직렬화를 위해 Pydantic을 사용합니다. 우리는 요청 및 응답에 대한 스키마를 생성해야 합니다.

schemas.py


    from pydantic import BaseModel
    from typing import Optional

    class UserBase(BaseModel):
        name: str
        email: str

    class UserCreate(UserBase):
        pass

    class User(UserBase):
        id: int

        class Config:
            orm_mode = True  # ORM 모드를 활성화
    

4. FastAPI 애플리케이션 생성하기

이제 FastAPI 애플리케이션을 설정할 시간입니다. 우리는 CRUD(Create, Read, Update, Delete) 작업을 구현할 것입니다.

main.py


    from fastapi import FastAPI, Depends, HTTPException
    from sqlalchemy.orm import Session
    from database import SessionLocal, engine
    from models import User, Base
    from schemas import User, UserCreate

    # 데이터베이스 테이블 생성
    Base.metadata.create_all(bind=engine)

    app = FastAPI()

    # 데이터베이스 세션을 가져오는 의존성
    def get_db():
        db = SessionLocal()
        try:
            yield db
        finally:
            db.close()

    @app.post("/users/", response_model=User)
    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

    @app.get("/users/{user_id}", response_model=User)
    def read_user(user_id: int, db: Session = Depends(get_db)):
        user = db.query(User).filter(User.id == user_id).first()
        if user is None:
            raise HTTPException(status_code=404, detail="User not found")
        return user

    @app.get("/users/", response_model=list[User])
    def read_users(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
        users = db.query(User).offset(skip).limit(limit).all()
        return users

    @app.put("/users/{user_id}", response_model=User)
    def update_user(user_id: int, user: UserCreate, db: Session = Depends(get_db)):
        db_user = db.query(User).filter(User.id == user_id).first()
        if db_user is None:
            raise HTTPException(status_code=404, detail="User not found")
        db_user.name = user.name
        db_user.email = user.email
        db.commit()
        db.refresh(db_user)
        return db_user

    @app.delete("/users/{user_id}")
    def delete_user(user_id: int, db: Session = Depends(get_db)):
        db_user = db.query(User).filter(User.id == user_id).first()
        if db_user is None:
            raise HTTPException(status_code=404, detail="User not found")
        db.delete(db_user)
        db.commit()
        return {"message": "User deleted"}
    

5. 애플리케이션 실행하기

이제 모든 설정이 완료되었습니다. 아래 명령어로 FastAPI 애플리케이션을 실행할 수 있습니다.

uvicorn main:app --reload

6. API 테스트하기

API가 성공적으로 실행되면, 브라우저에서 http://127.0.0.1:8000/docs로 이동하여 Swagger UI에서 API를 테스트할 수 있습니다.

예제 요청


    POST /users/
    {
        "name": "Alice",
        "email": "alice@example.com"
    }
    

성공적으로 생성되면 새 사용자 ID가 포함된 응답을 받을 수 있습니다:


    {
        "id": 1,
        "name": "Alice",
        "email": "alice@example.com"
    }
    

결론

이번 글에서는 FastAPI와 SQLAlchemy를 이용하여 간단한 사용자 관리 API를 구축하는 방법을 알아보았습니다.
FastAPI는 직관적인 문법과 비동기 처리 덕분에 신속한 개발이 가능하며, SQLAlchemy와의 통합 덕분에 강력한 데이터베이스 작업을 손쉽게 수행할 수 있습니다.
이를 통해 여러분도 멋진 백엔드 애플리케이션을 개발할 수 있게 되기를 바랍니다.

더 알아보세요

FastAPI와 SQLAlchemy에 대해 더 깊이 있는 정보가 필요하다면 그들의 공식 문서를 참고하시길 권장합니다.

FastAPI 서버개발, REST API와 GraphQL API의 통합 사용법

FastAPI는 현대적인 웹 프레임워크로, Python으로 작성된 비동기 웹 애플리케이션을 구축하는 데 매우 유용합니다. 특히 RESTful API와 GraphQL API를 손쉽게 구현할 수 있습니다. 이 글에서는 FastAPI로 두 가지 API를 통합하여 사용하는 방법에 대해 자세히 설명하겠습니다.

1. FastAPI란?

FastAPI는 Python 3.6 이상에서 사용할 수 있는 비동기 웹 프레임워크입니다. 자동 문서화, 데이터 유효성 검사 등에 강력한 기능을 가지고 있습니다. 또한, Starlette를 기반으로 하여 높은 성능과 비동기 작업을 지원합니다.

2. REST API와 GraphQL API의 차이

REST API는 자원에 대한 CRUD(Create, Read, Update, Delete) 작업을 수행하는데, 각 자원은 고유한 URI를 가지고 있습니다. 반면, GraphQL API는 클라이언트가 필요한 데이터를 명확하게 요청할 수 있는 쿼리 언어를 제공합니다. GraphQL을 사용하면 데이터 전송량을 줄이고, 클라이언트에서 원하는 형식으로 데이터를 요청할 수 있어 효율적입니다.

2.1 REST API의 예

GET /users : 모든 사용자 정보 가져오기
POST /users : 새로운 사용자 추가하기
GET /users/1 : 특정 사용자 정보 가져오기
PUT /users/1 : 특정 사용자 정보 수정하기
DELETE /users/1 : 특정 사용자 삭제하기
    

2.2 GraphQL의 예

query {
  users {
    id
    name
  }
}
mutation {
  createUser(name: "Alice") {
    id
    name
  }
}
    

3. FastAPI 설치

FastAPI를 사용하기 위해 필요한 패키지를 설치합니다. 먼저 Python과 pip가 설치되어 있는지 확인합니다. 다음 명령어를 사용하여 FastAPI와 Uvicorn을 설치할 수 있습니다.

pip install fastapi uvicorn

4. FastAPI 프로젝트 구조

FastAPI 프로젝트 구조는 아래와 같이 설정할 수 있습니다.

my_fastapi_project/
    ├── main.py
    ├── models.py
    ├── schemas.py
    ├── database.py
    └── graphql.py
    

5. FastAPI로 REST API 구현하기

이제 FastAPI를 사용하여 REST API를 구현해보겠습니다. 먼저 models.py 파일에서 데이터 모델을 정의합니다.

from pydantic import BaseModel
from typing import List

class User(BaseModel):
    id: int
    name: str

5.1 데이터베이스 설정

데이터베이스 접속을 위해 아래와 같은 database.py 파일을 만듭니다. SQLAlchemy를 사용하여 데이터베이스와 상호작용합니다.

from sqlalchemy import create_engine, Column, Integer, String
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()

class UserDB(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, index=True)

Base.metadata.create_all(bind=engine)

5.2 REST API 엔드포인트 만들기

이제 main.py 파일에 REST API 엔드포인트를 작성합니다.

from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy.orm import Session
from database import SessionLocal, UserDB, engine
from models import User

app = FastAPI()

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

@app.post("/users/", response_model=User)
def create_user(user: User, db: Session = Depends(get_db)):
    db_user = UserDB(name=user.name)
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

@app.get("/users/", response_model=List[User])
def read_users(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
    users = db.query(UserDB).offset(skip).limit(limit).all()
    return users

6. FastAPI로 GraphQL API 구현하기

이제 GraphQL API를 구현해보겠습니다. graphql.py 파일에서 GraphQL 스키마를 정의합니다.

from fastapi import FastAPI
from fastapi.openapi.docs import get_swagger_ui_html
from graphene import ObjectType, String, Schema, Field, List
from models import User, UserDB
from database import SessionLocal

class UserType(ObjectType):
    id = String()
    name = String()

class Query(ObjectType):
    users = List(UserType)

    def resolve_users(self, info):
        db = SessionLocal()
        return db.query(UserDB).all()

schema = Schema(query=Query)

app = FastAPI()

@app.get("/graphql/")
async def graphql_endpoint():
    return await Query().execute()

7. 두 API 통합하기

이제 두 가지 API를 통합할 시간입니다. 다음과 같이 FastAPI의 라우터와 GraphQL endpoint를 함께 사용할 수 있습니다.

from fastapi import FastAPI
from fastapi_graphql import GraphQLRouter
from database import Base, engine
from graphql import schema

app = FastAPI()

Base.metadata.create_all(bind=engine)

app.include_router(GraphQLRouter(schema=schema), prefix="/graphql")

# 기존 REST API 엔드포인트 코드...

8. 서버 실행하기

마지막으로, Uvicorn을 사용하여 FastAPI 서버를 실행합니다. 아래 명령어로 서버를 실행할 수 있습니다.

uvicorn main:app --reload

9. API 테스트

서버가 실행되면 http://127.0.0.1:8000/docs 주소에서 Swagger UI를 통해 REST API를 테스트할 수 있습니다. GraphQL API는 http://127.0.0.1:8000/graphql/에서 테스트할 수 있습니다.

10. 결론

FastAPI를 사용하면 REST API와 GraphQL API를 손쉽게 구축하고 통합할 수 있습니다. 이번 튜토리얼을 통해 두 가지 API 유형을 함께 사용하는 방법을 배웠습니다. 이를 통해 개발자는 필요에 따라 API를 선택할 수 있으며, 클라이언트의 요구를 충족할 수 있게 됩니다.

추가적인 질문이나 궁금증이 있다면 댓글로 남겨주시면 답변해드리겠습니다!