Cloudflare Containers: Serverless Edge Docker Leitfaden

Cloudflare Workers bietet ultraniedrige Latenzzeiten durch V8-Isolates-Computing, hatte jedoch klare Einschränkungen: „128MB~3GB Speicherbegrenzung“, „Unmöglichkeit, C/C++-Binärdateien und native Python-C-Extensions auszuführen“ sowie „Unfähigkeit, schwere Aufgaben auf Basis von Puppeteer, FFmpeg oder Chromium auszuführen“. Die Technologie, die diese Grenzen von Isolates vollständig überwindet und im April 2026 als allgemein verfügbare Version (GA) veröffentlicht wurde, ist Cloudflare Containers.

Cloudflare Containers ist ein Edge-Serverless-Container-Dienst, der Docker-Standard-OCI-Images in weltweit mehr als 330 Cloudflare Edge-Rechenzentren (Region: Earth) bereitstellt, wobei Workers-Skripte als Orchestrator fungieren, um Instanzen dynamisch zu steuern. Ohne die Belastung fester Fixkosten wie bei AWS Fargate oder GCP Cloud Run besticht die Abrechnungsarchitektur dadurch, dass Instanzen nur bei eingehenden Anfragen sofort ausgeführt und bei Inaktivität (Idle) auf 0 skaliert werden (Scale-to-Zero).

Dieser Leitfaden führt Sie anhand von praxisnah orientiertem Code durch die Funktionsweise von Cloudflare Containers – von wrangler.jsonc-basierten Docker-Bindings über die SDK-Orchestrierung mit @cloudflare/containers und den Aufbau von AI-Agenten-Code-Sandboxes bis hin zum Benchmark einer 70%igen Kostenersparnis im Vergleich zu AWS ECS/Fargate.

Wichtigste Zusammenfassung

• Scale-to-Zero Serverless Docker: Wenn keine Anfragen vorliegen, wird auf 0 Instanzen skaliert, sodass keine Grundgebühren anfallen. Die Abrechnung erfolgt ausschließlich auf Basis aktiver CPU-Zeit (Active CPU Time) in 10ms-Einheiten.
• Workers-basierte Orchestrierung: Der Cloudflare Worker agiert als API-Gateway und Orchestrator, um den Container-Lebenszyklus, das Session-Routing und das Round-Robin-Load-Balancing programmatisch zu steuern.
• Automatische Platzierung am Region-Edge (Region: Earth): Container-Instanzen werden im dem Benutzer nächstgelegenen Edge-Rechenzentrum dynamisch als Sandbox bereitgestellt, um die RTT-Latenz zu minimieren.
• 70% Kostenersparnis gegenüber AWS Fargate: Durch das Eliminieren von dauerhaft laufenden Serverinstanzen und die hochpräzise Abrechnung im 10ms-Takt wird ein herausragendes Preis-Leistungs-Verhältnis für Workloads mit intermittierendem Traffic (AI-Agenten-Ausführung, Bild-/Videokonvertierung) geboten.

1. Leistungsvergleich: V8 Isolates (Workers) vs. Cloudflare Containers

Dies ist ein Vergleich der Kernarchitekturen beider Runtimes basierend auf der offiziellen Cloudflare Containers-Dokumentation und dem GA-Stand von April 2026.

[Benutzeranfrage]
      │
      ▼
[Cloudflare Worker] ──(HTTP / SDK-Routing)──► [Cloudflare Containers (Docker)]
 (Authentifizierung,                            (Python, FFmpeg, AI Code Sandbox)
  Sicherheit, Routing)

2. Erstellung von Dockerfile und Container-Anwendung (Dockerfile, app.py)

Dies ist ein Beispiel für einen Webservice zur Bildverarbeitung und Python-Datenanalyse, der in Cloudflare Containers ausgeführt wird.

Python FastAPI-basierte Anwendung (app.py)

# app.py - Edge-Sandbox-Container-API mit FFmpeg und PIL
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):
    # Direkte Ausführung der FFmpeg-Binärdatei zur Videotranskodierung (in V8-Isolates nicht möglich)
    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-Definition (Dockerfile)

# Dockerfile
FROM python:3.11-slim

# Installation von FFmpeg und nativen C-Bibliotheken
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-Orchestrator-Implementierung: wrangler.jsonc und TypeScript (src/index.ts)

Deklarieren Sie die Docker-Container-Bindings im Cloudflare Worker und steuern Sie den Container-Lebenszyklus mit dem @cloudflare/containers SDK.

wrangler.jsonc-Konfiguration

// wrangler.jsonc - Cloudflare Containers-Binding-Konfiguration
{
  "$schema": "./node_modules/wrangler/config-schema.json",
  "name": "edge-container-orchestrator",
  "main": "src/index.ts",
  "compatibility_date": "2026-08-04",
  // Deklaration der Containers-Bindings
  "containers": [
    {
      "binding": "MEDIA_CONTAINER",
      "image": "docker.io/myusername/media-processor:latest",
      "class_name": "MediaProcessorContainer",
      "instance_limit": 10
    }
  ]
}

Worker-Orchestrator-Skript (src/index.ts)

// src/index.ts - Container-Orchestrator und Request-Routing
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. Einfache statische API-Routen verarbeitet der Worker extrem schnell in 0ms
    if (url.pathname === '/api/info') {
      return Response.json({ service: 'Workers Gateway', edge: true });
    }

    // 2. Dynamische Erstellung/Aufruf von Containern bei rechenintensiven Anfragen
    if (url.pathname === '/api/convert-video' && request.method === 'POST') {
      const body = await request.json();

      try {
        // @cloudflare/containers SDK: Abrufen der Container-Instanz basierend auf der Session-ID
        // Wenn keine aktive Instanz vorhanden ist, automatische Bereitstellung per Scale-from-Zero in unter 300ms
        const container = await env.MEDIA_CONTAINER.get({
          id: `session-${crypto.randomUUID()}`,
        });

        // Weiterleitung der HTTP-Anfrage per Proxy an den internen Port 8080 des Containers
        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 });
  },
};

In Kombination mit lang laufenden Pipelines, wie sie im Cloudflare Workflows Durable Execution Leitfaden behandelt werden, übernimmt Workflows den gesamten Steuerungsfluss, während einzelne schwere Ausführungsschritte auf Cloudflare Containers verteilt werden. So entsteht eine extrem leistungsfähige, ausfallsichere Edge-Architektur.

4. Kostenersparnis und Leistungs-Benchmark

Vergleich von AWS Fargate vs. Cloudflare Containers basierend auf einem monatlichen Traffic von 1 Million Video-Transkodierungen/Code-Ausführungen.

Ähnlich wie der im AWS S3 zu Cloudflare R2 Migrationsleitfaden behandelte Effekt zur Reduzierung von Egress-Kosten bietet auch Cloudflare den großen Vorteil, dass die Kosten für den Datenverkehr innerhalb der eigenen Infrastruktur 0 Euro betragen.

5. Enterprise-Einführungs-Checkliste

Häufig gestellte Fragen (FAQ)

Was ist der Unterschied zwischen Cloudflare Containers und traditionellen Cloudflare Workers?

Workers basiert auf der V8-Engine als extrem leichtgewichtige JavaScript/Wasm-Isolate mit einem Cold Start von nahezu 0ms, kann jedoch keine nativen C/C++-Bibliotheken oder Python-Pakete ausführen. Containers ermöglicht die Ausführung vollständiger Docker-OCI-Images am Edge ohne Speicher- oder Runtime-Einschränkungen.

Wie schnell ist der Cold Start?

Die Cold-Start-Latenzzeit zur Bereitstellung des ersten Containers beim Eingang einer Anfrage im Scale-to-Zero-Zustand liegt im Durchschnitt zwischen 280ms und 450ms. Das ist etwa 50-mal schneller als bei AWS Fargate (15 bis 45 Sekunden).

Können Container direkt auf D1-Datenbanken oder R2-Storage zugreifen?

Ja. Der Cloudflare Worker-Orchestrator besitzt die D1- und R2-Bindings. Beim Weiterleiten von Anfragen an den Container können Datenbanken und Storage durch Sandboxing in Form von HTTP-Headern oder Authentifizierungstokens sicher gemeinsam genutzt werden.

Können auch Images von Docker Hub direkt bereitgestellt werden?

Ja. Wenn Sie im image-Feld der Datei wrangler.jsonc das Format docker.io/username/repository:tag angeben, werden die Images bei der Bereitstellung automatisch mit der Cloudflare Edge-Registry synchronisiert und ausgerollt.