[작성자:] root

FastAPI 서버개발, FastAPI에서 CORS 설정하기

날짜:

작성자: AI 기술지원팀

서론

FastAPI는 Python으로 웹 API를 만들기 위한 현대적이고 뛰어난 성능을 가진 웹 프레임워크입니다. Python의 비동기 기능을 활용하여 빠르고 효율적인 서버를 구축할 수 있습니다. 또한 FastAPI는 Swagger UI와 ReDoc을 통한 자동 문서화 기능을 제공하여 API 개발을 용이하게 합니다. 이런 혜택 덕분에 FastAPI는 현재 많은 개발자들 사이에서 인기를 끌고 있는 웹 프레임워크가 되었습니다.

이 글에서는 FastAPI에서 CORS(Cross-Origin Resource Sharing) 설정의 중요성과 구체적인 방법에 대해 탐구해 보겠습니다.

CORS란 무엇인가?

CORS는 Cross-Origin Resource Sharing의 약어로, 웹 애플리케이션이 서로 다른 출처의 리소스에 접근할 수 있게 허용하는 메커니즘입니다. 예를 들어, 클라이언트가 http://example.com에서 호스팅되는 웹 애플리케이션이라고 할 때, http://api.example.com에서 제공하는 API에 접근할 필요가 있다면 CORS가 필요합니다.

브라우저는 보안상의 이유로 한 출처에서 로드된 웹 페이지가 다른 출처의 리소스에 접근하는 것을 기본적으로 제한합니다. 이러한 제한을 우회하기 위해 CORS 설정이 필요합니다.

FastAPI에서 CORS 설정하기

FastAPI에서는 fastapi.middleware.cors 모듈을 통해 CORS 설정을 간편하게 할 수 있습니다. CORS 미들웨어를 사용하여 특정 도메인에서 오는 요청을 허용하거나 차단할 수 있습니다.

FastAPI에서 CORS를 설정하기 위해서는 다음 두 가지 단계를 수행해야 합니다.

  1. CORS 미들웨어 설치: CORS 미들웨어가 설치되어 있어야 합니다. FastAPI는 CORS 미들웨어를 기본적으로 제공하고 있습니다.
  2. CORS 미들웨어 적용: FastAPI 애플리케이션 인스턴스에 CORS 미들웨어를 추가합니다.

1. CORS 미들웨어 설치

FastAPI를 사용하려면 먼저 FastAPI와 관련 패키지를 설치해야 합니다. 아래의 명령어를 통해 FastAPI와 Uvicorn(ASGI 서버)를 설치할 수 있습니다:

pip install fastapi uvicorn

2. CORS 미들웨어 적용 예제

이제 FastAPI 애플리케이션을 생성하고 CORS 미들웨어를 적용하는 예제를 살펴보겠습니다:

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# CORS 설정
origins = [
    "https://example.com",  # 특정 도메인
    "http://localhost:8000"  # 로컬 개발용
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,  # 허용할 도메인 목록
    allow_credentials=True,
    allow_methods=["GET", "POST", "PUT", "DELETE"],  # 허용할 HTTP 메서드
    allow_headers=["*"],  # 허용할 헤더
)

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

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

코드 설명

위 코드를 활용하여 FastAPI 애플리케이션을 설정합니다:

  • from fastapi import FastAPI: FastAPI 인스턴스를 생성하기 위한 모듈을 가져옵니다.
  • from fastapi.middleware.cors import CORSMiddleware: CORS 미들웨어를 가져옵니다.
  • origins: 이 리스트에는 허용할 도메인을 추가합니다. 개발 중에는 로컬 호스트와 같은 URL도 포함될 수 있습니다.
  • app.add_middleware: FastAPI 애플리케이션에 CORS 미들웨어를 추가합니다. 여기에 정의된 매개변수들은 CORS 동작을 정의합니다.
  • allow_credentials=True: 이 설정을 사용하면 고객 인증정보를 포함한 요청이 허용됩니다.
  • allow_methods: 이 리스트에는 허용할 HTTP 메서드(GET, POST, PUT, DELETE 등)를 정의합니다.
  • allow_headers=["*"]: 모든 요청 헤더를 허용합니다. 필요에 따라 구체적으로 정의할 수도 있습니다.
  • @app.get("/"): 루트 경로에 대한 GET 요청을 처리하는 엔드포인트입니다.
  • uvicorn.run(app, host="0.0.0.0", port=8000): Uvicorn을 통해 서버를 시작합니다.

3. CORS의 중요성

CORS는 여러 사용 사례에서 중요하게 작용합니다. 특히, 프런트엔드 개발 및 API 제공 시 웹 애플리케이션이 서로 다른 출처에서 데이터와 리소스를 공유할 수 있도록 돕습니다. 다음은 CORS가 필요한 몇 가지 주요 이유입니다:

  • 보안: CORS는 웹 애플리케이션이 잠재적으로 악의적인 요청으로부터 보호받을 수 있도록 도와줍니다.
  • 상호 운영성: 서로 다른 도메인 간에 API를 호출할 수 있어 서비스 간의 상호 작용을 가능하게 합니다.
  • 유연성: 다양한 클라이언트 애플리케이션(웹, 모바일 등)에서 API에 접근할 수 있도록 허용합니다.

4. CORS 관련 오류 처리

CORS 설정이 올바르지 않거나 허용되지 않는 출처에서 요청이 들어오는 경우 브라우저에서는 CORS 관련 오류 메시지를 표시합니다. 일반적인 오류와 그 해결 방법은 다음과 같습니다:

  • Access-Control-Allow-Origin 오류: 이 오류는 서버에서 요청한 출처를 허용하지 않을 때 발생합니다. CORS 미들웨어 설정에서 허용할 출처를 올바로 설정했는지 확인합니다.
  • Preflight 요청 오류: 특정 HTTP 메서드(예: PUT, DELETE 등)를 사용할 때 발생할 수 있습니다. 이러한 경우에는 서버가 OPTIONS 메서드에 대한 요청을 처리할 수 있도록 설정해야 합니다.

5. 다양한 CORS 설정하기

CORS 설정은 비즈니스 요구 사항에 따라 다양하게 구성할 수 있습니다. 일반적으로 다음과 같은 옵션을 설정할 수 있습니다:

  • 부분적 허용: 특정 도메인만 허용하려면 allow_origins에 해당 도메인만 추가합니다.
  • 모든 도메인 허용: 모든 도메인에서 요청을 허용하려면 allow_origins=["*"]로 설정합니다. 하지만, 보안상의 이유로 권장되지 않습니다.
  • 동적 허용: 요청 헤더를 기반으로 CORS 설정을 동적으로 처리할 수 있습니다. 이 경우, 요청의 출처를 확인하여 동적으로 허용 여부를 결정할 수 있습니다.

결론

FastAPI는 CORS 설정을 간단하게 처리할 수 있는 강력한 도구를 제공하여, 프런트엔드와 백엔드 간의 원활한 통신을 가능하게 합니다. 적절한 CORS 설정은 보안, 유연성 및 서비스 간의 상호 작용을 보장하는 데 필수적입니다. 따라서 FastAPI로 웹 서비스를 개발할 때 CORS 설정을 주의 깊게 다루어야 합니다.

이 글을 통해 FastAPI에서 CORS 설정을 간편하게 진행할 수 있는 방법을 배우셨기를 바랍니다. FastAPI를 사용하여 더욱 안전하고 효율적인 웹 애플리케이션을 개발해 보세요!

이 글이 도움이 되었다면 댓글로 의견을 남겨 주세요!

FastAPI 서버개발, React, Vue.js 또는 Angular와 FastAPI 통합하기

이 글에서는 FastAPI를 이용하여 효율적인 백엔드 서버를 개발하고, 이를 React, Vue.js 또는 Angular와 통합하는 방법에 대해 자세히 알아보겠습니다. FastAPI는 Python 기반의 현대적인 웹 프레임워크로, 고성능 API를 쉽게 구축할 수 있게 해줍니다. 이를 통해 클라이언트-서버 구조의 웹 애플리케이션을 구성하는 예제와 함께 설명드리겠습니다.

1. FastAPI 소개

FastAPI는 Starlette 기반으로 구축된 웹 프레임워크입니다. 비동기식 프로그래밍을 지원하며, 매우 높은 성능과 자동 문서화 기능을 제공합니다. 기본적 구조는 간단하며, 짧은 코드로 서버를 구축할 수 있습니다.

  • 비동기 요청 처리: FastAPI는 async/await 구문을 통해 비동기 처리를 쉽게 구현할 수 있습니다.
  • 자동 문서화: OpenAPI 및 JSON Schema를 기반으로 한 API 문서화가 자동으로 이루어집니다.
  • 타입 힌트 지원: Python의 타입 힌트를 활용하여 코드의 가독성과 유지 보수성을 높일 수 있습니다.

FastAPI 설치하기

pip install fastapi uvicorn

2. 기본 FastAPI 서버 구축하기

다음 예제는 기본적인 FastAPI 서버를 구축하는 방법을 보여줍니다. 웹 서버를 통해 간단한 ‘Hello World’ API를 만들어보겠습니다.

from fastapi import FastAPI

app = FastAPI()

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

위의 코드를 저장한 후, 다음 명령어로 서버를 실행할 수 있습니다:

uvicorn main:app --reload

localhost:8000에서 ‘Hello, World’ 메시지를 확인할 수 있습니다. 또한, http://localhost:8000/docs를 방문하면 Swagger UI를 통해 API 문서를 확인할 수 있습니다.

3. 데이터 모델링

FastAPI는 Pydantic을 사용하여 데이터 모델을 정의하고 검증할 수 있습니다. 다음은 사용자 정보를 처리하기 위한 사용자 모델을 정의하는 예제입니다.

from pydantic import BaseModel

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

이제 이 모델을 사용하여 사용자 정보를 받는 API를 생성해 보겠습니다.

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

위 코드를 통해 POST 요청으로 사용자 정보를 받아 JSON 형태로 응답합니다.

4. FastAPI와 React 통합하기

React는 페이지 기반의 사용자 인터페이스를 구축할 수 있는 JavaScript 라이브러리입니다. FastAPI와 React를 통합하여 클라이언트와 서버 간의 데이터를 주고받는 방법을 설명하겠습니다.

React 설치하기

React 프로젝트를 생성하기 위해 Create React App를 사용할 수 있습니다. 다음 명령어로 프로젝트를 생성합니다.

npx create-react-app my-app

API 호출하기

React를 사용하여 FastAPI 서버에 API 요청을 보내고 응답을 처리하는 방법은 다음과 같습니다.

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

function App() {
    const [user, setUser] = useState(null);

    const createUser = async () => {
        const response = await fetch('http://localhost:8000/users/', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({ id: 1, name: 'John Doe', email: 'john@example.com' }),
        });
        const data = await response.json();
        setUser(data);
    };

    return (
        

            
FastAPI와 React 통합 예제

            
            {user && 
{JSON.stringify(user, null, 2)}


}
        


    );

}


export default App;


위의 코드에서 버튼을 클릭하면 FastAPI 서버에 사용자 정보가 전송되고, 응답으로 받은 JSON 데이터가 화면에 출력됩니다.


5. FastAPI와 Vue.js 통합하기


Vue.js는 또 다른 인기 있는 프론트엔드 프레임워크로, FastAPI와 함께 사용할 수 있습니다.


Vue.js 설치하기


Vue CLI를 사용하여 새로운 Vue.js 프로젝트를 생성합니다. 다음 명령어로 프로젝트를 생성하세요.


vue create my-vue-app


API 호출하기


Vue.js에서 FastAPI로 POST 요청을 보내는 방법은 다음과 같습니다.


<template>
  <div>
    <h1>FastAPI와 Vue.js 통합 예제</h1>
    <button @click="createUser">사용자 생성</button>
    <pre v-if="user">{{ user }}</pre>
  </div>
</template>

<script>
export default {
  data() {
    return {
      user: null,
    };
  },
  methods: {
    async createUser() {
      const response = await fetch('http://localhost:8000/users/', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({ id: 1, name: 'Jane Doe', email: 'jane@example.com' }),
      });
      this.user = await response.json();
    },
  },
};
</script>


위 코드를 적용하고 버튼을 클릭하여 사용자 정보를 생성하면 FastAPI 서버에 POST 요청이 이루어집니다.


6. FastAPI와 Angular 통합하기


Angular는 또 다른 강력한 프론트엔드 프레임워크로, FastAPI와 통합하여 SPA(Single Page Application)을 만들 수 있습니다.


Angular 설치하기


Angular CLI를 사용하여 새로운 Angular 프로젝트를 생성합니다.


ng new my-angular-app


API 호출하기


Angular에서 FastAPI로 데이터를 전송하는 예시는 다음과 같습니다.


import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  template: `
    
FastAPI와 Angular 통합 예제

    
    
{{ user | json }}


  `,

})

export class AppComponent {

  user: any;


  async createUser() {

    const response = await fetch('http://localhost:8000/users/', {

      method: 'POST',

      headers: {

        'Content-Type': 'application/json',

      },

      body: JSON.stringify({ id: 1, name: 'Chris Doe', email: 'chris@example.com' }),

    });

    this.user = await response.json();

  }

}




위 코드를 통해 Angular 애플리케이션에서 FastAPI 서버에 사용자가 생성되는 요청을 보낼 수 있습니다.


7. 결론


이 글에서는 FastAPI를 이용하여 기본적인 백엔드 서버를 구축하고, React, Vue.js, Angular와 통합하는 방법을 알아보았습니다. FastAPI는 빠르고 효율적인 웹 API 개발을 가능하게 하며, 다양한 프론트엔드 프레임워크와 쉽게 통합할 수 있는 장점을 가지고 있습니다. 이번 강좌를 통해 FastAPI와 클라이언트 측 프레임워크 간의 상호작용을 이해하고, 응용 프로그램의 아키텍처 설계에 대한 통찰을 얻으시길 바랍니다.

FastAPI 서버개발, Jinja, 반복문

FastAPI는 웹 API 개발을 위해 설계된 현대적이고 빠른 프레임워크로, Python으로 작성되어 있으며 Starlette와 Pydantic을 기반으로 하고 있습니다. FastAPI는 비동기 프로그래밍을 지원하여 높은 성능을 자랑하며, 코드 작성 시 자동으로 OpenAPI와 JSON Schema를 생성해줍니다. 이번 글에서는 FastAPI 서버 개발 방법을 다루고, Jinja 템플릿 언어를 사용하여 HTML을 구성하는 방법을 설명하겠습니다. 또한, 반복문을 활용하여 동적으로 HTML 콘텐츠를 생성하는 방법을 함께 알아보겠습니다.

1. FastAPI 소개

FastAPI는 Python 3.6 이상에서 사용할 수 있는 웹 프레임워크로, RESTful API를 간편하게 구축할 수 있게 해줍니다. FastAPI의 가장 큰 특징은 다음과 같습니다.

  • 비동기 지원: FastAPI는 async/await 구문을 지원하여 비동기 요청을 처리할 수 있습니다.
  • 자동 문서화: 작성한 API에 대해 자동으로 OpenAPI 문서를 생성합니다.
  • 데이터 검증: Pydantic을 사용하여 API 요청 및 응답 데이터의 검증이 용이합니다.

2. FastAPI 설치

FastAPI를 설치하기 위해서는 Python이 설치되어 있어야 하며, 다음과 같은 명령어를 사용하여 설치할 수 있습니다. 

pip install fastapi uvicorn

3. FastAPI 기본 설정

FastAPI를 처음 설정해보겠습니다. 아래는 기본적인 FastAPI 서버의 예제입니다. 

from fastapi import FastAPI

app = FastAPI()

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

위의 코드는 FastAPI 서버를 생성하고, 루트 경로(“/”)에 GET 요청이 들어오면 “Hello, World”라는 JSON 응답을 생성합니다. 이 코드를 실행하기 위해서는 다음 명령어를 사용합니다. 

uvicorn main:app --reload

여기서 “main”은 Python 파일의 이름이며, “app”은 FastAPI 인스턴스 이름입니다. –reload 플래그를 사용하면 코드 변경 시 자동으로 서버를 재시작합니다.

4. Jinja 템플릿 소개

Jinja는 Python 웹 프레임워크에서 널리 사용되는 템플릿 엔진입니다. Jinja를 사용하면 HTML 파일과 Python 코드를 분리하여 웹 애플리케이션의 관리 및 유지보수를 용이하게 할 수 있습니다. FastAPI는 Jinja를 통해 HTML 템플릿을 렌더링할 수 있습니다.

5. FastAPI에서 Jinja 사용하기

FastAPI에서 Jinja를 사용하기 위해 먼저 Jinja2를 설치해야 합니다. 

pip install jinja2

다음으로, Jinja 템플릿을 사용하기 위한 FastAPI의 기본 설정을 살펴보겠습니다. 


from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates

app = FastAPI()

templates = Jinja2Templates(directory="templates")

@app.get("/", response_class=HTMLResponse)
async def read_root(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

여기서 “templates”라는 디렉토리를 생성하고 그 안에 “index.html” 파일을 만들어야 합니다. “TemplateResponse”를 사용하여 Jinja 템플릿을 렌더링하고 있습니다.

6. Jinja 템플릿에 반복문 사용하기

Jinja에서는 Python의 리스트나 딕셔너리와 같은 iterable 객체를 쉽게 반복할 수 있는 기능을 제공합니다. 아래는 Python 리스트를 반복하여 HTML 리스트를 생성하는 예제입니다. 


@app.get("/items/", response_class=HTMLResponse)
async def read_items(request: Request):
    items = ["Apple", "Banana", "Cherry"]
    return templates.TemplateResponse("items.html", {"request": request, "items": items})

위 코드에서 “items” 리스트를 FastAPI 경로(“/items/”)에 대한 GET 요청에 대한 응답으로 HTML 템플릿에 전달합니다. 이제 “items.html” 파일을 생성하여 Jinja 반복문을 사용하여 리스트 항목을 출력해보겠습니다. 






    
    Items List


    
과일 목록

    
    
        {% for item in items %}
            
  • {{ item }}
    • 
        {% endfor %}

위의 “items.html” 파일에서 Jinja의 {% for %} 구문을 사용하여 “items” 리스트의 각 항목을 반복하여 출력하고 있습니다. 이를 통해 웹 페이지에 동적으로 HTML 콘텐츠를 생성할 수 있습니다.

7. Jinja의 조건문 사용하기

반복문과 함께 Jinja에서는 조건문도 사용할 수 있습니다. 예를 들어, 과일 목록에서 특정 조건에 따라 다른 내용을 출력하도록 설정할 수 있습니다. 






    
    Items List


    
과일 목록

    
    
        {% for item in items %}
            
  • {{ item }}
    • 
            {% if item == "Banana" %}
                (이것은 바나나입니다!)
            {% endif %}
        {% endfor %}

위의 예제에서는 “item”이 “Banana”일 때, 추가 메시지를 출력하도록 설정하였습니다. Jinja의 조건문을 통해 HTML 템플릿 내에서 동적인 콘텐츠를 쉽게 제어할 수 있습니다.

8. FastAPI와 Jinja를 활용한 전체 예제

지금까지 배운 내용을 바탕으로 FastAPI와 Jinja를 활용한 전체 예제를 만들어 보겠습니다. 프로젝트 폴더 구조는 다음과 같습니다. 


project/
│
├── main.py
└── templates/
    ├── index.html
    └── items.html

이제 “main.py” 파일에 전체 코드를 작성해보겠습니다. 


from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates

app = FastAPI()
templates = Jinja2Templates(directory="templates")

@app.get("/", response_class=HTMLResponse)
async def read_root(request: Request):
    return templates.TemplateResponse("index.html", {"request": request})

@app.get("/items/", response_class=HTMLResponse)
async def read_items(request: Request):
    items = ["Apple", "Banana", "Cherry"]
    return templates.TemplateResponse("items.html", {"request": request, "items": items})

이제 “index.html” 파일과 “items.html” 파일은 이전에 설명한 내용과 동일하게 작성하십시오. FastAPI 서버를 실행한 후, “/” 경로에 접속하여 메인 페이지를 확인하고 “/items/” 경로에 접속하여 과일 목록을 볼 수 있습니다.

9. 결론

이번 강좌에서는 FastAPI를 사용하여 웹 API를 개발하는 방법과 Jinja 템플릿을 통해 HTML을 동적으로 생성하는 방법, 그리고 반복문과 조건문을 활용하여 보다 복잡한 UI를 구성하는 방법을 배웠습니다. FastAPI의 매력은 그 간결함과 비동기 처리 능력, 그리고 자동 문서화 기능에 있습니다. 앞으로 FastAPI와 Jinja를 활용하여 더욱 다양한 웹 애플리케이션을 개발해보시길 바랍니다.

10. 다음 단계

더 나아가 FastAPI의 고급 기능인 유저 인증, 데이터베이스 통합, 비동기 작업 등을 학습하여 실무에 적용할 수 있는 방향으로 발전시켜 보십시오. FastAPI의 공식 문서도 참고하시면 많은 도움이 될 것입니다.

© 2023 Your Name. All rights reserved.

FastAPI 서버개발, Docker 동작 확인

FastAPI는 현대적인 웹 애플리케이션 및 API 개발에 적합한 Python 프레임워크입니다. 그 주요 장점은 높은 성능과 직관적인 사용성입니다. 이번 글에서는 FastAPI를 이용한 기본적인 백엔드 서버 개발 방법과 Docker를 이용한 환경 구성 및 동작 확인 절차에 대해 자세히 설명하겠습니다.

1. FastAPI 개요

FastAPI는 ASGI(Asynchronous Server Gateway Interface)를 기반으로 하며, 비동기 프로그래밍을 지원합니다. 또한 FastAPI는 Python의 타입 힌트를 적극적으로 활용하여, 개발자가 코드를 작성하는 동시에 API 문서를 자동 생성할 수 있습니다. FastAPI의 주요 특징은 다음과 같습니다.

  • 고속 성능: FastAPI는 Starlette와 Pydantic을 기반으로 하여, 비동기 지원으로 매우 높은 성능을 제공합니다.
  • 자동 API 문서화: Swagger UI 및 ReDoc을 통해 API 문서를 자동으로 생성할 수 있습니다.
  • 데이터 검증: Pydantic을 사용하여 요청 데이터에 대한 검증을 손쉽게 수행할 수 있습니다.

2. FastAPI 서버 구축하기

2.1 FastAPI 설치

FastAPI와 Uvicorn(Web 서버)을 설치해보겠습니다. 아래 명령어를 통해 설치할 수 있습니다. 

        
        pip install fastapi uvicorn

2.2 기본 FastAPI 애플리케이션

FastAPI 애플리케이션을 시작해보겠습니다. 아래 코드를 “main.py” 파일에 작성합니다. 

        
        from fastapi import FastAPI

        app = FastAPI()

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

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

위 코드는 FastAPI 애플리케이션을 정의하는 기본 구조입니다. 우리는 “/” 경로로 GET 요청을 보내면 “Hello”: “World”라는 JSON 응답을 받게 됩니다.

2.3 FastAPI 실행하기

FastAPI 서버를 실행하려면 아래 명령어를 터미널에서 실행합니다. 

        
        python main.py

서버가 정상적으로 실행되면 http://127.0.0.1:8000/docs에 접속하여 Swagger UI를 통해 API 문서를 확인할 수 있습니다.

3. Docker를 이용한 FastAPI 배포

3.1 Docker 설치 확인

Docker가 설치되어 있지 않다면, Docker의 공식 웹사이트에서 다운로드하여 설치합니다. 설치가 완료되면 아래 명령어를 통해 Docker가 정상적으로 설치되었는지 확인할 수 있습니다. 

        
        docker --version

3.2 Dockerfile 작성하기

Dockerfile은 Docker 이미지를 생성하기 위한 스크립트입니다. 아래 내용을 기반으로 “Dockerfile”을 작성합니다. 

        
        # 베이스 이미지 설정
        FROM python:3.9

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

        # requirements.txt를 컨테이너로 복사
        COPY requirements.txt .

        # 종속성 설치
        RUN pip install --no-cache-dir -r requirements.txt

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

        # FastAPI 서버 실행
        CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

위 Dockerfile에서는 Python 3.9를 베이스 이미지로 사용하고, 작업 디렉토리를 “/app”으로 설정했습니다. 이후 requirements.txt를 통해 패키지를 설치하고, 애플리케이션 코드를 복사합니다.

3.3 requirements.txt 작성하기

FastAPI와 Uvicorn 패키지를 관리하기 위한 “requirements.txt” 파일을 생성합니다. 아래 내용을 입력합니다. 

        
        fastapi
        uvicorn

3.4 Docker 이미지 빌드하기

Dockerfile과 requirements.txt가 준비되었으면, Docker 이미지를 빌드할 수 있습니다. 아래 명령어를 터미널에서 실행합니다. 

        
        docker build -t fastapi-app .

3.5 Docker 컨테이너 실행하기

다음으로 Docker 컨테이너를 실행하여 FastAPI 애플리케이션을 확인합니다. 아래 명령어를 사용합니다. 

        
        docker run -d --name fastapi-container -p 8000:8000 fastapi-app

이제 http://127.0.0.1:8000/docs에 접속하여 Docker 내에서 실행 중인 FastAPI 서버의 Swagger UI를 확인할 수 있습니다.

4. 결론

이번 글에서는 FastAPI를 사용하여 기본적인 웹 애플리케이션을 구축하고 Docker를 통해 이를 배포하는 방법을 소개했습니다. FastAPI는 비동기 성공을 지원하며, 효율적인 API 개발을 가능하게 합니다. Docker를 이용한 배포는 애플리케이션 환경의 일관성을 보장하며, 손쉽게 배포할 수 있게 해줍니다. FastAPI와 Docker를 이용하여 신속하게 API 서버를 개발하시길 바랍니다.

5. 참고자료

© 2023 FastAPI 블로그 포스트

FastAPI 서버개발, 경로 동작 함수 만들기

FastAPI는 Python으로 작성된 현대적이고 빠른 웹 프레임워크로, API 서버 개발에 매우 유용합니다. 이 글에서는 FastAPI를 사용하여 경로 동작 함수를 만드는 방법에 대해 상세히 알아보겠습니다. 이 강좌는 FastAPI를 처음 접하는 개발자뿐만 아니라 경로와 동작 함수 작성을 개선하고자 하는 개발자에게도 유익할 것입니다.

1. FastAPI 소개

FastAPI는 Starlette(비동기 웹 프레임워크)와 Pydantic(데이터 유효성 검사 및 설정 관리)을 기반으로 구축되었습니다. 주로 RESTful API를 구축하는 데 사용되며, 다음과 같은 장점이 있습니다:

  • 성능: FastAPI는 매우 빠르며, Python의 비동기 기능을 통해 높은 성능을 제공합니다.
  • 유효성 검사: Pydantic을 통해 요청 및 응답에 대한 엄격한 데이터 유효성 검사를 수행할 수 있습니다.
  • 즉각적인 문서화: Swagger UI와 ReDoc을 사용하여 자동으로 API 문서 생성이 가능합니다.
  • 비동기 프로그래밍 지원: 비동기/동기 프로그래밍을 모두 지원해 빠른 데이터를 처리할 수 있습니다.

2. FastAPI 설치하기

FastAPI 프레임워크를 설치하려면 pip를 통해 간단히 설치할 수 있습니다. 아래 명령어를 사용하여 FastAPI와 uvicorn(ASGI 서버)을 설치하세요: 

pip install fastapi uvicorn

3. 간단한 FastAPI 서버 만들기

FastAPI 애플리케이션을 만들기 위해 가장 먼저 해야 할 일은 FastAPI 클래스를 인스턴스화하는 것입니다. 아래의 코드는 “Hello, World!”를 반환하는 기본적인 FastAPI 서버 예제입니다. 

from fastapi import FastAPI

app = FastAPI()

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

3.1. 서버 실행하기

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

uvicorn my_app:app --reload

이제 브라우저에서 http://127.0.0.1:8000를 열면 “Hello, World!” 메시지를 확인할 수 있습니다.

4. 경로와 HTTP 메서드

FastAPI에서는 다양한 HTTP 메서드를 사용하여 경로를 정의할 수 있습니다. 주로 사용되는 메서드는 다음과 같습니다:

  • GET: 데이터 조회
  • POST: 데이터 생성
  • PUT: 데이터 업데이트
  • DELETE: 데이터 삭제

4.1. GET 메서드 사용하기

GET 메서드를 사용하여 특정 경로에 대한 요청을 처리하는 예제를 살펴보겠습니다. 아래 코드는 /items/{item_id} 경로에 대한 GET 요청을 처리합니다. 

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

이 코드는 /items/1?q=example와 같은 요청을 처리하며, 응답은 다음과 같습니다: 

{"item_id": 1, "query": "example"}

4.2. POST 메서드 사용하기

POST 메서드는 서버에 새로운 데이터를 생성하는 데 사용됩니다. 다음 예제에서는 새 아이템을 추가하는 POST 요청을 처리합니다. 

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

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

클라이언트에서 application/json 포맷으로 데이터를 전송하면 FastAPI는 자동으로 데이터를 검증하고 파싱하여 item으로 전달합니다.

4.3. PUT 메서드 사용하기

PUT 메서드는 기존 데이터를 업데이트하는 데 사용됩니다. 아래 코드는 특정 아이템을 업데이트하는 예제입니다. 

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    return {"item_id": item_id, "updated_item": item}

4.4. DELETE 메서드 사용하기

DELETE 메서드는 특정 아이템을 삭제하는 데 사용됩니다. 다음 코드는 특정 아이템을 삭제하는 경로를 정의합니다. 

@app.delete("/items/{item_id}")
async def delete_item(item_id: int):
    return {"message": f"Item with id {item_id} deleted"}

5. 경로 동작 함수 파라미터

FastAPI의 경로 동작 함수에서는 입력 파라미터를 다양하게 정의할 수 있습니다. FastAPI는 자동으로 요청 본문, 쿼리 매개변수, 경로 매개변수를 검증합니다.

  • 경로 매개변수: 경로의 경로 변수에 대응하는 파라미터입니다.
  • 쿼리 매개변수: URL의 쿼리 문자열에 따라 전달되는 파라미터입니다.
  • 본문 데이터: POST, PUT 요청과 함께 전송되는 데이터

5.1. 쿼리 파라미터 예제

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

5.2. 본문 파라미터 예제

@app.post("/items/")
async def create_item(item: Item):
    return item

6. 데이터 검증 및 설정 관리

FastAPI는 편리한 데이터 검증을 위해 Pydantic 모델을 활용합니다. 모델 클래스는 데이터 유효성 검사 및 설정 관리를 가능하게 합니다.

6.1. Pydantic 모델 정의하기

from pydantic import BaseModel

class User(BaseModel):
    name: str
    email: str
    age: int = None

6.2. 모델 사용 예제

@app.post("/users/")
async def create_user(user: User):
    return {"name": user.name, "email": user.email}

7. API 문서 자동 생성

FastAPI는 Swagger UI와 ReDoc을 지원하여 API 문서를 자동으로 생성합니다. Swagger UI는 http://127.0.0.1:8000/docs에서 조회할 수 있으며, ReDoc은 http://127.0.0.1:8000/redoc에서 조회할 수 있습니다. FastAPI는 IO-bound 작업을 처리하기 위해 asyncio를 사용하여 비동기적인 코드를 작성하는 것이 가능합니다.

8. FastAPI 프로젝트 구조

일반적인 FastAPI 프로젝트 구조는 다음과 같습니다: 

my_fastapi_app/
├── app/
│   ├── main.py
│   ├── models.py
│   ├── routers/
│   └── services/
└── requirements.txt

이 구조는 더 큰 규모의 FastAPI 애플리케이션에서 유용하며, 각 구성요소를 분리하여 유지보수를 용이하게 합니다.

9. 결론

FastAPI는 매우 강력하고 직관적인 웹 프레임워크로, 쉬운 API 개발과 데이터 검증을 가능하게 합니다. 본 강좌에서는 FastAPI의 기본적인 경로 동작 함수를 만드는 방법을 배웠습니다. FastAPI를 사용하면 빠르고 효율적인 백엔드 서버 개발이 가능하니, 실무에 적용해 보시기를 추천합니다.

재능있는 개발자가 되기를 응원하며, 더 많은 정보를 원하시면 FastAPI 공식 문서를 참조하시기 바랍니다.