How to Design Content Delivery Network: Key Concepts & Example

To design a Content Delivery Network (CDN), deploy multiple geographically distributed edge servers that cache content close to users. Use a load balancer and DNS routing to direct user requests to the nearest edge server, reducing latency and improving performance.

Syntax

A CDN design typically includes these components:

• Origin Server: The main server hosting original content.
• Edge Servers: Distributed servers caching content near users.
• Load Balancer: Distributes user requests across edge servers.
• DNS Routing: Directs users to the closest edge server based on location.
• Cache Control: Rules to manage content freshness and expiration.

javascript

class CDN {
  constructor(originServer) {
    this.originServer = originServer;
    this.edgeServers = [];
  }

  addEdgeServer(edgeServer) {
    this.edgeServers.push(edgeServer);
  }

  routeRequest(userLocation) {
    // Find nearest edge server
    const nearest = this.edgeServers.reduce((prev, curr) => {
      return curr.distanceTo(userLocation) < prev.distanceTo(userLocation) ? curr : prev;
    });
    return nearest.serveContent();
  }
}

class EdgeServer {
  constructor(location) {
    this.location = location;
    this.cache = new Map();
  }

  distanceTo(userLocation) {
    // Simplified distance calculation
    return Math.abs(this.location - userLocation);
  }

  serveContent() {
    // Serve cached content or fetch from origin
    return 'Content served from edge server at ' + this.location;
  }
}

Example

This example shows a simple CDN routing user requests to the nearest edge server based on location.

javascript

const cdn = new CDN('Origin Server');
cdn.addEdgeServer(new EdgeServer(10));
cdn.addEdgeServer(new EdgeServer(50));
cdn.addEdgeServer(new EdgeServer(90));

console.log(cdn.routeRequest(12)); // User near location 12
console.log(cdn.routeRequest(70)); // User near location 70

Output

Content served from edge server at 10
Content served from edge server at 50

Common Pitfalls

• Poor Cache Invalidation: Not updating cached content leads to stale data served to users.
• Uneven Load Distribution: Some edge servers get overloaded while others are idle.
• Ignoring Geographic Diversity: Placing edge servers only in few locations increases latency for distant users.
• Not Handling Failures: Lack of fallback mechanisms causes downtime if an edge server fails.

javascript

/* Wrong: No cache invalidation */
edgeServer.cache.set('index.html', 'old content');
// Content never refreshed

/* Right: Use cache expiration */
function fetchContent() {
  if (cacheExpired()) {
    updateCacheFromOrigin();
  }
  return cache.get('index.html');
}

Quick Reference

• Place edge servers close to major user clusters.
• Use DNS-based routing for directing users to nearest edge.
• Implement cache control headers for content freshness.
• Monitor load and add auto-scaling for edge servers.
• Design fallback to origin server if edge cache misses.

Key Takeaways

Distribute edge servers geographically to reduce latency.

Use DNS routing and load balancers to direct user requests efficiently.

Implement cache invalidation to keep content fresh.

Plan for load balancing and failure handling to ensure reliability.

Monitor and scale edge servers based on traffic patterns.