Der günstigste Weg, einen Content-Agenten zu betreiben

[Betreiber-Einblick] Ich betreibe genau diese Pipeline für alejandrorioja.com: Ein TypeScript Worker schreibt einen Post, fächert 12 Übersetzungsjobs auf und speichert alles in KV — alles durch einen einzigen HTTP-Aufruf ausgelöst. Hier sind die genauen Kosten und wie alles verkabelt ist.

Inhaltsverzeichnis

Warum Cloudflare statt AWS oder Vercel

AWS Lambda berechnet pro GB-Sekunde Rechenzeit. Vercel berechnet pro Ausführung und hat aggressive Ratenlimits beim Hobby-Tier. Beide fügen bei Skalierung Cold-Start-Unvorhersehbarkeit hinzu.

Cloudflare Workers läuft auf V8-Isolates, nicht auf Containern. Cold Starts sind unter einer Millisekunde. Das Free-Tier ist wirklich nützlich: 100.000 Anfragen pro Tag, 10ms CPU-Zeit pro Anfrage (Wall-Clock-Zeit ist länger). Der bezahlte Plan kostet $5/Monat für 10 Millionen Anfragen.

Für eine KI-Content-Pipeline sind die Workers-Rechenkosten fast null. Die echten Kosten sind die Claude API. Das ist die einzige Variable, die du optimieren musst.

Die Architektur (Textdiagramm)

HTTP-Auslöser (Cron oder Webhook)
        │
        ▼
  Worker: Orchestrator
        │
        ├─ Job-Metadaten schreiben → KV (Status: "pending")
        │
        └─ 1 EN-Generierungsjob einreihen
               │
               ▼
         Queue: content-jobs
               │
        ┌──────┴──────┐
        ▼             ▼
  Worker: Schreiber   Worker: Übersetzer (×12 Locales)
        │                    │
        ▼                    ▼
  Claude API             Claude API
        │                    │
        └──────┬─────────────┘
               ▼
        KV: posts/{slug}/{locale}
               │
               ▼
     Webhook → GitHub → Deploy

Der Orchestrator-Worker ist der Einstiegspunkt. Er schreibt einen initialen Statusdatensatz in KV und pusht dann einen Job in eine Cloudflare Queue. Der Queue-Fan-Out startet den Writer-Worker (EN) und, sobald der EN-Body bereit ist, 12 Translator-Worker parallel. Alles landet in KV, indexiert nach {slug}/{locale}. Ein abschließender Webhook triggert ein GitHub Actions Deploy.

Cloudflare-Kostentabelle

Für eine Website, die 10 Posts/Monat veröffentlicht, beträgt die Cloudflare-Rechnung $0 im Free-Tier. Workers sind kostenlos. KV-Lese-/Schreibvorgänge in diesem Umfang sind kostenlos. Die einzige bezahlte Funktion, die ich verwende, ist Queues — die den $5/Monat Workers Paid-Plan erfordert, der aber 1M Queue-Nachrichten enthält.

Meine Cloudflare-Rechnung: $5/Monat pauschal, unabhängig vom Post-Volumen bis zu ~3.000 Posts/Monat.

Claude-API-Kostentabelle

Hier fließt das echte Geld. Hier ist die Aufschlüsselung pro Post.

EN-Generierung (ein Post, ~1.500 Wörter):

12 Übersetzungen (je ~1.500 Wörter):

Gesamt pro Post (EN + 12 Übersetzungen):

Ich verwende Sonnet für die EN-Generierung (Qualität ist beim kanonischen Post wichtig) und Haiku für Übersetzungen (der Quelltext ist bereits geschrieben; das Modell muss ihn nur treu übersetzen). Dieser gemischte Ansatz kostet in der Praxis etwa $0,10 pro Post.

TypeScript Worker: Der Orchestrator

// src/workers/orchestrator.ts
import { Queue } from "@cloudflare/workers-types";

interface Env {
  CONTENT_QUEUE: Queue;
  POSTS_KV: KVNamespace;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const { slug, topic } = await request.json<{ slug: string; topic: string }>();

    // Initialen Status schreiben
    await env.POSTS_KV.put(
      `status:${slug}`,
      JSON.stringify({ status: "pending", createdAt: Date.now() })
    );

    // EN-Generierungsjob einreihen
    await env.CONTENT_QUEUE.send({
      type: "generate",
      slug,
      topic,
      locale: "en",
    });

    return Response.json({ queued: true, slug });
  },
};

TypeScript Worker: Schreiber + Übersetzer

// src/workers/content-processor.ts
interface Env {
  CONTENT_QUEUE: Queue;
  POSTS_KV: KVNamespace;
  ANTHROPIC_API_KEY: string;
}

const LOCALES = ["ar","de","es","fr","hi","it","ja","ko","nl","pt","ru","zh"];

export default {
  async queue(batch: MessageBatch<ContentJob>, env: Env): Promise<void> {
    for (const msg of batch.messages) {
      const job = msg.body;

      if (job.type === "generate") {
        const post = await generatePost(job.topic, env.ANTHROPIC_API_KEY);
        await env.POSTS_KV.put(`post:${job.slug}:en`, post);

        // Übersetzungen auffächern
        for (const locale of LOCALES) {
          await env.CONTENT_QUEUE.send({
            type: "translate",
            slug: job.slug,
            locale,
            sourceText: post,
          });
        }
      }

      if (job.type === "translate") {
        const translated = await translatePost(
          job.sourceText,
          job.locale,
          env.ANTHROPIC_API_KEY,
          // Haiku für Übersetzungen verwenden, um Kosten zu senken
          "claude-haiku-3-5-20241022"
        );
        await env.POSTS_KV.put(`post:${job.slug}:${job.locale}`, translated);
      }

      msg.ack();
    }
  },
};

async function generatePost(topic: string, apiKey: string): Promise<string> {
  const res = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": apiKey,
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify({
      model: "claude-sonnet-3-5-20241022",
      max_tokens: 4096,
      messages: [{ role: "user", content: `Write a detailed blog post about: ${topic}` }],
    }),
  });
  const data = await res.json<{ content: Array<{ text: string }> }>();
  return data.content[0].text;
}

async function translatePost(
  text: string,
  locale: string,
  apiKey: string,
  model: string
): Promise<string> {
  const res = await fetch("https://api.anthropic.com/v1/messages", {
    method: "POST",
    headers: {
      "x-api-key": apiKey,
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify({
      model,
      max_tokens: 4096,
      messages: [
        {
          role: "user",
          content: `Translate the following blog post to ${locale}. Preserve all markdown. Keep code blocks in English.\n\n${text}`,
        },
      ],
    }),
  });
  const data = await res.json<{ content: Array<{ text: string }> }>();
  return data.content[0].text;
}

Alternativenvergleich

Ein eigener Server ist der einzige Fall, bei dem Cloudflare verliert. Ein $6/Monat Hetzner VPS betreibt Node 24/7 ohne Cold Starts und ohne Kosten pro Anfrage. Aber du verwaltest Deployments, Uptime und Skalierung selbst. Workers übernimmt all das kostenlos bei meinem Volumen.

Der AWS Lambda-Vergleich klingt auf dem Papier wettbewerbsfähig, aber das maximale Ausführungslimit von 15 Minuten von Lambda ist eine echte Einschränkung für lange LLM-Ketten. Workers hat ein CPU-Limit von 30 Sekunden im bezahlten Plan — was schlechter klingt, aber in Ordnung ist, weil du Queues für asynchrone Arbeit verwendest, nicht eine einzelne Lambda blockierst.

KV für Zustandsverwaltung

KV ist Cloudflares global verteilter Key-Value-Speicher. Lesevorgänge sind überall schnell (Edge-gecacht). Schreibvorgänge propagieren sich in weniger als 60 Sekunden global.

Für eine Content-Pipeline verwende ich drei Schlüsselmuster:

// Job-Status
await kv.put(`status:${slug}`, JSON.stringify({ status, updatedAt: Date.now() }));

// Post-Inhalt
await kv.put(`post:${slug}:${locale}`, markdownContent);

// Index für Auflistung
const index = await kv.get<string[]>("index:posts", "json") ?? [];
await kv.put("index:posts", JSON.stringify([...index, slug]));

KV-Kosten in meinem Umfang: $0. Das Free-Tier bietet 1K Schreibvorgänge/Tag und 100K Lesevorgänge/Tag. Ich schreibe ~300 KV-Einträge pro Monat (25 Posts × 13 Locales = 325). Weit entfernt vom Limit.

Wenn du 100+ Posts/Monat in 12 Locales veröffentlichst, würdest du ~39.000 Schreibvorgänge/Monat erreichen — immer noch unter dem im $5-Paid-Plan enthaltenen 1M/Monat.

Das Fazit des Betreibers

Meine vollständige Content-Pipeline — generieren, übersetzen, speichern, deployen — kostet $5,10/Monat an Infrastruktur ($5 Cloudflare Workers Paid + $0,10 Claude API pro Post bei 10 Posts/Monat). Das war’s. Keine Server zu verwalten, keine Container-Orchestrierung, keine unerwarteten Rechnungen von Lambda Cold Starts, die eine provisionierte Concurrency-Schwelle treffen.

Die gemischte Modellstrategie (Sonnet für EN, Haiku für Übersetzungen) senkt die Claude-Kosten um 80% ohne wahrnehmbare Qualitätseinbuße bei Übersetzungen. Rechne die Zahlen für dein Volumen durch und du wirst feststellen, dass Cloudflare + Claude Haiku wirklich der günstigste Weg ist, diese Art von Pipeline auf Gründer-Skala zu betreiben.