La façon la moins chère de faire tourner un agent de contenu sur Cloudflare

Table des matières

Mis à jour mai 2026.

TL;DR: Vous pouvez faire tourner un pipeline complet de génération et traduction de contenu sur Cloudflare Workers + Claude API pour environ $0,50 par article avec Sonnet 3.5, ou $0,12 avec Haiku. Le niveau gratuit de Cloudflare gère 100K requêtes/jour — vous ne payez que quand l’échelle le demande. La contrainte est la latence de démarrage à froid pour les appels LLM longs, que Queues résout.

[Lecture de l’opérateur] Je fais tourner exactement ce pipeline pour alejandrorioja.com : un Worker TypeScript rédige un article, distribue 12 jobs de traduction et stocke tout dans KV — le tout déclenché par un seul appel HTTP. Voici exactement ce que ça coûte et comment c’est câblé.

Pourquoi Cloudflare plutôt qu’AWS ou Vercel

AWS Lambda facture par GB-seconde de calcul. Vercel facture par exécution et impose des limites de débit agressives sur le niveau hobby. Les deux ajoutent une imprévisibilité des démarrages à froid à grande échelle.

Cloudflare Workers tourne sur des isolates V8, pas des conteneurs. Les démarrages à froid sont inférieurs à la milliseconde. Le niveau gratuit est vraiment utile : 100 000 requêtes par jour, 10ms de temps CPU par requête (le temps réel est plus long). Le plan payant est à $5/mois pour 10 millions de requêtes.

Pour un pipeline de contenu IA, le coût de calcul des Workers est quasi nul. Le vrai coût, c’est l’API Claude. C’est la seule variable à optimiser.

L’architecture (diagramme textuel)

Déclencheur HTTP (cron ou webhook)
        │
        ▼
  Worker : orchestrateur
        │
        ├─ Écrire les métadonnées du job → KV (statut : "pending")
        │
        └─ Mettre en file 1 job de génération EN
               │
               ▼
         Queue : content-jobs
               │
        ┌──────┴──────┐
        ▼             ▼
  Worker : rédacteur   Worker : traducteur (×12 locales)
        │                    │
        ▼                    ▼
  Claude API             Claude API
        │                    │
        └──────┬─────────────┘
               ▼
        KV : posts/{slug}/{locale}
               │
               ▼
     Webhook → GitHub → déploiement

Le Worker orchestrateur est le point d’entrée. Il écrit un enregistrement de statut initial dans KV, puis pousse un job dans une Queue Cloudflare. Le fan-out de la Queue lance le Worker rédacteur (EN) et, une fois le corps EN prêt, 12 Workers traducteurs en parallèle. Tout atterrit dans KV indexé par {slug}/{locale}. Un webhook final déclenche un déploiement GitHub Actions.

Tableau des coûts Cloudflare

Pour un site publiant 10 articles/mois, la facture Cloudflare est de $0 sur le niveau gratuit. Les Workers sont gratuits. Les lectures/écritures KV à ce volume sont gratuites. La seule fonctionnalité payante que j’utilise est Queues — qui exige le plan Workers Paid à $5/mois, mais ce plan inclut 1M de messages en file.

Ma facture Cloudflare : $5/mois fixe, quel que soit le volume d’articles jusqu’à ~3 000 articles/mois.

Tableau des coûts de l’API Claude

C’est là que va le vrai argent. Voici la décomposition par article.

Génération EN (un article, ~1 500 mots) :

12 traductions (chacune ~1 500 mots) :

Total par article (EN + 12 traductions) :

J’utilise Sonnet pour la génération EN (la qualité compte pour l’article canonique) et Haiku pour les traductions (le texte source est déjà rédigé ; le modèle n’a qu’à le traduire fidèlement). Cette approche mixte coûte environ $0,10 par article en pratique.

Worker TypeScript : l’orchestrateur

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

    // Écrire le statut initial
    await env.POSTS_KV.put(
      `status:${slug}`,
      JSON.stringify({ status: "pending", createdAt: Date.now() })
    );

    // Mettre en file le job de génération EN
    await env.CONTENT_QUEUE.send({
      type: "generate",
      slug,
      topic,
      locale: "en",
    });

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

Worker TypeScript : le rédacteur + traducteur

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

        // Distribuer les traductions
        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,
          // Utiliser Haiku pour les traductions pour réduire les coûts
          "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;
}

Comparaison des alternatives

L’hébergement propre est le seul cas où Cloudflare perd. Un VPS Hetzner à $6/mois fait tourner Node 24/7 sans démarrages à froid et sans coût par requête. Mais vous gérez les déploiements, la disponibilité et la mise à l’échelle vous-même. Workers gère tout ça gratuitement à mon volume.

La comparaison AWS Lambda semble compétitive sur le papier, mais la limite d’exécution maximale de 15 minutes de Lambda est une vraie contrainte pour les longues chaînes LLM. Workers a une limite CPU de 30 secondes sur le plan payant — ce qui semble pire mais convient car vous utilisez Queues pour le travail asynchrone, pas en bloquant un seul Lambda.

KV pour la gestion d’état

KV est le store clé-valeur distribué mondialement de Cloudflare. Les lectures sont rapides partout (mis en cache à la périphérie). Les écritures se propagent mondialement en moins de 60 secondes.

Pour un pipeline de contenu, j’utilise trois patterns de clés :

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

// Contenu de l'article
await kv.put(`post:${slug}:${locale}`, markdownContent);

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

Coûts KV à mon échelle : $0. Le niveau gratuit donne 1K écritures/jour et 100K lectures/jour. J’écris ~300 entrées KV par mois (25 articles × 13 locales = 325). Loin du plafond.

Si vous publiez 100+ articles/mois dans 12 locales, vous atteindriez ~39 000 écritures/mois — toujours sous le 1M/mois inclus dans le plan payant à $5.

Le bilan de l’opérateur

Mon pipeline de contenu complet — générer, traduire, stocker, déployer — coûte $5,10/mois en infrastructure ($5 Cloudflare Workers Paid + $0,10 API Claude par article à 10 articles/mois). C’est tout. Pas de serveurs à gérer, pas d’orchestration de conteneurs, pas de factures surprises de Lambda avec des démarrages à froid atteignant un seuil de concurrence provisionnée.

La stratégie de modèle mixte (Sonnet pour EN, Haiku pour les traductions) réduit les coûts Claude de 80% sans baisse de qualité perceptible sur les traductions. Faites les calculs pour votre volume et vous trouverez que Cloudflare + Claude Haiku est vraiment la façon la moins chère de faire tourner ce type de pipeline à l’échelle d’un fondateur.