De goedkoopste manier om een content-agent te draaien

[Operatorperspectief] Ik draai precies deze pipeline voor alejandrorioja.com: een TypeScript Worker schrijft een post, verspreidt 12 vertaaltaken en slaat alles op in KV — alles geactiveerd door één HTTP-aanroep. Hier is precies wat het kost en hoe het is geconfigureerd.

Inhoudsopgave

Waarom Cloudflare in plaats van AWS of Vercel

AWS Lambda rekent per GB-seconde rekentijd. Vercel rekent per uitvoering en heeft agressieve tarieflimieten op het hobby-niveau. Beide voegen cold-start-onvoorspelbaarheid toe op schaal.

Cloudflare Workers draait op V8-isolates, niet op containers. Cold starts zijn onder een milliseconde. De gratis laag is echt nuttig: 100.000 verzoeken per dag, 10ms CPU-tijd per verzoek (de wandkloktijd is langer). Het betaalde plan is $5/maand voor 10 miljoen verzoeken.

Voor een AI-content-pipeline zijn de Workers-rekenkosten bijna nul. De echte kosten zijn de Claude API. Dat is de enige variabele die je moet optimaliseren.

De architectuur (tekstdiagram)

HTTP-trigger (cron of webhook)
        │
        ▼
  Worker: orchestrator
        │
        ├─ Taakmetadata schrijven → KV (status: "pending")
        │
        └─ 1 EN-generatietaak in wachtrij plaatsen
               │
               ▼
         Wachtrij: content-jobs
               │
        ┌──────┴──────┐
        ▼             ▼
  Worker: schrijver   Worker: vertaler (×12 locales)
        │                    │
        ▼                    ▼
  Claude API             Claude API
        │                    │
        └──────┬─────────────┘
               ▼
        KV: posts/{slug}/{locale}
               │
               ▼
     Webhook → GitHub → deploy

De orchestrator Worker is het toegangspunt. Hij schrijft een initieel statusrecord naar KV en pusht vervolgens een taak naar een Cloudflare Queue. De Queue fan-out start de schrijver Worker (EN) en, zodra de EN-body klaar is, 12 vertaler Workers parallel. Alles belandt in KV gekoppeld aan {slug}/{locale}. Een laatste webhook activeert een GitHub Actions-deploy.

Kostentabel Cloudflare

Voor een site die 10 posts/maand publiceert, is de Cloudflare-rekening $0 op de gratis laag. Workers zijn gratis. KV-lees-/schrijfbewerkingen op dat volume zijn gratis. De enige betaalde functie die ik gebruik is Queues — wat het Workers Paid-plan van $5/maand vereist, maar dat plan bevat 1M wachtrij-berichten.

Mijn Cloudflare-rekening: $5/maand vast, ongeacht het postvolume tot ~3.000 posts/maand.

Kostentabel Claude API

Hier gaat het echte geld naartoe. Hier is de uitsplitsing per post.

EN-generatie (één post, ~1.500 woorden):

12 vertalingen (elk ~1.500 woorden):

Totaal per post (EN + 12 vertalingen):

Ik gebruik Sonnet voor EN-generatie (kwaliteit telt voor de canonieke post) en Haiku voor vertalingen (de brontekst is al geschreven; het model hoeft hem alleen maar getrouw te vertalen). Die gemengde aanpak kost in de praktijk ongeveer $0,10 per post.

TypeScript Worker: de 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 }>();

    // Initiële status schrijven
    await env.POSTS_KV.put(
      `status:${slug}`,
      JSON.stringify({ status: "pending", createdAt: Date.now() })
    );

    // EN-generatietaak in wachtrij plaatsen
    await env.CONTENT_QUEUE.send({
      type: "generate",
      slug,
      topic,
      locale: "en",
    });

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

TypeScript Worker: de schrijver + vertaler

// 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);

        // Vertalingen verspreiden
        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 gebruiken voor vertalingen om kosten te verlagen
          "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;
}

Vergelijking met alternatieven

Eigen hosting is het enige geval waarbij Cloudflare verliest. Een Hetzner VPS van $6/maand draait Node 24/7 zonder cold starts en zonder kosten per verzoek. Maar je beheert deploys, uptime en schaalbaarheid zelf. Workers regelt dat allemaal gratis bij mijn volume.

De AWS Lambda-vergelijking klinkt competitief op papier, maar de maximale uitvoeringstijd van 15 minuten van Lambda is een echte beperking voor lange LLM-ketens. Workers heeft een CPU-limiet van 30 seconden op het betaalde plan — wat slechter klinkt, maar prima is omdat je Queues gebruikt voor asynchroon werk, niet door één Lambda te blokkeren.

KV voor statusbeheer

KV is de wereldwijd gedistribueerde sleutel-waardeopslag van Cloudflare. Leesbewerkingen zijn overal snel (gecached aan de edge). Schrijfbewerkingen verspreiden zich wereldwijd in minder dan 60 seconden.

Voor een content-pipeline gebruik ik drie sleutelpatronen:

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

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

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

KV-kosten op mijn schaal: $0. De gratis laag geeft 1K schrijfbewerkingen/dag en 100K leesbewerkingen/dag. Ik schrijf ~300 KV-vermeldingen per maand (25 posts × 13 locales = 325). Ver van de limiet.

Als je 100+ posts/maand publiceert in 12 locales, zou je ~39.000 schrijfbewerkingen/maand bereiken — nog steeds onder de 1M/maand inbegrepen in het betaalde plan van $5.

De conclusie van de operator

Mijn volledige content-pipeline — genereren, vertalen, opslaan, deployen — kost $5,10/maand aan infrastructuur ($5 Cloudflare Workers Paid + $0,10 Claude API per post bij 10 posts/maand). Dat is alles. Geen servers te beheren, geen containerorkestratie, geen onverwachte rekeningen van Lambda-cold-starts die een drempel van voorziene gelijktijdigheid raken.

De gemengde modelstrategie (Sonnet voor EN, Haiku voor vertalingen) verlaagt de Claude-kosten met 80% zonder merkbare kwaliteitsdaling bij vertalingen. Doe de berekening voor jouw volume en je zult zien dat Cloudflare + Claude Haiku echt de goedkoopste manier is om dit soort pipeline op founder-schaal te draaien.