---
title: Configura Google Cloud KMS per CMEK
url: https://platform.claude.com/docs/it/manage-claude/cmek-google-cloud-kms
description: Usa Google Cloud KMS per fornire una chiave di crittografia per la tua organizzazione.
---
Lascia che Claude Code configuri questa funzionalità per te
```text
/claude-api aiutami a configurare una chiave di crittografia gestita dal cliente con Google Cloud KMS
```
Questa guida illustra la configurazione di una chiave Google Cloud KMS come [chiave di crittografia gestita dal cliente (CMEK)](https://platform.claude.com/docs/it/manage-claude/cmek) per la tua organizzazione Anthropic.
L'abilitazione di CMEK è permanente. Se la tua chiave KMS viene eliminata o disabilitata, Anthropic non può recuperare i dati crittografati con essa. Esamina gli [avvisi e le limitazioni](https://platform.claude.com/docs/it/manage-claude/cmek) prima di iniziare.
## Prerequisiti
* Un progetto Google Cloud con la fatturazione abilitata.
* L'API Cloud KMS abilitata (`cloudkms.googleapis.com`).
* Autorizzazioni per creare key ring e chiavi KMS, e per impostare la policy IAM su di essi (`roles/cloudkms.admin` o equivalente).
* Una chiave API Admin di Anthropic per la tua organizzazione.
* La [CLI `gcloud`](https://cloud.google.com/cli) installata e autenticata.
* I **log di audit di accesso ai dati** di Cloud KMS abilitati per il progetto (IAM & Admin > Audit Logs > Cloud Key Management Service, con `DATA_READ` e `DATA_WRITE`). Questi sono disattivati per impostazione predefinita; senza di essi, le operazioni di crittografia e decrittografia di Anthropic non producono voci in Cloud Logging.
## Email dell'account di servizio Anthropic
Per far sì che Anthropic utilizzi la tua chiave di crittografia, devi fornire all'account di servizio di Anthropic una chiave che possa usare per crittografare i dati. L'email dell'account di servizio per Anthropic CMEK è:
```text wrap
anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com
```
Usa solo questa email dell'account di servizio pubblicata. Non fidarti mai di un identificatore fornito via email, chat o qualsiasi canale di onboarding.
**Condivisione limitata al dominio:** Se il tuo progetto è sotto un'organizzazione Google Cloud che applica `constraints/iam.allowedPolicyMemberDomains`, i seguenti binding IAM vengono rifiutati perché l'account di servizio Anthropic è esterno alla tua organizzazione. Hai bisogno di un'esenzione a livello di progetto su quel vincolo, oppure di aggiungere l'ID cliente Cloud Identity di Anthropic (formato `C0xxxxxxxx`) all'elenco consentito. Contatta Anthropic per l'ID cliente se necessario.
## Configurazione della chiave di crittografia
Salta questo passaggio se hai già un key ring da riutilizzare. I key ring sono regionali. Scegli una posizione US a regione singola come `us-east5` che corrisponda alla geografia Anthropic che stai configurando. Le posizioni multi-regione come `us` e `global` non sono supportate.
```bash
gcloud kms keyrings create \
--project= \
--location=
```
Crea una chiave simmetrica con lo scopo `ENCRYPT_DECRYPT`. Anthropic consiglia vivamente la protezione HSM: le chiavi HSM di Cloud KMS sono validate FIPS 140-2 Level 3, e la differenza di costo rispetto alle chiavi software è ridotta.
L'opzione `--labels` aggiunge l'etichetta dell'organizzazione, `anthropic-org-` con il valore `true`, dove `` è l'ID della tua organizzazione Anthropic in minuscolo. L'etichetta è necessaria affinché Anthropic possa validare la chiave.
**Trovare l'ID della tua organizzazione:** copia il campo **Organization ID** nella pagina [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) nella Claude Console, oppure in **Organization settings > Organization** su claude.ai, oppure leggi il campo `id` dall'endpoint [Organization Info](https://platform.claude.com/docs/it/api/organization/retrieve). Usa l'UUID semplice, non l'ID con prefisso `org_`.
```bash
gcloud kms keys create \
--project= \
--location= \
--keyring= \
--purpose=encryption \
--protection-level=hsm \
--labels=anthropic-org-=true
```
Per la protezione software invece, ometti `--protection-level=hsm`. Nient'altro in questa guida cambia.
Puoi anche creare la chiave dalla Google Cloud Console. Apri il key ring, fai clic su **Create key**, seleziona **Generated key**, imposta lo scopo e l'algoritmo su crittografia e decrittografia simmetrica, e scegli **HSM** sotto il livello di protezione.
Per condividere una chiave tra più organizzazioni Anthropic, aggiungi una di queste etichette per ogni organizzazione. Una chiave può avere al massimo 64 etichette, incluse le tue.
Per aggiungere l'etichetta a una chiave che non la possiede, esegui `gcloud kms keys update --project= --location= --keyring= --update-labels=anthropic-org-=true`. Unisce l'etichetta a qualsiasi etichetta che la chiave possiede già.
Sono necessari due binding IAM a livello di chiave. Entrambi sono limitati alla singola chiave crittografica, non all'intero progetto o all'intero key ring.
Crittografia e decrittografia, che Anthropic usa per crittografare e decrittografare le chiavi dati che proteggono i dati del tuo workspace (crittografia a busta):
```bash
gcloud kms keys add-iam-policy-binding \
--project= \
--location= \
--keyring= \
--member="serviceAccount:anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com" \
--role=roles/cloudkms.cryptoKeyEncrypterDecrypter
```
Viewer, per la lettura dei metadati (`cryptoKeys.get`) che Anthropic esegue all'avvio per validare lo scopo e l'algoritmo della chiave:
```bash
gcloud kms keys add-iam-policy-binding \
--project= \
--location= \
--keyring= \
--member="serviceAccount:anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com" \
--role=roles/cloudkms.viewer
```
Dalla Console, seleziona la chiave, apri il pannello **Permissions**, fai clic su **Grant access**, e aggiungi l'account di servizio con entrambi i ruoli Cloud KMS CryptoKey Encrypter/Decrypter e Cloud KMS Viewer. Assicurati di essere nella pagina delle autorizzazioni della chiave, non del key ring o del progetto, in modo che la concessione sia limitata solo a questa chiave.
Lo passi ad Anthropic quando registri la chiave. Il formato è:
```text wrap
projects//locations//keyRings//cryptoKeys/
```
Recuperalo con:
```bash
gcloud kms keys describe \
--project= \
--location= \
--keyring= \
--format="value(name)"
```
Dalla Console, apri la pagina dei dettagli della chiave e fai clic su **Copy resource name**.
## Registra la chiave con Anthropic
Il modo in cui registri la chiave dipende dal prodotto che usi.
Puoi configurare la chiave nella Claude Console o tramite l'Admin API, con lo stesso risultato.
Nella Claude Console, vai alla pagina [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Se non vedi **Encryption keys**, seleziona **Organization** dal menu a discesa nella parte superiore della pagina. In **Encryption keys**, fai clic su **Add key**. Inserisci un nome visualizzato, scegli **Google Cloud KMS** e fai clic su **Continue**. Incolla il nome completo della risorsa della chiave in **Key resource name** e fai clic su **Add**.
Il passaggio dei dettagli della chiave mostra l'etichetta dell'organizzazione. Aggiungila alla chiave, come descrive [il passaggio di creazione](https://platform.claude.com/docs/it/manage-claude/cmek-google-cloud-kms#organization-label), prima di fare clic su **Add**.
Nell'elenco **Encryption keys**, fai clic su **Verify** accanto alla chiave. Quando il controllo ha esito positivo appare **Connected**. Se non riesce, un messaggio ne indica il motivo.
Nella Claude Console, vai alla pagina [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) e seleziona il workspace dal menu a discesa nella parte superiore della pagina. In **Encryption key**, seleziona la chiave, fai clic su **Save** e conferma. Il collegamento di una chiave non può essere annullato. Per un workspace che riceve già richieste, la chiave può impiegare [fino a un giorno per avere effetto](https://platform.claude.com/docs/it/manage-claude/cmek#how-it-works).
Crea una configurazione di chiave esterna tramite l'Admin API, usando il nome della risorsa dal passaggio Annota il nome completo della risorsa chiave sotto Configurazione della chiave di crittografia.
```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": "gcp",
"key_name": "projects//locations//keyRings//cryptoKeys/"
}
}'
```
```bash CLI
ant organization:external-keys create <<'YAML'
display_name: ""
geo: us
provider_config:
type: gcp
key_name: "projects//locations//keyRings//cryptoKeys/"
YAML
```
```python Python
client = anthropic.Anthropic()
external_key = client.organization.external_keys.create(
display_name="",
geo="us",
provider_config={
"type": "gcp",
"key_name": "projects//locations//keyRings//cryptoKeys/",
},
)
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: "gcp",
key_name:
"projects//locations//keyRings//cryptoKeys/"
}
});
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 GcpExternalKeyConfig
{
KeyName = "projects//locations//keyRings//cryptoKeys/"
}
});
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{
OfGCP: &anthropic.GCPExternalKeyConfigParam{
KeyName: "projects//locations//keyRings//cryptoKeys/",
},
},
})
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.ExternalKeyCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = ExternalKeyCreateParams.builder()
.displayName("")
.geo(ExternalKeyCreateParams.Geo.US)
.gcpProviderConfig("projects//locations//keyRings//cryptoKeys/")
.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' => 'gcp',
'keyName' => 'projects//locations//keyRings//cryptoKeys/',
],
);
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: :gcp,
key_name: "projects//locations//keyRings//cryptoKeys/"
}
)
puts "id: #{external_key.id}"
puts "display_name: #{external_key.display_name}"
```
La risposta contiene l'ID della chiave esterna:
```json
{
"type": "external_key",
"id": "ekey_",
"display_name": ""
}
```
Attiva un ciclo di crittografia e decrittografia sulla tua chiave.
```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
external_key_id = "ekey_"
validation = client.organization.external_keys.validate(external_key_id)
puts "status: #{validation.status}"
puts "error: #{validation.error}"
```
Una risposta riuscita appare così:
```json
{ "type": "external_key_validation", "status": "success", "error": null }
```
Se la validazione fallisce, le cause comuni sono:
* **VPC Service Controls:** se un perimetro di servizio protegge Cloud KMS nel tuo progetto, aggiungi Anthropic a un livello di accesso sul perimetro (o escludi il progetto della chiave) in modo che Anthropic possa raggiungere la chiave.
* **Condivisione limitata al dominio:** la policy org `constraints/iam.allowedPolicyMemberDomains` può rimuovere il binding dell'account di servizio Anthropic (vedi la nota precedente). Conferma che il binding sia presente con `gcloud kms keys get-iam-policy --project= --location= --keyring=`.
* **Versione della chiave disabilitata o distrutta:** conferma che la versione primaria della chiave sia abilitata, e non disabilitata, programmata per la distruzione, o distrutta.
Una volta validata la chiave, collegala a un nuovo workspace prima di inviare qualsiasi richiesta a quel workspace. Per un workspace che riceve già richieste, la chiave può impiegare [fino a un giorno per avere effetto](https://platform.claude.com/docs/it/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_id = ""
workspace = client.organization.workspaces.update(
workspace_id,
external_key_id: "ekey_"
)
puts "id: #{workspace.id}"
puts "external_key_id: #{workspace.external_key_id}"
```
In [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls), apri **Encryption keys**, poi fai clic su **Add key**. Scegli **Google Cloud**, incolla il nome completo della risorsa chiave dal passaggio precedente, e fai clic su **Continue**. Anthropic valida la chiave con un ciclo di crittografia e decrittografia. Una volta che appare come verificata, la tua organizzazione è protetta da CMEK da quel momento in poi.
Su Claude Enterprise, CMEK si applica all'intera organizzazione, quindi non c'è un passaggio separato di collegamento al workspace, e un'organizzazione può avere solo una chiave.
## Terraform
Per i deployment infrastructure-as-code, gli stessi passaggi corrispondono al provider `google` con le risorse `google_kms_key_ring`, `google_kms_crypto_key`, e `google_kms_crypto_key_iam_member`.