---
title: CMEK用のAWS KMSを設定する
url: https://platform.claude.com/docs/ja/manage-claude/cmek-aws-kms
description: AWS KMSを使用して、組織の暗号化キーを提供します。
---

Claude Codeにこの機能を設定させる

```text
/claude-api AWS KMSで顧客管理暗号化キーを設定するのを手伝ってください
```

このガイドでは、[AWS KMS](https://aws.amazon.com/kms/)キーをAnthropic組織の[顧客管理暗号化キー（CMEK）](https://platform.claude.com/docs/ja/manage-claude/cmek)として設定する手順を説明します。

<Warning>
  CMEKの有効化は永続的です。KMSキーが削除または無効化された場合、Anthropicはそのキーで暗号化されたデータを復元できません。開始する前に[警告と制限事項](https://platform.claude.com/docs/ja/manage-claude/cmek)を確認してください。
</Warning>

<Note>
  **Claude Platform on AWS:** [Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws)では、キーポリシーはAnthropicのIAMロールではなくAWSサービスプリンシパルにアクセスを付与し、個別の検証ステップはなく、Claude Consoleでキーを登録してアタッチします。次のセクションの手順ではなく、このページの[Claude Platform on AWSでCMEKを設定する](https://platform.claude.com/docs/ja/manage-claude/cmek-aws-kms#claude-platform-on-aws)に従ってください。
</Note>

## 前提条件

* KMSキーを作成しキーポリシーを設定する権限（`kms:CreateKey`および`kms:PutKeyPolicy`）を持つAWSアカウント。
* 組織のAnthropic Admin APIキー。
* インストールおよび認証済みの[AWS CLI](https://aws.amazon.com/cli/)。

## Anthropic用のAmazon Resource Name（ARN）

Anthropicに暗号化キーを使用させるには、AnthropicのIAMロールにデータの暗号化に使用できるKMSキーを付与する必要があります。Anthropic CMEK用のARNは次のとおりです。

```text wrap
arn:aws:iam::915198916910:role/anthropic-cmek-client-us
```

<Warning>
  この公開されたARNのみを使用してください。メール、チャット、またはオンボーディングチャネルで提供された識別子を決して信頼しないでください。
</Warning>

## 暗号化キーのセットアップ

<Steps>
  <Step title="クロスアカウントキーポリシーでKMSキーを作成する">
    <Note>
      **Claude Platform on AWS:** このステップはスキップしてください。キーポリシーはAWSサービスプリンシパルにアクセスを付与し、組織条件はありません。[Claude Platform on AWSでCMEKを設定する](https://platform.claude.com/docs/ja/manage-claude/cmek-aws-kms#claude-platform-on-aws)にそのポリシーが記載されています。
    </Note>

    キーポリシーはAnthropicのIAMロールにクロスアカウントアクセスを付与します。3つのステートメントが必要です。

    1. **アカウントルート管理者:** 標準的なKMSパターン。アカウントは完全な管理制御を保持します。
    2. **Anthropicの暗号化と復号:** `kms:Encrypt`および`kms:Decrypt`アクション。Anthropicはこれを使用して、ワークスペースデータを保護するデータキーを暗号化および復号します（エンベロープ暗号化）。
    3. **Anthropicのdescribe:** Anthropicが起動時に実行するメタデータの読み取り。`DescribeKey`には`EncryptionContext`パラメータがないため、このアクションに`EncryptionContext`条件を設定すると常に拒否されるため、別途付与されます。

    [AWSアカウントID](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html)を確認するには、`aws sts get-caller-identity --query Account --output text`を実行します。

    ポリシー内で、`<AWS_ACCOUNT_ID>`をAWSアカウントIDに、`<ORGANIZATION_UUID>`を組織IDに置き換えます。`kms:EncryptionContext:anthropic:org_uuid`の`StringEquals`条件はキーをAnthropic組織にバインドし、検証ではこれがないキーを拒否します。1つのキーを複数のAnthropic組織で共有するには、条件値に各組織IDをリストします。

    <Note>
      **組織IDの確認方法:** Claude Consoleの[Organization](https://platform.claude.com/settings/organization)ページ（`platform.claude.com/settings/organization`）、またはclaude.aiの**Organization settings > Organization**にある**Organization ID**フィールドをコピーするか、[Organization Info](https://platform.claude.com/docs/ja/api/organization/retrieve)エンドポイントから`id`フィールドを読み取ります。`org_`プレフィックス付きのIDではなく、プレフィックスなしのUUIDを使用してください。
    </Note>

    ポリシーを`key-policy.json`として保存します。代わりにAWS Consoleでキーを作成するには、このステップの後半で説明するように、そこにポリシーを貼り付けます。

    ```json key-policy.json
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "AccountRootAdmin",
          "Effect": "Allow",
          "Principal": {
            "AWS": "arn:aws:iam::<AWS_ACCOUNT_ID>:root"
          },
          "Action": "kms:*",
          "Resource": "*"
        },
        {
          "Sid": "AllowAnthropicCMEKCrypto",
          "Effect": "Allow",
          "Principal": {
            "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us"
          },
          "Action": ["kms:Encrypt", "kms:Decrypt"],
          "Resource": "*",
          "Condition": {
            "StringEquals": {
              "kms:EncryptionContext:anthropic:org_uuid": ["<ORGANIZATION_UUID>"]
            }
          }
        },
        {
          "Sid": "AllowAnthropicCMEKDescribe",
          "Effect": "Allow",
          "Principal": {
            "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us"
          },
          "Action": "kms:DescribeKey",
          "Resource": "*"
        }
      ]
    }
    ```

    <Note>
      **オプション:** キーを一部のワークスペースに限定するには、前述のポリシーJSONのものではなく、この`AllowAnthropicCMEKCrypto`ステートメントを使用し、各ワークスペースに1つのコンパートメントIDを指定します。キーをアタッチする前に、ワークスペースのコンパートメントIDを追加します。新しいワークスペースの場合は、キーなしで作成し、そのコンパートメントIDを追加してから、キーをアタッチします。

      ```json
      {
        "Sid": "AllowAnthropicCMEKCrypto",
        "Effect": "Allow",
        "Principal": {
          "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us"
        },
        "Action": ["kms:Encrypt", "kms:Decrypt"],
        "Resource": "*",
        "Condition": {
          "StringEquals": {
            "kms:EncryptionContext:anthropic:org_uuid": ["<ORGANIZATION_UUID>"]
          },
          "StringEqualsIfExists": {
            "kms:EncryptionContext:anthropic:compartment_uuid": ["<COMPARTMENT_UUID>"]
          }
        }
      }
      ```
    </Note>

    ```bash
    aws kms create-key \
      --region <REGION> \
      --description "Anthropic CMEK" \
      --key-usage ENCRYPT_DECRYPT \
      --policy file://key-policy.json
    ```

    出力から`KeyMetadata.Arn`を取得します。次のステップでキーを登録する際に必要になります。

    <Warning>
      キーがすでにCMEK用に設定されており、既存のデータを保護している場合は、前述のポリシーの3つのステートメントに加えて、Anthropicがそのデータを復号できるようにするステートメントを追加する必要があります。その条件には、キーがアタッチされている、またはアタッチされていたすべてのワークスペースのコンパートメントIDをリストします。

      ```json
      {
        "Sid": "AllowAnthropicCMEKDecryptExistingData",
        "Effect": "Allow",
        "Principal": {
          "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us"
        },
        "Action": "kms:Decrypt",
        "Resource": "*",
        "Condition": {
          "StringEquals": {
            "kms:EncryptionContext:anthropic:compartment_uuid": ["<COMPARTMENT_UUID>"]
          }
        }
      }
      ```
    </Warning>

    Anthropicは、キーを検証するとき、またはワークスペースにアタッチするときにキーを検証します。各検証はCloudTrailに4つのアクセス拒否エラーを追加します。これらは想定されたものです。これらをフィルタリングする必要がある場合は、次の3つの値すべてでフィルタリングします。最初の値だけでは不十分です。なぜなら、どの呼び出し元でも設定できるからです。

    * `requestParameters.encryptionContext.associatedData`: `Y21lay12YWxpZGF0aW9u`
    * `userIdentity.accountId`: `915198916910`
    * `resources.ARN`: `arn:aws:kms:<REGION>:<AWS_ACCOUNT_ID>:key/<KEY_ID>`

    <Note>
      **コンパートメントIDの確認方法:** **Register the key with Anthropic**の下の**Claude Platform**タブを参照してください。
    </Note>

    AWS Consoleからキーを作成することもできます。暗号化と復号のキー使用法を持つ対称キー、単一リージョンキー、およびKMSキーマテリアルオリジンを選択します。キー作成ウィザードは**Review**ステップでキーポリシーをコミットします。そこでキー使用権限の下にAnthropicのアカウントID `915198916910`を追加すると、生成されたポリシーはAnthropicアカウント全体に`EncryptionContext`条件なしでより広範なアクション（`kms:ReEncrypt*`や`kms:GenerateDataKey*`など）を付与し、検証はそれを拒否します。過度に許可されたキーを残さないようにするには、管理権限のみでウィザードを完了し、キーの**Key policy**タブを開いて、JSONをこのステップの前半で示した`key-policy.json`ポリシーに置き換えます。

    <Frame caption="キーの設定: 対称、暗号化と復号、単一リージョンキー。">
      ![AWS KMSのキー作成ウィザードのConfigure keyステップ。対称キータイプ、暗号化と復号のキー使用法、単一リージョンキーが選択されています。](https://platform.claude.com/docs/images/cmek/aws-configure-key.png)
    </Frame>

    <Frame caption="キーのエイリアスと説明を追加します。">
      ![AWS KMSのAdd labelsステップ。エイリアスにanthropic-cmek、説明にAnthropic CMEKが入力されています。](https://platform.claude.com/docs/images/cmek/aws-add-labels.png)
    </Frame>

    <Frame caption="キー管理権限を定義します（オプション）。アカウントは完全な管理制御を保持します。">
      ![AWS KMSのDefine key administrative permissionsステップ。キーを管理できるIAMロールが一覧表示されています。](https://platform.claude.com/docs/images/cmek/aws-admin-permissions.png)
    </Frame>

    <Frame caption="ここにAnthropicのアカウントIDを追加しないでください。このウィザードステップは過度に許可されたポリシーを生成します。使用権限を空のままにして、作成後にKey policy JSONを編集してください（前述のキーポリシーを参照）。">
      ![AWS KMSのDefine key usage permissionsステップ。Other AWS accountsの下にAnthropicのアカウントIDが入力されています。](https://platform.claude.com/docs/images/cmek/aws-usage-permissions.png)
    </Frame>
  </Step>
</Steps>

## Anthropicにキーを登録する

キーの登録方法は、使用する製品によって異なります。

<Tabs>
  <Tab title="Claude Platform">
    <Note>
      **Claude Platform on AWS:** プリンシパル、キーポリシー、登録フローが異なり、個別の検証ステップはありません。このタブではなく、[Claude Platform on AWSでCMEKを設定する](https://platform.claude.com/docs/ja/manage-claude/cmek-aws-kms#claude-platform-on-aws)に従ってください。
    </Note>

    <Note>
      **コンパートメントIDの確認方法:** 各ワークスペースには、そのCMEKデータのスコープを定めるコンパートメントIDがあります。Claude Consoleで確認するには、[Data retention](https://platform.claude.com/settings/privacy)ページ（`platform.claude.com/settings/privacy`）に移動し、ページ上部のドロップダウンメニューからワークスペースを選択します。IDは**Encryption key**の下の**Compartment ID**フィールドにあります。[Get Workspace](https://platform.claude.com/docs/ja/api/organization/workspaces/retrieve)エンドポイントが返す`compartment_id`フィールドを読み取ることもできます。
    </Note>

    Claude ConsoleまたはAdmin APIを通じてキーをセットアップでき、結果は同じです。

    <Tabs>
      <Tab title="Claude Console">
        <Steps>
          <Step title="Anthropicにキーを登録する">
            Claude Consoleで、[Data retention](https://platform.claude.com/settings/privacy#encryption-keys)ページ（`platform.claude.com/settings/privacy`）に移動します。**Encryption keys**が表示されない場合は、ページ上部のドロップダウンメニューから**Organization**を選択します。**Encryption keys**の下で**Add key**をクリックします。表示名を入力し、**AWS KMS**を選択して**Continue**をクリックします。キーARNを**KMS key ARN**に貼り付け、**Add**をクリックします。

            キー詳細ステップには組織IDが表示されます。**Add**をクリックする前に、それを[キーポリシー](https://platform.claude.com/docs/ja/manage-claude/cmek-aws-kms#key-policy)に追加してください。
          </Step>

          <Step title="キーを検証する">
            **Encryption keys**リストで、キーの横にある**Verify**をクリックします。チェックに合格すると**Connected**が表示されます。失敗した場合は、メッセージに理由が表示されます。
          </Step>

          <Step title="キーをワークスペースにアタッチする">
            Claude Consoleで、[Data retention](https://platform.claude.com/settings/privacy)ページ（`platform.claude.com/settings/privacy`）に移動し、ページ上部のドロップダウンメニューからワークスペースを選択します。**Encryption key**の下でキーを選択し、**Save**をクリックして確認します。キーのアタッチは元に戻せません。すでにリクエストを受信しているワークスペースの場合、キーが[有効になるまで最大1日](https://platform.claude.com/docs/ja/manage-claude/cmek#how-it-works)かかることがあります。
          </Step>
        </Steps>
      </Tab>

      <Tab title="API">
        <Steps>
          <Step title="Anthropicにキーを登録する">
            Admin APIを通じて外部キー設定を作成します。

            <CodeGroup>
              ```bash cURL
              curl -sS "https://api.anthropic.com/v1/organizations/external_keys" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01" \
                -H "content-type: application/json" \
                -d '{
                  "display_name": "<friendly-name>",
                  "geo": "us",
                  "provider_config": {
                    "type": "aws",
                    "kms_arn": "<key-arn-from-create-key-step>"
                  }
                }'
              ```

              ```bash CLI
              ant organization:external-keys create <<'YAML'
              display_name: "<friendly-name>"
              geo: us
              provider_config:
                type: aws
                kms_arn: "<key-arn-from-create-key-step>"
              YAML
              ```

              ```python Python
              client = anthropic.Anthropic()

              external_key = client.organization.external_keys.create(
                  display_name="<friendly-name>",
                  geo="us",
                  provider_config={"type": "aws", "kms_arn": "<key-arn-from-create-key-step>"},
              )

              print(f"id: {external_key.id}")
              print(f"display_name: {external_key.display_name}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const externalKey = await client.organization.externalKeys.create({
                display_name: "<friendly-name>",
                geo: "us",
                provider_config: {
                  type: "aws",
                  kms_arn: "<key-arn-from-create-key-step>"
                }
              });

              console.log(`id: ${externalKey.id}`);
              console.log(`display_name: ${externalKey.display_name}`);
              ```

              ```csharp C#
              using Anthropic.Models.Organization.ExternalKeys;

              AnthropicClient client = new();

              var externalKey = await client.Organization.ExternalKeys.Create(new()
              {
                  DisplayName = "<friendly-name>",
                  Geo = Geo.Us,
                  ProviderConfig = new AwsExternalKeyConfig
                  {
                      KmsArn = "<key-arn-from-create-key-step>"
                  }
              });

              Console.WriteLine($"id: {externalKey.ID}");
              Console.WriteLine($"display_name: {externalKey.DisplayName}");
              ```

              ```go Go
              client := anthropic.NewClient()

              externalKey, err := client.Organization.ExternalKeys.New(context.Background(), anthropic.OrganizationExternalKeyNewParams{
              	DisplayName: anthropic.String("<friendly-name>"),
              	Geo:         anthropic.OrganizationExternalKeyNewParamsGeoUs,
              	ProviderConfig: anthropic.OrganizationExternalKeyNewParamsProviderConfigUnion{
              		OfAWS: &anthropic.AWSExternalKeyConfigParam{
              			KMSARN: "<key-arn-from-create-key-step>",
              		},
              	},
              })
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("id: %s\n", externalKey.ID)
              fmt.Printf("display_name: %s\n", externalKey.DisplayName)
              ```

              ```java Java
              import com.anthropic.models.organization.externalkeys.AwsExternalKeyConfig;
              import com.anthropic.models.organization.externalkeys.ExternalKeyCreateParams;

              void main() {
                  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

                  var params = ExternalKeyCreateParams.builder()
                      .displayName("<friendly-name>")
                      .geo(ExternalKeyCreateParams.Geo.US)
                      .providerConfig(AwsExternalKeyConfig.builder()
                          .kmsArn("<key-arn-from-create-key-step>")
                          .build())
                      .build();
                  var externalKey = client.organization().externalKeys().create(params);

                  IO.println("id: " + externalKey.id());
                  IO.println("display_name: " + externalKey.displayName().orElseThrow());
              }
              ```

              ```php PHP
              use Anthropic\Organization\ExternalKeys\ExternalKeyCreateParams\Geo;
              // ...

              $client = new Client();

              $externalKey = $client->organization->externalKeys->create(
                  displayName: '<friendly-name>',
                  geo: Geo::US,
                  providerConfig: [
                      'type' => 'aws',
                      'kmsARN' => '<key-arn-from-create-key-step>',
                  ],
              );

              echo "id: {$externalKey->id}\n";
              echo "display_name: {$externalKey->displayName}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              external_key = client.organization.external_keys.create(
                display_name: "<friendly-name>",
                geo: :us,
                provider_config: {
                  type: :aws,
                  kms_arn: "<key-arn-from-create-key-step>"
                }
              )

              puts "id: #{external_key.id}"
              puts "display_name: #{external_key.display_name}"
              ```
            </CodeGroup>

            レスポンスには外部キーIDが含まれます。

            ```json
            {
              "type": "external_key",
              "id": "ekey_<id>",
              "display_name": "<friendly-name>"
            }
            ```
          </Step>

          <Step title="キーを検証する">
            キーに対して暗号化と復号のラウンドトリップをトリガーします。

            <CodeGroup>
              ```bash cURL
              curl -sS -X POST "https://api.anthropic.com/v1/organizations/external_keys/ekey_<id>/validate" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01"
              ```

              ```bash CLI
              ant organization:external-keys validate --external-key-id "ekey_<id>"
              ```

              ```python Python
              client = anthropic.Anthropic()

              validation = client.organization.external_keys.validate("ekey_<id>")

              print(f"status: {validation.status}")
              print(f"error: {validation.error}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const validation = await client.organization.externalKeys.validate("ekey_<id>");

              console.log(`status: ${validation.status}`);
              console.log(`error: ${validation.error}`);
              ```

              ```csharp C#
              AnthropicClient client = new();

              var validation = await client.Organization.ExternalKeys.Validate("ekey_<id>");

              Console.WriteLine($"status: {validation.Status.Raw()}");
              Console.WriteLine($"error: {validation.Error}");
              ```

              ```go Go
              client := anthropic.NewClient()

              validation, err := client.Organization.ExternalKeys.Validate(context.Background(), "ekey_<id>")
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("status: %s\n", validation.Status)
              fmt.Printf("error: %s\n", validation.Error)
              ```

              ```java Java
              AnthropicClient client = AnthropicOkHttpClient.fromEnv();

              var validation = client.organization().externalKeys().validate("ekey_<id>");

              IO.println("status: " + validation.status().asString());
              IO.println("error: " + validation.error().orElse(""));
              ```

              ```php PHP
              $client = new Client();

              $validation = $client->organization->externalKeys->validate(
                  externalKeyID: 'ekey_<id>',
              );

              echo "status: {$validation->status}\n";
              echo "error: {$validation->error}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              external_key_id = "ekey_<id>"
              validation = client.organization.external_keys.validate(external_key_id)

              puts "status: #{validation.status}"
              puts "error: #{validation.error}"
              ```
            </CodeGroup>

            成功したレスポンスは次のようになります。

            ```json
            { "type": "external_key_validation", "status": "success", "error": null }
            ```

            検証が失敗した場合、一般的な原因は次のとおりです。

            * **暗号化コンテキストの不一致:** ポリシーに`kms:EncryptionContext:anthropic:compartment_uuid`条件がある場合、キーがアタッチされている各ワークスペースのコンパートメントIDがリストされていることを確認してください。検証はチェックするワークスペースのコンパートメントIDを送信します。コンパートメントステートメントがまだ`kms:Encrypt`を許可している古いキーは、アタッチされていない間はすべてゼロの値（`00000000-0000-0000-0000-000000000000`）で検証されるため、その値をリストに保持してください。
            * **リソースコントロールポリシー（RCP）:** AWS組織に`aws:PrincipalOrgID`が組織と一致しない場合にKMS操作を拒否するRCPがある場合、Anthropicのクロスアカウントロールをブロックします。RCPにはこのキーまたはAnthropicのロールARNの例外が必要です。サービスコントロールポリシーはここでは適用されません。なぜなら、リソースベースのポリシーを通じて呼び出す外部プリンシパルに対しては評価されないからです。
            * **キーポリシーではなくIAMを通じて付与されたアクセス:** クロスアカウントKMSアクセスは、アカウント内のIAMポリシーを通じてではなく、キーポリシー自体で付与する必要があります。`aws kms get-key-policy --key-id <id> --policy-name default`で確認してください。
            * **リージョンの不一致:** キーのリージョンが、設定した地理ティアでAnthropicが運用しているリージョンの1つであることを確認してください。
          </Step>

          <Step title="キーをワークスペースにアタッチする">
            キーが検証されたら、そのワークスペースにリクエストを送信する前に、新しいワークスペースにアタッチします。すでにリクエストを受信しているワークスペースの場合、キーが[有効になるまで最大1日かかる](https://platform.claude.com/docs/ja/manage-claude/cmek#how-it-works)ことがあります。

            <CodeGroup>
              ```bash cURL
              curl -sS -X POST "https://api.anthropic.com/v1/organizations/workspaces/<workspace-id>" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01" \
                -H "content-type: application/json" \
                -d '{
                  "external_key_id": "ekey_<id>"
                }'
              ```

              ```bash CLI
              ant organization:workspaces update \
                --workspace-id "<workspace-id>" \
                --external-key-id "ekey_<id>"
              ```

              ```python Python
              client = anthropic.Anthropic()

              workspace = client.organization.workspaces.update(
                  "<workspace-id>", external_key_id="ekey_<id>"
              )

              print(f"id: {workspace.id}")
              print(f"external_key_id: {workspace.external_key_id}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const workspace = await client.organization.workspaces.update("<workspace-id>", {
                external_key_id: "ekey_<id>"
              });

              console.log(`id: ${workspace.id}`);
              console.log(`external_key_id: ${workspace.external_key_id}`);
              ```

              ```csharp C#
              AnthropicClient client = new();

              var workspace = await client.Organization.Workspaces.Update("<workspace-id>", new()
              {
                  ExternalKeyID = "ekey_<id>"
              });

              Console.WriteLine($"id: {workspace.ID}");
              Console.WriteLine($"external_key_id: {workspace.ExternalKeyID}");
              ```

              ```go Go
              client := anthropic.NewClient()

              workspace, err := client.Organization.Workspaces.Update(
              	context.Background(),
              	"<workspace-id>",
              	anthropic.OrganizationWorkspaceUpdateParams{
              		ExternalKeyID: anthropic.String("ekey_<id>"),
              	},
              )
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("id: %s\n", workspace.ID)
              fmt.Printf("external_key_id: %s\n", workspace.ExternalKeyID)
              ```

              ```java Java
              import com.anthropic.models.organization.workspaces.WorkspaceUpdateParams;

              void main() {
                  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

                  var params = WorkspaceUpdateParams.builder()
                      .externalKeyId("ekey_<id>")
                      .build();
                  var workspace = client.organization().workspaces().update("<workspace-id>", params);

                  IO.println("id: " + workspace.id());
                  IO.println("external_key_id: " + workspace.externalKeyId().orElseThrow());
              }
              ```

              ```php PHP
              $client = new Client();

              $workspace = $client->organization->workspaces->update(
                  workspaceID: '<workspace-id>',
                  externalKeyID: 'ekey_<id>',
              );

              echo "id: {$workspace->id}\n";
              echo "external_key_id: {$workspace->externalKeyID}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              workspace_id = "<workspace-id>"
              workspace = client.organization.workspaces.update(
                workspace_id,
                external_key_id: "ekey_<id>"
              )

              puts "id: #{workspace.id}"
              puts "external_key_id: #{workspace.external_key_id}"
              ```
            </CodeGroup>
          </Step>
        </Steps>
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="Claude Enterprise">
    [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls)で、**Encryption keys**を開き、**Add key**をクリックします。**AWS**を選択して**Continue**をクリックし、前のステップのKey ARNを貼り付けて**Add**をクリックします。Anthropicは暗号化と復号のラウンドトリップでキーを検証します。検証済みと表示されると、その時点から組織はCMEKで保護されます。

    このフローのキー詳細ステップには、コピーボタン付きで**Organization ID for the key policy**が表示されます。その値をキーポリシーの`<ORGANIZATION_UUID>`に置き換えます。キーを作成する前にフローを開いてIDをコピーできます。

    Claude Enterpriseでは、CMEKは組織全体に適用されるため、個別のワークスペースアタッチステップはなく、組織は1つのキーのみを持つことができます。
  </Tab>
</Tabs>

## Claude Platform on AWSでCMEKを設定する

[Claude Platform on AWS](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws)では、CMEKはAWS KMSキーのみを使用し、セットアップは前述のセクションと次の点で異なります。

* **プリンシパル:** キーポリシーはAWSサービスプリンシパル`aws-external-anthropic.amazonaws.com`にアクセスを付与します。AnthropicのIAMロールとアカウントIDは使用されないため、[Anthropic用のARN](https://platform.claude.com/docs/ja/manage-claude/cmek-aws-kms#amazon-resource-name-arn-for-anthropic)は適用されません。
* **キー要件:** キーは、暗号化と復号の使用法を持つ対称KMSキーで、単一リージョンであり、アタッチするワークスペースと同じAWSアカウントおよびリージョンにある必要があります。クロスアカウントキーはサポートされていません。キーは組織をホストするAWSアカウントにある必要があります。マルチリージョンキー（`mrk-`で始まるキーID）とエイリアスARNは、キーを登録するときに拒否されます。キーARNを使用してください。
* **個別の検証ステップなし:** 登録時のキーARNに対するこれらのチェックを除き、キーはワークスペースにアタッチするときに検証されます。アタッチ呼び出しは、そのワークスペースのコンパートメントIDを暗号化コンテキストとしてキーに対して暗号化/復号ラウンドを実行するため、キーポリシーの問題は登録時ではなくアタッチ時に表面化します。したがって、`EncryptionContext`条件にはすべてゼロのエントリは必要ありません。
* **キーの管理場所:** Adminロールを使用してAWS経由でサインインし、Claude Consoleでキーを登録してアタッチします。外部キーエンドポイントはClaude Platform on AWSでも利用可能で、[IAMアクション](https://platform.claude.com/docs/ja/api/claude-platform-on-aws-iam-actions#encryption-keys)を通じて認可されます。そこでは、キーは`ekey_` IDではなくKMSキーARNで識別されます。

<Warning>
  この公開されたサービスプリンシパル名のみを使用してください。メール、チャット、またはオンボーディングチャネルで提供された識別子を決して信頼しないでください。
</Warning>

### 前提条件

* Claude Platform on AWS組織をホストするAWSアカウントで、KMSキーを作成しキーポリシーを設定する権限（`kms:CreateKey`および`kms:PutKeyPolicy`）を持つもの。
* Claude Platform on AWS用のClaude Consoleの**Admin**ロール。[Claude Consoleの使用](https://platform.claude.com/docs/ja/build-with-claude/claude-platform-on-aws#using-the-claude-console)を参照してください。
* Claude Consoleへのサインインに使用するIAMプリンシパルには、`aws-external-anthropic:AssumeConsole`に加えて、そこで実行する操作の[IAMアクション](https://platform.claude.com/docs/ja/api/claude-platform-on-aws-iam-actions#encryption-keys)が必要です。キーの登録、一覧表示、アタッチはAWSゲートウェイを経由するためです。キーの登録は`RegisterKey`（登録を表示するには`ListKeys`と`GetKey`）、キーのアタッチは`UpdateWorkspace`または`CreateWorkspace`です。外部キーアクション（および`CreateWorkspace`）はアカウントスコープであるため、`Resource: "*"`に対して付与してください。ワークスペースARNに限定されたポリシーにはこれらは含まれません。
* キーをワークスペースにアタッチするIAMプリンシパル（Claude Consoleにサインインしたアイデンティティ）について: キーに対する`kms:DescribeKey`、`kms:Encrypt`、および`kms:Decrypt`。アタッチ時には、サービスプリンシパルに加えて、プリンシパルのキーへのアクセスがチェックされます。
* オプション、Claude Consoleのキーピッカー用: サインインするプリンシパルの`kms:ListKeys`および`kms:DescribeKey`。これらがない場合は、代わりにキーARNを貼り付けてください。

### KMSキーを作成する

キーポリシーには3つのステートメントがあります。アカウントのルート管理者ステートメント、Claude Platform on AWSサービスプリンシパルがデータキーの暗号化、復号、生成を行えるようにするステートメント、そして`kms:DescribeKey`用の個別のステートメントです。暗号化ステートメントには、リストしたワークスペースにキーをバインドするオプションの`EncryptionContext`条件が含まれます。`DescribeKey`には`EncryptionContext`パラメータがなく、そのアクションに`EncryptionContext`条件を付けると常に拒否されるため、個別に付与されます。

ここに示すオプションの`EncryptionContext`条件を使用する予定の場合は、まずワークスペースを（キーなしで）作成し、そのコンパートメントIDをコピーして、`<compartment-uuid>`を置き換えてください。Claude ConsoleでIDを確認するには、[Data retention](https://platform.claude.com/settings/privacy)ページ（`platform.claude.com/settings/privacy`）に移動し、ページ上部のドロップダウンメニューからワークスペースを選択します。IDは**Encryption key**の下の**Compartment ID**フィールドにあります。[Get Workspace](https://platform.claude.com/docs/ja/api/organization/workspaces/retrieve)エンドポイントが返す`compartment_id`フィールドから読み取ることもできます。条件を使用する予定がない場合は、そのステートメントから`Condition`ブロックを削除してください。

```bash
export YOUR_ACCOUNT=$(aws sts get-caller-identity --query Account --output text)

aws kms create-key \
  --region <workspace-region> \
  --description "Anthropic CMEK (Claude Platform on AWS)" \
  --key-usage ENCRYPT_DECRYPT \
  --policy "{
    \"Version\": \"2012-10-17\",
    \"Statement\": [
      {
        \"Sid\": \"AccountRootAdmin\",
        \"Effect\": \"Allow\",
        \"Principal\": {\"AWS\": \"arn:aws:iam::${YOUR_ACCOUNT}:root\"},
        \"Action\": \"kms:*\",
        \"Resource\": \"*\"
      },
      {
        \"Sid\": \"AllowClaudePlatformOnAWSCrypto\",
        \"Effect\": \"Allow\",
        \"Principal\": {\"Service\": \"aws-external-anthropic.amazonaws.com\"},
        \"Action\": [\"kms:Encrypt\", \"kms:Decrypt\", \"kms:GenerateDataKey\"],
        \"Resource\": \"*\",
        \"Condition\": {
          \"StringEquals\": {
            \"kms:EncryptionContext:anthropic:compartment_uuid\": [
              \"<compartment-uuid>\"
            ]
          }
        }
      },
      {
        \"Sid\": \"AllowClaudePlatformOnAWSDescribe\",
        \"Effect\": \"Allow\",
        \"Principal\": {\"Service\": \"aws-external-anthropic.amazonaws.com\"},
        \"Action\": \"kms:DescribeKey\",
        \"Resource\": \"*\"
      }
    ]
  }"
```

出力から`KeyMetadata.Arn`を取得します。キーを登録する際に必要になります。

`EncryptionContext`条件はオプションです。アタッチ時のチェックを含め、ワークスペースに対して行われるすべての暗号化、復号、データキーの呼び出しには、そのワークスペースのコンパートメントIDが`anthropic:compartment_uuid`として含まれます。そのため、条件にはキーをアタッチする各ワークスペースのコンパートメントIDを列挙し、すべてゼロのエントリは必要ありません。この条件を追加すると、IAMレイヤーでもリストしたワークスペースにキーがバインドされます。コンパートメントIDはワークスペースが存在して初めて存在するため、順序は次のとおりです。ワークスペースを作成し、そのコンパートメントIDを条件に入れ（キー作成時、または後で`kms:PutKeyPolicy`を使用して）、その後キーをアタッチします。追加の各ワークスペースにキーをアタッチする前に、同じ方法でそのワークスペースのコンパートメントIDを追加してください。条件なしで始めるには、`AllowClaudePlatformOnAWSCrypto`ステートメントから`Condition`ブロックを削除します。後で追加する場合は、キーがすでにアタッチされているすべてのワークスペースのコンパートメントIDを含めてください。

`aws:SourceArn`条件を使用して、両方のサービスプリンシパルステートメントをさらに制限できます。サービスは、キーを使用して行うすべての呼び出しで、[ワークスペースのARN](https://platform.claude.com/docs/ja/api/claude-platform-on-aws-iam-actions#service-details)（`arn:aws:aws-external-anthropic:<region>:<account-id>:workspace/<workspace-id>`）をソースARNとして渡します。そのため、`"ArnLike": {"aws:SourceArn": "arn:aws:aws-external-anthropic:*:<account-id>:workspace/*"}`は付与を自分のAWSアカウント内のワークスペースに限定し、完全なワークスペースARNのリストは付与をそれらのワークスペースに限定します。この条件は必須ではありません。`EncryptionContext`条件だけで、リストしたワークスペースにキーがバインドされます。

AWS Consoleからキーを作成することもできます。ワークスペースのリージョンで、暗号化と復号のキー使用法を持つ対称キー、単一リージョンキー、およびKMSキーマテリアルオリジンを選択します。キー作成ウィザードでキー使用権限を空のままにして、キーの**Key policy**タブを開き、JSONをここに示すポリシーに置き換えます。

### キーを登録してアタッチする

<Steps>
  <Step title="キーを登録する">
    Claude Consoleで、[Data retention](https://platform.claude.com/settings/privacy#encryption-keys)ページ（`platform.claude.com/settings/privacy`）に移動します。**Encryption keys**が表示されない場合は、ページ上部のドロップダウンメニューから**Organization**を選択します。**Encryption keys**の下で**Add key**をクリックします。表示名を入力し、キーピッカーからキーを選択するか、**Enter ARN manually**を選択してキーARNを貼り付け、**Add**をクリックします。キーは組織をホストするAWSアカウントにある必要があります。クロスアカウントキーはサポートされていません。ピッカーには、組織のいずれかのリージョンにある、アカウント内の有効な顧客管理の対称単一リージョンキーが一覧表示されます。ピッカーに表示されないキーの場合は、ARNを入力してください。ピッカーにキーが表示されるのは、サインインに使用したプリンシパルが`kms:ListKeys`と`kms:DescribeKey`を呼び出せる場合のみです。
  </Step>

  <Step title="キーをワークスペースにアタッチする">
    新しいワークスペースにリクエストを送信する前に、そのワークスペースにキーをアタッチします。すでにリクエストを受信しているワークスペースの場合、キーが[有効になるまで最大1日](https://platform.claude.com/docs/ja/manage-claude/cmek#how-it-works)かかることがあります。Claude Consoleで、[Data retention](https://platform.claude.com/settings/privacy)ページ（`platform.claude.com/settings/privacy`）に移動し、ページ上部のドロップダウンメニューからワークスペースを選択します。**Encryption key**の下でキーを選択し、**Save**をクリックして確認します。Claude Consoleでワークスペースを作成するときにキーを選択することもできますが、ワークスペースのコンパートメントIDは作成時に割り当てられるため、キーポリシーがまだ特定のワークスペースを指定していない場合（`EncryptionContext`条件がない場合）に限ります。一度アタッチすると、ワークスペースのキーは変更できません。

    これがキーが検証されるときです。アタッチ呼び出しは、プリンシパルのキーへのアクセスをチェックし、ワークスペースのコンパートメントIDを暗号化コンテキストとしてキーに対して暗号化/復号ラウンドを実行するため、キーポリシーまたはプリンシパルの権限のいずれかの問題がその呼び出しでエラーとして表面化します。アタッチがKMSアクセスエラーで失敗した場合は、次を確認してください。

    * キーポリシーが`aws-external-anthropic.amazonaws.com`サービスプリンシパルを指定し、`kms:Encrypt`、`kms:Decrypt`、および`kms:GenerateDataKey`を付与し、さらに`EncryptionContext`条件のない個別のステートメントで`kms:DescribeKey`を付与していること。
    * `EncryptionContext`条件を使用している場合は、その条件にこのワークスペースのコンパートメントIDが含まれていること。`aws:SourceArn`条件を追加した場合は、その条件がこのワークスペースのARNと一致していること。
    * キーが有効で、単一リージョンであり、ワークスペースと同じAWSアカウントおよびリージョンにあること。
    * サインインしているプリンシパルがキーに対する`kms:DescribeKey`、`kms:Encrypt`、および`kms:Decrypt`を持っていること。
    * AWS組織内のサービスコントロールポリシーまたはリソースコントロールポリシーが、サービスプリンシパルまたはプリンシパルがキーを使用することを妨げていないこと。
    * ポリシーが正しいように見えてもアタッチが失敗する場合は、キーのアカウントのCloudTrailで拒否された`kms:`イベントを見つけ（呼び出し元のプリンシパルと、暗号化呼び出しの場合は暗号化コンテキストが表示されます）、`kms:PutKeyPolicy`で条件を修正して再試行してください。
  </Step>
</Steps>

## Terraform

Infrastructure-as-codeデプロイメントの場合、同じ手順は`aws_kms_key`および`aws_kms_alias`リソースを持つ`aws`プロバイダーにマッピングされます。
