Content Delivery Network (CDN)

Metadata

1. Overview

What problem does it solve?

Data cannot travel faster than the speed of light. If your server is in New York, and a user is in Tokyo, a simple HTTP request takes at least 200 milliseconds just in physical transit time. If that user is downloading a 5MB image or a large JavaScript bundle, the latency is highly noticeable.

A Content Delivery Network (CDN) solves the physics problem of distance. It is a globally distributed network of servers (called Edge Servers) that cache static content (images, videos, CSS, JS) as close to the end-user as physically possible.

What breaks without it?

• High Latency: Users far from your datacenter experience slow load times, leading to high bounce rates.
• Bandwidth Costs: Serving terabytes of images from your primary application server (AWS EC2) is incredibly expensive compared to CDN bandwidth.
• Server Overload: Your application servers spend all their CPU and network capacity serving static files instead of executing business logic.

2. Motivation

Why did CDNs emerge?

In the late 1990s, the internet started filling up with images and multimedia, leading to the "World Wide Wait." Akamai (the first major CDN) was born out of an MIT research project to solve this by moving the content closer to the users, effectively bypassing the congested core of the internet.

Origin vs Edge

• Origin Server: Your primary database and application server (e.g., an EC2 instance in Virginia or an S3 bucket). The source of truth.
• Edge Server: One of thousands of CDN servers scattered across the globe (e.g., a server rack in a Tokyo telecom building). It caches copies of the Origin's data.

3. Real-World Usage

4. Prerequisites

5. Visual Explanation

The Pull CDN Flow

sequenceDiagram
    participant U as User (Tokyo)
    participant Edge as CDN Edge (Tokyo)
    participant Origin as Origin Server (New York)

    Note over U,Edge: Request 1 (Cache Miss)
    U->>Edge: GET /logo.png
    Edge->>Origin: Cache Miss! Fetch /logo.png
    Origin-->>Edge: 200 OK (logo.png)
    Note over Edge: Saves to local cache
    Edge-->>U: 200 OK (logo.png) (Latency: 250ms)

    Note over U,Edge: Request 2 (Cache Hit)
    U->>Edge: GET /logo.png
    Edge-->>U: 200 OK (logo.png) (Latency: 15ms)

Anycast Routing (How the user finds the Edge)

If cdn.example.com resolves to IP 1.1.1.1, how does a user in Tokyo hit the Tokyo edge server, while a user in New York hits the New York edge server?

Anycast DNS: The same IP address (1.1.1.1) is assigned to multiple servers globally. The core internet routers (BGP) automatically route the user's TCP packets to the server physically closest to them.

6. Internal Working

6.1 Push vs Pull CDN

6.2 Cache Invalidations

When you update a CSS file on the Origin, the CDN doesn't know. It will keep serving the old CSS until its TTL (Time-To-Live) expires. How to fix this?

1. Cache Purge API: Call the CDN's API (DELETE /cache/style.css) to force it to delete the file globally. (Slow and expensive).
2. File Versioning / Cache Busting (Industry Standard): Never update files. Always create new ones. E.g., change style.css to style.v2.css or style.a8f9c.css. The CDN treats it as a brand-new file, guaranteeing users get the latest version immediately.

7. Implementation

Why Python? We will write a simple "Edge Node" script that demonstrates the Pull CDN behavior. It will accept requests, check its local disk cache, and if missing, fetch it from a mock Origin server.

"""
012 - Pull CDN Edge Node Implementation
A simplified edge server that caches responses from an Origin server.
Run: `python cdn_edge.py`
"""
import os
import time
import requests
from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import urlparse

# ── Configuration ──

# The "Origin" we are protecting (e.g., an S3 bucket or main app server)
ORIGIN_URL = "https://httpbin.org"

# Local directory to act as our CDN cache
CACHE_DIR = "/tmp/cdn_cache"

# How long to keep files in the CDN cache (seconds)
TTL = 60 

os.makedirs(CACHE_DIR, exist_ok=True)


# ── CDN Edge Server ──

class CDNEdgeHandler(BaseHTTPRequestHandler):
    
    def do_GET(self):
        parsed_path = urlparse(self.path)
        path = parsed_path.path
        
        # We use the path as the cache key. (In prod, replace slashes to avoid directory traversal)
        cache_key = path.replace("/", "_")
        if not cache_key:
            cache_key = "index"
            
        cache_file = os.path.join(CACHE_DIR, cache_key)
        
        # 1. Check if we have a valid cached copy
        if os.path.exists(cache_file):
            file_age = time.time() - os.path.getmtime(cache_file)
            if file_age < TTL:
                # ── CACHE HIT ──
                print(f"[CACHE HIT] Serving {path} from Edge (Age: {int(file_age)}s)")
                self.send_response(200)
                self.send_header("X-Cache", "HIT")
                self.end_headers()
                
                with open(cache_file, "rb") as f:
                    self.wfile.write(f.read())
                return
            else:
                print(f"[CACHE EXPIRED] {path} is older than {TTL}s.")
        
        # 2. Cache Miss or Expired -> Fetch from Origin
        print(f"[CACHE MISS] Fetching {path} from Origin ({ORIGIN_URL})...")
        origin_target = f"{ORIGIN_URL}{path}"
        
        try:
            # We add a timeout so the edge doesn't hang forever if origin is down
            resp = requests.get(origin_target, timeout=5)
            
            if resp.status_code == 200:
                # 3. Save to local cache for the next user
                with open(cache_file, "wb") as f:
                    f.write(resp.content)
                
                # 4. Serve to user
                self.send_response(200)
                self.send_header("X-Cache", "MISS")
                self.end_headers()
                self.wfile.write(resp.content)
                print(f"[SAVED] {path} cached at Edge.")
            else:
                self.send_response(resp.status_code)
                self.end_headers()
                self.wfile.write(f"Origin returned {resp.status_code}".encode())
                
        except requests.RequestException as e:
            print(f"[ORIGIN ERROR] {e}")
            self.send_response(502)
            self.end_headers()
            self.wfile.write(b"502 Bad Gateway: Origin Unreachable")

    def log_message(self, format, *args):
        pass # Suppress default logging


if __name__ == "__main__":
    port = 8080
    server = HTTPServer(("127.0.0.1", port), CDNEdgeHandler)
    print(f"CDN Edge Node running on port {port}")
    print(f"Origin Server: {ORIGIN_URL}")
    print("Test via:")
    print("  curl -i http://127.0.0.1:8080/json")
    print("  curl -i http://127.0.0.1:8080/uuid")
    
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        print("\nShutting down CDN node.")

Sample Output

# Terminal 1: Run Edge Node
$ python cdn_edge.py
CDN Edge Node running on port 8080

# Terminal 2: First Request (Cache Miss)
$ curl -i http://127.0.0.1:8080/uuid
HTTP/1.0 200 OK
X-Cache: MISS

# ... Terminal 1 Output:
[CACHE MISS] Fetching /uuid from Origin (https://httpbin.org)...
[SAVED] /uuid cached at Edge.

# Terminal 2: Second Request (Cache Hit - Instant!)
$ curl -i http://127.0.0.1:8080/uuid
HTTP/1.0 200 OK
X-Cache: HIT

# ... Terminal 1 Output:
[CACHE HIT] Serving /uuid from Edge (Age: 3s)

Note how the second request is blazing fast and doesn't hit httpbin.org at all.

8. Complexity

Scalability Characteristics

• Dynamic Content Acceleration: Modern CDNs don't just cache static files. They can accelerate dynamic API calls by keeping long-lived, optimized TCP connections open between the Edge and the Origin (reducing TCP/TLS handshake latency).
• Edge Computing: Cloudflare Workers or Lambda@Edge allow you to run Javascript/Wasm directly on the Edge nodes, entirely bypassing your Origin for basic business logic (like A/B testing or JWT validation).

9. Trade-offs

10. Production Evolution

11. Common Bugs

12. Interview Questions

1. What is the difference between a Push CDN and a Pull CDN? Hint: Pull fetches from Origin on a cache miss. Push requires you to actively upload files to the CDN before they are requested.

2. How does a CDN know when to delete a file from its cache? Hint: The Origin server includes a Cache-Control: max-age=X header in its HTTP response. The CDN respects this TTL.

3. If you have a global user base, how do you ensure users in Japan hit the Tokyo CDN node, while users in Germany hit the Frankfurt node? Hint: Anycast DNS routing or Geo-DNS. BGP routing tables direct the packet to the topologically closest server announcing that IP.

4. Your company accidentally pushed a broken JavaScript file to the CDN with a 1-year TTL. How do you fix the website for users immediately? Hint: Pushing an invalidation/purge command to the CDN takes time. The fastest fix is to push a code change to the HTML to request a new filename (e.g., app.v2.js).

13. Used By (Downstream Blocks)

• 035 Edge Computing — Running code directly on CDN edge nodes.
• 010 Caching Strategies — CDNs are essentially massive distributed caches implementing LRU/LFU.

14. Used In (Case Studies)

15. Related Blocks

16. Try It Yourself

Exercise 1: Respect Cache-Control

Modify the Python Edge server. When a Cache Miss occurs, inspect resp.headers.get("Cache-Control"). If the Origin returns no-store or private, do not save it to disk, but still return the content to the client.

Exercise 2: Purge Endpoint

Add an HTTP DELETE handler to the Edge server. When a request comes to DELETE /logo.png, delete the corresponding file from CACHE_DIR if it exists, simulating a CDN Cache Purge API.

Website Metadata