# Claude on Amazon Bedrock（旧版）

Claude 模型的旧版 Amazon Bedrock 集成，使用 InvokeModel 和 Converse API 以及 ARN 版本化模型标识符。

---

<Note>
本页面介绍旧版 Amazon Bedrock 集成：使用 ARN 版本化模型标识符和 AWS 事件流编码的 `InvokeModel` 和 `Converse` API。有关 Messages-API Bedrock 端点上可用的模型，请参阅 [Claude in Amazon Bedrock](/docs/en/build-with-claude/claude-in-amazon-bedrock)，它在 `/anthropic/v1/messages` 处使用 Messages API 并支持 SSE 流式传输。有关 AWS 上 Anthropic 运营的替代方案，具有 AWS Marketplace 计费和通常当天功能访问，请参阅 [Claude Platform on AWS](/docs/en/build-with-claude/claude-platform-on-aws)。现有 Bedrock 用户可以按照[迁移指南](/docs/en/build-with-claude/claude-platform-on-aws#migrating-from-amazon-bedrock)操作。
</Note>

通过 Bedrock 调用 Claude 与直接在 Claude API 上调用 Claude 略有不同。本指南将引导您使用 Anthropic 的[客户端 SDK](/docs/en/api/client-sdks) 完成对 Bedrock 上 Claude 的 API 调用。

请注意，本指南假设您已注册 [AWS 账户](https://portal.aws.amazon.com/billing/signup)并配置了编程访问。

## 安装和配置 AWS CLI

1. [安装版本不低于 `2.13.23` 的 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)
2. 使用 AWS configure 命令配置您的 AWS 凭证（参见[配置 AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html)），或通过在 AWS 控制台中导航到"命令行或编程访问"并按照弹出窗口中的说明找到您的凭证。
3. 验证您的凭证是否正常工作：

```bash AWS CLI
aws sts get-caller-identity
```

## 安装用于访问 Bedrock 的 SDK

Anthropic 的[客户端 SDK](/docs/en/api/client-sdks) 支持 Bedrock。您也可以直接使用 AWS SDK，如 `boto3`。

<Tabs>
<Tab title="Python">
```bash
pip install -U "anthropic[bedrock]"
```
</Tab>

<Tab title="TypeScript">
```bash
npm install @anthropic-ai/bedrock-sdk
```
</Tab>

<Tab title="C#">
```bash
dotnet add package Anthropic.Bedrock
```
</Tab>

<Tab title="Go">
```bash
go get github.com/anthropics/anthropic-sdk-go/bedrock
```
</Tab>

<Tab title="Java">
<CodeGroup>
```groovy Gradle
implementation("com.anthropic:anthropic-java-bedrock:2.33.0")
```

```xml Maven
<dependency>
    <groupId>com.anthropic</groupId>
    <artifactId>anthropic-java-bedrock</artifactId>
    <version>2.33.0</version>
</dependency>
```

```java Java nocheck hidelines={7..9,-2..}
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.bedrock.backends.BedrockBackend;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.Model;

public class BasicMessage {
    public static void main(String[] args) {
        AnthropicClient client = AnthropicOkHttpClient.builder()
            .backend(BedrockBackend.fromEnv())
            .build();

        MessageCreateParams params = MessageCreateParams.builder()
            .model(Model.CLAUDE_OPUS_4_6)
            .maxTokens(1024L)
            .addUserMessage("What is the capital of France?")
            .build();

        Message response = client.messages().create(params);
        response.content().stream()
            .flatMap(block -> block.text().stream())
            .forEach(textBlock -> System.out.println(textBlock.text()));
    }
}
```
</CodeGroup>
</Tab>

<Tab title="PHP">
```bash
composer require anthropic-ai/sdk aws/aws-sdk-php
```
</Tab>

<Tab title="Ruby">
```bash
# Gemfile
gem "anthropic"
gem "aws-sdk-bedrockruntime"
```
</Tab>

<Tab title="Boto3 (Python)">
```bash
pip install "boto3>=1.28.59"
```
</Tab>
</Tabs>

## 访问 Bedrock

### 订阅 Anthropic 模型

前往 [AWS 控制台 > Bedrock > 模型访问](https://console.aws.amazon.com/bedrock/home?region=us-west-2#/modelaccess)并请求访问 Anthropic 模型。请注意，Anthropic 模型的可用性因区域而异。有关最新信息，请参阅 [AWS 文档](https://docs.aws.amazon.com/bedrock/latest/userguide/models-regions.html)。

#### API 模型 ID

<Note>
  Claude Opus 4.7 可通过 `bedrock-runtime` 上的 `InvokeModel` 访问。
  这些请求由与 [Claude in Amazon Bedrock](/docs/en/build-with-claude/claude-in-amazon-bedrock)
  端点相同的基础设施提供服务。有关原生 Messages API 请求格式和完整功能
  对等，请使用该页面。Claude Opus 4.7 在本页的模型表中被省略，
  因为它没有 ARN 版本化模型 ID。
</Note>

生命周期术语（已弃用、已退役）在[模型弃用](/docs/en/about-claude/model-deprecations)中定义；"即将退役"标注给出了平台公布的退役日期。下表中的日期是 **Amazon Bedrock** 的时间表，由 AWS 独立设置。模型在此处的生命周期状态和日期可能与模型弃用页面上 Anthropic 运营的时间表不同。

| 模型 | 基础 Bedrock 模型 ID | `global` | `us` | `eu` | `jp` | `apac` |
| :---- | :---- | :---- | :---- | :---- | :---- | :---- |
| Claude Opus 4.6 | anthropic.claude-opus-4-6-v1 | 是 | 是 | 是 | 是 | 是 |
| Claude Sonnet 4.6 | anthropic.claude-sonnet-4-6 | 是 | 是 | 是 | 是 | 否 |
| Claude Sonnet 4.5 | anthropic.claude-sonnet-4-5-20250929-v1:0 | 是 | 是 | 是 | 是 | 否 |
| Claude Sonnet 4 <br /><small>已弃用。将于 2026 年 10 月 14 日退役。</small> | anthropic.claude-sonnet-4-20250514-v1:0 | 是 | 是 | 是 | 否 | 是 |
| Claude Sonnet 3.7 <br /><small>已于 2026 年 4 月 28 日退役。</small> | anthropic.claude-3-7-sonnet-20250219-v1:0 | 否 | 否 | 否 | 否 | 否 |
| Claude Opus 4.5 | anthropic.claude-opus-4-5-20251101-v1:0 | 是 | 是 | 是 | 否 | 否 |
| Claude Opus 4.1 | anthropic.claude-opus-4-1-20250805-v1:0 | 否 | 是 | 否 | 否 | 否 |
| Claude Opus 4 <br /><small>已弃用。将于 2026 年 5 月 31 日退役。</small> | anthropic.claude-opus-4-20250514-v1:0 | 否 | 是 | 否 | 否 | 否 |
| Claude Haiku 4.5 | anthropic.claude-haiku-4-5-20251001-v1:0 | 是 | 是 | 是 | 否 | 否 |
| Claude Haiku 3.5 <br /><small>已弃用。将于 2026 年 6 月 19 日退役。</small> | anthropic.claude-3-5-haiku-20241022-v1:0 | 否 | 是 | 否 | 否 | 否 |

有关区域与全球模型 ID 的更多信息，请参阅[全球与区域端点](#全球与区域端点)部分。

### 列出可用模型

以下示例展示如何打印通过 Bedrock 可用的所有 Claude 模型列表：

<CodeGroup>
  ```bash AWS CLI
  aws bedrock list-foundation-models --region=us-west-2 --by-provider anthropic --query "modelSummaries[*].modelId"
  ```

  
  ```python Boto3 (Python) nocheck
  import boto3

  bedrock = boto3.client(service_name="bedrock")
  response = bedrock.list_foundation_models(byProvider="anthropic")

  for summary in response["modelSummaries"]:
      print(summary["modelId"])
  ```

  
  ```typescript TypeScript nocheck
  import { BedrockClient, ListFoundationModelsCommand } from "@aws-sdk/client-bedrock";

  const client = new BedrockClient({ region: "us-west-2" });

  const command = new ListFoundationModelsCommand({ byProvider: "anthropic" });
  const response = await client.send(command);

  if (response.modelSummaries) {
    for (const summary of response.modelSummaries) {
      console.log(summary.modelId);
    }
  }
  ```

  
  ```csharp C# nocheck
  using System;
  using System.Threading.Tasks;
  using Amazon;
  using Amazon.Bedrock;
  using Amazon.Bedrock.Model;

  public class ListAnthropicModels
  {
      public static async Task Main(string[] args)
      {
          var client = new AmazonBedrockClient(RegionEndpoint.USWest2);

          var request = new ListFoundationModelsRequest
          {
              ByProvider = "anthropic"
          };

          var response = await client.ListFoundationModelsAsync(request);

          foreach (var summary in response.ModelSummaries)
          {
              Console.WriteLine(summary.ModelId);
          }
      }
  }
  ```

  
  ```go Go nocheck hidelines={1..2,11..12,-1}
  package main

  import (
  	"context"
  	"fmt"
  	"log"

  	"github.com/aws/aws-sdk-go-v2/config"
  	"github.com/aws/aws-sdk-go-v2/service/bedrock"
  )

  func main() {
  	cfg, err := config.LoadDefaultConfig(context.TODO(), config.WithRegion("us-west-2"))
  	if err != nil {
  		log.Fatal(err)
  	}

  	client := bedrock.NewFromConfig(cfg)

  	byProvider := "anthropic"
  	response, err := client.ListFoundationModels(context.TODO(), &bedrock.ListFoundationModelsInput{
  		ByProvider: &byProvider,
  	})
  	if err != nil {
  		log.Fatal(err)
  	}

  	for _, summary := range response.ModelSummaries {
  		fmt.Println(*summary.ModelId)
  	}
  }
  ```

  
  ```java Java nocheck hidelines={6..8,-2..}
  import software.amazon.awssdk.regions.Region;
  import software.amazon.awssdk.services.bedrock.BedrockClient;
  import software.amazon.awssdk.services.bedrock.model.ListFoundationModelsRequest;
  import software.amazon.awssdk.services.bedrock.model.ListFoundationModelsResponse;
  import software.amazon.awssdk.services.bedrock.model.FoundationModelSummary;

  public class ListAnthropicModels {
      public static void main(String[] args) {
          BedrockClient client = BedrockClient.builder()
              .region(Region.US_WEST_2)
              .build();

          ListFoundationModelsRequest request = ListFoundationModelsRequest.builder()
              .byProvider("anthropic")
              .build();

          ListFoundationModelsResponse response = client.listFoundationModels(request);

          for (FoundationModelSummary summary : response.modelSummaries()) {
              System.out.println(summary.modelId());
          }

          client.close();
      }
  }
  ```

  
  ```php PHP nocheck
  <?php

  use Aws\Bedrock\BedrockClient;

  $client = new BedrockClient([
      'region' => 'us-west-2',
      'version' => 'latest'
  ]);

  $result = $client->listFoundationModels([
      'byProvider' => 'anthropic'
  ]);

  foreach ($result['modelSummaries'] as $summary) {
      echo $summary['modelId'] . PHP_EOL;
  }
  ```

  
  ```ruby Ruby nocheck
  require "aws-sdk-bedrock"

  client = Aws::Bedrock::Client.new(region: "us-west-2")

  response = client.list_foundation_models({
    by_provider: "anthropic"
  })

  response.model_summaries.each do |summary|
    puts summary.model_id
  end
  ```
</CodeGroup>

### 发起请求

以下示例展示如何从 Bedrock 上的 Claude 生成文本：

<CodeGroup>
  ```bash CLI
  # ant CLI 不支持 Amazon Bedrock。
  ```

  
  ```python Python nocheck
  from anthropic import AnthropicBedrock

  client = AnthropicBedrock(
      # 通过提供以下密钥或使用默认 AWS 凭证提供者进行认证，例如
      # 使用 ~/.aws/credentials 或 "AWS_SECRET_ACCESS_KEY" 和 "AWS_ACCESS_KEY_ID" 环境变量。
      aws_access_key="<access key>",
      aws_secret_key="<secret key>",
      # 临时凭证可以与 aws_session_token 一起使用。
      # 了解更多请访问 https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html。
      aws_session_token="<session_token>",
      # aws_region 更改请求发送到的 aws 区域。默认情况下，SDK 读取 AWS_REGION，
      # 如果不存在，则默认为 us-east-1。请注意，SDK 不会从 ~/.aws/config 读取区域。
      aws_region="us-west-2",
  )

  message = client.messages.create(
      model="global.anthropic.claude-opus-4-6-v1",
      max_tokens=256,
      messages=[{"role": "user", "content": "Hello, world"}],
  )
  print(message.content)
  ```

  
  ```typescript TypeScript nocheck
  import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

  const client = new AnthropicBedrock({
    // 通过提供以下密钥或使用默认 AWS 凭证提供者进行认证，例如
    // ~/.aws/credentials 或 "AWS_SECRET_ACCESS_KEY" 和 "AWS_ACCESS_KEY_ID" 环境变量。
    awsAccessKey: "<access key>",
    awsSecretKey: "<secret key>",

    // 临时凭证可以与 awsSessionToken 一起使用。
    // 了解更多请访问 https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html。
    awsSessionToken: "<session_token>",

    // awsRegion 更改请求发送到的 aws 区域。默认情况下，SDK 读取 AWS_REGION，如果
    // 不存在，则默认为 us-east-1。请注意，SDK 不会从 ~/.aws/config 读取区域。
    awsRegion: "us-west-2"
  });

  async function main() {
    const message = await client.messages.create({
      model: "global.anthropic.claude-opus-4-6-v1",
      max_tokens: 256,
      messages: [{ role: "user", content: "Hello, world" }]
    });
    console.log(message);
  }
  main().catch(console.error);
  ```

  
  ```csharp C# nocheck
  using Anthropic.Bedrock;
  using Anthropic.Models.Messages;

  AnthropicBedrockClient client = new(
      await AnthropicBedrockCredentialsHelper.FromEnv()
      ?? throw new InvalidOperationException("AWS credentials not configured.")
  );

  var response = await client.Messages.Create(new MessageCreateParams
  {
      Model = "global.anthropic.claude-opus-4-6-v1",
      MaxTokens = 256,
      Messages = [new() { Role = Role.User, Content = "Hello, world" }],
  });

  Console.WriteLine(
      string.Join("", response.Content
          .Where(c => c.Value is TextBlock)
          .Select(c => (c.Value as TextBlock)!.Text)));
  ```

  
  ```go Go nocheck hidelines={1..2,10..11,-1}
  package main

  import (
  	"context"
  	"fmt"

  	"github.com/anthropics/anthropic-sdk-go"
  	"github.com/anthropics/anthropic-sdk-go/bedrock"
  )

  func main() {
  	// 使用默认 AWS 凭证提供者链
  	client := anthropic.NewClient(
  		bedrock.WithLoadDefaultConfig(context.Background()),
  	)

  	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		Model:     "global.anthropic.claude-opus-4-6-v1",
  		MaxTokens: 256,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("%+v\n", message.Content)
  }
  ```

  
  ```java Java nocheck hidelines={6..9,-2..}
  import com.anthropic.bedrock.backends.BedrockBackend;
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.models.messages.Message;
  import com.anthropic.models.messages.MessageCreateParams;

  public class BedrockExample {

    public static void main(String[] args) {
      // 使用默认 AWS 凭证提供者链
      AnthropicClient client = AnthropicOkHttpClient.builder()
        .backend(BedrockBackend.fromEnv())
        .build();

      Message message = client
        .messages()
        .create(
          MessageCreateParams.builder()
            .model("global.anthropic.claude-opus-4-6-v1")
            .maxTokens(256)
            .addUserMessage("Hello, world")
            .build()
        );

      System.out.println(message.content());
    }
  }
  ```

  
  ```php PHP nocheck
  <?php

  use Anthropic\Bedrock;

  $client = Bedrock\Client::withCredentials(
      accessKeyId: getenv("AWS_ACCESS_KEY_ID"),
      secretAccessKey: getenv("AWS_SECRET_ACCESS_KEY"),
      region: 'us-west-2',
      securityToken: getenv("AWS_SESSION_TOKEN"),
  );

  $message = $client->messages->create(
      maxTokens: 256,
      messages: [
          ['role' => 'user', 'content' => 'Hello, world']
      ],
      model: 'global.anthropic.claude-opus-4-6-v1',
  );
  echo $message->content[0]->text;
  ```

  
  ```ruby Ruby nocheck
  require "anthropic"

  client = Anthropic::BedrockClient.new

  message = client.messages.create(
    model: "global.anthropic.claude-opus-4-6-v1",
    max_tokens: 256,
    messages: [{role: "user", content: "Hello, world"}]
  )

  puts message.content.first.text
  ```

  
  ```python Boto3 (Python) nocheck
  import boto3
  import json

  bedrock = boto3.client(service_name="bedrock-runtime")
  body = json.dumps(
      {
          "max_tokens": 256,
          "messages": [{"role": "user", "content": "Hello, world"}],
          "anthropic_version": "bedrock-2023-05-31",
      }
  )

  response = bedrock.invoke_model(
      body=body, modelId="global.anthropic.claude-opus-4-6-v1"
  )

  response_body = json.loads(response.get("body").read())
  print(response_body.get("content"))
  ```
</CodeGroup>

有关更多详细信息，请参阅[客户端 SDK](/docs/en/api/client-sdks) 和[官方 Bedrock 文档](https://docs.aws.amazon.com/bedrock/)。

### Bearer token 认证

您可以使用 bearer token 而不是 AWS 凭证来认证 Bedrock。这在团队需要访问 Bedrock 而无需管理 AWS 凭证、IAM 角色或账户级权限的企业环境中非常有用。

<Note>
Bearer token 认证在 C#、Go 和 Java SDK 中受支持。PHP、Python、TypeScript 和 Ruby SDK 仅使用 AWS SigV4 签名。
</Note>

最简单的方法是设置 `AWS_BEARER_TOKEN_BEDROCK` 环境变量，每个 SDK 在从环境解析凭证时会自动检测。

要以编程方式提供 token：

<CodeGroup>

```csharp C# nocheck
using Anthropic.Bedrock;
using Anthropic.Models.Messages;

var client = new AnthropicBedrockClient(
    new AnthropicBedrockApiTokenCredentials
    {
        BearerToken = "your-bearer-token",
        Region = "us-west-2",
    }
);

var response = await client.Messages.Create(new MessageCreateParams
{
    Model = "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
    MaxTokens = 1024,
    Messages = [new() { Role = Role.User, Content = "Hello!" }],
});
```

```go Go nocheck hidelines={1..2,11..12,-1}
package main

import (
	"context"
	"fmt"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/bedrock"
	"github.com/aws/aws-sdk-go-v2/aws"
)

func main() {
	cfg := aws.Config{
		Region:                  "us-west-2",
		BearerAuthTokenProvider: bedrock.NewStaticBearerTokenProvider("your-bearer-token"),
	}
	client := anthropic.NewClient(
		bedrock.WithConfig(cfg),
	)

	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		Model:     "us.anthropic.claude-sonnet-4-5-20250929-v1:0",
		MaxTokens: 1024,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
		},
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(message.Content[0].Text)
}
```

```java Java nocheck
import com.anthropic.bedrock.backends.BedrockBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;

// 选项 1：设置 AWS_BEARER_TOKEN_BEDROCK 环境变量并使用 fromEnv()
AnthropicClient client = AnthropicOkHttpClient.builder()
  .backend(BedrockBackend.fromEnv())
  .build();

// 选项 2：以编程方式提供 token
client = AnthropicOkHttpClient.builder()
  .backend(BedrockBackend.builder()
    .apiKey("your-bearer-token")
    .build())
  .build();

MessageCreateParams params = MessageCreateParams.builder()
  .model("us.anthropic.claude-sonnet-4-5-20250929-v1:0")
  .maxTokens(1024)
  .addUserMessage("Hello!")
  .build();

client.messages().create(params).content().stream()
  .flatMap(block -> block.text().stream())
  .forEach(textBlock -> System.out.println(textBlock.text()));
```

</CodeGroup>

## 活动日志

Bedrock 提供[调用日志服务](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html)，允许客户记录与使用相关的提示和补全。

Anthropic 建议您至少保留 30 天的滚动活动日志，以了解您的活动并调查任何潜在的滥用。

<Note>
启用此服务不会让 AWS 或 Anthropic 访问您的内容。
</Note>

## 功能支持
有关 Amazon Bedrock 可用性的完整功能列表，请参阅[功能概览](/docs/en/build-with-claude/overview)。

### 支持的功能亮点

- [Messages API](/docs/en/api/messages/create)
- [Prompt caching](/docs/en/build-with-claude/prompt-caching)
- [Extended thinking](/docs/en/build-with-claude/extended-thinking)
- [Tool use](/docs/en/agents-and-tools/tool-use/overview)，包括 [Bash tool](/docs/en/agents-and-tools/tool-use/bash-tool)、[Computer use tool](/docs/en/agents-and-tools/tool-use/computer-use-tool)、[Memory tool](/docs/en/agents-and-tools/tool-use/memory-tool) 和 [Text editor tool](/docs/en/agents-and-tools/tool-use/text-editor-tool)
- [Citations](/docs/en/build-with-claude/citations)
- [Structured outputs](/docs/en/build-with-claude/structured-outputs)

### 不支持的功能

- 输入源（图像和文档的 URL 源、Files API）
- 服务器端工具（代码执行、网络搜索、网络获取、顾问）
- 基础设施代理（Agent Skills、MCP 连接器、程序化工具调用）
- API 端点（Message Batches、Models、Admin、Compliance、Usage and Cost）
- Claude 托管代理

### Bedrock 上的 PDF 支持

PDF 支持可通过 Bedrock 上的 Converse API 和 InvokeModel API 使用。有关 PDF 处理功能和限制的详细信息，请参阅 [Amazon Bedrock PDF 支持](/docs/en/build-with-claude/pdf-support#amazon-bedrock-pdf-support)。

**Converse API 用户的重要注意事项：**
- 可视 PDF 分析（图表、图像、布局）需要启用引用
- 不启用引用时，仅提供基本文本提取
- 要在不强制引用的情况下获得完全控制，请使用 InvokeModel API

### 上下文窗口

Claude Opus 4.6 和 Claude Sonnet 4.6 在 Amazon Bedrock 上具有 [1M token 上下文窗口](/docs/en/build-with-claude/context-windows)。其他 Claude 模型，包括 Sonnet 4.5 和 Sonnet 4（已弃用），具有 200k token 上下文窗口。

Bedrock 将请求有效负载限制为 20 MB。发送大型文档或多张图像时，您可能会在达到 token 限制之前达到此限制。

## 全球与区域端点

从 **Claude Sonnet 4.5 和所有未来模型**开始，Bedrock 提供两种端点类型：

- **全球端点：** 动态路由以实现最大可用性
- **区域端点：** 保证通过特定地理区域的数据路由

区域端点比全球端点有 10% 的价格溢价。

<Note>
这仅适用于 Claude Sonnet 4.5 和未来模型。旧模型（Claude Sonnet 4（已弃用）、Opus 4（已弃用）及更早版本）保持其现有定价结构。
</Note>

### 何时使用每个选项

**全球端点（推荐）：**
- 提供最大可用性和正常运行时间
- 动态将请求路由到有可用容量的区域
- 无价格溢价
- 最适合数据驻留灵活的应用程序

**区域端点（CRIS）：**
- 通过特定地理区域路由流量
- 数据驻留和合规要求所需
- 适用于美国、欧盟、日本和亚太地区
- 10% 的价格溢价反映了专用区域容量的基础设施成本

### 实现

**使用全球端点（Opus 4.6、Sonnet 4.6 和 Sonnet 4.5 的默认值）：**

Claude Opus 4.6、Sonnet 4.6 和 Sonnet 4.5 的模型 ID 已包含 `global.` 前缀：

<CodeGroup>
```bash CLI
# ant CLI 不支持 Amazon Bedrock。
```

```python Python nocheck
from anthropic import AnthropicBedrock

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

message = client.messages.create(
    model="global.anthropic.claude-opus-4-6-v1",
    max_tokens=256,
    messages=[{"role": "user", "content": "Hello, world"}],
)
```

```typescript TypeScript nocheck
import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

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

const message = await client.messages.create({
  model: "global.anthropic.claude-opus-4-6-v1",
  max_tokens: 256,
  messages: [{ role: "user", content: "Hello, world" }]
});
```

```csharp C# nocheck
using Anthropic.Bedrock;
using Anthropic.Models.Messages;

// C# Bedrock 客户端使用带区域前缀的模型 ID 进行全球路由
AnthropicBedrockClient client = new(
    await AnthropicBedrockCredentialsHelper.FromEnv()
    ?? throw new InvalidOperationException("AWS credentials not configured.")
);

var response = await client.Messages.Create(new MessageCreateParams
{
    // 使用 "global." 前缀进行全球跨区域推理
    Model = "global.anthropic.claude-opus-4-6-v1",
    MaxTokens = 256,
    Messages = [new() { Role = Role.User, Content = "Hello, world" }],
});
```

```go Go hidelines={1..2,9..10,-1}
package main

import (
	"context"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/bedrock"
)

func main() {
	// 使用默认 AWS 凭证提供者链
	client := anthropic.NewClient(
		bedrock.WithLoadDefaultConfig(context.Background()),
	)

	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "global.anthropic.claude-opus-4-6-v1",
		MaxTokens: 256,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
		},
	})
	_ = message
}
```

```java Java nocheck
import com.anthropic.bedrock.backends.BedrockBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;

// 使用默认 AWS 凭证提供者链
AnthropicClient client = AnthropicOkHttpClient.builder()
  .backend(BedrockBackend.fromEnv())
  .build();

var message = client
  .messages()
  .create(
    MessageCreateParams.builder()
      .model("global.anthropic.claude-opus-4-6-v1")
      .maxTokens(256)
      .addUserMessage("Hello, world")
      .build()
  );
```

```php PHP nocheck
<?php

use Anthropic\Bedrock;

$client = Bedrock\Client::fromEnvironment();

$message = $client->messages->create(
    maxTokens: 256,
    messages: [
        ['role' => 'user', 'content' => 'Hello, world']
    ],
    model: 'global.anthropic.claude-opus-4-6-v1',
);
```

```ruby Ruby nocheck
require "anthropic"

# 默认凭证从 AWS_REGION 环境变量解析区域
client = Anthropic::BedrockClient.new

message = client.messages.create(
  # 使用 "global." 前缀进行全球跨区域推理
  model: "global.anthropic.claude-opus-4-6-v1",
  max_tokens: 256,
  messages: [{role: "user", content: "Hello, world"}]
)
```
</CodeGroup>

**使用区域端点（CRIS）：**

要使用区域端点，请将 `global.` 前缀替换为区域前缀，如 `us.`：

<CodeGroup>
```bash CLI
# ant CLI 不支持 Amazon Bedrock。
```

```python Python nocheck
from anthropic import AnthropicBedrock

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

# 使用美国区域端点（CRIS）
message = client.messages.create(
    model="us.anthropic.claude-opus-4-6-v1",  # 区域前缀
    max_tokens=256,
    messages=[{"role": "user", "content": "Hello, world"}],
)
```

```typescript TypeScript nocheck
import AnthropicBedrock from "@anthropic-ai/bedrock-sdk";

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

// 使用美国区域端点（CRIS）
const message = await client.messages.create({
  model: "us.anthropic.claude-opus-4-6-v1", // 区域前缀
  max_tokens: 256,
  messages: [{ role: "user", content: "Hello, world" }]
});
```

```csharp C# nocheck
using Anthropic.Bedrock;
using Anthropic.Models.Messages;

AnthropicBedrockClient client = new(
    new AnthropicBedrockPrivateKeyCredentials { Region = "us-west-2" }
);

// 使用美国区域端点（CRIS）
var response = await client.Messages.Create(new MessageCreateParams
{
    Model = "us.anthropic.claude-opus-4-6-v1", // 区域前缀
    MaxTokens = 256,
    Messages = [new() { Role = Role.User, Content = "Hello, world" }],
});
```

```go Go hidelines={1..2,9..10,-1}
package main

import (
	"context"

	"github.com/anthropics/anthropic-sdk-go"
	"github.com/anthropics/anthropic-sdk-go/bedrock"
)

func main() {
	// 使用默认 AWS 凭证提供者链
	client := anthropic.NewClient(
		bedrock.WithLoadDefaultConfig(context.Background()),
	)

	// 使用美国区域端点（CRIS）
	message, _ := client.Messages.New(context.Background(), anthropic.MessageNewParams{
		Model:     "us.anthropic.claude-opus-4-6-v1", // 区域前缀
		MaxTokens: 256,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, world")),
		},
	})
	_ = message
}
```

```java Java nocheck
import com.anthropic.bedrock.backends.BedrockBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.MessageCreateParams;

// 使用默认 AWS 凭证提供者链
AnthropicClient client = AnthropicOkHttpClient.builder()
  .backend(BedrockBackend.fromEnv())
  .build();

// 使用美国区域端点（CRIS）
var message = client
  .messages()
  .create(
    MessageCreateParams.builder()
      .model("us.anthropic.claude-opus-4-6-v1") // 区域前缀
      .maxTokens(256)
      .addUserMessage("Hello, world")
      .build()
  );
```

```php PHP nocheck
<?php

use Anthropic\Bedrock;

$client = Bedrock\Client::fromEnvironment();

$message = $client->messages->create(
    maxTokens: 256,
    messages: [
        ['role' => 'user', 'content' => 'Hello, world']
    ],
    model: 'us.anthropic.claude-opus-4-6-v1',
);
```

```ruby Ruby nocheck
require "anthropic"

# 使用美国区域端点（CRIS）
client = Anthropic::BedrockClient.new(aws_region: "us-west-2")

message = client.messages.create(
  model: "us.anthropic.claude-opus-4-6-v1", # 区域前缀
  max_tokens: 256,
  messages: [{role: "user", content: "Hello, world"}]
)
```
</CodeGroup>

<Note>
**Claude Mythos Preview** 是一个研究预览模型，面向 Amazon Bedrock 上受邀客户开放。有关更多信息，请参阅 [Project Glasswing](https://anthropic.com/glasswing)。
</Note>

## 其他资源

- **Bedrock 定价：** [aws.amazon.com/bedrock/pricing](https://aws.amazon.com/bedrock/pricing/)
- **AWS 定价文档：** [Bedrock 定价指南](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-pricing.html)
- **AWS 博客文章：** [在 Amazon Bedrock 中引入 Claude Sonnet 4.5](https://aws.amazon.com/blogs/aws/introducing-claude-sonnet-4-5-in-amazon-bedrock-anthropics-most-intelligent-model-best-for-coding-and-complex-agents/)
- **Anthropic 定价详情：** [云平台定价](/docs/en/about-claude/pricing#cloud-platform-pricing)