Building an HTTP Server in Rust with Axum A Popular Alternative to Actix-web

Rust has become a popular choice for building high-performance web servers due to its memory safety, concurrency model, and performance. While Actix-web is widely used, Axum is gaining traction as a powerful alternative built on Tokio and emphasizing type safety and ergonomics.

This guide will walk through setting up an HTTP server using Axum, handling routes, extracting parameters, and integrating middleware.

Axum is built on hyper (a low-level HTTP library) and integrates seamlessly with Tokio (an async runtime). Key benefits:

• Type-safe request handling - Uses Rust's strong type system.
• Asynchronous support - Fully compatible with async/await.
• Middleware support - Logging, authentication, and request transformation.
• Tower ecosystem - Uses Tower's middleware and service abstractions.

First, create a new Rust project:

cargo new axum-server
cd axum-server

Then, add dependencies to Cargo.toml:

[dependencies]
axum = "0.7"
tokio = { version = "1", features = ["full"] }
hyper = "1"
serde = { version = "1", features = ["derive"] }
serde_json = "1"

Create src/main.rs and add the following code:

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

#[tokio::main]
async fn main() {
    // Define a simple route
    let app = Router::new().route("/", get(root));

    // Define the address to listen on
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    println!("Server running at http://{}", addr);

    // Start the server
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

// Handler for the root route
async fn root() -> &'static str {
    "Hello, Axum!"
}

Run the server with:

cargo run

Visit http://127.0.0.1:3000 to see "Hello, Axum!" in the browser.

Axum allows extracting parameters directly from URLs. Modify main.rs:

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

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(root))
        .route("/hello/:name", get(greet));

    let addr = "127.0.0.1:3000".parse().unwrap();
    println!("Server running at http://{}", addr);

    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

async fn root() -> &'static str {
    "Welcome to Axum!"
}

async fn greet(Path(name): Path<String>) -> String {
    format!("Hello, {}!", name)
}

Now, visiting http://127.0.0.1:3000/hello/Rust returns "Hello, Rust!".

Axum supports JSON via serde. Modify main.rs:

use axum::{extract::Json, response::IntoResponse, routing::post, Router};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct User {
    name: String,
    age: u8,
}

async fn create_user(Json(user): Json<User>) -> impl IntoResponse {
    let response = format!("User {} ({} years old) created", user.name, user.age);
    Json(serde_json::json!({ "message": response }))
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/user", post(create_user));

    let addr = "127.0.0.1:3000".parse().unwrap();
    println!("Server running at http://{}", addr);

    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

Test with:

curl -X POST http://127.0.0.1:3000/user \
     -H "Content-Type: application/json" \
     -d '{"name": "Alice", "age": 25}'

Axum supports middleware via Tower. Add logging middleware:

use axum::{routing::get, Router};
use tower_http::trace::TraceLayer;
use tracing_subscriber;

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    let app = Router::new()
        .route("/", get(|| async { "Hello, Axum with logging!" }))
        .layer(TraceLayer::new_for_http());

    let addr = "127.0.0.1:3000".parse().unwrap();
    println!("Server running at http://{}", addr);

    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

This logs incoming requests automatically.

Axum and Actix-web are both powerful, but they have different strengths:

Axum follows a modular architecture where:

• Routers define routes and request handlers.
• Extractors parse incoming data.
• Middleware handles logging, authentication, etc.

graph TD;
    Client -->|Sends Request| Router;
    Router -->|Extracts Data| Handlers;
    Handlers -->|Processes Logic| Response;
    Response -->|Returns Data| Client;

Axum provides a simple, ergonomic, and type-safe alternative to Actix-web. It's built on Tokio, integrates with Hyper, and supports async handlers, middleware, and JSON processing.

If you need a safe, efficient, and modern Rust web framework, Axum is an excellent choice.

By following this guide, you have built:

• A basic HTTP server
• Routes with parameters
• JSON request handling
• Middleware logging

Next steps:

• Explore state management in Axum.
• Implement authentication and authorization.
• Use database integration with SQLx or Diesel.

Rust's ecosystem is growing, and Axum is at the forefront of web development in Rust.