[FastAPI] FastAPI이용한 백엔드 구축 가이드라인 (1) 설치 및 Uvicorn을 통한 테스트

*위 글은 Perplexcity를 기반으로 작성된 글입니다.

FastAPI를 이용한 백엔드 구축 가이드라인

FastAPI는 Python기반의 백엔드 프레임워크입니다.

높은 성능과 개발자 친화적인 특징을 지어, 웹 애플리케이션 개발에 인기를 얻고 있는데요,

FastAPI를 사용해서 견고한 백엔드 시스템 구축하는 과정을 초기설정,배포,모범 사례를 통해 살펴보도록하겠습니다.

1. FastAPI 소개

FastAPI는 REST API 원칙을 중심으로 설계된 Python기반 백엔드 프레임워크임.

주요 특징은 다음과 같습니다.

1) 비동기 프로그래밍 지원

async 및 await 키워드를 사용하여 비동기 I/O 작업을 손쉽게 처리 가능
I/O 바운드 작업(데이터베이스 요청, API 호출 등)에서 성능 향상

2) 자동 API문서 생성( OpenAPI표준)

OpenAPI 표준을 지원하여 /docs 경로에서 자동으로 Swagger UI 문서 제공
API 변경 시 문서를 수동으로 관리할 필요 없음

3) Pydantic을 이용한 데이터 검증

Python의 타입 힌트(Type Hint)와 Pydantic을 활용하여 데이터 유효성 검사 수행
데이터 스키마를 자동으로 생성하고, 잘못된 요청 데이터를 사전에 차단

4) 높은 성능

Starlette과 Uvicorn을 기반으로 설계되어 비동기 처리에 최적화됨
FastAPI는 일반적인 Python 웹 프레임워크보다 빠른 응답 속도를 제공

FastAPI 구성요소

- Pydantic (Python Data Validation Library)

- FastAPI

- Starlette (ASGI Framework / Toolkit)

2. 개발 환경 설정

먼저, pip install을 사용하여 2개의 라이브러리를 설치합니다.(Python 3.6이상 환경 필요)

- FastAPI : 백엔드 구축 라이브러리, 핵심 웹 프레임워크

- Uvicorn : 경량 서버를 가동시키는 라이브러리, ASGI(Asynchronous Server Gateway Interface) 서버

| 추가 추천 패키지: python-multipart (폼 데이터 처리), requests (HTTP 요청), SQLAlchemy (데이터베이스 연동)

pip install fastapi uvicorn

우리가 학습해볼 기본적인 FastAPI 프로젝트 구조는 다음과 같습니다.

my_fastapi_project/
│
├── app/
│ ├── __init__.py
│ ├── main.py         # FastAPI 애플리케이션 진입점
│ ├── models.py       # 데이터베이스 모델
│ ├── schemas.py      # Pydantic 스키마
│ └── routes.py       # API 엔드포인트
│
└── requirements.txt  # 패키지 의존성

3. FastAPI 애플리케이션 구축

위에서 작성한 프로젝트 구조에 따라서 기본적인 애플리케이션을 설정해보도록하겠습니다.

먼저, main.py 파일에 다음과 같이 작성한 후, terminal 명령어로 해당 애플리케이션을 실행합니다.

3.1 기본 애플리케이션 설정 및 실행

main.py

- Hello world 라고 출력되는 화면을 구성하는 가장 간단한 애플리케이션 코드를 작성합니다,

from fastapi import FastAPI

app = FastAPI()

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

- FastAPI() 객체를 생성하여 app인스턴스를 만듭니다.

- @app.get("/") 데코레이터를 사용하여 루트 경로 /에 대한 GET요청을 처리하는 함수를 정의합니다.

- JSON응답을 반환하는 함수입니다.

애플리케이션 실행

- terminal 명령어로 해당 애플리케이션을 실행하여 Uvicorn이 잘 설치되었는지 확인합니다.

uvicorn app.main:app --reload #실행이 안된다면,python -m uvicorn main:app --reload으로 수정 후 재실행

uvicorn app.main:app --reload

app.main :app - 모듈과 함수명 cf, app 폴더 내 -> main.py 의 -> app인스턴스 실행

--reload - 모듈변경시 자동 감지 옵션, 코드 변경 시 자동으로 서버를 재시작합니다.

- 터미널에서 주소 클릭해 접속하거나 브라우저에 http://127.0.0.1:8000 으로 접속합니다.

- 브라우저 접속 시, 그 결과는 아래와 같이 JSON 형태의 return 값이 잘 출력되는 것을 확인할 수 있습니다.

3.2 고급 FastAPI 기능

1) 경로 매개변수 및 타입 검증
2) Pydantic을 이용한 모델 정의 및 데이터 검증
3) 비동기 프로그래밍

1) 경로 매개변수 및 타입 검증

FastAPI는 경로(Path) 및 쿼리(Query) 매개변수를 사용해서 데이터를 동적으로 처리합니다,

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

- item_id는 경로에서 가져오며, int 타입으로 자동 변환됩니다.

- q는 선택적 쿼리 매개변수, 기본값은 None

2) Pydantic을 이용한 모델 정의 및 데이터 검증

Pydantic은 요청 데이터 검증 자동화를 위해 사용합니다.

기본적인 타입 검사부터 특정 길이 제한, 기본값 설정, 정규 표현식 검증 등을 수행할 수 있습니다.

from pydantic import BaseModel

class Item(BaseModel) :
	id :  int # 필수 정수 값(자동 검증)
	name : str  # 필수 문자열 값
  	price : flaat
   	is_offer : Optional[bool] = None # 선택적 값 (없을 경우 None)

이 Item 모델 을 사용하면 API에서 자동으로 데이터 유형을 검증하고, 잘못된 데이터를 입력하면 오류를 반환합니다.

- id 필드는 정수(int) 타입으로, 사용자가 id ="abc"를 입력하면 오류를 반환합니다.

- name 필드는 문자열(str) 타입으로, 사용자가 name =12345 정수를 입력하면 자동변환 or 오류를 반환합니다.

- is_offer 필드는 선택적 논리형 값으로, 기본적으로 None을 설정합니다.

[예제]

아래와 같이 Pydantic 모델을 FastAPI 엔드포인트에서 활용하면 요청 데이터를 쉽게 검증할 수 있습니다.

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional

app = FastAPI()

class Item(BaseModel):
    id: int
    name: str
    description: Optional[str] = None

@app.post("/items/")
def create_item(item: Item):
    return {"message": "Item received", "item": item}

POST/items/ 엔드포인트는 요청 본문(body)에서 item 모델 객체를 받습니다.

이는 사용자가 JSON 데이터를 전송 시, API가 자동적으로 요청 데이터를 지정 타입에 따라 검증합니다.

3) 비동기 프로그래밍

FastAPI는 비동기 함수(async def)을 지원하여 성능을 극대화할 수 있습니다.

I/O 작업(예: 데이터베이스 쿼리, API 요청, 파일 읽기 등)이 블로킹 없이 실행하여 동시 처리 기능을 향상 시킵니다.

cf , 동기 방식(블로킹 발생) 사용시 하나의 요청이 완료될때까지 다른 요청이 대기해야하지만, 비동기 방식은 await을 사용해 여러요청을 동시에 처리하여 성능을 향상시킵니다.

@app.get("/async-items/{item_id}")
async def read_item_async(item_id : int):
	result = await some async_operation(item_id)
    return {"item_id" : item_id, "result":result}

[예제1]

FastAPI에서는 async def와 await 키워드를 사용하여 비동기 처리를 구현합니다.

from fastapi import FastAPI
import asyncio

app = FastAPI()

async def async_operation(item_id: int):
    await asyncio.sleep(2)  # 비동기적으로 2초 동안 대기 (예: DB 조회)
    return f"Processed item {item_id}"

@app.get("/async-items/{item_id}")
async def read_item_async(item_id: int):
    result = await async_operation(item_id)  # 비동기 함수 호출
    return {"item_id": item_id, "result": result}

실행 흐름은 다음과 같습니다

1. async_operation()함수가 2초간 대기한 후 문자열을 반환합니다.

2. read_tiem_async 함수에서 await을 사용합니다.

3. API 요청이 들어오면 동시에 여러 요청을 처리할 수 있는데→ 하나의 요청이 대기하는 동안 다른 요청을 처리 가능합니다.

[예제2]

비동기적으로 회부 API를 호출하는 예제입니다.

import httpx

@app.get("/external-api/{item_id}")
async def call_external_api(item_id: int):
    async with httpx.AsyncClient() as client:
        response = await client.get(f"https://jsonplaceholder.typicode.com/todos/{item_id}")
    return response.json()

4. FastAPI 애플리케이션 배포

4.1 Uvicorn을 활용한 배포

간단한 환경에서는 Uvicorn을 사용하여 직접 배포할 수 있습니다.

uvicorn app.main:app --host 0.0.0.0 --port 8000

- 0.0.0.0 → 모든 네트워크에서 접근 가능하도록 설정

4.2 Docker를 이용한 배포

FastAPI 애플리케이션을 Docker 컨테이너로 배포할 수 도 있습니다.

기본적인 Dockerfile은 다음과 같음.

FROM python:3.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", "8000"]

docker build -t fast-api-tutorial .
docker run -p 8090:8000 fast-api-tutorial

5. [실습] 챗봇 정보 저장 조회 API

(1) 챗봇 정보 저장 조회 API 구축

프로젝트 구조

이 프로젝트는 FastAPI + SQLAlchemy + SQLite를 활용하여 챗봇 정보를 저장하고 조회하는 간단한 API를 구현

my_fastapi_project/
│
├── app/
│ ├── __init__.py
│ ├── main.py         # FastAPI 애플리케이션 진입점
│ ├── models.py       # 데이터베이스 모델
│ ├── schemas.py      # Pydantic 스키마
│ └── routes.py       # API 엔드포인트
│
└── requirements.txt  # 패키지 의존성

1. requirements.txt

fastapi==0.68.0
uvicorn==0.15.0
sqlalchemy==1.4.25
pydantic==1.8.2

FastAPI: API 개발을 위한 프레임워크

Uvicorn: FastAPI 서버 실행

SQLAlchemy: ORM을 사용하여 데이터베이스 관리

Pydantic: 데이터 검증 및 스키마 정의

환경 설정:
- Python 3.7 이상 설치
- 가상 환경 생성 및 활성화

- pip install -r requirements.txt로 의존성 설치

pip install -r requirements.txt

2. app/init.py

- 이 파일은 비워두는 파일입니다.

- Python 패키지로 인식되도록 app/ 폴더를 패키지로 선언하는 역할

3. app/models.py (데이터베이스 모델)

from sqlalchemy import Column, Integer, String, Date
from sqlalchemy.ext.declarative import declarative_base

# SQLAlchemy 모델의 기반 클래스 생성
Base = declarative_base()

# 챗봇 정보 테이블 정의
class ChatInfo(Base):
    __tablename__ = "chat_info"

    id = Column(Integer, primary_key=True, index=True)  # 기본 키 (자동 증가)
    date = Column(Date)  # 날짜
    content = Column(String)  # 챗봇 응답 내용

Base = declarative_base(): 모든 SQLAlchemy 모델의 부모 클래스 역할을 한다.

__tablename__ = "chat_info": 데이터베이스 테이블 이름을 정의한다.

각 컬럼 설명

id: 기본 키(PK), 자동 증가.

date: 챗봇이 응답한 날짜.

content: 챗봇의 응답 내용.

📌 다른 파일과의 관계

- app/database.py의 engine을 사용하여 테이블을 생성합니다.

- app/schemas.py에서 이 모델을 Pydantic 스키마로 변환합니다.

4. app/schemas.py (Pydantic 데이터 검증)

from pydantic import BaseModel
from datetime import date

# 기본 데이터 구조 정의
class ChatInfoBase(BaseModel):
    date: date
    content: str

# 새로운 데이터 생성용 스키마
class ChatInfoCreate(ChatInfoBase):
    pass

# 데이터 반환용 스키마
class ChatInfo(ChatInfoBase):
    id: int  # DB에서 할당된 ID 포함

    class Config:
        orm_mode = True  # SQLAlchemy 모델을 Pydantic 모델로 변환할 때 사용

📌 설명

ChatInfoBase: 공통 속성을 가진 기본 데이터 모델.

ChatInfoCreate: 데이터 생성 시 사용되는 스키마.

ChatInfo: 데이터베이스 조회 시 반환되는 스키마.

orm_mode = True를 설정하면 SQLAlchemy 모델을 자동으로 변환할 수 있음.

📌 다른 파일과의 관계

app/routes.py에서 API 요청 데이터를 검증하는 데 사용됩니다.

app/models.py의 ChatInfo 모델과 연결됩니다

5. app/database.py (DB 연결 및 세션 관리)

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

# SQLite 데이터베이스 URL 설정
SQLALCHEMY_DATABASE_URL = "sqlite:///./chatbot.db"

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

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

# 데이터베이스 세션을 생성하는 함수
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

📌 설명

engine: SQLite 데이터베이스를 연결하는 SQLAlchemy 엔진.

SessionLocal: DB 세션을 관리하는 객체.

get_db(): API 요청마다 새로운 DB 세션을 생성하고 자동 종료.

📌 다른 파일과의 관계

app/models.py에서 이 engine을 사용하여 테이블을 생성.

app/routes.py에서 DB 세션을 받아와 데이터 조작 수행.

6. app/routes.py (API 엔드포인트)

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from . import models, schemas
from .database import get_db
from datetime import date

router = APIRouter()

# 새로운 챗봇 정보 추가
@router.post("/chat_info/", response_model=schemas.ChatInfo)
def create_chat_info(chat_info: schemas.ChatInfoCreate, db: Session = Depends(get_db)):
    db_chat_info = models.ChatInfo(**chat_info.dict())
    db.add(db_chat_info)
    db.commit()
    db.refresh(db_chat_info)
    return db_chat_info

# 특정 날짜의 챗봇 정보 조회
@router.get("/chat_info/{date}", response_model=schemas.ChatInfo)
def read_chat_info(date: date, db: Session = Depends(get_db)):
    db_chat_info = db.query(models.ChatInfo).filter(models.ChatInfo.date == date).first()
    if db_chat_info is None:
        raise HTTPException(status_code=404, detail="해당 날짜의 정보를 찾을 수 없습니다")
    return db_chat_info

📌 설명

@router.post("/chat_info/"): 챗봇 정보를 DB에 저장하는 엔드포인트.

@router.get("/chat_info/{date}"): 특정 날짜의 챗봇 정보를 조회하는 엔드포인트.

📌 다른 파일과의 관계

app/schemas.py를 사용하여 데이터 검증.

app/database.py에서 DB 세션을 가져옴.

7. app/main.py (FastAPI 진입점)

from fastapi import FastAPI
from .database import engine
from . import models, routes

# 테이블 생성
models.Base.metadata.create_all(bind=engine)

# FastAPI 애플리케이션 인스턴스 생성
app = FastAPI()

# 라우터 등록
app.include_router(routes.router)

@app.get("/")
def read_root():
    return {"message": "챗봇 정보 출력 시스템에 오신 것을 환영합니다"}

📌 설명

FastAPI 앱을 생성하고 라우터를 등록.

models.Base.metadata.create_all(bind=engine): 테이블 자동 생성.

📌 다른 파일과의 관계

app/models.py에서 정의한 테이블을 생성.

app/routes.py에서 정의한 API를 등록.

main.py과 router.py의 차이는?

API의 설정은 주로 두 부분으로 나누어 처리

main.py: 여기서는 FastAPI 애플리케이션의 기본 설정을 합니다.
- FastAPI 인스턴스 생성
- 서버 시작/종료 이벤트 처리
- 미들웨어 설정
- 라우터 등록 (app.include_router)
- 전역 예외 처리
- 기본 경로 설정 등
routes.py (또는 router.py): 여기서는 실제 API 엔드포인트의 세부 로직을 정의합니다.
- 특정 경로에 대한 HTTP 메서드(GET, POST 등) 처리
- 요청 데이터 검증
- 데이터베이스 작업 수행
- 응답 형식 정의

가장 좋은 방법은 둘을 조합하는 것

# main.py
from fastapi import FastAPI
from .routes import router

app = FastAPI()
app.include_router(router, prefix="/api")

# routes.py
from fastapi import APIRouter
router = APIRouter()

@router.get("/items")
def get_items():
    return {"items": []}

- 이렇게 하면 main.py는 애플리케이션 설정에 집중하고, routes.py는 엔드포인트 로직에 집중할 수 있어 코드 구조가 더 깔끔해짐

- 대규모 프로젝트에서는 routes를 여러 파일로 나누어 관리하는 것도 일반적입니다.

models.py 과 schemas.py 의 차이는?

models.py와 schemas.py는 FastAPI + SQLAlchemy + Pydantic을 사용할 때 서로 다른 역할을 수행

SQLAlchemy 모델에서 데이터 가져오기 (models.py 활용) ▶FastAPI 엔드포인트에서 schemas.py 활용

1️⃣ models.py (데이터베이스 모델 - SQLAlchemy) : SQLAlchemy ORM을 사용하여 데이터베이스 테이블을 정의

실제 데이터베이스의 구조를 결정하는 역할
데이터 저장, 조회, 수정, 삭제(CRUD)와 관련된 작업 수

특징

Base 클래스를 상속받아 테이블을 정의
- Base = declarative_base()
Column()을 사용하여 각 필드의 데이터 타입 및 제약 조건 지정
- 예) id = Column(Integer, primary_key=True, index=True) # 기본 키 (자동 증가)
실제 데이터베이스 테이블에 매핑
- class NPSData(Base):
  __tablename__ = "nps_score" # 실제 데이터베이스 테이블 이름

2️⃣ schemas.py (Pydantic 데이터 스키마) - Pydantic을 사용하여 데이터 유효성 검사

API에서 요청/응답 시 사용할 데이터 검증
Pydantic을 사용하여 데이터 유효성 검사
SQLAlchemy 모델(models.py)과 구분됨 (DB와 독립적)
클라이언트에서 API로 데이터를 보낼 때 (입력) 또는 API가 클라이언트에 데이터를 반환할 때 (출력) 사용됨

특징

BaseModel을 상속받아 JSON 데이터의 구조를 정의
FastAPI 엔드포인트에서 데이터를 자동으로 검증
orm_mode = True (Pydantic v2에서는 from_attributes = True)를 설정하여 SQLAlchemy 모델을 Pydantic 스키마로 변환 가능

(2)챗봇 정보 저장 조회 API 서버 실행

1️⃣ 가상환경 활성화 (선택)

source venv/bin/activate # Mac/Linux
venv\Scripts\activate # Windows

2️⃣ FastAPI 서버 실행

1. FastAPI 서버 실행

uvicorn app.main:app --reload

1. app/main.py가 실행됨.

2. FastAPI 앱(app)이 생성되고, 데이터베이스 테이블이 자동 생성됨.

3. app.include_router(routes.router)를 통해 routes.py의 API 엔드포인트가 등록됨.

2. models.Base.metadata.create_all(bind=engine) 실행 (테이블 생성)

- SQLAlchemy의 자동 테이블 생성 기능을 실행

1. app/main.py에서 실행됨.

2. engine을 통해 데이터베이스(chatbot.db)에 연결.

3. models.ChatInfo 모델을 확인.

- 테이블이 없으면 CREATE TABLE chat_info (...) SQL 실행 → 테이블 생성.

- 테이블이 이미 존재하면(chatbot.db) 아무 작업도 하지 않음.

3️⃣ API 테스트

- http://127.0.0.1:8000/docs 에서 Swagger UI 확인

1. POST /chat_info/ 요청으로 데이터 추가

{
    "date": "2025-03-06",
    "content": "안녕하세요, 챗봇입니다!"
}

routes.py에서 POST /chat_info/ 엔드포인트 호출됨.
요청 본문(JSON 데이터)을 schemas.ChatInfoCreate 스키마로 검증.
get_db()를 통해 SessionLocal()로 데이터베이스 세션을 생성.
models.ChatInfo(**chat_info.dict())를 사용해 모델 객체 생성.
DB 세션(db.add(db_chat_info))을 통해 데이터를 추가한 후 commit().
refresh()를 통해 추가된 데이터의 id 값을 얻음.
새로 추가된 챗봇 정보가 JSON 형태로 응답됨.

2. GET /chat_info/{date} 요청으로 데이터 조회

GET /chat_info/2025-03-06

routes.py에서 GET /chat_info/{date} 엔드포인트 호출됨.
URL의 {date} 값을 datetime.date 타입으로 변환.
get_db()를 통해 DB 세션을 가져옴.
db.query(models.ChatInfo).filter(models.ChatInfo.date == date).first()를 실행하여 특정 날짜의 데이터 조회.
데이터가 존재하면 JSON 형태로 반환.
데이터가 없으면 HTTPException(status_code=404) 발생.

(3) FastAPI API 테스트 (심화)

FastAPI에서 GET /chat_info/2025-03-06 API를 테스트하는 방법은 여러 가지가 있음

[방법1] 브라우저에서 직접 테스트 (GET 요청)

FastAPI는 GET 요청을 브라우저에서 쉽게 테스트할 수 있습니다.

✅ 테스트 방법

FastAPI 서버 실행:
uvicorn app.main:app --reload
브라우저에서 다음 URL로 접속:
<http://127.0.0.1:8000/chat_info/2025-03-06>
응답 예시
- 데이터가 존재할 경우:
- { "id": 1, "date": "2025-03-06", "content": "안녕하세요, 챗봇입니다!" }
- 데이터가 존재하지 않는 경우:
- { "detail": "해당 날짜의 정보를 찾을 수 없습니다" }

[방법2] curl 명령어 사용 (터미널에서 테스트)

터미널에서 curl을 사용해 GET 요청을 보낼 수도 있습니다.

✅ 테스트 방법

curl -X GET "<http://127.0.0.1:8000/chat_info/2025-03-06>"

📌 응답 예시

{
    "id": 1,
    "date": "2025-03-06",
    "content": "안녕하세요, 챗봇입니다!"
}

📌 에러 발생 시

{
    "detail": "해당 날짜의 정보를 찾을 수 없습니다"
}

[방법3] Postman으로 테스트 (GUI 기반)

GUI 환경에서 테스트하려면 Postman을 사용하면 편리합니다.

✅ Postman 사용 방법

Postman 실행 (설치 필요)
새로운 GET 요청 생성
- URL: http://127.0.0.1:8000/chat_info/2025-03-06
- Method: GET
Send 버튼 클릭
응답 확인
- 성공하면 데이터가 JSON으로 반환됨.
- 데이터가 없으면 "detail": "해당 날짜의 정보를 찾을 수 없습니다" 메시지 반환.

[방법4] FastAPI 내장 Swagger UI 사용

FastAPI의 Swagger UI (/docs)에서 API 테스트를 할 수 있습니다.

✅ Swagger UI 테스트 방법

FastAPI 서버 실행
uvicorn app.main:app --reload
Swagger UI 접속
<http://127.0.0.1:8000/docs>
"GET /chat_info/{date}" API 선택
date 값 입력 (예: 2025-03-06) 후 "Try it out" 클릭
응답 확인

📌 응답 예시

{
    "id": 1,
    "date": "2025-03-06",
    "content": "안녕하세요, 챗봇입니다!"
}

✅ 결론 : 어떤 방법을 사용할까?

방법	추천 대상	장점
브라우저	간단한 GET 요청 테스트	URL 입력만으로 테스트 가능
curl (터미널)	CLI 환경에서 테스트	별도 프로그램 없이 테스트 가능
Postman	GUI 기반 테스트가 필요한 경우	API 요청 관리가 편리함
Swagger UI (/docs)	FastAPI 내장 문서 활용	UI에서 직접 API 호출 가능

✅ 가장 간단한 방법은 브라우저에서 URL 입력하거나,

✅ 터미널에서 curl 명령어를 실행하는 것입니다.

🚀 추천 : 개발 중에는 FastAPI의 /docs를 활용하여 빠르게 테스트하는 것이 가장 편리

[ 참고 문서 ]

FastAPI Create Database Connection for API(Sqlite) - 33

API를 만들어서 연결하는 함수 구현해보기 1. .py파일 생성 todoapp폴더 하위에 새로운 main.py를 생성한다.(31번, 32번 페이지 참조) 2. todoapp폴더 하위에 database.py의 Base와 models.py를 import 한다. import model

zambbon.tistory.com

저작자표시

'Tools > Python' 카테고리의 다른 글

[python] Huggingface 모델 다운로드 방법 (API 다운못받는 환경에서 SSL 오류날 때 사용) (0)	2025.04.25
[FastAPI] FastAPI이용한 백엔드 구축 가이드라인 (2) parameter (0)	2025.03.06
[Crawler] 네이버 지도 크롤링 - 여러 URL을 하나의 탭에서 크롤링 (3)	2024.10.25
[GIT] 깃으로 협업하기 가이드라인 (0)	2024.01.08
[python] 07. 패키지와 모듈 (1)	2023.12.31

샤샤's 데이터 분석 블로그

[FastAPI] FastAPI이용한 백엔드 구축 가이드라인 (1) 설치 및 Uvicorn을 통한 테스트

FastAPI를 이용한 백엔드 구축 가이드라인

1. FastAPI 소개

2. 개발 환경 설정

3. FastAPI 애플리케이션 구축

4. FastAPI 애플리케이션 배포

5. [실습] 챗봇 정보 저장 조회 API

(1) 챗봇 정보 저장 조회 API 구축

(2)챗봇 정보 저장 조회 API 서버 실행

(3) FastAPI API 테스트 (심화)

'Tools > Python' 카테고리의 다른 글

티스토리툴바

[FastAPI] FastAPI이용한 백엔드 구축 가이드라인 (1) 설치 및 Uvicorn을 통한 테스트

FastAPI를 이용한 백엔드 구축 가이드라인

1. FastAPI 소개

2. 개발 환경 설정

3. FastAPI 애플리케이션 구축

4. FastAPI 애플리케이션 배포

5. [실습] 챗봇 정보 저장 조회 API

(1) 챗봇 정보 저장 조회 API 구축

(2)챗봇 정보 저장 조회 API 서버 실행

(3) FastAPI API 테스트 (심화)

'Tools > Python' 카테고리의 다른 글

'Tools/Python' Related Articles

티스토리툴바