Daily CS) Flask

goldenGlow_21·2024년 11월 30일
Daily CSFlaskframeworkpython
0

Daily CS

목록 보기
6/50

Flask

lightweight and flexible framework for web development and web applications that utilizes the Python programming language

앞서 언급한 프로젝트에서, 서비스 포트 스캐너를 구현하며 Flask 프레임워크를 사용하였다. 프론트엔드에서는 React를 사용했는데... 이 둘이 서로 그다지 어울리는 조합이 아니라는 것은 나중에서야 알게 되었다. 그래도 평소 Django만 써보던 나로서는 새로운 프레임워크를 익숙한 언어로 배워 볼 수 있다는 점에 매력을 느껴, 긍정적으로 생각하고 공부를 시작했다. 오늘의 데일리 CS 에서는 이 공부 과정에서 알게 된 점들에 대해 다뤄보려 한다.

Spoiler: 오늘 포스팅에 코드 엄청 많음

1. 서론

1.1 Flask의 정의와 소개

Flask는 Python으로 작성된 마이크로 웹 프레임워크로, 웹 애플리케이션 및 RESTful API 개발에 사용된다. "마이크로"라는 명칭은 크기가 작다는 것을 의미하지 않으며, 핵심 기능만 제공하고 확장성을 강조하는 설계를 뜻한다. Flask는 간결하고 유연한 코드를 작성할 수 있도록 설계되었으며, Jinja2 템플릿 엔진과 Werkzeug WSGI 라이브러리를 기반으로 동작한다. 초보자부터 전문가까지 모두 사용하기 쉽도록 설계된 Flask는 Python 웹 개발의 대표적인 선택지 중 하나이다.

1.2 Flask의 역사와 배경

Flask는 2010년 Armin Ronacher가 Pallets 프로젝트의 일부로 시작한 오픈소스 프레임워크이다. Flask는 "April Fool's Joke"로 처음 공개되었으나, 사용자들이 그 간결함과 유연성을 주목하며 폭발적인 인기를 얻었다. Flask는 Django와 같은 대규모 프레임워크와 달리 필요한 기능만 추가하는 구조로 설계되었으며, 다양한 확장(예: Flask-SQLAlchemy, Flask-WTF)을 통해 사용자가 프로젝트에 필요한 기능을 쉽게 통합할 수 있다.

1.3 Flask를 사용하는 이유와 주요 장점

Flask는 간단하고 직관적인 코딩 경험을 제공하며, 다양한 이유로 많은 개발자가 선택한다. 주요 장점은 다음과 같다:

  • 간결성과 유연성: 코드를 최소화하면서도 원하는 대로 확장할 수 있다.
  • 풍부한 확장 도구: 인증, 데이터베이스 연동, 폼 검증 등 다양한 기능을 쉽게 추가할 수 있다.
  • 활발한 커뮤니티: 강력한 커뮤니티 지원과 풍부한 튜토리얼이 제공된다.
  • 경량 프레임워크: 프로젝트 요구 사항에 따라 불필요한 기능 없이 경량화된 애플리케이션을 구축할 수 있다.

2. Flask의 기초 개념

2.1 Flask와 WSGI (Web Server Gateway Interface)

WSGI는 Python 웹 애플리케이션과 웹 서버 간의 통신을 정의하는 표준 인터페이스이다. Flask는 Werkzeug를 통해 WSGI를 구현하며, 이로 인해 Python 웹 애플리케이션이 서버와 상호작용할 수 있다. Flask가 자체적으로 웹 서버를 제공하지는 않지만, 개발 환경에서 flask run 명령어로 내장 WSGI 서버를 사용할 수 있다. 이 표준은 Flask가 다양한 웹 서버(예: Gunicorn, uWSGI)와 호환되도록 한다.

2.2 Flask의 동작 원리

Flask는 사용자가 정의한 URL 라우트와 뷰 함수를 통해 요청을 처리하고 응답을 생성한다. 사용자가 브라우저에서 URL을 요청하면 Flask는 해당 URL에 매핑된 뷰 함수를 실행하고 결과를 반환한다. Flask는 요청(Request)와 응답(Response)을 처리하기 위해 Werkzeug WSGI를 활용하며, 템플릿 엔진(Jinja2)을 통해 HTML 페이지를 동적으로 렌더링할 수 있다.

예시:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def home():
    return "Hello, Flask!"
    
if __name__ == "__main__":
    app.run()

2.3 Flask와 다른 Python 웹 프레임워크 비교 (Django, FastAPI 등)

Framework특징적합한 프로젝트
Flask경량, 유연성 중심, 필요한 기능만 추가 가능소규모 프로젝트, RESTful API 개발
Django완전한 웹 프레임워크, ORM 및 관리 인터페이스 기본 제공대규모 프로젝트, 데이터 중심 애플리케이션
FastAPI비동기 지원, 자동 문서화(Swagger UI), 성능 최적화실시간 API, 고성능 애플리케이션

Flask는 간결성과 확장성을 중시하며, 사용자가 애플리케이션 구조를 자유롭게 설계할 수 있는 반면, Django는 모든 것을 포함한 풀스택 프레임워크이다. FastAPI는 비동기 프로그래밍에 특화되어 있으며, 최신 기술을 적용한 고성능 API 개발에 적합하다.

3. Flask의 기본 구조

3.1 Flask 애플리케이션 생성과 실행

Flask 애플리케이션은 Flask 클래스를 사용해 생성하며, app.route() 데코레이터를 통해 URL 라우트를 정의한다. 개발 환경에서는 app.run()을 호출하여 애플리케이션을 실행한다.

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Welcome to Flask!"

if __name__ == "__main__":
    app.run(debug=True)

위 코드에서 debug=True는 실시간 코드 변경 반영 및 오류 디버깅 화면을 활성화한다.

3.2 Flask 애플리케이션의 디렉토리 구조

Flask 애플리케이션의 디렉토리 구조는 프로젝트 규모와 요구 사항에 따라 다르지만, 일반적으로 다음과 같다. 아래의 구조는 코드의 재사용성과 유지보수를 용이하게 하는 것을 우선순위로 두고 있다.

project/
├── app/
│   ├── __init__.py  # 애플리케이션 팩토리 함수
│   ├── routes.py    # URL 라우트 정의
│   ├── models.py    # 데이터베이스 모델
│   ├── templates/   # HTML 템플릿
│   └── static/      # 정적 파일 (CSS, JS, 이미지 등)
├── tests/           # 테스트 코드
├── .env             # 환경 변수 설정
└── run.py           # 실행 스크립트

3.3 Flask의 요청-응답 주기

Flask의 요청-응답 주기는 클라이언트의 요청이 서버에서 처리되어 응답으로 반환되는 일련의 과정이다. 주요 단계는 다음과 같다.

  1. 클라이언트 요청: 브라우저에서 HTTP 요청을 보냄
  2. WSGI 서버 처리: 요청이 WSGI 서버로 전달됨
  3. Flask 라우팅: Flask가 URL과 일치하는 뷰 함수를 실행
  4. 응답 생성: 뷰 함수의 결과를 HTTP 응답으로 변환
  5. 클라이언트로 응답 반환: HTML, JSON, 또는 텍스트 형태로 응답

4. Flask의 주요 구성 요소

4.1 Flask 객체와 앱 컨텍스트

Flask 객체는 애플리케이션의 중심으로, URL 라우팅, 설정 관리, 확장 로드 등을 담당한다. Flask 객체는 Flask 클래스를 사용해 생성하며, 애플리케이션 전역 상태를 관리한다. 앱 컨텍스트(Application Context)는 특정 요청과 관련된 데이터를 Flask 애플리케이션에서 안전하게 처리할 수 있도록 지원하는 환경이다. 예를 들어, current_app은 현재 활성화된 Flask 애플리케이션 객체에 대한 참조를 제공하며, g 객체는 요청 수명 동안 데이터를 저장할 수 있다.

from flask import Flask, current_app, g

app = Flask(__name__)

@app.route("/")
def index():
    g.message = "Hello from g!"
    return g.message

with app.app_context():
    print(current_app.name)  # 현재 앱 이름 출력

4.2 요청 객체 (Request Object)

요청 객체는 클라이언트가 서버로 보내는 요청 데이터를 처리하는 데 사용된다. Flask의 request 객체는 HTTP 메서드(GET, POST 등), URL 매개변수, 폼 데이터, 헤더 등을 포함한다. 이를 통해 사용자의 입력을 처리하거나 쿼리 스트링 데이터를 파싱할 수 있다. 요청 객체는 요청 수명 동안만 유효하며, Flask가 요청을 처리하는 동안 안전하게 사용된다.

from flask import Flask, request

app = Flask(__name__)

@app.route("/search")
def search():
    query = request.args.get("q")  # 쿼리 스트링에서 'q' 값 가져오기
    return f"Searching for: {query}"

위처럼 코드를 작성하면, http://127.0.0.1:5000/search?q=flask를 요청할 시 Searching for: flask가 반환된다.

4.3 응답 객체 (Response Object)

응답 객체는 Flask에서 클라이언트에게 반환하는 HTTP 응답을 생성한다. Flask는 문자열, JSON, HTML 등의 간단한 값도 응답으로 변환할 수 있지만, Response 객체를 사용하면 상태 코드, 헤더, 콘텐츠 유형을 세부적으로 제어할 수 있다. 응답 객체는 REST API 개발이나 커스텀 헤더 설정이 필요한 경우 유용하다.

from flask import Flask, Response

app = Flask(__name__)

@app.route("/custom")
def custom():
    response = Response(
        "This is a custom response",
        status=201,
        mimetype="application/json"
    )
    response.headers["X-Custom-Header"] = "CustomValue"
    return response

4.4 URL 라우팅과 뷰 함수

URL 라우팅은 특정 URL 요청을 처리할 뷰 함수와 매핑하는 역할을 한다. Flask는 @app.route 데코레이터를 사용하여 URL 경로를 정의하고, HTTP 메서드(GET, POST 등)를 설정할 수 있다. 라우트는 동적 URL을 지원하며, URL 경로에서 매개변수를 추출하여 뷰 함수로 전달할 수 있다.

from flask import Flask

app = Flask(__name__)

@app.route("/user/<username>")
def show_user(username):
    return f"Hello, {username}!"

@app.route("/post/<int:post_id>")
def show_post(post_id):
    return f"Post ID: {post_id}"
  • http://127.0.0.1:5000/user/john → Hello, john!
  • http://127.0.0.1:5000/post/42 → Post ID: 42

4.5 템플릿 렌더링 (Jinja2)

Flask는 Jinja2 템플릿 엔진을 사용해 HTML을 동적으로 생성한다. 템플릿은 동적 데이터를 삽입하기 위한 변수와 로직(반복문, 조건문)을 포함할 수 있다. Flask의 render_template 함수는 지정된 HTML 파일을 렌더링하며, 이를 통해 서버에서 생성된 데이터를 사용자에게 전달할 수 있다.

# template file - hello.html
<!DOCTYPE html>
<html>
<head><title>Hello Flask</title></head>
<body>
    <h1>Hello, {{ name }}!</h1>
</body>
</html>
# Flask Application
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/hello/<name>")
def hello(name):
    return render_template("hello.html", name=name)

위처럼 코드를 구성하면 http://127.0.0.1:5000/hello/Flask를 요청할 시 HTML 페이지에 Hello, Flask!가 표시된다.

4.6 HTTP 메서드와 플라스크의 처리 방식

HTTP 메서드(GET, POST, PUT, DELETE 등)는 클라이언트가 서버와 상호작용하는 방식을 정의한다. Flask에서는 각 라우트에서 지원하는 HTTP 메서드를 명시할 수 있다. 기본값은 GET이지만, 다른 메서드를 추가하려면 methods 매개변수를 사용한다. 각 메서드는 고유한 목적을 가지며, RESTful API 설계에 핵심적인 역할을 한다.

from flask import Flask, request

app = Flask(__name__)

@app.route("/data", methods=["GET", "POST"])
def handle_data():
    if request.method == "GET":
        return "This is a GET request"
    elif request.method == "POST":
        data = request.json
        return f"Received data: {data}"
  • GET 요청 → This is a GET request
  • POST 요청 → Received data: {...}

HTTP 메서드를 통해 CRUD(Create, Read, Update, Delete) 작업을 구현할 수 있으며, 이를 RESTful 서비스 설계에 활용하게 된다!

5. Flask의 확장 기능과 모듈

5.1 Flask Blueprints

Flask Blueprints는 애플리케이션을 모듈화하여 대규모 프로젝트를 효율적으로 관리하도록 돕는 기능이다. 이를 통해 각 기능(예: 사용자 인증, 블로그 게시물 관리)을 별도의 모듈로 분리하고 독립적으로 관리할 수 있다. Blueprints는 라우트, 템플릿, 정적 파일 등을 포함하여 코드의 재사용성과 유지보수를 향상시킨다.

from flask import Blueprint

# 블루프린트 정의
auth = Blueprint('auth', __name__)

@auth.route("/login")
def login():
    return "Login Page"

# 애플리케이션에 등록
from flask import Flask
app = Flask(__name__)
app.register_blueprint(auth, url_prefix="/auth")

# /auth/login 경로에서 "Login Page" 출력

5.2 Flask Extensions (Flask-SQLAlchemy, Flask-WTF 등)

Flask Extensions는 애플리케이션의 기능을 확장하는 플러그인으로, 데이터베이스 연동, 폼 처리, 인증 등 다양한 기능을 제공한다.

  • Flask-SQLAlchemy: SQLAlchemy ORM을 사용해 데이터베이스와 상호작용
  • Flask-WTF: 폼 생성과 검증을 간소화
  • Flask-Mail: 이메일 전송 기능 추가
  • Flask-Login: 사용자 인증과 세션 관리
Extension주요 기능
Flask-SQLAlchemy데이터베이스 ORM 관리
Flask-WTFHTML 폼과 데이터 검증
Flask-Migrate데이터베이스 마이그레이션
Flask-Login인증 및 권한 관리
Flask-Caching캐싱을 통한 성능 최적화

5.3 Flask 플러그인 및 서드파티 라이브러리

Flask는 확장 가능성을 염두에 두고 설계된 가벼운 프레임워크인 만큼, 커뮤니티에서 개발된 플러그인과 서드파티 라이브러리를 활용할 수 있다.

  • Flask-RESTful: RESTful API 개발을 단순화
  • Flask-JWT-Extended: JSON Web Token 기반 인증
  • Flask-SocketIO: 실시간 웹소켓 통신 구현

이러한 플러그인들은 Flask 애플리케이션의 기능을 확장하는 데 핵심적인 역할을 한다.

6. Flask의 데이터 처리와 보안

6.1 데이터베이스 연동 (SQLAlchemy, Flask-Migrate)

Flask는 데이터베이스와 연동하기 위해 Flask-SQLAlchemy 확장을 사용한다. SQLAlchemy는 객체 관계 매핑(ORM)을 지원하며, Python 클래스와 데이터베이스 테이블 간 매핑을 통해 SQL 쿼리를 간소화한다. Flask-Migrate는 Alembic을 사용해 데이터베이스 스키마 변경(마이그레이션)을 관리한다.

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)

db.create_all()

6.2 폼 데이터 처리 (Flask-WTF)

Flask-WTF는 폼 생성과 데이터 검증을 간소화하는 확장이다. 이는 CSRF 방지 기능을 기본적으로 제공하며, 서버에서 데이터 유효성을 쉽게 확인할 수 있다.

from flask import Flask, render_template, request
from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField
from wtforms.validators import DataRequired

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret'

class NameForm(FlaskForm):
    name = StringField('Name', validators=[DataRequired()])
    submit = SubmitField('Submit')

@app.route("/", methods=["GET", "POST"])
def index():
    form = NameForm()
    if form.validate_on_submit():
        return f"Hello, {form.name.data}!"
    return render_template("index.html", form=form)

6.3 사용자 인증과 권한 관리 (Flask-Login, JWT)

Flask-Login은 사용자의 로그인 상태를 관리하고, 보호된 페이지에 접근을 제한하는 기능을 제공한다. JWT(JSON Web Token)는 클라이언트-서버 간 인증을 위한 토큰 기반 메커니즘으로, RESTful API에서 자주 사용된다.

from flask import Flask, redirect, url_for
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret'
login_manager = LoginManager(app)

class User(UserMixin):
    def __init__(self, id):
        self.id = id

@login_manager.user_loader
def load_user(user_id):
    return User(user_id)

@app.route("/login")
def login():
    user = User("123")
    login_user(user)
    return "Logged in!"

@app.route("/protected")
@login_required
def protected():
    return "Protected page."

@app.route("/logout")
def logout():
    logout_user()
    return redirect(url_for("login"))

6.4 CSRF 방지와 세션 관리

CSRF(Cross-Site Request Forgery)는 악의적인 요청을 서버에 보내는 공격으로, Flask는 CSRF 방지를 위해 Flask-WTF를 사용한다. 세션 관리는 Flask의 내장 세션 객체를 통해 클라이언트 상태를 유지한다.

from flask_wtf.csrf import CSRFProtect

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret'
csrf = CSRFProtect(app)

세션은 flask.session을 통해 키-값 저장소처럼 데이터를 관리할 수 있다.

7. Flask와 RESTful API

7.1 RESTful API의 개념과 Flask에서의 구현

RESTful API는 HTTP 메서드(GET, POST, PUT, DELETE)를 통해 자원을 CRUD(생성, 읽기, 수정, 삭제) 방식으로 관리하는 아키텍처 스타일이다. Flask는 RESTful API 구현에 적합하며, 라우트를 정의하고 HTTP 메서드를 처리하는 방식으로 간단히 API를 구축할 수 있다. RESTful API는 URL을 통해 리소스를 명확히 표현하며, 요청/응답은 보통 JSON 형식으로 이루어진다.

from flask import Flask, request, jsonify

app = Flask(__name__)

# 간단한 RESTful API 구현
users = []

@app.route("/users", methods=["GET", "POST"])
def manage_users():
    if request.method == "GET":
        return jsonify(users)  # 전체 사용자 반환
    elif request.method == "POST":
        new_user = request.json
        users.append(new_user)
        return jsonify(new_user), 201  # 새 사용자 생성

@app.route("/users/<int:user_id>", methods=["GET", "PUT", "DELETE"])
def user_detail(user_id):
    if user_id >= len(users):
        return {"error": "User not found"}, 404
    if request.method == "GET":
        return jsonify(users[user_id])  # 특정 사용자 반환
    elif request.method == "PUT":
        users[user_id] = request.json
        return jsonify(users[user_id])  # 사용자 정보 수정
    elif request.method == "DELETE":
        users.pop(user_id)
        return {}, 204  # 사용자 삭제

if __name__ == "__main__":
    app.run(debug=True)

7.2 Flask-RESTful과 Flask API

Flask-RESTful은 RESTful API 구축을 간소화하는 확장으로, 클래스를 사용해 리소스를 관리한다. 이 확장은 HTTP 메서드를 명확히 정의할 수 있으며, 코드 가독성과 재사용성을 높여준다.

from flask import Flask
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

class UserResource(Resource):
    def get(self, user_id):
        return {"user_id": user_id}

    def post(self):
        return {"message": "User created"}, 201

api.add_resource(UserResource, "/users/<int:user_id>")

위 코드는 /users/<int:user_id> 경로에서 GET과 POST 메서드를 처리한다. API는 명확하고 확장 가능하게 작성된다.

7.3 JSON 데이터 처리 및 응답

JSON은 RESTful API의 데이터 교환 형식으로, Flask는 JSON 데이터를 쉽게 처리할 수 있도록 request.json과 jsonify를 제공한다. 클라이언트가 JSON 데이터를 POST 요청으로 보내면, Flask에서 이를 처리하고 JSON 응답을 생성할 수 있다.

  • json 데이터 처리 예제
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/data", methods=["POST"])
def handle_data():
    received_data = request.json  # 클라이언트로부터 JSON 데이터 읽기
    return jsonify({"received": received_data})  # JSON 응답 생성
  • request / response 예제
// request
POST /data
{
    "name": "John Doe",
    "age": 30
}
// response
{
    "received": {
        "name": "John Doe",
        "age": 30
    }
}

7.4 API 버전 관리와 오류 처리

Flask는 API의 버전을 URL 또는 헤더로 관리할 수 있다. URL 기반 버전 관리는 /v1/resource와 같은 형식을 사용하며, 여러 버전의 API를 동시에 지원한다. 또한, Flask의 @app.errorhandler 데코레이터를 사용하여 오류를 처리하고 사용자에게 명확한 오류 메시지를 반환할 수 있다.

  • API 버전 관리의 예시 코드
@app.route("/v1/users")
def users_v1():
    return {"version": 1, "users": []}

@app.route("/v2/users")
def users_v2():
    return {"version": 2, "users": []}
  • 오류 처리 예시 코드
@app.errorhandler(404)
def not_found_error(error):
    return {"error": "Resource not found"}, 404

8. Flask와 비동기 프로그래밍

8.1 Flask에서의 비동기 작업 소개

비동기 프로그래밍은 작업이 동시에 실행되지 않고, 하나의 작업이 끝날 때까지 기다리지 않고 다음 작업을 시작할 수 있는 프로그래밍 방식이다. 예를 들어, 비동기 작업을 통해 서버는 파일을 읽거나 외부 API 호출을 기다리는 동안 다른 요청을 처리할 수 있다. Flask는 기본적으로 동기적으로 작동하지만, 비동기 처리를 통해 CPU 또는 I/O 집약적인 작업을 효율적으로 처리할 수 있다.

Flask 2.0부터는 async 키워드를 사용해 비동기 뷰 함수를 작성할 수 있다. 이는 데이터베이스 작업, 외부 API 호출과 같은 작업에서 비동기 코드를 활용할 수 있도록 한다.

from flask import Flask
import asyncio

app = Flask(__name__)

@app.route("/")
async def async_view():
    await asyncio.sleep(1)
    return "Hello, Async Flask!"

8.2 Celery와 Flask의 연동

Flask는 자체적으로 비동기 작업 큐를 제공하지 않지만, Celery와 같은 강력한 도구를 통합하여 백그라운드 작업을 처리할 수 있다. Celery는 작업을 큐에 넣고, 독립적인 워커(worker)가 이를 처리하는 방식으로 작동한다. 이는 서버가 주 작업(예: HTTP 요청 처리)을 수행하는 동안 시간이 많이 걸리는 작업(예: 이메일 전송, 데이터 분석)을 백그라운드에서 처리할 수 있도록 한다.

예를 들어, 이메일 전송 작업을 동기적으로 처리하면 서버는 이메일 전송이 끝날 때까지 대기해야 하므로 다른 요청을 처리하지 못한다. Celery를 사용하면 이메일 전송 작업을 큐에 넣고, 워커가 이를 처리하도록 하여 서버의 가용성을 높일 수 있다.

from flask import Flask
from celery import Celery

app = Flask(__name__)
app.config['CELERY_BROKER_URL'] = 'redis://localhost:6379/0'
celery = Celery(app.name, broker=app.config['CELERY_BROKER_URL'])

@celery.task
def send_email(email):
    print(f"Sending email to {email}")

@app.route("/send/<email>")
def send(email):
    send_email.delay(email)  # 백그라운드 작업으로 실행
    return "Email task started!"

Celery의 주요 개념

  • 작업 큐: 실행 대기 중인 작업 목록
  • 브로커(Broker): 작업 큐를 관리하는 시스템(Redis, RabbitMQ 등)
  • 워커(Worker): 큐에 저장된 작업을 처리하는 독립적인 실행 단위

8.3 Flask-SocketIO를 이용한 실시간 통신

WebSocket은 HTTP와는 다른 방식으로 클라이언트와 서버 간 실시간 양방향 통신을 가능하게 하는 기술이다. 일반 HTTP 요청은 클라이언트가 요청을 보낼 때만 서버가 응답을 반환하지만, WebSocket은 클라이언트와 서버가 지속적으로 연결된 상태를 유지하며 실시간으로 데이터를 주고받을 수 있다.

Flask-SocketIO는 Flask에서 WebSocket 기능을 간편하게 구현할 수 있는 확장이다. 실시간 채팅 애플리케이션, 실시간 알림 시스템, 주식 가격 스트리밍과 같은 애플리케이션에 적합하다.

WebSocket과 HTTP의 차이점

  • HTTP: 요청-응답 기반. 클라이언트가 요청을 보내야만 서버가 응답
  • WebSocket: 연결이 유지된 상태에서 클라이언트와 서버가 자유롭게 메시지를 주고받음
from flask import Flask, render_template
from flask_socketio import SocketIO

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)

@socketio.on('message')
def handle_message(msg):
    print(f"Received: {msg}")
    socketio.send(f"Echo: {msg}")

if __name__ == "__main__":
    socketio.run(app)

개괄적인 흐름

  1. 클라이언트가 서버와 WebSocket 연결을 설정
  2. 연결이 설정되면, 클라이언트와 서버는 지속적으로 데이터를 주고받을 수 있음
  3. Flask-SocketIO는 이벤트 기반으로 동작하며, 클라이언트가 보낸 특정 이벤트를 처리하거나, 서버에서 이벤트를 트리거할 수 있음

8.4 비동기 요청과 응답 처리

비동기 요청과 응답 처리는 서버가 외부 API 호출이나 데이터베이스 쿼리 같은 대기 시간이 긴 작업을 처리할 때 효율적으로 작동한다. 동기 방식에서는 이러한 작업이 끝날 때까지 서버가 다른 요청을 처리하지 못하지만, 비동기 방식에서는 대기하는 동안 다른 작업을 처리할 수 있다.

Flask 2.0부터는 async와 await 키워드를 사용해 비동기 요청을 처리할 수 있다. async 함수는 일반적인 동기 함수와 다르게 실행되며, await 키워드는 비동기 함수가 완료될 때까지 기다린다. 이를 통해 Flask는 외부 API와 효율적으로 상호작용하거나, 비동기 데이터베이스 드라이버를 사용할 수 있다.

비동기 HTTP 요청 처리 예시

  1. 클라이언트가 서버에 요청을 보냄
  2. Flask 애플리케이션은 aiohttp를 사용해 외부 API에 비동기로 요청을 보냄
  3. Flask는 응답이 올 때까지 기다리지 않고 다른 작업을 처리
  4. 외부 API의 응답이 도착하면 Flask는 이를 클라이언트에게 반환
import aiohttp
from flask import Flask

app = Flask(__name__)

@app.route("/async_request")
async def async_request():
    async with aiohttp.ClientSession() as session:
        async with session.get("https://jsonplaceholder.typicode.com/posts/1") as response:
            data = await response.json()
            return data

비동기 작업의 장점

  • 효율적인 리소스 사용: 서버의 가용성을 높이고, 대규모 트래픽을 처리할 수 있음
  • 응답 시간 단축: 느린 작업을 대기하지 않고 처리하여 사용자 경험 개선

9. Flask의 성능 최적화

9.1 프로파일링과 디버깅

프로파일링은 애플리케이션의 성능 병목 현상을 식별하기 위해 각 함수나 코드 블록의 실행 시간을 분석하는 작업이다. Flask에서는 Werkzeug Debugger와 같은 디버깅 도구를 기본적으로 제공하며, 이를 활성화하면 코드에서 발생하는 오류를 실시간으로 확인할 수 있다. 또한, flask-profiler와 같은 플러그인을 사용하면 요청 처리 시간과 데이터베이스 쿼리 성능을 분석할 수 있다.

app = Flask(__name__)
app.config["DEBUG"] = True  # 실시간 디버깅 활성화

9.2 캐싱을 이용한 성능 개선 (Flask-Caching)

캐싱은 동일한 요청에 대해 서버가 결과를 재생성하지 않고, 이전에 계산된 응답을 반환하는 방식으로 성능을 향상시킨다. Flask-Caching은 Flask 애플리케이션에서 간단히 캐싱을 구현할 수 있는 확장으로, 메모리, 파일, Redis 등을 캐싱 백엔드로 지원한다.

from flask import Flask
from flask_caching import Cache

app = Flask(__name__)
app.config['CACHE_TYPE'] = 'SimpleCache'
cache = Cache(app)

@app.route("/")
@cache.cached(timeout=60)  # 캐시된 결과를 60초 동안 유지
def index():
    return "This is a cached response"

9.3 다중 프로세스 및 WSGI 서버 (uWSGI, Gunicorn)

Flask는 기본적으로 개발용 서버를 제공하지만, 이는 생산 환경에서 적합하지 않다. WSGI(Web Server Gateway Interface) 서버인 uWSGI나 Gunicorn을 사용하면 다중 프로세스를 통해 동시에 여러 요청을 처리할 수 있다. Gunicorn은 간단하게 설정할 수 있고, uWSGI는 고급 설정이 가능하며 성능이 뛰어나다. 상황에 따라 잘 골라 쓰자.

gunicorn -w 4 -b 127.0.0.1:5000 app:app
  • -w 4: 워커(worker) 프로세스 수를 4개로 설정
  • -b: 애플리케이션 바인딩 주소

9.4 플라스크 애플리케이션의 로드 밸런싱

로드 밸런싱은 여러 서버에 걸쳐 네트워크 트래픽을 고르게 분산시키는 기술이다. 이는 단일 서버의 과부하를 방지하고, 애플리케이션의 가용성과 성능을 유지하는 데 필수적이다. Flask 애플리케이션은 여러 서버(또는 WSGI 워커)로 구성된 환경에서 로드 밸런서를 통해 요청을 분산받을 수 있다. 실제 작업 환경에 응용하면 Nginx는 로드 밸런서로 작동하고, Gunicorn은 Flask 애플리케이션을 실행하는 방식으로 운용할 수 있다.

로드 밸런싱의 기본 원리

  1. 사용자가 요청을 보냄
  2. 로드 밸런서가 요청을 여러 서버로 나눔
  3. 각 서버가 요청을 처리하고 응답을 반환
upstream flask_app {
    server 127.0.0.1:8000;
    server 127.0.0.1:8001;
    server 127.0.0.1:8002;
}

server {
    listen 80;
    location / {
        proxy_pass http://flask_app;
    }
}

10. Flask와 프론트엔드 통합

10.1 Flask와 React/Angular/Vue 연동

Flask는 백엔드(API 서버)로 사용되고, React, Angular, Vue는 프론트엔드 애플리케이션을 구성한다. Flask는 RESTful API를 제공하며, 프론트엔드에서 데이터를 요청하고 화면에 표시한다.

어떻게 연동해요?

  1. Flask는 /api/data와 같은 엔드포인트를 제공
  2. 프론트엔드는 Axios 또는 Fetch API를 사용해 Flask API에 데이터를 요청
  3. 서버에서 반환된 데이터를 바탕으로 화면이 업데이트

연동 시의 구조

  • 백엔드: Flask는 데이터를 JSON 형식으로 제공
  • 프론트엔드: React는 JSON 데이터를 받아 UI를 동적으로 구성.

10.2 AJAX와 Flask

AJAX(Asynchronous JavaScript and XML)는 웹 페이지를 새로고침하지 않고 서버와 데이터를 주고받을 수 있도록 한다. Flask는 AJAX 요청을 처리하여 동적인 사용자 경험을 제공할 수 있다.

AJAX의 필요성

  1. 새로고침 없이 데이터 갱신
  2. 빠른 사용자 경험 제공
  • 사용자 이름 보내어 응답 받아오기 예시
<script>
    function sendData() {
        fetch('/api/submit', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ name: 'John' })
        })
        .then(response => response.json())
        .then(data => console.log(data));
    }
</script>
  • Flask에서의 처리
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/api/submit", methods=["POST"])
def submit():
    data = request.json
    return jsonify({"received": data["name"]})

10.3 Flask에서 정적 파일 관리

Flask에서 정적 파일은 HTML 페이지에서 사용하는 CSS, JavaScript, 이미지와 같은 리소스를 의미하며, 애플리케이션의 /static 디렉토리에 저장된다. Flask는 이러한 정적 파일을 효율적으로 관리하고 제공하기 위해 url_for 함수와 함께 정적 파일 경로를 쉽게 생성할 수 있도록 지원한다.

정적 파일 관리의 필요성

  1. 프론트엔드에서 일관된 스타일을 유지하기 위해 CSS 파일이 필요
  2. 사용자 경험을 개선하기 위해 JavaScript 파일로 인터랙티브 기능을 추가
  3. 애플리케이션에 사용되는 로고, 아이콘 등의 이미지를 저장
  • 기본적인 디렉토리 구조
project/
├── app.py         # Flask 애플리케이션
├── static/        # 정적 파일 폴더
│   ├── style.css  # CSS 파일
│   ├── script.js  # JavaScript 파일
│   └── logo.png   # 이미지 파일
  • HTML에서 정적 파일 참조
<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
    <script src="{{ url_for('static', filename='script.js') }}"></script>
</head>
<body>
    <h1>Flask Static Files Example</h1>
    <img src="{{ url_for('static', filename='logo.png') }}" alt="Logo">
</body>
</html>

위와 같은 형태로 코드를 구성하고 구동하면 Flask는 url_for 함수를 사용하여 static 디렉토리에 있는 파일의 경로를 자동으로 생성한다. 예를 들어, {{ url_for('static', filename='style.css') }}는 /static/style.css로 변환된다.

10.4 Webpack 또는 Vite와 Flask의 통합

Webpack과 Vite는 최신 프론트엔드 개발에서 자산(파일)을 효율적으로 관리하고 최적화하는 도구이다. Flask와의 통합은 주로 프론트엔드 코드(CSS, JS)를 번들링하고, Flask가 이를 정적 파일로 제공하도록 구성하는 방식으로 이루어진다.

Webpack과 Flask 통합의 장점

  1. JavaScript와 CSS 파일의 크기를 줄여 페이지 로딩 속도를 개선
  2. 코드 변경 시 자동으로 파일을 갱신(핫 리로딩)
  3. 여러 파일을 하나의 번들 파일로 병합하여 네트워크 요청을 최소화
  • Webpack 설정 파일 예시 코드
const path = require('path');

module.exports = {
    entry: './src/index.js',  // 번들링 시작 파일
    output: {
        path: path.resolve(__dirname, 'static'),  // 번들 파일 저장 위치
        filename: 'bundle.js'  // 생성될 파일 이름
    },
    mode: 'production'  // 최적화 모드
};

Vite를 쓰면?

  • Vite는 Webpack보다 더 빠른 빌드 속도와 개발 환경을 제공
  • 설정 파일(vite.config.js)에서 빌드 결과를 Flask의 /static 디렉토리에 저장하도록 지정

통합 방식은?

  1. Webpack/Vite에서 JavaScript와 CSS를 번들링하여 /static에 저장
  2. Flask는 번들된 파일을 HTML 템플릿에서 로드
<script src="{{ url_for('static', filename='bundle.js') }}"></script>

11. Flask 애플리케이션 배포

11.1 Flask 애플리케이션을 배포하기 위한 준비

Flask 애플리케이션을 배포하려면 로컬 개발 환경에서 실행 중인 코드를 실제 서버에서 운영할 수 있도록 구성해야 한다.

배포 준비 단계

  1. 필수 파일 준비: 애플리케이션의 의존성을 기록한 requirements.txt를 생성하여 필요한 패키지를 설치할 수 있도록 한다
  2. 프로덕션 환경 설정: 디버그 모드를 비활성화하고, 환경 변수를 .env 파일로 관리해 민감한 정보를 보호한다
  3. WSGI 서버 준비: Flask는 개발용 서버를 제공하지만, 프로덕션 환경에서는 WSGI 서버(Gunicorn, uWSGI 등)를 사용해야 한다
  • requirements.txt
Flask==2.1.1
gunicorn==20.1.0
  • WSGI 서버 실행 예제
gunicorn -w 4 -b 0.0.0.0:8000 app:app

위의 명령은 app.py에 정의된 Flask 애플리케이션을 4개의 워커 프로세스를 사용하여 실행한다.

11.2 Heroku, AWS, GCP, Azure를 이용한 배포

Flask 애플리케이션은 다양한 클라우드 플랫폼을 통해 배포할 수 있다. 여기서 가장 접근성이 높은 Heroku와 대규모 애플리케이션 배포에 적합한 AWS/GCP/Azure를 비교한다.

Heroku 배포 단계

Heroku는 간단한 설정으로 Flask 애플리케이션을 클라우드에 배포할 수 있다.

  1. Heroku CLI 설치: 명령줄 도구를 설치하고 로그인.
  2. Git 초기화: 프로젝트 디렉토리를 Git으로 설정.
  3. 애플리케이션 배포:
heroku create
git add .
git commit -m "Deploy Flask app"
git push heroku main

AWS/GCP/Azure 배포

  • AWS Elastic Beanstalk: Flask를 포함한 Python 애플리케이션을 쉽게 배포할 수 있는 AWS 서비스
  • Google App Engine: Python 런타임을 제공하며, Flask 애플리케이션을 지원
  • Azure App Service: Flask 앱을 컨테이너 기반으로 배포 가능

11.3 Docker와 Flask 애플리케이션의 컨테이너화

Docker?

Docker는 애플리케이션과 실행 환경(의존성, 라이브러리)을 하나의 컨테이너에 묶어 어디서나 일관되게 실행할 수 있도록 하는 도구이다. "컨테이너"는 가상 머신과 달리 경량화되어 있으며, 개발 환경과 프로덕션 환경 간의 차이를 최소화한다.

Docker의 이점은?

  1. 일관된 실행 환경 제공: "내 로컬에서는 잘 되는데 서버에서는 안 된다"는 문제를 해결
  2. 빠른 배포: 컨테이너 이미지를 통해 애플리케이션을 빠르게 배포 가능
  3. 확장성: 컨테이너를 여러 대 실행하여 수평 확장 가능

Docker를 활용한 Flask 배포 단계

  1. Flask 애플리케이션 코드 준비

애플리케이션의 디렉토리 구조를 다음과 같이 구성:

project/
├── app.py           # Flask 애플리케이션 진입점
├── requirements.txt # 의존성 목록
├── Dockerfile       # Docker 이미지 빌드를 위한 설정 파일
# app.py 예시
from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Dockerized Flask!"
# requirements.txt 예시
Flask==2.1.1
gunicorn==20.1.0
  1. Dockerfile 작성

Dockerfile은 Docker 이미지를 생성하기 위한 스크립트이다. Python 기반 Flask 애플리케이션을 실행하기 위해 필요한 설정을 포함한다.

# Dockerfile 예시
# Python 3.9 환경에서 시작
FROM python:3.9

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

# 소스 코드와 의존성 파일 복사
COPY . .

# 필요한 Python 패키지 설치
RUN pip install -r requirements.txt

# Gunicorn을 사용해 Flask 애플리케이션 실행
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "app:app"]
  • FROM: Python 3.9 이미지를 기반으로 사용
  • WORKDIR: 컨테이너 내부에서 코드가 저장될 디렉토리 설정
  • COPY: 현재 디렉토리의 파일을 컨테이너 내부로 복사
  • RUN: requirements.txt를 이용해 필요한 패키지 설치
  • CMD: Gunicorn으로 Flask 애플리케이션 실행(4개의 워커로 실행)
  1. Docker 이미지 생성

Dockerfile을 기반으로 이미지를 생성!

docker build -t flask-app .
  • flask-app이라는 이름의 Docker 이미지가 생성
  • docker images 명령어로 생성된 이미지를 확인할 수 있을 것
  1. Docker 컨테이너 실행

생성된 이미지를 기반으로 컨테이너를 실행

docker run -p 8000:8000 flask-app
  • -p 8000:8000: 호스트의 8000번 포트를 컨테이너의 8000번 포트에 매핑
  • flask-app: 이전 단계에서 생성한 Docker 이미지 이름

테스트 하는 법: 브라우저에서 http://localhost:8000로 접속하여 Flask 애플리케이션이 정상적으로 실행되는지 확인!

  1. Docker Compose로 여러 컨테이너 관리

Docker Compose는 여러 컨테이너(예: Flask와 데이터베이스)를 한꺼번에 실행하고 관리할 수 있다.

# docker-compose.yml
version: '3.8'

services:
  web:
    build: .
    ports:
      - "8000:8000"
    volumes:
      - .:/app
    environment:
      FLASK_ENV: production
docker-compose up

11.4 CI/CD와 Flask (Github Actions, Jenkins)

CI/CD

CI/CD는 소프트웨어 개발과 배포 과정을 자동화하여 효율성과 신뢰성을 높이는 프로세스를 의미한다.

  • CI(지속적 통합)
    - 팀원이 작성한 코드를 지속적으로 병합하고 테스트하여 코드의 품질을 유지한다.
  • CD(지속적 배포)
    - 테스트를 통과한 코드를 자동으로 서버에 배포하여 배포 속도를 높인다.

이 시스템은 코드 변경 후 수동으로 테스트하거나 배포하는 과정을 줄여주며, 테스트 자동화, 버그 감지, 빠른 배포라는 장점을 제공한다.

Flask 애플리케이션에서 CI/CD의 중요성

Flask 애플리케이션도 지속적인 통합과 배포의 이점을 활용할 수 있다. CI/CD를 통해

  1. 코드 품질 보장: 각 코드 변경 사항이 테스트를 통과했는지 확인할 수 있다.
  2. 배포 속도 향상: 성공적으로 테스트된 코드를 자동으로 서버에 배포한다.
  3. 버그 감지: 문제를 조기에 발견하여 배포 전 수정할 수 있다.

Github Actions로 CI/CD 구축

1. Github Actions란?

Github Actions는 Github에서 제공하는 무료 자동화 도구로, 저장소의 코드 푸시 시 자동으로 워크플로를 실행한다. Flask 프로젝트에 CI/CD 파이프라인을 구축하기에 적합하다.

2. Github Actions 설정 방법

(1) 워크플로 파일 생성

Github 저장소에서 .github/workflows/ci.yml 파일을 생성한다. 이 파일은 CI/CD 프로세스를 정의한다.

(2) 워크플로 정의

워크플로 파일에서 다음을 설정:

  • on: 이 워크플로가 실행되는 조건(예: 코드 푸시, PR 생성)
  • jobs: 실행할 작업의 집합
3. Flask CI/CD 워크플로 예제

다음은 Flask 애플리케이션의 CI/CD 구축 예제이다. 이 예제는 코드 push 시 자동으로 테스트와 Docker 이미지를 빌드하고, 서버에 배포한다.

.github/workflows/main.yml

name: Flask CI/CD

on:
  push:
    branches:
      - main

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest

    steps:
      # 코드 다운로드
      - name: Checkout code
        uses: actions/checkout@v2

      # Python 설정
      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: 3.9

      # 종속성 설치
      - name: Install dependencies
        run: |
          pip install -r requirements.txt

      # 테스트 실행
      - name: Run tests
        run: |
          pytest

      # Docker 이미지 빌드
      - name: Build Docker image
        run: |
          docker build -t flask-app .

      # Docker 이미지 Docker Hub에 업로드
      - name: Push Docker image to Docker Hub
        run: |
          echo "${{ secrets.DOCKER_PASSWORD }}" | docker login -u "${{ secrets.DOCKER_USERNAME }}" --password-stdin
          docker tag flask-app my-dockerhub-user/flask-app:latest
          docker push my-dockerhub-user/flask-app:latest

      # 원격 서버에 배포
      - name: Deploy to production
        run: |
          ssh user@your-server "docker pull my-dockerhub-user/flask-app:latest && docker run -d -p 8000:8000 flask-app"
4. CI/CD 파이프라인 설명

(1) 의존성 설치

requirements.txt 파일에 기록된 Python 라이브러리를 설치한다. 이 단계에서 Flask, Gunicorn 등의 필수 패키지가 설치된다.

(2) 테스트 실행

pytest를 사용해 코드를 테스트한다. 모든 테스트가 성공하면 다음 단계로 진행된다.

(3) Docker 이미지 빌드

Dockerfile을 기반으로 Flask 애플리케이션의 이미지를 빌드한다. 빌드된 이미지는 로컬 환경에서 실행 가능하다.

(4) Docker Hub에 이미지 업로드

이미지를 Docker Hub와 같은 컨테이너 레지스트리에 업로드하여 원격 서버에서 재사용할 수 있게 한다. 이는 여러 서버에서 이미지를 쉽게 가져와 실행할 수 있도록 한다.

(5) 프로덕션 서버 배포

SSH를 사용해 원격 서버에 연결하고, Docker 이미지를 가져와 실행한다. 이 단계에서 새 컨테이너가 실행되며 애플리케이션이 배포된다.

5. CI/CD 실행 결과

CI/CD가 성공적으로 설정되면 다음과 같은 자동화가 가능해진다.

  1. 코드 push → Github Actions가 테스트와 빌드를 실행
  2. 테스트 성공 시 Docker 이미지 빌드 및 업로드
  3. 프로덕션 서버에 자동으로 배포

Jenkins를 활용한 CI/CD

1. Jenkins란?

Jenkins는 오픈소스 CI/CD 도구로, 복잡한 파이프라인을 구축하고 자동화된 테스트 및 배포를 지원한다. Flask 애플리케이션의 지속적 통합과 배포를 위한 강력한 옵션이다.

2. Jenkins 파이프라인 작성

Jenkinsfile을 사용해 Flask 애플리케이션의 CI/CD를 정의한다.

pipeline {
    agent any

    stages {
        stage('Checkout Code') {
            steps {
                git 'https://github.com/your-repo.git'
            }
        }

        stage('Install Dependencies') {
            steps {
                sh 'pip install -r requirements.txt'
            }
        }

        stage('Run Tests') {
            steps {
                sh 'pytest'
            }
        }

        stage('Build Docker Image') {
            steps {
                sh 'docker build -t flask-app .'
            }
        }

        stage('Deploy') {
            steps {
                sh 'ssh user@your-server "docker pull flask-app && docker run -d -p 8000:8000 flask-app"'
            }
        }
    }
}

CI/CD 구축 시 주의할 점

  1. 보안 관리: 환경 변수(API 키, 비밀번호 등)를 안전하게 관리(Github Secrets, Jenkins 환경 변수 활용) 할 것!
  2. 테스트 우선: 모든 배포 전 테스트가 성공해야 함...
  3. 로그 모니터링: 배포 후 애플리케이션 상태를 지속적으로 확인할 것(+ issue 즉시 대응)

12. Flask의 확장 가능성과 마이크로서비스

12.1 Flask 기반의 마이크로서비스 설계

마이크로서비스는 애플리케이션을 작고 독립적인 서비스로 나누어 개발, 배포, 확장성을 높이는 설계 방식이다. Flask는 경량 프레임워크로서 각 마이크로서비스를 쉽게 구현할 수 있다. Flask 애플리케이션은 RESTful API를 통해 서로 통신하며, 이를 통해 독립적인 배포와 확장이 가능하다.

마이크로서비스 설계의 기본 구조

  1. User Service: 사용자 인증 및 관리
  2. Order Service: 주문 처리와 기록
  3. Payment Service: 결제 관리
  • User Service (user.py)
from flask import Flask, jsonify

app = Flask(__name__)

@app.route("/users")
def get_users():
    return jsonify([{"id": 1, "name": "John"}])
  • Order Service (order.py)
from flask import Flask, jsonify

app = Flask(__name__)

@app.route("/orders")
def get_orders():
    return jsonify([{"id": 101, "item": "Laptop"}])

참고로, 각 서비스는 개별적으로 실행되며, API Gateway를 통해 통합된다.

12.2 Flask와 메시지 브로커 (RabbitMQ, Kafka)

메시지 브로커는 서비스 간 데이터를 비동기적으로 전달하는 데 사용되며, Flask는 Celery와 통합하여 RabbitMQ 또는 Kafka를 활용할 수 있다.

  • RabbitMQ: 작업 큐에 적합하며, 간단한 메시징 프로토콜 제공
  • Kafka: 대규모 데이터 스트리밍과 실시간 처리에 적합

RabbitMQ와 Celery 통합 예제

  • Flask 애플리케이션
from flask import Flask
from celery import Celery

app = Flask(__name__)
app.config['CELERY_BROKER_URL'] = 'amqp://localhost'

celery = Celery(app.name, broker=app.config['CELERY_BROKER_URL'])

@celery.task
def add(x, y):
    return x + y

@app.route("/add/<int:x>/<int:y>")
def add_task(x, y):
    result = add.delay(x, y)
    return f"Task submitted: {result.id}"
  • 작업 실행
celery -A app.celery worker --loglevel=info

12.3 Flask에서 API 게이트웨이 역할 수행

API 게이트웨이는 클라이언트 요청을 여러 마이크로서비스로 라우팅하는 중앙 허브 역할을 한다. Flask는 이를 위한 경량 API 게이트웨이로 동작할 수 있다.

Flask API 게이트웨이의 주요 역할

  1. 요청 인증 및 권한 관리
  2. 요청 라우팅 및 로드 밸런싱
  3. 응답 통합
from flask import Flask, jsonify, redirect

app = Flask(__name__)

@app.route("/api/users")
def user_service():
    return redirect("http://localhost:5001/users")

@app.route("/api/orders")
def order_service():
    return redirect("http://localhost:5002/orders")

if __name__ == "__main__":
    app.run(port=8000)

이 게이트웨이는 클라이언트가 http://localhost:8000/api/users에 요청을 보내면, 이를 사용자 서비스로 전달한다.

13. Flask의 한계와 발전

13.1 Flask의 주요 한계

Flask는 경량 프레임워크로 설계되었기 때문에 단순성과 유연성에서는 강점을 가지지만, 대규모 애플리케이션 개발이나 복잡한 요구 사항을 처리할 때는 몇 가지 한계를 가진다.

첫 번째 한계는 기본 제공 기능이 제한적이라는 점이다. 예를 들어, Flask는 데이터베이스 연동(ORM), 사용자 인증, 관리자 페이지와 같은 기능을 기본적으로 제공하지 않는다. 이러한 기능은 Flask-SQLAlchemy, Flask-Login 등의 확장을 통해 추가해야 하며, 확장이 많아질수록 코드의 복잡성이 증가할 수 있다.

두 번째 한계는 개발자가 프로젝트 구조를 직접 설계해야 한다는 점이다. Flask는 자유로운 구조 설계를 지원하지만, 이로 인해 프로젝트가 커질수록 코드 관리가 어려워질 수 있다. 특히 초보자는 표준화된 구조가 없는 점에서 어려움을 느낄 수 있다.

세 번째 한계는 비동기 작업에 대한 제한이다. Flask는 2.0 버전부터 비동기 처리를 지원하지만, FastAPI와 같은 비동기에 최적화된 프레임워크에 비해서는 여전히 제약이 있다. 예를 들어, 실시간 데이터 처리나 고성능 비동기 API 구현에는 Flask보다 FastAPI가 더 적합하다.

극복 방안?

  1. 확장을 적극적으로 활용하되, 코드 복잡성을 줄이기 위해 필요한 기능만 선택적으로 사용한다.
  2. Flask 공식 문서에서 제시하는 프로젝트 구조 가이드를 참고하여 구조를 표준화한다.
  3. 비동기 작업이 필요한 경우 Celery나 Flask-SocketIO와 같은 도구를 활용하거나, FastAPI와 혼합해 사용하는 것을 고려한다.

13.2 Django와의 기능적 차이 분석

Flask와 Django는 모두 Python 기반의 웹 프레임워크지만, 철학과 사용 사례에서 큰 차이를 보인다. Flask는 "마이크로 프레임워크"로, 간단한 애플리케이션부터 시작하여 필요한 기능을 추가하며 점진적으로 확장할 수 있도록 설계되었다. 반면 Django는 "풀스택 프레임워크"로, 데이터베이스 관리, 사용자 인증, 관리자 인터페이스 등 대부분의 기능을 기본적으로 제공한다.

Flask와 Django의 주요 차이점

  1. 철학과 설계 방식
    Flask는 자유도가 높아 개발자가 원하는 대로 프로젝트를 설계할 수 있다. 필요한 기능을 최소화하고 경량 애플리케이션을 개발하거나, 확장을 통해 대규모 프로젝트로 성장시킬 수 있다. 반면, Django는 "한 가지 명확한 방법"을 따르는 것을 철학으로 삼아, 개발자가 표준화된 방식으로 애플리케이션을 설계하도록 한다.

  2. 기본 제공 기능
    Django는 ORM(Object Relational Mapping), 사용자 인증 시스템, 관리자 페이지 등 대규모 애플리케이션에 필요한 기능을 기본적으로 제공한다. Flask는 이러한 기능을 제공하지 않으므로, 확장을 통해 직접 구현해야 한다.

  3. 프로젝트 크기와 적합성
    Flask는 소규모 프로젝트나 RESTful API 개발에 적합하며, Django는 데이터베이스 중심의 대규모 웹 애플리케이션 개발에 더 적합하다.

특징FlaskDjango
철학유연성, 간단함규칙 기반, 많은 기능 기본 제공
기본 제공 기능제한적(라우팅, 템플릿 렌더링 등)ORM, 인증, 관리자 페이지 등 다수 제공
학습 난이도낮음, 단순한 구조높은 진입 장벽, 복잡한 구조
적합한 프로젝트소규모 애플리케이션, API 서버대규모 데이터 중심 애플리케이션

13.3 FastAPI의 등장과 Flask의 경쟁력

FastAPI는 Flask와 비교되는 최신 Python 웹 프레임워크로, 비동기 프로그래밍을 기본으로 지원하며 높은 성능을 제공한다. 특히, 자동 문서화 기능(OpenAPI/Swagger)과 타입 힌트 기반 개발로 개발 속도와 생산성을 높이는 데 강점을 가진다.

FastAPI의 주요 특징

  1. 비동기 지원: 비동기 요청 처리를 기본으로 하여 고성능 애플리케이션을 지원한다.
  2. 자동 문서화: 개발자는 별도로 문서를 작성할 필요 없이, FastAPI가 OpenAPI 사양을 기반으로 문서를 자동 생성한다.
  3. 타입 힌트 기반: Python의 타입 힌트를 활용해 데이터 유효성 검사를 자동으로 처리한다.

Flask와 FastAPI의 비교

특징FlaskFastAPI
비동기 지원제한적으로 지원기본적으로 지원
자동 문서화수동 작성 필요OpenAPI/Swagger 자동 생성
성능적절한 확장으로 성능 향상 가능비동기에 최적화된 높은 성능 제공
적합한 프로젝트소규모 프로젝트, RESTful API실시간 데이터 처리, 대규모 API 서비스

결론

FastAPI는 최신 기술과 요구를 반영한 프레임워크로, 고성능 API와 실시간 데이터 처리에 강점을 가진다. 하지만 Flask는 여전히 단순성과 자유도를 선호하는 개발자들에게 사랑받고 있으며, 기존 확장 도구와 커뮤니티 지원을 바탕으로 경쟁력을 유지하고 있다.

14. 마무리

정말... 소개사진 한 장 말고는 아무 이미지 없이 끝난 포스팅이다. 덕분에 사진을 붙여넣을 수고는 줄었지만, 코드를 다량 작성하면서 시간은 더 오래 걸렸다. 그래도 연습은 좀 됐으니 아무튼 럭키비키인걸로..?

사실 프로젝트에서 Flask를 쓰면서 느꼈던 불편함이 없지는 않았다. 처리 속도, 작업을 구현해놓은 라이브러리 등 정말 수많은 편의 요소들이 아쉬웠는데, 막상 조사해보니 원래부터 있었다는 것이다! 아무래도 처음 접해보는 프레임워크인데다, 제대로 공부할 시간 없이 바로 개발에 들어가느라 놓친 부분이 좀 있었던 것 같다. 다음 플젝이나 경험에선 사전 조사와 계획 세우기에 공을 좀 더 들여보는 걸로 하자..!

profile
goldenGlow_21
안드로이드는 리눅스의 꿈을 꾸는가
이전 포스트

Daily CS) Port Scanning

다음 포스트

Daily CS) VPN

0개의 댓글