Production-ready Rust backend development with Axum framework and PostgreSQL. Master async patterns, tower middleware, SQLx database operations, authentication (JWT/OAuth), testing strategies, and deployment. Use when building REST APIs, microservices, or any Rust web backend with Axum.
Production-ready patterns for building scalable Rust backends with Axum and PostgreSQL.
use axum::{routing::get, Router};
#[tokio::main]
async fn main() {
let app = Router::new()
.route("/", get(|| async { "Hello, Axum!" }));
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
axum::serve(listener, app).await.unwrap();
}
[dependencies]
axum = "0.7"
tokio = { version = "1", features = ["full"] }
tower = "0.4"
tower-http = { version = "0.5", features = ["cors", "trace"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
sqlx = { version = "0.7", features = ["runtime-tokio", "postgres", "uuid", "time"] }
uuid = { version = "1", features = ["v4", "serde"] }
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
thiserror = "1"
anyhow = "1"
| Topic | File | Description |
|---|---|---|
| Rust Idioms | rust-patterns.md | Enums, iterators, error handling |
| Async/Tokio | async-tokio.md | Async patterns, spawn, channels |
| Topic | File | Description |
|---|---|---|
| Axum Guide | axum-complete-guide.md | Routing, handlers, state |
| Extractors | axum-extractors.md | Path, Query, Json, State |
| Middleware | middleware-patterns.md | Tower layers, auth middleware |
| Topic | File | Description |
|---|---|---|
| SQLx | sqlx-postgresql.md | Queries, transactions, migrations |
| Patterns | database-patterns.md | Connection pools, optimization |
| Topic | File | Description |
|---|---|---|
| Project Structure | project-structure.md | Folder organization |
| Patterns | architecture-patterns.md | Microservices, modulith |
| Topic | File | Description |
|---|---|---|
| Authentication | authentication.md | JWT, OAuth 2.1, sessions |
| Security | security-owasp.md | OWASP Top 10 for Rust |
| Topic | File | Description |
|---|---|---|
| Testing | testing-guide.md | Unit, integration, E2E |
| Error Handling | error-handling.md | HTTP errors, thiserror |
| Topic | File | Description |
|---|---|---|
| Deployment | deployment.md | Docker, Kubernetes |
| Monitoring | monitoring.md | Tracing, Prometheus |
✅ Choose Axum when:
- Building new Rust web projects
- Need tower ecosystem compatibility
- Want ergonomic, type-safe extractors
- Prefer modular, composable design
- Need excellent async performance
Actix-web - When you need:
- Maximum raw performance (benchmarks leader)
- Actor model for complex state
- Established ecosystem with more examples
Rocket - When you need:
- Simplest learning curve
- Most "magical" developer experience
- Rapid prototyping
use axum::{http::StatusCode, response::IntoResponse, Json};
use serde_json::json;
pub enum AppError {
NotFound(String),
Database(sqlx::Error),
Unauthorized,
}
impl IntoResponse for AppError {
fn into_response(self) -> axum::response::Response {
let (status, message) = match self {
Self::NotFound(msg) => (StatusCode::NOT_FOUND, msg),
Self::Database(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
Self::Unauthorized => (StatusCode::UNAUTHORIZED, "Unauthorized".into()),
};
(status, Json(json!({ "error": message }))).into_response()
}
}
use axum::{extract::{Path, State}, Json};
use uuid::Uuid;
async fn get_user(
State(pool): State<PgPool>,
Path(id): Path<Uuid>,
) -> Result<Json<User>, AppError> {
let user = sqlx::query_as!(User, "SELECT * FROM users WHERE id = $1", id)
.fetch_optional(&pool)
.await?
.ok_or_else(|| AppError::NotFound("User not found".into()))?;
Ok(Json(user))
}
use std::sync::Arc;
use sqlx::PgPool;
#[derive(Clone)]
pub struct AppState {
pub db: PgPool,
pub config: Arc<Config>,
}
let app = Router::new()
.route("/users/:id", get(get_user))
.with_state(AppState { db: pool, config: Arc::new(config) });