NGINX High Performance (Rahul Sharma)（Z-Library）

【One-Line Pitch】 A practical, hands-on guide to squeezing maximum throughput and lower latency out of NGINX, aimed at sysadmins and developers who already run a web server and now need it to survive real traffic. Read it if you want to benchmark honestly, tune workers and I/O, and add caching or scripting without guessing. 【Book Arc】 - **Opening (~0%–10%)**: Sets the stage with NGINX's event-driven, non-blocking architecture and the C10K problem it was built to solve, then walks through building NGINX from source and deploying a first "Hello world" page. - **Early (~10%–32%)**: Covers compile-time configuration choices (modules, paths, libraries) and establishes the discipline of benchmarking — performance testing concepts, baselines, and tools like Siege — before any tuning begins. - **Middle (~32%–48%)**: Extends benchmarking with Apache JMeter (GUI, non-GUI, and distributed server modes, test plans, assertions, timeouts), then moves into core tuning: worker processes, accept_mutex behavior, and connection-processing methods. - **Late (~48%–70%)**: Dives into I/O and network-level tuning — sendfile, direct and asynchronous I/O, TCP_NODELAY/TCP_CORK — plus buffers, timeouts, and compression directives that shape real-world response behavior. - **Ending (~70%–100%)**: Moves to caching layers (proxy cache, stale handling, Memcache) and extensibility through the Lua module and its directives/API, closing the loop from raw server tuning to programmable request handling. 【Key Takeaways】 - **Benchmark before you tune** (Early): The book insists on establishing a baseline with tools like Siege and JMeter so you can prove an optimization actually helped rather than assume it did. - **Worker configuration is the first real lever** (Middle): worker_processes, worker_connections, and accept_mutex directly govern how many connections the server can handle and whether CPU cycles are wasted on the "thundering herd" wake-up problem. - **I/O and TCP settings have outsized impact** (Late): sendfile, direct/asynchronous I/O, and TCP_NODELAY vs. TCP_CORK are presented as concrete, measurable knobs rather than abstract theory. - **Buffers, timeouts, and compression trade memory for speed** (Late): client body buffers and gzip-related settings change both resource usage and perceived page load time, so they must be tuned together. - **Caching is a performance strategy, not an afterthought** (Ending): Proxy caching, stale-content handling, and Memcache integration let NGINX absorb load that would otherwise hit upstream servers. - **NGINX is extensible when configuration isn't enough** (Ending): The Lua module and its directive/API surface (ngx.var, ngx.location.capture, content/rewrite/access phases) let you push custom logic into the server itself. - **Build-time decisions are hard to reverse** (Early): Compile options for modules and paths are locked into the binary, so the configure step deserves deliberate thought before installation. 【Reading Tips】 - Deep-read the benchmarking chapters first if you have never measured your server — the rest of the book assumes you have numbers to compare against. - Skim the source-build walkthrough if you install NGINX from a package manager; focus instead on the module and configure-option explanations that affect performance. - Treat the worker, I/O, and TCP chapters as your primary tuning checklist; test one change at a time against your baseline. - The Lua chapter is the most advanced material — read it only after the configuration-level tuning is solid, and expect to consult external Lua references alongside it. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book in detail, with later chapters (caching, Memcache, Lua) represented mainly through tables of contents and directive lists; specific benchmark figures and full code examples from those chapters are not covered here.