Axum + SQLx + PostgreSQL + JWT + Docker Compose 프로덕션 스택: 컴파일 타임 SQL 검증부터 컨테이너 배포까지

// 핸들러 시그니처만 봐도 "이 엔드포인트는 인증 필요"가 명확히 드러납니다
async fn get_profile(
    claims: Claims,                  // JWT 추출자 — 토큰 없으면 자동으로 401
    State(state): State<AppState>,
) -> impl IntoResponse {
    // claims.sub에 이미 검증된 사용자 ID가 있음
}

// 이 코드는 컴파일 시점에 DB에 실제로 연결해서 쿼리를 검증합니다
let user = sqlx::query_as!(
    UserProfile,
    "SELECT id, email, name, created_at FROM users WHERE id = $1",
    user_id
)
.fetch_one(&pool)
.await?;

# 1. 로컬 DB가 실행 중인 상태에서 메타데이터 생성
cargo sqlx prepare
 
# 2. 생성된 .sqlx/ 디렉터리를 Git에 포함
git add .sqlx/
git commit -m "chore: sqlx 쿼리 메타데이터 추가"

# GitHub Actions 예시
- name: Build
  env:
    SQLX_OFFLINE: true
  run: cargo build --release

// 패턴 2: 미들웨어로 라우트 그룹 전체를 보호
let protected_routes = Router::new()
    .route("/profile", get(get_profile))
    .route("/posts", post(create_post))
    .route_layer(middleware::from_fn_with_state(
        app_state.clone(),
        jwt_auth_middleware,
    ));
 
let public_routes = Router::new()
    .route("/auth/login", post(login))
    .route("/auth/register", post(register))
    .route("/health", get(health));      // 인증 불필요한 헬스체크
 
let app = Router::new()
    .merge(protected_routes)
    .merge(public_routes)
    .with_state(app_state);

async fn health(State(state): State<AppState>) -> impl IntoResponse {
    match sqlx::query("SELECT 1").execute(&state.db).await {
        Ok(_)  => StatusCode::OK,
        Err(_) => StatusCode::SERVICE_UNAVAILABLE,
    }
}

[dependencies]
axum = "0.8"
tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres", "uuid", "time", "chrono"] }
jsonwebtoken = "9"
axum-extra = { version = "0.9", features = ["typed-header"] }
tower-http = { version = "0.6", features = ["cors", "trace"] }
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
dotenvy = "0.15"
chrono = { version = "0.4", features = ["serde"] }

-- migrations/20240101000001_create_users.sql
CREATE TABLE users (
    id            BIGSERIAL PRIMARY KEY,
    email         VARCHAR(255) UNIQUE NOT NULL,
    name          VARCHAR(100) NOT NULL,
    password_hash TEXT NOT NULL,
    created_at    TIMESTAMPTZ DEFAULT NOW() NOT NULL
);

use sqlx::PgPool;
use std::sync::Arc;
 
#[derive(Clone)]
pub struct AppState {
    pub db: PgPool,
    pub jwt_secret: Arc<str>,    // Clone 시 문자열 버퍼 복사 없이 참조 카운트만 증가
}
 
impl AppState {
    pub async fn new() -> Result<Self, Box<dyn std::error::Error>> {
        dotenvy::dotenv().ok();
 
        let database_url = std::env::var("DATABASE_URL")
            .expect("DATABASE_URL must be set");
        let jwt_secret = std::env::var("JWT_SECRET")
            .expect("JWT_SECRET must be set");
 
        let db = sqlx::postgres::PgPoolOptions::new()
            .max_connections(10)
            .acquire_timeout(std::time::Duration::from_secs(3))
            .connect(&database_url)
            .await?;
 
        // 앱 시작 시 자동으로 마이그레이션 적용
        sqlx::migrate!("./migrations").run(&db).await?;
 
        Ok(Self {
            db,
            jwt_secret: jwt_secret.into(),
        })
    }
}

use axum::{
    extract::FromRequestParts,
    http::{request::Parts, StatusCode},
    response::{IntoResponse, Response},
    Json,
};
use axum_extra::{
    headers::{authorization::Bearer, Authorization},
    TypedHeader,
};
use jsonwebtoken::{decode, DecodingKey, Validation};
use serde::{Deserialize, Serialize};
 
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Claims {
    pub sub: i64,    // 사용자 ID를 처음부터 i64로 저장 — 핸들러에서 파싱 불필요
    pub exp: usize,
    pub iat: usize,
}
 
#[derive(Debug)]
pub enum AuthError {
    MissingToken,
    InvalidToken,
    ExpiredToken,
}
 
impl IntoResponse for AuthError {
    fn into_response(self) -> Response {
        let (status, message) = match self {
            AuthError::MissingToken => (StatusCode::UNAUTHORIZED, "토큰이 필요합니다"),
            AuthError::InvalidToken => (StatusCode::UNAUTHORIZED, "유효하지 않은 토큰입니다"),
            AuthError::ExpiredToken => (StatusCode::UNAUTHORIZED, "만료된 토큰입니다"),
        };
        (status, Json(serde_json::json!({ "error": message }))).into_response()
    }
}
 
// AppState를 직접 받아 jwt_secret에 접근 — 매 요청마다 env::var 호출 없음
impl FromRequestParts<AppState> for Claims {
    type Rejection = AuthError;
 
    async fn from_request_parts(
        parts: &mut Parts,
        state: &AppState,
    ) -> Result<Self, Self::Rejection> {
        let TypedHeader(Authorization(bearer)) =
            TypedHeader::<Authorization<Bearer>>::from_request_parts(parts, state)
                .await
                .map_err(|_| AuthError::MissingToken)?;
 
        let token_data = decode::<Claims>(
            bearer.token(),
            &DecodingKey::from_secret(state.jwt_secret.as_bytes()),
            &Validation::default(),
        )
        .map_err(|e| match e.kind() {
            jsonwebtoken::errors::ErrorKind::ExpiredSignature => AuthError::ExpiredToken,
            _ => AuthError::InvalidToken,
        })?;
 
        Ok(token_data.claims)
    }
}

#[derive(Debug, Serialize, sqlx::FromRow)]
pub struct UserProfile {
    pub id: i64,
    pub email: String,
    pub name: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
}
 
pub async fn get_my_profile(
    claims: Claims,
    State(state): State<AppState>,
) -> impl IntoResponse {
    let result = sqlx::query_as!(
        UserProfile,
        "SELECT id, email, name, created_at FROM users WHERE id = $1",
        claims.sub    // i64 타입 그대로 사용
    )
    .fetch_optional(&state.db)
    .await;
 
    match result {
        Ok(Some(profile)) => (StatusCode::OK, Json(profile)).into_response(),
        Ok(None)          => StatusCode::NOT_FOUND.into_response(),
        Err(_)            => StatusCode::INTERNAL_SERVER_ERROR.into_response(),
    }
}

# ---- 빌드 스테이지 ----
FROM rust:alpine AS builder
# 버전을 고정하고 싶다면 rust:1.82-alpine 처럼 명시하는 것도 좋습니다
 
RUN apk add --no-cache musl-dev pkgconfig openssl-dev
 
WORKDIR /app
 
# 의존성 레이어 캐싱: Cargo 파일만 먼저 복사해 의존성을 별도 레이어로 분리
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo 'fn main() {}' > src/main.rs
RUN cargo build --release --target x86_64-unknown-linux-musl
RUN rm -f target/x86_64-unknown-linux-musl/release/deps/api*
 
# 실제 소스 복사 및 빌드
COPY . .
ENV SQLX_OFFLINE=true    # .sqlx/ 메타데이터 사용 — DB 없이 빌드
RUN cargo build --release --target x86_64-unknown-linux-musl
 
# ---- 런타임 스테이지 ----
FROM scratch
 
COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/api /api
COPY --from=builder /app/migrations /migrations
 
EXPOSE 3000
CMD ["/api"]

# docker-compose.yml
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://user:pass@db:5432/mydb
      JWT_SECRET: ${JWT_SECRET}          # .env에서 주입 — 평문 하드코딩 금지
      RUST_LOG: info
    depends_on:
      db:
        condition: service_healthy       # 이 줄이 없으면 간헐적 연결 실패 발생
    restart: unless-stopped
 
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: mydb
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user -d mydb"]
      interval: 5s
      timeout: 3s
      retries: 5
      start_period: 10s    # 초기 기동 시 데이터 파일 초기화에 걸리는 시간을 유예
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped
 
volumes:
  pgdata: