What is CDN edge computing? What are the application scenarios? - 面试题

Concept of CDN Edge Computing

CDN edge computing refers to moving computing capabilities from centralized origin servers or cloud to CDN edge nodes, executing computing tasks at the network edge close to users. This architecture can significantly reduce latency, reduce origin traffic, and improve user experience.

Core Value of Edge Computing

1. Reduce Latency

Traditional architecture:

shell
User request → CDN edge node → Origin/Cloud processing → Return result
Latency: 200-500ms

Edge computing architecture:

shell
User request → CDN edge node (local processing) → Return result
Latency: 10-50ms

Advantages:

Reduce network transmission distance
Avoid cross-region access
Real-time response to user requests

2. Reduce Origin Traffic

Scenario comparison:

Traditional approach:

All dynamic requests need to go to origin
High origin server load
High bandwidth cost

Edge computing approach:

Most requests processed at edge
Only few requests need to go to origin
Significantly reduce origin load and bandwidth cost

3. Improve User Experience

User experience improvements:

Faster response speed
Higher availability
Better personalized services

4. Data Privacy Protection

Privacy advantages:

Data processed locally, reduce transmission
Comply with data localization regulations
Reduce risk of data leakage

CDN Edge Computing Use Cases

1. API Gateway and Routing

Functions:

Request routing and forwarding
API version management
Request/response transformation

Example:

javascript
// Cloudflare Workers example
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  const url = new URL(request.url)
  
  // API routing
  if (url.pathname.startsWith('/api/v1')) {
    return fetch('https://api-v1.example.com' + url.pathname + url.search)
  } else if (url.pathname.startsWith('/api/v2')) {
    return fetch('https://api-v2.example.com' + url.pathname + url.search)
  }
  
  return new Response('Not Found', { status: 404 })
}

2. Dynamic Content Generation

Applications:

Personalized content recommendations
A/B testing
Real-time content modification

Example:

javascript
// Return different content based on user's geographic location
async function handleRequest(request) {
  const country = request.cf.country
  
  if (country === 'CN') {
    return new Response('欢迎访问中国版网站')
  } else if (country === 'US') {
    return new Response('Welcome to US version')
  }
  
  return new Response('Welcome to our website')
}

3. Image Processing and Optimization

Functions:

Real-time image scaling, cropping
Format conversion (WebP, AVIF)
Quality optimization

Example:

javascript
// Image processing
async function handleRequest(request) {
  const url = new URL(request.url)
  const width = url.searchParams.get('width') || 800
  const height = url.searchParams.get('height') || 600
  
  // Fetch original image from origin
  const originalImage = await fetch('https://origin.example.com/image.jpg')
  const imageBuffer = await originalImage.arrayBuffer()
  
  // Process image
  const processedImage = await processImage(imageBuffer, width, height)
  
  return new Response(processedImage, {
    headers: { 'Content-Type': 'image/jpeg' }
  })
}

4. Authentication and Authorization

Functions:

JWT verification
API Key verification
Permission checking

Example:

javascript
// JWT verification
async function handleRequest(request) {
  const authHeader = request.headers.get('Authorization')
  
  if (!authHeader || !authHeader.startsWith('Bearer ')) {
    return new Response('Unauthorized', { status: 401 })
  }
  
  const token = authHeader.substring(7)
  
  try {
    const decoded = await verifyJWT(token)
    // Continue processing request
    return fetch('https://api.example.com/data', {
      headers: { 'X-User-ID': decoded.userId }
    })
  } catch (error) {
    return new Response('Invalid token', { status: 401 })
  }
}

5. Rate Limiting and Anti-Crawling

Functions:

Request frequency limiting
Crawler identification and interception
Malicious request filtering

Example:

javascript
// IP-based rate limiting
const rateLimiter = new Map()

async function handleRequest(request) {
  const ip = request.headers.get('CF-Connecting-IP')
  const now = Date.now()
  
  if (!rateLimiter.has(ip)) {
    rateLimiter.set(ip, { count: 1, resetTime: now + 60000 })
    return fetch(request)
  }
  
  const data = rateLimiter.get(ip)
  
  if (now > data.resetTime) {
    rateLimiter.set(ip, { count: 1, resetTime: now + 60000 })
    return fetch(request)
  }
  
  if (data.count >= 100) {
    return new Response('Too many requests', { status: 429 })
  }
  
  data.count++
  return fetch(request)
}

6. Data Aggregation and Caching

Functions:

Multi-source data aggregation
Intelligent caching
Data preprocessing

Example:

javascript
// Aggregate data from multiple APIs
async function handleRequest(request) {
  const cacheKey = 'aggregated-data'
  const cachedData = await cache.get(cacheKey)
  
  if (cachedData) {
    return new Response(cachedData)
  }
  
  // Parallel requests to multiple data sources
  const [users, products, orders] = await Promise.all([
    fetch('https://api.example.com/users').then(r => r.json()),
    fetch('https://api.example.com/products').then(r => r.json()),
    fetch('https://api.example.com/orders').then(r => r.json())
  ])
  
  const aggregatedData = {
    users: users.data,
    products: products.data,
    orders: orders.data,
    timestamp: Date.now()
  }
  
  // Cache for 5 minutes
  await cache.put(cacheKey, JSON.stringify(aggregatedData), { expirationTtl: 300 })
  
  return new Response(JSON.stringify(aggregatedData))
}

Main CDN Edge Computing Platforms

1. Cloudflare Workers

Features:

Based on V8 engine
Supports JavaScript/TypeScript
200+ data centers globally
Free tier available

Advantages:

Simple deployment
Excellent performance
Rich ecosystem

Example:

javascript
addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
  return new Response('Hello from Cloudflare Workers!')
}

2. AWS Lambda@Edge

Features:

Integrated with CloudFront
Supports Node.js, Python
Auto-scaling

Advantages:

Seamless integration with AWS ecosystem
High availability
Pay-as-you-go

Example:

javascript
exports.handler = async (event) => {
  const request = event.Records[0].cf.request
  
  // Modify request
  request.headers['x-custom-header'] = [{ value: 'custom-value' }]
  
  return request
}

3. Fastly Compute@Edge

Features:

Based on WebAssembly
Supports Rust, C++, JavaScript
High performance

Advantages:

Excellent performance
Supports multiple languages
High flexibility

4. Cloudflare Workers KV

Features:

Globally distributed key-value storage
Integrated with Workers
Low-latency read/write

Use cases:

Configuration storage
User sessions
Counters

Example:

javascript
async function handleRequest(request) {
  const key = 'visit-count'
  let count = await KV.get(key) || 0
  count = parseInt(count) + 1
  await KV.put(key, count.toString())
  
  return new Response(`Visit count: ${count}`)
}

Edge Computing Best Practices

1. Stateless Design

Principles:

Don't rely on local storage
Use external storage services
Design reentrant functions

Example:

javascript
// Good practice: Use external storage
async function handleRequest(request) {
  const data = await KV.get('key')
  return new Response(data)
}

// Bad practice: Rely on local variables
let counter = 0
async function handleRequest(request) {
  counter++
  return new Response(counter.toString())
}

2. Error Handling and Degradation

Strategies:

Graceful degradation
Retry mechanism
Timeout control

Example:

javascript
async function fetchWithTimeout(url, timeout = 5000) {
  const controller = new AbortController()
  const timeoutId = setTimeout(() => controller.abort(), timeout)
  
  try {
    const response = await fetch(url, { signal: controller.signal })
    clearTimeout(timeoutId)
    return response
  } catch (error) {
    clearTimeout(timeoutId)
    // Return cached data or default value
    return new Response('Service temporarily unavailable', { status: 503 })
  }
}

3. Performance Optimization

Optimization techniques:

Reduce external dependencies
Use caching
Optimize code size

Example:

javascript
// Use cache to reduce external requests
const CACHE_TTL = 300 // 5 minutes

async function handleRequest(request) {
  const cacheKey = request.url
  const cached = await cache.get(cacheKey)
  
  if (cached) {
    return cached
  }
  
  const response = await fetch(request)
  await cache.put(cacheKey, response.clone(), { expirationTtl: CACHE_TTL })
  
  return response
}

4. Monitoring and Logging

Monitoring metrics:

Request success rate
Response time
Error rate

Logging:

javascript
async function handleRequest(request) {
  const startTime = Date.now()
  
  try {
    const response = await fetch(request)
    console.log(`Request completed in ${Date.now() - startTime}ms`)
    return response
  } catch (error) {
    console.error(`Request failed: ${error.message}`)
    throw error
  }
}

Edge Computing Challenges

1. Difficult Development and Debugging

Challenges:

Differences between local and production environments
Limited debugging tools
Inconvenient log viewing

Solutions:

Use simulation environments
Comprehensive logging
Gradual deployment

2. Resource Limitations

Limitations:

CPU time limits
Memory limits
Execution time limits

Coping strategies:

Optimize code performance
Reduce unnecessary calculations
Use async operations

3. Cold Start Latency

Problem:

First request may have latency
Affects user experience

Solutions:

Warm up functions
Keep functions active
Use caching

Interview Points

When answering this question, emphasize:

Understanding of core value and advantages of edge computing
Knowledge of main edge computing use cases
Mastery of at least one edge computing platform
Practical edge computing development experience
Understanding of edge computing challenges and solutions