Rust Servers, Services, and Apps (Prabhu Eshwarla)（Z-Library）

【One-Line Pitch】 A hands-on, project-driven guide for web developers with basic Rust knowledge who want to build production-ready backend servers, RESTful APIs, server-rendered apps, and even full-stack frontends—all in Rust, from raw TCP sockets to async frameworks like Actix Web. 【Book Arc】 - **Opening (~0%–9%)**: Introduces why Rust is a strong choice for web applications, covering memory safety, thread safety, and the elimination of common bugs like null dereferences and buffer overflows. It also sets up the book's running example: EzyTutors, a digital storefront for tutors. - **Early (~9%–25%)**: Explains networking fundamentals—TCP/IP model, OSI layers—and then dives into building a basic TCP server and client from scratch using only Rust's standard library, introducing the `Read` and `Write` traits. - **Early (~25%–34%)**: Extends the TCP work into a minimal HTTP server, implementing request parsing (GET/POST), response construction, and serialization into proper HTTP messages, complete with unit tests for 200 and 404 responses. - **Middle (~34%–44%)**: Adds a handler trait to serve static pages and 404s, then transitions to the Actix Web framework, highlighting its features (HTTP/2, middleware, async I/O) and building a health-check API with application state and route configuration. - **Middle (~44%–end of excerpts)**: Begins building RESTful web services with Actix, covering CRUD operations, database persistence, error handling, state management, JWT authentication, and middleware—all within the EzyTutors context. 【Key Takeaways】 - **Rust's ownership model is the core advantage for web servers** (Early): It eliminates null pointer dereferences, segfaults, dangling pointers, and buffer overflows at compile time, without needing a garbage collector. This means safer, more predictable backend code. - **Start from raw TCP, not frameworks** (Early): The book builds a TCP server and client using only `std::net::TcpStream` and the `Read`/`Write` traits, showing how bytes flow over the wire before abstracting with HTTP. - **HTTP is just structured bytes** (Early): You'll parse GET/POST requests into Rust structs and serialize responses with status lines, headers, and bodies—demystifying what frameworks do under the hood. - **Test your protocol code early** (Early): The book includes unit tests for constructing 200 and 404 responses, ensuring your HTTP structs serialize correctly before building higher-level features. - **Actix Web is a mature, high-performance choice** (Middle): It supports HTTP/1.x and HTTP/2, async I/O, middleware (CORS, sessions, auth), content compression, and multiple database connections—making it ideal for production REST APIs. - **Application state is shared via extractors** (Middle): Using `web::Data<T>` with a struct like `AppState` (containing a visit counter with `Mutex`) shows how to manage shared, mutable state safely across handlers. - **The book is deliberately scoped** (Early): It focuses only on REST (not SOAP) and skips CI/CD, but includes Docker/Docker Compose deployment and a brief look at peer-to-peer networks for async practice. 【Reading Tips】 - **Skim the opening chapters** (~0–9%) if you already know Rust's safety guarantees; the real value starts with the TCP server code. - **Deep-read the HTTP server section** (~25–34%): This is where you'll truly understand request/response parsing and serialization—don't rush through the listings and tests. - **Follow along with the EzyTutors example** throughout; it ties every chapter together, from static pages to REST APIs, so keep the project vision in mind. - **Hard spot**: The transition from raw TCP to Actix Web can feel jarring—expect to see framework abstractions (like `web::Data` and route config) that assume you've internalized the earlier manual HTTP work. - **Take away the testing mindset**: The book's habit of writing unit tests for HTTP structs is a pattern you should replicate in your own projects. 【Coverage Limits】 This guide covers the book's opening through the early REST API chapters (~44% of the book). Excerpts do not cover later topics like full database integration, JWT auth implementation, frontend development, async programming deep dives, or Docker deployment—those appear in later chapters not included here.