cloudflare-expert

name	cloudflare-expert
version	1.0.0
description	Expert-level Cloudflare Workers, CDN, edge computing, and security services
category	cloud
tags	["cloudflare","edge-computing","cdn","workers","waf"]
allowed-tools	["Read","Write","Edit","Bash(wrangler:*)"]

Cloudflare Expert

Expert guidance for Cloudflare Workers, edge computing, CDN optimization, and Cloudflare security services.

Core Concepts

Cloudflare Services

• Cloudflare Workers (serverless edge computing)
• CDN and caching
• DDoS protection
• Web Application Firewall (WAF)
• DNS management
• Load balancing
• Workers KV (key-value storage)
• Durable Objects

Edge Computing

• Deploy code globally
• Reduce latency
• Process at the edge
• Distributed state
• Real-time applications

Developer Tools

• Wrangler CLI
• Workers Playground
• Edge APIs
• Analytics and logs

Cloudflare Workers

// Basic Worker
export default {
  async fetch(request, env, ctx) {
    return new Response('Hello from Cloudflare Workers!', {
      headers: { 'Content-Type': 'text/plain' }
    });
  }
};

// Advanced routing
export default {
  async fetch(request, env, ctx) {
    const url = new URL(request.url);

    // Route based on path
    switch (url.pathname) {
      case '/api/users':
        return handleUsers(request, env);
      case '/api/posts':
        return handlePosts(request, env);
      default:
        return new Response('Not Found', { status: 404 });
    }
  }
};

// API endpoint with JSON
async function handleUsers(request, env) {
  if (request.method === 'GET') {
    const users = await env..(, { :  });
      (.(users), {
      : { :  }
    });
  }

   (request. === ) {
     body =  request.();
     env..(, .(body));
      (, { :  });
  }

    (, { :  });
}

Workers KV Storage

// Workers KV operations
export default {
  async fetch(request, env, ctx) {
    // Write
    await env.MY_KV.put('key', 'value');

    // Write with metadata and expiration
    await env.MY_KV.put('key', 'value', {
      metadata: { userId: '123' },
      expirationTtl: 3600 // 1 hour
    });

    // Read
    const value = await env.MY_KV.get('key');

    // Read as JSON
    const jsonValue = await env.MY_KV.get('key', { type: 'json' });

    // Read with metadata
    const { value, metadata } = await env.MY_KV.getWithMetadata('key');

    // Delete
    await env.MY_KV.delete('key');

    // List keys
    const keys = await env..({ :  });

      (.({ value, keys }));
  }
};


  {
  () {
    . = kv;
  }

   () {
    
     cached =  ..(key, { :  });
     (cached)  cached;

    
     data =  ();
     ..(key, .(data), {
      : ttl
    });

     data;
  }
}

  {
   () {
     cache =  (env.);

     data =  cache.(,  () => {
       response =  ();
       response.();
    }, );

      (.(data));
  }
};

Durable Objects

// Durable Object for stateful logic
export class Counter {
  constructor(state, env) {
    this.state = state;
    this.value = 0;
  }

  async initialize() {
    this.value = await this.state.storage.get('value') || 0;
  }

  async fetch(request) {
    await this.initialize();

    const url = new URL(request.url);

    if (url.pathname === '/increment') {
      this.value++;
      await this.state.storage.put('value', this.value);
      return new Response(String(this.value));
    }

     (url. === ) {
      .--;
       ...(, .);
        ((.));
    }

      ((.));
  }
}


   {
  () {
    . = state;
    . = [];
  }

   () {
     (request..() !== ) {
        (, { :  });
    }

     pair =  ();
     [client, server] = .(pair);

     .(server);

      (, {
      : ,
      : client
    });
  }

   () {
    websocket.();
    ..(websocket);

    websocket.(,  (msg) => {
      
       ( session  .) {
         {
          session.(msg.);
        }  (err) {
          
          . = ..( s !== session);
        }
      }
    });
  }
}


  {
   () {
     url =  (request.);
     roomId = url..();

    
     id = env..(roomId);
     stub = env..(id);

     stub.(request);
  }
};

Request/Response Handling

// CORS handling
function handleCORS(request) {
  const corsHeaders = {
    'Access-Control-Allow-Origin': '*',
    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE',
    'Access-Control-Allow-Headers': 'Content-Type, Authorization'
  };

  // Handle preflight
  if (request.method === 'OPTIONS') {
    return new Response(null, { headers: corsHeaders });
  }

  return corsHeaders;
}

// Authentication middleware
async function authenticate(request, env) {
  const token = request.headers.get('Authorization')?.replace('Bearer ', '');

  if (!token) {
    return new Response('Unauthorized', { status: 401 });
  }

  // Verify token (example using JWT)
  try {
    const payload = await verifyJWT(token, env.JWT_SECRET);
    return payload;
  } catch (err) {
    return  (, { :  });
  }
}


  {
  () {
    . = kv;
  }

   () {
     key = ;
     now = .();
     windowMs = windowSeconds * ;

    
     data =  ..(key, { :  });

     (!data || now - data. > windowMs) {
      
       ..(key, .({
        : ,
        : now
      }), { : windowSeconds });
       ;
    }

     (data. >= maxRequests) {
       ; 
    }

    
    data.++;
     ..(key, .(data), {
      : windowSeconds
    });

     ;
  }
}

  {
   () {
     corsHeaders = (request);
     (request. === )  corsHeaders;

    
     rateLimiter =  (env.);
     clientIP = request..();
     allowed =  rateLimiter.(clientIP, , );

     (!allowed) {
        (, {
        : ,
        : corsHeaders
      });
    }

    
     user =  (request, env);
     (user  ) {
       user; 
    }

    
     response =  (request, env, user);

    
    .(corsHeaders).( {
      response..(key, value);
    });

     response;
  }
};

Caching Strategies

// Cache API
async function cacheFirst(request) {
  const cache = caches.default;
  let response = await cache.match(request);

  if (!response) {
    response = await fetch(request);
    // Cache for 1 hour
    response = new Response(response.body, response);
    response.headers.set('Cache-Control', 'max-age=3600');
    await cache.put(request, response.clone());
  }

  return response;
}

// Stale-while-revalidate
async function staleWhileRevalidate(request, ctx) {
  const cache = caches.default;
  let response = await cache.match(request);

  // Background refresh
  ctx.waitUntil(
    fetch(request).then(freshResponse => {
      const clonedResponse = freshResponse.clone();
      cache.put(request, clonedResponse);
    })
  );

  if (response) {
    return response;
  }

  return (request);
}


 () {
   url =  (request.);

  
  url. = ;

  
   userAgent = request..();
   isMobile = .(userAgent);
  url..(, isMobile ?  : );

    (url.(), request);
}

  {
   () {
     cacheKey = (request);

     (request..()) {
      
       (cacheKey, ctx);
    }

    
     (cacheKey);
  }
};

Edge Functions

// HTML rewriting
export default {
  async fetch(request, env, ctx) {
    const response = await fetch(request);

    // Inject analytics script
    return new HTMLRewriter()
      .on('head', new HeadInjector())
      .transform(response);
  }
};

class HeadInjector {
  element(element) {
    element.append(
      '<script>console.log("Injected at edge!");</script>',
      { html: true }
    );
  }
}

// Geolocation-based routing
export default {
  async fetch(request, env, ctx) {
    const country = request.cf.country;

    // Route based on country
    const apiEndpoint = {
      'US': 'https://us-api.example.com',
      'EU': 'https://eu-api.example.com',
      'default': 'https://global-api.example.com'
    }[country] || 'https://global-api.example.com';

    const url = new URL(request.url);
     apiUrl =  (url., apiEndpoint);

     (apiUrl, request);
  }
};


  {
   () {
     url =  (request.);

    
     variant = request..()?.()?.[];

     (!variant) {
      variant = .() <  ?  : ;
    }

    
     response =  ();

    
     newResponse =  (response., response);
    newResponse..(, );

     newResponse;
  }
};

Wrangler CLI

# Initialize project
wrangler init my-worker

# Development server
wrangler dev

# Deploy to production
wrangler publish

# Deploy to specific environment
wrangler publish --env production

# Tail logs
wrangler tail

# KV operations
wrangler kv:namespace create "MY_KV"
wrangler kv:key put --namespace-id=<id> "key" "value"
wrangler kv:key get --namespace-id=<id> "key"

# Durable Objects
wrangler publish --new-class Counter

# Secrets
wrangler secret put SECRET_NAME

wrangler.toml Configuration

name = "my-worker"
main = "src/index.js"
compatibility_date = "2024-01-01"

# KV bindings
kv_namespaces = [
  { binding = "MY_KV", id = "xxxxxxxx" },
  { binding = "CACHE_KV", id = "yyyyyyyy" }
]

# Durable Objects
[durable_objects]
bindings = [
  { name = "COUNTER", class_name = "Counter" },
  { name = "CHAT_ROOM", class_name = "ChatRoom" }
]

[[migrations]]
tag = "v1"
new_classes = ["Counter", "ChatRoom"]

# Environment variables
[vars]
ENVIRONMENT = "production"

# Routes
routes = [
  { pattern = "example.com/*", zone_name = "example.com" }
]

# Cron triggers
[triggers]
crons = ["0 */6 * * *"]

Best Practices

Performance

• Cache aggressively at the edge
• Minimize worker execution time
• Use Workers KV for global data
• Implement connection pooling
• Optimize cache keys
• Use stale-while-revalidate
• Minimize external requests

Security

• Validate all inputs
• Implement rate limiting
• Use secrets for sensitive data
• Set security headers
• Implement CORS properly
• Use HTTPS everywhere
• Log security events

Development

• Use TypeScript for type safety
• Test locally with wrangler dev
• Implement proper error handling
• Monitor worker metrics
• Use environment variables
• Version your workers
• Document API endpoints

Anti-Patterns

❌ Storing large data in KV frequently ❌ Long-running computations in workers ❌ Not implementing caching ❌ Hardcoding secrets ❌ Ignoring rate limits ❌ No error handling ❌ Excessive external API calls

Resources

• Cloudflare Workers: https://workers.cloudflare.com/
• Wrangler CLI: https://developers.cloudflare.com/workers/wrangler/
• Workers Examples: https://developers.cloudflare.com/workers/examples/
• Durable Objects: https://developers.cloudflare.com/workers/learning/using-durable-objects/
• Workers KV: https://developers.cloudflare.com/workers/runtime-apis/kv/