Rust Axum Power: Build a Blazing Web API Fast Today

Axum turns Rust into a serious API framework. You'll map routes to async functions, pull typed inputs from extractors, and stack Tower middleware with one method call. The compiler checks your wiring.

It rewards small decisions: shared state behind Arc, errors as enums, timeouts on every route. Skip them and you'll debug 415s at midnight.

You'll ship a health-checked JSON API with tracing and timeouts, then see how one team cut p99 from 840ms to 120ms. APIs stay boring.

The router maps paths to handlers in a few lines. Router::new().route("/health", get(health)) binds GET to an async function returning a static string. Routes compose with .nest() for versioned prefixes like /v1.

Order matters: register specific paths before parameterized ones. A greedy /{id} route placed first swallows /health and /metrics. List routes from most to least specific and test each.

Extractors turn raw requests into typed values. Path<Uuid> parses IDs, Query<Filter> parses search strings, Json<Order> deserializes bodies, and State<Arc<AppState>> injects shared pools. Wrong shapes fail with 400 or 415 before your code runs.

Derive Deserialize on every input struct and test with real curl commands. The compiler plus serde validate more than hand-written checks ever will.

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

#[tokio::main]
async fn main() {
    let app = Router::new().route("/health", get(health));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

async fn health() -> &'static str {
    "ok"
}

Shared state lives in one struct behind Arc. struct AppState { pool: DbPool, config: Config } holds everything handlers need, injected once with .with_state(Arc::new(state)). Each request clones only the Arc, costing nanoseconds.

Keep `Send + Sync` members inside: Tokio workers move handlers across threads. tokio::sync primitives compose; std blocking ones stall. cargo check proves the bounds hold.

use axum::{Router, routing::get};
use std::sync::Arc;

#[derive(Clone)]
struct AppState {
    version: &'static str,
}

async fn version(axum::extract::State(s): axum::extract::State<Arc<AppState>>) -> String {
    s.version.to_string()
}

#[tokio::main]
async fn main() {
    let state = Arc::new(AppState { version: "1.4.2" });
    let app = Router::new().route("/version", get(version)).with_state(state);
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Tower layers add cross-cutting behavior with .layer(). TraceLayer logs method, path, status, and latency per request. TimeoutLayer caps handler time so slow vendors cannot park workers forever.

Stack them deliberately: tracing outermost for full visibility, timeout outside auth so credential stalls shed, compression innermost near the handler. Wrong order means blind spots during the incidents you most need logs.

Errors should be an enum implementing IntoResponse. Each variant maps to a status code plus a JSON body: NotFound becomes 404, Db becomes 503 with a retry hint. Handlers return Result<Json<T>, AppError> uniformly.

This kills response-shape drift: every route speaks the same error dialect. Clients parse one schema, alerting groups by variant, and new handlers inherit the mapping automatically.