Deploying a Rust Axum API on Persistent Containers
Rust Axum is the modern Rust web framework, built on top of Tokio (the async runtime) and Hyper (the HTTP library). It is type-safe, fast, and ergonomic, which makes it a great choice for high-performance APIs. But deploying Rust apps has traditionally been painful, because Rust's compilation is slow (30 seconds to 5 minutes for a typical app), the resulting binary needs to be stripped and optimized, and the container needs the right system libraries. Deployxa's zero-config engine handles all of this, compiling your Rust code in a release build, stripping the binary, and running it in a minimal container. Here is how to deploy a Rust Axum API on Deployxa.
The direct answer is that Deployxa auto-detects Rust from your Cargo.toml and Axum from your source code (by detecting the axum crate). It configures the build and start commands automatically: the build command compiles the Rust code in release mode (cargo build --release), and the start command runs the resulting binary (./target/release/my-app). The Rust toolchain is included in the build container, and the binary runs in a minimal runtime container. You do not write a Dockerfile, you do not configure the build, and you do not manage the binary. The platform handles all of it, just as it does for Go and Node.js apps.
Why Rust Axum Is a Great Choice for Performance-Critical APIs
Three reasons explain why Rust Axum is a great choice for performance-critical APIs. First, Rust is fast: it compiles to a native binary with zero runtime overhead, which means it is as fast as C and C++ but with memory safety guarantees. For CPU-intensive APIs (e.g., data processing, image manipulation, cryptographic operations), Rust is hard to beat. Second, Rust is safe: the borrow checker prevents memory leaks, data races, and null pointer dereferences at compile time, which means production crashes are rare. For APIs that need to be highly reliable, Rust's safety guarantees are a significant advantage. Third, Axum is ergonomic: its type-safe routing, extractors, and error handling make it pleasant to work with, which means the LLM can generate correct Axum code with minimal guidance. The result is that AI assistants can generate clean, correct, high-performance Rust Axum APIs with minimal guidance.
The trade-off is that Rust has a steep learning curve, which means the LLM occasionally generates code that does not compile (especially around lifetimes and ownership). The AutoRepairService does not handle Rust compilation errors (it focuses on missing npm packages), so you will need to fix compilation errors manually. But once the code compiles, the resulting binary is fast, safe, and reliable.
The Architecture: Rust Binary + Database
Here is how Deployxa deploys a Rust Axum API.
The Rust container
The ingestion service detects Rust from your Cargo.toml and Axum from your source code. It configures the build and start commands:
- Build command: cargo build --release
- Start command: ./target/release/my-app
- Runtime: A minimal Linux container with the necessary system libraries (libc, libssl, etc.)
The database connection
Your Rust app connects to the database via the DATABASE_URL environment variable, which you set in the Deployxa dashboard. The connection is managed by your database library (e.g., sqlx for async Postgres, diesel for ORM), which handles connection pooling automatically.
The reverse proxy
Traefik v3 routes traffic from your custom domain to the Rust container, with automatic SSL via Let's Encrypt.
Step-by-Step: Deploying a Rust Axum API
Here is the exact workflow for a typical Rust Axum API.
Step 1: Create your Rust Axum app
// src/main.rs
use axum::{
routing::get,
Router,
extract::State,
response::Json,
};
use serde_json::json;
use sqlx::PgPool;
use std::env;
struct AppState {
db: PgPool,
}
#[tokio::main]
async fn main() {
let database_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
let pool = sqlx::postgres::PgPoolOptions::new()
.max_connections(10)
.connect(&database_url)
.await
.expect("Failed to connect to database");
let state = AppState { db: pool };
let app = Router::new()
.route("/", get(root))
.route("/health", get(health))
.with_state(state);
let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port))
.await
.unwrap();
axum::serve(listener, app).await.unwrap();
}
async fn root() -> Json {
Json(json!({ "message": "Hello, World!" }))
}
async fn health(State(state): State) -> Json {
match sqlx::query("SELECT 1").execute(&state.db).await {
Ok(_) => Json(json!({ "status": "ok" })),
Err(e) => Json(json!({ "status": "error", "message": e.to_string() })),
}
} Step 2: Create Cargo.toml
[package]
name = "my-app"
version = "0.1.0"
edition = "2021"
[dependencies]
axum = "0.7"
tokio = { version = "1", features = ["full"] }
serde_json = "1"
sqlx = { version = "0.7", features = ["runtime-tokio", "postgres"] }
[profile.release]
strip = true
lto = true
codegen-units = 1Step 3: Push to GitHub
git init
git add .
git commit -m "rust axum api"
git remote add origin https://github.com/yourname/my-app.git
git push -u origin mainStep 4: Connect to Deployxa
In the Deployxa dashboard, connect your repository. Deployxa auto-detects Rust and Axum:
[ingest] Detected Rust project
[ingest] Framework: axum
[ingest] Runtime: rust 1.75
[ingest] Build command: cargo build --release
[ingest] Start command: ./target/release/my-app
[ingest] Port: $PORTStep 5: Configure environment variables
In the Deployxa dashboard, add DATABASE_URL with your Postgres connection string. The pre-flight scanner will warn you if it is missing.
Step 6: Deploy
Click Deploy. The build compiles the Rust code in release mode (which takes 30 seconds to 5 minutes, depending on the app's complexity), the container starts, and your API is live. The release profile strips the binary and enables LTO (Link Time Optimization), which produces a small, fast binary.
Step 7: Add a custom domain
Add a custom domain in the Deployxa dashboard. SSL is provisioned automatically.
Step 8: Verify with deployxa doctor
Run deployxa doctor to verify health. The 14-point readiness engine checks SSL, DNS, environment variables, health endpoints, and container status.
Common Pitfalls and Troubleshooting
The first pitfall is compilation time. Rust's release build is slow (30 seconds to 5 minutes), because the compiler performs many optimizations. This is expected, and Deployxa's persistent build cache helps (subsequent builds are faster, because dependencies are cached). The second pitfall is the PORT environment variable. Rust apps typically hardcode the port, but Deployxa assigns a dynamic port via the PORT environment variable. The fix is to use env::var("PORT") as shown in the code above. The third pitfall is system library dependencies. If your Rust app uses OpenSSL (via the openssl crate), the container needs libssl-dev and pkg-config installed. The fix is to use the rustls crate instead, which is a pure-Rust TLS implementation that does not require system libraries. The fourth pitfall is graceful shutdown. When Deployxa stops your container, your app should close the database connection and stop accepting new requests. The fix is to use Tokio's signal::ctrl_c() and Axum's serve method with graceful shutdown. The fifth pitfall is binary size. Rust release binaries are 5 to 20MB, which is fine for runtime but can slow down the build. The fix is to use strip = true and lto = true in the release profile (as shown above), which reduces the binary size by 30 to 50 percent.
Performance: Rust Axum vs Go Fiber vs Node.js
Rust Axum, Go Fiber, and Node.js (with Fastify) are the three fastest web frameworks in their respective languages. Rust Axum is the fastest, because Rust has zero runtime overhead and Axum is built on Hyper (which is highly optimized). Go Fiber is a close second, because Go compiles to a native binary and Fiber is built on Fasthttp. Node.js with Fastify is the slowest of the three, because Node.js has the V8 runtime overhead, but it is still fast enough for most APIs. The exact performance difference depends on the workload: for simple JSON responses, Rust is 2 to 3x faster than Go and 5 to 10x faster than Node.js. For database-heavy endpoints, the difference is smaller, because the database is the bottleneck. For most apps, the performance difference does not matter, because the bottleneck is elsewhere (database, external APIs, network). For apps where every microsecond matters (e.g., high-frequency trading, real-time bidding), Rust is the right choice. For more on performance, see our article on SPA vs SSR hardware sizing.
Advanced Rust Axum Patterns
Beyond the basics, Rust Axum apps benefit from several advanced patterns. The first is error handling. Rust's Result type and the ? operator make error handling explicit, but you need a consistent error type across your app. The fix is to define an AppError enum that implements IntoResponse, so your handlers can return Result
Conclusion: Rust Without the Compilation Pain
Rust Axum is the modern Rust web framework, and deploying it should be as simple as pushing to Git. Deployxa's zero-config engine makes it so: no Dockerfile, no build configuration, no binary management. The persistent build cache handles Rust's slow compilation, and the release profile produces a small, fast binary. Stop writing Dockerfiles for Rust apps and start shipping.
Ready to deploy your Rust Axum API? Drag your project to Deployxa Drop for an instant live preview, or install the CLI with npm i -g @deployxa/cli and deploy from your terminal. For more on polyglot deployment, see our articles on deploying Go Fiber APIs and the FastAPI + Next.js monorepo. Learn about running BullMQ background workers and deploying .NET 8 Web APIs in our companion articles. Explore our free developer tools to speed up your workflow.