Contexto: o que foi coberto na Parte 1
A Parte 1 desta série apresentou a atribuição granular de custos do Amazon Bedrock — um recurso que rastreia automaticamente cada requisição de inferência até o principal do Serviço de Gerenciamento de Identidade e Acesso (IAM) que realizou a chamada. A coluna line_item_iam_principal no Relatório de Custo e Uso (CUR) passa a oferecer visibilidade por usuário e por aplicação, e com tags de alocação de custos opcionais, é possível agregar gastos por equipe, projeto ou tenant.
Nesta segunda parte, a AWS mostra como colocar esses dados em prática: como configurar o CUR 2.0 com dados de principal IAM, como consultar padrões de custo no Amazon Athena e como comparar gastos entre projetos e identidades. A publicação também apresenta os novos recursos do painel CUDOS com suporte completo à atribuição de custos do Bedrock.
Configurando o Relatório de Custo e Uso (CUR 2.0)
Antes de analisar os custos do Amazon Bedrock, é necessário configurar uma exportação de dados CUR 2.0 e conectá-la ao Amazon Athena. Os pré-requisitos são:
- Uma conta AWS com acesso ao console de faturamento
- Permissões IAM para Relatórios de Custo e Uso, S3 e Athena
- Um bucket do Amazon S3 para armazenar os dados do CUR
- Familiaridade básica com SQL e o Console de Gerenciamento da AWS
- (Opcional) Claude Code ou Kiro-CLI para configuração automatizada
Verifique se você possui as permissões IAM necessárias antes de começar. Para a atribuição de custos do Bedrock, é preciso habilitar os dados de principal IAM na exportação CUR 2.0, de forma que a coluna line_item_iam_principal e as tags associadas sejam populadas.
Criando a exportação CUR 2.0 com dados de principal IAM
Siga as instruções de criação de uma exportação de dados padrão para configurar a exportação CUR 2.0. Durante a configuração, certifique-se de que as seguintes opções estejam presentes:
- Em Conteúdo adicional da exportação, marque a opção Include caller identity (IAM principal) allocation data — essa é a configuração essencial que popula a coluna
line_item_iam_principale expõe as tags do principal IAM (prefixadas comiamPrincipal/) nos dados de custo. - Em Configurações da tabela de dados, defina a granularidade de tempo como Hourly para o máximo de detalhes.
- Em Opções de entrega, selecione Overwrite existing report para evitar dados duplicados.
Atenção: habilitar os dados de principal IAM aumenta o tamanho dos arquivos CUR, pois o que antes era uma única linha de uso agora se expande em múltiplas linhas — uma para cada principal IAM que contribuiu para aquele uso. Para workloads de alto volume com muitos principals distintos, planeje o armazenamento no Amazon S3 adequadamente e considere o uso de políticas de ciclo de vida do Amazon S3 para arquivos CUR mais antigos. Pode levar até 24 horas para que a AWS entregue o primeiro relatório CUR 2.0 no bucket S3.
Conectando o CUR 2.0 ao Amazon Athena
Com o Amazon Athena, é possível consultar os dados do CUR usando SQL padrão sem nenhuma infraestrutura para gerenciar. Para simplificar essa configuração, há um repositório agent.md opcional que pode ser usado com assistentes de IA como Claude Code, Kiro-CLI ou Codex. Ele automatiza o processo completo de conexão do ambiente Athena aos dados do CUR:
- Clone o repositório:
git clone https://github.com/aws-samples/sample-cur-iam-principal-bedrock-tracking - Inicie o Claude Code (
claude) ou o Kiro CLI (kiro) nesse diretório - Use o prompt: “Read agent.md and follow its workflow to set up Cost and Usage Report tracking and run the Amazon Bedrock-by-principal query for the current month.”
Também é possível seguir os passos de configuração manual. Se você planeja implantar o painel CUDOS, pode implantá-lo pelo AWS CloudFormation, que também cria o banco de dados do Athena como parte do processo.
Após a implantação, uma query de teste no Editor de Queries do Athena pode validar a configuração:
SELECT line_item_iam_principal,
line_item_usage_type,
line_item_unblended_cost --# Note: replace your_cur_table_name, like `cid_data_export.cur2`
FROM your_cur_table_name
WHERE line_item_product_code in ('AmazonBedrock', 'AmazonBedrockService')
AND line_item_iam_principal IS NOT NULL
LIMIT 10;Se essa query retornar linhas com ARNs de principal IAM e tipos de uso do Bedrock, a configuração está completa e pronta para análises mais aprofundadas.
Padrões de queries no Athena para rastreamento de custos do Bedrock
Com os dados do CUR 2.0 disponíveis no Athena, é possível responder perguntas granulares de atribuição de custos usando SQL. A seguir, três padrões de queries progressivamente mais sofisticados que cobrem os cenários de análise mais comuns.
Nota: nas queries abaixo, substitua your_cur_table_name pelo nome real da sua tabela CUR no Athena (por exemplo, cid_data_export.cur2).
Query 1: Custos do Bedrock por principal IAM e tipo de uso
Esta query oferece um detalhamento completo dos gastos com o Amazon Bedrock por identidade do chamador e uso de modelo. Ela responde à pergunta: “Quem está chamando quais modelos e quanto está gastando?”
SELECT line_item_iam_principal,
line_item_usage_type,
SUM(line_item_usage_amount) AS total_tokens,
SUM(line_item_unblended_cost) AS total_cost
FROM your_cur_table_name
WHERE line_item_product_code in ('AmazonBedrock', 'AmazonBedrockService')
AND billing_period = DATE_FORMAT(CURRENT_DATE, '%Y-%m')
AND line_item_iam_principal IS NOT NULL
-- AND line_item_usage_type LIKE '%Sonnet%input%'
GROUP BY line_item_iam_principal, line_item_usage_type
ORDER BY total_cost DESC;Dica de análise: use padrões LIKE como line_item_usage_type LIKE '%Sonnet%output%' ou %nova% para filtrar modelos específicos. A coluna line_item_iam_principal contém o ARN completo. Para roles assumidas, o nome de sessão após o último / identifica o usuário ou sessão específica.
Query 2: Custos agrupados por tags de principal IAM conhecidas
Quando os principais IAM estão marcados com dimensões como team, project ou costcenter — e essas tags foram ativadas como tags de alocação de custos —, elas aparecem nos dados do CUR 2.0 com o prefixo iamPrincipal/. Esta query agrupa os custos por essas tags para responder perguntas como: “Quanto a equipe de engenharia gastou com o Bedrock neste mês?” ou “Qual é o custo total do Bedrock para o projeto chatbot?”
SELECT tags['iamPrincipal/project'] AS project,
line_item_usage_type,
SUM(line_item_usage_amount) AS total_tokens,
SUM(line_item_unblended_cost) AS total_cost
FROM your_cur_table_name
WHERE line_item_product_code in ('AmazonBedrock', 'AmazonBedrockService')
AND billing_period = DATE_FORMAT(CURRENT_DATE, '%Y-%m')
AND line_item_iam_principal IS NOT NULL
GROUP BY tags['iamPrincipal/project'], line_item_usage_type
ORDER BY total_cost DESC;Nota: esta query retorna resultados apenas se os principais IAM tiverem sido marcados com as chaves relevantes e essas tags tiverem sido ativadas como tags de alocação de custos.
Query 3: Descoberta dinâmica de tags com UNNEST para schemas desconhecidos
Em organizações maiores, pode não ser possível saber antecipadamente quais tags foram aplicadas em todos os principais IAM. Diferentes equipes podem usar chaves de tags distintas, ou novas tags podem ser introduzidas ao longo do tempo. A função UNNEST do Athena permite explorar isso dinamicamente, descobrindo todas as tags de principal IAM usadas nas workloads do Bedrock e mostrando a alocação de custo para cada par chave-valor de tag:
WITH iam_principal_costs AS (
SELECT t.key AS tag_name,
t.value AS tag_value,
line_item_usage_type,
line_item_unblended_cost
FROM your_cur_table_name
CROSS JOIN UNNEST(tags) AS t(key, value)
WHERE line_item_product_code IN ('AmazonBedrock', 'AmazonBedrockService')
AND line_item_iam_principal IS NOT NULL
AND line_item_iam_principal != ''
AND t.key LIKE 'iamPrincipal/%'
)
SELECT tag_name || ': ' || tag_value AS tags,
line_item_usage_type,
SUM(line_item_unblended_cost) AS total_cost
FROM iam_principal_costs
GROUP BY tag_name, tag_value, line_item_usage_type
ORDER BY total_cost DESC;Caso de uso real: comparação de custos entre múltiplos serviços
Considere uma equipe de plataforma que executa múltiplos serviços com IA. Por exemplo, um pipeline de sumarização de documentos (DocProcessor) e um chatbot voltado ao cliente (ChatApp). Cada serviço é atribuído a sua própria role IAM. Com os padrões de query apresentados, é possível isolar como o gasto de cada serviço evolui:
SELECT line_item_iam_principal,
line_item_usage_type,
SUM(line_item_usage_amount) AS total_usage,
SUM(line_item_unblended_cost) AS total_cost
FROM your_cur_table_name
WHERE line_item_product_code IN ('AmazonBedrock', 'AmazonBedrockService')
AND billing_period = DATE_FORMAT(CURRENT_DATE, '%Y-%m')
AND line_item_iam_principal IS NOT NULL
AND (
line_item_iam_principal LIKE '%DocProcessor%'
OR line_item_iam_principal LIKE '%ChatApp%'
)
GROUP BY line_item_iam_principal, line_item_usage_type
ORDER BY total_cost DESC;Com os resultados, a equipe consegue responder perguntas como: qual aplicação é a maior responsável pelo gasto com Bedrock neste mês? No exemplo do artigo original, o ChatApp acumula mais de US$ 80 usando o Claude 4.6 Sonnet, enquanto o DocProcessor custa menos de US$ 5 usando o Nova Lite. Isso abre a discussão sobre se seria possível reduzir custos usando modelos diferentes para cada workload.
Custo das queries no Athena
No Athena, você paga apenas pelas queries executadas, com base na quantidade de dados varridos por cada consulta. As queries são cobradas a US$ 5 por TB varrido, com um mínimo de 10 MB por query. Como a tabela usa automaticamente projeção de partição Hive sobre o campo billing_period, queries limitadas a um único mês varrem apenas os arquivos Parquet daquele período — geralmente bem abaixo de 10 MB, o que representa cerca de US$ 0,00005 por query. Para manter os custos baixos, sempre inclua um filtro WHERE billing_period = ... e selecione apenas as colunas necessárias, evitando o SELECT *.
O painel CUDOS e os novos recursos para o Bedrock
O painel CUDOS faz parte do framework open source Cloud Intelligence Dashboards (CID), que pode ser implantado na sua conta AWS usando templates de infraestrutura como código (IaC). O framework ajuda a promover accountability financeiro e aumentar a eficiência operacional em organizações AWS.
A versão 5.8 do CUDOS introduz uma seção abrangente do Amazon Bedrock na aba AI/ML, com suporte completo à atribuição de custos por principal IAM. Os principais recursos são:
- Dimensões de agrupamento flexíveis: agrupe os gastos com o Bedrock por Principal IAM, Tags de Principal IAM (como Projeto ou Equipe), Modelo/Grupo de Recursos, Região ou qualquer outro campo de taxonomia de custos configurado durante a implantação.
- Rastreamento de custo por milhão de tokens: uma linha de tendência sobreposta ao gráfico de gastos mostra como o custo por milhão de tokens evolui ao longo do tempo, ajudando a medir o impacto de mudanças na seleção de modelos ou de esforços de otimização de prompts, como o uso de cache.
- Filtragem interativa com drill-down: ao selecionar qualquer valor no gráfico de gastos de alto nível (como um projeto, principal ou conta específicos), todos os outros visuais se filtram automaticamente para aquela seleção, permitindo navegar de uma visão geral até o detalhe por modelo e tipo de uso sem sair do painel.
- Detalhamento granular por modelo e tipo de uso: visuais adicionais mostram gastos por modelo, por tipo de uso e custo por milhão de tokens por modelo, para identificar quais modelos e tipos de token estão gerando custos para uma determinada equipe ou projeto.
Com esses visuais, é possível responder rapidamente a perguntas como “Qual projeto está gerando mais custos de tokens de saída?”, “Nossa equipe de chatbot está usando modelos eficientes em custo?” ou “Como o nosso custo por milhão de tokens mudou desde que migramos do Opus para o Sonnet?” — sem escrever nenhum SQL.
Como começar com o CUDOS
Para explorar os novos recursos, a AWS disponibiliza um demo interativo do painel. Para implantar em sua organização, siga o guia de implantação. Quem já usa o CUDOS pode seguir as instruções de atualização para a versão 5.8. Também é possível usar a funcionalidade de adicionar taxonomia organizacional para incluir dados de Principal IAM em um painel CUDOS já existente.
Limpeza dos recursos
Para remover os recursos criados, siga esta sequência:
1. Remova a tabela do Athena e o banco de dados do AWS Glue (são apenas metadados, sem compute em execução):
aws glue delete-table --region us-east-1 --database-name your_cur_table_name --name curexport
aws glue delete-database --region us-east-1 --name your_cur_table_nameAtenção: remover a tabela do Athena e o banco de dados do Glue eliminará a capacidade de consultar os dados do CUR. Será necessário recriar esses recursos caso queira analisar dados de faturamento no futuro.
2. Se os dados de custo não forem mais necessários, desative a exportação no console de Gerenciamento de Faturamento e Custos da AWS, em Data Exports, e esvazie o prefixo S3 correspondente. Atenção: isso representa o histórico bruto de faturamento — delete apenas se tiver certeza.
3. Limpe os resultados de queries do Athena acumulados:
aws s3 rm s3://<your-cur-bucket>/athena-results/ --recursiveNão há crawlers, funções AWS Lambda ou agendamentos para excluir. A projeção de partição significa que o único custo contínuo é o armazenamento S3 dos próprios arquivos CUR, que tipicamente representa centavos por mês. Para a limpeza do CUDOS, consulte as instruções de teardown do painel CUDOS.
Conclusão
Esta série de dois artigos apresenta um conjunto completo de ferramentas para entender e gerenciar os custos de inferência do Amazon Bedrock. A Parte 1 introduziu a atribuição granular de custos — como o Bedrock captura automaticamente o principal IAM por trás de cada chamada de inferência e como as tags de alocação de custos permitem agregar gastos por equipe, projeto ou tenant. Esta segunda parte mostrou como colocar esses dados em uso: configurando o CUR 2.0 com dados de principal IAM, consultando padrões de custo no Amazon Athena e comparando gastos entre projetos e principals para embasar decisões de alocação de custos. O painel CUDOS complementa essa visão com uma aba de AI/ML abrangente para o Bedrock.
O caminho prático sugerido pela AWS é: habilite o CUR 2.0 com dados de identidade do chamador no console de faturamento, conecte-o ao Athena usando o arquivo agent.md do repositório disponibilizado e execute sua primeira query de custo por principal. Em seguida, acompanhe a adoção do Bedrock na sua organização com o painel CUDOS.
Fonte
Part 2: Amazon Bedrock cost attribution with Amazon Athena and CUDOS (https://aws.amazon.com/blogs/machine-learning/part-2-amazon-bedrock-cost-attribution-with-amazon-athena-and-cudos/)
Leave a Reply