As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Monitorar e registrar

A AWS CloudTrail pode capturar todas as solicitações para a plataforma Claude na AWS. As operações do espaço de trabalho e do cofre são registradas como eventos de gerenciamento por padrão. Todas as outras operações (inferência, lote, arquivo, habilidade, modelo, perfil de usuário e agentes gerenciados por Claude, exceto cofres) são eventos de dados. Registrá-los requer configuração explícita e acarreta custos adicionais CloudTrail . Consulte as ações do IAM para obter a classificação completa do tipo de evento e a CloudTrail documentação da AWS para obter detalhes de configuração.

Ao configurar o registro de eventos de CloudTrail dados, selecione o tipo AWS::AWSExternalAnthropic::Workspace de recurso. Esse é o tipo de CloudTrail recurso da plataforma Claude nos espaços de trabalho da AWS e é necessário para capturar eventos do plano de dados (inferência, lote, arquivo e outras operações por espaço de trabalho). Defina o escopo dos seletores de eventos de dados para ARNs de espaços de trabalho específicos se você quiser registrar atividades em um subconjunto de espaços de trabalho em vez de em toda a conta.

Solicitar IDs

Cada resposta inclui duas IDs de solicitação nos cabeçalhos de resposta:

Python

from anthropic import AnthropicAWS

client = AnthropicAWS(aws_region="us-west-2")

response = client.messages.with_raw_response.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello!"}],
)

print(response.headers.get("x-amzn-requestid"))  # AWS request ID
print(response.headers.get("request-id"))  # Anthropic request ID

message = response.parse()
print(message.content)

TypeScript

import AnthropicAws from "@anthropic-ai/aws-sdk";

const client = new AnthropicAws({ awsRegion: "us-west-2" });

const { data: message, response } = await client.messages
  .create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello!" }]
  })
  .withResponse();

console.log(response.headers.get("x-amzn-requestid")); // AWS request ID
console.log(response.headers.get("request-id")); // Anthropic request ID
console.log(message.content);

C#

using Anthropic;
using Anthropic.Aws;

var client = new AnthropicAwsClient(new() { AwsRegion = "us-west-2" });

var response = await client.WithRawResponse.Messages.Create(new()
{
    Model = "claude-sonnet-4-6",
    MaxTokens = 1024,
    Messages = [new() { Role = "user", Content = "Hello!" }]
});

Console.WriteLine(response.Headers.GetValues("x-amzn-requestid").First()); // AWS request ID
Console.WriteLine(response.Headers.GetValues("request-id").First()); // Anthropic request ID
Console.WriteLine(response.Value.Content);

Go

client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
    panic(err)
}

var response *http.Response
message, err := client.Messages.New(
    context.Background(),
    anthropic.MessageNewParams{
        Model:     anthropic.ModelClaudeSonnet4_6,
        MaxTokens: 1024,
        Messages: []anthropic.MessageParam{
            anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
        },
    },
    option.WithResponseInto(&response),
)
if err != nil {
    panic(err)
}

fmt.Println(response.Header.Get("x-amzn-requestid")) // AWS request ID
fmt.Println(response.Header.Get("request-id"))       // Anthropic request ID
fmt.Println(message.Content[0].Text)

Java

import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.http.HttpResponseFor;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;

AnthropicClient client = AnthropicOkHttpClient.builder()
    .backend(AwsBackend.fromEnv())
    .build();

HttpResponseFor<Message> response = client.messages().withRawResponse().create(
    MessageCreateParams.builder()
        .model(Model.CLAUDE_SONNET_4_6)
        .maxTokens(1024)
        .addUserMessage("Hello!")
        .build()
);

IO.println(response.headers().values("x-amzn-requestid")); // AWS request ID
IO.println(response.requestId()); // Anthropic request ID
IO.println(response.parse().content());

PHP

use Anthropic\Aws\Client;

$client = new Client();

$response = $client->messages->raw->create(
    model: 'claude-sonnet-4-6',
    maxTokens: 1024,
    messages: [['role' => 'user', 'content' => 'Hello!']],
);

echo $response->getHeaderLine('x-amzn-requestid') . "\n"; // AWS request ID
echo $response->getHeaderLine('request-id') . "\n"; // Anthropic request ID
echo $response->parse();

Ruby

Atualmente, o SDK do Ruby não expõe um acessador de resposta bruta, portanto, os IDs de solicitação não podem ser lidos nos cabeçalhos de resposta em Ruby. Se você precisar de registro de ID de solicitação, use qualquer uma das outras linguagens acima ou capture as IDs na camada de proxy HTTP.

A Anthropic recomenda registrar sua atividade em pelo menos 30 dias contínuos para entender os padrões de uso e investigar possíveis problemas.

Métricas e painéis de uso

A Claude Platform na AWS não publica métricas de uso por espaço de trabalho na Amazon. CloudWatch Em vez disso, a contagem de tokens, o volume de solicitações e o uso por modelo estão disponíveis nas superfícies de uso da Anthropic:

Para monitoramento operacional (taxas de erro, latência, cabeçalhos de limite de taxa), use os cabeçalhos de resposta retornados em cada solicitação (consulte Limites de taxa e cotas) junto com os IDs de solicitação da AWS capturados. CloudTrail

Alocação e monitoramento de custos

As cobranças da Plataforma Claude na AWS aparecem em sua fatura da AWS no serviço Claude Platform na AWS, com dimensões de uso por modelo. Use o Relatório de Custos e Uso da AWS (CUR) combinado com tags de espaço de trabalho para alocação de custos refinada:

As tags do espaço de trabalho fluem para os itens da linha CUR para todo o uso da plataforma Claude na AWS. As mesmas chaves de tag orientam tanto o controle de IAM-based acesso quanto a alocação de custos. Consulte as tags de alocação de custos na documentação do AWS Billing para ver as etapas de configuração e os atrasos na ativação.