The Networking Stack (OSI Model)#

To understand web servers, we first need to look at the OSI Model, which breaks computer networking into seven layers. For a web server, the two most critical layers are the Transport Layer (Layer 4), which manages the actual delivery of data using protocols like TCP, and the Application Layer (Layer 7), where protocols like HTTP define how the client and server communicate.

Setting up a TCP Listener#

The core of every web server is a TCP Listener. We use Rust’s standard library to bind to a port and listen for incoming connections. For each accepted connection, we spawn a new thread to handle it concurrently so the main loop remains free to accept the next client.

1
use std::net::TcpListener;
2

3
fn main() {
4
    let listener = TcpListener::bind("127.0.0.1:8080").unwrap();
5

6
    for stream in listener.incoming() {
7
        match stream {
8
            Ok(stream) => {
9
                std::thread::spawn(move || handle_client(stream));
10
            }
11
            Err(e) => println!("Error: {}", e),
12
        }
13
    }
14
}

Handling Client Requests#

When a client connects, we read the incoming byte stream into a buffer and then parse it into a structured Request type. This struct captures the HTTP method (e.g., GET, POST), the requested URI, the HTTP version, any headers, and an optional body. From there we can inspect the request and generate an appropriate Response.

1
pub struct Request {
2
    pub method: HttpMethod,
3
    pub uri: String,
4
    pub version: String,
5
    pub headers: HashMap<String, String>,
6
    pub body: Option<String>,
7
}

Routing and Middleware#

To make our server useful, we need a way to map specific URL paths to handler functions. We achieve this with a HashMap of routes keyed by path and HTTP method. We can also define a Middleware trait to intercept requests and responses — useful for cross-cutting concerns like logging or authentication without cluttering individual route handlers.

1
pub trait Middleware: Send + Sync {
2
    fn on_request(&self, request: Request) -> FutureRequest;
3
    fn on_response(&self, response: Response) -> FutureResponse;
4
}

Running the Server#

Finally, we instantiate our server, bind it to an address, and register our routes. For handling multiple concurrent connections efficiently, we can swap raw threads for Tokio — Rust’s async runtime — which gives us non-blocking I/O without the overhead of spawning a thread per connection.

1
#[tokio::main]
2
async fn main() {
3
    let addr = SocketAddr::from(([127, 0, 0, 1], 8080));
4
    let server = ServerBuilder::new()
5
        .bind(addr)
6
        .route("/", HttpMethod::GET, hello_handler)
7
        .build();
8

9
    server.run().await.unwrap();
10
}

Watch the full step-by-step video tutorial below:

YouTube#