Flask 파일 저장 완벽 가이드 S3, GCS, 로컬, 사전서명 URL

from flask import Flask, request
from werkzeug.utils import secure_filename
import os

app = Flask(__name__)
UPLOAD_FOLDER = 'uploads'
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

@app.route('/upload', methods=['POST'])
def upload_file():
    if 'file' not in request.files:
        return 'No file uploaded', 400
    file = request.files['file']
    if file.filename == '':
        return 'No selected file', 400
    filename = secure_filename(file.filename)
    filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
    file.save(filepath)
    return f'File saved at {filepath}'

import boto3, os
from flask import Flask, request
from werkzeug.utils import secure_filename

app = Flask(__name__)
s3_client = boto3.client('s3')
BUCKET_NAME = 'my-bucket'

@app.route('/upload-s3', methods=['POST'])
def upload_to_s3():
    file = request.files['file']
    filename = secure_filename(file.filename)
    s3_client.upload_fileobj(file, BUCKET_NAME, filename)
    return f"Uploaded to S3: {filename}"

@app.route('/generate-presigned-url', methods=['GET'])
def generate_presigned_url():
    filename = request.args.get('filename')
    url = s3_client.generate_presigned_url(
        'put_object',
        Params={'Bucket': BUCKET_NAME, 'Key': filename},
        ExpiresIn=3600  # 1시간
    )
    return {"url": url}

from flask import Flask, request
from werkzeug.utils import secure_filename
from google.cloud import storage

app = Flask(__name__)
client = storage.Client.from_service_account_json("service-account.json")
bucket = client.bucket("my-gcs-bucket")

@app.route('/upload-gcs', methods=['POST'])
def upload_to_gcs():
    file = request.files['file']
    filename = secure_filename(file.filename)
    blob = bucket.blob(filename)
    blob.upload_from_file(file)
    return f"Uploaded to GCS: {filename}"

from datetime import timedelta

@app.route('/generate-gcs-url', methods=['GET'])
def generate_gcs_url():
    filename = request.args.get("filename")
    blob = bucket.blob(filename)
    url = blob.generate_signed_url(
        version="v4",
        expiration=timedelta(hours=1),
        method="PUT"
    )
    return {"url": url}

app/
  __init__.py          # 앱 팩토리, 클라이언트 초기화
  config.py            # 환경별 설정 (DEV/PROD)
  blueprints/
    files.py           # 업로드/사전서명 URL 라우트
  services/
    storage.py         # 로컬/S3/GCS 어댑터
  utils/
    validation.py      # 확장자·MIME 검증, 안전한 파일명
instance/
  .env                 # 환경 변수 (Flask가 자동 로드 가능)

# app/__init__.py
import os
from flask import Flask
from .config import Config
from .blueprints.files import bp as files_bp

def create_app():
    app = Flask(__name__, instance_relative_config=True)
    app.config.from_object(Config())

    # 선택적: boto3, google-cloud-storage 지연 로드
    app.extensions["s3"] = None
    app.extensions["gcs"] = None

    if app.config.get("S3_ENABLED"):
        import boto3
        app.extensions["s3"] = boto3.client(
            "s3",
            region_name=app.config.get("AWS_REGION"),
        )

    if app.config.get("GCS_ENABLED"):
        from google.cloud import storage
        app.extensions["gcs"] = storage.Client.from_service_account_json(
            app.config.get("GCS_CREDENTIALS")
        )

    app.register_blueprint(files_bp, url_prefix="/files")
    return app

# app/services/storage.py
import os
from datetime import timedelta
from werkzeug.utils import secure_filename

def save_local(file, base_dir):
    filename = secure_filename(file.filename)
    path = os.path.join(base_dir, filename)
    os.makedirs(os.path.dirname(path), exist_ok=True)
    file.save(path)
    return {"location": "local", "key": filename, "path": path}

def presign_s3(s3, bucket, key, expires=3600, method="put_object"):
    return s3.generate_presigned_url(
        ClientMethod=method,
        Params={"Bucket": bucket, "Key": key},
        ExpiresIn=expires,
    )

def presign_gcs(gcs_bucket, key, expires_seconds=3600, method="PUT"):
    blob = gcs_bucket.blob(key)
    from datetime import timedelta
    return blob.generate_signed_url(
        version="v4",
        expiration=timedelta(seconds=expires_seconds),
        method=method
    )

# app/blueprints/files.py
from flask import Blueprint, current_app, request, jsonify
from ..services import storage
from werkzeug.utils import secure_filename

bp = Blueprint("files", __name__)

@bp.post("/upload-local")
def upload_local():
    f = request.files.get("file")
    if not f or f.filename == "":
        return {"message": "file required"}, 400
    result = storage.save_local(f, current_app.config["UPLOAD_FOLDER"])
    return jsonify(result), 201

@bp.get("/presign/s3")
def presign_s3():
    key = secure_filename(request.args.get("key", "upload.bin"))
    s3 = current_app.extensions.get("s3")
    if not s3:
        return {"message": "S3 disabled"}, 400
    url = storage.presign_s3(
        s3,
        current_app.config["S3_BUCKET"],
        key,
        expires=current_app.config.get("PRESIGN_EXPIRES", 3600),
        method="put_object"
    )
    return {"url": url, "key": key}

@bp.get("/presign/gcs")
def presign_gcs():
    key = secure_filename(request.args.get("key", "upload.bin"))
    gcs_client = current_app.extensions.get("gcs")
    if not gcs_client:
        return {"message": "GCS disabled"}, 400
    bucket = gcs_client.bucket(current_app.config["GCS_BUCKET"])
    url = storage.presign_gcs(
        bucket,
        key,
        expires_seconds=current_app.config.get("PRESIGN_EXPIRES", 3600),
        method="PUT"
    )
    return {"url": url, "key": key}

# app/config.py
import os
class Config:
    UPLOAD_FOLDER = os.getenv("UPLOAD_FOLDER", "uploads")
    PRESIGN_EXPIRES = int(os.getenv("PRESIGN_EXPIRES", "3600"))
    # S3
    S3_ENABLED = os.getenv("S3_ENABLED", "0") == "1"
    AWS_REGION = os.getenv("AWS_REGION", "ap-northeast-2")
    S3_BUCKET = os.getenv("S3_BUCKET", "")
    # GCS
    GCS_ENABLED = os.getenv("GCS_ENABLED", "0") == "1"
    GCS_BUCKET = os.getenv("GCS_BUCKET", "")
    GCS_CREDENTIALS = os.getenv("GCS_CREDENTIALS", "service-account.json")