Axum이 Rust 웹 개발의 미래가 될 수 있는 이유

Rust 개발자라면 Axum에 대해 들어봤을 것입니다. Tokio 팀에서 소개한 이 웹 프레임워크는 불과 몇 년 만에 커뮤니티에서 가장 좋아하는 프레임워크가 되었으며, 22k 개 이상의 GitHub 스타를 자랑하며 동시대의 다른 프레임워크를 훨씬 능가합니다. Axum을 돋보이게 만드는 것은 무엇일까요? Actix-web 및 Rocket과 같은 이전 프레임워크와 비교하여 어떤 고유한 장점을 제공할까요? 오늘 우리는 이 놀라운 프레임워크에 대해 자세히 알아볼 것입니다.

I. Axum의 "제로 비용 추상화" 철학

Axum의 핵심 경쟁 우위는 Rust의 언어 기능과 완벽하게 일치하는 설계 철학에 있습니다. 많은 프레임워크가 "배터리 포함" 접근 방식을 추구하는 것과 달리 Axum은 "린 디자인"을 채택하여 핵심 웹 개발 추상화만 제공하는 동시에 추가 기능이 생태계를 통해 자연스럽게 나타나도록 합니다.

이 디자인은 인지적 부담을 직접적으로 줄여줍니다. 이 간단한 Hello World 예제를 고려해 보세요.

use axum::{routing::get, Router};
use std::net::SocketAddr;

#[tokio::main]
async fn main() {
    // 경로 빌드
    let app = Router::new().route("/", get(|| async { "Hello, World!" }));

    // 수신 주소 정의
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("listening on {}", addr);

    // 서버 시작
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

이 코드는 프레임워크 특정 개념을 거의 포함하지 않으며 Rust 개발자의 직관과 완벽하게 일치합니다. 대조적으로 Actix-web에서 이와 동등한 구현을 하려면 액터 모델 개념을 이해해야 하고, Rocket은 매크로 속성 및 수명 주기 관리를 처리해야 합니다. 둘 다 초보자에게는 덜 친숙합니다.

Axum의 "제로 비용" 접근 방식은 또한 유형 시스템의 정교한 사용법으로 나타납니다. 엑스트랙터 시스템을 통해 개발자는 함수 매개변수를 통해 필요한 요청 데이터를 선언할 수 있으며, 프레임워크는 컴파일 시점에 모든 종속성을 검증합니다.

use axum::{
    extract::{Path, Query},
    routing::get,
    Router,
};
use serde::Deserialize;

#[derive(Deserialize)]
struct QueryParams {
    page: u32,
    limit: u32,
}

// 경로 및 쿼리 매개변수 모두 추출
async fn handler(
    Path(user_id): Path<u64>,
    Query(params): Query<QueryParams>,
) -> String {
    format!(
        "User ID: {}, Page: {}, Limit: {}",
        user_id, params.page, params.limit
    )
}

let app = Router::new()
    .route("/users/:user_id", get(handler));

이 디자인은 코드를 단순화할 뿐만 아니라 수많은 런타임 오류를 컴파일 타임 오류로 변환합니다. 이는 Rust 개발자가 채택한 "안전 우선" 아이디어를 완벽하게 구현합니다.

II. Tokio 생태계와의 원활한 통합

Tokio 팀의 Axum 개발은 비동기 런타임과의 심층적인 통합에 상당한 이점을 제공합니다. Rust의 가장 성숙한 비동기 런타임인 Tokio는 광대한 생태계와 프로덕션에서 입증된 성능을 자랑합니다.

이 통합은 높은 동시성 시나리오에서 빛을 발합니다. 예를 들어 데이터베이스 작업을 수행할 때 Axum은 Tokio의 비동기 IO 기능을 직접 활용할 수 있습니다.

use axum::{routing::get, Router};
use sqlx::PgPool;
use std::net::SocketAddr;

async fn users_handler(pool: PgPool) -> String {
    // sqlx로 비동기 데이터베이스 쿼리 수행
    let users = sqlx::query!("SELECT id, name FROM users")
        .fetch_all(&pool)
        .await
        .unwrap();

    format!("Found {} users", users.len())
}

#[tokio::main]
async fn main() {
    // 데이터베이스 연결 풀 생성
    let pool = PgPool::connect("postgres://user:pass@localhost/db")
        .await
        .unwrap();

    // 연결 풀을 애플리케이션 상태에 삽입
    let app = Router::new()
        .route("/users", get(users_handler))
        .with_state(pool); // 상태는 필요한 핸들러에 자동으로 전달됩니다.

    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

대조적으로 Actix-web은 비동기 작업을 지원하지만 액터 모델과 메시지 전달 메커니즘이 필요하여 추가 추상화 계층이 추가됩니다. Rocket은 버전 0.5에서 비동기 지원을 도입했지만 생태계가 덜 성숙했습니다.

Axum의 상태 관리 시스템은 유사한 설계 방식을 보여줍니다. with_state 메서드를 통해 삽입된 애플리케이션 상태는 엑스트랙터를 통해 모든 핸들러에서 액세스할 수 있으므로 수동 전달의 필요성이 없어지고 종속성 관리가 크게 단순화됩니다.

III. 다른 인기 프레임워크와의 비교 분석

Axum의 장점을 더 잘 이해하기 위해 Rust 생태계의 다른 두 가지 주요 프레임워크와 비교해 보겠습니다.

1. Axum vs Actix-web

Actix-web은 Rust 생태계에서 가장 먼저 등장한 성숙한 웹 프레임워크 중 하나로, 높은 성능으로 유명합니다. 그러나 설계 철학은 Axum과 크게 다릅니다.

• 추상화 수준: Actix-web은 액터 모델을 기반으로 하며 액터 및 컨텍스트와 같은 개념을 이해해야 합니다. Axum은 기본 Rust 구문을 더 밀접하게 준수합니다.
• 성능: 벤치마크에서 둘 다 비슷하게 수행되지만 Axum은 일반적으로 메모리 사용량이 더 적습니다.
• 생태계: Actix-web은 자체 비동기 런타임을 가지고 있어 Tokio 생태계와 약간의 분리가 발생합니다. Axum은 Tokio와 완전히 통합되어 있습니다.

다음은 두 프레임워크 모두에서 동일한 기능을 구현하는 코드 비교입니다.

Actix-web 버전:

use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};

#[get("/users/{user_id}")]
async fn get_user(
    user_id: web::Path<u64>,
    db_pool: web::Data<sqlx::PgPool>,
) -> impl Responder {
    let user = sqlx::query!("SELECT id, name FROM users WHERE id = $1", user_id)
        .fetch_one(db_pool.get_ref())
        .await
        .map_err(|_| HttpResponse::NotFound());

    match user {
        Ok(user) => HttpResponse::Ok().body(format!("User: {}", user.name)),
        Err(resp) => resp,
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let pool = sqlx::PgPool::connect("postgres://user:pass@localhost/db")
        .await
        .unwrap();

    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(pool.clone()))
            .service(get_user)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Axum 버전:

use axum::{
    extract::{Path, State},
    http::StatusCode,
    routing::get,
    Router,
};
use sqlx::PgPool;
use std::net::SocketAddr;

async fn get_user(
    Path(user_id): Path<u64>,
    State(pool): State<PgPool>,
) -> Result<String, StatusCode> {
    let user = sqlx::query!("SELECT id, name FROM users WHERE id = $1", user_id)
        .fetch_one(&pool)
        .await
        .map_err(|_| StatusCode::NOT_FOUND)?;

    Ok(format!("User: {}", user.name))
}

#[tokio::main]
async fn main() {
    let pool = sqlx::PgPool::connect("postgres://user:pass@localhost/db")
        .await
        .unwrap();

    let app = Router::new()
        .route("/users/:user_id", get(get_user))
        .with_state(pool);

    let addr = SocketAddr::from(([127, 0, 0, 1], 8080));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Axum의 코드는 표준 Rust 구문과 더 유사하며 프레임워크 특정 응답자 패턴을 학습할 필요가 없는 보다 자연스러운 오류 처리를 제공합니다.

2. Axum vs Rocket

Rocket은 우아한 라우팅 매크로와 자동 문서 생성으로 유명하지만 개발 경로는 Axum과 다릅니다.

• 성숙도: Rocket은 버전 0.4와 0.5 사이에 오랜 시간이 걸렸으며 비동기 지원은 0.5에서만 제공되었습니다. Axum은 처음부터 비동기를 위해 설계되었습니다.
• 유연성: Rocket은 많은 기능에 대한 고정 구현을 통해 "구성보다 규칙"을 지향합니다. Axum은 더 많은 유연성을 제공하여 개발자가 필요에 따라 기능을 구성할 수 있습니다.
• 컴파일 타임 검사: 둘 다 컴파일 타임 안전성을 강조하지만 Axum의 엑스트랙터 시스템이 더 유연합니다.

Rocket의 경로 정의는 간결하지만 매크로 마법에 크게 의존합니다.

#[get("/users/<user_id>?<page>&<limit>")]
fn get_users(user_id: u64, page: u32, limit: u32) -> String {
    format!("User: {}, Page: {}, Limit: {}", user_id, page, limit)
}

Axum은 명시적 엑스트랙터 선언이 필요하지만 더 명확한 유형 시스템과 더 나은 확장성을 제공합니다.

async fn get_users(
    Path(user_id): Path<u64>,
    Query(params): Query<QueryParams>,
) -> String {
    format!("User: {}, Page: {}, Limit: {}", user_id, params.page, params.limit)
}

IV. Axum의 생태계 및 실제 예제

비교적 젊지만 Axum의 생태계는 빠르게 성장하여 완전한 웹 개발 툴체인을 형성하고 있습니다.

• 데이터베이스 액세스: sqlx, diesel-async는 비동기 데이터베이스 지원을 제공합니다.
• 인증: axum-login, axum-jwt는 인증 및 권한 부여를 처리합니다.
• 템플릿 엔진: askama, minijinja는 서버 측 렌더링을 위한 것입니다.
• API 문서: OpenAPI 지원을 위한 Swagger-ui가 있는 utoipa

인증된 RESTful API를 구현하는 보다 완전한 실제 예제를 살펴보겠습니다.

use axum::{
    extract::{Path, State},
    http::StatusCode,
    middleware,
    routing::{delete, get, post},
    Json, Router,
};
use axum_jwt::JwtMiddleware;
use serde::{Deserialize, Serialize};
use sqlx::{FromRow, PgPool};
use std::net::SocketAddr;

// 데이터 모델 정의
#[derive(Serialize, FromRow)]
struct User {
    id: u64,
    username: String,
    email: String,
}

#[derive(Deserialize)]
struct CreateUserRequest {
    username: String,
    email: String,
    password: String,
}

// JWT 인증 미들웨어
fn auth_middleware() -> JwtMiddleware {
    JwtMiddleware::new("secret".as_bytes())
}

// 경로 정의
fn routes(pool: PgPool) -> Router {
    // 공개 경로
    let public_routes = Router::new()
        .route("/users", post(create_user))
        .route("/login", post(login));

    // 보호된 경로
    let protected_routes = Router::new()
        .route("/users", get(list_users))
        .route("/users/:id", get(get_user))
        .route("/users/:id", delete(delete_user))
        .layer(middleware::from_fn_with_state(
            pool.clone(),
            auth_middleware,
        ));

    Router::new()
        .merge(public_routes)
        .merge(protected_routes)
        .with_state(pool)
}

// 핸들러 구현(세부 정보 생략됨)
async fn create_user(...) -> ... {}
async fn login(...) -> ... {}
async fn list_users(...) -> ... {}
async fn get_user(...) -> ... {}
async fn delete_user(...) -> ... {}

#[tokio::main]
async fn main() {
    let pool = PgPool::connect("postgres://user:pass@localhost/db")
        .await
        .unwrap();

    let app = routes(pool);
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

이 예제는 실제 프로젝트에서 일반적인 Axum 사용법을 보여줍니다. 미들웨어를 통한 인증 구현, 상태 관리를 통한 데이터베이스 연결 풀 삽입, 엑스트랙터를 사용한 요청 데이터 처리. 코드 구조는 명확하고 구성 요소 책임이 잘 정의되어 있어 최신 웹 개발 모범 사례를 준수합니다.

V. 개발자가 Axum을 좋아하는 이유

커뮤니티가 Axum에 애정을 갖는 이유는 설계 철학에서 비롯됩니다.

• Rust의 언어 기능 존중: 다른 언어의 프레임워크를 모방하는 대신 Axum은 Rust의 유형 시스템과 비동기 기능을 활용합니다.
• 점진적인 학습 곡선: 초보자는 간단한 예제로 빠르게 시작하고 필요에 따라 더 고급 기능을 점진적으로 학습할 수 있습니다.
• 균형 잡힌 추상화 수준: 과도한 추상화를 도입하지 않고도 저수준 HTTP 처리의 복잡성을 방지하여 개발자가 주요 세부 정보를 제어할 수 있습니다.
• 활성 커뮤니티 지원: Tokio 팀의 지속적인 투자와 활성 커뮤니티 기여는 프레임워크의 빠른 반복과 적시 문제 해결을 보장합니다.

2023 Rust 개발자 설문 조사에 따르면 Axum은 채택률에서 Actix-web을 넘어 가장 인기 있는 Rust 웹 프레임워크가 되었습니다. Vector 및 Tremor와 같은 많은 주요 프로젝트에서 웹 계층 솔루션으로 Axum을 채택했습니다.

VI. 결론: Axum의 미래 전망

Axum의 성공은 우연이 아닙니다. 언어 기능을 기반으로 구축하고 개발자 경험에 집중하며 생태계 협업에 의해 주도되는 Rust 웹 프레임워크 개발의 새로운 방향을 나타냅니다.

Rust가 계속 성숙하고 비동기 생태계가 완벽해짐에 따라 Axum은 앞으로도 계속 성장할 것으로 예상됩니다. 개발자의 경우 지금이 Axum을 배울 수 있는 좋은 시기입니다. 고성능 API 서비스를 구축하든, 실시간 통신 애플리케이션을 개발하든, 마이크로서비스 아키텍처를 만들든 Axum은 간결하고 안전하며 효율적인 솔루션을 제공합니다.

Rust 웹 프레임워크를 아직 결정하지 못했다면 Axum을 사용해 보세요. 바로 찾고 있던 "적합한" 프레임워크일 수 있습니다.

Leapcell: 최고의 서버리스 웹 호스팅

마지막으로 Rust 애플리케이션 배포에 가장 적합한 플랫폼인 **Leapcell**을 추천합니다.

🚀 좋아하는 언어로 빌드

JavaScript, Python, Go 또는 Rust로 간편하게 개발하세요.

🌍 무제한 프로젝트를 무료로 배포

사용한 만큼만 지불하세요. 요청도 없고 요금도 없습니다.

⚡ 사용한 만큼 지불, 숨겨진 비용 없음

유휴 요금 없이 원활한 확장성만 제공합니다.

📖 문서 탐색

🔹 Twitter에서 팔로우하세요: @LeapcellHQ