---
title: Mengonfigurasi Azure Key Vault untuk CMEK
url: https://platform.claude.com/docs/id/manage-claude/cmek-azure-key-vault
description: Gunakan Azure Key Vault untuk menyediakan kunci enkripsi bagi organisasi Anda.
---
Biarkan Claude Code menyiapkan fitur ini untuk Anda
```text
/claude-api bantu saya mengonfigurasi kunci enkripsi yang dikelola pelanggan dengan Azure Key Vault
```
Panduan ini memandu Anda mengonfigurasi kunci Azure Key Vault sebagai [customer-managed encryption key (CMEK)](https://platform.claude.com/docs/id/manage-claude/cmek) untuk organisasi Anthropic Anda.
Mengaktifkan CMEK bersifat permanen. Jika kunci Key Vault Anda dihapus atau dinonaktifkan, Anthropic tidak dapat memulihkan data yang dienkripsi dengannya. Tinjau [peringatan dan batasan](https://platform.claude.com/docs/id/manage-claude/cmek) sebelum Anda mulai.
## Prasyarat
* Sebuah Azure Key Vault dengan **otorisasi RBAC diaktifkan** (`enableRbacAuthorization: true`) dan **akses jaringan publik diizinkan**. Anthropic memanggil vault Anda melalui endpoint data-plane publik; private endpoint tidak didukung.
* **Perlindungan purge diaktifkan** (`enablePurgeProtection: true`) pada vault. Tanpa itu, kunci yang dihapus dapat di-purge secara permanen selama jendela retensi soft-delete, menyebabkan kehilangan data yang dilindungi CMEK Anda secara tidak dapat dipulihkan. Perlindungan purge tidak dapat dinonaktifkan setelah diaktifkan.
* Izin untuk membuat kunci di vault dan untuk menetapkan peran RBAC padanya.
* Izin untuk membuat service principal di tenant Entra Anda (`Application Administrator`, `Cloud Application Administrator`, atau peran kustom yang setara).
* Sebuah kunci Admin API Anthropic untuk organisasi Anda.
* [`az` CLI](https://learn.microsoft.com/en-us/cli/azure/?view=azure-cli-latest) terinstal dan terautentikasi.
* **Diagnostic Settings** dikonfigurasi pada vault untuk merutekan kategori log `AuditEvent` ke Log Analytics, akun penyimpanan, atau event hub. Azure Key Vault tidak memancarkan log audit data-plane (seperti `KeyWrap`, `KeyUnwrap`, dan `KeyGet`) secara default, jadi tanpa ini Anda tidak mendapatkan jejak audit untuk operasi kunci Anthropic.
## Informasi aplikasi Anthropic
Agar Anthropic menggunakan kunci enkripsi Anda, Anda harus mengonfigurasi ID aplikasi multitenant Anthropic dan nama tampilan. Nilai-nilai tersebut adalah:
| Field | Nilai |
| ----------------------------------- | -------------------------------------- |
| Client ID aplikasi multitenant (US) | `8635ae1a-3e5d-44e8-a4ed-e0f614466f87` |
| Nama tampilan aplikasi | `anthropic-cmek-client-us` |
Gunakan hanya client ID dan nama tampilan yang dipublikasikan ini. Jangan pernah mempercayai pengidentifikasi yang diberikan melalui email, chat, atau saluran onboarding apa pun.
## Penyiapan kunci enkripsi
Ini membuat service principal di tenant Entra Anda untuk aplikasi client CMEK Anthropic. Aplikasi tidak meminta izin Microsoft Graph; aplikasi ini ada semata-mata sebagai target federasi untuk akses data-plane Key Vault.
```bash
az ad sp create --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87
```
Dari output, tangkap field `id`. Ini adalah object ID service principal di tenant Anda, yang Anda gunakan saat menetapkan peran RBAC.
```json
{
"appId": "8635ae1a-3e5d-44e8-a4ed-e0f614466f87",
"displayName": "anthropic-cmek-client-us",
"id": ""
}
```
Jika service principal sudah ada di tenant Anda (dari upaya sebelumnya atau integrasi lain), `az ad sp create` keluar dengan error "already exists". Ambil object ID-nya sebagai gantinya:
```bash
az ad sp show --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 --query id -o tsv
```
Langkah ini tidak memiliki padanan di Portal. Jika Anda tidak memiliki Azure CLI terinstal secara lokal, buka Cloud Shell dari bilah navigasi atas Portal. Setelah perintah berhasil, Anda dapat menemukan object ID service principal di **Microsoft Entra ID > Enterprise applications** dengan menghapus filter tipe aplikasi default dan mencari `anthropic-cmek-client-us`.
Azure Key Vault tidak mendukung pembungkusan kunci simetris, jadi kunci harus berupa RSA (3072-bit atau lebih besar) dengan `wrapKey` dan `unwrapKey` dalam operasi yang diizinkannya.
Opsi `--tags` menambahkan tag organisasi, `anthropic-org-` dengan nilai `true`, di mana `` adalah ID organisasi Anthropic Anda dalam huruf kecil. Tag ini diperlukan agar Anthropic dapat memvalidasi kunci.
**Menemukan ID organisasi Anda:** Salin field **Organization ID** di halaman [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) di Claude Console, atau di bawah **Organization settings > Organization** di claude.ai, atau baca field `id` dari endpoint [Organization Info](https://platform.claude.com/docs/id/api/organization/retrieve). Gunakan UUID polos, bukan ID dengan awalan `org_`.
```bash
az keyvault key create \
--vault-name \
--name \
--kty RSA --size 3072 \
--ops wrapKey unwrapKey \
--tags anthropic-org-=true
```
Untuk kunci yang didukung HSM, gunakan `--kty RSA-HSM` (memerlukan vault Premium-SKU). Kunci RSA yang dilindungi perangkat lunak dapat diterima untuk integrasi ini.
Dari Portal, buka Key Vault Anda, pilih **Keys**, lalu **Generate/Import**. Atur tipe kunci ke RSA dan ukuran ke 3072 atau lebih besar. Untuk membatasi kunci hanya untuk wrap dan unwrap, buka versi kunci, gulir ke **Permitted operations**, dan hapus centang semuanya kecuali **Wrap Key** dan **Unwrap Key**.
Pada halaman **Create a key**, tambahkan juga tag organisasi di bawah **Tags**.
Untuk berbagi satu kunci di antara beberapa organisasi Anthropic, tambahkan satu tag semacam itu untuk setiap organisasi. Sebuah versi kunci dapat membawa paling banyak 15 tag, termasuk milik Anda sendiri.
Untuk menambahkan tag ke kunci yang sudah Anda miliki, buka versi kunci saat ini di Portal, pilih tautan di sebelah **Tags**, tambahkan tag, dan klik **Save**. Dengan Azure CLI, jalankan `az keyvault key set-attributes --vault-name --name --tags anthropic-org-=true`. Opsi `--tags`-nya menggantikan tag versi, jadi masukkan juga setiap tag yang sudah dimiliki versi tersebut di `--tags`, sebagai `name=value`. Untuk kunci di Managed HSM, gunakan `--hsm-name ` alih-alih `--vault-name`.
Tetapkan peran `Key Vault Crypto User` ke service principal dari langkah pertama, dengan cakupan ke **kunci individual** alih-alih seluruh vault.
```bash
VAULT_ID=$(az keyvault show --name --query id -o tsv)
az role assignment create \
--role "Key Vault Crypto User" \
--assignee-object-id \
--assignee-principal-type ServicePrincipal \
--scope "${VAULT_ID}/keys/"
```
Peran bawaan `Key Vault Crypto User` memberikan operasi kriptografi kunci (encrypt, decrypt, wrap, unwrap, sign, verify) ditambah pembacaan kunci pada cakupan yang ditetapkannya. Pembatasan `--ops wrapKey unwrapKey` yang Anda atur pada kunci di langkah sebelumnya lebih lanjut mempersempit operasi mana dari operasi tersebut yang dapat berhasil terhadap kunci ini, sehingga dalam praktiknya Anthropic hanya dapat melakukan wrap dan unwrap.
Dari Portal, buka **kunci** (bukan vault), pilih tab **Access control (IAM)**-nya, klik **Add > Add role assignment**, pilih **Key Vault Crypto User**, dan tetapkan ke service principal `anthropic-cmek-client-us`.
**Alternatif vault khusus:** Microsoft merekomendasikan vault khusus per aplikasi dengan peran yang ditetapkan pada cakupan vault. Jika Anda menyediakan vault yang hanya menyimpan kunci CMEK Anthropic ini, Anda dapat menetapkan peran pada cakupan vault sebagai gantinya dan efeknya identik. Cakupkan ke kunci individual ketika kunci berada di vault bersama.
```bash
az keyvault show --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}"
```
Konfirmasikan bahwa:
* `rbac` adalah `true`.
* `purge` adalah `true`. Jika `false` atau `null`, aktifkan perlindungan purge pada vault sebelum melanjutkan. Tanpa itu, kunci yang di-soft-delete dapat di-purge secara permanen selama jendela retensi, membuat data yang dilindungi CMEK Anda tidak dapat dipulihkan.
* `pub` adalah `"Enabled"`. Jika `"Disabled"`, Anthropic tidak dapat menjangkau vault melalui endpoint data-plane publiknya dan validasi gagal.
* `net` adalah `"Allow"`, atau, jika `"Deny"`, bahwa `ipRules` menyertakan rentang egress Anthropic (hubungi Anthropic untuk daftar terkini).
* `uri` adalah URI vault yang Anda gunakan saat mendaftarkan kunci.
* `tenantId` adalah tenant yang mengatur vault. Gunakan nilai ini sebagai `tenant_id` saat Anda mendaftarkan kunci, bukan tenant dari langganan yang sedang aktif saat ini (keduanya dapat berbeda dalam penyiapan lintas-tenant).
## Mendaftarkan kunci dengan Anthropic
Cara Anda mendaftarkan kunci bergantung pada produk mana yang Anda gunakan.
Anda dapat menyiapkan kunci di Claude Console atau melalui Admin API, dengan hasil yang sama.
Di Claude Console, buka halaman [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Jika Anda tidak melihat **Encryption keys**, pilih **Organization** dari menu dropdown di bagian atas halaman. Di bawah **Encryption keys**, klik **Add key**. Masukkan nama tampilan, pilih **Azure Key Vault**, lalu klik **Continue**. Isi **Vault URI**, **Key name**, dan **Tenant ID**, lalu klik **Add**.
Langkah detail kunci menampilkan tag organisasi. Tambahkan ke kunci, seperti yang dijelaskan [langkah pembuatan](https://platform.claude.com/docs/id/manage-claude/cmek-azure-key-vault#organization-tag), sebelum Anda klik **Add**.
Di daftar **Encryption keys**, klik **Verify** di sebelah kunci. **Connected** muncul ketika pemeriksaan berhasil. Jika gagal, sebuah pesan akan memberikan alasannya.
Di Claude Console, buka halaman [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) dan pilih workspace dari menu dropdown di bagian atas halaman. Di bawah **Encryption key**, pilih kunci, klik **Save**, lalu konfirmasi. Melampirkan kunci tidak dapat dibatalkan. Untuk workspace yang sudah menerima permintaan, kunci dapat memerlukan [hingga satu hari untuk berlaku](https://platform.claude.com/docs/id/manage-claude/cmek#how-it-works).
Buat konfigurasi kunci eksternal melalui Admin API.
```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": "",
"geo": "us",
"provider_config": {
"type": "azure",
"vault_uri": "https://.vault.azure.net/",
"key_name": "",
"tenant_id": ""
}
}'
```
```bash CLI
ant organization:external-keys create <<'YAML'
display_name: ""
geo: us
provider_config:
type: azure
vault_uri: "https://.vault.azure.net/"
key_name: ""
tenant_id: ""
YAML
```
```python Python
client = anthropic.Anthropic()
external_key = client.organization.external_keys.create(
display_name="",
geo="us",
provider_config={
"type": "azure",
"vault_uri": "https://.vault.azure.net/",
"key_name": "",
"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: "",
geo: "us",
provider_config: {
type: "azure",
vault_uri: "https://.vault.azure.net/",
key_name: "",
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 = "",
Geo = Geo.Us,
ProviderConfig = new AzureExternalKeyConfigParam
{
VaultUri = "https://.vault.azure.net/",
KeyName = "",
TenantID = ""
}
});
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(""),
Geo: anthropic.OrganizationExternalKeyNewParamsGeoUs,
ProviderConfig: anthropic.OrganizationExternalKeyNewParamsProviderConfigUnion{
OfAzure: &anthropic.AzureExternalKeyConfigParam{
VaultURI: "https://.vault.azure.net/",
KeyName: "",
TenantID: "",
},
},
})
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("")
.geo(ExternalKeyCreateParams.Geo.US)
.providerConfig(AzureExternalKeyConfigParam.builder()
.vaultUri("https://.vault.azure.net/")
.keyName("")
.tenantId("")
.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: '',
geo: Geo::US,
providerConfig: [
'type' => 'azure',
'vaultURI' => 'https://.vault.azure.net/',
'keyName' => '',
'tenantID' => '',
],
);
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: "",
geo: :us,
provider_config: {
type: :azure,
vault_uri: "https://.vault.azure.net/",
key_name: "",
tenant_id: ""
}
)
puts "id: #{external_key.id}"
puts "display_name: #{external_key.display_name}"
```
Respons berisi ID kunci eksternal:
```json
{
"type": "external_key",
"id": "ekey_",
"display_name": ""
}
```
Picu round-trip encrypt dan decrypt terhadap kunci Anda. Ini mengonfirmasi bahwa Anthropic dapat mengautentikasi ke tenant Anda dan melakukan operasi wrap dan unwrap.
```bash cURL
curl -sS -X POST "https://api.anthropic.com/v1/organizations/external_keys/ekey_/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_"
```
```python Python
client = anthropic.Anthropic()
validation = client.organization.external_keys.validate("ekey_")
print(f"status: {validation.status}")
print(f"error: {validation.error}")
```
```typescript TypeScript
const client = new Anthropic();
const validation = await client.organization.externalKeys.validate("ekey_");
console.log(`status: ${validation.status}`);
console.log(`error: ${validation.error}`);
```
```csharp C#
AnthropicClient client = new();
var validation = await client.Organization.ExternalKeys.Validate("ekey_");
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_")
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_");
IO.println("status: " + validation.status().asString());
IO.println("error: " + validation.error().orElse(""));
```
```php PHP
$client = new Client();
$validation = $client->organization->externalKeys->validate(
externalKeyID: 'ekey_',
);
echo "status: {$validation->status}\n";
echo "error: {$validation->error}\n";
```
```ruby Ruby
client = Anthropic::Client.new
validation = client.organization.external_keys.validate("ekey_")
puts "status: #{validation.status}"
puts "error: #{validation.error}"
```
Respons yang berhasil terlihat seperti ini:
```json
{ "type": "external_key_validation", "status": "success", "error": null }
```
Jika validasi gagal, field `error` menjelaskan masalahnya. Penyebab umum adalah:
* **Penundaan propagasi RBAC:** penetapan peran dapat memerlukan beberapa menit untuk berlaku. Tunggu dan coba lagi.
* **Network ACL memblokir Anthropic:** konfirmasikan akses jaringan publik dan `ipRules` seperti yang dijelaskan dalam langkah verifikasi.
* **Kebijakan conditional access pada workload identity:** jika tenant Anda memiliki kebijakan conditional access yang menargetkan service principal, kecualikan service principal Anthropic atau tambahkan rentang egress Anthropic ke named location kebijakan.
Setelah kunci divalidasi, lampirkan ke workspace baru sebelum Anda mengirim permintaan apa pun ke workspace tersebut. Untuk workspace yang sudah menerima permintaan, kunci dapat memerlukan [hingga satu hari untuk berlaku](https://platform.claude.com/docs/id/manage-claude/cmek#how-it-works).
```bash cURL
curl -sS -X POST "https://api.anthropic.com/v1/organizations/workspaces/" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{
"external_key_id": "ekey_"
}'
```
```bash CLI
ant organization:workspaces update \
--workspace-id "" \
--external-key-id "ekey_"
```
```python Python
client = anthropic.Anthropic()
workspace = client.organization.workspaces.update(
"", external_key_id="ekey_"
)
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("", {
external_key_id: "ekey_"
});
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("", new()
{
ExternalKeyID = "ekey_"
});
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(),
"",
anthropic.OrganizationWorkspaceUpdateParams{
ExternalKeyID: anthropic.String("ekey_"),
},
)
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_")
.build();
var workspace = client.organization().workspaces().update("", 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: '',
externalKeyID: 'ekey_',
);
echo "id: {$workspace->id}\n";
echo "external_key_id: {$workspace->externalKeyID}\n";
```
```ruby Ruby
client = Anthropic::Client.new
workspace = client.organization.workspaces.update(
"",
external_key_id: "ekey_"
)
puts "id: #{workspace.id}"
puts "external_key_id: #{workspace.external_key_id}"
```
Di [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls), buka **Encryption keys**, lalu klik **Add key**. Pilih **Azure**, masukkan URI vault, nama kunci, dan tenant ID dari langkah verifikasi, lalu klik **Continue**. Anthropic memvalidasi kunci dengan round-trip encrypt dan decrypt. Setelah ditampilkan sebagai terverifikasi, organisasi Anda dilindungi CMEK mulai dari titik itu.
Pada Claude Enterprise, CMEK berlaku untuk seluruh organisasi, jadi tidak ada langkah lampiran workspace terpisah, dan sebuah organisasi hanya dapat memiliki satu kunci.
## Terraform
Untuk deployment infrastructure-as-code, langkah-langkah yang sama dipetakan ke provider `azurerm` dan `azuread`.