FastAPI서버개발 보관 - 21 중 14 번째 페이지

FastAPI 서버개발, 컨테이너 구동 Cloud Run 설정 및 실행

FastAPI는 현대적인 웹 API를 구축하는 데 유용한 프레임워크로, 비동기 Python 기능을 활용하여 성능을 극대화합니다. 이 글에서는 FastAPI를 사용하여 간단한 웹 애플리케이션을 개발하고, 이를 Google Cloud Run에 배포하는 과정을 자세히 설명합니다. Cloud Run은 컨테이너화를 통해 서버리스 방식의 애플리케이션 배포를 가능하게 하며, 매우 유연합니다.

1. FastAPI 설치 및 기본 서버 구축

FastAPI를 설치하고 기본 서버를 만드는 과정부터 시작하겠습니다. FastAPI는 Python 3.6 이상에서 사용할 수 있습니다. 다음 명령어를 통해 FastAPI를 설치하세요:

pip install fastapi uvicorn

이제 간단한 FastAPI 서버를 설정해보겠습니다.

1.1 FastAPI 서버 코드

from fastapi import FastAPI

app = FastAPI()

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

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

위 코드를 main.py라는 파일에 저장한 후, 다음 명령어로 서버를 실행합니다:

uvicorn main:app --reload

서버가 성공적으로 시작되면 http://127.0.0.1:8000에서 “Hello World” 메시지를 확인할 수 있습니다.

2. Docker로 FastAPI 애플리케이션 컨테이너화

이제 FastAPI 애플리케이션을 Docker 컨테이너로 패키징하는 방법을 알아보겠습니다. 먼저, Docker를 설치해야 합니다. 시스템에 맞는 Docker를 설치한 후, 다음 단계를 진행해주세요.

2.1 Dockerfile 작성

프로젝트 루트 디렉토리에 Dockerfile이라는 파일을 생성하고 다음 내용을 추가합니다:

FROM python:3.9

# 작업 디렉토리 생성
WORKDIR /app

# requirements.txt 복사
COPY requirements.txt .

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

# 앱 코드 복사
COPY . .

# Uvicorn으로 앱 실행
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

위의 Dockerfile에서는 Python 3.9 이미지를 기반으로 FastAPI 애플리케이션을 실행하도록 설정했습니다. 의존성을 설치하고, FastAPI 애플리케이션을 실행하는 Uvicorn을 명령어로 지정합니다.

2.2 requirements.txt 파일 작성

다음으로 requirements.txt 파일을 생성하여 FastAPI와 Uvicorn을 설치할 수 있도록 합니다. 이 파일의 내용은 다음과 같습니다:

fastapi
uvicorn

2.3 Docker 이미지 빌드 및 실행

Dockerfile과 requirements.txt 파일이 준비되었으면, 다음 명령어를 통해 Docker 이미지를 빌드합니다:

docker build -t fastapi-app .

빌드가 완료되면 아래의 명령어로 컨테이너를 실행합니다:

docker run -d -p 8080:8080 fastapi-app

이제 http://localhost:8080에서 FastAPI 애플리케이션을 확인할 수 있습니다.

3. Google Cloud Run에 배포

이제 우리의 FastAPI 애플리케이션을 Google Cloud Run에 배포해보겠습니다. 이를 위해 먼저 Google Cloud Console에 로그인하고 새로운 프로젝트를 생성합니다.

3.1 Google Cloud SDK 설치 및 초기화

Google Cloud SDK가 필요합니다. 아래의 명령어를 통해 설치하고 초기화합니다:

curl https://sdk.cloud.google.com | bash
gcloud init

초기화 과정에서 생성할 프로젝트를 선택하거나 새로 생성합니다.

3.2 Google Container Registry에 이미지 푸시

Google Cloud Run에 배포하기 전에 이미지를 Google Container Registry에 푸시해야 합니다. 다음 명령어를 실행합니다:

gcloud auth configure-docker

이후 이미지를 푸시하기 위한 태그를 설정합니다:

docker tag fastapi-app gcr.io/YOUR_PROJECT_ID/fastapi-app

설정한 태그로 이미지를 푸시합니다:

docker push gcr.io/YOUR_PROJECT_ID/fastapi-app

여기서 YOUR_PROJECT_ID 부분은 Google Cloud Console에서 확인할 수 있는 자신의 프로젝트 ID로 대체해야 합니다.

3.3 Cloud Run 서비스 생성

이제 Cloud Run에서 서비스를 생성할 수 있습니다. 다음 명령어를 실행하세요:

gcloud run deploy fastapi-app --image gcr.io/YOUR_PROJECT_ID/fastapi-app --platform managed --region us-central1 --allow-unauthenticated

배포가 완료되면 Cloud Run에서 생성된 URL을 통해 FastAPI 애플리케이션에 접근할 수 있습니다.

4. Cloud Run에서 FastAPI 애플리케이션 확인

Cloud Run에 배포한 FastAPI 애플리케이션을 브라우저에서 확인해보세요. 배포 후 제공되는 URL로 이동하면 “Hello World” 메시지를 확인할 수 있습니다. 또한, /items/{item_id} 엔드포인트도 동일하게 작동하는 것을 확인할 수 있습니다.

5. 마무리

FastAPI를 사용하여 간단한 웹 애플리케이션을 구축하고, 이를 Docker로 컨테이너화한 후 Google Cloud Run에 배포하는 방법을 살펴보았습니다. 이러한 흐름은 실제 개발에서 유용한 경험이 될 것입니다. 앞으로 더 복잡한 FastAPI 애플리케이션을 개발하면서 다양한 기능과 모듈을 적용해보면 좋겠습니다.

이 글이 FastAPI와 Cloud Run에 대한 이해를 돕는 데 도움이 되었길 바랍니다. 성공적인 개발을 기원합니다!

FastAPI 서버개발, docker compose 관련 파일 생성

최근 웹 애플리케이션 개발에서 FastAPI는 파이썬 기반의 비동기 웹 프레임워크로 많은 인기를 얻고 있습니다. 이 글에서는 FastAPI 서버 개발 과정과 함께 Docker Compose를 활용하여 개발 환경을 설정하고 배포할 수 있는 방법에 대해 상세히 설명하겠습니다.

FastAPI 소개

FastAPI는 Python 3.6 이상에서 동작하는 현대적인 웹 프레임워크로, 특히 비동기 프로그래밍을 지원합니다. 그 주요 특징으로는 다음과 같은 것들이 있습니다:

고속: 페이로드와 까다로운 요청을 처리하는 데 최적화되어 있습니다.
직관적: Python 타입 힌트를 사용하여 코드의 가독성을 높입니다.
자동화된 문서화: Swagger UI 및 ReDoc을 통해 API 문서를 자동 생성합니다.
비동기 지원: Async/Await를 활용하여 더 많은 동시 요청을 처리할 수 있습니다.

FastAPI 서버 설정하기

FastAPI를 사용하기 위해서 먼저 환경을 설정해야 합니다. 아래의 예제에서는 FastAPI를 설치하고 간단한 API 서버를 만드는 과정을 보여줍니다.

1. 가상 환경 설정

FastAPI 프로젝트를 위한 가상 환경을 설정합니다.

python -m venv venv
source venv/bin/activate  # 리눅스/macOS
venv\Scripts\activate     # 윈도우

2. FastAPI 및 Uvicorn 설치

FastAPI와 ASGI 서버인 Uvicorn을 설치합니다.

pip install fastapi uvicorn

3. 간단한 API 코드 작성

아래와 같은 구조의 main.py 파일을 생성합니다.

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, "q": q}

4. 서버 실행

다음 명령어로 FastAPI 서버를 실행합니다.

uvicorn main:app --reload

서버가 실행되면 http://127.0.0.1:8000/docs에서 자동 생성된 Swagger UI를 통해 API를 테스트할 수 있습니다.

Docker Compose를 이용한 FastAPI 서버 배포

Docker Compose를 이용하면 여러 서비스를 쉽게 관리할 수 있습니다. FastAPI 서버와 데이터베이스(MySQL)를 함께 설정할 수 있습니다.

1. Docker 및 Docker Compose 설치

Docker와 Docker Compose가 설치되어 있어야 합니다. 리눅스에서는 다음 명령어로 설치할 수 있습니다:

sudo apt-get update
sudo apt-get install docker docker-compose

2. Dockerfile 작성

프로젝트 루트 디렉토리에 Dockerfile을 생성합니다.

FROM python:3.9

# Set the working directory
WORKDIR /app

# Copy the requirements file
COPY requirements.txt .

# Install dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Copy the rest of the application code
COPY . .

# Expose the port the app runs on
EXPOSE 8000

# Command to run the application
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

3. requirements.txt 파일 생성

fastapi
uvicorn
mysql-connector-python

4. docker-compose.yml 파일 작성

다음으로 docker-compose.yml 파일을 작성합니다. 이 파일은 Docker Compose의 설정 파일입니다.

version: '3.8'

services:
  app:
    build: .
    ports:
      - "8000:8000"
    depends_on:
      - db
    environment:
      - DATABASE_URL=mysql://user:password@db:3306/db_name

  db:
    image: mysql:latest
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: rootpassword
      MYSQL_USER: user
      MYSQL_PASSWORD: password
      MYSQL_DATABASE: db_name

5. Docker Compose로 서비스 실행

아래 명령어로 Docker Compose를 실행하여 서비스들을 시작합니다.

docker-compose up --build

위 명령어를 실행하면 FastAPI 서버와 MySQL 데이터베이스가 컨테이너에서 실행됩니다. FastAPI는 http://localhost:8000에서 접근 가능합니다.

FastAPI와 MySQL 연동하기

이제 FastAPI와 MySQL을 연동하여 데이터를 저장하고 가져올 수 있는 API를 작성하겠습니다.

1. 데이터베이스 모델 정의

SQLAlchemy를 사용하여 데이터베이스 모델을 정의합니다. 먼저 SQLAlchemy와 MySQL 커넥터를 설치합니다.

pip install sqlalchemy pymysql

이제 models.py 파일을 생성하고 아래와 같은 코드를 작성합니다.

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

Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    
    id = Column(Integer, primary_key=True, index=True)
    name = Column(String(50))
    description = Column(String(255))

2. 데이터베이스 연결 설정

데이터베이스 연결을 위해 database.py 파일을 생성합니다.

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "mysql+pymysql://user:password@db:3306/db_name"

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

3. CRUD API 작성

FastAPI를 사용하여 CRUD(Create, Read, Update, Delete) API를 작성합니다. main.py 파일을 다음과 같이 업데이트합니다.

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

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

app = FastAPI()

# 의존성 주입을 통해 세션 생성
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/items/", response_model=Item)
async def create_item(item: Item, db: Session = Depends(get_db)):
    db.add(item)
    db.commit()
    db.refresh(item)
    return item

@app.get("/items/{item_id}", response_model=Item)
async def read_item(item_id: int, db: Session = Depends(get_db)):
    item = db.query(Item).filter(Item.id == item_id).first()
    if item is None:
        raise HTTPException(status_code=404, detail="Item not found")
    return item

@app.put("/items/{item_id}", response_model=Item)
async def update_item(item_id: int, item: Item, db: Session = Depends(get_db)):
    db_item = db.query(Item).filter(Item.id == item_id).first()
    if db_item is None:
        raise HTTPException(status_code=404, detail="Item not found")
    
    db_item.name = item.name
    db_item.description = item.description
    db.commit()
    db.refresh(db_item)
    return db_item

@app.delete("/items/{item_id}")
async def delete_item(item_id: int, db: Session = Depends(get_db)):
    db_item = db.query(Item).filter(Item.id == item_id).first()
    if db_item is None:
        raise HTTPException(status_code=404, detail="Item not found")
    
    db.delete(db_item)
    db.commit()
    return {"message": "Item deleted successfully"}

결론

이번 글에서는 FastAPI를 이용하여 간단한 API 서버를 구축하고, Docker Compose를 통해 개발 환경을 설정하는 방법을 배웠습니다. 또한 MySQL과의 연동을 통해 데이터를 관리하는 API를 작성하였습니다. FastAPI의 비동기 성능과 간결한 코드 작성을 통해 더 효율적인 웹 애플리케이션을 개발할 수 있습니다. Docker Compose를 이용하여 손쉽게 프로젝트를 배포하고 관리할 수 있어 개발자에게 유용한 도구입니다.

FastAPI와 Docker Compose를 이용한 개발은 현대적인 웹 개발을 추구하는 많은 인프라에서 필수적인 부분으로 자리잡고 있습니다. 앞으로 더 발전된 기능과 아키텍처를 활용하여 보다 혁신적인 애플리케이션을 만들어 나갈 수 있기를 기대합니다.

FastAPI 서버개발, WebSocket을 이용한 실시간 통신 구현

FastAPI는 현대적인 웹 API를 쉽게 구축할 수 있도록 설계된 파이썬 웹 프레임워크입니다. RESTful API뿐만 아니라 WebSocket을 이용한 실시간 통신 기능을 지원하는데, 이를 통해 클라이언트와 서버 간의 양방향 통신이 가능해집니다. 이번 글에서는 FastAPI를 사용하여 WebSocket을 통한 실시간 통신을 구현하는 방법에 대해 자세히 알아보겠습니다.

1. FastAPI 개요

FastAPI는 고성능 웹 서버를 구축하는 데 매우 효율적이며, 다음과 같은 주요 기능을 제공합니다.

비동기 프로그래밍 지원: 비동기 처리를 통해 더 많은 요청을 동시에 처리할 수 있습니다.
자동 문서화: Swagger UI와 ReDoc을 통해 자동으로 API 문서를 생성합니다.
Python 타입 힌트 활용: 타입 힌트를 통해 코드의 가독성과 유지보수성을 높입니다.

2. WebSocket이란?

WebSocket은 클라이언트와 서버 간의 전이중(Full-Duplex) 통신을 가능하게 하는 프로토콜입니다. HTTP와는 다르게, WebSocket을 사용하면 클라이언트가 서버에 요청하지 않고도 서버로부터 실시간 업데이트를 받을 수 있습니다. 이로 인해 채팅 응용 프로그램, 실시간 데이터 피드 등과 같은 다양한 애플리케이션에 적합합니다.

3. FastAPI 설치하기

FastAPI를 사용하려면 먼저 FastAPI와 ASGI 서버(Uvicorn)를 설치해야 합니다. 다음 명령어를 사용하여 설치할 수 있습니다:

pip install fastapi uvicorn

4. FastAPI WebSocket 예제

이제 FastAPI를 사용하여 간단한 WebSocket 서버를 구현해 보겠습니다. 이 예제에서는 클라이언트가 서버에 연결하고 메시지를 주고받는 기본적인 기능을 구현하겠습니다.

4.1 기본 WebSocket 서버 만들기

from fastapi import FastAPI, WebSocket
from fastapi.responses import HTMLResponse

app = FastAPI()

html = """




    
    
    WebSocket Chat


    WebSocket Chat
    

    
    

    


"""

@app.get("/")
async def get():
    return HTMLResponse(html)

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"메시지 수신: {data}")

4.2 코드 설명

위 코드는 FastAPI를 사용하여 WebSocket 서버를 구현한 것입니다.

FastAPI 모듈에서 FastAPI와 WebSocket를 가져옵니다.
html 변수에 클라이언트 측 HTML 코드를 저장합니다. 클라이언트는 이 HTML 코드를 통해 WebSocket 서버에 연결하고 메시지를 주고받을 수 있습니다.
get() 함수는 클라이언트의 GET 요청에 대해 HTML 페이지를 반환합니다.
websocket_endpoint() 함수는 WebSocket 요청을 처리합니다. 클라이언트가 연결할 때 await websocket.accept()로 연결을 승인하고, 이후 클라이언트로부터 메시지를 받으면 확인 메시지를 다시 전송합니다.

5. 웹소켓 서버 실행하기

서버 코드를 작성한 후, 다음 명령어로 FastAPI 서버를 실행합니다:

uvicorn main:app --reload

이 명령어에서 main은 Python 파일의 이름이고, app는 FastAPI 인스턴스입니다.

6. WebSocket 클라이언트 테스트하기

브라우저에서 http://localhost:8000를 방문하면 웹소켓 채팅 인터페이스가 나타납니다. 메시지를 입력한 후 “전송” 버튼을 누르면, 서버에서 수신한 메시지가 다시 클라이언트로 전송되고, 텍스트 영역에 표시됩니다.

7. WebSocket의 고급 기능 구현하기

이제 기본적인 WebSocket 구현에 대해 알아보았으므로, 다음 단계로는 여러 클라이언트가 동시에 연결하여 서로 메시지를 주고받을 수 있는 기능을 추가하겠습니다. 이를 위해 클라이언트 관리를 위한 리스트와 메시지 방송 기능을 구현하겠습니다.

7.1 여러 클라이언트를 위한 코드 수정

from fastapi import FastAPI, WebSocket
from fastapi.responses import HTMLResponse
from typing import List

app = FastAPI()
clients: List[WebSocket] = []

html = """




    
    
    WebSocket Chat


    WebSocket Chat
    

    
    

    


"""

@app.get("/")
async def get():
    return HTMLResponse(html)

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    clients.append(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            for client in clients:
                if client != websocket:  # 현재 클라이언트를 제외하고 메시지 전송
                    await client.send_text(f"전달된 메시지: {data}")
    except Exception as e:
        print("클라이언트가 연결을 종료했습니다.", e)
    finally:
        clients.remove(websocket)

7.2 추가된 기능 설명

위 코드에서는 클라이언트를 관리하는 clients 리스트를 추가하여 현재 연결된 모든 클라이언트를 저장합니다. 메시지를 수신하면, 모든 클라이언트에게 그 메시지를 전송하여 서로 간의 채팅이 가능하도록 합니다. 다음은 코드의 주요 변경 사항입니다:

클라이언트가 연결될 때 clients 리스트에 추가합니다.
서버는 모든 클라이언트에게 수신한 메시지를 전송하고, 현재 클라이언트를 제외합니다.
예외가 발생할 경우(예: 클라이언트 연결 종료) finally 블록에서 해당 클라이언트를 리스트에서 제거합니다.

8. 클라이언트 어플리케이션 만들기

지금까지의 설명을 통해 간단한 WebSocket 서버를 구현했습니다. 이제는 위의 예제를 바탕으로 프론트엔드와 백엔드를 통합한 클라이언트 어플리케이션을 만들어보겠습니다. React, Vue.js, 또는 Angular와 같은 프론트엔드 프레임워크를 사용할 수 있습니다.

8.1 React를 통한 WebSocket 클라이언트 구현하기

React를 사용하여 WebSocket 클라이언트를 만들어보겠습니다.

import React, { useState, useEffect } from 'react';

function App() {
    const [socket, setSocket] = useState(null);
    const [message, setMessage] = useState('');
    const [chat, setChat] = useState([]);

    useEffect(() => {
        const ws = new WebSocket('ws://localhost:8000/ws');
        ws.onmessage = (event) => {
            setChat((prevChat) => [...prevChat, event.data]);
        };
        setSocket(ws);

        return () => {
            ws.close();
        };
    }, []);

    const sendMessage = () => {
        if (socket) {
            socket.send(message);
            setMessage('');
        }
    };

    return (
        
            WebSocket Chat
            
            

             setMessage(e.target.value)}
                placeholder="메시지를 입력하세요..."
            />
            
        

    );
}

export default App;

9. 결론

이번 포스트를 통해 FastAPI를 사용하여 WebSocket을 통한 실시간 통신을 구현하는 방법에 대해 알아보았습니다. FastAPI의 장점을 살리면서, 비동기 방식으로 클라이언트와 서버 간의 실시간 소통을 구현할 수 있었습니다. 이러한 기술은 다양한 응용 분야에 활용될 수 있으며, 실시간 데이터 처리와 자극적인 UX를 제공하는 데 기여할 것입니다.

10. 참고 자료

FastAPI 서버개발, 컨테이너 이미지 업로드 ECR 이용하기

최근 들어 마이크로서비스 아키텍처가 인기를 끌면서 RESTful API를 이용한 서버 개발이 중요한 기술로 자리잡고 있습니다. FastAPI는 이러한 RESTful API를 쉽게 만들 수 있는 현대적인 웹 프레임워크로, 비동기 처리를 지원하며, 빠르게 성능을 최적화할 수 있는 장점이 있습니다. 본 강좌에서는 FastAPI를 사용하여 백엔드 서버를 개발하고 AWS Elastic Container Registry(ECR)를 이용하여 컨테이너 이미지를 업로드하는 방법을 상세히 설명하겠습니다.

1. FastAPI란?

FastAPI는 Python3.6 이상에서 사용할 수 있는 빠른 웹 프레임워크입니다. 높은 성능과 쉬운 사용법, 데이터 검증, Swagger UI 자동 생성을 제공하여 RESTful API를 효율적으로 구축할 수 있게 도와줍니다.

주요 특징:

비동기 프로그래밍 지원
데이터 유효성 검사 및 직렬화
자동 API 문서화
고성능: Starlette와 Pydantic 기반

2. FastAPI 환경 설정

FastAPI를 사용하기 위해서는 Python이 설치되어 있어야 하며, 다음과 같은 패키지를 설치해야 합니다.

pip install fastapi uvicorn boto3

이후 가장 간단한 FastAPI 애플리케이션을 생성하여 실행해 보겠습니다.

2.1 첫 번째 FastAPI 애플리케이션

from fastapi import FastAPI

app = FastAPI()

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

위 코드를 main.py라는 파일에 저장한 후, 서버를 실행해보세요.

uvicorn main:app --reload

브라우저에서 http://127.0.0.1:8000에 접속하면 “Hello, FastAPI!” 메시지를 확인할 수 있습니다.

3. ECR에 대해 알아보기

AWS Elastic Container Registry(ECR)는 Docker 이미지를 저장하고 관리할 수 있는 완전 관리형 컨테이너 레지스트리 서비스입니다. ECR은 이미지 배포와 버전 관리를 간단하게 할 수 있도록 도와줍니다.

3.1 ECR 설정하기

AWS Management Console에서 ECR 서비스로 이동합니다.
레지스트리를 생성합니다.
IAM 사용자에게 ECR 권한을 부여합니다.
레지스트리 URI를 복사합니다.

4. FastAPI 애플리케이션 Dockerize

이제 FastAPI 애플리케이션을 Docker 이미지로 패키징해보겠습니다. Dockerfile을 생성하고 아래와 같이 작성합니다.

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.9

COPY ./main.py /app/main.py

# 설치할 추가 패키지가 있다면 아래에 추가하세요.
RUN pip install -U pip
RUN pip install -U boto3

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

4.1 Docker 이미지 빌드하기

Docker 이미지를 빌드하려면 다음 명령어를 사용합니다.

docker build -t fastapi-app .

5. ECR에 Docker 이미지 푸시하기

ECR에 Docker 이미지를 업로드하기 위해서는 먼저 로그인해야 합니다. AWS CLI를 사용하여 인증을 수행할 수 있습니다.

aws ecr get-login-password --region YOUR_REGION | docker login --username AWS --password-stdin YOUR_AWS_ACCOUNT_ID.dkr.ecr.YOUR_REGION.amazonaws.com

이후 ECR에서 컨테이너 이미지를 푸시할 수 있습니다.

docker tag fastapi-app:latest YOUR_AWS_ACCOUNT_ID.dkr.ecr.YOUR_REGION.amazonaws.com/YOUR_REPOSITORY_NAME:latest

docker push YOUR_AWS_ACCOUNT_ID.dkr.ecr.YOUR_REGION.amazonaws.com/YOUR_REPOSITORY_NAME:latest

6. FastAPI와 ECR의 통합

이제 FastAPI로 구축한 백엔드 서버와 AWS ECR을 통한 이미지 업로드가 완료되었습니다. ECR에 푸시한 이미지를 기반으로 AWS 서비스와 통합하여 다양한 어플리케이션을 개발할 수 있습니다.

7. 마무리

이 강좌를 통해 FastAPI를 사용하여 RESTful API 서버를 개발하고, AWS Elastic Container Registry를 통해 Docker 이미지를 업로드하는 방법을 알게 되었습니다. FastAPI의 사용법과 AWS의 다양한 기능을 활용하여 실제로 동작하는 어플리케이션을 구축해 보세요. 추가적인 질문이나 피드백이 있으면 댓글로 남겨주시기 바랍니다. 감사합니다!

FastAPI 서버개발, 실시간 채팅 애플리케이션 개발하기

최근 몇 년간 웹 애플리케이션 개발에서 실시간 통신의 필요성이 증가하면서 WebSocket을 통한 실시간 애플리케이션의 개발이 주목받고 있습니다. FastAPI는 Python으로 만들어진 현대적인 웹 프레임워크로, 고성능 비동기 프로그래밍을 지원하여 실시간 채팅 애플리케이션 개발에 적합합니다. 본 글에서는 FastAPI를 활용하여 실시간 채팅 애플리케이션을 만드는 방법을 단계별로 설명하겠습니다.

1. FastAPI란?

FastAPI는 Python 3.6 이상에서 사용할 수 있는 웹 프레임워크로, RESTful API를 신속하게 구축할 수 있도록 도와줍니다. FastAPI는 다음과 같은 주요 특징이 있습니다:

고속성: Starlette를 기반으로 하고 있어 비동기 프로그래밍이 가능합니다.
자동화된 API 문서화: OpenAPI 스펙을 기반으로 자동화된 Swagger UI와 ReDoc 문서가 생성됩니다.
타입 힌트 지원: Python의 타입 힌트를 활용하여 오류를 사전에 방지하고, 가독성을 높입니다.

2. 개발 환경 설정

실시간 채팅 애플리케이션을 개발하기 위해서 먼저 개발 환경을 설정합니다. Python 3.x가 설치되어 있다고 가정하고, 필요한 패키지를 설치합니다.

pip install fastapi uvicorn websockets

3. FastAPI 애플리케이션 구조

프로젝트 디렉토리를 생성하고 기본 구조를 설정합니다.

mkdir fastapi_chat
cd fastapi_chat
touch main.py

main.py 파일 작성

이제 main.py 파일에 FastAPI 애플리케이션과 WebSocket 핸들러를 작성하겠습니다.

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.responses import HTMLResponse

app = FastAPI()

# HTML 페이지를 반환하는 API
@app.get("/")
async def get():
    return HTMLResponse(content="""
    
        
            Chat Application
        
        
            Chat Application
            
            
            
            
        
    
    """)

# WebSocket 핸들러
connections = []

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    connections.append(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            # 연결된 모든 클라이언트에게 메시지를 broadcast
            for connection in connections:
                await connection.send_text(data)
    except WebSocketDisconnect:
        connections.remove(websocket)

4. 코드 설명

위 코드는 FastAPI를 사용하여 기본적인 웹소켓 서버와 HTML 클라이언트를 구현한 것입니다. 간단히 설명해보겠습니다:

FastAPI 인스턴스: 애플리케이션 객체를 생성합니다.
HTML 반환: get 함수는 클라이언트에게 HTML 페이지를 반환합니다.
WebSocket 핸들러: /ws 엔드포인트는 클라이언트와의 실시간 연결을 관리합니다.
메시지 브로드캐스트: 클라이언트가 서버에 메시지를 보낼 때, 연결된 모든 클라이언트에게 메시지를 전송합니다.

5. 애플리케이션 실행

애플리케이션을 실행하기 위해 터미널에서 다음 명령어를 입력합니다.

uvicorn main:app --reload

이제 브라우저에서 http://localhost:8000에 접속하면 채팅 애플리케이션이 열립니다. 여러 개의 브라우저 탭을 열고 메시지를 보내보세요. 모든 탭에서 메시지가 실시간으로 표시되는 것을 확인할 수 있습니다.

6. 추가 기능 구현

기본적인 채팅 기능 외에도 여러 가지 기능을 추가할 수 있습니다. 예를 들어 사용자 이름, 메시지 이력 저장, 그리고 사용자별로 메시지 필터링 등을 구현할 수 있습니다.

6.1 사용자 이름 기능 추가

사용자가 채팅에 참여할 때 사용자 이름을 입력하게 할 수 있습니다. HTML 코드에 사용자 이름 입력란을 추가하고, 메시지를 전송할 때 이 사용자 이름을 포함시켜 보겠습니다.

HTMLResponse(content="""

    
        Chat Application
    
    
        Chat Application
        
        
        
        
        
    

""")

6.2 메시지 이력 저장

서버에서 전송된 메시지를 저장하여 사용자가 페이지를 새로고침 해도 이전 메시지를 볼 수 있도록 만들 수 있습니다. 이를 위해 메모리 내 저장소를 사용할 수 있는데, 더 나아가 데이터베이스 연결도 고려할 수 있습니다. 간단하게 메시지 리스트를 추가하고, 클라이언트가 연결할 때 이 메시지를 전송하는 방법을 구현해 보겠습니다.

messages = []

async def broadcast_message(message: str):
    messages.append(message)
    for connection in connections:
        await connection.send_text(message)

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    connections.append(websocket)
    try:
        # 기존 메시지를 클라이언트에 전송
        for message in messages:
            await websocket.send_text(message)
        while True:
            data = await websocket.receive_text()
            await broadcast_message(data)
    except WebSocketDisconnect:
        connections.remove(websocket)

7. 마무리

이번 글에서는 FastAPI를 사용하여 실시간 채팅 애플리케이션을 개발하는 방법에 대해 알아보았습니다. FastAPI의 비동기 기능을 활용하여 고성능의 실시간 웹 소켓 서버를 구축하고 클라이언트와의 안정적인 연결을 유지하는 법을 배웠습니다.

FastAPI는 강력하면서도 간단한 API 개발 도구로, 다양한 기능들을 확장하여 더욱 복잡한 애플리케이션을 구축할 수 있습니다. 추가적으로 데이터베이스와의 연결, 사용자 인증 및 인가, 그리고 서드파티 API와의 통합 등을 통해 발전시키기 바랍니다.

FastAPI를 통해 여러분의 아이디어를 실현해보세요! 학습과 경험을 통해 더욱 많은 애플리케이션을 개발할 수 있을 것입니다.

감사합니다.