A Forma Mais Barata de Executar um Agente de Conteúdo no Cloudflare

Índice

Atualizado maio de 2026.

TL;DR: Você pode executar um pipeline completo de geração e tradução de conteúdo no Cloudflare Workers + Claude API por aproximadamente $0,50 por post com Sonnet 3.5, ou $0,12 com Haiku. O nível gratuito do Cloudflare gerencia 100K requisições/dia — você só paga quando a escala exige. A limitação é a latência de cold start para chamadas LLM longas, que Queues resolve.

[Visão do operador] Eu executo exatamente esse pipeline para alejandrorioja.com: um Worker TypeScript escreve um post, distribui 12 jobs de tradução e armazena tudo no KV — tudo acionado por uma única chamada HTTP. Aqui está exatamente o que custa e como está estruturado.

Por que Cloudflare em vez de AWS ou Vercel

AWS Lambda cobra por GB-segundo de computação. Vercel cobra por execução e tem limites de taxa agressivos no nível gratuito. Ambos adicionam imprevisibilidade de cold start em escala.

Cloudflare Workers roda em isolates V8, não em containers. Cold starts ficam abaixo de um milissegundo. O nível gratuito é genuinamente útil: 100.000 requisições por dia, 10ms de tempo de CPU por requisição (o tempo de relógio de parede é maior). O plano pago é $5/mês para 10 milhões de requisições.

Para um pipeline de conteúdo IA, o custo de computação dos Workers é quase zero. O custo real é a API Claude. Essa é a única variável que você precisa otimizar.

A arquitetura (diagrama textual)

Acionador HTTP (cron ou webhook)
        │
        ▼
  Worker: orquestrador
        │
        ├─ Gravar metadados do job → KV (status: "pending")
        │
        └─ Enfileirar 1 job de geração EN
               │
               ▼
         Fila: content-jobs
               │
        ┌──────┴──────┐
        ▼             ▼
  Worker: escritor   Worker: tradutor (×12 locales)
        │                    │
        ▼                    ▼
  Claude API             Claude API
        │                    │
        └──────┬─────────────┘
               ▼
        KV: posts/{slug}/{locale}
               │
               ▼
     Webhook → GitHub → deploy

O Worker orquestrador é o ponto de entrada. Ele grava um registro de status inicial no KV, depois empurra um job para uma Fila Cloudflare. O fan-out da Fila gera o Worker escritor (EN) e, assim que o corpo EN estiver pronto, 12 Workers tradutores em paralelo. Tudo vai parar no KV com chave {slug}/{locale}. Um webhook final aciona um deploy do GitHub Actions.

Tabela de custos do Cloudflare

Para um site publicando 10 posts/mês, a conta do Cloudflare é $0 no nível gratuito. Workers são gratuitos. Leituras/escritas KV nesse volume são gratuitas. A única funcionalidade paga que uso é Queues — que exige o plano Workers Paid de $5/mês, mas esse plano inclui 1M de mensagens em fila.

Minha conta Cloudflare: $5/mês fixo, independente do volume de posts até ~3.000 posts/mês.

Tabela de custos da API Claude

É aqui que vai o dinheiro real. Aqui está a decomposição por post.

Geração EN (um post, ~1.500 palavras):

12 traduções (cada uma ~1.500 palavras):

Total por post (EN + 12 traduções):

Uso Sonnet para geração EN (qualidade importa para o post canônico) e Haiku para traduções (o texto fonte já está escrito; o modelo só precisa traduzir fielmente). Essa abordagem mista custa aproximadamente $0,10 por post na prática.

Worker TypeScript: o orquestrador

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

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

    // Enfileirar o job de geração EN
    await env.CONTENT_QUEUE.send({
      type: "generate",
      slug,
      topic,
      locale: "en",
    });

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

Worker TypeScript: o escritor + tradutor

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

        // Distribuir traduções
        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,
          // Usar Haiku para traduções para reduzir custo
          "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;
}

Comparação de alternativas

Servidor próprio é o único caso em que o Cloudflare perde. Um VPS Hetzner de $6/mês roda Node 24/7 sem cold starts e sem custo por requisição. Mas você gerencia deploys, uptime e escalabilidade sozinho. Workers cuida de tudo isso de graça no meu volume.

A comparação com AWS Lambda parece competitiva no papel, mas o limite máximo de execução de 15 minutos do Lambda é uma limitação real para cadeias LLM longas. Workers tem um limite de CPU de 30 segundos no plano pago — o que parece pior, mas está bem porque você usa Queues para trabalho assíncrono, não bloqueando uma única Lambda.

KV para gerenciamento de estado

KV é o armazenamento chave-valor distribuído globalmente do Cloudflare. Leituras são rápidas em qualquer lugar (cache na borda). Escritas se propagam globalmente em menos de 60 segundos.

Para um pipeline de conteúdo, uso três padrões de chave:

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

// Conteúdo do post
await kv.put(`post:${slug}:${locale}`, markdownContent);

// Índice para listagem
const index = await kv.get<string[]>("index:posts", "json") ?? [];
await kv.put("index:posts", JSON.stringify([...index, slug]));

Custos do KV na minha escala: $0. O nível gratuito dá 1K escritas/dia e 100K leituras/dia. Escrevo ~300 entradas KV por mês (25 posts × 13 locales = 325). Muito longe do limite.

Se você publica 100+ posts/mês em 12 locales, atingiria ~39.000 escritas/mês — ainda abaixo do 1M/mês incluído no plano pago de $5.

O resultado final do operador

Meu pipeline completo de conteúdo — gerar, traduzir, armazenar, fazer deploy — custa $5,10/mês em infraestrutura ($5 Cloudflare Workers Paid + $0,10 API Claude por post a 10 posts/mês). É isso. Sem servidores para gerenciar, sem orquestração de containers, sem contas surpresa de Lambda com cold starts atingindo um limite de concorrência provisionada.

A estratégia de modelo misto (Sonnet para EN, Haiku para traduções) reduz os custos do Claude em 80% sem queda perceptível na qualidade das traduções. Faça as contas para o seu volume e você descobrirá que Cloudflare + Claude Haiku é genuinamente a forma mais barata de executar esse tipo de pipeline na escala de um fundador.