---
title: CMEK用のAzure Key Vaultの設定
url: https://platform.claude.com/docs/ja/manage-claude/cmek-azure-key-vault
description: Azure Key Vaultを使用して、組織の暗号化キーを提供します。
---

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

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

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

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

## 前提条件

* **RBAC認可が有効**（`enableRbacAuthorization: true`）で、**パブリックネットワークアクセスが許可されている**Azure Key Vault。Anthropicはパブリックデータプレーンエンドポイント経由でvaultを呼び出します。プライベートエンドポイントはサポートされていません。
* vaultで**パージ保護が有効**（`enablePurgeProtection: true`）であること。これがないと、削除されたキーがソフト削除の保持期間中に完全にパージされ、CMEK保護されたデータが回復不能な損失を被る可能性があります。パージ保護は一度有効にすると無効化できません。
* vaultでキーを作成し、RBACロールを割り当てる権限。
* Entraテナントでサービスプリンシパルを作成する権限（`Application Administrator`、`Cloud Application Administrator`、または同等のカスタムロール）。
* 組織のAnthropic Admin APIキー。
* [`az` CLI](https://learn.microsoft.com/en-us/cli/azure/?view=azure-cli-latest)がインストールされ、認証されていること。
* `AuditEvent`ログカテゴリをLog Analytics、ストレージアカウント、またはイベントハブにルーティングするようにvaultで**診断設定**が構成されていること。Azure Key Vaultはデフォルトではデータプレーン監査ログ（`KeyWrap`、`KeyUnwrap`、`KeyGet`など）を出力しないため、これがないとAnthropicのキー操作の監査証跡が得られません。

## Anthropicアプリ情報

Anthropicに暗号化キーを使用させるには、AnthropicのマルチテナントアプリケーションIDと表示名を設定する必要があります。それらの値は次のとおりです。

| フィールド                  | 値                                      |
| ---------------------- | -------------------------------------- |
| マルチテナントアプリクライアントID（US） | `8635ae1a-3e5d-44e8-a4ed-e0f614466f87` |
| アプリ表示名                 | `anthropic-cmek-client-us`             |

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

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

<Steps>
  <Step title="Anthropicマルチテナントアプリケーションへの同意">
    これにより、AnthropicのCMEKクライアントアプリケーション用のサービスプリンシパルがEntraテナントに作成されます。このアプリケーションはMicrosoft Graphの権限を要求しません。Key Vaultデータプレーンアクセスのフェデレーションターゲットとしてのみ存在します。

    ```bash
    az ad sp create --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87
    ```

    出力から`id`フィールドを取得します。これはテナント内のサービスプリンシパルのオブジェクトIDで、RBACロールを割り当てる際に使用します。

    ```json
    {
      "appId": "8635ae1a-3e5d-44e8-a4ed-e0f614466f87",
      "displayName": "anthropic-cmek-client-us",
      "id": "<sp-object-id>"
    }
    ```

    サービスプリンシパルがすでにテナントに存在する場合（以前の試行や別の統合から）、`az ad sp create`は「already exists」エラーで終了します。代わりにそのオブジェクトIDを取得してください。

    ```bash
    az ad sp show --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 --query id -o tsv
    ```

    このステップにはPortalの同等の操作はありません。Azure CLIがローカルにインストールされていない場合は、Portalの上部ナビゲーションバーからCloud Shellを開いてください。コマンドが成功した後、**Microsoft Entra ID > エンタープライズアプリケーション**でデフォルトのアプリケーションタイプフィルターをクリアし、`anthropic-cmek-client-us`を検索することで、サービスプリンシパルのオブジェクトIDを見つけることができます。

    <Frame caption="Entraエンタープライズアプリケーションの概要でサービスプリンシパルのObject IDを見つけます。">
      ![anthropic-cmek-client-usのMicrosoft Entraエンタープライズアプリケーションの概要。Application IDとObject IDが表示されています。](https://platform.claude.com/docs/images/cmek/azure-service-principal.png)
    </Frame>
  </Step>

  <Step title="vaultでRSAキーを作成する">
    Azure Key Vaultは対称キーラッピングをサポートしていないため、キーは許可された操作に`wrapKey`と`unwrapKey`を含むRSA（3072ビット以上）である必要があります。

    `--tags`オプションは、組織タグ`anthropic-org-<ORGANIZATION_UUID>`を値`true`で追加します。ここで`<ORGANIZATION_UUID>`は小文字のAnthropic組織IDです。このタグはAnthropicがキーを検証するために必要です。

    <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>

    ```bash
    az keyvault key create \
      --vault-name <VAULT_NAME> \
      --name <KEY_NAME> \
      --kty RSA --size 3072 \
      --ops wrapKey unwrapKey \
      --tags anthropic-org-<ORGANIZATION_UUID>=true
    ```

    HSMバックアップキーの場合は、`--kty RSA-HSM`を使用します（Premium-SKU vaultが必要）。この統合にはソフトウェア保護されたRSAキーで問題ありません。

    Portalから、Key Vaultを開き、**Keys**を選択してから**Generate/Import**を選択します。キータイプをRSAに、サイズを3072以上に設定します。キーをラップとアンラップのみに制限するには、キーバージョンを開き、**Permitted operations**までスクロールし、**Wrap Key**と**Unwrap Key**以外のすべてのチェックを外します。

    **Create a key**ページで、**Tags**の下に組織タグも追加します。

    <Frame caption="3072以上のサイズのRSAキーを作成し、タグanthropic-org-<ORGANIZATION_UUID>をtrueに設定します。">
      ![Azure Key VaultのCreate a keyページ。RSAとキーサイズ3072が選択され、anthropic-orgタグがtrueに設定されています。](https://platform.claude.com/docs/images/cmek/azure-create-key-tag.png)
    </Frame>

    <Frame caption="許可された操作をWrap KeyとUnwrap Keyに制限します。キーバージョンには組織タグが表示されます。">
      ![Azure Key Vaultのキーバージョン。タグが1つ設定され、Permitted operationsがWrap KeyとUnwrap Keyに制限されています。](https://platform.claude.com/docs/images/cmek/azure-permitted-operations-tag.png)
    </Frame>

    1つのキーを複数のAnthropic組織で共有するには、組織ごとにそのようなタグを1つ追加します。キーバージョンは、独自のものを含めて最大15個のタグを持つことができます。

    <Note>
      すでに持っているキーにタグを追加するには、Portalでキーの現在のバージョンを開き、**Tags**の横のリンクを選択し、タグを追加して**Save**をクリックします。Azure CLIでは、`az keyvault key set-attributes --vault-name <VAULT_NAME> --name <KEY_NAME> --tags anthropic-org-<ORGANIZATION_UUID>=true`を実行します。その`--tags`オプションはバージョンのタグを置き換えるため、バージョンがすでに持っている各タグも`name=value`として`--tags`に入れてください。Managed HSM内のキーの場合は、`--vault-name`の代わりに`--hsm-name <HSM_NAME>`を使用します。
    </Note>
  </Step>

  <Step title="Anthropicサービスプリンシパルにキーへのアクセスを付与する">
    最初のステップのサービスプリンシパルに`Key Vault Crypto User`ロールを割り当てます。vault全体ではなく**個別のキー**にスコープを設定します。

    ```bash
    VAULT_ID=$(az keyvault show --name <your-vault-name> --query id -o tsv)

    az role assignment create \
      --role "Key Vault Crypto User" \
      --assignee-object-id <sp-object-id> \
      --assignee-principal-type ServicePrincipal \
      --scope "${VAULT_ID}/keys/<your-key-name>"
    ```

    組み込みの`Key Vault Crypto User`ロールは、割り当てられたスコープでキーの暗号化操作（暗号化、復号化、ラップ、アンラップ、署名、検証）とキーの読み取りを付与します。前のステップでキーに設定した`--ops wrapKey unwrapKey`の制限により、このキーに対して成功できる操作がさらに絞り込まれるため、実際にはAnthropicはラップとアンラップのみを実行できます。

    Portalから、**キー**（vaultではなく）を開き、その**Access control (IAM)**&#x30BF;ブを選択し、**Add > Add role assignment**をクリックし、**Key Vault Crypto User**を選択して、`anthropic-cmek-client-us`サービスプリンシパルに割り当てます。

    <Note>
      **専用vaultの代替案:** Microsoftは、vaultスコープでロールを割り当てたアプリケーションごとの専用vaultを推奨しています。このAnthropic CMEKキーのみを保持するvaultをプロビジョニングする場合は、代わりにvaultスコープでロールを割り当てることができ、効果は同じです。キーが共有vaultに存在する場合は、個別のキーにスコープを設定してください。
    </Note>

    <Frame caption="AnthropicサービスプリンシパルにKey Vault Crypto Userを割り当て、キーにスコープを設定します。">
      ![Key VaultのIAMにおけるロールの割り当て。anthropic-cmek-client-usにKey Vault Crypto Userロールが割り当てられています。](https://platform.claude.com/docs/images/cmek/azure-role-assignment.png)
    </Frame>
  </Step>

  <Step title="vault構成を検証する">
    ```bash
    az keyvault show --name <your-vault-name> \
      --query "{rbac:properties.enableRbacAuthorization, purge:properties.enablePurgeProtection, pub:properties.publicNetworkAccess, net:properties.networkAcls.defaultAction, ipRules:properties.networkAcls.ipRules, uri:properties.vaultUri, tenantId:properties.tenantId}"
    ```

    次のことを確認します。

    * `rbac`が`true`であること。
    * `purge`が`true`であること。`false`または`null`の場合は、続行する前にvaultでパージ保護を有効にしてください。これがないと、ソフト削除されたキーが保持期間中に完全にパージされ、CMEK保護されたデータが回復不能になります。
    * `pub`が`"Enabled"`であること。`"Disabled"`の場合、Anthropicはパブリックデータプレーンエンドポイント経由でvaultに到達できず、検証が失敗します。
    * `net`が`"Allow"`であること、または`"Deny"`の場合は、`ipRules`にAnthropicのエグレス範囲が含まれていること（現在のリストについてはAnthropicにお問い合わせください）。
    * `uri`がキーを登録する際に使用するvault URIであること。
    * `tenantId`がvaultを管理するテナントであること。キーを登録する際は、現在アクティブなサブスクリプションのテナントではなく、この値を`tenant_id`として使用してください（クロステナント設定では両者が異なる場合があります）。
  </Step>
</Steps>

## Anthropicにキーを登録する

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

<Tabs>
  <Tab title="Claude Platform">
    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**をクリックします。表示名を入力し、**Azure Key Vault**を選択して**Continue**をクリックします。**Vault URI**、**Key name**、**Tenant ID**を入力し、**Add**をクリックします。

            キー詳細ステップには組織タグが表示されます。**Add**をクリックする前に、[作成ステップ](https://platform.claude.com/docs/ja/manage-claude/cmek-azure-key-vault#organization-tag)で説明されているようにキーに追加してください。
          </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": "azure",
                    "vault_uri": "https://<your-vault-name>.vault.azure.net/",
                    "key_name": "<your-key-name>",
                    "tenant_id": "<your-tenant-id>"
                  }
                }'
              ```

              ```bash CLI
              ant organization:external-keys create <<'YAML'
              display_name: "<friendly-name>"
              geo: us
              provider_config:
                type: azure
                vault_uri: "https://<your-vault-name>.vault.azure.net/"
                key_name: "<your-key-name>"
                tenant_id: "<your-tenant-id>"
              YAML
              ```

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

              external_key = client.organization.external_keys.create(
                  display_name="<friendly-name>",
                  geo="us",
                  provider_config={
                      "type": "azure",
                      "vault_uri": "https://<your-vault-name>.vault.azure.net/",
                      "key_name": "<your-key-name>",
                      "tenant_id": "<your-tenant-id>",
                  },
              )

              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: "azure",
                  vault_uri: "https://<your-vault-name>.vault.azure.net/",
                  key_name: "<your-key-name>",
                  tenant_id: "<your-tenant-id>"
                }
              });

              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 AzureExternalKeyConfigParam
                  {
                      VaultUri = "https://<your-vault-name>.vault.azure.net/",
                      KeyName = "<your-key-name>",
                      TenantID = "<your-tenant-id>"
                  }
              });

              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{
              		OfAzure: &anthropic.AzureExternalKeyConfigParam{
              			VaultURI: "https://<your-vault-name>.vault.azure.net/",
              			KeyName:  "<your-key-name>",
              			TenantID: "<your-tenant-id>",
              		},
              	},
              })
              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.AzureExternalKeyConfigParam;
              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(AzureExternalKeyConfigParam.builder()
                          .vaultUri("https://<your-vault-name>.vault.azure.net/")
                          .keyName("<your-key-name>")
                          .tenantId("<your-tenant-id>")
                          .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' => 'azure',
                      'vaultURI' => 'https://<your-vault-name>.vault.azure.net/',
                      'keyName' => '<your-key-name>',
                      'tenantID' => '<your-tenant-id>',
                  ],
              );

              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: :azure,
                  vault_uri: "https://<your-vault-name>.vault.azure.net/",
                  key_name: "<your-key-name>",
                  tenant_id: "<your-tenant-id>"
                }
              )

              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="キーを検証する">
            キーに対して暗号化と復号化のラウンドトリップをトリガーします。これにより、Anthropicがテナントに認証し、ラップとアンラップの操作を実行できることが確認されます。

            <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

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

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

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

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

            検証が失敗した場合、`error`フィールドに問題が記述されます。一般的な原因は次のとおりです。

            * **RBAC伝播の遅延:** ロールの割り当てが有効になるまで数分かかることがあります。待ってから再試行してください。
            * **AnthropicをブロックするネットワークACL:** 検証ステップで説明されているように、パブリックネットワークアクセスと`ipRules`を確認してください。
            * **ワークロードIDに対する条件付きアクセスポリシー:** テナントにサービスプリンシパルを対象とする条件付きアクセスポリシーがある場合は、Anthropicサービスプリンシパルを除外するか、ポリシーの名前付きの場所にAnthropicのエグレス範囲を追加してください。
          </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 = 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**をクリックします。**Azure**を選択し、検証ステップのvault URI、キー名、テナントIDを入力して、**Continue**をクリックします。Anthropicは暗号化と復号化のラウンドトリップでキーを検証します。検証済みと表示されると、その時点以降、組織はCMEK保護されます。

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

## Terraform

Infrastructure-as-codeデプロイメントの場合、同じステップが`azurerm`および`azuread`プロバイダーにマッピングされます。
