Rust Web Development

🌐 Rust Web Frameworks

Rust offers powerful web frameworks like Rocket and Actix-web for building fast, safe web applications. These frameworks provide routing, middleware, and async support for modern web development.


// Simple web server with Rocket
#[macro_use] extern crate rocket;

#[get("/")]
fn hello() -> &'static str {
    "Hello, Rust Web!"
}

Result:

A web server running on localhost:8000 serving "Hello, Rust Web!"

Popular Web Frameworks

🚀

Rocket

Type-safe, easy-to-use web framework

#[get("/user/")]
fn get_user(id: u32) -> String {
    format!("User ID: {}", id)
}

⚡

Actix-web

High-performance async web framework

async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello Actix!")
}

🔧

Axum

Modern async web framework by Tokio team

async fn handler() -> &'static str {
    "Hello, Axum!"
}

🌊

Warp

Composable web framework with filters

let hello = warp::path!("hello" / String)
    .map(|name| format!("Hello, {}!", name));

🔹 Rocket Web Server

Create a simple web server with Rocket:

# Cargo.toml
[dependencies]
rocket = { version = "0.5", features = ["json"] }
serde = { version = "1.0", features = ["derive"] }

// main.rs
#[macro_use] extern crate rocket;

use rocket::serde::{Deserialize, Serialize, json::Json};

#[derive(Serialize, Deserialize)]
#[serde(crate = "rocket::serde")]
struct User {
    id: u32,
    name: String,
}

#[get("/")]
fn index() -> &'static str {
    "Welcome to Rocket!"
}

#[get("/user/")]
fn get_user(id: u32) -> Json {
    Json(User {
        id,
        name: format!("User {}", id),
    })
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/", routes![index, get_user])
}

Run with:


           cargo run

- Server starts on http://localhost:8000

🔹 Actix-web Server

Build a high-performance server with Actix-web:

# Cargo.toml
[dependencies]
actix-web = "4.0"
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }

// main.rs
use actix_web::{web, App, HttpResponse, HttpServer, Responder, Result};
use serde::{Deserialize, Serialize};

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

async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello Actix-web!")
}

async fn get_user(path: web::Path) -> Result {
    let user_id = path.into_inner();
    let user = User {
        id: user_id,
        name: format!("User {}", user_id),
    };
    Ok(HttpResponse::Ok().json(user))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(hello))
            .route("/user/{id}", web::get().to(get_user))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Features:

Async/await support
JSON serialization
Path parameters
High performance

🔹 REST API Example

Create a simple REST API with CRUD operations:

// Using Rocket for REST API
use rocket::serde::{Deserialize, Serialize, json::Json};
use rocket::{State, post, get, put, delete};
use std::collections::HashMap;
use std::sync::Mutex;

type UserDb = Mutex>;

#[derive(Serialize, Deserialize, Clone)]
#[serde(crate = "rocket::serde")]
struct User {
    id: u32,
    name: String,
    email: String,
}

#[post("/users", data = "")]
fn create_user(user: Json, db: &State) -> Json {
    let mut users = db.lock().unwrap();
    users.insert(user.id, user.clone());
    user
}

#[get("/users/")]
fn get_user(id: u32, db: &State) -> Option> {
    let users = db.lock().unwrap();
    users.get(&id).map(|user| Json(user.clone()))
}

#[put("/users/", data = "")]
fn update_user(id: u32, user: Json, db: &State) -> Option> {
    let mut users = db.lock().unwrap();
    users.insert(id, user.clone());
    Some(user)
}

#[delete("/users/")]
fn delete_user(id: u32, db: &State) -> Option {
    let mut users = db.lock().unwrap();
    users.remove(&id).map(|_| format!("User {} deleted", id))
}

API Endpoints:

POST /users - Create user
GET /users/<id> - Get user
PUT /users/<id> - Update user
DELETE /users/<id> - Delete user