Cloudflare Containers: Guía de Docker Serverless

Aunque Cloudflare Workers ofrece un cómputo V8 Isolates de ultra baja latencia, existían limitaciones como el “límite de memoria de 128 MB a 3 GB”, la “imposibilidad de ejecutar binarios C/C++ y C-extensions nativas de Python” y la “incapacidad de realizar tareas pesadas basadas en Puppeteer, FFmpeg o Chromium”. La tecnología lanzada como versión de disponibilidad general (GA) en abril de 2026, solucionando por completo estas limitaciones de los Isolates, es precisamente Cloudflare Containers.

Cloudflare Containers es un servicio de contenedores serverless en el edge que despliega imágenes OCI estándar de Docker en más de 330 centros de datos edge de Cloudflare a nivel mundial (Region: Earth), donde el script de Workers actúa como orquestador (Orchestrator) controlando dinámicamente las instancias. A diferencia de AWS Fargate o GCP Cloud Run, que requieren mantener servidores encendidos con costos fijos, cuenta con una arquitectura de facturación que se ejecuta al instante solo cuando se reciben solicitudes y se escala a cero (Scale-to-Zero) durante los períodos de inactividad (Idle).

Este artículo ofrece una guía basada en código práctico que abarca desde el principio de funcionamiento de Cloudflare Containers hasta la vinculación de Docker mediante wrangler.jsonc, la implementación de orquestación con el SDK @cloudflare/containers, la construcción de un sandbox de código para agentes de IA y un benchmark con una reducción de costos del 70% en comparación con AWS ECS/Fargate.

Resumen clave

• Docker Serverless Scale-to-Zero: Cuando no hay solicitudes, escala a 0 instancias reduciendo el costo básico de mantenimiento a 0 dólares, facturándose exclusivamente en función del tiempo de CPU activo (Active CPU Time) en incrementos de 10 ms.
• Orquestación basada en Workers: Cloudflare Worker opera como API Gateway y orquestador, controlando programáticamente el ciclo de vida del contenedor, el enrutamiento de sesiones y el balanceo de carga round-robin.
• Ubicación automática en el edge regional (Region: Earth): Las instancias de contenedores se aprovisionan dinámicamente en forma de sandbox en el centro de datos edge más cercano al usuario, minimizando la latencia RTT.
• Reducción de costos del 70% en comparación con AWS Fargate: Elimina los costos de instancias de servidor siempre encendidas y ofrece una rentabilidad abrumadora en cargas de trabajo de tráfico intermitente (ejecución de agentes de IA, conversión de imagen/video) mediante una facturación de ultra precisión de 10 ms.

1. Comparación de rendimiento: V8 Isolates (Workers) vs Cloudflare Containers

Según la documentación oficial de Cloudflare Containers y la versión GA de abril de 2026, esta es la comparación de la arquitectura central entre ambos runtimes.

[사용자 요청]
      │
      ▼
[Cloudflare Worker] ──(HTTP / SDK 라우팅)──► [Cloudflare Containers (Docker)]
 (인증, 보안, 라우팅)                           (Python, FFmpeg, AI Code Sandbox)

2. Dockerfile 및 컨테이너 애플리케이션 작성 (Dockerfile, app.py)

Cloudflare Containers에서 실행할 이미지 처리 및 Python 데이터 분석용 웹 서비스 예시다.

Python FastAPI 기반 애플리케이션 (app.py)

# app.py - FFmpeg 및 PIL을 활용한 에지 샌드박스 컨테이너 API
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import subprocess
import os

app = FastAPI(title="Cloudflare Containers Microservice")

class MediaRequest(BaseModel):
    video_url: str
    target_format: str = "mp4"

@app.get("/health")
def health_check():
    return {"status": "healthy", "runtime": "Cloudflare Containers"}

@app.post("/process-media")
def process_media(req: MediaRequest):
    # FFmpeg 바이너리를 직접 실행하여 영상 트랜스코딩 수행 (V8 Isolates에서는 불가능)
    output_filename = f"/tmp/output.{req.target_format}"
    cmd = [
        "ffmpeg", "-y", "-i", req.video_url,
        "-t", "5", "-vf", "scale=640:-1", output_filename
    ]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        raise HTTPException(status_code=500, detail=f"FFmpeg Error: {result.stderr}")
        
    file_size = os.path.getsize(output_filename)
    return {
        "success": True,
        "output_file": output_filename,
        "size_bytes": file_size
    }

Dockerfile 정의 (Dockerfile)

# Dockerfile
FROM python:3.11-slim

# FFmpeg 및 네이티브 C 라이브러리 설치
RUN apt-get update && apt-get install -y \
    ffmpeg \
    libsm6 \
    libxext6 \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

EXPOSE 8080

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8080"]

3. Worker 오케스트레이터 구현: wrangler.jsonc 및 TypeScript (src/index.ts)

Cloudflare Worker에서 Docker 컨테이너 바인딩을 선언하고 @cloudflare/containers SDK로 컨테이너 수명주기를 제어한다.

wrangler.jsonc 설정

// wrangler.jsonc - Cloudflare Containers 바인딩 설정
{
  "$schema": "./node_modules/wrangler/config-schema.json",
  "name": "edge-container-orchestrator",
  "main": "src/index.ts",
  "compatibility_date": "2026-08-04",
  // Containers 바인딩 선언
  "containers": [
    {
      "binding": "MEDIA_CONTAINER",
      "image": "docker.io/myusername/media-processor:latest",
      "class_name": "MediaProcessorContainer",
      "instance_limit": 10
    }
  ]
}

Worker 오케스트레이터 스크립트 (src/index.ts)

// src/index.ts - Container 오케스트레이터 및 리퀘스트 라우팅
import { ContainerBinding } from '@cloudflare/containers';

export interface Env {
  MEDIA_CONTAINER: ContainerBinding;
}

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

    // 1. 단순 정적 API 라우트는 Worker가 0ms로 빠른 처리
    if (url.pathname === '/api/info') {
      return Response.json({ service: 'Workers Gateway', edge: true });
    }

    // 2. 고성능 무거운 작업 요청 시 컨테이너 동적 생성/호출
    if (url.pathname === '/api/convert-video' && request.method === 'POST') {
      const body = await request.json();

      try {
        // @cloudflare/containers SDK: 세션 ID 기반 컨테이너 인스턴스 획득
        // 활성화된 인스턴스가 없으면 Scale-from-Zero로 300ms 내 자동 프로비저닝
        const container = await env.MEDIA_CONTAINER.get({
          id: `session-${crypto.randomUUID()}`,
        });

        // 컨테이너 내부 8080 포트로 HTTP 요청 프록시 전달
        const containerResponse = await container.fetch('/process-media', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(body),
        });

        const data = await containerResponse.json();
        return Response.json({
          orchestrated_by: 'Cloudflare Worker',
          result: data,
        });
      } catch (err: any) {
        return Response.json(
          { error: 'Container Execution Failed', details: err.message },
          { status: 500 },
        );
      }
    }

    return new Response('Not Found', { status: 404 });
  },
};

Al combinarlo con las canalizaciones de larga ejecución abordadas en la Guía de ejecuciones duraderas de Cloudflare Workflows, se completa una potente arquitectura edge a prueba de fallos en la que Workflows se encarga de todo el flujo de control y distribuye cada paso de ejecución pesado a Cloudflare Containers.

4. Reducción de costos y benchmark de rendimiento

Comparación entre AWS Fargate y Cloudflare Containers basada en un tráfico de 1 millón de transcodificaciones de video/ejecuciones de código al mes.

Al igual que el efecto de ahorro en costos de egreso abordado en la Guía de migración de AWS S3 a Cloudflare R2, el hecho de que el costo de transferencia de datos dentro de la infraestructura de Cloudflare sea de 0 dólares representa una gran ventaja.

5. Lista de verificación para adopción empresarial

Preguntas frecuentes

¿Cuál es la diferencia entre Cloudflare Containers y los Cloudflare Workers tradicionales?

Workers es un Isolate ultraligero de JavaScript/Wasm basado en el motor V8 con un Cold Start cercano a los 0 ms, pero no permite la ejecución de librerías nativas C/C++ ni paquetes de Python. Containers permite ejecutar imágenes OCI de Docker completas en el edge, eliminando las restricciones de memoria o runtime.

¿Cuál es la velocidad del Cold Start?

En un estado de Scale-to-Zero, la latencia del Cold Start para aprovisionar el primer contenedor al recibir una solicitud es en promedio de 280 ms a 450 ms. Es aproximadamente 50 veces más rápido en comparación con AWS Fargate (15 a 45 segundos).

¿Pueden los contenedores acceder directamente a la base de datos D1 o al almacenamiento R2?

Sí. El orquestador Cloudflare Worker posee las vinculaciones de D1 y R2, y al reenviar solicitudes al contenedor, las aísla mediante encabezados HTTP o tokens de autenticación para compartir la base de datos y el almacenamiento de forma segura.

¿Es posible desplegar directamente imágenes de Docker Hub existentes?

Sí. Si se especifica en el campo image del archivo wrangler.jsonc con el formato docker.io/username/repository:tag, se sincronizará y desplegará automáticamente en el registro edge de Cloudflare durante el deployment.