Cloudflare: Seguridad en el Edge, CDN, Plataforma AI y Rendimiento

Tipos de Registros DNS y Configuración

Cloudflare actúa como proveedor DNS autoritativo con anycast global. El ícono de nube naranja (proxied) enruta el tráfico a través del edge de Cloudflare, habilitando CDN, WAF y protección DDoS. Nube gris (DNS only) es resolución DNS plana.

# Terraform - Cloudflare DNS records
resource "cloudflare_record" "root" {
  zone_id = var.zone_id
  name    = "@"
  content = "192.0.2.1"
  type    = "A"
  proxied = true
  ttl     = 1 # Auto when proxied
}

resource "cloudflare_record" "www" {
  zone_id = var.zone_id
  name    = "www"
  content = "josenobile.co"
  type    = "CNAME"
  proxied = true
}

resource "cloudflare_record" "api" {
  zone_id = var.zone_id
  name    = "api"
  content = "api-lb.example.com"
  type    = "CNAME"
  proxied = true
}

# MX records (cannot be proxied)
resource "cloudflare_record" "mx" {
  zone_id  = var.zone_id
  name     = "@"
  content  = "mx.zoho.com"
  type     = "MX"
  priority = 10
}

DNSSEC

DNSSEC agrega firmas criptográficas a los registros DNS, previniendo DNS spoofing y cache poisoning. Cloudflare gestiona las claves de firma automáticamente; solo necesitas agregar el registro DS en tu registrador.

# Enable DNSSEC via API
curl -X PATCH "https://api.cloudflare.com/client/v4/zones/${ZONE_ID}/dnssec" \
  -H "Authorization: Bearer ${CF_TOKEN}" \
  -H "Content-Type: application/json" \
  --data '{"status":"active"}'

# Response includes DS record to add at registrar:
# {
#   "ds_record": "example.com. 3600 IN DS 2371 13 2 abc123...",
#   "algorithm": "ECDSAP256SHA256",
#   "digest": "abc123...",
#   "key_tag": 2371
# }

Reglas de Cache y TTLs

El CDN de Cloudflare cachea assets estáticos en 300+ ubicaciones edge en todo el mundo. Las Cache Rules (reemplazando las legacy Page Rules) proporcionan control granular sobre qué se cachea, por cuánto tiempo y bajo qué condiciones.

# Terraform - Cache Rules
resource "cloudflare_ruleset" "cache_rules" {
  zone_id = var.zone_id
  name    = "Cache Rules"
  kind    = "zone"
  phase   = "http_request_cache_settings"

  # Cache static assets aggressively
  rules {
    action = "set_cache_settings"
    action_parameters {
      cache = true
      browser_ttl { mode = "override_origin"; default = 2592000 }
      edge_ttl { mode = "override_origin"; default = 604800 }
    }
    expression = "(http.request.uri.path.extension in {\"js\" \"css\" \"png\" \"jpg\" \"webp\" \"woff2\" \"svg\"})"
    description = "Cache static assets: 7d edge, 30d browser"
  }

  # API: no cache
  rules {
    action = "set_cache_settings"
    action_parameters {
      cache = false
    }
    expression = "(starts_with(http.request.uri.path, \"/api/\"))"
    description = "Bypass cache for API endpoints"
  }

  # HTML: short edge cache, revalidate
  rules {
    action = "set_cache_settings"
    action_parameters {
      cache = true
      edge_ttl { mode = "override_origin"; default = 3600 }
      browser_ttl { mode = "override_origin"; default = 0 }
    }
    expression = "(http.request.uri.path.extension eq \"html\" or http.request.uri.path eq \"/\")"
    description = "Cache HTML: 1h edge, always revalidate browser"
  }
}

Estrategias de Purga de Cache

Purga por URL para invalidación dirigida, por tag para assets agrupados, o purga total para limpiar todo el cache. La purga vía API se integra con CI/CD para cache busting disparado por deploys.

# Purge specific URLs after deploy
curl -X POST "https://api.cloudflare.com/client/v4/zones/${ZONE_ID}/purge_cache" \
  -H "Authorization: Bearer ${CF_TOKEN}" \
  -H "Content-Type: application/json" \
  --data '{
    "files": [
      "https://josenobile.co/",
      "https://josenobile.co/health/",
      "https://josenobile.co/scripts/lib/search-component.js"
    ]
  }'

# Purge by Cache-Tag header (Enterprise)
curl -X POST "https://api.cloudflare.com/client/v4/zones/${ZONE_ID}/purge_cache" \
  -H "Authorization: Bearer ${CF_TOKEN}" \
  --data '{"tags": ["health-articles", "dashboard"]}'

Reglas WAF Personalizadas

El WAF de Cloudflare provee rulesets gestionados (OWASP Core Ruleset, Cloudflare Managed) y reglas personalizadas usando expresiones wirefilter. Las reglas custom permiten bloquear, desafiar o loguear tráfico basado en atributos del request.

# Terraform - Custom WAF rules
resource "cloudflare_ruleset" "waf_custom" {
  zone_id = var.zone_id
  name    = "Custom WAF Rules"
  kind    = "zone"
  phase   = "http_request_firewall_custom"

  # Block known bad user agents
  rules {
    action     = "block"
    expression = "(http.user_agent contains \"sqlmap\" or http.user_agent contains \"nikto\" or http.user_agent contains \"nmap\")"
    description = "Block security scanner user agents"
  }

  # Challenge suspicious login attempts
  rules {
    action     = "managed_challenge"
    expression = "(http.request.uri.path eq \"/api/auth/login\" and http.request.method eq \"POST\" and ip.geoip.country ne \"CO\" and ip.geoip.country ne \"US\")"
    description = "Challenge foreign login attempts"
  }

  # Block access to sensitive paths
  rules {
    action     = "block"
    expression = "(http.request.uri.path contains \"/.env\" or http.request.uri.path contains \"/wp-admin\" or http.request.uri.path contains \"/.git\")"
    description = "Block access to sensitive files"
  }

  # Log high-risk requests for analysis
  rules {
    action     = "log"
    expression = "(cf.threat_score gt 30)"
    description = "Log high threat score requests"
  }
}

Rulesets Gestionados y OWASP

El Cloudflare Managed Ruleset y el OWASP Core Ruleset proporcionan protección automática contra vulnerabilidades comunes: SQLi, XSS, RCE, LFI y anomalías de protocolo. Puedes sobreescribir la sensibilidad y acción por regla o grupo de reglas.

# Terraform - Deploy managed WAF rulesets
resource "cloudflare_ruleset" "waf_managed" {
  zone_id = var.zone_id
  name    = "Managed WAF Rulesets"
  kind    = "zone"
  phase   = "http_request_firewall_managed"

  # Cloudflare Managed Ruleset
  rules {
    action = "execute"
    action_parameters {
      id = "efb7b8c949ac4650a09736fc376e9aee" # CF Managed
      overrides {
        rules {
          id      = "5de7edfa648c4d6891dc3e7f84534ffa"
          action  = "log"
          enabled = true
        }
      }
    }
    expression  = "true"
    description = "Deploy Cloudflare Managed Ruleset"
  }

  # OWASP Core Ruleset
  rules {
    action = "execute"
    action_parameters {
      id = "4814384a9e5d4991b9815dcfc25d2f1f" # OWASP
      overrides {
        categories {
          category = "paranoia-level-2"
          action   = "managed_challenge"
        }
      }
    }
    expression  = "true"
    description = "Deploy OWASP Core Ruleset"
  }
}

Reglas de Rate Limiting en el Edge

El rate limiting en el edge detiene tráfico abusivo antes de que llegue a tus servidores origen. Cloudflare soporta rate limiting por IP, IP + path, sesión, país y claves custom usando headers o cookies.

# Terraform - Rate limiting rules
resource "cloudflare_ruleset" "rate_limit" {
  zone_id = var.zone_id
  name    = "Rate Limiting"
  kind    = "zone"
  phase   = "http_ratelimit"

  # API global rate limit: 100 req/min per IP
  rules {
    action = "block"
    action_parameters {
      response {
        status_code  = 429
        content      = "{\"error\":\"Rate limit exceeded\"}"
        content_type = "application/json"
      }
    }
    ratelimit {
      characteristics     = ["cf.colo.id", "ip.src"]
      period              = 60
      requests_per_period  = 100
      mitigation_timeout   = 120
    }
    expression  = "(starts_with(http.request.uri.path, \"/api/\"))"
    description = "API rate limit: 100 req/min per IP"
  }

  # Login brute force protection: 5 attempts/min
  rules {
    action = "managed_challenge"
    ratelimit {
      characteristics     = ["ip.src"]
      period              = 60
      requests_per_period  = 5
      mitigation_timeout   = 600
    }
    expression  = "(http.request.uri.path eq \"/api/auth/login\" and http.request.method eq \"POST\")"
    description = "Login rate limit: 5 attempts/min"
  }
}

Fundamentos de Workers

Los Cloudflare Workers ejecutan JavaScript/TypeScript en el edge en isolates V8. Cold starts sub-milisegundo, sin contenedores, desplegados en 300+ ubicaciones. Los Workers pueden interceptar, modificar o generar respuestas HTTP.

// src/index.ts - Cloudflare Worker
export interface Env {
  API_KEY: string;
  RATE_LIMIT_KV: KVNamespace;
  ASSETS: Fetcher;
}

export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
    const url = new URL(request.url);

    // Serve static assets
    if (url.pathname.startsWith('/static/')) {
      return env.ASSETS.fetch(request);
    }

    // API proxy with auth header injection
    if (url.pathname.startsWith('/api/')) {
      const origin = new URL(request.url);
      origin.hostname = 'api-internal.example.com';

      const modifiedRequest = new Request(origin.toString(), {
        method: request.method,
        headers: new Headers(request.headers),
        body: request.body,
      });
      modifiedRequest.headers.set('X-Worker-Auth', env.API_KEY);
      modifiedRequest.headers.set('X-Real-IP', request.headers.get('CF-Connecting-IP') || '');

      return fetch(modifiedRequest);
    }

    // A/B testing via cookie
    const variant = request.headers.get('cookie')?.match(/ab_variant=(\w+)/)?.[1]
      || (Math.random() > 0.5 ? 'A' : 'B');

    const response = await fetch(`https://origin.example.com/${variant.toLowerCase()}${url.pathname}`);
    const newResponse = new Response(response.body, response);
    newResponse.headers.set('Set-Cookie', `ab_variant=${variant}; Path=/; Max-Age=86400`);
    return newResponse;
  }
};

Workers KV y Durable Objects

Workers KV es un key-value store distribuido globalmente con consistencia eventual. Durable Objects proporcionan consistencia fuerte y coordinación de instancia única para casos como rate limiters, contadores y salas WebSocket.

// Rate limiter using Durable Objects
export class RateLimiter implements DurableObject {
  private requests: Map<string, number[]> = new Map();

  async fetch(request: Request): Promise<Response> {
    const ip = request.headers.get('CF-Connecting-IP') || 'unknown';
    const now = Date.now();
    const windowMs = 60_000;
    const limit = 100;

    const timestamps = this.requests.get(ip) || [];
    const recent = timestamps.filter(t => now - t < windowMs);

    if (recent.length >= limit) {
      return new Response(JSON.stringify({ error: 'Rate limit exceeded' }), {
        status: 429,
        headers: {
          'Content-Type': 'application/json',
          'Retry-After': '60',
          'X-RateLimit-Limit': limit.toString(),
          'X-RateLimit-Remaining': '0',
        },
      });
    }

    recent.push(now);
    this.requests.set(ip, recent);

    return new Response(JSON.stringify({ allowed: true }), {
      headers: {
        'X-RateLimit-Remaining': (limit - recent.length).toString(),
      },
    });
  }
}

D1, R2 y Queues

D1 es la base de datos SQLite serverless de Cloudflare. R2 es almacenamiento de objetos compatible con S3 sin costos de egreso. Queues permite el paso de mensajes asíncronos entre Workers para arquitecturas desacopladas.

// D1 - Serverless SQLite at the edge
export interface Env {
  DB: D1Database;
  BUCKET: R2Bucket;
  QUEUE: Queue<{ type: string; payload: unknown }>;
}

// D1: query SQLite
async function getUser(env: Env, id: string) {
  const stmt = env.DB.prepare('SELECT * FROM users WHERE id = ?').bind(id);
  return await stmt.first();
}

// R2: store/retrieve objects (S3-compatible)
async function uploadFile(env: Env, key: string, body: ReadableStream) {
  await env.BUCKET.put(key, body, {
    httpMetadata: { contentType: 'application/octet-stream' },
    customMetadata: { uploadedAt: new Date().toISOString() },
  });
}

async function getFile(env: Env, key: string) {
  const obj = await env.BUCKET.get(key);
  if (!obj) return new Response('Not found', { status: 404 });
  return new Response(obj.body, {
    headers: { 'Content-Type': obj.httpMetadata?.contentType || '' },
  });
}

// Queues: async message passing between Workers
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    // Producer: send message to queue
    await env.QUEUE.send({
      type: 'user.signup',
      payload: { email: '[email protected]', timestamp: Date.now() },
    });
    return new Response('Queued');
  },

  // Consumer: process messages from queue
  async queue(batch: MessageBatch<{ type: string; payload: unknown }>, env: Env) {
    for (const msg of batch.messages) {
      console.log(`Processing: ${msg.body.type}`);
      // Process message...
      msg.ack();
    }
  },
};

Configuración de Cloudflare Pages

Pages despliega sitios estáticos directamente desde repositorios Git con builds automáticos, deployments de preview para branches y soporte de dominios custom. Cero configuración para la mayoría de generadores de sitios estáticos.

# wrangler.toml for Pages project
name = "josenobile-co"
compatibility_date = "2024-12-01"
pages_build_output_dir = "./"

# Deploy via CLI
npx wrangler pages deploy ./ --project-name=josenobile-co

# Or connect Git repo for automatic deploys:
# Repository: github.com/josenobile/josenobile.co
# Branch: main -> Production
# All other branches -> Preview URLs

# Custom headers (_headers file)
/*
  X-Frame-Options: DENY
  X-Content-Type-Options: nosniff
  Referrer-Policy: strict-origin-when-cross-origin
  Permissions-Policy: camera=(), microphone=(), geolocation=()
  Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self'

/assets/*
  Cache-Control: public, max-age=31536000, immutable

/*.html
  Cache-Control: public, max-age=0, must-revalidate

Redirects y Routing Personalizado

El archivo _redirects maneja redirects y rewrites de URLs. Combinado con Pages Functions (Workers del lado del servidor), obtienes capacidad full-stack en una plataforma de sitios estáticos.

# _redirects file
/blog/*  /health/:splat  301
/old-page  /new-page  301
/api/*  https://api.example.com/:splat  200
/es/*  /:splat  302

# Pages Function (functions/api/health.ts)
export const onRequestGet: PagesFunction = async (context) => {
  const data = await fetch('https://api.example.com/health');
  return new Response(await data.text(), {
    headers: {
      'Content-Type': 'application/json',
      'Cache-Control': 'public, max-age=60',
    },
  });
};

Consultas de Logs Basadas en SQL

Cloudflare Log Explorer proporciona una API SQL para consultar logs de requests HTTP, eventos de firewall y analytics de Workers. Puedes ejecutar queries ad-hoc para debugging, investigación de seguridad y análisis de rendimiento.

# Top 10 paths by request count (last 24h)
SELECT
  ClientRequestPath AS path,
  COUNT(*) AS requests,
  AVG(EdgeTimeToFirstByteMs) AS avg_ttfb_ms,
  SUM(CASE WHEN EdgeResponseStatus >= 500 THEN 1 ELSE 0 END) AS errors_5xx
FROM http_requests
WHERE Datetime > NOW() - INTERVAL '24' HOUR
GROUP BY path
ORDER BY requests DESC
LIMIT 10;

# Detect anomalous traffic patterns
SELECT
  ClientIP,
  ClientCountry,
  COUNT(*) AS requests,
  COUNT(DISTINCT ClientRequestPath) AS unique_paths,
  AVG(EdgeTimeToFirstByteMs) AS avg_ttfb
FROM http_requests
WHERE Datetime > NOW() - INTERVAL '1' HOUR
GROUP BY ClientIP, ClientCountry
HAVING requests > 500
ORDER BY requests DESC;

# WAF blocked requests analysis
SELECT
  Action,
  RuleID,
  Description,
  COUNT(*) AS blocks,
  array_agg(DISTINCT ClientCountry) AS countries
FROM firewall_events
WHERE Datetime > NOW() - INTERVAL '7' DAY
  AND Action = 'block'
GROUP BY Action, RuleID, Description
ORDER BY blocks DESC;

Bot Score y Detección

La detección de bots de Cloudflare asigna un score de 1 (probable bot) a 99 (probable humano) usando machine learning, análisis de comportamiento y fingerprinting. Las reglas pueden tomar diferentes acciones basadas en el bot score.

# Terraform - Bot management rules
resource "cloudflare_ruleset" "bot_rules" {
  zone_id = var.zone_id
  name    = "Bot Management"
  kind    = "zone"
  phase   = "http_request_firewall_custom"

  # Block definitely automated traffic on API
  rules {
    action     = "block"
    expression = "(cf.bot_management.score lt 10 and starts_with(http.request.uri.path, \"/api/\") and not cf.bot_management.verified_bot)"
    description = "Block definite bots on API"
  }

  # Challenge likely bots on forms
  rules {
    action     = "managed_challenge"
    expression = "(cf.bot_management.score lt 30 and http.request.method eq \"POST\" and not cf.bot_management.verified_bot)"
    description = "Challenge likely bots on POST"
  }

  # Allow verified bots (Googlebot, Bingbot, etc.)
  rules {
    action     = "skip"
    action_parameters { ruleset = "current" }
    expression = "(cf.bot_management.verified_bot)"
    description = "Allow verified search engine bots"
  }
}

# Super Bot Fight Mode (free tier)
resource "cloudflare_bot_management" "default" {
  zone_id              = var.zone_id
  fight_mode           = true
  enable_js            = true
  sbfm_definitely_automated = "block"
  sbfm_likely_automated     = "managed_challenge"
  sbfm_verified_bots        = "allow"
}

Configuración de Tunnel

Cloudflare Tunnel (anteriormente Argo Tunnel) crea conexiones cifradas de solo salida desde tu origen al edge de Cloudflare, eliminando la necesidad de exponer IPs públicas o abrir puertos de firewall entrantes. El tráfico se enruta a través del centro de datos de Cloudflare más cercano.

Related: see Cloudflare Tunnel Proxy for an end-to-end self-hosted authenticated proxy (cloudflared + Xray VLESS+WS+TLS + v2RayTun on Android), with travel runbook, hardening, and troubleshooting.

# Install and authenticate cloudflared
cloudflared tunnel login
cloudflared tunnel create my-tunnel

# config.yml
tunnel: <TUNNEL_ID>
credentials-file: /root/.cloudflared/<TUNNEL_ID>.json

ingress:
  - hostname: app.example.com
    service: http://localhost:8080
  - hostname: api.example.com
    service: http://localhost:3000
    originRequest:
      noTLSVerify: true
      connectTimeout: 30s
  - hostname: ssh.example.com
    service: ssh://localhost:22
  - service: http_status:404  # Catch-all

# Run as systemd service
cloudflared tunnel --config /etc/cloudflared/config.yml run my-tunnel

# Terraform - Cloudflare Tunnel
resource "cloudflare_tunnel" "main" {
  account_id = var.account_id
  name       = "production-tunnel"
  secret     = base64encode(random_password.tunnel_secret.result)
}

resource "cloudflare_tunnel_config" "main" {
  account_id = var.account_id
  tunnel_id  = cloudflare_tunnel.main.id

  config {
    ingress_rule {
      hostname = "app.example.com"
      service  = "http://localhost:8080"
    }
    ingress_rule {
      service = "http_status:404"
    }
  }
}

Políticas de Cloudflare Access

Cloudflare Access reemplaza las VPNs tradicionales con un proxy basado en identidad. Cada request se autentica y autoriza en el edge basado en proveedor de identidad (IdP), postura del dispositivo, IP y país antes de llegar a la aplicación.

# Terraform - Zero Trust Access application
resource "cloudflare_access_application" "internal_dashboard" {
  zone_id                   = var.zone_id
  name                      = "Internal Dashboard"
  domain                    = "dashboard.example.com"
  type                      = "self_hosted"
  session_duration          = "24h"
  auto_redirect_to_identity = true
  allowed_idps              = [cloudflare_access_identity_provider.google.id]
}

resource "cloudflare_access_policy" "dashboard_policy" {
  zone_id        = var.zone_id
  application_id = cloudflare_access_application.internal_dashboard.id
  name           = "Allow engineering team"
  precedence     = 1
  decision       = "allow"

  include {
    email_domain = ["example.com"]
  }
  require {
    group = [cloudflare_access_group.engineering.id]
  }
}

resource "cloudflare_access_group" "engineering" {
  zone_id = var.zone_id
  name    = "Engineering Team"

  include {
    email_domain = ["example.com"]
  }
  require {
    group = ["[email protected]"]
  }
}

# Identity provider configuration
resource "cloudflare_access_identity_provider" "google" {
  zone_id = var.zone_id
  name    = "Google Workspace"
  type    = "google"
  config {
    client_id     = var.google_client_id
    client_secret = var.google_client_secret
  }
}

Configuración de Email Routing

Cloudflare Email Routing crea direcciones de email personalizadas en tu dominio y las reenvía a buzones existentes. No se requiere servidor de correo. Soporta reglas catch-all, múltiples destinos y procesamiento de emails basado en Workers.

# Terraform - Email routing rules
resource "cloudflare_email_routing_settings" "default" {
  zone_id = var.zone_id
  enabled = true
}

resource "cloudflare_email_routing_address" "personal" {
  account_id = var.account_id
  email      = "[email protected]"
}

resource "cloudflare_email_routing_rule" "contact" {
  zone_id = var.zone_id
  name    = "contact"
  enabled = true

  matcher {
    type  = "literal"
    field = "to"
    value = "[email protected]"
  }
  action {
    type  = "forward"
    value = ["[email protected]"]
  }
}

resource "cloudflare_email_routing_catch_all" "default" {
  zone_id = var.zone_id
  name    = "catch-all"
  enabled = true

  matcher { type = "all" }
  action {
    type  = "forward"
    value = ["[email protected]"]
  }
}

# Email Worker for programmatic email processing
export default {
  async email(message: EmailMessage, env: Env) {
    // Forward based on subject
    if (message.headers.get('subject')?.includes('urgent')) {
      await message.forward('[email protected]');
    } else {
      await message.forward('[email protected]');
    }
  },
};

Mitigación y Configuración DDoS

Cloudflare proporciona protección DDoS ilimitada y siempre activa en las capas 3, 4 y 7. La red absorbe ataques de hasta cientos de Tbps usando anycast y detección automatizada. Las reglas HTTP DDoS y Advanced TCP Protection permiten ajustar la sensibilidad para patrones de tráfico específicos.

# Terraform - HTTP DDoS Attack Protection overrides
resource "cloudflare_ruleset" "ddos_override" {
  zone_id = var.zone_id
  name    = "DDoS Protection Overrides"
  kind    = "zone"
  phase   = "ddos_l7"

  rules {
    action = "execute"
    action_parameters {
      id = "4d21379b4f9f4bb088e0729962c8b3cf" # HTTP DDoS ruleset
      overrides {
        # Increase sensitivity for API endpoints
        rules {
          id              = "fdfdac75430c4c47a422bdc024f57730"
          sensitivity_level = "high"
          action          = "block"
        }
      }
    }
    expression  = "true"
    description = "HTTP DDoS protection with custom sensitivity"
  }
}

# Network-layer DDoS (L3/L4) is automatic for proxied records
# Monitor via API:
curl -s "https://api.cloudflare.com/client/v4/zones/${ZONE_ID}/security/events?filter=kind:ddos" \
  -H "Authorization: Bearer ${CF_TOKEN}" | jq '.result[:5]'

Modos de Cifrado SSL/TLS

Cloudflare ofrece cuatro modos SSL/TLS: Off, Flexible (solo edge), Full (edge-a-origen, certificado autofirmado OK) y Full (Strict) (edge-a-origen, certificado válido requerido). Siempre usa Full (Strict) en producción. Los certificados de origen emitidos por Cloudflare proporcionan TLS gratuito y de larga duración para la conexión al origen.

# Terraform - SSL/TLS configuration
resource "cloudflare_zone_settings_override" "ssl" {
  zone_id = var.zone_id

  settings {
    ssl                      = "strict"        # Full (Strict)
    always_use_https         = "on"
    min_tls_version          = "1.2"
    tls_1_3                  = "zrt"           # 0-RTT enabled
    automatic_https_rewrites = "on"
    opportunistic_encryption = "on"
  }
}

# Origin Certificate (15-year, free from Cloudflare)
curl -X POST "https://api.cloudflare.com/client/v4/certificates" \
  -H "Authorization: Bearer ${CF_TOKEN}" \
  -H "Content-Type: application/json" \
  --data '{
    "hostnames": ["example.com", "*.example.com"],
    "requested_validity": 5475,
    "request_type": "origin-rsa",
    "csr": "'"$(cat origin.csr)"'"
  }'

# Authenticated Origin Pulls (mTLS: Cloudflare -> Origin)
resource "cloudflare_authenticated_origin_pulls" "default" {
  zone_id = var.zone_id
  enabled = true
}

# On the origin server (nginx):
# ssl_client_certificate /etc/nginx/certs/cloudflare-origin-pull-ca.pem;
# ssl_verify_client on;

Argo Smart Routing y Tiered Cache

Argo Smart Routing usa inteligencia de red en tiempo real para enrutar tráfico por las rutas más rápidas a través del backbone privado de Cloudflare, reduciendo la latencia un 30% en promedio. Combinado con Tiered Caching, optimiza la entrega tanto de contenido dinámico como estático.

# Terraform - Enable Argo Smart Routing
resource "cloudflare_argo" "default" {
  zone_id        = var.zone_id
  smart_routing  = "on"
  tiered_caching = "on"
}

# Argo routing benefits:
# - Detects real-time congestion and routes around it
# - Uses Cloudflare's private backbone instead of public internet
# - Reduces TTFB by 30% on average for dynamic content
# - Reduces origin load by ~35% with tiered caching

# Monitor Argo analytics via API
curl -s "https://api.cloudflare.com/client/v4/zones/${ZONE_ID}/analytics/latency?bins=10" \
  -H "Authorization: Bearer ${CF_TOKEN}" | jq '
  {
    argo_enabled_latency: .result.argo_enabled,
    without_argo_latency: .result.without_argo,
    improvement_pct: ((.result.without_argo - .result.argo_enabled) / .result.without_argo * 100)
  }'

Workers AI: Inferencia en el Edge

Workers AI ejecuta inferencia AI directamente en el edge de Cloudflare con GPUs desplegadas en 180+ ciudades, una de las mayores huellas de inferencia AI distribuida a nivel global. La plataforma aloja 50+ modelos open-source: LLMs (Llama 3.1/3.2, DeepSeek-R1, Qwen3, Gemma, Mistral), embeddings de texto, generación de imágenes (FLUX, Stable Diffusion), voz a texto (incluyendo el modelo Flux de Deepgram, @cf/deepgram/flux, diseñado para agentes de voz en tiempo real), texto a voz, clasificación de imágenes y detección de objetos. El pricing usa Neurons: $0.011 por 1,000 Neurons en planes pagos, con 10,000 Neurons/día gratis. El motor Infire, un runtime de inferencia en Rust lanzado a finales de 2025, entrega 7% más rápido que vLLM y reduce el overhead de CPU un 82% usando CUDA Graphs Granulares y compilación JIT.

// Workers AI: LLM inference at the edge
export default {
  async fetch(request, env) {
    const { prompt } = await request.json();

    // DeepSeek-R1 reasoning model
    const response = await env.AI.run('@cf/deepseek-ai/deepseek-r1-distill-qwen-32b', {
      messages: [
        { role: 'system', content: 'You are a helpful assistant.' },
        { role: 'user', content: prompt },
      ],
      max_tokens: 1024,
      temperature: 0.7,
    });

    return Response.json({ result: response.response });
  },
};

// Embeddings for semantic search
const embeddings = await env.AI.run('@cf/baai/bge-base-en-v1.5', {
  text: ['gym membership plans', 'workout schedule', 'personal training'],
});
// Returns: { data: [{ values: [0.012, -0.034, ...] }, ...] }

// Image generation with FLUX
const image = await env.AI.run('@cf/black-forest-labs/flux-1-schnell', {
  prompt: 'modern gym interior, natural lighting, photorealistic',
});
// Returns: ArrayBuffer of generated PNG

// Workers AI pricing (Neurons):
// @cf/meta/llama-3.2-1b-instruct:  ~2,457 Neurons/M input, ~18,252/M output
// @cf/meta/llama-3.1-70b-instruct: ~26,668 Neurons/M input, ~204,805/M output
// Free tier: 10,000 Neurons/day (hard limit on free plan)

Cloudflare finalizó la adquisición de Replicate en abril 2026 (anunciada originalmente en noviembre 2025), trayendo más de 50,000 modelos listos para producción al ecosistema Workers AI. El registro de modelos de Replicate, su infraestructura de fine-tuning y su comunidad de desarrolladores se integran directamente con Workers AI, dando acceso al mayor catálogo de modelos AI listos para desplegar en el edge. La API existente de Replicate sigue operativa con compatibilidad retroactiva, mientras los nuevos modelos están disponibles progresivamente a través del binding estándar de Workers AI con pricing basado en Neurons.

Kimi K2.5 (Agents Week 2026): Kimi K2.5 de Moonshot AI se convirtió en el primer modelo open-source de escala frontier disponible en Workers AI, con ventana de contexto de 256K, tool calling multi-turno, inputs de visión y outputs estructurados. Las pruebas internas mostraron que reduce costos de inferencia un 77% comparado con modelos propietarios de nivel medio para tareas de coding agéntico, siendo una opción fuerte para workloads de agentes sensibles al costo corriendo en el edge de Cloudflare.

Junto con la expansión de la plataforma AI, Cloudflare reconstruyó el CLI Wrangler con cobertura completa de API diseñada para workflows amigables con agentes. El nuevo CLI expone cada capacidad de Workers AI, Agents SDK y la plataforma como un comando scriptable, facilitando que agentes AI aprovisionen recursos, desplieguen workers, gestionen Durable Objects y orquesten pipelines AI programáticamente sin interacción con el dashboard.

Infire: Motor de Inferencia en Rust

Infire es el motor de inferencia LLM personalizado de Cloudflare, escrito en Rust, que potencia Workers AI en toda la red global. Reemplaza stacks de inferencia basados en Python (como vLLM) con un runtime de alto rendimiento optimizado para despliegue en el edge. Infire usa CUDA Graphs Granulares con compilación JIT para compilar un grafo CUDA dedicado para cada tamaño de batch posible al vuelo, ejecutando el trabajo como una estructura GPU monolítica única. Esto reduce el overhead de CPU un 82% (25% CPU vs. 140%+ de vLLM) y entrega 7% más rápido que vLLM 0.10.0 en GPUs H100 NVL. La carga de modelos desde disco toma menos de 4 segundos para Llama-3-8B-Instruct, y la utilización de GPU alcanza 80%+.

AI Gateway: Proxy, Observabilidad y Facturación Unificada

AI Gateway es una capa de proxy y observabilidad entre tu aplicación y 14+ proveedores AI (OpenAI, Anthropic, Google, Mistral, Cohere, Groq, xAI, Alibaba Cloud, Bytedance, Workers AI y otros), exponiendo 70+ modelos a través de un único endpoint API. Provee un endpoint compatible con OpenAI, rate limiting por usuario/clave (ventana deslizante o fija), caching de respuestas (reduciendo latencia hasta 90%), logging, analytics de costos en tiempo real y fallback con reintentos automáticos. Facturación Unificada consolida todos los costos de proveedores AI en una sola factura de Cloudflare -- carga créditos y gasta en cualquier proveedor, cambiando modelos con una sola línea de código. Logs persistentes (open beta) almacenan prompts y respuestas para análisis extendido.

// AI Gateway: proxy any AI provider through Cloudflare
const response = await fetch(
  'https://gateway.ai.cloudflare.com/v1/{account_id}/{gateway_id}/openai/chat/completions',
  {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${OPENAI_KEY}`,
      'Content-Type': 'application/json',
      'cf-aig-cache-ttl': '3600', // Cache identical prompts for 1h
    },
    body: JSON.stringify({
      model: 'gpt-4o',
      messages: [{ role: 'user', content: 'Suggest a workout plan' }],
    }),
  }
);
// Gateway adds: caching, rate limiting, logging, cost tracking, fallback
// No code changes needed — just change the base URL

// Unified Billing: pay for OpenAI, Anthropic, Google, etc. via Cloudflare
// 1. Load credits in Cloudflare dashboard
// 2. Remove provider API keys from your app
// 3. AI Gateway handles auth and billing transparently

// Provider fallback: automatic failover between providers
// Configure in dashboard: primary=OpenAI, fallback=Anthropic, fallback=Workers AI

Vectorize: Base de Datos Vectorial para RAG

Vectorize es la base de datos vectorial distribuida globalmente de Cloudflare, ahora GA y soportando hasta 5 millones de vectores por índice (desde 200K en el lanzamiento) con una latencia mediana de consulta de 31ms (desde 549ms). Diseñada para pipelines RAG, almacena embeddings de Workers AI y habilita búsqueda de similitud con baja latencia. Se integra nativamente con Workers AI para RAG de extremo a extremo en el edge.

// RAG pipeline: Workers AI + Vectorize
export default {
  async fetch(request, env) {
    const { question } = await request.json();

    // 1. Embed the question
    const queryEmbedding = await env.AI.run('@cf/baai/bge-base-en-v1.5', {
      text: [question],
    });

    // 2. Search Vectorize for similar documents (31ms median latency)
    const matches = await env.VECTORIZE.query(queryEmbedding.data[0].values, {
      topK: 5,
      returnMetadata: true,
      // Supports up to 5M vectors per index
    });

    // 3. Build context from matched documents
    const context = matches.matches
      .map(m => m.metadata.text)
      .join('\n');

    // 4. Generate answer with context
    const answer = await env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
      messages: [
        { role: 'system', content: `Answer using this context:\n${context}` },
        { role: 'user', content: question },
      ],
    });

    return Response.json({ answer: answer.response, sources: matches.matches });
  },
};

AI Search: Pipeline RAG Gestionado

AI Search (anteriormente AutoRAG) es el pipeline RAG completamente gestionado de Cloudflare. Maneja el flujo completo: ingesta de datos desde sitios web o contenido no estructurado, chunking y embedding automático, almacenamiento de vectores en Vectorize, recuperación semántica y generación de respuestas usando Workers AI. El pipeline monitorea continuamente las fuentes de datos y re-indexa en segundo plano. Se integra nativamente con R2, Browser Rendering, Vectorize, AI Gateway y Workers AI.

// AI Search (formerly AutoRAG): managed RAG pipeline
import { createAISearch } from '@cloudflare/ai-search';

// Configure data sources and AI Search handles the rest
const aiSearch = createAISearch({
  source: { type: 'r2', bucket: 'knowledge-base' },
  // Auto-chunks, embeds, stores vectors, and keeps index fresh
});

// Worker binding for queries
export default {
  async fetch(request, env) {
    const { query } = await request.json();

    // Natural language search with context-aware answers
    const result = await env.AI_SEARCH.search(query);

    return Response.json({
      answer: result.response,
      sources: result.citations,
      confidence: result.score,
    });
  },
};

R2 + AI: Pipelines AI Basados en Eventos

Las Notificaciones de Eventos de R2 (GA) disparan Workers cuando se crean, modifican o eliminan objetos en buckets R2, habilitando pipelines AI basados en eventos. Sube un documento a R2 y automáticamente se fragmenta, embebe e indexa en Vectorize. Sube un video y se auto-transcribe con reconocimiento de voz de Workers AI. Los eventos fluyen por Cloudflare Queues a hasta 5,000 mensajes por segundo. Combinado con restricciones jurisdiccionales, políticas de ciclo de vida y uploads multipart 60% más rápidos, R2 sirve como backbone de almacenamiento para flujos AI en producción.

// R2 Event Notifications: auto-process uploads with AI
// wrangler.toml
// [[r2_buckets]]
// binding = "DOCS_BUCKET"
// bucket_name = "knowledge-base"

// [[queues.consumers]]
// queue = "r2-upload-events"

export default {
  // Triggered when new file uploaded to R2
  async queue(batch, env) {
    for (const msg of batch.messages) {
      const event = msg.body;
      if (event.action === 'PutObject') {
        const obj = await env.DOCS_BUCKET.get(event.object.key);
        const text = await obj.text();

        // Auto-embed and store in Vectorize
        const embedding = await env.AI.run('@cf/baai/bge-base-en-v1.5', {
          text: [text],
        });
        await env.VECTORIZE.upsert([{
          id: event.object.key,
          values: embedding.data[0].values,
          metadata: { text, source: event.object.key },
        }]);
      }
      msg.ack();
    }
  },
};

// R2 Storage Classes + AI workloads
# Standard: active data ($0.015/GB/month, zero egress)
# Infrequent Access: archival training data ($0.01/GB/month)
# Event notifications: up to 5,000 msgs/sec per Queue
# Jurisdictional restrictions: pin data to EU, US, etc.
# Super Slurper: migrate from S3/GCS/Azure to R2

Agents SDK: Agentes AI con Estado sobre Durable Objects

El Agents SDK es un framework TypeScript para construir agentes AI en producción sobre la infraestructura de Durable Objects de Cloudflare. Cada agente es un micro-servidor con estado con su propia base de datos SQL, conexiones WebSocket y scheduling. AIChatAgent provee chat AI con streaming, persistencia automática de mensajes y streams reanudables. Define herramientas del servidor, herramientas del cliente que corren en el navegador y flujos de aprobación humana. Los agentes pueden llamar cualquier modelo AI (Workers AI, OpenAI, Anthropic, Gemini) y transmitir respuestas por WebSockets o Server-Sent Events.A2A Protocol -- per-task state, native SSE, global anycast for Agent Card fetches, and edge-native x402 support for agent-to-agent payments.

// Agents SDK: AI agent with persistent state and tools
import { AIChatAgent } from 'cloudflare:agents';

export class ResearchAgent extends AIChatAgent {
  // Persistent SQL database per agent instance
  // Automatic message history persistence
  // Resumable streams across disconnections

  async onMessage(message) {
    // Stream response from any AI provider
    const stream = await this.ai.run('@cf/meta/llama-3.1-70b-instruct-fp8-fast', {
      messages: this.getHistory(),
      stream: true,
    });

    // Tool calling with human-in-the-loop approval
    return this.streamResponse(stream, {
      tools: [this.searchDocs, this.createReport],
      requireApproval: ['createReport'],
    });
  }

  @tool('Search documentation')
  async searchDocs(query: string) {
    const results = await this.env.VECTORIZE.query(
      await this.embed(query), { topK: 10 }
    );
    return results.matches;
  }

  @tool('Create report (requires approval)')
  async createReport(title: string, content: string) {
    await this.env.DB.prepare(
      'INSERT INTO reports (title, content) VALUES (?, ?)'
    ).bind(title, content).run();
    return { created: true };
  }

  // Schedule: agents can wake themselves for periodic work
  async onSchedule(trigger) {
    await this.refreshData();
  }
}

Think: Framework de Agentes Multi-Paso de Larga Duración

Think es un framework dentro del Agents SDK diseñado para persistencia y tareas multi-paso de larga duración. En lugar de responder a prompts individuales, los agentes Think mantienen estado entre pasos, pausan para eventos externos, reanudan después de horas o días, y coordinan con otros agentes. Think combina la persistencia de Durable Objects con la semántica de reintento paso a paso de Workflows.

Artifacts: Almacenamiento Git-Compatible para Agentes

Artifacts es un primitivo de almacenamiento compatible con Git construido para la era de agentes. Los desarrolladores pueden crear millones de repositorios, hacer fork desde cualquier fuente remota y dar a los agentes un hogar permanente para código y datos accesible desde cualquier cliente Git estándar. Los agentes usan Artifacts para persistir código generado, archivos de configuración, datos de investigación y productos de trabajo iterativos entre sesiones.

Sandboxes: SO Completo para Cargas de Trabajo de Agentes

Sandboxes da a los agentes acceso a entornos Linux persistentes y aislados con shell, sistema de archivos y procesos en segundo plano. Un agente puede clonar un repositorio, instalar paquetes Python, ejecutar builds, correr tests e iterar con el mismo ciclo de retroalimentación que un desarrollador humano. Los Sandboxes son más pesados que Dynamic Workers (que usan isolates V8) pero proveen capacidades de SO completas.

Abril 2026: Expansión de Agent Cloud

El 13 de abril de 2026, Cloudflare anunció una expansión importante de su infraestructura de agentes bajo el paraguas Agent Cloud. Artifacts alcanzó disponibilidad general como capa de almacenamiento Git-compatible diseñada para agentes, habilitando millones de repositorios con capacidad de fork desde cualquier fuente. Sandboxes pasó a GA con entornos Linux persistentes que sobreviven reinicios de agentes, dándoles el mismo ciclo de desarrollo que los humanos. El framework Think se integró en el Agents SDK como primitivo de primera clase para tareas multi-paso de larga duración con persistencia automática de estado y semánticas de reintento. Juntas, estas tres capacidades forman un runtime completo de agentes: Think para orquestación, Artifacts para almacenamiento persistente y Sandboxes para ejecución.

Tier Gratuito de Durable Objects

Los Durable Objects están ahora disponibles en el plan gratuito de Workers. Esto elimina la barrera del plan pago para construir aplicaciones en tiempo real, servidores WebSocket, herramientas colaborativas y agentes AI. El tier gratuito incluye 100,000 requests/día y 1 GB de almacenamiento.

Agents Week 2026 (22-24 de Abril)

Cloudflare Agents Week 2026 introdujo varias capacidades importantes. Agent Memory es un servicio gestionado que da a los agentes AI memoria persistente, permitiéndoles recordar contexto, olvidar datos irrelevantes y mejorar con el tiempo. Unweight es un sistema de compresión lossless en tiempo de inferencia que logra hasta 22% de reducción de footprint del modelo para ejecutar LLMs en la red de Cloudflare. Flagship es un servicio nativo de feature flags construido sobre KV y Durable Objects con evaluación de flags en sub-milisegundos. Cloudflare Email Service entró en beta pública, habilitando a los agentes enviar, recibir y procesar email nativamente. La Registrar API beta permite a desarrolladores y agentes AI buscar, verificar disponibilidad y registrar dominios programáticamente. Los Rust Workers ahora soportan recuperación resiliente de errores críticos con panic unwinding vía WebAssembly Exception Handling.

Dynamic Workers: Ejecución de Código AI 100x Más Rápida

Dynamic Workers (beta abierta, marzo 2026) son un runtime basado en isolates para ejecutar código generado por AI en sandboxes seguros. En lugar de ejecutar cada llamada a herramienta secuencialmente, el LLM genera una sola función TypeScript que encadena múltiples llamadas API, la ejecuta en un Dynamic Worker y retorna el resultado. Usan isolates V8 (no contenedores), arrancando en milisegundos y usando megabytes de memoria: 100x más rápido que contenedores. Los bridges Cap'n Web RPC manejan conectividad API a través del límite de seguridad, y la intercepción HTTP saliente inyecta credenciales automáticamente. Precio: $0.002 por Worker único cargado por día (gratuito durante beta).

// Dynamic Workers: LLM generates and executes code at runtime
import { DynamicWorkerLoader } from 'cloudflare:workers';

export default {
  async fetch(request, env) {
    const { task } = await request.json();

    // LLM generates a TypeScript function for the task
    const codeResponse = await env.AI.run('@cf/meta/llama-3.1-70b-instruct-fp8-fast', {
      messages: [{
        role: 'system',
        content: `Generate a TypeScript function that accomplishes the task.
                  Available APIs: env.DB (D1), env.KV, env.R2.
                  Return only the function body.`,
      }, {
        role: 'user',
        content: task,
      }],
    });

    // Execute the generated code in an isolated V8 sandbox
    const dynamicWorker = await env.DYNAMIC_WORKER.create({
      code: codeResponse.response,
      // Cap'n Web RPC bridges provide API access
      bindings: { DB: env.DB, KV: env.KV, R2: env.R2 },
    });

    // Starts in milliseconds, isolated from host Worker
    const result = await dynamicWorker.fetch(new Request('http://sandbox/run'));
    return result;
  },
};

// Security: outbound HTTP interception injects credentials
// Agent code never sees API keys or secrets directly
// Each Dynamic Worker runs in its own V8 isolate
// Boot time: ~5ms (vs. ~500ms for containers)

Servidores MCP Remotos en Cloudflare Workers

Model Context Protocol (MCP) es el estándar abierto para conectar agentes AI con herramientas externas. Cloudflare permite construir y desplegar servidores MCP remotos en Workers, haciendo tus herramientas accesibles a cualquier agente AI compatible con MCP (Claude, GPT, Gemini, etc.). A diferencia de servidores MCP locales, los remotos en Cloudflare corren globalmente en el edge sin gestión de infraestructura. Cloudflare provee el adaptador mcp-remote y un AI Playground como cliente MCP remoto para pruebas.

// MCP Server on Cloudflare Workers
import { McpAgent } from 'cloudflare:agents';

export class MyMCPServer extends McpAgent {
  // Expose tools to any MCP-compatible AI agent
  @tool('Query database')
  async queryDB(sql: string) {
    return await this.env.DB.prepare(sql).all();
  }

  @tool('Upload file to R2')
  async uploadFile(key: string, content: string) {
    await this.env.BUCKET.put(key, content);
    return { uploaded: key };
  }

  @tool('Run AI inference')
  async runInference(prompt: string) {
    return await this.env.AI.run('@cf/meta/llama-3.1-8b-instruct', {
      messages: [{ role: 'user', content: prompt }],
    });
  }
}
// Deploy: npx wrangler deploy
// Connect from Claude Desktop, Cursor, etc. via mcp-remote

Code Mode: APIs Completas en 1,000 Tokens

Code Mode resuelve una tensión central en MCP: los agentes necesitan muchas herramientas pero cada una llena la ventana de contexto. En lugar de describir cada operación como herramienta separada, Code Mode permite al modelo escribir código contra un SDK tipado y ejecutarlo de forma segura en un Dynamic Worker. El servidor MCP de la API de Cloudflare usa Code Mode para dar acceso a toda la API de Cloudflare consumiendo solo ~1,000 tokens de contexto.

Servidores MCP Oficiales de Cloudflare

Cloudflare provee servidores MCP oficiales para gestionar servicios de Cloudflare directamente desde agentes AI: gestionar deployments de Workers, consultar bases de datos D1, interactuar con almacenamiento R2, configurar registros DNS, inspeccionar analytics y más. Instala el servidor MCP de Cloudflare en tu IDE AI (Claude Desktop, Cursor, Windsurf) y gestiona toda tu infraestructura Cloudflare conversacionalmente.

Cloudflare Containers en el Edge

Cloudflare Containers ejecutan contenedores OCI (Docker) en la infraestructura de Durable Objects a través de la red global de Cloudflare. Los Workers sirven como API gateway, enrutando requests a instancias de contenedores de larga duración. Soportan networking TCP, sistemas de archivos persistentes, userspace Linux completo y límites a nivel de cuenta de aproximadamente 6 TiB de memoria, 1,500 vCPU y 30 TB de disco para cargas concurrentes. Usa contenedores para cargas que necesitan paquetes de sistema, procesos de larga duración o lenguajes más allá de JavaScript/TypeScript.

// wrangler.jsonc — Container configuration
{
  "name": "my-container-app",
  "containers": [{
    "name": "ml-inference",
    "image": "./Dockerfile",
    "max_instances": 5,
    "instance_type": "standard"
  }]
}

// Worker as API gateway for containers
export default {
  async fetch(request, env) {
    const container = await env.ML_CONTAINER.get("inference-1");
    // Forward request to the container
    const result = await container.fetch(request);
    return result;
  },
};

// Account limits (2026):
// ~6 TiB memory, ~1,500 vCPU, ~30 TB disk concurrent
// Full Docker/OCI compatibility
// Persistent filesystem across restarts

Workflows V2: Motor de Ejecución Durable

Workflows es el motor de ejecución durable de Cloudflare para aplicaciones multi-paso. Cada paso se persiste y reintenta automáticamente en caso de fallo. Soportan pasos de aprobación humana vía la API waitForEvent, ejecución paralela y procesos de larga duración (horas, días o semanas). El estado se persiste automáticamente entre pasos. Workflows es el backbone para orquestación de agentes AI: encadenar llamadas a herramientas, esperar aprobación humana, manejar rate limits con reintento automático y coordinar workflows multi-agente. Workflows V2 (mayo 2026) reconstruyó el motor con ejecución determinista y reproducible, y elevó los límites: hasta 50,000 instancias concurrentes (antes 4,500), 300 ejecuciones nuevas por segundo por cuenta (antes 100) y 2 millones de instancias en cola por workflow.

// Workflows: durable multi-step execution
import { WorkflowEntrypoint, WorkflowStep } from 'cloudflare:workers';

export class MemberOnboarding extends WorkflowEntrypoint {
  async run(event, step: WorkflowStep) {
    // Step 1: Create account (auto-retried on failure)
    const member = await step.do('create-account', async () => {
      return await this.env.API.createMember(event.payload);
    });

    // Step 2: Send welcome email
    await step.do('send-welcome', async () => {
      await this.env.EMAIL.send(member.email, 'Welcome!');
    });

    // Step 3: Wait for human approval (pauses workflow)
    await step.waitForEvent('admin-approval', { timeout: '7 days' });

    // Step 4: Activate subscription
    await step.do('activate', async () => {
      await this.env.API.activateSubscription(member.id);
    });

    return { memberId: member.id, status: 'onboarded' };
  }
}

EmDash: CMS AI-Nativo en Cloudflare Workers

EmDash (v0.1, abril 2026) es el CMS open-source de Cloudflare posicionado como sucesor espiritual de WordPress, reescrito completamente en TypeScript sobre Astro 6.0. Corre en Cloudflare Workers (escala a cero cuando está inactivo), usa Dynamic Workers para aislar plugins con permisos explícitos (abordando la causa raíz del 96% de las vulnerabilidades de seguridad de WordPress), e incluye características AI-nativas: Agent Skills para desarrollo asistido por AI de plugins/temas, CLI para gestión programática del sitio y un servidor MCP integrado para integración directa con herramientas AI. Migración de WordPress importa posts, páginas, media y taxonomías desde exportaciones WXR, la API REST de WordPress o WordPress.com.

# EmDash: TypeScript CMS on Cloudflare Workers
npm create emdash@latest my-site
cd my-site

# Configure for Cloudflare (also works on Node.js, Deno, etc.)
# astro.config.ts
import { defineConfig } from 'astro/config';
import emdash from '@emdash/astro';
import cloudflare from '@astrojs/cloudflare';

export default defineConfig({
  integrations: [emdash()],
  adapter: cloudflare(),
});

# Deploy to Cloudflare Workers
npx wrangler deploy

# Features included:
# - Admin panel, REST API, authentication, media library
# - Plugin system (sandboxed in Dynamic Workers)
# - Agent Skills for AI-assisted development
# - Built-in MCP server for AI agent management
# - WordPress import (WXR, REST API, WordPress.com)
# - Database: D1/SQLite/PostgreSQL via Kysely
# - Storage: R2/S3/local via S3 API abstraction