반응형

파이썬 FastAPI 요청 처리 심화 – 경로와 쿼리 매개변수, 다양한 요청 방식

FastAPI에서의 요청 처리는 단순한 URL 호출을 넘어, 변수, 쿼리, 그리고 다양한 HTTP 메서드로 확장됩니다. 그 핵심을 이번 글에서 파헤쳐볼게요!

 

 

안녕하세요, 개발자 여러분 😊

이번 글에서는 FastAPI의 진짜 매력을 느낄 수 있는 "요청 처리 심화" 파트를 다뤄보려 해요.

단순히 /hello 경로만 호출해서 문자열 반환하는 것에 만족하셨다면, 이제 한 단계 더 나아가 보죠.

경로 변수와 쿼리 파라미터, 그리고 다양한 HTTP 메서드를 활용한 CRUD API 설계까지, 여러분이 실전에서 꼭 만나게 될 상황들을 중심으로 소개합니다.

개발자라면 누구나 REST API를 다루게 되는데, FastAPI만큼 직관적이고 깔끔하게 처리할 수 있는 프레임워크는 드물어요.

이 글을 끝까지 따라오시면, 여러분도 FastAPI로 유연하고 강력한 API를 만드는 데 자신감을 가지게 될 거예요!

 

1. 경로 변수(Path Parameters)의 개념과 활용

FastAPI를 사용하다 보면 경로(URL) 안에 직접 데이터를 넣어서 API 요청을 날리는 경우가 정말 많습니다.

예를 들어

사용자 정보를 조회할 때 /users/10 이런 식으로 요청을 보내곤 하죠.

여기서 10경로 변수입니다.

FastAPI에서는 /users/{user_id}와 같이 중괄호({})를 사용해서 경로 변수를 선언할 수 있고, 해당 값은 함수 인자에서 받아올 수 있어요.

여기에 타입 힌트까지 붙이면 더 강력해지죠.

다음 예제를 함께 살펴볼게요.

📌 실습 예제 – 사용자 ID로 조회하기

@app.get("/users/{user_id}")
def read_user(user_id: int):
    return {"user_id": user_id}

 

👉 예를 들어 http://127.0.0.1:8000/users/7에 요청하면, {"user_id": 7} 이 응답됩니다!

🎯 경로 변수의 특징 정리

  • URL 경로 내에 값을 직접 삽입할 수 있다.
  • user_id: int처럼 타입 지정 가능 → FastAPI가 자동으로 검증
  • 잘못된 타입 요청 시 자동으로 422 오류 반환됨

📎 참고 팁

FastAPI는 Pydantic의 Path() 함수를 활용해 경로 변수에 대해 더 정교한 검증을 할 수 있도록 지원해요.

예를 들어,

최소값, 최대값을 설정하거나 설명을 추가할 수 있답니다.

이건 나중에 심화로 다룰 테니 일단 기본 개념만 확실히 익혀둬요!

✅ 요약 정리

  1. {변수명}으로 경로에 변수 삽입 가능
  2. 타입 힌트 사용 시 자동 변환 및 검증 처리
  3. 잘못된 타입 전달 시 422 Unprocessable Entity 오류

 

 

2. 쿼리 파라미터(Query Parameters)의 처리와 기본값 설정

FastAPI에서는 경로 이외에도 쿼리 파라미터를 아주 쉽게 처리할 수 있어요.

우리가 웹사이트에서 흔히 보는 ?page=1&size=10 같은 주소 기억나시죠?

이런 식의 URL에서 pagesize 같은 값들을 FastAPI는 아주 자연스럽게 함수 인자로 넘겨줍니다.

FastAPI는 함수에 정의된 매개변수가 경로 변수와 일치하지 않으면 자동으로 쿼리 문자열로 간주해서 값을 찾아요.

즉, /items?skip=5&limit=20 요청은 아래 함수로 처리할 수 있습니다.

🔍 실습 예제 – 아이템 페이징 처리

@app.get("/items")
def read_items(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

 

🔗 http://127.0.0.1:8000/items?skip=5&limit=20로 접속해보세요!

결과는 {"skip": 5, "limit": 20}으로 출력될 거예요.

⚙️ 기본값과 선택적 파라미터

매개변수에 = 기본값을 지정하면, 그 값은 선택적 파라미터가 됩니다.

예를 들어

위의 skip: int = 0은 값을 주지 않아도 기본적으로 0으로 설정돼요.

그래서 /items만 호출해도 오류 없이 작동합니다.

🎯 쿼리 파라미터의 활용 예

  • 게시글 목록 조회 시 페이징 처리 (page, size)
  • 상품 검색 시 필터링 옵션 전달 (keyword, category 등)

📎 고급 활용 – Query 함수로 유효성 검증

FastAPI는 Query()라는 유틸리티를 제공해요.

이걸 쓰면 최소값, 최대값, 정규식 검증 등 다양한 제약 조건을 설정할 수 있어요.

예를 들어:

from fastapi import Query

@app.get("/search")
def search_items(q: str = Query(..., min_length=3, max_length=50)):
    return {"query": q}

 

▶️ 이처럼 Query를 활용하면 검색어가 최소 3자 이상, 50자 이하일 때만 유효하게 동작하게 만들 수 있어요!

✅ 요약 정리

  1. 경로에 포함되지 않은 인자는 자동으로 쿼리 파라미터로 처리
  2. 기본값을 지정해 선택적 파라미터 구현 가능
  3. Query()를 통해 유효성 검사와 문서화 가능

 

 

3. 다양한 HTTP 메서드로 API 설계하기

웹 개발을 하다 보면 단순한 데이터 조회(GET) 외에도, 데이터를 생성, 수정, 삭제하는 다양한 작업이 필요하죠.

이럴 때 사용하는 것이 바로 HTTP 메서드입니다.

FastAPI는 @app.post(), @app.put(), @app.delete() 같은 데코레이터로 쉽게 메서드를 구분해 구현할 수 있어요.

 

보통 REST API에서 CRUD 작업은 다음과 같은 매핑으로 이루어져요:

  • POST – 자원 생성(Create)
  • GET – 자원 조회(Read)
  • PUT / PATCH – 자원 수정(Update)
  • DELETE – 자원 삭제(Delete)

🛠 실습 예제 – Todo 리스트 API

이제 간단한 Todo 리스트 API를 만들어볼게요.

아직 데이터베이스는 연결하지 않고, 메모리 안에 리스트로 관리할 거예요.

from typing import List

todos: List[str] = []

@app.post("/todos")
def create_todo(item: str):
    todos.append(item)
    return {"msg": "Todo created", "item": item}

@app.get("/todos")
def read_todos():
    return {"todos": todos}

@app.delete("/todos/{index}")
def delete_todo(index: int):
    if 0 <= index < len(todos):
        removed = todos.pop(index)
        return {"msg": "Todo deleted", "item": removed}
    else:
        return {"msg": "Index out of range", "index": index}

📌 포인트 정리

  • POST 요청으로 할 일(item)을 생성할 수 있어요.
  • GET 요청으로 현재 저장된 모든 할 일들을 조회할 수 있어요.
  • DELETE 요청으로 특정 인덱스의 할 일을 삭제할 수 있어요.

✨ 추후에는 item을 문자열 대신 JSON 구조로 받고, 유효성 검사도 추가할 예정입니다.

      지금은 기본 동작 원리를 익히는 게 목표예요!

 

 

4. 간단한 Todo 리스트 API 실습

이번에는 앞서 배운 내용을 바탕으로 아주 간단한 Todo API를 하나씩 구현해볼 거예요.

복잡한 데이터베이스는 사용하지 않고, 우선 파이썬 리스트에 데이터를 저장하면서 개념과 흐름을 익히는 데 집중해봅시다.

📝 기능 목록

  • POST – 새로운 Todo 항목 추가
  • GET – 전체 Todo 항목 조회
  • DELETE – 특정 항목 삭제

이 Todo API는 FastAPI의 기본 기능만으로도 손쉽게 만들 수 있어요.

아래는 전체 구현 코드입니다.

from typing import List
from fastapi import FastAPI

app = FastAPI()
todos: List[str] = []

@app.post("/todos")
def create_todo(item: str):
    todos.append(item)
    return {"msg": "Todo created", "item": item}

@app.get("/todos")
def read_todos():
    return {"todos": todos}

@app.delete("/todos/{index}")
def delete_todo(index: int):
    if 0 <= index < len(todos):
        removed = todos.pop(index)
        return {"msg": "Todo deleted", "item": removed}
    else:
        return {"msg": "Index out of range", "index": index}

💡 테스트 방법

  1. 터미널에서 uvicorn main:app --reload로 실행
  2. http://127.0.0.1:8000/docs로 접속
  3. Swagger UI에서 API 직접 테스트

📎 실전 팁

현재는 문자열 하나만 다루고 있지만, 보통은 title, description, due_date 같은 구조화된 데이터를 다루게 돼요.

그래서 다음에는 Pydantic 모델을 이용한 JSON 구조 요청 처리도 이어서 다뤄볼 거예요.

 

🛠 지금은 구조보다 흐름과 메서드별 동작 방식을 이해하는 게 포인트입니다!

 

 

5. 응답 코드 설정과 HTTPException 사용법

API를 개발하다 보면 어떤 작업이 성공했는지, 실패했는지 클라이언트에게 명확한 상태 코드로 알려주는 게 매우 중요해요.

FastAPI에서는 status_code 파라미터나 HTTPException 클래스를 이용해서 간단하게 응답 상태를 설정할 수 있습니다.

🔢 status_code 파라미터

기본적으로 FastAPI는 정상 응답 시 200 OK 상태 코드를 반환하지만, POST 요청에서 자원이 성공적으로 생성됐다는 의미로는 201 Created를 사용하는 것이 더 적절해요.

from fastapi import FastAPI

app = FastAPI()

@app.post("/todos", status_code=201)
def create_todo(item: str):
    return {"msg": "Todo created", "item": item}

 

📍 위처럼 status_code=201을 명시하면 Swagger 문서(/docs)에서도 명확히 표현되고, 실제 응답 헤더에도 적용돼요.

🚨 HTTPException으로 에러 처리하기

클라이언트가 잘못된 요청을 보냈을 때, 그냥 텍스트로 알려주는 대신 HTTPException을 활용하면 더 표준적인 방식으로 에러를 응답할 수 있어요.

FastAPI는 이 기능을 아주 깔끔하게 지원합니다.

from fastapi import HTTPException

@app.delete("/todos/{index}")
def delete_todo(index: int):
    if 0 <= index < len(todos):
        removed = todos.pop(index)
        return {"msg": "Todo deleted", "item": removed}
    else:
        raise HTTPException(status_code=404, detail="Todo index out of range")

 

❗ 이렇게 하면 404 Not Found 상태 코드와 함께 에러 메시지가 JSON 형태로 전달됩니다.

🧾 예시 응답 구조

{
  "detail": "Todo index out of range"
}

✅ 요약 정리

  1. status_code 파라미터로 성공 응답 상태 지정 가능 (예: 201)
  2. 에러 상황에는 HTTPException을 활용해 상태 코드 + 상세 메시지 전달
  3. Swagger 문서에 자동으로 반영되어 테스트가 쉬움

🧠 상태 코드와 예외 처리는 API 설계에서 신뢰도를 높이는 핵심 요소예요.

      놓치지 말고 꼭 적용해보세요!

 

 

6. 자동 문서화 /docs로 확인하는 API 인터페이스

FastAPI를 처음 접했을 때 가장 감탄했던 기능 중 하나가 자동 API 문서화였어요.

우리가 별도로 Swagger를 설정하지 않아도, FastAPI는 프로젝트를 실행하면 /docs 경로에 멋진 UI를 제공해줍니다.

이 문서화 기능은 Swagger UI를 기반으로 하고 있으며, OpenAPI 스펙을 따르기 때문에 API를 설계, 테스트, 설명하는 데 매우 유용합니다.

📘 /docs에서 확인할 수 있는 정보들

  • 등록된 모든 API 경로 (GET, POST, DELETE 등)
  • 각 API가 사용하는 요청 파라미터와 타입
  • 응답 형식 및 예시 JSON
  • 상태 코드 정보 및 설명

📌 테스트도 직접 가능!

Swagger UI의 진짜 매력은 단순 문서화가 아니라 인터랙티브한 테스트 기능입니다.

각 API 아래에 있는 "Try it out" 버튼을 누르면, 실제로 파라미터를 입력해보고 바로 응답 결과를 확인할 수 있어요.

 

🧪 서버를 켜둔 상태에서 http://127.0.0.1:8000/docs 로 접속하면 지금까지 만든 Todo API를 바로 테스트할 수 있습니다!

📄 응답과 상태 코드 자동 문서화

우리가 status_codeHTTPException을 지정해 놓으면 그 정보 또한 Swagger UI에 자동으로 반영돼요.

예를 들어

Todo 삭제 API에서 404 에러가 발생할 수 있다고 하면, 이 상황도 문서 상에 함께 노출돼서 클라이언트 개발자도 명확히 이해할 수 있습니다.

✅ 요약 정리

  1. FastAPI는 기본적으로 Swagger UI 기반의 문서 제공
  2. 각 API의 경로, 메서드, 파라미터, 응답을 자동 문서화
  3. /docs 페이지에서 직접 테스트 가능

🚀 자동 문서화 기능은 FastAPI의 가장 큰 장점 중 하나입니다.

      실무에서는 팀원들과 협업하거나 외부 개발자에게 API를 설명할 때 이 기능이 정말 유용하게 쓰이죠.

 

 

마무리

여기까지 따라오셨다면 FastAPI의 요청 처리 방식에 대해 꽤나 깊이 있게 이해하셨을 거예요.

단순한 라우팅을 넘어, 경로 변수와 쿼리 파라미터를 어떻게 활용할 수 있는지, 그리고 다양한 HTTP 메서드와 응답 코드 설정, 예외 처리, 자동 문서화까지…

이 모든 요소들이 잘 어우러져야 실용적이고 유지보수하기 쉬운 API를 만들 수 있습니다.

FastAPI는 배우기도 쉽고, 작성한 코드가 곧 문서가 되어주기 때문에 백엔드 API를 처음 만드는 분들에게도 정말 좋은 선택이에요.

 

다음 단계에서는 Pydantic 모델을 활용한 본문(JSON) 처리와 입력 검증에 대해 다룰 예정입니다.

점점 더 실무에 가까운 내용으로 나아가니, 기대해 주세요!

 

📌 오늘 배운 내용은 실제 웹 서비스,

      예를 들어 블로그 API나 게시판 API처럼 사용자와 데이터를 주고받는 시스템의 기본이 되는 부분입니다.

      꼭 복습하시고, 실습도 꼭 해보세요!

반응형
반응형

FastAPI로 배우는 REST API 개발 입문

REST API, 아직도 어렵게 느껴지시나요?
FastAPI를 이용하면 믿을 수 없을 만큼 쉽게 웹 API를 만들 수 있어요!

 

 

안녕하세요!

오늘부터 여러분과 함께 Python의 강력한 웹 프레임워크 FastAPI를 활용한 REST API 개발을 단계별로 배워보려고 합니다.

요즘 웹 개발에 있어서 REST API는 기본 중의 기본이죠.

다양한 시스템이 서로 데이터를 주고받기 위해 가장 많이 사용되는 방식입니다.

특히 FastAPI는 빠르고 간편하며, 자동 문서화 기능까지 갖춰져 있어 초보자도 쉽게 API를 개발할 수 있는 환상적인 도구예요.

이 블로그 시리즈에서는 REST API의 개념부터 시작해서, FastAPI 설치, Hello World 예제, 엔드포인트 추가 실습까지 하나하나 직접 구현해보며 개념과 실습을 모두 챙길 거예요.

준비되셨나요?

그럼 첫 번째 이야기, REST API와 FastAPI의 만남을 시작해볼게요! 🚀

 

1. REST API란 무엇인가요? 🌐

REST API는 웹에서 데이터를 주고받는 가장 표준적인 방법 중 하나입니다.

먼저 이름부터 풀어볼까요?

REST는 Representational State Transfer의 약자인데요, 말이 좀 어렵게 느껴질 수 있지만 핵심은 간단합니다.

"웹 자원을 고유한 주소(URI)로 표현하고, 그 자원에 대해 HTTP 메서드를 통해 동작을 지정한다"는 게 핵심이에요.

우리가 평소에 웹 브라우저에서 주소창에 https://example.com/users를 입력하면 "users"라는 자원(데이터 목록)에 접근하는 거잖아요?

이처럼 REST에서는 각각의 자원을 URL을 통해 표현합니다.

그리고 어떤 동작을 하고 싶은지에 따라 GET, POST, PUT, DELETE 같은 HTTP 메서드를 사용해 요청을 보냅니다.

📌 REST 아키텍처의 6가지 원칙

  • 클라이언트-서버 구조 : UI와 데이터 처리를 분리해 독립적으로 발전 가능
  • 무상태성 (Stateless) : 서버는 요청을 받을 때 클라이언트의 상태를 기억하지 않음
  • 캐시 처리 가능 : 클라이언트는 서버 응답을 캐싱해 효율성 향상 가능
  • 계층화된 시스템 : 중간 서버를 통해 보안, 로드 밸런싱 등 기능 분리
  • 인터페이스 일관성 : URI 설계와 메서드 사용이 일관되게 유지되어야 함
  • 코드 온 디맨드(Optional) : 서버에서 클라이언트로 스크립트 등을 전달 가능

🧩 RESTful API 설계의 예시

HTTP 메서드 URI 설명
GET /users 모든 사용자 조회
GET /users/123 ID가 123인 사용자 조회
POST /users 새 사용자 등록
PUT /users/123 ID가 123인 사용자 정보 수정
DELETE /users/123 ID가 123인 사용자 삭제

이러한 설계 방식 덕분에 RESTful API는 명확하고 예측 가능하며 유지보수가 쉬운 구조를 가질 수 있어요.

그래서 요즘 거의 모든 서비스가 REST API 기반으로 구성되고 있죠.

그리고 이걸 Python으로 정말 쉽게 만들 수 있도록 도와주는 도구가 바로 FastAPI입니다.

 

 

2. RESTful API의 구조와 특징 🔍

RESTful API는 단순히 REST 원칙을 따르는 API 이상을 의미해요.

클라이언트와 서버 간의 소통을 효율적이고 일관되게 만들어주는 아키텍처 스타일이자 규칙의 집합이죠.

흔히들 “REST스럽다”는 표현을 쓰는데, 이는 API가 REST의 원칙을 잘 따르고 있다는 의미예요.

✅ RESTful API의 구조적 특징

  1. URI를 통한 자원 표현 – 모든 자원은 고유한 URI로 식별됩니다. 예: /users, /posts/1
  2. HTTP 메서드의 의미 명확화 – CRUD 작업을 각각 GET, POST, PUT, DELETE로 매핑합니다.
  3. 무상태성(Stateless) – 요청은 독립적으로 처리되며, 서버는 이전 요청 상태를 저장하지 않습니다.
  4. 표현(Representation)의 활용 – 클라이언트는 자원의 ‘표현’을 받으며, 보통은 JSON이나 XML 형식을 사용합니다.
  5. 표준 HTTP 상태 코드 사용 – 예: 200(성공), 201(생성됨), 404(없음), 500(서버 오류)

💡 RESTful API가 주는 이점

RESTful API를 설계하면 얻게 되는 이점도 많아요.

가장 큰 장점은 바로 일관성과 가독성입니다.

 

예를 들어,

다음처럼 URI를 설계한다면 처음 보는 사람도 어떤 기능인지 대충 감이 올 거예요.

  • GET /articles – 전체 글 목록 불러오기
  • POST /articles – 새 글 작성
  • GET /articles/3 – ID가 3인 글 조회

 

이처럼 RESTful한 API는 예측 가능하고 규칙 기반이기 때문에 협업 시에도 소통이 쉬워지고, 문서화를 따로 하지 않아도 사용할 수 있을 만큼 직관적인 경우도 많습니다.

 

❗REST API vs RESTful API – 혼동하지 마세요

간혹 REST API와 RESTful API를 같은 개념으로 쓰기도 하지만, 기술적으로는 살짝 차이가 있어요.

REST API는 단지 REST 기반 구조를 사용하는 API를 의미하고, RESTful API는 REST의 원칙을 충실히 따르는 ‘REST다운’ API를 말합니다.

즉, RESTful API는 REST API보다 좀 더 엄격한 규칙을 따른다는 뜻이에요.

 

RESTful한 구조를 유지하기 위해서는 불필요한 동사 사용을 피하고, 자원 중심으로 URI를 설계하며, HTTP 상태 코드도 적절히 활용해야 해요.

이런 기준을 지켜야만 “RESTful하다”고 말할 수 있답니다!

이제 RESTful API의 기본 철학과 구조에 대해 어느 정도 감이 오셨죠? 😉

 

다음 섹션에서는 FastAPI라는 도구를 통해 이런 RESTful API를 실제로 구현하는 방법을 배워볼 거예요.

기대되시죠?

 

 

3. FastAPI 프레임워크 소개 🚀

FastAPI는 최근 Python 웹 개발자들 사이에서 가장 주목받고 있는 비동기 기반 웹 프레임워크입니다.

Flask나 Django처럼 웹 애플리케이션을 만들 수 있으면서도,

비동기 처리, 자동 문서화, 타입 기반 유효성 검사 같은 최신 기능들을 기본으로 제공합니다.

📌 FastAPI의 핵심 특징

  • 빠른 성능 – Starlette(ASGI 서버) 기반으로 구성되어 Node.js나 Go와 맞먹는 수준의 퍼포먼스를 자랑합니다.
  • 타입 기반 유효성 검사 – Python의 타입 힌트를 활용해 Pydantic이 자동으로 데이터 검증 및 스키마 생성을 해줍니다.
  • 자동 문서화 – OpenAPI(Swagger)와 ReDoc 기반 문서가 자동 생성되어 /docs/redoc 경로에서 API 테스트도 가능합니다.
  • 비동기 처리 지원async/await 문법으로 고성능 API 서버 구현도 손쉽게 가능합니다.

⚙️ 왜 FastAPI인가요?

처음에는 Flask로도 충분하지 않나? 하는 생각이 들 수도 있어요. 저도 그랬거든요.

하지만 FastAPI를 사용해보면 정말 많은 차이를 느낄 수 있습니다.

특히 Swagger 문서 자동 생성비동기 처리 성능은 다른 프레임워크들이 따라오기 어려울 정도예요.

여기에 Python의 타입 힌트를 적극적으로 활용해, 코드 작성과 동시에 문서화와 유효성 검사를 자동으로 처리해주는 점이 초보자들에게도 큰 장점으로 작용합니다.

비교 항목 Flask FastAPI
성능 중간 매우 빠름
문서화 수동 또는 확장 자동 제공 (Swagger / ReDoc)
타입 힌트 지원 선택적 강력히 활용
비동기 지원 간접적 지원 기본 제공

결론적으로 FastAPI는 빠르게 프로토타입을 만들고, 동시에 안정성과 문서화까지 챙기고 싶은 개발자에게 최적의 선택이에요.

Python을 이미 알고 있다면, FastAPI는 자연스럽고 직관적으로 배울 수 있습니다.

 

다음 글에서는 실제로 FastAPI를 설치하고 기본 개발 환경을 세팅하는 과정을 차근차근 안내해드릴게요.

이제 실습을 통해 본격적으로 시작해볼까요? 🔧

 

 

4. 개발 환경 설정과 FastAPI 설치 ⚙️

지금부터는 본격적으로 FastAPI를 개발 환경에 설치해보는 시간입니다.

FastAPI는 Python 3.7 이상에서 사용할 수 있기 때문에, 우선 Python 버전 확인부터 해볼게요.

그리고 가상환경을 만들어서 프로젝트별 의존성을 관리하는 것이 좋습니다.

🔍 Python 및 가상환경 설정

  1. Python 버전 확인: python --version
  2. 가상환경 생성: python -m venv venv
  3. 가상환경 활성화
    • Windows: venv\Scripts\activate
    • Mac/Linux: source venv/bin/activate

가상환경이 활성화되면 프롬프트 앞에 (venv)가 붙어요.

이제 여기서 필요한 라이브러리를 설치하면 됩니다.

📦 FastAPI와 Uvicorn 설치

FastAPI는 자체적으로 웹 서버를 포함하고 있지 않기 때문에 ASGI 서버가 필요해요.

대부분의 개발자들은 Uvicorn을 사용합니다.

 

pip install fastapi
pip install "uvicorn[standard]"

 

[standard] 옵션을 포함하면 HTTP/2, WebSocket 등 다양한 기능도 함께 설치돼요.

설치가 끝나면 FastAPI 애플리케이션을 실행할 준비가 완료된 셈입니다.

📝 프로젝트 구조와 첫 파일 만들기

간단한 FastAPI 프로젝트 구조는 다음과 같아요:

  • main.py – 앱 실행 파일
  • venv/ – 가상환경 폴더

main.py 파일을 열고 FastAPI 기본 코드를 작성할 준비를 합니다.

다음 단계에서는 “Hello, FastAPI”라는 응답을 반환하는 아주 간단한 예제를 통해 첫 API를 직접 만들어볼 거예요.

지금까지 잘 따라오셨나요? 🧑‍💻

환경 설정만 마쳐도 절반은 완성된 셈입니다!

 

이제 직접 서버를 띄워보며 FastAPI가 어떻게 동작하는지 살펴보겠습니다.

 

 

5. Hello FastAPI - 첫 API 만들기 👋

드디어 우리가 기다리던 순간!

이제 FastAPI를 직접 실행해 보며 첫 번째 API를 만들어볼 거예요.

처음 만드는 만큼 아주 단순한 "Hello, FastAPI" 메시지를 반환하는 예제부터 시작해 보겠습니다.

📄 main.py 코드 작성

이제 main.py 파일을 열고

아래와 같이 코드를 작성해 주세요:

 

from fastapi import FastAPI

app = FastAPI()

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

 

이 코드에서 @app.get("/")는 루트 경로(/)에 GET 요청이 들어왔을 때 실행되는 함수입니다.

return 부분에서 반환하는 딕셔너리는 자동으로 JSON으로 변환돼서 응답으로 전송돼요.

🚀 서버 실행

이제 작성한 FastAPI 앱을 실행해볼게요.

터미널에 다음 명령어를 입력하세요:

 

uvicorn main:app --reload

 

main은 파일 이름, app은 FastAPI 객체입니다.

--reload 옵션을 붙이면 코드 변경 시 서버가 자동으로 재시작돼서 개발할 때 아주 편리하죠!

🔎 실행 결과 확인하기

정말 신기하지 않나요?

별도의 설정 없이도 이렇게 깔끔한 API 문서가 자동 생성됩니다. 🧙‍♂️

그리고 이게 FastAPI의 가장 큰 매력 중 하나예요. 작성한 API들을 테스트도 가능하니, 개발과 동시에 검증까지 가능하죠.

이제 FastAPI의 기본 구조와 실행 흐름을 이해하셨을 거예요.

다음 단계에서는 실제로 또 하나의 엔드포인트를 추가하면서 다양한 HTTP 메서드와 라우팅 개념도 함께 살펴보겠습니다.

 

 

6. 엔드포인트 추가 실습: 버전 정보 API 구현 🛠️

이전 단계에서 GET /으로 기본 응답을 반환하는 간단한 API를 만들어봤죠.

이번에는 FastAPI 앱에 새로운 엔드포인트를 하나 더 추가해보겠습니다.

예를 들어,

프로젝트의 버전 정보를 클라이언트에게 알려주는 API가 있다고 가정해볼게요.

📄 main.py에 엔드포인트 추가

@app.get("/version")
def get_version():
  return {"version": "0.1.0"}

 

이 함수는 /version 경로에 GET 요청이 들어왔을 때 버전 정보를 JSON 형식으로 반환합니다.

예를 들어,

클라이언트가 API의 버전 관리를 하고자 할 때 유용하게 사용할 수 있어요.

🔎 실행 후 테스트하기

📌 엔드포인트를 추가하면서 익히는 FastAPI의 핵심

  • 라우팅 – 경로(URL)마다 함수 하나씩 대응시켜 구조적으로 관리
  • 함수 기반 뷰(View) – 각각의 엔드포인트는 Python 함수로 표현
  • 자동 문서화 – 개발자가 문서를 별도로 작성하지 않아도 FastAPI가 Swagger 문서를 자동 생성

 

이번 실습을 통해 RESTful API의 핵심인 라우팅 설계를 직접 해보셨고, FastAPI가 얼마나 직관적이고 강력한지 직접 체험하셨을 거예요. 엔드포인트 추가는 이제 식은 죽 먹기죠?

점점 실전 API에 가까워지고 있죠? 😊

지금까지 우리는 REST API의 개념부터 FastAPI 설치, 기본 예제 구현까지 한 걸음씩 따라와 봤습니다.

처음에는 다소 낯설 수 있었던 REST 구조도, FastAPI의 직관적인 문법과 자동 문서화 덕분에 훨씬 더 쉽게 접근할 수 있었죠.

 

RESTful한 방식으로 API를 설계하면,

확장성과 유지보수성을 동시에 확보할 수 있다는 점에서 그 가치가 분명합니다.

FastAPI는 여기에 더해 빠른 속도, 간결한 코드, 뛰어난 생산성까지 갖추고 있어 Python 개발자라면 반드시 익혀야 할 도구예요.

 

다음 글에서는 POST 요청 처리입력 데이터 검증을 다룰 예정입니다.

본격적으로 사용자의 입력을 받아 처리하고, Pydantic을 활용한 스키마 기반 검증도 함께 배워볼 거예요.

기대되시죠? 😊

 

이 글이 도움이 되셨다면 댓글이나 공유도 환영합니다.

앞으로도 쉽고 실용적인 Python 백엔드 개발 이야기, 계속 함께해 주세요!

반응형
반응형

Flask 웹 애플리케이션 배포 및 전체 개발 여정 마무리

이제 Flask로 만든 내 앱을 세상 밖으로 꺼내놓을 시간입니다.
코딩만으로는 끝나지 않는 웹 개발의 진짜 마무리,
배포의 세계로 함께 떠나볼까요?

 

 

안녕하세요! 어느덧 8일 간의 Flask 웹 개발 여정이 끝을 향해 가고 있습니다.

오늘은 정말 중요한 시간이자, 실제 서비스를 꿈꾸는 개발자라면 반드시 짚고 넘어가야 할 Flask 애플리케이션의 배포 과정을 다룹니다.

개발 환경에서만 돌아가던 코드가 운영 환경에서,

즉 ‘실제 인터넷 사용자’에게 서비스되기 위해 어떤 과정이 필요한지, 어떤 요소들을 점검해야 하는지 차근차근 살펴볼 거예요.

그리고 지난 8일 동안 우리가 배운 기술들을 돌아보며, 앞으로 어떤 방향으로 더 성장할 수 있을지도 함께 이야기해 보겠습니다.

실전 배포의 긴장감 속에서도, 마무리의 뿌듯함과 성취감을 느끼실 수 있을 거예요 😊

 

1. 개발 환경 vs 운영 환경 설정 차이 이해하기 ⚙️

웹 애플리케이션을 개발하면서 가장 흔하게 저지르는 실수 중 하나는 개발 환경운영 환경을 동일하게 다룬다는 점입니다.

개발은 말 그대로 테스트와 디버깅이 용이하게 구성되어 있지만, 운영 환경은 실제 사용자와의 만남이기 때문에 보안, 성능, 안정성 등 모든 면에서 더욱 철저하게 대비해야 합니다.

🔐 DEBUG 모드 해제와 그 중요성

개발할 때는 DEBUG=True로 설정해서 코드 수정 후 바로 반영되도록 하고, 에러가 발생하면 상세한 디버거 화면을 확인할 수 있어서 편하죠.

하지만 운영에서는 반드시 DEBUG=False로 변경해야 합니다.

이유는 간단해요.

에러 메시지를 통해 시스템 내부 구조나 경로, 변수명이 노출될 수 있기 때문이에요.

이것만으로도 보안에 심각한 구멍이 생길 수 있죠.

  • DEBUG=False 설정은 사용자에게 민감한 에러 정보를 숨겨주는 역할
  • 에러 추적은 logging 모듈을 통해 따로 처리

📦 환경 변수로 민감 정보 분리하기

운영 환경에서는 SECRET_KEYDB 비밀번호 같은 민감한 정보가 절대 코드에 직접 노출되어선 안 됩니다.

이를 위해 .env 파일을 사용하거나, 운영체제의 환경 변수에 등록해 관리하는 것이 일반적이에요.

Flask에서는 python-dotenv 같은 라이브러리를 사용하면 .env 파일을 쉽게 로드할 수 있죠.

예시 - .env 파일

SECRET_KEY=mysecretkey123
DATABASE_URL=mysql://user:password@localhost/db
FLASK_ENV=production

🛠️ 개발 DB vs 운영 DB

개발 환경에서는 SQLite 같은 간단한 파일 기반 데이터베이스를 사용하는 경우가 많지만,

운영 환경에서는 MySQL, PostgreSQL 같은 상용 또는 오픈소스 DB를 사용해야 합니다.

특히 트래픽이 많아질 경우 DB 성능이 앱의 전체 성능에 큰 영향을 끼치기 때문에,

개발 단계부터 운영 DB로의 전환을 염두에 두고 설계하는 습관이 중요해요.

📈 로그 기록과 모니터링 준비

운영 환경에서는 예기치 않은 문제를 발견하기 위해 로그 설정이 중요합니다.

Python의 logging 모듈을 활용해서 파일로 저장하거나, 콘솔/서버 스트림으로 출력하게 설정할 수 있죠.

Sentry, Datadog 같은 SaaS 기반 모니터링 도구도 함께 사용하면 더 좋습니다.

추후 확장 가능성까지 고려한다면 꼭 챙겨야 할 요소입니다.

간단한 logging 설정 예시

import logging

logging.basicConfig(
    filename='app.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'
)

 

이처럼 운영 환경은 단순히 서버에 올리는 것 이상입니다.

전반적인 시스템의 신뢰성과 보안을 고려한 전략이 필요하죠.

다음 섹션에서는 본격적으로 배포를 위해 어떤 준비가 필요한지 살펴보겠습니다.

 

 

2. 배포를 위한 필수 설정 및 준비물 🔧

이제 운영 환경으로 옮길 준비를 본격적으로 해야겠죠.

Flask 애플리케이션을 배포하려면 몇 가지 반드시 준비해야 할 요소들이 있어요.

이 항목들은 단순히 앱을 ‘올린다’는 행위를 넘어, 안정적이고 유지보수가 가능한 형태로 운영하는 데 핵심이 됩니다.

🗂 필수 파일 구성

운영 배포를 위해 다음과 같은 파일들을 준비해두면 좋습니다.

특히 Heroku나 Railway 같은 플랫폼에서는 Procfilerequirements.txt가 필수입니다.

  • requirements.txt: 필요한 패키지 목록을 나열한 파일 (예: Flask, gunicorn 등)
  • Procfile: 실행 명령어를 담은 파일 (예: web: gunicorn app:app)
  • .env: 환경 변수 파일 (운영 시 실제 민감 정보 포함)
  • runtime.txt: 사용하는 파이썬 버전 지정 (Heroku에서 권장됨)

🌐 WSGI 서버 준비 - Gunicorn

Flask는 기본적으로 내장 개발용 서버(flask run)를 사용하지만, 운영용 서버로는 성능과 안정성이 부족해요.

그래서 WSGI(Web Server Gateway Interface)를 사용하는 서버로 전환해야 하죠.

대표적인 선택이 Gunicorn입니다.

pip install gunicorn
gunicorn app:app

 

이 명령은 현재 디렉토리에 있는 app.py 파일 안의 app 객체를 실행합니다.

Gunicorn은 멀티 스레드와 멀티 프로세스를 지원해서, 더 많은 요청을 처리할 수 있도록 해줍니다.

Windows 사용자를 위한 대안

Gunicorn은 Windows에서는 제대로 작동하지 않기 때문에 Waitress 서버를 대안으로 사용할 수 있어요.

pip install waitress
waitress-serve --port=8080 app:app

📁 정적 파일 서빙 준비

Flask도 정적 파일 서빙이 가능하지만,

실제 서비스에서는 Nginx 같은 웹 서버를 활용하는 것이 효율적이에요.

CSS, JS, 이미지 파일은 모두 Nginx가 처리하고, 동적인 라우팅 요청만 Flask로 전달되게 설정하는 게 일반적인 방식입니다.

이렇게 하면 정적 리소스의 로딩 속도도 빨라지고, Flask의 부하도 줄일 수 있어서 훨씬 쾌적한 서비스가 가능해집니다.

 

이제 기본적인 배포 준비물들을 정리했으니,

다음 단계에서는 실제로 Gunicorn과 Nginx를 활용해 애플리케이션을 배포하는 과정을 실습해볼게요!

 

 

3. Gunicorn과 Nginx를 이용한 배포 실습 🚀

이제 본격적으로 Flask 애플리케이션을 운영 환경에 배포하는 실습을 진행해보겠습니다.

이번에는 가장 널리 쓰이는 조합인 Gunicorn + Nginx 환경을 기반으로 설명할게요.

이 조합은 성능과 확장성, 안정성 측면에서 많은 Flask 프로젝트에서 사용됩니다.

🧱 Gunicorn으로 Flask 실행하기

Gunicorn은 Python WSGI 애플리케이션을 실행할 수 있는 고성능 WSGI 서버입니다.

먼저 아래와 같이 애플리케이션을 실행해보세요:

gunicorn -w 4 -b 127.0.0.1:8000 app:app

 

이 명령은 4개의 워커(worker)를 생성하여 127.0.0.1:8000 포트에서 애플리케이션을 실행합니다.

로컬에서 테스트할 경우 웹 브라우저에서 http://127.0.0.1:8000으로 접속하면 됩니다.

🌐 Nginx 설치 및 설정

이제 웹 서버인 Nginx를 설치하고 Gunicorn과 연동해봅니다.

Nginx는 클라이언트 요청을 받아 Gunicorn으로 전달해주는 프록시 역할을 수행하며, 정적 파일 서빙까지 맡을 수 있죠.

sudo apt update
sudo apt install nginx

기본 설정 예시

server {
    listen 80;
    server_name yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /static/ {
        alias /home/ubuntu/yourproject/static/;
    }
}

 

위 설정은 yourdomain.com으로 들어온 요청을 127.0.0.1:8000으로 프록시 전달하고,

/static/ 경로의 파일은 Nginx가 직접 서빙합니다.

설정 후에는 다음 명령어로 Nginx를 재시작합니다:

sudo systemctl restart nginx

🔒 HTTPS 적용 개요

서비스를 인터넷에 공개한다면 HTTPS는 선택이 아닌 필수입니다.

무료 SSL 인증서인 Let’s Encrypt를 사용하면 쉽게 HTTPS를 적용할 수 있어요.

certbot을 사용하여 도메인을 인증하고 Nginx 설정을 자동으로 갱신할 수 있습니다.

다음과 같이 실행해보세요:

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx

 

이 과정을 통해 인증서가 자동 설치되며, Nginx 설정도 자동으로 변경됩니다.

이제 HTTPS 기반으로 보안된 연결을 제공할 수 있습니다.

이제 로컬 개발용 서버에서 벗어나, 실제 운영 환경에서 Flask 앱을 동작시킬 준비가 끝났습니다.

다음 섹션에서는 Heroku와 같은 클라우드 플랫폼을 이용한 배포 방법을 알아볼게요!

 

 

4. 클라우드 서비스에 앱 배포하기 (Heroku 예시) ☁️

운영 환경에 배포하는 가장 쉬운 방법 중 하나는 클라우드 PaaS(Platform as a Service)를 이용하는 거예요.

오늘은 대표적인 서비스인 Heroku를 예로 들어, Flask 앱을 단계별로 배포하는 과정을 소개할게요.

Heroku 외에도 Render, Railway, PythonAnywhere, AWS EC2 등이 있지만, 초심자 입문용으로는 Heroku가 최고죠!

🧰 Heroku 배포 준비물

  • requirements.txt – 설치할 패키지 목록
  • Procfile – 실행 명령어 (예: web: gunicorn app:app)
  • runtime.txt – Python 버전 명시 (예: python-3.10.5)

🧑‍💻 Heroku CLI 설치 및 로그인

# CLI 설치 (공식 사이트 참고)
https://devcenter.heroku.com/articles/heroku-cli

# 로그인
heroku login

 

로그인을 하면 브라우저가 열리면서 인증이 완료되고, CLI에서 Heroku를 조작할 수 있게 됩니다.

📦 Flask 앱 배포하기

  1. Git 저장소 초기화
git init
git add .
git commit -m "Initial commit"
  1. Heroku 앱 생성
heroku create your-app-name
  1. Git으로 배포
git push heroku master
  1. 웹 브라우저로 접속 확인
heroku open

🔐 환경 변수 설정

SECRET_KEYDATABASE_URL 등 민감한 정보는 Heroku Dashboard나 CLI를 통해 설정할 수 있어요.

heroku config:set SECRET_KEY=mysecretvalue

 

여기까지 설정을 완료하면, Flask 앱이 Heroku를 통해 전 세계 어디서나 접근 가능한 서비스로 탈바꿈하게 됩니다!

다음 섹션에서는 운영 시 고려해야 할 보안과 성능 팁들을 소개할게요.

 

 

5. 실서비스를 위한 운영 환경 고려사항 🛡️

이제 애플리케이션이 세상에 나왔습니다. 하지만 진짜 중요한 건 지금부터예요.

서비스 운영은 단순히 앱을 “돌리는 것” 그 이상이에요.

사용자의 신뢰를 얻기 위한 보안, 성능, 확장성까지 두루 고려해야 하죠.

🔒 필수 보안 수칙

  • DEBUG=False 설정 유지 – 민감한 에러 정보 노출 방지
  • SECRET_KEY와 DB 암호는 코드에 절대 직접 작성하지 않기 – 환경 변수로 분리
  • API 요청에 JWT, OAuth, Token 기반 인증 적용하기 – 공개 API 방지

⚙️ 성능과 확장성 확보

처음에는 사용자가 적을 수 있지만, 언젠가 수천 명이 동시 접속하는 날이 올 수도 있죠.

그때를 대비해 확장성과 성능 튜닝 전략을 알아둬야 해요.

  • Gunicorn 워커 수 조절 – 서버 CPU 수와 트래픽에 따라 조정
  • DB 튜닝 및 연결 수 제한 – SQLAlchemy에서 pool_size 설정
  • Redis 캐시 도입 – 반복 쿼리 응답 속도 개선
  • CDN 적용 – 정적 파일 전송 속도 개선

🔍 다른 프레임워크와의 비교

Flask를 통해 웹 개발의 흐름을 이해했지만, 세상에는 다른 선택지도 많아요.

아래는 Flask와 자주 비교되는 프레임워크입니다:

프레임워크 특징 추천 용도
Flask 마이크로, 자유로운 구조 작은 서비스, 빠른 프로토타입
Django 풀스택, Admin 포함 중대형 프로젝트, 팀 협업
FastAPI 비동기 지원, 자동 문서화 고성능 API 서버

중요한 건, 어떤 프레임워크든 웹 서비스의 기본 개념은 비슷하다는 점이에요.

이번 과정을 통해 익힌 개념들은 다른 도구에서도 그대로 활용 가능하다는 점, 꼭 기억해주세요!

 

 

6. 전체 과정 정리 및 Q&A 🧭

어느덧 여덟 번째 날, 이번 Flask 웹 개발 여정의 마지막 단계에 도달했습니다.

그동안 배우고 실습했던 모든 내용을 정리하며, 마무리의 의미를 되새겨볼 시간이에요.

그리고 이제는 여러분이 직접 웹 개발자로서 첫 발을 내디딜 차례입니다 😊

🧩 8일간의 핵심 기술 요약

  • Flask 라우팅, 요청/응답 처리 및 템플릿 렌더링
  • Blueprint로 구조화된 웹 애플리케이션 설계
  • SQLAlchemy ORM을 활용한 데이터베이스 연동 및 CRUD
  • REST API 설계 및 JSON 형태의 응답 처리
  • Flask-WTF, Flask-Login 등 확장을 통한 기능 고도화
  • Gunicorn, Nginx, Heroku 등을 통한 배포 실습과 운영 고려사항

🙋 질의응답 & 개별 피드백

질문 있으신가요? 오늘은 자유롭게 질의응답을 진행합니다.

아직도 헷갈리는 부분이나 추가 설명이 필요한 개념이 있다면 지금 질문해 주세요.

시간이 허락된다면 간단한 데모나 그림으로도 다시 설명해드릴 수 있어요.

또한 각자 만든 프로젝트나 진행 중인 개인 작업에 대해 피드백을 받고 싶다면 언제든 공유해 주세요.

Flask를 사용한 실무적인 팁이나 코드 리뷰도 가능합니다 💬

🔮 차후 학습 방향 제안

Flask를 마스터했다고 해서 끝은 아니에요. 오히려 시작점일 수도 있어요.

아래는 다음 단계로 나아가기 위한 추천 학습 주제입니다:

  • Flask-RESTX를 활용한 API 문서 자동화 및 Swagger UI
  • JavaScript 프론트엔드 프레임워크(React, Vue 등)와의 연동 프로젝트
  • Django를 통한 풀스택 웹 앱 구축 실습

무엇보다 중요한 건, 작은 프로젝트라도 직접 만들어보는 것이에요.

CRUD 게시판, 블로그 API, 포트폴리오 웹사이트 등 본인만의 결과물을 만드는 과정이 진짜 실력이 되는 길입니다.

 

 

📝  Flask 개발 여정의 끝, 그리고 새로운 시작

여기까지 따라오신 여러분, 진심으로 고생 많으셨습니다 🙌

처음 Flask의 간단한 라우팅부터 시작해서 ORM, REST API, 배포까지, 쉽지 않은 여정을 함께 해냈다는 건 정말 대단한 일이에요.

이번 8일 과정은 단순한 코드 학습이 아닌, 웹 서비스라는 전체 흐름을 한 번 체험해보는 기회였습니다.

 

앞으로 여러분은 더 복잡한 웹 서비스도 구현할 수 있을 거예요.

그리고 이 경험은 분명히 현업 개발자나 사이드 프로젝트를 꿈꾸는 여러분에게 튼튼한 기반이 될 겁니다.

이제는 혼자서도 서버를 만들고, 클라이언트와 소통하고, 진짜로 세상에 서비스 하나를 내놓을 수 있으니까요.

그리고... 끝은 곧 시작입니다. 여기서 멈추지 말고 계속해서 나아가세요.

더 깊이 있는 백엔드 기술, 더 나은 UX를 위한 프론트엔드 기술, 클라우드 인프라까지 여러분의 세계는 점점 넓어질 거예요. 감사합니다! 💙

반응형

+ Recent posts