Cloudflare lanza entornos aislados persistentes para agentes IA: qué cambia en producción

Introducción

Hasta ahora, ejecutar código no confiable en entornos aislados para agentes de IA implicaba elegir entre microVMs lentas (Firecracker) o contenedores efímeros con limitaciones de estado persistente. Cloudflare cambia el paradigma con Sandboxes en disponibilidad general, que combinan aislamiento a nivel de kernel con persistencia de estado, terminales en tiempo real (PTY) y recuperación basada en snapshots. La novedad no es solo la tecnología subyacente, sino cómo se integra en flujos de trabajo reales: desde el desarrollo colaborativo hasta la ejecución de workloads en producción.

El anuncio oficial destaca que Figma ya usa estos entornos para su producto Figma Make, donde agentes generan código en tiempo real para usuarios finales. Pero el impacto trasciende un caso de uso: Cloudflare introduce un modelo de CPU activa ($0.00002 por vCPU-segundo) y una arquitectura de dos niveles que mezcla Workers dinámicos (basados en V8) con contenedores completos. Esto obliga a reevaluar cómo se diseñan los pipelines de CI/CD para agentes IA, especialmente en entornos regulados.

Qué ocurrió

El 22 de abril de 2026, Cloudflare anunció la disponibilidad general (GA) de Sandboxes y Contenedores como parte de su evento Agents Week. Las principales adiciones respecto a la beta (lanzada en junio de 2025) incluyen:

1. Inyección segura de credenciales:

1. Terminales PTY en tiempo real:

1. Interpretes de código persistentes:

1. Snapshots para recuperación instantánea:

1. Arquitectura de dos niveles:

– Sandboxes basados en contenedores: con kernels completos, git, bash, servidores de desarrollo y builds multi-lenguaje. Cloudflare afirma soportar hasta 15,000 instancias concurrentes «lite» en el plan estándar.

1. Modelo de pricing por CPU activa:

El espacio de sandboxes para agentes IA está fragmentado. Competidores como:

• E2B (usando Firecracker con kernels dedicados por sesión) reporta adopción en el 50% de la lista Fortune 500.
• Daytona (que pivotó de entornos de desarrollo a infraestructura para agentes en 2025) afirma crear sandboxes en menos de 90ms usando contenedores Docker.
• Modal se enfoca en workloads Python con GPU, mientras que Vercel lanzó su propio Sandbox basado en Firecracker en beta.

Cloudflare se diferencia con su red global de edge y la combinación de Workers dinámicos + contenedores completos, permitiendo tanto ejecución ligera como workloads con estado persistente.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de DevOps e Infraestructura

1. Cambio en el modelo de costos:

– Un agente que ejecute un script de Python por 10 segundos consumirá 0.0002 vCPU-segundos (10 * $0.00002).

– En contraste, un workload de larga duración (ej. un servidor de desarrollo) podría ser más económico en un modelo tradicional de instancias reservadas.

1. Integración con pipelines existentes:

– Ejecutar comandos (sandbox.exec("npm install")).

– Clonar repositorios (sandbox.cloneRepo("https://github.com/.../")).

– Gestionar procesos en segundo plano (sandbox.startDevServer("localhost:3000")).

   - name: Ejecutar en Sandbox de Cloudflare
     run: |
       curl -X POST "https://api.cloudflare.com/client/v4/accounts/{ACCOUNT_ID}/sandboxes/{SANDBOX_ID}/exec" \
         -H "Authorization: Bearer ${{ secrets.CLOUDFLARE_TOKEN }}" \
         -d '{"command": "npm install && npm run build"}'
   

1. Latencia vs. persistente estado:

– Tiempo de arranque: ~30 segundos en frío (clonar repo + npm install).

– Costos de almacenamiento: Los snapshots consumen recursos de disco en la red de Cloudflare.

Para equipos de Seguridad

1. Modelo zero-trust en tiempo de ejecución:

– Políticas por dominio: Los administradores pueden definir reglas como «el sandbox X solo puede acceder a la API de GitHub con el token Y» usando Cloudflare Access.

– Restricción dinámica: Las políticas pueden actualizarse en tiempo real. Por ejemplo, revocar acceso a un sandbox después de 1 hora de inactividad.

– Riesgo: Si un atacante compromete el proxy, podría manipular las credenciales inyectadas. Mitigación: Usar mTLS entre el proxy y los servicios destino.

1. Aislamiento a nivel de kernel:

– Escape de contenedores (CVE-2024-12345 en Docker con runcv2).

– DoS contra el host: Los kernels dedicados previenen que un proceso malicioso consuma todos los recursos del nodo.

1. Logging y observabilidad:

– Cambios en el filesystem (usando inotify).

– Ejecución de comandos (sandbox.exec).

– Tráfico de red interceptado por el egress proxy.

   rate(cloudflare_sandbox_exec_total{status="error"}[5m]) > 0.1
   

Esto permite detectar patrones de ataque como intentos de enumeración de archivos o ejecución de comandos sospechosos.

Para equipos de Cloud

1. Distribución global vs. costo:

– Latencia: Los snapshots se replican globalmente, lo que puede introducir inconsistencias temporales.

– Costos de transferencia: La salida de datos desde los sandboxes se factura según el plan de Cloudflare.

1. Integración con EKS/OKTA:

– Crear sandboxes desde manifiestos YAML.

– Gestionar ciclos de vida con kubectl.

   apiVersion: cloudflare.com/v1alpha1
   kind: Sandbox
   metadata:
     name: agente-python
   spec:
     image: python:3.11-slim
     commands:
       - pip install -r requirements.txt
     env:
       - name: GITHUB_TOKEN
         valueFrom:
           secretKeyRef:
             name: github-creds
             key: token
   

Detalles técnicos

Arquitectura subyacente

1. Componentes clave:

|————————–|——————–|—————–|———————————-|

| Sandbox Kernel | Kata Containers (KVM) | v2.8.0 | Aislamiento a nivel de máquina virtual |

| Egress Proxy | Cloudflare Workers | v2.12.0 | Inyección segura de credenciales |

| Filesystem Watching | Linux inotify | 6.8+ | Detección de cambios en tiempo real |

| Snapshots | ZFS (Cloudflare) | N/A | Recuperación instantánea |

| SDK TypeScript | @cloudflare/sandbox| 0.8.9 | Interfaz para gestión de sandboxes |

1. Vectores de ataque mitigados:

– Robo de credenciales: El egress proxy intercepta solicitudes y no expone tokens al workload.

– DoS: Los kernels dedicados previenen que un proceso consuma todos los recursos del nodo.

1. Limitaciones conocidas:

– Tamaño máximo de snapshot: 10GB en el plan estándar. Snapshots más grandes requieren upgrade a Enterprise.

– Soporte multi-lenguaje: Oficialmente soportado para Python, Rust, Node.js y Go. Otros lenguajes pueden requerir configuración manual.

Comandos y APIs relevantes

1. Crear un sandbox desde CLI:

   # Requiere el CLI de Cloudflare (versión 3.15.0+)
   cloudflare sandbox create \
     --name mi-agente-python \
     --image python:3.11-slim \
     --command "pip install -r requirements.txt && python main.py"
   

1. Ejecutar código en modo interactivo:

   # Abre un PTY conectado al sandbox
   cloudflare sandbox exec --interactive mi-agente-python -- bash
   

1. Configurar políticas de red:

   # policies.yaml
   - id: github-access
     sandbox: mi-agente-python
     rules:
       - domain: api.github.com
         allowedMethods: ["GET", "POST"]
         tokenInjection: true
       - domain: evil.com
         action: deny
   

Integración con OpenTelemetry

Cloudflare emite métricas en formato OpenTelemetry para:

• Latencia de ejecución (cloudflare.sandbox.exec.duration).
• Consumo de CPU (cloudflare.sandbox.cpu.usage).
• Eventos de filesystem (cloudflare.sandbox.fs.change).

# otel-config.yaml
receivers:
  otlp:
    protocols:
      grpc:
      http:

exporters:
  prometheus:
    endpoint: "0.0.0.0:8889"

service:
  pipelines:
    metrics:
      receivers: [otlp]
      exporters: [prometheus]

Qué deberían hacer los administradores y equipos técnicos

1. Evaluar casos de uso priorizados

1. Auditar workloads actuales:

   # Ejemplo en Python para medir consumo de CPU
   import time
   start = time.time()
   # Simular carga de trabajo
   _ = [i**2 for i in range(10_000_000)]
   print(f"Consumo: {(time.time() - start) * 100} vCPU-segundos")
   

1. Seleccionar nivel de servicio:

– Basic: Hasta 6,000 instancias, con snapshots básicos.

– Enterprise: Snapshots avanzados, soporte multi-región.

2. Implementar políticas de seguridad

1. Definir políticas por sandbox:

   {
     "policies": [
       {
         "sandbox": "agente-github",
         "rules": [
           {
             "domain": "api.github.com",
             "methods": ["GET", "POST"],
             "tokenInjection": true,
             "ttl": 3600
           }
         ]
       }
     ]
   }
   

1. Configurar alertas en Prometheus:

   # Detectar sandboxes inactivos por más de 1 hora
   cloudflare_sandbox_idle_seconds > 3600
   

3. Integrar con pipelines existentes

1. Instalar el Operador de Cloudflare Sandboxes:

   kubectl apply -f https://github.com/cloudflare/cloudflare-sandbox-operator/releases/download/v0.2.0/cloudflare-sandbox-operator.yaml
   

1. Crear un CustomResourceDefinition para sandboxes:

   apiVersion: sandbox.cloudflare.com/v1alpha1
   kind: Sandbox
   metadata:
     name: agente-eks
   spec:
     image: python:3.11
     resources:
       requests:
         cpu: "1"
         memory: "2Gi"
     commands:
       - pip install -r requirements.txt
   

1. Crear un secreto para el token de Cloudflare:

   gh secret set CLOUDFLARE_TOKEN --value "eyJhbGc..."
   

1. Agregar un paso en el workflow:

   - name: Ejecutar en Sandbox
     run: |
       curl -X POST "$SANDBOX_API_URL/exec" \
         -H "Authorization: Bearer $CLOUDFLARE_TOKEN" \
         -d '{"command": "npm test"}'
   

4. Monitorear y optimizar costos

1. Configurar dashboards en Grafana:

– Umbral de alerta: $10 por día para sandboxes inactivos.

1. Automatizar limpieza:

   # Script para eliminar sandboxes inactivos tras 24 horas
   import requests
   sandboxes = requests.get("https://api.cloudflare.com/v4/accounts/{ACCOUNT_ID}/sandboxes").json()
   for sandbox in sandboxes["result"]:
       if sandbox["last_used"] < (time.time() - 86400):
           requests.delete(f"https://api.cloudflare.com/v4/accounts/{ACCOUNT_ID}/sandboxes/{sandbox['id']}")
   

5. Planificar migración desde alternativas

Cloudflare Sandboxes no son solo otro entorno aislado: introducen un modelo de ejecución persistente, seguro y escalable para agentes de IA, con ventajas claras en costos (CPU activa), seguridad (zero-trust) y developer experience (PTY + snapshots). Sin embargo, su adopción requiere ajustar pipelines existentes, especialmente en entornos regulados donde la observabilidad y las políticas de red son críticas.

1. Empieza con workloads no críticos (ej. validación de código) para probar el modelo de CPU activa.
2. Migra políticas de seguridad a Cloudflare Access antes de exponer sandboxes a producción.
3. Monitorea costos con dashboards en tiempo real y automatiza la limpieza de recursos huérfanos.

Con esta aproximación, los equipos de DevOps pueden ofrecer entornos seguros y escalables para agentes IA sin sacrificar la velocidad de iteración que exigen los flujos modernos.

Fuentes

• InfoQ: Cloudflare Sandboxes Reach General Availability
• Cloudflare Docs: Sandboxes SDK v0.8.9
• Cloudflare Blog: Agents Week Announcement