Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Supervisión y registro

AWS CloudTrail puede capturar todas las solicitudes a la plataforma Claude en AWS. De forma predeterminada, las operaciones del espacio de trabajo y el almacén se registran como eventos de administración. Todas las demás operaciones (inferencia, lote, archivo, habilidad, modelo, perfil de usuario y Claude Managed Agents, excepto los almacenes) son eventos de datos. Registrarlos requiere una configuración explícita y conlleva cargos adicionales. CloudTrail Consulte las acciones de IAM para ver la clasificación completa de los tipos de eventos y la CloudTrail documentación de AWS para obtener detalles de configuración.

Al configurar el registro CloudTrail de eventos de datos, seleccione el tipo AWS::AWSExternalAnthropic::Workspace de recurso. Este es el tipo de CloudTrail recurso para la plataforma Claude en los espacios de trabajo de AWS y es necesario para capturar eventos del plano de datos (operaciones de inferencia, por lotes, de archivos y otras operaciones por espacio de trabajo). Limite los selectores de eventos de datos a los ARN específicos del espacio de trabajo si desea registrar la actividad de un subconjunto de espacios de trabajo y no de toda la cuenta.

ID de solicitud

Cada respuesta incluye dos ID de solicitud en los encabezados de respuesta:

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

Actualmente, el SDK de Ruby no muestra un descriptor de acceso de respuesta sin procesar, por lo que los ID de las solicitudes no se pueden leer en los encabezados de respuesta de Ruby. Si necesitas registrar los ID de solicitud, usa cualquiera de los lenguajes anteriores o captura los ID en la capa de proxy HTTP.

Anthropic recomienda registrar tu actividad al menos 30 días seguidos para comprender los patrones de uso e investigar cualquier posible problema.

Métricas de uso y paneles de control

La plataforma Claude en AWS no publica métricas de uso por espacio de trabajo en Amazon CloudWatch. En cambio, los recuentos de fichas, el volumen de solicitudes y el uso por modelo están disponibles en las secciones de uso de Anthropic:

Para la supervisión operativa (tasas de error, latencia, encabezados de límite de velocidad), utilice los encabezados de respuesta que se muestran en cada solicitud (consulte Límites y cuotas de velocidad) junto con los ID de solicitud de AWS capturados en ellos. CloudTrail

Asignación y monitoreo de costos

Los cargos de Claude Platform on AWS aparecen en su factura de AWS en el servicio Claude Platform on AWS, con las dimensiones de uso por modelo. Use el informe de costo y uso (CUR) de AWS combinado con etiquetas de espacio de trabajo para una asignación de costos detallada:

Las etiquetas del espacio de trabajo fluyen hasta las líneas de CUR para todo el uso de Claude Platform en AWS. Las mismas claves de etiquetas impulsan tanto el control de IAM-based acceso como la asignación de costos. Consulte las etiquetas de asignación de costes en la documentación de facturación de AWS para conocer los pasos de configuración y los retrasos en la activación.