Web Server Fundamentals
A web server is software that accepts HTTP requests from clients and returns files or generated content over the network. It maps URLs to resources, terminates TLS, and can reverse-proxy to application backends.
itWeb servers, proxies, and traffic management | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Web Server Fundamentals
Web server is the software at the front door of an HTTP service. A browser asks for a URL, and the server applies a rulebook: send a file, pass the request to an application backend, redirect it, or say no. Before that arrangement, every public-facing program had to be its own receptionist, courier, and occasional keeper of the keys. This was not a relaxing job description.
The useful shape is a URL-to-response engine. A request brings a method, path, headers, and perhaps a body. The server matches those against configuration and returns a status code, headers, and a body. The important surprise is that serving an image and forwarding a profile request can look identical to the client. Both are HTTP responses; the server knows whether bytes came from its document root or an application process somewhere behind it.
Reverse proxying is the trick that lets the same front door speak to several backends without inviting the internet to wander through the building. The proxy is a server to the client and a client to the backend. It can terminate TLS, hold many connections, and route paths before an application handles business logic. It can also distribute requests across backends, although a dedicated load balancer has more elaborate health checks and traffic rules. Giving one component every responsibility is how architecture becomes a group project with no agenda.
Virtual hosting lets several sites share an address and port. HTTP version 1.1 supplies the Host header; TLS adds SNI so the server can choose the right certificate before ordinary HTTP begins. Then caching adds another polite complication: a saved response is useful only when its headers say which requests may share it. Vary is the small label that prevents one client's version of a response becoming another client's surprise.
The remainder of the course sorts the moving parts. The intro explains the request path, concurrency models, TLS, logs, failures, and boundaries. The slides reduce the route to a map. The cheatsheet holds the header pairs, status ranges, and operational signals for the moment a request stops behaving. Start there before choosing a server product; the product is the dialect, while the listener, rulebook, response, and backend are the grammar.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://developer.mozilla.org/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_web_server
Supports
- Web server as hardware and software; the software boundary is the meaningful one
- Static web server (HTTP server plus files) versus dynamic web server (plus application server and database)
- The request loop: browser requests a file, HTTP server finds it, returns it or a 404
- Hosting rationale: availability, always-on connectivity, dedicated IP, third-party maintenance
- HTTP is a textual, stateless, application-layer protocol
- https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview
Supports
- HTTP as a client-server, request/response protocol; the user-agent initiates
- Components of HTTP-based systems: client (user-agent), server, proxies
- HTTP is stateless but not sessionless (cookies add sessions)
- Connections: HTTP/1.0 one connection per request; HTTP/1.1 persistent connections and pipelining; HTTP/2 multiplexing; QUIC experiments over UDP
- HTTP flow: open TCP, send message, read response, close or reuse
- Request and response message structure (method, path, version, headers, body; status, headers, body)
- Caching, authentication, proxying/tunneling, sessions, and CORS as features controllable by HTTP
- https://www.rfc-editor.org/rfc/rfc9110.html
Supports
- Authoritative definitions of HTTP methods, status codes, and header semantics
- Content negotiation and caching semantics referenced by this course
- https://www.rfc-editor.org/rfc/rfc9112.html
Supports
- HTTP/1.1 wire format and the mandatory Host header enabling name-based virtual hosting
- Persistent connections (keep-alive) and message parsing the server performs
- https://www.rfc-editor.org/rfc/rfc9113.html
Supports
- HTTP/2 stream multiplexing over one TCP connection and binary frame layer
- HPACK header compression referenced in the HTTP versions comparison
- https://www.rfc-editor.org/rfc/rfc9114.html
Supports
- HTTP/3 over QUIC (UDP), combined transport and TLS handshake, per-stream loss recovery
- Why a server adopting HTTP/3 needs a QUIC-capable listener
- https://www.rfc-editor.org/rfc/rfc6066.html
Supports
- Server Name Indication (SNI) carrying the host name in the TLS ClientHello
- How name-based virtual hosting works under HTTPS
- https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching
Supports
- Cache-Control, ETag, Last-Modified, Vary, and conditional (304) request behavior
- Browser, shared proxy, and origin cache layers
- https://httpd.apache.org/docs/2.4/
Supports
- Apache's directive and context configuration model referenced as one concrete server
- MPMs (prefork, worker, event) as the concrete instances of the three concurrency models
- https://nginx.org/en/docs/
Supports
- NGINX master/worker architecture and event-driven concurrency model
- Configuration contexts (main, events, http, server, location) referenced as the rulebook example
- Reload behavior: validate new config, start new workers, old workers finish in-flight requests
- https://awesome-selfhosted.net/tags/web-servers.html
Supports
- Curated discovery source for which web server and reverse-proxy projects belong on the Awesome Links page (Apache, Caddy, lighttpd, HAProxy, Nginx Proxy Manager, Traefik)
- https://www.kegel.com/c10k.html
Supports
- The C10K problem: why process-per-connection servers cannot scale to ten thousand concurrent connections
- The design goal that event-driven web server architectures were built to meet
- https://httpd.apache.org/ABOUT_APACHE.html
Supports
- Apache 0.6.2 first public release in April 1995 as patches to NCSA HTTPd 1.3
- Apache 1.0 released December 1995 with the Shambhala modular architecture
- Apache surpassing NCSA as the most-used web server within a year
- https://www.apache.org/history/timeline.html
Supports
- Apache Software Foundation formed in June 1999
- Apache 2.0 alpha released during ApacheCon March 2000
- https://blog.nginx.org/blog/celebrating-20-years-of-nginx
Supports
- NGINX first publicly released October 4, 2004, by Igor Sysoev
- NGINX designed to solve the C10K problem with event-driven architecture
- NGINX 1.0.0 released April 12, 2011
- https://www.rfc-editor.org/rfc/rfc7540
Supports
- HTTP/2 standardized May 2015 with binary frames, stream multiplexing, and HPACK
- https://caddyserver.com/docs/
Supports
- Caddy's automatic HTTPS via ACME/Let's Encrypt as its defining feature
- Caddy first released in 2015 by Matthew Holt
- https://en.wikipedia.org/wiki/Traefik_Proxy
Supports
- Traefik first released 2016, deriving configuration from container orchestrator APIs
- Container-native reverse proxy that reconfigures itself from service discovery
- https://en.wikipedia.org/wiki/Lighttpd
Supports
- lighttpd first released March 2003 as an event-driven server with small memory footprint
- https://www.oneuptime.com/blog/post/2026-03-20-nginx-worker-connections-high-traffic/view
Supports
- worker_connections is bounded by the OS file descriptor limit (ulimit -n)
- Raising NGINX connection limits without raising backend capacity moves the bottleneck upstream
- worker_connections error log messages point at NGINX but the fix is often upstream capacity
- https://nginx.org/en/docs/beginners_guide.html
Supports
- A local NGINX configuration can serve static files and proxy requests to another HTTP server
- The nginx -t configuration test and reload workflow used by the practice reference
- https://httpd.apache.org/docs/trunk/en/new_features_2_0.html
Supports
- Apache HTTP Server 2.0 introduced platform-specific multi-processing modules and hybrid multi-process, multithreaded operation
- https://traefik.io/blog/traefik-1-0-0-reblochon-is-out-e6fca002284d
Supports
- Traefik 1.0 was released on July 6, 2016 and supported dynamic configuration from container and orchestration backends
- https://www.haproxy.org/#docs
Supports
- HAProxy is a reverse-proxy and load-balancing option in the product landscape
- https://doc.traefik.io/traefik/
Supports
- Traefik Proxy is a dynamic-environment routing option in the product landscape
- https://www.cloudflare.com/learning/cdn/what-is-a-cdn/
Supports
- A CDN provides an edge layer that can cache and serve content before requests reach an origin server
