CACHING & CDN

If 95% cache hit rate:
- 95% of requests: 1ms (cache)
- 5% of requests: 50ms (database)

Average latency = (0.95 x 1) + (0.05 x 50) = 3.45ms

def get_user(user_id):
    # Step 1: Check cache
    cache_key = f"user:{user_id}"
    cached = cache.get(cache_key)

    if cached:
        return cached  # Cache hit

    # Step 2: Cache miss - query database
    user = db.query("SELECT * FROM users WHERE id = ?", user_id)

    # Step 3: Store in cache for next time
    cache.set(cache_key, user, ttl=3600)  # 1 hour TTL

    return user

# Application only talks to cache
# Cache handles database interaction
def get_user(user_id):
    return cache.get(f"user:{user_id}")  # Cache fetches from DB if miss

def update_user(user_id, data):
    # Write to cache, cache writes to database
    cache.set(f"user:{user_id}", data)  # Cache persists to DB

def update_user(user_id, data):
    # Write to cache immediately, return to user
    cache.set(f"user:{user_id}", data)
    # Cache persists to DB asynchronously (batched)

Without TTL:
- Cache grows unbounded
- Stale data never refreshed
- Memory exhaustion

With TTL:
- Automatic expiration
- Bounded staleness
- Memory recycled

def get_ttl(data_type, popularity):
    base_ttl = {
        "user_profile": 3600,
        "feed": 300,
        "trending": 60
    }

    # Popular items get longer TTL (more cache hits)
    if popularity > 1000:
        return base_ttl[data_type] * 2

    return base_ttl[data_type]

"There are only two hard things in Computer Science:
cache invalidation and naming things."
- Phil Karlton

def update_user(user_id, data):
    db.update("UPDATE users SET ... WHERE id = ?", data, user_id)
    # Do nothing to cache
    # Cache will expire based on TTL

def update_user(user_id, data):
    db.update("UPDATE users SET ... WHERE id = ?", data, user_id)
    cache.delete(f"user:{user_id}")  # Invalidate cache

def update_user(user_id, data):
    db.update("UPDATE users SET ... WHERE id = ?", data, user_id)
    cache.set(f"user:{user_id}", data)  # Update cache

# On write
def update_user(user_id, data):
    db.update("UPDATE users SET ... WHERE id = ?", data, user_id)
    event_bus.publish("user.updated", {"user_id": user_id})

# Subscriber
def on_user_updated(event):
    cache.delete(f"user:{event.user_id}")

1. Popular item cached with TTL = 60 seconds
2. 10,000 users viewing this item
3. Cache expires at t=60
4. All 10,000 users request simultaneously
5. All 10,000 requests hit database
6. Database overwhelmed, crashes

def cache_with_jitter(key, value, base_ttl):
    # Add random jitter: TTL = base + random(0, 10%)
    jitter = random.uniform(0, base_ttl * 0.1)
    ttl = base_ttl + jitter
    cache.set(key, value, ttl=ttl)

def get_with_lock(key, fetch_func):
    value = cache.get(key)
    if value:
        return value

    # Try to acquire lock
    lock_key = f"lock:{key}"
    if cache.set(lock_key, "1", nx=True, ex=5):  # Lock for 5 seconds
        # I have the lock, fetch data
        value = fetch_func()
        cache.set(key, value, ttl=3600)
        cache.delete(lock_key)
        return value
    else:
        # Someone else is fetching, wait and retry
        time.sleep(0.1)
        return get_with_lock(key, fetch_func)

def get_with_stale(key, fetch_func, ttl=3600, stale_ttl=300):
    cached = cache.get(key)

    if cached:
        if cached.age < ttl:
            return cached.value  # Fresh
        elif cached.age < ttl + stale_ttl:
            # Stale but acceptable
            # Trigger async refresh
            queue.enqueue("refresh_cache", key)
            return cached.value  # Return stale

    # No cache or too stale
    value = fetch_func()
    cache.set(key, value, ttl=ttl + stale_ttl)
    return value

Key: "trending_post:123"
Traffic: 100,000 requests/second
Single Redis server: 50,000 ops/second max
Result: Redis overloaded, latency spikes

# In-memory cache on application server
local_cache = {}
local_cache_ttl = {}

def get_with_local_cache(key):
    # Check local cache first (no network)
    if key in local_cache and local_cache_ttl[key] > time.now():
        return local_cache[key]

    # Check Redis
    value = redis.get(key)

    if value and is_hot_key(key):
        # Cache hot keys locally for 1 second
        local_cache[key] = value
        local_cache_ttl[key] = time.now() + 1

    return value

def set_hot_key(key, value):
    # Replicate to multiple keys
    for i in range(10):
        redis.set(f"{key}:{i}", value)

def get_hot_key(key):
    # Randomly pick one replica
    replica = random.randint(0, 9)
    return redis.get(f"{key}:{replica}")

def warm_cache():
    # Warm most popular users
    popular_users = db.query("""
        SELECT id FROM users
        ORDER BY follower_count DESC
        LIMIT 10000
    """)

    for user in popular_users:
        user_data = db.query("SELECT * FROM users WHERE id = ?", user.id)
        cache.set(f"user:{user.id}", user_data, ttl=3600)

    print(f"Warmed cache with{len(popular_users)} users")

def gradual_warm(items, batch_size=100, delay=0.1):
    for i in range(0, len(items), batch_size):
        batch = items[i:i + batch_size]

        for item in batch:
            warm_item(item)

        # Pause to avoid overwhelming database
        time.sleep(delay)

# Cache for 1 year (immutable assets)
Cache-Control: public, max-age=31536000, immutable

# Cache for 5 minutes, revalidate after
Cache-Control: public, max-age=300, stale-while-revalidate=60

# Do not cache at all
Cache-Control: no-store, no-cache, must-revalidate

# Cache privately (browser only, not CDN)
Cache-Control: private, max-age=3600

- Security vulnerability in JavaScript
- Incorrect data served
- Legal/compliance issue
- Breaking bug in production

Do NOT purge for:
- Normal content updates (use versioned URLs)
- Minor fixes (wait for TTL)

import cloudflare

def purge_url(url):
    cf = cloudflare.Client(api_key="...")
    cf.zones.purge_cache.post(
        zone_id="...",
        data={"files": [url]}
    )