Como usar o Claude Code com Amazon Bedrock

Por Guilherme Ricci, Arquiteto de Soluções Sênior para startups na Amazon Web Services e Phelipe Fabres, Arquiteto de Soluções da AWS.

Ferramentas de assistentes de código com IA se tornaram parte essencial do dia a dia de equipes de desenvolvimento. Soluções como o Kiro, Claude Code e Amazon Q Developer estão transformando a forma como se escreve, revisa e depura código. Entre essas ferramentas, o Claude Code tem ganhado destaque pela sua capacidade de operar diretamente no terminal, entender contexto de projetos inteiros e executar tarefas complexas de forma autônoma, desde refatorações até criação de features completas.

O desafio: licenciamento nem sempre se encaixa

A maioria dessas ferramentas opera em um modelo de assinatura mensal por desenvolvedor. Para equipes grandes com uso constante, isso pode fazer sentido. Mas e quando:

• O time usa a ferramenta de forma esporádica?
• É necessário testar com um grupo piloto sem comprometer orçamento fixo?
• Há necessidade de controle granular de custos por time, projeto ou ambiente?
• Se deseja utilizar modelos de ponta como o Claude Opus 4.6 sem restrições de plano?

Nesses cenários, um modelo de cobrança por demanda, onde você paga apenas pelas chamadas que faz, pode ser significativamente mais vantajoso.

A solução: Claude Code + Amazon Bedrock

O Claude Code suporta nativamente o Amazon Bedrock como backend. Isso significa que, em vez de utilizar a API direta da Anthropic com uma assinatura separada, é possível rotear todas as chamadas pelo Amazon Bedrock, e isso traz vantagens significativas:

• Dados dentro da AWS: Todo o fluxo de dados (prompts, respostas, contexto de código) permanece dentro da infraestrutura AWS, sem sair para endpoints externos. Isso simplifica requisitos de compliance e residência de dados.
• Controle de acesso via AWS IAM: É possível definir com granularidade quais usuários ou roles podem acessar quais modelos, usando policies IAM padrão. Por exemplo, permitir que o time de backend use apenas Claude Opus, enquanto o time de QA acessa apenas Sonnet.
• Pagamento sob demanda: Cobrança por tokens de input e output consumidos, sem licenciamento, contratos mínimos ou compromissos antecipados. Basta habilitar o modelo e começar a usar.

Com essa configuração, é possível acessar modelos de ponta como o Claude Opus 4.6, Claude Sonnet 4.6 e Claude Haiku 4.5.

Como configurar

Pré-requisitos

• Uma conta AWS com acesso ao Amazon Bedrock
• Acesso habilitado ao modelo Claude desejado na região escolhida
• AWS CLI instalado e configurado (veja opções a seguir)
• Claude Code instalado (veja instruções de instalação):

  curl -fsSL https://claude.ai/install.sh | bash
  

• Permissões IAM adequadas (veja abaixo)

Permissões IAM necessárias

O IAM principal utilizado para rodar o Claude Code precisa de permissões para invocar modelos e listar inference profiles. A documentação da Anthropic recomenda a seguinte policy:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowModelAndInferenceProfileAccess",
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream",
        "bedrock:ListInferenceProfiles"
      ],
      "Resource": [
        "arn:aws:bedrock:*:*:inference-profile/*",
        "arn:aws:bedrock:*:*:application-inference-profile/*",
        "arn:aws:bedrock:*:*:foundation-model/*"
      ]
    },
    {
      "Sid": "AllowMarketplaceSubscription",
      "Effect": "Allow",
      "Action": [
        "aws-marketplace:ViewSubscriptions",
        "aws-marketplace:Subscribe"
      ],
      "Resource": "*",
      "Condition": {
        "StringEquals": {
          "aws:CalledViaLast": "bedrock.amazonaws.com"
        }
      }
    }
  ]
}

Para permissões mais restritivas, é possível limitar o campo Resource a ARNs específicos de inference profiles. Mais detalhes na documentação de IAM do Bedrock.

Passo 1: Configure suas credenciais AWS

Antes de começar, é necessário configurar a autenticação. Existem duas opções:

Opção A — aws configure com chaves de acesso

Opção mais simples, indicada para testes rápidos ou contas pessoais, utiliza chaves de acesso de um IAM user.

aws configure

Informe:

• AWS Access Key ID: a access key
• AWS Secret Access Key: a secret key
• Default region name: us-east-1
• Default output format: json

Para boas práticas de segurança de conta AWS, consulte: AWS Security Best Practices.

Opção B — AWS IAM Identity Center (Recomendado para organizações)

Opção mais segura, indicada para ambientes corporativos. Utiliza credenciais temporárias via SSO, sem chaves de acesso permanentes.

aws configure sso

O assistente solicitará:

• SSO session name: um nome para a sessão (ex: minha-org)
• SSO start URL: a URL do portal da organização (ex: https://minha-org.awsapps.com/start)
• SSO Region: a região do Identity Center (ex: us-east-1)
• SSO registration scopes: pressionar Enter para aceitar o padrão

O navegador abrirá para autenticação. Em seguida, basta selecionar a conta e a role desejada. O CLI salvará o profile automaticamente.

Para fazer login (e renovar credenciais quando expirarem):

aws sso login --profile <NOME_DO_PROFILE>

Para utilizar esse profile no Claude Code:

export AWS_PROFILE=<NOME_DO_PROFILE>

Passo 2: Crie um Application Inference Profile

Antes de configurar o Claude Code, é recomendável criar um application inference profile com tags. Isso permite identificar os custos por time, projeto ou ambiente no Cost Explorer e criar alertas de orçamento, essencial para governança em organizações com múltiplos desenvolvedores.

Primeiro, identificar o ARN do system-defined inference profile desejado:

aws bedrock get-inference-profile \
  --inference-profile-identifier "us.anthropic.claude-opus-4-6-v1" \
  --region us-east-1 \
  --query "inferenceProfileArn"

E o comando retorna algo como:

arn:aws:bedrock:<SUA_REGIÃO>:<SUA_CONTA>:inference-profile/<MODEL_ID>

Com o ARN obtido, criar o application inference profile com tags:

aws bedrock create-inference-profile \
  --inference-profile-name "backend-dev-opus" \
  --model-source '{"copyFrom":"<ARN_DO_INFERENCE_PROFILE>"}' \
  --tags '[{"key":"Environment","value":"dev"},{"key":"Team","value":"backend"},{"key":"Model","value":"claude-opus-4-6"}]' \
  --region us-east-1

E o comando retorna algo como:

{
  "inferenceProfileArn": "arn:aws:bedrock:<SUA_REGIÃO>:<SUA_CONTA>:application-inference-profile/<PROFILE_ID>",
  "status": "ACTIVE"
}

O valor de copyFrom deve ser o ARN completo do system-defined inference profile (ex: arn:aws:bedrock:<SUA_REGIÃO>:<SUA_CONTA>:inference-profile/us.anthropic.claude-opus-4-6-v1), não o ARN de um foundation model.

O comando retorna o ARN do novo profile no campo inferenceProfileArn. Copie esse valor, que será usado no próximo passo.

Nota: Caso prefira começar sem criar um inference profile, é possível usar diretamente o system-defined profile ID (ex: us.anthropic.claude-opus-4-6-v1) no passo 3. A diferença é que sem o application inference profile não será possível segmentar custos por tags.

Passo 3: Configure as variáveis de ambiente

O Claude Code precisa de três variáveis de ambiente para funcionar com o Amazon Bedrock: uma flag que ativa o modo Amazon Bedrock (CLAUDE_CODE_USE_BEDROCK), a região AWS onde o modelo será invocado (AWS_REGION) e o identificador do modelo desejado (ANTHROPIC_MODEL). Sem essas variáveis, o Claude Code tentará se conectar à API direta da Anthropic.

export CLAUDE_CODE_USE_BEDROCK=true
export AWS_REGION=us-east-1
export ANTHROPIC_MODEL="arn:aws:bedrock:<SUA_REGIÃO>:<SUA_CONTA>:application-inference-profile/<PROFILE_ID>"

Para que essas variáveis estejam disponíveis nas sessões de terminal, é possível adicioná-las ao arquivo de configuração do shell. No macOS, o shell exemplo é o zsh:

# Para zsh (padrão no macOS)
echo 'export CLAUDE_CODE_USE_BEDROCK=true' >> ~/.zshrc
echo 'export AWS_REGION=us-east-1' >> ~/.zshrc
echo 'export ANTHROPIC_MODEL="arn:aws:bedrock:<SUA_REGIÃO>:<SUA_CONTA>:application-inference-profile/<PROFILE_ID>"' >> ~/.zshrc
source ~/.zshrc

Em ambientes Linux com bash:

echo 'export CLAUDE_CODE_USE_BEDROCK=true' >> ~/.bashrc
echo 'export AWS_REGION=us-east-1' >> ~/.bashrc
echo 'export ANTHROPIC_MODEL="arn:aws:bedrock:<SUA_REGIÃO>:<SUA_CONTA>:application-inference-profile/<PROFILE_ID>"' >> ~/.bashrc
source ~/.bashrc

Dica: Caso prefira não persistir as variáveis, basta executar os export diretamente no terminal antes de iniciar o Claude Code. Eles valem apenas para a sessão atual.

Se foi utilizado aws configure (opção A), as credenciais são carregadas automaticamente do ~/.aws/credentials.

Se foi configurado o Identity Center (opção B), adicionar também o profile ao shell:

export AWS_PROFILE=<NOME_DO_PROFILE>

Passo 4: Inicie o Claude Code

claude

O Claude Code utilizará automaticamente o Amazon Bedrock como backend e roteará as chamadas pelo inference profile configurado.

Passo 5: Valide a configuração

Dentro do Claude Code, o comando /model permite confirmar que o modelo correto está sendo utilizado.

Você poderá verificar o ARN do application inference profile.

A partir deste momento, o Claude Code está pronto para uso. É possível fazer qualquer teste, desde perguntas simples até tarefas complexas de geração de código. O importante é que as chamadas passam pelo Amazon Bedrock, com a observabilidade e governança da AWS.

Exemplo prático: validador de chave PIX

Para ilustrar o potencial da ferramenta, considere o seguinte cenário: um desenvolvedor do setor financeiro precisa implementar a validação de chaves PIX na API de pagamentos da sua instituição. O PIX, sistema de pagamentos instantâneos do Banco Central do Brasil, aceita quatro tipos de chave (CPF, CNPJ, email, telefone, EVP), cada um com regras de formato e validação diferentes. Implementar essas regras corretamente, incluindo validação de dígito verificador para CPF/CNPJ e regex para os demais tipos, é uma tarefa repetitiva, mas que exige atenção aos detalhes.

Com o Claude Code rodando via Bedrock, basta descrever o problema em linguagem natural:

Crie um módulo Python com uma função que receba uma chave PIX como string, 
identifique automaticamente o tipo (CPF, CNPJ, email, telefone ou EVP) 
e valide o formato conforme as regras do Banco Central. Inclua validação 
de dígito verificador para CPF e CNPJ. Retorne um dict com o tipo 
identificado e se a chave é válida.

Em poucos segundos, o Claude Code gera um módulo completo com as validações, pronto para ser integrado à API. Todo o processamento permanece dentro da infraestrutura AWS, sem que dados sensíveis do setor financeiro trafeguem para APIs externas.

Entendendo cross-region inference

Os inference profiles com prefixo us. ou global. habilitam o cross-region inference: o Amazon Bedrock roteia automaticamente as chamadas para diferentes regiões AWS. Isso traz dois benefícios principais:

• Maior throughput: As chamadas são distribuídas entre regiões, reduzindo a chance de throttling em momentos de alta demanda.
• Resiliência: Se uma região estiver sobrecarregada, o Amazon Bedrock redireciona automaticamente para outra.

É possível observar a região efetiva de cada chamada no campo inferenceRegion do AWS CloudTrail (detalhado na seção de monitoramento). Para cenários onde a latência é crítica, também podemos utilizar inference profiles de região única (sem o prefixo global. ou us.).

A governança de custos usando as tags do inference profile é detalhada na seção Governança de custos com tags mais adiante.

Monitorando o uso

Monitorar o uso do Claude Code via Amazon Bedrock é essencial por três razões: custo, segurança e performance. Sem observabilidade, não há como saber quanto cada desenvolvedor ou time está consumindo, se as chamadas estão sendo roteadas corretamente, ou se a latência está dentro do esperado. Em ambientes regulados como o setor financeiro, a auditoria de cada invocação pode ser um requisito de compliance.

O Amazon Bedrock oferece múltiplas opções de observabilidade, cada uma com um propósito diferente.

GenAI Observability — Logs em tempo real (recomendado)

A forma mais rápida e completa de monitorar as chamadas do Claude Code é pelo Amazon Bedrock GenAI Observability, disponível no console do Amazon Bedrock em Observability > Model invocation logging.

Os logs aparecem em tempo real, assim que o Claude Code faz uma chamada, já é possível ver os detalhes da invocação, incluindo:

• Modelo utilizado e inference profile
• Tokens de input e output
• Latência da chamada
• Requisições e respostas completas (se habilitado)

Para habilitar, basta acessar o console do Amazon Bedrock em Settings > Model invocation logging e configurar o destino dos logs (Amazon CloudWatch Logs ou Amazon Simple Storage Service (Amazon S3)).

Depois de habilitado, os logs podem ser consultados em Observability > Model invocation logging:

É possível ver detalhes de dashboards prontos com dados de invocações e contagem de tokens.

Além de uma listagem de invocações.

É possível clicar no request ID para ver os detalhes do que foi trafegado.

Dica: Este é o método mais confiável para validar que o Claude Code está usando o Amazon Bedrock corretamente. Os logs aparecem instantaneamente, diferente de outros serviços que têm delay de propagação.

AWS CloudTrail — Auditoria de chamadas de API

O AWS CloudTrail complementa o monitoramento com uma trilha de auditoria completa. Um detalhe importante: o Claude Code usa streaming, então o evento registrado é InvokeModelWithResponseStream (não InvokeModel). Os eventos aparecem tipicamente em 5 a 15 minutos após a chamada.

aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=InvokeModelWithResponseStream \
  --max-results 5 \
  --region us-east-1

Você também pode consultar pelo console do AWS CloudTrail em Event history, filtrando por Event name = InvokeModelWithResponseStream:

Cada evento mostra detalhes como o modelo invocado, o inference profile utilizado, o IAM principal que fez a chamada e, no caso de inference profiles globais, a região onde o inference foi efetivamente processado (campo inferenceRegion em additionalEventData), conforme explicado na seção sobre cross-region inference.

Atenção: Ao buscar por InvokeModel, não serão encontrados eventos do Claude Code. O evento correto é InvokeModelWithResponseStream.

AWS CloudWatch — métricas agregadas de uso

O Amazon Bedrock publica métricas automaticamente no CloudWatch sob o namespace AWS/Bedrock. Essas métricas permitem acompanhar invocações, latência e consumo de tokens de forma agregada.

Para consultar o número de invocações:

aws cloudwatch get-metric-statistics \
  --namespace AWS/Bedrock \
  --metric-name Invocations \
  --start-time $(date -u -v-7d +%Y-%m-%dT%H:%M:%SZ) \
  --end-time $(date -u +%Y-%m-%dT%H:%M:%SZ) \
  --period 86400 \
  --statistics Sum \
  --region us-east-1

As principais métricas disponíveis são:

Governança de custos com tags

Como o inference profile foi criado com tags no Passo 2 (Environment=dev, Team=backend), é possível segmentar os custos no AWS Cost Explorer e criar alertas de orçamento por time ou projeto.

Acompanhando custos por tag

Os custos aparecem no Cost Explorer segmentados pelas tags do inference profile. Os dados levam aproximadamente 24 horas para aparecer.

No console do Cost Explorer, filtrar por:

• Service: Amazon Bedrock
• Tag: Team = backend

Para que as tags apareçam no Cost Explorer, elas precisam estar ativadas como cost allocation tags em Billing > Cost allocation tags.

Criando um alerta de custo

Com as tags do inference profile, é possível criar um AWS Budgets que alerta quando os custos do time atingirem um limite:

aws budgets create-budget \
  --account-id <ACCOUNT_ID> \
  --budget '{
    "BudgetName": "backend-dev-bedrock-budget",
    "BudgetLimit": {"Amount": "<LIMITE_USD>", "Unit": "USD"},
    "BudgetType": "COST",
    "TimeUnit": "MONTHLY",
    "CostFilters": {
      "TagKeyValue": ["user:Team$backend"],
      "Service": ["Amazon Bedrock"]
    }
  }' \
  --notifications-with-subscribers '[{
    "Notification": {
      "NotificationType": "ACTUAL",
      "ComparisonOperator": "GREATER_THAN",
      "Threshold": 80,
      "ThresholdType": "PERCENTAGE"
    },
    "Subscribers": [{
      "SubscriptionType": "EMAIL",
      "Address": "<SEU_EMAIL>"
    }]
  }]' \
  --region us-east-1

Substitua:

• <ACCOUNT_ID> pelo ID da conta AWS
• <LIMITE_USD> pelo valor máximo mensal desejado (ex: 50)
• <SEU_EMAIL> pelo email que receberá os alertas

Pré-requisito: A tag Team precisa estar ativada como cost allocation tag em Billing > Cost allocation tags para que o filtro funcione.

É possível confirmar as tags do inference profile a qualquer momento:

aws bedrock list-tags-for-resource \
  --resource-arn "arn:aws:bedrock:us-east-1:<ACCOUNT_ID>:application-inference-profile/<PROFILE_ID>" \
  --region us-east-1

Benefícios dessa abordagem

Conclusão

Para equipes que já utilizam ou estão avaliando o Claude Code, o Amazon Bedrock pode ser utilizado como backend para rotear as requisições de LLM, o que oferece segurança corporativa, conformidade de dados e integração com os serviços da AWS, em vez de depender diretamente da API da Anthropic. A combinação oferece a experiência de desenvolvimento do Claude Code com a flexibilidade, governança e modelo de custos da AWS.

O processo começa com a criação de um inference profile com tags para o time, passando pela definições de variáveis de ambiente locais, resultando no controle de do que está sendo utilizado pelos serviços de inteligência artificial. Em poucos minutos, é possível ter um assistente de codificação de ponta rodando no terminal, com controle total de custos e segurança.

Para detalhes de custo por modelo, consultar a página de preços: Amazon Bedrock Pricing

Autores

	Guilherme Ricci é Arquiteto de Soluções Sênior, para startups na Amazon Web Services, especializado no Setor Financeiro, ajudando startups a modernizar e criar arquiteturas escaláveis resilientes e de baixo custo, além de modernizar suas aplicações. Com mais de 15 anos de experiência em empresas do setor financeiro, atualmente trabalha com a equipe de especialistas em AI.
	Phelipe Fabres é Arquiteto de Soluções da AWS especializado em arquiteturas modernas Serverless e generative AI com Ph.D em Teoria dos Grafos.