Rust in web and systems

The web and systems half of the Rust ecosystem is mature and stable. If you have written async server code in any language, the Rust version reads as you would expect, but with stronger guarantees about lifetime, concurrency, and error handling. The crates worth knowing are few.

The async runtime

Tokio's pieces you will see constantly:

• tokio::spawn for new tasks.
• tokio::sync::{mpsc, oneshot, broadcast, watch} for channels.
• tokio::sync::{Mutex, RwLock} for async-aware locks (different from std::sync).
• tokio::time::{sleep, timeout, interval} for scheduling.
• tokio::task::spawn_blocking for CPU-bound work.

HTTP servers

For new projects, the default is Axum for HTTP REST/JSON and Tonic for gRPC. Both compose with the rest of the Tokio ecosystem via the tower::Service trait.

A minimal Axum server gives you a sense of the shape:

use axum::{routing::get, Json, Router};
use serde::Serialize;
 
#[derive(Serialize)]
struct Health { ok: bool }
 
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let app = Router::new()
        .route("/health", get(|| async { Json(Health { ok: true }) }));
 
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;
    axum::serve(listener, app).await?;
    Ok(())
}

Three things to notice: #[tokio::main] sets up the runtime, handlers are plain async closures, serde::Serialize derives JSON output. There is no IoC container, no annotation magic, no surprise.

HTTP clients

For most projects, reqwest with tokio is the right answer. JSON via .json::<T>().await?, TLS via rustls (preferred over OpenSSL).

TLS

Reach for rustls first. The OpenSSL binding (openssl-sys) has historically been a source of build pain and CVEs.

Serialization

Serde is the part of the Rust ecosystem that feels like magic. #[derive(Serialize, Deserialize)] on a struct produces correct, fast code for any format that implements the trait.

CLI

For any CLI, start with clap derive macros:

use clap::Parser;
 
#[derive(Parser)]
struct Cli {
    /// Input file path.
    #[arg(short, long)]
    input: std::path::PathBuf,
    /// Verbose mode.
    #[arg(short, long)]
    verbose: bool,
}
 
fn main() -> anyhow::Result<()> {
    let cli = Cli::parse();
    // ... cli.input, cli.verbose
    Ok(())
}

Database access

Most teams pick sqlx for new projects: typed queries, async, multiple backends, well-maintained.

Embedded and edge

Most readers will not write embedded Rust. But knowing the ecosystem exists matters: if an agent suggests Rust for an edge device or a Wasm module, the path is well-paved.

What to look for as an orchestrator

When an agent writes web/systems Rust:

The ecosystem is wide but the surface you need for any one task is small. For most projects, tokio + axum + reqwest + sqlx + serde + clap + anyhow + thiserror + tracing is the entire dependency list. Lean on that.