Il Modo Più Economico per Eseguire un Agente di Contenuto su Cloudflare

Indice

Aggiornato maggio 2026.

TL;DR: Puoi eseguire una pipeline completa di generazione e traduzione di contenuto su Cloudflare Workers + Claude API per circa $0,50 per post con Sonnet 3.5, o $0,12 con Haiku. Il livello gratuito di Cloudflare gestisce 100K richieste/giorno — paghi solo quando la scala lo richiede. Il limite è la latenza di cold start per le chiamate LLM lunghe, che Queues risolve.

[Lettura dell’operatore] Eseguo esattamente questa pipeline per alejandrorioja.com: un Worker TypeScript scrive un post, distribuisce 12 job di traduzione e archivia tutto in KV — tutto attivato da una singola chiamata HTTP. Ecco esattamente quanto costa e come è configurata.

Perché Cloudflare invece di AWS o Vercel

AWS Lambda addebita per GB-secondo di calcolo. Vercel addebita per esecuzione e ha limiti di frequenza aggressivi sul livello hobby. Entrambi aggiungono imprevedibilità di cold start su larga scala.

Cloudflare Workers gira su isolate V8, non su container. I cold start sono sotto il millisecondo. Il livello gratuito è genuinamente utile: 100.000 richieste al giorno, 10ms di tempo CPU per richiesta (il tempo wall-clock è più lungo). Il piano a pagamento è $5/mese per 10 milioni di richieste.

Per una pipeline di contenuto AI, il costo di calcolo dei Workers è quasi zero. Il costo reale è la Claude API. Questa è l’unica variabile che devi ottimizzare.

L’architettura (diagramma testuale)

Trigger HTTP (cron o webhook)
        │
        ▼
  Worker: orchestratore
        │
        ├─ Scrivere metadati job → KV (stato: "pending")
        │
        └─ Accodare 1 job di generazione EN
               │
               ▼
         Coda: content-jobs
               │
        ┌──────┴──────┐
        ▼             ▼
  Worker: scrittore   Worker: traduttore (×12 locali)
        │                    │
        ▼                    ▼
  Claude API             Claude API
        │                    │
        └──────┬─────────────┘
               ▼
        KV: posts/{slug}/{locale}
               │
               ▼
     Webhook → GitHub → deploy

Il Worker orchestratore è il punto di ingresso. Scrive un record di stato iniziale in KV, poi spinge un job su una Coda Cloudflare. Il fan-out della Coda lancia il Worker scrittore (EN) e, una volta che il corpo EN è pronto, 12 Worker traduttori in parallelo. Tutto finisce in KV indicizzato per {slug}/{locale}. Un webhook finale attiva un deploy di GitHub Actions.

Tabella dei costi Cloudflare

Per un sito che pubblica 10 post/mese, la fattura Cloudflare è $0 sul livello gratuito. I Workers sono gratuiti. Le letture/scritture KV a quel volume sono gratuite. L’unica funzionalità a pagamento che uso è Queues — che richiede il piano Workers Paid da $5/mese, ma quel piano include 1M di messaggi in coda.

La mia fattura Cloudflare: $5/mese fisso, indipendentemente dal volume di post fino a ~3.000 post/mese.

Tabella dei costi della Claude API

Qui va il vero denaro. Ecco il dettaglio per post.

Generazione EN (un post, ~1.500 parole):

12 traduzioni (ciascuna ~1.500 parole):

Totale per post (EN + 12 traduzioni):

Uso Sonnet per la generazione EN (la qualità conta per il post canonico) e Haiku per le traduzioni (il testo sorgente è già scritto; il modello deve solo tradurlo fedelmente). Questo approccio misto costa circa $0,10 per post in pratica.

Worker TypeScript: l’orchestratore

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

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

    // Accodare il job di generazione EN
    await env.CONTENT_QUEUE.send({
      type: "generate",
      slug,
      topic,
      locale: "en",
    });

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

Worker TypeScript: lo scrittore + traduttore

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

        // Distribuire le traduzioni
        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,
          // Usare Haiku per le traduzioni per ridurre i costi
          "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;
}

Confronto con le alternative

Il self-hosting è l’unico caso in cui Cloudflare perde. Un VPS Hetzner da $6/mese gira Node 24/7 senza cold start e senza costo per richiesta. Ma gestisci deploy, uptime e scalabilità da solo. Workers gestisce tutto questo gratuitamente al mio volume.

Il confronto con AWS Lambda sembra competitivo sulla carta, ma il limite massimo di esecuzione di 15 minuti di Lambda è un vero limite per le catene LLM lunghe. Workers ha un limite CPU di 30 secondi sul piano a pagamento — che sembra peggio ma va bene perché usi Queues per il lavoro asincrono, non bloccando un singolo Lambda.

KV per la gestione dello stato

KV è lo store chiave-valore distribuito globalmente di Cloudflare. Le letture sono veloci ovunque (cache all’edge). Le scritture si propagano globalmente in meno di 60 secondi.

Per una pipeline di contenuto, uso tre pattern di chiavi:

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

// Contenuto del post
await kv.put(`post:${slug}:${locale}`, markdownContent);

// Indice per la lista
const index = await kv.get<string[]>("index:posts", "json") ?? [];
await kv.put("index:posts", JSON.stringify([...index, slug]));

Costi KV alla mia scala: $0. Il livello gratuito dà 1K scritture/giorno e 100K letture/giorno. Scrivo ~300 voci KV al mese (25 post × 13 locali = 325). Ben lontano dal limite.

Se pubblichi 100+ post/mese in 12 locali, raggiungeresti ~39.000 scritture/mese — ancora sotto il 1M/mese incluso nel piano a pagamento da $5.

Il verdetto finale dell’operatore

La mia pipeline di contenuto completa — generare, tradurre, archiviare, deployare — costa $5,10/mese in infrastruttura ($5 Cloudflare Workers Paid + $0,10 Claude API per post a 10 post/mese). Tutto qui. Nessun server da gestire, nessuna orchestrazione di container, nessuna bolletta a sorpresa da Lambda con cold start che raggiunge una soglia di concorrenza provisionata.

La strategia del modello misto (Sonnet per EN, Haiku per le traduzioni) riduce i costi di Claude dell’80% senza alcun calo percepibile nella qualità delle traduzioni. Fai i calcoli per il tuo volume e scoprirai che Cloudflare + Claude Haiku è genuinamente il modo più economico per eseguire questo tipo di pipeline alla scala di un founder.