Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Überwachung und Protokollierung

AWS CloudTrail kann alle Anfragen an Claude Platform auf AWS erfassen. Workspace- und Tresorvorgänge werden standardmäßig als Management-Ereignisse protokolliert. Alle anderen Operationen (Inferenz, Batch, Datei, Fähigkeit, Modell, Benutzerprofil und Claude Managed Agents außer Tresoren) sind Datenereignisse. Ihre Protokollierung erfordert eine ausdrückliche Konfiguration und verursacht zusätzliche Gebühren. CloudTrail Die vollständige Klassifizierung der Ereignistypen finden Sie in den IAM-Aktionen und in der CloudTrail AWS-Dokumentation finden Sie weitere Informationen zur Konfiguration.

Wählen Sie bei der Konfiguration der CloudTrail Datenereignisprotokollierung den Ressourcentyp AWS::AWSExternalAnthropic::Workspace aus. Dies ist der CloudTrail Ressourcentyp für Claude Platform auf AWS-Workspaces und ist erforderlich, um Ereignisse auf Datenebene (Inferenz-, Batch-, Datei- und andere Workspace-Operationen) zu erfassen. Richten Sie die Auswahl von Datenereignissen auf bestimmte Workspace-ARNs ein, wenn Sie Aktivitäten für eine Teilmenge von Workspaces und nicht für das gesamte Konto protokollieren möchten.

IDs anfordern

Jede Antwort enthält zwei Anfrage-IDs in den Antwort-Headern:

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

Das Ruby-SDK stellt derzeit keinen Raw-Response-Accessor zur Verfügung, sodass Anfrage-IDs nicht aus den Antwort-Headern in Ruby gelesen werden können. Wenn Sie eine Anforderungs-ID-Protokollierung benötigen, verwenden Sie eine der anderen oben genannten Sprachen oder erfassen Sie die IDs auf der HTTP-Proxyebene.

Anthropic empfiehlt, Ihre Aktivitäten mindestens 30 Tage fortlaufend zu protokollieren, um die Nutzungsmuster zu verstehen und mögliche Probleme zu untersuchen.

Nutzungsmetriken und Dashboards

Claude Platform on AWS veröffentlicht keine Nutzungsmetriken pro Workspace auf Amazon CloudWatch. Die Token-Anzahl, das Anforderungsvolumen und die Nutzung pro Modell sind stattdessen über die Nutzungsoberflächen von Anthropic verfügbar:

Verwenden Sie für die Betriebsüberwachung (Fehlerraten, Latenz, Ratenlimit-Header) die bei jeder Anfrage zurückgegebenen Antwort-Header (siehe Ratenlimits und Kontingente) zusammen mit den erfassten AWS-Anforderungs-IDs. CloudTrail

Kostenzuweisung und Überwachung

Die Gebühren für die Claude-Plattform auf AWS werden auf Ihrer AWS-Rechnung unter dem Service Claude Platform on AWS aufgeführt, mit Nutzungsdimensionen pro Modell. Verwenden Sie den AWS-Kosten- und Nutzungsbericht (CUR) in Kombination mit Workspace-Tags für eine detaillierte Kostenzuweisung:

Workspace-Tags fließen in CUR-Einzelposten für die gesamte Nutzung der Claude-Plattform auf AWS ein. Dieselben Tag-Schlüssel steuern sowohl die IAM-based Zugriffskontrolle als auch die Kostenzuweisung. Informationen zu Einrichtungsschritten und Verzögerungen bei der Aktivierung finden Sie in den Tags zur Kostenzuweisung in der AWS-Rechnungsdokumentation.