---
title: 為 CMEK 設定 Azure Key Vault
url: https://platform.claude.com/docs/zh-TW/manage-claude/cmek-azure-key-vault
description: 使用 Azure Key Vault 為您的組織提供加密金鑰。
---

讓 Claude Code 為您設定此功能

```text
/claude-api 協助我使用 Azure Key Vault 設定客戶管理的加密金鑰
```

本指南將逐步說明如何將 Azure Key Vault 金鑰設定為您 Anthropic 組織的[客戶管理加密金鑰（customer-managed encryption key，CMEK）](https://platform.claude.com/docs/zh-TW/manage-claude/cmek)。

<Warning>
  啟用 CMEK 是永久性的。如果您的 Key Vault 金鑰被刪除或停用，Anthropic 將無法復原以該金鑰加密的資料。在開始之前，請先檢閱[警告與限制](https://platform.claude.com/docs/zh-TW/manage-claude/cmek)。
</Warning>

## 先決條件

* 一個已**啟用 RBAC 授權**（`enableRbacAuthorization: true`）且**允許公開網路存取**的 Azure Key Vault。Anthropic 透過公開資料平面端點呼叫您的保存庫；不支援私有端點。
* 保存庫上已**啟用清除保護**（`enablePurgeProtection: true`）。若沒有啟用，已刪除的金鑰可能在軟刪除保留期間內被永久清除，導致您受 CMEK 保護的資料發生不可逆的遺失。清除保護一旦啟用便無法停用。
* 在保存庫中建立金鑰以及在其上指派 RBAC 角色的權限。
* 在您的 Entra 租用戶中建立服務主體的權限（`Application Administrator`、`Cloud Application Administrator` 或同等的自訂角色）。
* 您組織的 Anthropic Admin API 金鑰。
* 已安裝並通過驗證的 [`az` CLI](https://learn.microsoft.com/en-us/cli/azure/?view=azure-cli-latest)。
* 在保存庫上設定的**診斷設定（Diagnostic Settings）**，將 `AuditEvent` 記錄類別路由至 Log Analytics、儲存體帳戶或事件中樞。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 多租用戶應用程式">
    這會在您的 Entra 租用戶中為 Anthropic 的 CMEK 用戶端應用程式建立一個服務主體。該應用程式不要求任何 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
    ```

    此步驟沒有入口網站的對應操作。如果您本機未安裝 Azure CLI，請從入口網站頂部導覽列開啟 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="在您的保存庫中建立 RSA 金鑰">
    Azure Key Vault 不支援對稱金鑰包裝，因此金鑰必須是 RSA（3072 位元或更大），且其允許的操作中包含 `wrapKey` 和 `unwrapKey`。

    `--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`）上的 **Organization ID** 欄位，或 claude.ai 中 **Organization settings > Organization** 下的該欄位，或從 [Organization Info](https://platform.claude.com/docs/zh-TW/api/organization/retrieve) 端點讀取 `id` 欄位。請使用純 UUID，而非帶有 `org_` 前綴的 ID。
    </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 保存庫）。軟體保護的 RSA 金鑰對於此整合是可接受的。

    從入口網站中，開啟您的 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>

    若要在多個 Anthropic 組織之間共用一個金鑰，請為每個組織新增一個這樣的標籤。一個金鑰版本最多可攜帶 15 個標籤，包括您自己的標籤。

    <Note>
      若要將標籤新增至您已擁有的金鑰，請在入口網站中開啟金鑰的目前版本，選擇 **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 中的金鑰，請使用 `--hsm-name <HSM_NAME>` 而非 `--vault-name`。
    </Note>
  </Step>

  <Step title="授予 Anthropic 服務主體存取您金鑰的權限">
    將 `Key Vault Crypto User` 角色指派給第一步中的服務主體，範圍限定於**個別金鑰**而非整個保存庫。

    ```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 只能進行包裝和解除包裝。

    從入口網站中，開啟**金鑰**（而非保存庫），選擇其 **Access control (IAM)** 索引標籤，按一下 **Add > Add role assignment**，選擇 **Key Vault Crypto User**，並將其指派給 `anthropic-cmek-client-us` 服務主體。

    <Note>
      **專用保存庫替代方案：** Microsoft 建議每個應用程式使用專用保存庫，並在保存庫範圍指派角色。如果您佈建一個僅保存此 Anthropic CMEK 金鑰的保存庫，您可以改為在保存庫範圍指派角色，效果完全相同。當金鑰位於共用保存庫中時，請將範圍限定於個別金鑰。
    </Note>

    <Frame caption="將 Key Vault Crypto User 指派給 Anthropic 服務主體，範圍限定於金鑰。">
      ![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="驗證您的保存庫設定">
    ```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`，請在繼續之前於保存庫上啟用清除保護。若沒有啟用，軟刪除的金鑰可能在保留期間內被永久清除，使您受 CMEK 保護的資料無法復原。
    * `pub` 為 `"Enabled"`。如果它是 `"Disabled"`，Anthropic 無法透過其公開資料平面端點連接保存庫，驗證將失敗。
    * `net` 為 `"Allow"`，或者，如果它是 `"Deny"`，則 `ipRules` 包含 Anthropic 的輸出範圍（請聯絡 Anthropic 取得目前清單）。
    * `uri` 是您註冊金鑰時使用的保存庫 URI。
    * `tenantId` 是管理保存庫的租用戶。註冊金鑰時請使用此值作為 `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/zh-TW/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** 並確認。附加金鑰後無法復原。對於已在接收請求的工作區，金鑰可能需要[最多一天才會生效](https://platform.claude.com/docs/zh-TW/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 傳播延遲：** 角色指派可能需要幾分鐘才能生效。請等待並重試。
            * **網路 ACL 封鎖 Anthropic：** 依照驗證步驟中的說明確認公開網路存取和 `ipRules`。
            * **工作負載身分上的條件式存取原則：** 如果您的租用戶有針對服務主體的條件式存取原則，請排除 Anthropic 服務主體，或將 Anthropic 的輸出範圍新增至原則的具名位置。
          </Step>

          <Step title="將金鑰附加至工作區">
            金鑰驗證後，在您向該工作區傳送任何請求之前，將其附加至新工作區。對於已接收請求的工作區，金鑰可能需要[最多一天才能生效](https://platform.claude.com/docs/zh-TW/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**，輸入驗證步驟中的保存庫 URI、金鑰名稱和租用戶 ID，然後按一下 **Continue**。Anthropic 會透過加密和解密的往返操作驗證金鑰。一旦顯示為已驗證，您的組織從該時間點起即受 CMEK 保護。

    在 Claude Enterprise 上，CMEK 適用於整個組織，因此沒有單獨的工作區附加步驟，且一個組織只能有一個金鑰。
  </Tab>
</Tabs>

## Terraform

對於基礎架構即程式碼（infrastructure-as-code）部署，相同的步驟對應至 `azurerm` 和 `azuread` 提供者。