Cloudflare Containers 实战：在边缘运行完整容器工作负载

Cloudflare 在 2026 年正式推出 Containers 服务，打破了「边缘计算只能跑轻量函数」的固有认知。据官方数据，Containers 可在 50ms 内冷启动完整 Linux 容器，全球 300+ 数据中心就近执行，单容器最高支持 8 vCPU / 8GB 内存。对于需要运行 FFmpeg、Puppeteer、Python 数据处理等重负载的开发者来说，这彻底改变了边缘计算的游戏规则。

📌 记住： Cloudflare Containers 不是传统容器编排平台（如 K8s）的替代品，而是填补了 Workers（轻量无状态函数）和传统容器服务（高延迟、高成本）之间的空白地带。

🐳 一、架构原理与核心概念

1.1 Containers vs Workers：何时该用哪个？

Cloudflare 的计算产品线现在形成了清晰的三层架构：

⚠️ 警告： 不要因为 Containers 支持完整 Linux 就把所有逻辑都迁到容器里。能用 Workers 解决的问题，优先用 Workers — 启动更快、成本更低、运维更简单。

选择策略：

• ✅ 用 Workers： API 路由、轻量数据转换、HTML 重写、简单认证逻辑
• ✅ 用 Containers： FFmpeg 视频处理、Puppeteer 截图、Python ML 推理、编译型语言运行、需要系统级依赖的场景
• ❌ 避免用 Containers： 简单 CRUD API、静态内容服务、纯 JS 数据转换

1.2 运行时架构

Cloudflare Containers 基于 microVM 技术（类似 AWS Firecracker），每个容器运行在独立的轻量级虚拟机中：

┌─────────────────────────────────────┐
│         Cloudflare 数据中心          │
│  ┌──────────┐  ┌──────────┐        │
│  │ Worker   │  │ Worker   │        │
│  │ (V8)     │  │ (V8)     │        │
│  └────┬─────┘  └────┬─────┘        │
│       │              │              │
│  ┌────▼─────┐  ┌────▼─────┐        │
│  │Container │  │Container │        │
│  │(microVM) │  │(microVM) │        │
│  │ Ubuntu   │  │ Alpine   │        │
│  │ FFmpeg   │  │ Python   │        │
│  └──────────┘  └──────────┘        │
│                                     │
│  ┌──────────────────────────┐       │
│  │     D1 / R2 / KV         │       │
│  │   (持久化存储层)          │       │
│  └──────────────────────────┘       │
└─────────────────────────────────────┘

每个 microVM 提供：

• 完整的 Linux 内核隔离
• 独立的文件系统（支持持久化卷）
• 可配置的网络策略
• 最长 24 小时运行时间（长时间任务需续期）

🚀 二、从零部署一个容器

2.1 项目结构

创建一个 Cloudflare Containers 项目的标准结构如下：

my-container-app/
├── worker/
│   ├── src/
│   │   └── index.ts          # Worker 入口，调度容器
│   └── wrangler.toml
├── container/
│   ├── Dockerfile             # 容器镜像定义
│   └── app.py                 # 容器内应用
└── package.json

2.2 定义容器镜像

以下是一个 Python 数据处理容器的完整 Dockerfile：

# container/Dockerfile — 边缘数据处理容器
FROM python:3.12-slim

WORKDIR /app

# 安装依赖（尽量使用多阶段构建减小镜像体积）
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

# 暴露 Cloudflare 要求的默认端口
EXPOSE 8080

# Cloudflare 要求容器启动后监听健康检查
HEALTHCHECK --interval=5s --timeout=3s \
  CMD curl -f http://localhost:8080/health || exit 1

CMD ["python", "app.py"]

2.3 容器内应用代码

# container/app.py — 边缘 JSON 处理微服务
import json
import hashlib
from http.server import HTTPServer, BaseHTTPRequestHandler
from datetime import datetime, timezone

class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/health':
            self.send_response(200)
            self.send_header('Content-Type', 'application/json')
            self.end_headers()
            self.wfile.write(json.dumps({
                'status': 'healthy',
                'timestamp': datetime.now(timezone.utc).isoformat()
            }).encode())
            return

    def do_POST(self):
        if self.path == '/process':
            content_length = int(self.headers.get('Content-Length', 0))
            body = self.rfile.read(content_length)

            try:
                data = json.loads(body)
                # 执行 CPU 密集型处理
                result = self.process_data(data)

                self.send_response(200)
                self.send_header('Content-Type', 'application/json')
                self.end_headers()
                self.wfile.write(json.dumps(result).encode())
            except Exception as e:
                self.send_response(400)
                self.send_header('Content-Type', 'application/json')
                self.end_headers()
                self.wfile.write(json.dumps({
                    'error': str(e)
                }).encode())

    def process_data(self, data):
        """CPU 密集型 JSON 数据处理"""
        records = data.get('records', [])
        processed = []
        for record in records:
            # 计算数据指纹
            fingerprint = hashlib.sha256(
                json.dumps(record, sort_keys=True).encode()
            ).hexdigest()[:16]

            processed.append({
                **record,
                'fingerprint': fingerprint,
                'processed_at': datetime.now(timezone.utc).isoformat(),
                'record_size': len(json.dumps(record))
            })

        return {
            'total': len(processed),
            'records': processed,
            'total_size_bytes': sum(r['record_size'] for r in processed)
        }

if __name__ == '__main__':
    server = HTTPServer(('0.0.0.0', 8080), Handler)
    print('Container listening on port 8080')
    server.serve_forever()

2.4 Worker 入口：调度容器

// worker/src/index.ts — Cloudflare Worker 调度容器
interface Env {
  DATA_PROCESSOR: Fetcher; // 容器绑定
  AUTH_TOKEN: string;
}

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

    // 认证中间件
    const token = request.headers.get('Authorization')?.replace('Bearer ', '');
    if (token !== env.AUTH_TOKEN) {
      return new Response(JSON.stringify({ error: 'Unauthorized' }), {
        status: 401,
        headers: { 'Content-Type': 'application/json' }
      });
    }

    // 路由：健康检查
    if (url.pathname === '/health') {
      return env.DATA_PROCESSOR.fetch('http://container/health');
    }

    // 路由：数据处理 — 转发到容器
    if (url.pathname === '/api/process' && request.method === 'POST') {
      const body = await request.text();

      // 在 Worker 层做请求验证（轻量逻辑留在 Worker）
      try {
        const parsed = JSON.parse(body);
        if (!Array.isArray(parsed.records)) {
          return Response.json(
            { error: 'records must be an array' },
            { status: 400 }
          );
        }
        if (parsed.records.length > 10000) {
          return Response.json(
            { error: 'max 10000 records per request' },
            { status: 400 }
          );
        }
      } catch {
        return Response.json({ error: 'Invalid JSON' }, { status: 400 });
      }

      // 重负载转发给容器处理
      const containerResponse = await env.DATA_PROCESSOR.fetch(
        'http://container/process',
        {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body
        }
      );

      return containerResponse;
    }

    return Response.json({ error: 'Not Found' }, { status: 404 });
  }
};

2.5 Wrangler 配置

# worker/wrangler.toml
name = "my-container-app"
main = "src/index.ts"
compatibility_date = "2026-06-01"

[vars]
AUTH_TOKEN = "your-secret-token"  # 生产环境用 secrets

# 容器绑定配置
[[containers]]
name = "data-processor"
image = "./container/Dockerfile"
instance_type = "basic"  # basic(1vCPU/512MB) | standard(2vCPU/2GB) | performance(4vCPU/4GB)
max_instances = 10
min_instances = 0  # 缩容到 0，按需启动
port = 8080

# 持久化存储绑定
[[r2_buckets]]
binding = "STORAGE"
bucket_name = "container-data"

部署命令：

# 构建并部署
npx wrangler deploy

# 查看容器日志
npx wrangler containers logs data-processor

# 查看容器实例状态
npx wrangler containers instances list

⚡ 三、性能基准与成本对比

3.1 冷启动性能实测

以下是在不同场景下实测的冷启动数据（从请求到容器首次响应）：

⚠️ 警告： Chromium 类容器的冷启动时间显著高于轻量容器。如果做 Puppeteer 截图服务，建议保持至少 1 个热实例（min_instances = 1），避免用户体验问题。

3.2 成本对比（月估算）

以「每日 10 万次请求，每次平均 2 秒 CPU 时间」为例：

Cloudflare Containers 的计费模型是 按 vCPU·秒 + 内存·秒 计费，没有请求费。对于 CPU 密集型任务，这比 Lambda 的请求+持续时间双重计费更划算。

3.3 与 Workers 的协同模式

最佳实践是采用 Worker + Container 混合架构：

// 最佳实践：Worker 处理轻量逻辑，Container 处理重负载
async function handleRequest(request: Request, env: Env) {
  // 1️⃣ Worker 层：认证、路由、限流（< 5ms）
  const auth = await authenticate(request, env);
  if (!auth.valid) return unauthorized();

  // 2️⃣ Worker 层：输入验证（< 1ms）
  const input = await validateInput(request);

  // 3️⃣ 判断是否需要容器处理
  if (isLightweight(input)) {
    // 轻量任务直接在 Worker 中完成
    return processInWorker(input);
  }

  // 4️⃣ 重负载转发给容器（30-200ms）
  return env.PROCESSOR.fetch(new Request('http://container/run', {
    method: 'POST',
    body: JSON.stringify(input)
  }));
}

🔧 四、生产环境避坑指南

4.1 镜像优化：减小体积 = 加速启动

镜像大小直接影响冷启动时间。以下是一组实测数据：

# ❌ 错误写法：完整 Ubuntu + 未清理缓存（1.2GB）
FROM ubuntu:22.04
RUN apt-get update && apt-get install -y python3 python3-pip
RUN pip install pandas numpy scipy matplotlib

# ✅ 正确写法：slim 基础镜像 + 多阶段构建（180MB）
FROM python:3.12-slim AS builder
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

FROM python:3.12-slim
COPY --from=builder /install /usr/local
COPY app.py .
CMD ["python", "app.py"]

💡 提示： Cloudflare 提供基础镜像缓存，相同镜像的后续部署不会重复上传。但每次修改 Dockerfile 都会触发重新构建。

4.2 容器状态管理

容器实例可能随时被回收（默认空闲 5 分钟后缩容），不能假设状态持久：

# ❌ 错误写法：依赖容器内本地状态
session_data = {}  # 容器回收后数据丢失

# ✅ 正确写法：使用 R2/D1/KV 持久化状态
import os

async def save_state(key, value):
    """通过 Worker 代理访问 R2 存储"""
    # 容器内通过环境变量获取 Worker URL
    worker_url = os.environ.get('WORKER_URL')
    await fetch(f'{worker_url}/api/state/{key}', {
        method: 'PUT',
        body: json.dumps(value)
    })

4.3 长时间任务处理

单次请求最长超时为 60 秒（Workers 限制），更长的任务需要拆分：

// 长任务模式：分片处理 + 轮询结果
async function handleLongTask(env: Env, taskId: string, data: any) {
  // 1. 提交任务到容器
  await env.PROCESSOR.fetch('http://container/tasks', {
    method: 'POST',
    body: JSON.stringify({ taskId, data, chunked: true })
  });

  // 2. 返回任务 ID，客户端轮询结果
  return Response.json({
    taskId,
    status: 'processing',
    pollUrl: `/api/tasks/${taskId}/status`
  });
}

// 轮询端点
async function pollTaskStatus(env: Env, taskId: string) {
  const result = await env.PROCESSOR.fetch(
    `http://container/tasks/${taskId}`
  );
  const status = await result.json();

  if (status.completed) {
    // 将结果存入 R2，避免容器回收后丢失
    await env.STORAGE.put(`results/${taskId}`, JSON.stringify(status.result));
  }

  return Response.json(status);
}

4.4 网络与安全配置

# wrangler.toml — 网络安全配置
[[containers]]
name = "api-processor"
image = "./Dockerfile"
instance_type = "standard"

# 限制出站网络访问
[networking]
outbound = [
  "api.openai.com:443",     # 只允许访问 OpenAI API
  "storage.googleapis.com:443"
]
# 不配置 = 默认允许所有出站

⚠️ 警告： 容器默认可以访问公网。在生产环境中，务必通过 networking.outbound 限制出站白名单，防止数据泄露或被滥用为代理。

📊 五、实战案例：在边缘运行 FFmpeg

一个最常见的用例是在边缘进行视频/图片处理：

// worker/src/index.ts — 边缘视频处理服务
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== 'POST') {
      return Response.json({ error: 'POST only' }, { status: 405 });
    }

    const formData = await request.formData();
    const file = formData.get('video') as File;
    const format = formData.get('format') as string || 'mp4';
    const quality = formData.get('quality') as string || 'medium';

    if (!file) {
      return Response.json({ error: 'No video file' }, { status: 400 });
    }

    // 验证文件大小（Workers 层拦截，不占用容器资源）
    if (file.size > 100 * 1024 * 1024) { // 100MB
      return Response.json({ error: 'File too large, max 100MB' }, { status: 413 });
    }

    // 转发给 FFmpeg 容器处理
    const response = await env.FFMPEG.fetch('http://container/convert', {
      method: 'POST',
      headers: { 'Content-Type': 'application/octet-stream' },
      body: file.stream()
    });

    // 返回处理后的文件
    return new Response(response.body, {
      headers: {
        'Content-Type': `video/${format}`,
        'Content-Disposition': `attachment; filename="converted.${format}"`
      }
    });
  }
};

对应的 FFmpeg 容器处理逻辑：

# container/ffmpeg_handler.py
import subprocess
import tempfile
import os
from http.server import HTTPServer, BaseHTTPRequestHandler

QUALITY_PRESETS = {
    'low': ['-crf', '28', '-preset', 'ultrafast'],
    'medium': ['-crf', '23', '-preset', 'medium'],
    'high': ['-crf', '18', '-preset', 'slow']
}

class FFmpegHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        if self.path == '/convert':
            content_length = int(self.headers.get('Content-Length', 0))
            video_data = self.rfile.read(content_length)

            # 从请求头获取参数
            fmt = self.headers.get('X-Format', 'mp4')
            quality = self.headers.get('X-Quality', 'medium')

            try:
                result = self.convert(video_data, fmt, quality)
                self.send_response(200)
                self.send_header('Content-Type', f'video/{fmt}')
                self.end_headers()
                self.wfile.write(result)
            except Exception as e:
                self.send_response(500)
                self.send_header('Content-Type', 'application/json')
                self.end_headers()
                self.wfile.write(f'{{"error": "{str(e)}"}}'.encode())

    def convert(self, video_data, fmt, quality):
        with tempfile.NamedTemporaryFile(suffix='.input', delete=False) as inp:
            inp.write(video_data)
            input_path = inp.name

        output_path = input_path + f'.{fmt}'
        cmd = [
            'ffmpeg', '-y', '-i', input_path,
            *QUALITY_PRESETS.get(quality, QUALITY_PRESETS['medium']),
            '-c:a', 'aac', '-b:a', '128k',
            output_path
        ]

        subprocess.run(cmd, check=True, capture_output=True)

        with open(output_path, 'rb') as f:
            result = f.read()

        os.unlink(input_path)
        os.unlink(output_path)
        return result

💡 六、最佳实践总结

经过生产环境验证，以下是 Cloudflare Containers 的核心最佳实践：

⚡ 关键结论： Cloudflare Containers 的核心价值在于「边缘 + 完整 Linux」的组合。如果你的任务只需要 JavaScript/TypeScript，Workers 是更好的选择；如果你需要全球分布 + 完整系统依赖，Containers 是目前市场上最优雅的解决方案。

🔗 相关工具推荐

• 🔧 jsjson.com JSON 格式化工具 — 在线 JSON 处理，无需容器
• 🔧 jsjson.com Base64 编解码 — 轻量编码工具
• 📖 Docker 镜像优化实战指南 — 容器镜像瘦身技巧
• 📖 Cloudflare Workers 实战 — 轻量边缘计算入门
• 📖 Cloudflare D1 + Hono + Drizzle — 边缘全栈方案
• 📖 Cloudflare Workflows 实战 — 长任务编排方案