Какие production-риски есть у Axum (Rust): blocking code, connection pooling, config, auth, observability, deploy или graceful shutdown?

Blocking code

Так же как и в Actix, синхронный код внутри async-хендлера блокирует tokio-поток. Используйте tokio::task::spawn_blocking:

use axum::{routing::get, Router};
use tokio::task;

async fn process_file() -> String {
    task::spawn_blocking(|| {
        // синхронное чтение или CPU-тяжёлая операция
        std::fs::read_to_string("/large/file.csv").unwrap()
    })
    .await
    .unwrap()
}

Production-риски Axum

Axum построен поверх tokio и tower, что даёт гибкость, но требует явной настройки каждого аспекта production-готовности.

Connection pooling

Стандартный стек — sqlx::PgPool, передаётся через axum::Extension или State:

use axum::{extract::State, routing::get, Router};
use sqlx::PgPool;

#[derive(Clone)]
struct AppState {
    db: PgPool,
}

#[tokio::main]
async fn main() {
    let pool = sqlx::postgres::PgPoolOptions::new()
        .max_connections(20)
        .acquire_timeout(std::time::Duration::from_secs(3))
        .connect(&std::env::var("DATABASE_URL").unwrap())
        .await
        .unwrap();

    let state = AppState { db: pool };

    let app = Router::new()
        .route("/users", get(list_users))
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Auth

Axum использует tower middleware для auth. Типичный подход — JWT через кастомный FromRequestParts extractor:

use axum::{
    async_trait,
    extract::FromRequestParts,
    http::{request::Parts, StatusCode},
};

pub struct AuthUser { pub id: uuid::Uuid }

#[async_trait]
impl<S> FromRequestParts<S> for AuthUser
where S: Send + Sync
{
    type Rejection = (StatusCode, &'static str);

    async fn from_request_parts(parts: &mut Parts, _: &S)
        -> Result<Self, Self::Rejection>
    {
        let token = parts.headers
            .get("Authorization")
            .and_then(|v| v.to_str().ok())
            .and_then(|v| v.strip_prefix("Bearer "))
            .ok_or((StatusCode::UNAUTHORIZED, "Missing token"))?;

        verify_jwt(token)
            .map(|claims| AuthUser { id: claims.sub })
            .map_err(|_| (StatusCode::UNAUTHORIZED, "Invalid token"))
    }
}

Observability через tower-http

use tower_http::{
    trace::TraceLayer,
    timeout::TimeoutLayer,
    compression::CompressionLayer,
};

let app = Router::new()
    .route("/", get(handler))
    .layer(TraceLayer::new_for_http())
    .layer(TimeoutLayer::new(std::time::Duration::from_secs(30)))
    .layer(CompressionLayer::new());

Graceful shutdown

let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();

axum::serve(listener, app)
    .with_graceful_shutdown(shutdown_signal())
    .await
    .unwrap();

async fn shutdown_signal() {
    tokio::signal::ctrl_c().await.expect("failed to install signal");
    tracing::info!("shutdown signal received");
}

Подводные камни

• Axum State требует Clone — тяжёлые структуры без Arc будут копироваться на каждый запрос.
• tower middleware применяется в обратном порядке при стекировании через .layer() — порядок важен для логирования и auth.
• Router::merge() не проверяет коллизии путей в compile time — дублирование маршрутов приводит к runtime-конфликтам.
• Extractor ошибки (400 Bad Request) от Json<T> не кастомизированы по умолчанию — нужен JsonRejection обработчик.
• Отсутствие таймаута на соединение позволяет slow-loris атакам исчерпать пул — TimeoutLayer обязателен.
• Panic в хендлере крашит tokio-таску но не весь процесс — добавьте tower::ServiceBuilder::new().layer(CatchPanicLayer::new()).
• При использовании WebSocket через axum — graceful shutdown не дожидается закрытия WS-соединений автоматически.
• В Kubernetes без preStop hook SIGTERM приходит одновременно с удалением из endpoints — часть запросов получит connection refused.

• Говорить только о запуске Axum (Rust), но не об эксплуатации
• Не упоминать observability, обновления, безопасность и rollback
• Описывать риски абстрактно, без способов их снижать

• Видит production-риски Axum (Rust)
• Говорит про monitoring, rollout, rollback и безопасность
• Умеет ранжировать риски по вероятности и влиянию