Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Surveillance et journalisation

AWS CloudTrail peut capturer toutes les demandes adressées à Claude Platform sur AWS. Les opérations de l'espace de travail et du coffre-fort sont enregistrées en tant qu'événements de gestion par défaut. Toutes les autres opérations (inférence, lot, fichier, compétence, modèle, profil utilisateur et agents gérés par Claude, à l'exception des coffres-forts) sont des événements de données. Leur enregistrement nécessite une configuration explicite et entraîne des CloudTrail frais supplémentaires. Consultez les actions IAM pour la classification complète des types d'événements et la CloudTrail documentation AWS pour les détails de configuration.

Lors de la configuration CloudTrail de la journalisation des événements de données, sélectionnez le type de ressourceAWS::AWSExternalAnthropic::Workspace. Il s'agit du type de CloudTrail ressource pour Claude Platform sur les espaces de travail AWS. Il est nécessaire pour capturer les événements du plan de données (inférence, traitement par lots, fichiers et autres opérations par espace de travail). Étendez les sélecteurs d'événements de données aux ARN spécifiques de l'espace de travail si vous souhaitez enregistrer l'activité d'un sous-ensemble d'espaces de travail plutôt que de l'ensemble du compte.

Identifiants de demande

Chaque réponse inclut deux identifiants de demande dans les en-têtes de réponse :

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

Le SDK Ruby n'expose actuellement aucun accesseur à réponse brute. Les identifiants de demande ne peuvent donc pas être lus à partir des en-têtes de réponse dans Ruby. Si vous avez besoin de la journalisation des identifiants de demande, utilisez l'une des autres langues ci-dessus ou capturez les identifiants au niveau de la couche proxy HTTP.

Anthropic recommande d'enregistrer votre activité sur une base continue d'au moins 30 jours pour comprendre les habitudes d'utilisation et étudier tout problème potentiel.

Indicateurs d'utilisation et tableaux de bord

Claude Platform sur AWS ne publie pas de statistiques d'utilisation par espace de travail sur Amazon CloudWatch. Le nombre de jetons, le volume de demandes et l'utilisation par modèle sont plutôt disponibles sur les surfaces d'utilisation d'Anthropic :

Pour la surveillance opérationnelle (taux d'erreur, latence, en-têtes de limite de débit), utilisez les en-têtes de réponse renvoyés à chaque demande (voir Limites de débit et quotas) ainsi que les identifiants de demande AWS capturés dans. CloudTrail

Allocation et suivi des coûts

Les frais liés à la plateforme Claude sur AWS apparaissent sur votre facture AWS dans le cadre du service Claude Platform on AWS, avec les dimensions d'utilisation par modèle. Utilisez le rapport sur les coûts et l'utilisation (CUR) d'AWS associé aux balises d'espace de travail pour une répartition précise des coûts :

Les balises de l'espace de travail sont transmises aux éléments de ligne CUR pour toutes les utilisations de la plateforme Claude sur AWS. Les mêmes clés de balise régissent à la fois le contrôle IAM-based d'accès et la répartition des coûts. Consultez les balises de répartition des coûts dans la documentation de facturation AWS pour connaître les étapes de configuration et les délais d'activation.