Claude Code × Amazon Bedrock Guia Completo | Executando Claude em Produção com AWS

“Quero usar a API do Claude em produção, mas me preocupa o gerenciamento de chaves API” ou “Nossa política de segurança interna não permite que dados saiam da AWS” — para esses problemas, o Amazon Bedrock é a melhor resposta.

Quando eu estava integrando IA em um servidor de API no ECS para o trabalho, inicialmente usava a API da Anthropic diretamente. Porém, uma revisão de segurança apontou o “gerenciamento de chaves API para serviços externos” como um problema. Após migrar para o Bedrock, a autenticação passou a ser feita completamente via papéis IAM e me libertei do gerenciamento de chaves API. Este artigo explica tudo, desde a implementação do Bedrock com Claude Code até a operação em produção.

---

O que é Amazon Bedrock?

O Amazon Bedrock é um serviço de modelos de IA gerenciado da AWS. Você pode chamar múltiplos modelos — Claude (Anthropic), Llama (Meta), Titan (Amazon) — por meio de uma API unificada.

Por que usar o Bedrock?

Aspecto	API da Anthropic	Amazon Bedrock
Autenticação	Chave API	Papel IAM da AWS
Faturamento	Diretamente à Anthropic	Integrado à cobrança da AWS
Suporte VPC	Nenhum	Totalmente privado com PrivateLink
Retenção de dados	Política da Anthropic	Política da AWS
Conformidade	SOC2, etc.	SOC2 / ISO27001 / HIPAA, etc.

A API da Anthropic é prática para projetos pessoais, mas para casos de uso enterprise, financeiro e de saúde, o Bedrock está se tornando cada vez mais a única opção.

---

Passo 1: Configuração inicial

Solicitar acesso ao modelo

Primeiro, solicite acesso aos modelos Claude no console da AWS.

# Verificar a lista de modelos disponíveis
aws bedrock list-foundation-models \
  --by-provider anthropic \
  --region us-east-1 \
  --query 'modelSummaries[].{id:modelId, name:modelName}'

# Exemplo de saída
[
  {"id": "anthropic.claude-opus-4-5",     "name": "Claude Opus 4.5"},
  {"id": "anthropic.claude-sonnet-4-6",   "name": "Claude Sonnet 4.6"},
  {"id": "anthropic.claude-haiku-4-5-20251001", "name": "Claude Haiku 4.5"}
]

Importante: As regiões principais disponíveis são us-east-1 (Virgínia) e us-west-2 (Oregon). A região de Tóquio pode ser usada via Cross-region inference.

Instalação do SDK

npm install @anthropic-ai/sdk @aws-sdk/client-bedrock-runtime

---

Passo 2: Implementação básica

Usar o suporte Bedrock integrado do SDK da Anthropic (Recomendado)

O SDK oficial da Anthropic possui suporte Bedrock integrado. Como a sintaxe é quase idêntica à API Anthropic regular, o custo de migração a partir do código existente é mínimo.

// src/lib/bedrock-client.ts
import Anthropic from "@anthropic-ai/sdk";

// Sem necessidade de credenciais quando o papel IAM é usado (ex. Lambda/ECS)
const bedrock = new Anthropic.AnthropicBedrock({
  awsRegion: process.env.AWS_REGION ?? "us-east-1",
  // Durante o desenvolvimento local, o perfil da AWS CLI é usado automaticamente
});

export async function generateText(
  prompt: string,
  options: { model?: string; maxTokens?: number } = {}
): Promise<string> {
  const { model = "anthropic.claude-sonnet-4-6", maxTokens = 1024 } = options;

  const response = await bedrock.messages.create({
    model,
    max_tokens: maxTokens,
    messages: [{ role: "user", content: prompt }],
  });

  return response.content[0].type === "text" ? response.content[0].text : "";
}

Os IDs de modelo do Bedrock diferem da API da Anthropic:

API da Anthropic: claude-sonnet-4-6
Bedrock:          anthropic.claude-sonnet-4-6  (prefixo adicionado)

Suporte a streaming

O streaming é essencial para respostas longas.

// src/lib/bedrock-stream.ts
export async function* streamText(
  prompt: string,
  model = "anthropic.claude-sonnet-4-6"
): AsyncGenerator<string> {
  const stream = await bedrock.messages.stream({
    model,
    max_tokens: 4096,
    messages: [{ role: "user", content: prompt }],
  });

  for await (const chunk of stream) {
    if (
      chunk.type === "content_block_delta" &&
      chunk.delta.type === "text_delta"
    ) {
      yield chunk.delta.text;
    }
  }
}

// Exemplo de uso (Next.js App Router)
export async function POST(req: Request) {
  const { prompt } = await req.json();
  const encoder = new TextEncoder();

  const stream = new ReadableStream({
    async start(controller) {
      for await (const text of streamText(prompt)) {
        controller.enqueue(encoder.encode(text));
      }
      controller.close();
    },
  });

  return new Response(stream, {
    headers: { "Content-Type": "text/event-stream" },
  });
}

---

Passo 3: Padrão Lambda + Bedrock

A arquitetura mais comum para fornecer funcionalidades de IA sem servidor.

claude -p "
Implemente a seguinte função Lambda em src/lambda/ai-handler.ts:
- Receber prompt e maxTokens do evento
- Chamar o Bedrock (claude-sonnet-4-6) e retornar o resultado
- Tratar erros: ThrottlingException (retry) e ValidationException (400)
- Registrar o tempo de execução
- Inicializar o cliente fora do handler (otimização de cold start)
"

// src/lambda/ai-handler.ts
import { Handler, APIGatewayProxyEvent, APIGatewayProxyResult } from "aws-lambda";
import Anthropic from "@anthropic-ai/sdk";

// Inicialização no escopo do módulo (armazenado em cache na reutilização do container)
const bedrock = new Anthropic.AnthropicBedrock({
  awsRegion: process.env.AWS_REGION,
});

export const handler: Handler<APIGatewayProxyEvent, APIGatewayProxyResult> = async (event) => {
  const startTime = Date.now();

  try {
    const { prompt, maxTokens = 512 } = JSON.parse(event.body ?? "{}");

    if (!prompt) {
      return { statusCode: 400, body: JSON.stringify({ error: "prompt is required" }) };
    }

    const response = await bedrock.messages.create({
      model: "anthropic.claude-sonnet-4-6",
      max_tokens: maxTokens,
      messages: [{ role: "user", content: prompt }],
    });

    const duration = Date.now() - startTime;
    console.log(JSON.stringify({
      level: "INFO",
      duration_ms: duration,
      input_tokens: response.usage.input_tokens,
      output_tokens: response.usage.output_tokens,
    }));

    return {
      statusCode: 200,
      body: JSON.stringify({
        text: response.content[0].type === "text" ? response.content[0].text : "",
        usage: response.usage,
      }),
    };
  } catch (error: any) {
    if (error.name === "ThrottlingException") {
      console.warn("Rate limited by Bedrock, client should retry");
      return { statusCode: 429, body: JSON.stringify({ error: "Rate limited, please retry" }) };
    }
    console.error("Bedrock error:", error);
    return { statusCode: 500, body: JSON.stringify({ error: "AI generation failed" }) };
  }
};

Política IAM do Lambda

// Configuração IAM com CDK
import * as iam from "aws-cdk-lib/aws-iam";

lambdaFunction.addToRolePolicy(new iam.PolicyStatement({
  effect: iam.Effect.ALLOW,
  actions: [
    "bedrock:InvokeModel",
    "bedrock:InvokeModelWithResponseStream",
  ],
  resources: [
    `arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-6`,
    `arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-haiku-4-5-20251001`,
  ],
}));

---

Passo 4: Implementação de RAG (Retrieval-Augmented Generation)

Um padrão onde o Claude lê documentos internos ou informações de produtos para responder perguntas.

claude -p "
Implemente um sistema RAG usando Bedrock Knowledge Base.

Arquitetura:
- Armazenar documentos no S3
- Indexação vetorial com Bedrock Knowledge Base
- Recuperar documentos com base nas perguntas do usuário
- Gerar respostas com Claude Sonnet

Implementar com TypeScript + AWS SDK v3.
Obter o ID do Knowledge Base da variável de ambiente KNOWLEDGE_BASE_ID.
"

// src/lib/rag.ts
import {
  BedrockAgentRuntimeClient,
  RetrieveAndGenerateCommand,
} from "@aws-sdk/client-bedrock-agent-runtime";

const agentClient = new BedrockAgentRuntimeClient({ region: "us-east-1" });

export async function ragQuery(question: string): Promise<{
  answer: string;
  citations: string[];
}> {
  const response = await agentClient.send(
    new RetrieveAndGenerateCommand({
      input: { text: question },
      retrieveAndGenerateConfiguration: {
        type: "KNOWLEDGE_BASE",
        knowledgeBaseConfiguration: {
          knowledgeBaseId: process.env.KNOWLEDGE_BASE_ID!,
          modelArn: `arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-6`,
          retrievalConfiguration: {
            vectorSearchConfiguration: { numberOfResults: 5 },
          },
        },
      },
    })
  );

  const answer = response.output?.text ?? "";
  const citations = (response.citations ?? [])
    .flatMap((c) => c.retrievedReferences ?? [])
    .map((r) => r.location?.s3Location?.uri ?? "")
    .filter(Boolean);

  return { answer, citations };
}

---

Passo 5: Otimização de custos

// Utilitário de seleção de modelo
type TaskType = "classify" | "extract" | "summarize" | "generate" | "complex";

const MODEL_MAP: Record<TaskType, string> = {
  classify: "anthropic.claude-haiku-4-5-20251001",  // $0,80/1M tokens de entrada
  extract:  "anthropic.claude-haiku-4-5-20251001",
  summarize: "anthropic.claude-sonnet-4-6",          // $3,00/1M tokens de entrada
  generate: "anthropic.claude-sonnet-4-6",
  complex:  "anthropic.claude-opus-4-5",             // $15,00/1M tokens de entrada
};

export function selectModel(task: TaskType): string {
  return MODEL_MAP[task];
}

Reduzir custos de entrada com cache de prompts

// O cache de prompts também está disponível no Bedrock
const response = await bedrock.messages.create({
  model: "anthropic.claude-sonnet-4-6",
  max_tokens: 1024,
  system: [
    {
      type: "text",
      text: longSystemPrompt,
      cache_control: { type: "ephemeral" },  // Cache por 5 minutos
    },
  ],
  messages: [{ role: "user", content: userQuery }],
});

---

5 armadilhas comuns

1. Região não suportada

O Claude no Bedrock não está disponível em todas as regiões. Em 2026, us-east-1 e us-west-2 são as regiões principais. Para usá-lo a partir de Tóquio, ative o Cross-region inference.

// Usar o ARN de modelo para Cross-region inference
const crossRegionModelArn = 
  "arn:aws:bedrock:us-east-1::foundation-model/anthropic.claude-sonnet-4-6";

2. Esquecer de solicitar acesso ao modelo

No Bedrock, você deve solicitar “Model access” para cada modelo que deseja usar. Chamar um modelo sem solicitação de acesso resulta em AccessDeniedException. Sempre solicite o acesso antes de começar a codificar com Claude Code.

3. Timeout do Lambda muito curto

As respostas do Claude podem levar de 10 a 30 segundos. O padrão de 3 segundos do Lambda definitivamente causará timeout. Configure para pelo menos 30 segundos, e de 60 a 300 segundos para gerações mais longas.

4. Confundir IDs de modelo do Bedrock com IDs da API da Anthropic

❌ Usar o ID da API da Anthropic diretamente: "claude-sonnet-4-6"
✅ ID do Bedrock: "anthropic.claude-sonnet-4-6"

5. Não levar em conta a latência do Cross-region inference

Chamar modelos em us-east-1 a partir de Tóquio adiciona latência de rede de ida e volta de aproximadamente 100–200 ms. Para aplicações sensíveis à latência, use streaming para reduzir o atraso percebido.

---

Resumo

Tarefa	Contribuição do Claude Code
Implementação básica	Gera cliente AnthropicBedrock e funções
Integração com Lambda	Gera handler e política IAM juntos
Implementação RAG	Gera automaticamente código de integração com Knowledge Base
Otimização de custos	Projeta lógica de seleção de modelo por tipo de tarefa
Solução de problemas	Identifica causa e sugere correção a partir de logs de erro

Desenvolva com Claude Code, opere em produção com Bedrock — essa combinação atende a todos os requisitos de segurança, custo e escalabilidade. Comece com o período de teste gratuito do Bedrock e, quando estiver pronto para produção, basta configurar o papel IAM.

Artigos relacionados

• Guia Completo Claude Code × AWS Lambda
• Guia Completo Claude Code × AWS IAM
• Guia Completo para Reduzir os Custos da API do Claude Code em 90%

Referências

• Documentação Oficial do Amazon Bedrock
• Suporte Bedrock do SDK da Anthropic
• Lista de IDs de modelo do Bedrock