---
title: Configurar Google Cloud KMS para CMEK
url: https://platform.claude.com/docs/es/manage-claude/cmek-google-cloud-kms
description: Usa Google Cloud KMS para proporcionar una clave de cifrado para tu organización.
---

Deja que Claude Code configure esta función por ti

```text
/claude-api ayúdame a configurar una clave de cifrado gestionada por el cliente con Google Cloud KMS
```

Esta guía explica cómo configurar una clave de Google Cloud KMS como una [clave de cifrado gestionada por el cliente (CMEK)](https://platform.claude.com/docs/es/manage-claude/cmek) para tu organización de Anthropic.

<Warning>
  Habilitar CMEK es permanente. Si tu clave de KMS se elimina o deshabilita, Anthropic no puede recuperar los datos cifrados con ella. Revisa las [advertencias y limitaciones](https://platform.claude.com/docs/es/manage-claude/cmek) antes de comenzar.
</Warning>

## Requisitos previos

* Un proyecto de Google Cloud con facturación habilitada.
* La API de Cloud KMS habilitada (`cloudkms.googleapis.com`).
* Permisos para crear conjuntos de claves (key rings) y claves de KMS, y para establecer la política de IAM sobre ellas (`roles/cloudkms.admin` o equivalente).
* Una clave de API de administrador de Anthropic para tu organización.
* La [CLI de `gcloud`](https://cloud.google.com/cli) instalada y autenticada.
* Los **registros de auditoría de acceso a datos** de Cloud KMS habilitados para el proyecto (IAM y administración > Registros de auditoría > Cloud Key Management Service, con `DATA_READ` y `DATA_WRITE`). Están desactivados de forma predeterminada; sin ellos, las operaciones de cifrado y descifrado de Anthropic no producen entradas en Cloud Logging.

## Correo electrónico de la cuenta de servicio de Anthropic

Para que Anthropic use tu clave de cifrado, debes proporcionar a la cuenta de servicio de Anthropic una clave que pueda usar para cifrar datos. El correo electrónico de la cuenta de servicio para CMEK de Anthropic es:

```text wrap
anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com
```

<Warning>
  Usa únicamente este correo electrónico de cuenta de servicio publicado. Nunca confíes en un identificador proporcionado por correo electrónico, chat o cualquier canal de incorporación.
</Warning>

<Note>
  **Uso compartido restringido por dominio:** Si tu proyecto está bajo una organización de Google Cloud que aplica `constraints/iam.allowedPolicyMemberDomains`, las siguientes vinculaciones de IAM se rechazan porque la cuenta de servicio de Anthropic está fuera de tu organización. Necesitas una excepción a nivel de proyecto sobre esa restricción, o agregar el ID de cliente de Cloud Identity de Anthropic (formato `C0xxxxxxxx`) a la lista de permitidos. Contacta a Anthropic para obtener el ID de cliente si es necesario.
</Note>

## Configuración de la clave de cifrado

<Steps>
  <Step title="Crear o elegir un conjunto de claves">
    Omite este paso si ya tienes un conjunto de claves para reutilizar. Los conjuntos de claves son regionales. Elige una ubicación de una sola región en EE. UU. como `us-east5` que coincida con la geografía de Anthropic que estás configurando. Las ubicaciones multirregionales como `us` y `global` no son compatibles.

    ```bash
    gcloud kms keyrings create <your-keyring-name> \
      --project=<your-project-id> \
      --location=<region>
    ```
  </Step>

  <Step title="Crear la clave criptográfica">
    Crea una clave simétrica con el propósito `ENCRYPT_DECRYPT`. Anthropic recomienda encarecidamente la protección HSM: las claves HSM de Cloud KMS están validadas según FIPS 140-2 Nivel 3, y la diferencia de costo respecto a las claves de software es pequeña.

    La opción `--labels` agrega la etiqueta de organización, `anthropic-org-<ORGANIZATION_UUID>` con el valor `true`, donde `<ORGANIZATION_UUID>` es el ID de tu organización de Anthropic en minúsculas. La etiqueta es necesaria para que Anthropic valide la clave.

    <Note>
      **Encontrar el ID de tu organización:** Copia el campo **Organization ID** en la página [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) en la Claude Console, o en **Organization settings > Organization** en claude.ai, o lee el campo `id` del endpoint [Organization Info](https://platform.claude.com/docs/es/api/organization/retrieve). Usa el UUID sin prefijo, no el ID con el prefijo `org_`.
    </Note>

    ```bash
    gcloud kms keys create <KEY_NAME> \
      --project=<PROJECT_ID> \
      --location=<REGION> \
      --keyring=<KEYRING_NAME> \
      --purpose=encryption \
      --protection-level=hsm \
      --labels=anthropic-org-<ORGANIZATION_UUID>=true
    ```

    Para usar protección de software en su lugar, omite `--protection-level=hsm`. Nada más en esta guía cambia.

    También puedes crear la clave desde la Google Cloud Console. Abre el conjunto de claves, haz clic en **Create key**, selecciona **Generated key**, establece el propósito y el algoritmo en cifrado y descifrado simétrico, y elige **HSM** en el nivel de protección.

    <Frame caption="Crea una clave simétrica de cifrado/descifrado protegida por HSM con la etiqueta de organización.">
      ![Página Create key de Google Cloud KMS con protección HSM, cifrado/descifrado simétrico y la etiqueta anthropic-org establecida en true.](https://platform.claude.com/docs/images/cmek/gcp-create-key-label.png)
    </Frame>

    Para compartir una clave entre varias organizaciones de Anthropic, agrega una etiqueta de este tipo por cada organización. Una clave puede tener como máximo 64 etiquetas, incluidas las tuyas.

    <Note>
      Para agregar la etiqueta a una clave que no la tiene, ejecuta `gcloud kms keys update <KEY_NAME> --project=<PROJECT_ID> --location=<REGION> --keyring=<KEYRING_NAME> --update-labels=anthropic-org-<ORGANIZATION_UUID>=true`. Esto combina la etiqueta con cualquier etiqueta que la clave ya tenga.
    </Note>
  </Step>

  <Step title="Otorgar a la cuenta de servicio de Anthropic acceso a la clave">
    Se requieren dos vinculaciones de IAM a nivel de clave. Ambas están limitadas a la clave criptográfica individual, no a todo el proyecto ni a todo el conjunto de claves.

    Cifrado y descifrado, que Anthropic usa para cifrar y descifrar las claves de datos que protegen los datos de tu espacio de trabajo (cifrado de sobre):

    ```bash
    gcloud kms keys add-iam-policy-binding <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --member="serviceAccount:anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com" \
      --role=roles/cloudkms.cryptoKeyEncrypterDecrypter
    ```

    Visor, para la lectura de metadatos (`cryptoKeys.get`) que Anthropic realiza al inicio para validar el propósito y el algoritmo de la clave:

    ```bash
    gcloud kms keys add-iam-policy-binding <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --member="serviceAccount:anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com" \
      --role=roles/cloudkms.viewer
    ```

    Desde la Console, selecciona la clave, abre el panel **Permissions**, haz clic en **Grant access** y agrega la cuenta de servicio con los roles Cloud KMS CryptoKey Encrypter/Decrypter y Cloud KMS Viewer. Asegúrate de estar en la página de permisos de la clave, no del conjunto de claves ni del proyecto, para que la concesión esté limitada únicamente a esta clave.

    <Frame caption="Otorga a la cuenta de servicio de Anthropic ambos roles, limitados a la clave.">
      ![Cuadro de diálogo Grant access en el que la cuenta de servicio de Anthropic tiene asignados los roles Cloud KMS CryptoKey Encrypter/Decrypter y Viewer.](https://platform.claude.com/docs/images/cmek/gcp-grant-access.png)
    </Frame>
  </Step>

  <Step title="Anotar el nombre completo del recurso de la clave">
    Esto se lo pasas a Anthropic cuando registras la clave. El formato es:

    ```text wrap
    projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>
    ```

    Recupéralo con:

    ```bash
    gcloud kms keys describe <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --format="value(name)"
    ```

    Desde la Console, abre la página de detalles de la clave y haz clic en **Copy resource name**.

    <Frame caption="Copia el nombre completo del recurso de la clave desde el menú de acciones.">
      ![Detalles del conjunto de claves de Google Cloud con la acción Copy resource name resaltada en el menú de acciones de la clave.](https://platform.claude.com/docs/images/cmek/gcp-copy-resource-name.png)
    </Frame>
  </Step>
</Steps>

## Registrar la clave con Anthropic

La forma de registrar la clave depende del producto que uses.

<Tabs>
  <Tab title="Claude Platform">
    Puedes configurar la clave en la Claude Console o a través de la Admin API, con el mismo resultado.

    <Tabs>
      <Tab title="Claude Console">
        <Steps>
          <Step title="Registrar la clave con Anthropic">
            En la Claude Console, ve a la página [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Si no ves **Encryption keys**, selecciona **Organization** en el menú desplegable en la parte superior de la página. En **Encryption keys**, haz clic en **Add key**. Ingresa un nombre para mostrar, elige **Google Cloud KMS** y haz clic en **Continue**. Pega el nombre completo del recurso de la clave en **Key resource name** y haz clic en **Add**.

            El paso de detalles de la clave muestra la etiqueta de organización. Agrégala a la clave, como describe [el paso de creación](https://platform.claude.com/docs/es/manage-claude/cmek-google-cloud-kms#organization-label), antes de hacer clic en **Add**.
          </Step>

          <Step title="Validar la clave">
            En la lista **Encryption keys**, haz clic en **Verify** junto a la clave. Aparece **Connected** cuando la verificación se completa correctamente. Si falla, un mensaje indica el motivo.
          </Step>

          <Step title="Adjuntar la clave a un espacio de trabajo">
            En la Claude Console, ve a la página [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) y selecciona el espacio de trabajo en el menú desplegable en la parte superior de la página. En **Encryption key**, selecciona la clave, haz clic en **Save** y confirma. Adjuntar una clave no se puede deshacer. Para un espacio de trabajo que ya recibe solicitudes, la clave puede tardar [hasta un día en surtir efecto](https://platform.claude.com/docs/es/manage-claude/cmek#how-it-works).
          </Step>
        </Steps>
      </Tab>

      <Tab title="API">
        <Steps>
          <Step title="Registrar la clave con Anthropic">
            Crea una configuración de clave externa a través de la Admin API, usando el nombre del recurso del paso Anotar el nombre completo del recurso de la clave en Configuración de la clave de cifrado.

            <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": "gcp",
                    "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                  }
                }'
              ```

              ```bash CLI
              ant organization:external-keys create <<'YAML'
              display_name: "<friendly-name>"
              geo: us
              provider_config:
                type: gcp
                key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
              YAML
              ```

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

              external_key = client.organization.external_keys.create(
                  display_name="<friendly-name>",
                  geo="us",
                  provider_config={
                      "type": "gcp",
                      "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
                  },
              )

              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: "gcp",
                  key_name:
                    "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                }
              });

              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 GcpExternalKeyConfig
                  {
                      KeyName = "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                  }
              });

              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{
              		OfGCP: &anthropic.GCPExternalKeyConfigParam{
              			KeyName: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
              		},
              	},
              })
              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("<friendly-name>")
                      .geo(ExternalKeyCreateParams.Geo.US)
                      .gcpProviderConfig("projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>")
                      .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' => 'gcp',
                      'keyName' => 'projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>',
                  ],
              );

              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: :gcp,
                  key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                }
              )

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

            La respuesta contiene el ID de la clave externa:

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

          <Step title="Validar la clave">
            Activa un ciclo de cifrado y descifrado contra tu clave.

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

            Una respuesta exitosa se ve así:

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

            Si la validación falla, las causas comunes son:

            * **VPC Service Controls:** si un perímetro de servicio protege Cloud KMS en tu proyecto, agrega Anthropic a un nivel de acceso en el perímetro (o excluye el proyecto de la clave) para que Anthropic pueda acceder a la clave.
            * **Uso compartido restringido por dominio:** la política de organización `constraints/iam.allowedPolicyMemberDomains` puede eliminar la vinculación de la cuenta de servicio de Anthropic (consulta la nota anterior). Confirma que la vinculación está presente con `gcloud kms keys get-iam-policy <your-key-name> --project=<your-project-id> --location=<region> --keyring=<your-keyring-name>`.
            * **Versión de clave deshabilitada o destruida:** confirma que la versión principal de la clave está habilitada, y no deshabilitada, programada para destrucción o destruida.
          </Step>

          <Step title="Adjuntar la clave a un espacio de trabajo">
            Una vez validada la clave, adjúntala a un nuevo espacio de trabajo antes de enviar cualquier solicitud a ese espacio de trabajo. Para un espacio de trabajo que ya recibe solicitudes, la clave puede tardar [hasta un día en surtir efecto](https://platform.claude.com/docs/es/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">
    En [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls), abre **Encryption keys** y luego haz clic en **Add key**. Elige **Google Cloud**, pega el nombre completo del recurso de la clave del paso anterior y haz clic en **Continue**. Anthropic valida la clave con un ciclo de cifrado y descifrado. Una vez que aparece como verificada, tu organización está protegida con CMEK a partir de ese momento.

    En Claude Enterprise, CMEK se aplica a toda la organización, por lo que no hay un paso separado para adjuntar al espacio de trabajo, y una organización solo puede tener una clave.
  </Tab>
</Tabs>

## Terraform

Para implementaciones de infraestructura como código, los mismos pasos se corresponden con el proveedor `google` usando los recursos `google_kms_key_ring`, `google_kms_crypto_key` y `google_kms_crypto_key_iam_member`.