[작성자:] root

현대적인 웹 애플리케이션 개발에 있어 FastAPI는 빠르고, 직관적이며, 현대적인 프레임워크로 많은 개발자들에게 사랑받고 있습니다. 본 문서에서는 FastAPI로 백엔드 서버를 개발하는 과정과 이를 Docker를 통해 컨테이너화하는 방법에 대해 자세히 설명하겠습니다. FastAPI의 장점을 살리고, Docker를 활용하여 개발 환경을 표준화하고 배포의 용이성을 극대화할 수 있습니다.

목차

• 1. FastAPI 소개
• 2. FastAPI 설치
• 3. FastAPI 기본 예제
• 4. Docker 소개
• 5. Docker 설치
• 6. Docker로 FastAPI 애플리케이션 배포
• 7. 결론

1. FastAPI 소개

FastAPI는 Pydantic과 Starlette를 기반으로 하는 Python web framework으로, RESTful API를 쉽게 구축할 수 있도록 설계되었습니다. 모델 정의, 자동화된 API 문서화, 비동기 처리를 지원하며, 높은 성능과 직관적인 문법으로 인기를 얻고 있습니다. FastAPI는 다음과 같은 주요 기능을 제공합니다:

• 자동 문서화: OpenAPI와 JSON Schema를 기반으로 하는 자동화된 문서화 기능.
• 비동기 프로그래밍: Python의 async/await를 활용하여 높은 성능을 지원.
• 타입 힌트: Pydantic을 통해 데이터 검증 및 변환 지원.
• 미들웨어 및 의존성 주입: 다양한 미들웨어와 의존성 관리 기능으로 효율적인 코드 작성.

2. FastAPI 설치

FastAPI와 Uvicorn을 설치하기 위해 Python이 설치되어 있어야 합니다. Python 3.6 이상이 필요하며, 다음과 같이 FastAPI와 Uvicorn을 설치할 수 있습니다:

pip install fastapi uvicorn

설치가 완료되면, 필요한 경우 Pydantic과 같은 추가 라이브러리도 설치할 수 있습니다.

3. FastAPI 기본 예제

FastAPI로 간단한 RESTful API 서버를 만들어 보겠습니다. 아래의 코드는 기본적으로 사용자 정보를 추가하고 조회하는 API를 구현합니다:

from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

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

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 get_users():
    return users

이 코드는 POST 요청을 통해 사용자를 생성하고, GET 요청을 통해 사용자 목록을 조회하는 API를 제공합니다. 서버를 실행하려면 다음과 같은 커맨드를 사용합니다:

uvicorn main:app --reload

이제 http://127.0.0.1:8000/docs에 접속하면 Swagger UI를 통해 API 문서를 확인하고 테스트할 수 있습니다.

4. Docker 소개

Docker는 애플리케이션을 독립적인 컨테이너에서 실행할 수 있도록 도와주는 플랫폼입니다. 컨테이너는 빠르고 경량화된 실행 환경을 제공하여 다양한 환경에서 실행할 수 있는 애플리케이션을 쉽게 배포할 수 있습니다. Docker를 사용하면 다음과 같은 이점을 얻을 수 있습니다:

• 일관된 환경: 개발 환경과 프로덕션 환경 간의 차이를 줄입니다.
• 빠른 배포: 컨테이너를 사용하면 복잡한 설치 과정 없이 빠르게 배포할 수 있습니다.
• 확장성: 쉽게 확장하고, 여러 개의 컨테이너를 동시에 관리할 수 있습니다.

5. Docker 설치

Docker를 설치하는 과정은 운영 체제에 따라 다르지만, 대체로 다음과 같은 단계를 따릅니다. 여기서는 Ubuntu를 기준으로 설명합니다:

1. Docker의 공식 GPG 키를 추가합니다:

sudo apt-get remove docker docker-engine docker.io containerd runc
sudo apt-get update
sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

2. Docker를 설치합니다:

sudo apt-get update
sudo apt-get install docker-ce

3. Docker가 정상적으로 설치되었는지 확인합니다:

sudo docker --version

이제 Docker를 사용할 준비가 완료되었습니다.

6. Docker로 FastAPI 애플리케이션 배포

FastAPI 애플리케이션을 Docker에서 실행하기 위해서는 Dockerfile을 작성해야 합니다. 다음은 FastAPI 애플리케이션을 위한 Dockerfile의 예입니다:

FROM python:3.9

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

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

위의 Dockerfile에서 requirements.txt에는 FastAPI와 Uvicorn을 포함시킵니다:

fastapi
uvicorn

이제 Docker 이미지를 빌드할 수 있습니다:

sudo docker build -t fastapi-app .

그리고 다음 명령어로 Docker 컨테이너를 실행합니다:

sudo docker run -d -p 80:80 fastapi-app

이제 http://localhost/docs에 접속하여 FastAPI 애플리케이션을 확인할 수 있습니다.

7. 결론

이 글에서는 FastAPI로 RESTful API 서버를 구축하고, Docker를 통해 이를 컨테이너화하는 방법에 대해 설명했습니다. FastAPI는 빠르고 효율적인 웹 개발을 지원하며, Docker는 복잡한 배포 과정을 단순화하여 개발자들이 더 나은 경험을 할 수 있도록 도와줍니다. 이러한 도구들을 활용하여 개발 환경을 표준화하고, 효율적인 배포를 이루는 것이 가능합니다.

FastAPI와 Docker를 활용한 개발에 대한 더 많은 예제와 정보는 공식 문서를 참고하시기 바랍니다. 이제 여러분의 애플리케이션을 더 잘 관리하고 배포할 준비가 되셨기를 바랍니다!

FastAPI는 간단하고 효율적인 웹 API를 구축할 수 있는 현대적인 프레임워크입니다. Python의 타입 힌트를 적극적으로 활용하여 코드의 가독성을 높이고, 자동으로 OpenAPI 및 JSON Schema를 생성하는 등의 특성을 갖추고 있습니다. 이번 강좌에서는 FastAPI에서 요청 및 응답 데이터의 검증 및 변환 방법에 대해 자세히 알아보겠습니다.

1. 데이터 검증의 필요성

웹 서버는 클라이언트로부터 다양한 형태의 데이터 요청을 받습니다. 이러한 데이터는 종종 예상하지 못한 형식이나 값을 가질 수 있으며, 이로 인해 서버에서 오류가 발생하거나 잘못된 동작을 유발할 수 있습니다. 따라서 데이터의 유효성을 검사하고, 필요시 변환하는 과정이 중요합니다.

2. FastAPI에서의 데이터 검증

FastAPI는 Pydantic이라는 데이터 검증 라이브러리를 사용하여 요청 및 응답 데이터의 검증을 수행합니다. Pydantic의 모델을 선언하고 유효성 검사를 수행하는 방법을 살펴보겠습니다.

2.1 Pydantic 모델 정의하기

Pydantic 모델은 요청 데이터의 구조를 정의하며, 각 필드에 대한 데이터 타입과 제약 조건을 설정할 수 있습니다. 다음은 사용자 정보를 정의하는 Pydantic 모델의 예시입니다.

from pydantic import BaseModel, EmailStr, conint

class User(BaseModel):
    name: str
    email: EmailStr
    age: conint(ge=0)  # 0 이상의 정수

위의 모델은 사용자의 이름, 이메일, 나이를 저장하는 구조체를 정의합니다. 여기서 EmailStr는 유효한 이메일 형식인지 검사하며, conint는 정수 값을 기준으로 제약 조건을 설정합니다.

2.2 FastAPI 엔드포인트에서 데이터 검증하기

이제 이 Pydantic 모델을 FastAPI의 엔드포인트에 사용하여 클라이언트로부터 오는 요청을 검증할 수 있습니다.

from fastapi import FastAPI, HTTPException

app = FastAPI()

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

위의 엔드포인트는 POST 요청을 처리하고, 요청 본문에서 사용자 정보를 가져와 검증합니다. 만약 요청 데이터가 유효하지 않다면 FastAPI는 자동으로 422 Unprocessable Entity 오류를 반환합니다.

3. 응답 데이터 검증 및 변환

FastAPI는 응답 데이터도 Pydantic 모델을 사용하여 추천합니다. 이는 응답 형식을 일관되게 유지하고 클라이언트가 받을 데이터를 정확히 알고 있게 합니다.

3.1 응답 모델 정의하기

응답 데이터의 형태도 Pydantic 모델로 정의할 수 있습니다. 예를 들어, 사용자가 생성된 후 반환할 데이터의 형태를 정의합니다.

class UserResponse(BaseModel):
    id: int
    name: str
    email: EmailStr

3.2 엔드포인트에서 응답 데이터 사용하기

@app.post("/users/", response_model=UserResponse)
async def create_user(user: User):
    user_id = 1  # 예를 들어, 사용자 ID를 1로 설정
    return UserResponse(id=user_id, name=user.name, email=user.email)

이제 응답 데이터는 UserResponse 모델에 따라 검증되고 변환됩니다. 클라이언트는 명확하게 어떤 형태의 데이터를 받을 수 있는지 알 수 있습니다.

4. 데이터 변환

FastAPI는 요청 데이터 및 응답 데이터의 구조를 변환할 수 있는 방법을 제공합니다. 예를 들어, 클라이언트가 UUID 형식의 ID를 보낸다고 가정할 때, 이를 정수형 ID로 변환하는 방법을 설명합니다.

4.1 UUID 검증 및 변환

from uuid import UUID

class User(BaseModel):
    name: str
    email: EmailStr
    id: UUID  # UUID로 ID를 정의

이 경우 FastAPI는 클라이언트가 보낸 데이터를 자동으로 UUID 형태로 변환합니다.

4.2 변환 예제 코드

@app.post("/users/", response_model=UserResponse)
async def create_user(user: User):
    user_id = str(user.id)  # UUID에서 문자열로 변환
    # DB에 사용자 정보를 저장하는 로직 추가
    return UserResponse(id=user_id, name=user.name, email=user.email)

5. 전체 예제

전체적인 코드를 종합하여 FastAPI 애플리케이션을 구현하겠습니다. 아래 예시는 사용자 정보를 생성하는 API로, 데이터 검증 및 응답 변환을 포함합니다.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, EmailStr, conint
from uuid import UUID
import uvicorn

class User(BaseModel):
    name: str
    email: EmailStr
    id: UUID

class UserResponse(BaseModel):
    id: str
    name: str
    email: EmailStr

app = FastAPI()

@app.post("/users/", response_model=UserResponse)
async def create_user(user: User):
    user_id = str(user.id)  # UUID에서 문자열로 변환
    # DB에 사용자 정보를 저장하는 로직 추가
    return UserResponse(id=user_id, name=user.name, email=user.email)

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

6. 결론

FastAPI를 사용하여 요청 및 응답 데이터의 검증 및 변환 과정을 간편하게 처리할 수 있는 방법에 대해 알아보았습니다. 이는 서버의 안정성을 증가시키고, 클라이언트와의 통신을 명확하게 하여 개발 효율성을 높이는 데 기여합니다. FastAPI의 데이터 검증 및 변환 기능을 활용하면, 복잡한 비즈니스 로직을 간단하게 구현할 수 있습니다.

이 글을 통해 FastAPI의 장점과 데이터 검증 및 변환 프로세스를 이해하고, 실제 애플리케이션 개발에 적용할 수 있게 되기를 바랍니다.

7. 참고 문서

• FastAPI 공식 문서
• Pydantic 공식 문서

FastAPI는 현대적인 웹 프레임워크로서, Python을 사용하여 API 서버를 쉽게 개발할 수 있게 해줍니다.
이 글에서는 FastAPI를 사용하여 데이터베이스와 상호작용하고, 특히 데이터의 업데이트 기능에 대해 자세히 알아보겠습니다.

1. FastAPI란?

FastAPI는 비동기 프로그래밍을 지원하며, 데이터 유효성 검사를 위해 Pydantic을 통합하여 사용합니다.
이 프레임워크는 성능과 개발속도를 중시하여 설계되었으며, Swagger UI와 ReDoc을 기본적으로 제공하여 API 문서를 자동으로 생성할 수 있습니다.

1.1 FastAPI의 주요 기능

• 비동기적 처리
• 자동화된 API 문서화
• 신뢰성 높은 데이터 검증
• 직관적인 코드 구조

2. 데이터베이스 설정

FastAPI는 다양한 데이터베이스와 쉽게 통합할 수 있습니다.
이번 예제에서는 SQLAlchemy를 사용하여 SQLite 데이터베이스를 구축할 것입니다.
SQLAlchemy는 Python에서 가장 인기 있는 ORM(Object-Relational Mapping) 라이브러리 중 하나입니다.

2.1 SQLAlchemy 설치

pip install sqlalchemy databases

2.2 데이터베이스 모델 생성

데이터베이스를 사용하기 위해 먼저 데이터 모델을 정의해야 합니다.
예를 들어, 간단한 사용자 정보를 저장할 수 있는 User 모델을 만들어보겠습니다.

from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    email = Column(String, unique=True, index=True)

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

engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

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

3. FastAPI 설정 및 라우터 구현

FastAPI 애플리케이션을 설정하고, 사용자 정보를 업데이트할 수 있는 API의 엔드포인트를 구현하겠습니다.

3.1 FastAPI 설치

pip install fastapi[all]

3.2 FastAPI 설계 및 엔드포인트 구현

CRUD(Create, Read, Update, Delete) 중 Update 기능을 중점적으로 살펴보겠습니다.
아래 예제 코드는 사용자의 정보를 업데이트하는 API를 구현합니다.

from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy.orm import Session

app = FastAPI()

# 데이터베이스 의존성 관리
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.put("/users/{user_id}")
def update_user(user_id: int, username: str = None, email: str = None, db: Session = Depends(get_db)):
    # 해당 ID의 사용자 검색
    user = db.query(User).filter(User.id == user_id).first()
    if not user:
        raise HTTPException(status_code=404, detail="User not found")

    # 값 업데이트
    if username:
        user.username = username
    if email:
        user.email = email

    db.commit()
    db.refresh(user)
    
    return {"message": "User updated successfully", "user": user}
    

4. 업데이트 기능 테스트

API를 테스트하기 위해 Swagger UI를 사용하여 업데이트 작업을 수행합니다.
서버를 실행한 후, http://127.0.0.1:8000/docs에 접근하여 API를 확인하고 테스트할 수 있습니다.

# 서버 실행
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="127.0.0.1", port=8000)
    

5. 결론

FastAPI와 SQLAlchemy를 사용하여 RESTful API를 개발하고, 데이터베이스에서 정보를 업데이트하는 방법에 대해 알아보았습니다.
FastAPI는 빠른 성능과 편리한 개발 경험을 제공하며, 실제 많은 프로젝트에서 활용되고 있습니다.
데이터베이스 작업을 쉽게 처리할 수 있도록 하여 효율적인 서버 개발을 도와줍니다.

이 글에서 제공한 예제를 토대로 프로젝트를 확장하고, 다양한 기능을 추가하여 자신만의 FastAPI 애플리케이션을 만들어보세요.
FastAPI는 매우 유연하고 확장성이 뛰어난 프레임워크이므로, 다양한 요구사항에 맞추어 개발할 수 있습니다.

참고 자료

• FastAPI 공식 문서
• SQLAlchemy 공식 문서

작성일: 2023년 10월 10일

소개

FastAPI는 Python으로 구축된 웹 프레임워크로, 비동기 프로그래밍과 데이터 검증을 지원하여 빠르고 효율적인 API를 개발할 수 있도록 도와줍니다. 이 글에서는 FastAPI를 사용하여 사용자 인증 및 권한 부여 기능을 구현하는 방법에 대해 자세히 설명하겠습니다.

1. 환경 설정

FastAPI와 관련 라이브러리를 설치하기 위해 Python의 패키지 관리자인 pip를 사용합니다. 다음 명령어를 통해 필요한 패키지를 설치합니다:

pip install fastapi uvicorn python-jose passlib[bcrypt]

각 라이브러리의 역할은 다음과 같습니다:

• fastapi: 웹 프레임워크
• uvicorn: ASGI 서버, FastAPI 애플리케이션을 실행하기 위해 사용
• python-jose: JWT(Json Web Token) 인코딩 및 디코딩을 위한 라이브러리
• passlib: 비밀번호 해싱을 위한 라이브러리

2. FastAPI 기본 구조

FastAPI 애플리케이션의 기본 구조는 다음과 같습니다:

from fastapi import FastAPI

app = FastAPI()

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

위 코드를 실행하면 기본적인 FastAPI 서버가 생성됩니다. 이를 바탕으로 사용자 인증 및 권한 부여 기능을 추가해보겠습니다.

3. 사용자 모델 정의

사용자 모델을 정의하기 위해 Pydantic을 사용할 것입니다. Pydantic은 데이터 검증을 자동으로 처리해주는 라이브러리로, FastAPI와 잘 연동됩니다.

from pydantic import BaseModel, EmailStr
from typing import Optional
from passlib.context import CryptContext

class User(BaseModel):
    username: str
    email: EmailStr
    full_name: Optional[str] = None
    disabled: Optional[bool] = None

class UserInDB(User):
    hashed_password: str

위의 User 모델은 사용자 정보를 정의하며, UserInDB는 데이터베이스에 저장되기 위해 해싱된 비밀번호를 포함합니다.

4. 비밀번호 해싱

비밀번호를 안전하게 저장하기 위해 해싱을 진행합니다. Passlib 라이브러리를 사용하여 비밀번호를 해싱하는 방법은 다음과 같습니다:

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def hash_password(password: str) -> str:
    return pwd_context.hash(password)

해싱된 비밀번호는 사용자를 데이터베이스에 저장할 때 사용됩니다.

5. 사용자 등록 API

사용자 등록을 처리할 API 엔드포인트를 생성합니다. 사용자가 입력한 정보를 통해 새로운 사용자를 생성하고, 비밀번호는 해싱하여 저장합니다.

from fastapi import HTTPException, Depends
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm

users_db = {}

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.post("/register/")
def register(user: User):
    if user.username in users_db:
        raise HTTPException(status_code=400, detail="Username already registered")
    hashed_password = hash_password(user.password)
    users_db[user.username] = UserInDB(
        username=user.username, email=user.email, full_name=user.full_name, hashed_password=hashed_password
    )
    return {"msg": "User registered successfully!"}

6. JWT 생성 및 검증

JWT(Json Web Token)를 이용하여 사용자 인증 및 권한 부여를 수행합니다. 다음 코드에서는 JWT를 생성하고 검증하는 방법을 보여줍니다:

from datetime import datetime, timedelta
from jose import JWTError, jwt

SECRET_KEY = "mysecretkey"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
    to_encode = data.copy()
    if expires_delta:
        expire = datetime.utcnow() + expires_delta
    else:
        expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

def verify_token(token: str):
    credentials_exception = HTTPException(status_code=401, detail="Could not validate credentials")
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
    except JWTError:
        raise credentials_exception
    return username

7. 로그인 API

사용자가 로그인할 수 있는 API를 구현합니다. 사용자는 사용자명과 비밀번호를 입력하여 JWT를 생성합니다.

@app.post("/token")
def login(form_data: OAuth2PasswordRequestForm = Depends()):
    user = users_db.get(form_data.username)
    if not user or not pwd_context.verify(form_data.password, user.hashed_password):
        raise HTTPException(status_code=400, detail="Incorrect username or password")
    access_token = create_access_token(data={"sub": user.username})
    return {"access_token": access_token, "token_type": "bearer"}

8. 인증이 필요한 API 엔드포인트

인증이 필요한 엔드포인트를 추가하는 방법에 대해 설명합니다. OAuth2PasswordBearer 를 사용하여 API에 인증 기능을 추가할 수 있습니다.

from fastapi import Security

@app.get("/users/me", response_model=User)
def read_users_me(token: str = Depends(oauth2_scheme)):
    username = verify_token(token)
    user = users_db.get(username)
    if user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return user

9. 권한 부여 기능 추가하기

사용자 권한 부여 기능을 추가할 수 있습니다. 이를 통해 특정 사용자에게만 접근 허용하는 API 엔드포인트를 만들 수 있습니다.

def get_current_active_user(token: str = Depends(oauth2_scheme)):
    username = verify_token(token)
    user = users_db.get(username)
    if user is None or user.disabled:
        raise HTTPException(status_code=400, detail="Inactive user")
    return user

@app.get("/users/me/role")
def read_user_role(current_user: User = Depends(get_current_active_user)):
    return {"username": current_user.username, "role": "admin"}

10. FastAPI 서버 실행하기

FastAPI 서버를 실행하기 위해 uvicorn를 사용합니다. 다음 명령어로 서버를 실행할 수 있습니다:

uvicorn main:app --reload

서버가 실행되면, /docs 경로로 접속하여 Swagger UI를 통해 API를 테스트할 수 있습니다.

결론

FastAPI를 사용하여 사용자 인증 및 권한 부여 기능을 성공적으로 구현했습니다. FastAPI의 강력한 기능을 통해 효율적인 웹 API를 구축할 수 있으며, JWT를 활용한 인증 방식은 보안과 성능 모두를 고려할 수 있는 좋은 선택입니다. 앞으로 FastAPI의 다양한 기능을 탐색해 보시기 바랍니다.

현대의 웹 서버 개발에 있어 FastAPI는 빠른 속도와 직관적인 API 설계를 제공하는 프레임워크로 인기를 얻고 있습니다. 본 강좌에서는 FastAPI를 사용하여 기본적인 서버를 개발하는 방법과 그 서버를 도커를 통해 쉽게 배포하는 방법에 대해 설명하겠습니다.

1. FastAPI란?

FastAPI는 Python으로 작성된 현대적인 웹 프레임워크로, Starlette을 기반으로 하며 Pydantic으로 데이터 유효성 검사를 제공합니다. 빠른 성능과 직관적인 문서화, 자동화된 API 문서 생성 기능 덕분에 많은 개발자들에게 선택받고 있습니다.

1.1 FastAPI의 주요 특징

• 빠른 성능: ASGI 기반으로, 비동기 프로그래밍을 지원하여 높은 성능을 자랑합니다.
• 자동화된 문서화: Swagger UI와 Redoc을 통한 자동 문서화 기능이 내장되어 있습니다.
• Pydantic: 데이터 모델링 및 유효성 검사에 Pydantic을 사용합니다.
• 비동기 지원: Python의 비동기 프로그래밍을 통해 I/O 작업을 효율적으로 처리할 수 있습니다.

2. FastAPI 서버 개발하기

2.1 환경 설정

FastAPI 서버를 만들기 위해 Python 3.6 이상이 필요합니다. 아래의 명령어를 사용하여 FastAPI와 Uvicorn을 설치합니다:

pip install fastapi uvicorn

2.2 기본적인 FastAPI 서버 작성

다음은 기본적인 FastAPI 서버의 코드 예제입니다:

from fastapi import FastAPI

app = FastAPI()

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

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

이 코드는 두 개의 GET 엔드포인트를 가진 FastAPI 서버를 정의합니다. 첫 번째 엔드포인트는 루트 URL에 대한 응답으로 “Hello, FastAPI!” 메시지를 반환합니다. 두 번째 엔드포인트는 아이템 ID와 쿼리 파라미터를 받아 그 값을 반환합니다.

2.3 서버 실행하기

서버를 실행하기 위해 다음 명령어를 사용합니다:

uvicorn main:app --reload

이 명령은 FastAPI 서버를 로컬호스트 8000번 포트에서 실행합니다. 웹 브라우저에서 http://127.0.0.1:8000/docs로 접속하면 자동으로 생성된 Swagger UI를 통해 API를 탐색할 수 있습니다.

3. 도커를 사용한 배포

도커를 사용하면 FastAPI 서버의 배포를 간편하게 할 수 있습니다. 도커는 애플리케이션을 컨테이너 형태로 패키징하여 이식성과 관리성을 향상시키는 도구입니다.

3.1 도커 설치

도커를 설치하려면, 운영체제에 맞는 도커 설치 방법을 참조하여 설치합니다. 도커가 설치되면, 컨테이너를 쉽게 만들고 관리할 수 있는 환경을 갖추게 됩니다.

3.2 도커 파일 생성

FastAPI 애플리케이션을 도커로 배포하기 위해 도커 파일을 생성해야 합니다. 프로젝트 디렉토리에 Dockerfile이라는 이름의 파일을 생성하고 아래 내용을 추가합니다:

FROM python:3.9

# 작업 디렉토리 설정
WORKDIR /app

# 의존성 파일 복사
COPY requirements.txt .

# 의존성 설치
RUN pip install --no-cache-dir -r requirements.txt

# 애플리케이션 코드 복사
COPY . .

# Uvicorn으로 애플리케이션 실행
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

3.3 요구 사항 파일

또한, requirements.txt 파일을 생성하여 애플리케이션의 의존성을 명시해야 합니다. 아래는 contents of requirements.txt의 예시입니다:

fastapi
uvicorn

3.4 도커 이미지 빌드하기

도커 파일을 준비했으면 다음 명령어를 사용하여 도커 이미지를 빌드할 수 있습니다:

docker build -t fastapi-app .

이 명령은 현재 디렉토리 (.)에 있는 Dockerfile을 읽어 fastapi-app라는 이름의 이미지를 생성합니다.

3.5 도커 컨테이너 실행하기

이미지를 빌드한 후, 다음 명령어로 컨테이너를 실행할 수 있습니다:

docker run -d --name my-fastapi-app -p 80:80 fastapi-app

이 명령은 my-fastapi-app라는 이름으로 컨테이너를 백그라운드에서 실행하며, 호스트의 포트 80을 컨테이너의 포트 80에 매핑합니다.

4. 도커와 함께하는 FastAPI의 장점

FastAPI를 도커와 함께 사용하면 다음과 같은 장점이 있습니다:

• 이식성: 도커 컨테이너는 어떤 환경에서도 동일하게 실행됩니다.
• 관리 용이성: 의존성 문제를 해결할 수 있으며, 컨테이너 관리를 통해 배포 및 롤백이 간편합니다.
• 스케일링: 컨테이너를 쉽게 복제할 수 있으므로 수평 확장이 용이합니다.

5. 결론

FastAPI와 도커를 사용하여 웹 API를 개발하고 배포하는 과정은 매우 효율적입니다. FastAPI의 간결한 코드 작성법과 도커의 관리의 용이성을 결합하면 강력한 웹 애플리케이션을 쉽게 만들 수 있습니다.

이 강좌를 통해 FastAPI의 기본적인 사용법과 도커를 통한 배포 방법에 대해 이해할 수 있었기를 바랍니다. 다음 단계로는 FastAPI의 추가 기능이나 보안, 데이터베이스 연동 등을 탐색해보면 좋을 것입니다.