Mastering Large-Scale Internet Architecture: From DNS to Distributed Caching

Architecture Goals

Low cost: minimize commercial expenses wherever possible.

High performance: measured by response time, throughput, QPS, and concurrency.

High availability: maintain service during failures, measured by uptime ratio.

Scalability: linear expansion by adding machines to handle growing traffic.

Security: protect against data breaches and account theft.

Typical Implementation

A typical web request flow includes DNS resolution, CDN delivery, load balancing, and backend processing.

DNS

Browser checks its own cache.

OS checks the hosts file.

If not cached, the request is sent to the local DNS (LDNS).

LDNS queries the global TLD server, which returns the authoritative name server and the IP address.

Browser caches the result according to the TTL.

CDN

Content Delivery Networks place data in edge locations close to users. Common self‑hosted solutions include Squid, Varnish, and Nginx cache.

Load Balancing (LB)

LB distributes incoming requests across multiple servers using algorithms such as Round Robin, Weighted RR, Random, Least Connection, and Source Hash. Typical stack: LVS + HAProxy + Nginx, with Keepalived + VIP for health checks and failover.

Web Application Stack

Frontend : follow best‑practice optimization, use techniques like BigPipe, page staticization, and infinite scroll.

Backend :

HTTP protocol fundamentals (request/response headers and bodies).

RESTful APIs for resource‑oriented, stateless communication.

Application servers (e.g., Tomcat) with connectors and containers managing lifecycle.

Session management using filters and distributed caches for massive concurrent users.

MVC pattern to separate model, view, and controller logic.

IoC implementation via reflection, singleton, hash maps, bytecode enhancement, and ThreadLocal.

ORM mapping between objects and relational tables, often using JDBC metadata and convention‑over‑configuration.

SOA

Service‑Oriented Architecture separates functionality into independent services. Example: Dubbo uses Spring extensions, JDK dynamic proxies, Javassist, and ZooKeeper for high‑availability metadata.

Message Queue (MQ)

MQ decouples services and smooths traffic spikes; Kafka is a common choice for large‑scale systems.

Cache

Caching stores frequently accessed data closer to the compute layer, reducing latency. Strategies include local node cache, global shared cache, and distributed cache (consistent‑hash based). Memcached and Redis are popular implementations.

Proxy

Proxies sit between clients and servers to filter, log, transform, or compress traffic. They can also collapse duplicate requests to reduce backend load (collapsed forwarding).

Indexing

Indexes accelerate data retrieval at the cost of extra storage and write overhead. Multi‑level indexes, inverted indexes, and in‑memory structures (e.g., B‑trees) are essential for large‑scale search.

Load Balancer

Load balancers distribute connections across server pools, providing scalability and failover. Software solutions like HAProxy are widely used; algorithms range from simple round‑robin to resource‑aware scheduling.

Queue

Queues enable asynchronous processing, improving throughput and resilience. Workers pull tasks from the queue, allowing the client to continue without waiting. Popular open‑source queues include RabbitMQ, ActiveMQ, Beanstalkd, and Redis‑based solutions.

Conclusion

Designing fast, scalable data access for large‑scale web systems involves combining caching, proxies, indexing, load balancing, and queuing. The tools and patterns described provide a foundation for building robust, high‑performance internet architectures.