Destruye y restablece versiones de claves

En esta página, se muestra cómo programar una versión de clave de Cloud Key Management Service para su destrucción permanente. En Cloud KMS, el material de clave criptográfica que usas para encriptar, desencriptar, firmar y verificar los datos se almacena en una versión de clave. Una clave tiene cero o más versiones de clave. Cuando rotas una clave, creas una versión de clave nueva.

Destruir una versión de clave significa que el material de clave se borra de forma permanente. Cuando destruyes una versión de clave, no se borran otros detalles, como el nombre de la clave y el número de versión de la clave. Una vez que se destruye una clave, no se pueden desencriptar los datos que se encriptaron con la versión de clave.

Debido a que la destrucción de claves es irreversible, Cloud KMS no te permite destruir las versiones de claves de inmediato. En su lugar, programa una versión de clave para su destrucción. La versión de clave permanece en el estado de destrucción programada durante un tiempo configurable. Durante el período programado para la destrucción, puedes restablecer una versión de clave para cancelar su destrucción.

La duración predeterminada de la destrucción programada es de 30 días. Puedes configurar una duración personalizada programada para la destrucción de una clave durante su creación. Tu organización puede aplicar una duración mínima programada de destrucción si configuras la restricción Duración mínima programada de destrucción por clave en las políticas de tu organización.

También puedes administrar el acceso a la clave mediante la administración de identidades y accesos (IAM). Las operaciones de IAM son coherentes en segundos. Para obtener más información, consulta Usa IAM.

Precaución: La destrucción de una clave es una operación permanente que puede provocar una pérdida de datos irreversible. Asegúrate de comprender los riesgos antes de destruir una versión de clave.

También puedes inhabilitar una versión de clave de forma temporal. Te recomendamos que inhabilites las versiones de clave antes de programar su destrucción como parte de tus procedimientos para garantizar que la clave se pueda destruir de forma segura. Según las políticas de tu organización, es posible que debas inhabilitar una versión de clave antes de poder programar su destrucción. Para obtener más información sobre cómo controlar la destrucción de versiones de claves con las políticas de la organización, consulta Controla la destrucción de versiones de claves.

Nota: Los llaveros de claves, las claves y las versiones de clave no se pueden borrar. Esto garantiza que el identificador de recursos de una versión de clave sea único y siempre apunte al material de clave original para esa versión, a menos que se haya destruido. Puedes almacenar una cantidad ilimitada de llaveros de claves, las claves habilitadas o inhabilitadas, y las versiones de clave habilitadas, inhabilitadas o destruidas. Para obtener más información, consulta Precios y Cuotas.

En el resto de este documento, se habla de la destrucción de la clave para hacer referencia a programar una clave para su destrucción, aunque la destrucción no sea inmediata.

Antes de comenzar

Comprende los riesgos

La destrucción de una versión de clave es una operación permanente. Destruir una versión de clave que aún se necesita conlleva riesgos, como los siguientes:

• Interrupción del servicio: Si destruyes una clave necesaria para iniciar un contenedor o una instancia, es posible que tus servicios o aplicaciones dejen de estar disponibles.

• Pérdida permanente de datos: Si destruyes una clave que se usó para encriptar datos, estos dejarán de estar disponibles. Los datos encriptados con una clave que se destruyó se consideran crypto-shredded. En algunos casos, destruir una clave puede hacer que los recursos encriptados se borren de forma permanente.

• Problemas de cumplimiento o regulatorios: Si destruyes una clave que es necesaria para acceder a datos que están sujetos a un período de retención antes de que se complete, es posible que incumplas un requisito regulatorio o de cumplimiento.

Roles obligatorios

Para obtener los permisos que necesitas para destruir y restablecer versiones de claves, pídele a tu administrador que te otorgue el rol de IAM de administrador de Cloud KMS (roles/cloudkms.admin) en la clave. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Verifica si la versión de la clave está en uso

Antes de destruir una versión de clave, completa los siguientes pasos para ver si está en uso:

1. Consulta los detalles del seguimiento de uso de claves de la clave. Si algún recurso está protegido por la versión de clave que deseas destruir, vuelve a encriptarlo con otra versión de clave.

   Precaución: Los detalles del seguimiento del uso de claves pueden retrasarse o estar incompletos. Familiarízate con las limitaciones de estos datos.

2. Activa los registros de cualquier servicio o aplicación que pueda estar usando la versión de clave.

3. Activa los registros en el proyecto de Cloud KMS que contiene la clave.

4. Inhabilita la versión de clave. Si inhabilitas la versión de clave, se evita que se use. Con la versión de clave inhabilitada, fallan todos los intentos de usarla.

5. Supervisa los registros hasta que te asegures de que ninguna aplicación o servicio siga dependiendo de la versión de clave que inhabilitaste. Si algún error indica que falló el acceso a la versión de clave, configura la aplicación o el recurso para que use otra versión de clave.

   El tiempo que dedicas a supervisar los registros antes de destruir una versión de clave depende del tipo de clave, su patrón de uso y su nivel de sensibilidad. Por ejemplo, antes de destruir una versión de clave que se usa en un proceso que se ejecuta trimestralmente, mantén la versión de clave inhabilitada hasta que se complete correctamente el proceso.

6. Verifica el uso de la clave en función de los requisitos de cumplimiento aplicables. Por ejemplo, la versión de clave y los datos encriptados con ella pueden estar sujetos a períodos de retención de datos.

Estos pasos te ayudan a identificar si es posible que aún se necesite una clave. Sin embargo, no pueden garantizar que ya no se necesite una versión de clave. Tu organización debe implementar procedimientos y lineamientos para garantizar que la destrucción de la versión de la clave no cause efectos negativos.

Advertencia: Es tu responsabilidad asegurarte de que sea seguro destruir una versión de clave. Google no es responsable de las interrupciones, la pérdida de datos ni los problemas de cumplimiento que se produzcan por destruir una versión de clave.

Destruir una versión de clave

Puedes destruir una versión de clave habilitada o inhabilitada.

Precaución: El material de la clave no se destruye de inmediato. En su lugar, la versión de clave permanece programada para su destrucción durante la duración programada. Una vez finalizado este período, el material de clave se destruye automáticamente. No hay forma de anular este resguardo de seguridad.

Si decides que no deseas que se produzca la destrucción, puedes restablecer la versión de clave. Sin embargo, después de la duración programada para la destrucción, esta no se puede revertir. No se pueden desencriptar los datos encriptados con esta versión de clave.

Console

1. En la consola de Google Cloud, ve a la página Administración de claves.

   Ir a Key Management

2. Marca la casilla junto a la versión de clave que deseas programar para la destrucción.

3. Haz clic en Destruir en el encabezado.

4. En el mensaje de confirmación, ingresa el nombre de la clave y, luego, haz clic en Programar destrucción.

gcloud

Para usar Cloud KMS en la línea de comandos, primero instala o actualiza a la versión más reciente de Google Cloud CLI.

gcloud kms keys versions destroy KEY_VERSION \
    --key KEY_NAME \
    --keyring KEY_RING \
    --location LOCATION

Reemplaza lo siguiente:

• KEY_VERSION: Es el número de versión de la clave que deseas destruir.
• KEY_NAME: Es el nombre de la clave para la que deseas destruir una versión.
• KEY_RING: Es el nombre del llavero de claves que contiene la clave.
• LOCATION: Es la ubicación de Cloud KMS del llavero de claves.

Para obtener información sobre todas las marcas y los valores posibles, ejecuta el comando con la marca --help.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# e instala el SDK de C# para Cloud KMS.

using Google.Cloud.Kms.V1;

public class DestroyKeyVersionSample
{
    public CryptoKeyVersion DestroyKeyVersion(
      string projectId = "my-project", string locationId = "us-east1", string keyRingId = "my-key-ring", string keyId = "my-key", string keyVersionId = "123")
    {
        // Create the client.
        KeyManagementServiceClient client = KeyManagementServiceClient.Create();

        // Build the key version name.
        CryptoKeyVersionName keyVersionName = new CryptoKeyVersionName(projectId, locationId, keyRingId, keyId, keyVersionId);

        // Call the API.
        CryptoKeyVersion result = client.DestroyCryptoKeyVersion(keyVersionName);

        // Return the result.
        return result;
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go para Cloud KMS.

import (
	"context"
	"fmt"
	"io"

	kms "cloud.google.com/go/kms/apiv1"
	"cloud.google.com/go/kms/apiv1/kmspb"
)

// destroyKeyVersion marks a specified key version for deletion. The key can be
// restored if requested within 24 hours.
func destroyKeyVersion(w io.Writer, name string) error {
	// name := "projects/my-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key/cryptoKeyVersions/123"

	// Create the client.
	ctx := context.Background()
	client, err := kms.NewKeyManagementClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create kms client: %w", err)
	}
	defer client.Close()

	// Build the request.
	req := &kmspb.DestroyCryptoKeyVersionRequest{
		Name: name,
	}

	// Call the API.
	result, err := client.DestroyCryptoKeyVersion(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to destroy key version: %w", err)
	}
	fmt.Fprintf(w, "Destroyed key version: %s\n", result)
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java para Cloud KMS.

import com.google.cloud.kms.v1.CryptoKeyVersion;
import com.google.cloud.kms.v1.CryptoKeyVersionName;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import java.io.IOException;

public class DestroyKeyVersion {

  public void destroyKeyVersion() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "us-east1";
    String keyRingId = "my-key-ring";
    String keyId = "my-key";
    String keyVersionId = "123";
    destroyKeyVersion(projectId, locationId, keyRingId, keyId, keyVersionId);
  }

  // Schedule destruction of the given key version.
  public void destroyKeyVersion(
      String projectId, String locationId, String keyRingId, String keyId, String keyVersionId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests. After
    // completing all of your requests, call the "close" method on the client to
    // safely clean up any remaining background resources.
    try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {
      // Build the key version name from the project, location, key ring, key,
      // and key version.
      CryptoKeyVersionName keyVersionName =
          CryptoKeyVersionName.of(projectId, locationId, keyRingId, keyId, keyVersionId);

      // Destroy the key version.
      CryptoKeyVersion response = client.destroyCryptoKeyVersion(keyVersionName);
      System.out.printf("Destroyed key version: %s%n", response.getName());
    }
  }
}

Node.js

Para ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js para Cloud KMS.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-east1';
// const keyRingId = 'my-key-ring';
// const keyId = 'my-key';
// const versionId = '123';

// Imports the Cloud KMS library
const {KeyManagementServiceClient} = require('@google-cloud/kms');

// Instantiates a client
const client = new KeyManagementServiceClient();

// Build the key version name
const versionName = client.cryptoKeyVersionPath(
  projectId,
  locationId,
  keyRingId,
  keyId,
  versionId
);

async function destroyKeyVersion() {
  const [version] = await client.destroyCryptoKeyVersion({
    name: versionName,
  });

  console.log(`Destroyed key version: ${version.name}`);
  return version;
}

return destroyKeyVersion();

PHP

Para ejecutar este código, primero obtén información sobre cómo usar PHP en Google Cloud y, luego, instala el SDK de PHP para Cloud KMS.

use Google\Cloud\Kms\V1\Client\KeyManagementServiceClient;
use Google\Cloud\Kms\V1\DestroyCryptoKeyVersionRequest;

function destroy_key_version(
    string $projectId = 'my-project',
    string $locationId = 'us-east1',
    string $keyRingId = 'my-key-ring',
    string $keyId = 'my-key',
    string $versionId = '123'
) {
    // Create the Cloud KMS client.
    $client = new KeyManagementServiceClient();

    // Build the key version name.
    $keyVersionName = $client->cryptoKeyVersionName($projectId, $locationId, $keyRingId, $keyId, $versionId);

    // Call the API.
    $destroyCryptoKeyVersionRequest = (new DestroyCryptoKeyVersionRequest())
        ->setName($keyVersionName);
    $destroyedVersion = $client->destroyCryptoKeyVersion($destroyCryptoKeyVersionRequest);
    printf('Destroyed key version: %s' . PHP_EOL, $destroyedVersion->getName());

    return $destroyedVersion;
}

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Cloud KMS.

from google.cloud import kms


def destroy_key_version(
    project_id: str, location_id: str, key_ring_id: str, key_id: str, version_id: str
) -> kms.CryptoKeyVersion:
    """
    Schedule destruction of the given key version.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        key_id (string): ID of the key to use (e.g. 'my-key').
        version_id (string): ID of the key version to destroy (e.g. '1').

    Returns:
        CryptoKeyVersion: The version.

    """

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Build the key version name.
    key_version_name = client.crypto_key_version_path(
        project_id, location_id, key_ring_id, key_id, version_id
    )

    # Call the API.
    destroyed_version = client.destroy_crypto_key_version(
        request={"name": key_version_name}
    )
    print(f"Destroyed key version: {destroyed_version.name}")
    return destroyed_version

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby para Cloud KMS.

# TODO(developer): uncomment these values before running the sample.
# project_id  = "my-project"
# location_id = "us-east1"
# key_ring_id = "my-key-ring"
# key_id      = "my-key"
# version_id  = "123"

# Require the library.
require "google/cloud/kms"

# Create the client.
client = Google::Cloud::Kms.key_management_service

# Build the key version name.
key_version_name = client.crypto_key_version_path project:            project_id,
                                                  location:           location_id,
                                                  key_ring:           key_ring_id,
                                                  crypto_key:         key_id,
                                                  crypto_key_version: version_id

# Call the API.
destroyed_version = client.destroy_crypto_key_version name: key_version_name
puts "Destroyed key version: #{destroyed_version.name}"

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

Para destruir una versión de clave, llama al método CryptoKeyVersions.destroy.

curl "https://cloudkms.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY_NAME/cryptoKeyVersions/KEY_VERSION:destroy" \
    --request "POST" \
    --header "authorization: Bearer TOKEN"

Si no puedes destruir una versión de clave, es posible que tu organización requiera que se inhabiliten las versiones de clave antes de la destrucción. Intenta inhabilitar la versión de clave antes de destruirla.

Cuando envías la solicitud de destrucción, el estado de la versión de clave pasa a estar programado para su destrucción. Una vez que haya transcurrido la duración programada para la destrucción de la clave, el estado de la versión de clave se destruirá, lo que significa que comenzó la eliminación lógica del material de la clave de los sistemas activos, y el cliente no podrá recuperarlo. El material clave puede permanecer en los sistemas de Google hasta 45 días después de la hora de destrucción programada.

A fin de recibir una alerta cuando una versión de clave está programada para su destrucción, consulta Usa Cloud Monitoring con Cloud KMS.

Las versiones de clave destruidas no son recursos facturados.

Nota: Destruir todas las versiones de clave activas no cambia el programa de rotación de la clave si se configuró uno. Si deseas descontinuar la creación automática de versiones de claves nuevas, también debes inhabilitar la rotación automática en la clave. Si no inhabilitas la rotación automática, se seguirán creando versiones de claves nuevas según lo programado.

Destrucción de claves externas

Para quitar de forma permanente la asociación entre una clave de Cloud EKM y una clave externa, puedes destruir la versión de clave. Después de que haya transcurrido el período Programada para su destrucción, se destruirá la clave. Una vez que se destruye la versión de clave, ya no puedes encriptar ni desencriptar los datos que se encriptaron con la versión de clave de Cloud EKM.

Precaución: No puedes volver a crear una versión de clave de Cloud EKM que se destruyó, incluso si usas el mismo URI o la misma ruta de la clave externa.

La destrucción de una versión de clave administrada de forma manual en Cloud KMS no modifica la clave en el administrador de claves externo. Te recomendamos que primero destruyas la clave o la versión de clave en Google Cloud. Después de destruir la versión de clave de Cloud EKM, puedes destruir el material de clave en el administrador de claves externo.

Cuando se destruye una versión de clave externa coordinada en Cloud KMS, primero se destruye la versión de clave en Google Cloud y, luego, se envía una solicitud de destrucción al EKM para destruir el material de clave externo.

Restablece una versión de clave

Durante el período en el que el estado de la versión de una clave está programado para su destrucción, puedes restablecer la versión de clave mediante el envío de una solicitud de restablecimiento.

Console

1. Ve a la página Administración de claves en la consola de Google Cloud.

   Ir a la página Administración de claves

2. Haz clic en el nombre del llavero de claves que contiene la clave cuya versión se restablecerá.

3. Haz clic en la clave cuya versión de clave deseas restablecer.

4. Marca la casilla junto a la versión de clave que deseas restablecer.

5. Haga clic en Restablecer en el encabezado.

6. En el mensaje de confirmación, haz clic en Restablecer.

gcloud

Para usar Cloud KMS en la línea de comandos, primero instala o actualiza a la versión más reciente de Google Cloud CLI.

gcloud kms keys versions restore key-version \
    --key key \
    --keyring key-ring \
    --location location

Reemplaza key-version por la versión de la clave que deseas restablecer. Reemplaza key por el nombre de la clave. Reemplaza key-ring por el nombre del llavero de claves en el que se encuentra la clave. Reemplaza location por la ubicación de Cloud KMS para el llavero de claves.

Para obtener información sobre todas las marcas y los valores posibles, ejecuta el comando con la marca --help.

C#

Para ejecutar este código, primero configura un entorno de desarrollo de C# e instala el SDK de C# para Cloud KMS.

using Google.Cloud.Kms.V1;

public class RestoreKeyVersionSample
{
    public CryptoKeyVersion RestoreKeyVersion(string projectId = "my-project", string locationId = "us-east1", string keyRingId = "my-key-ring", string keyId = "my-key", string keyVersionId = "123")
    {
        // Create the client.
        KeyManagementServiceClient client = KeyManagementServiceClient.Create();

        // Build the key version name.
        CryptoKeyVersionName cryptoKeyVersionName = new CryptoKeyVersionName(projectId, locationId, keyRingId, keyId, keyVersionId);

        // Call the API.
        CryptoKeyVersion result = client.RestoreCryptoKeyVersion(cryptoKeyVersionName);

        // Return the result.
        return result;
    }
}

Go

Para ejecutar este código, primero configura un entorno de desarrollo de Go y, luego, instala el SDK de Go para Cloud KMS.

import (
	"context"
	"fmt"
	"io"

	kms "cloud.google.com/go/kms/apiv1"
	"cloud.google.com/go/kms/apiv1/kmspb"
)

// restoreKeyVersion attempts to recover a key that has been marked for
// destruction in the past 24h.
func restoreKeyVersion(w io.Writer, name string) error {
	// name := "projects/my-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key/cryptoKeyVersions/123"

	// Create the client.
	ctx := context.Background()
	client, err := kms.NewKeyManagementClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create kms client: %w", err)
	}
	defer client.Close()

	// Build the request.
	req := &kmspb.RestoreCryptoKeyVersionRequest{
		Name: name,
	}

	// Call the API.
	result, err := client.RestoreCryptoKeyVersion(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to restore key version: %w", err)
	}
	fmt.Fprintf(w, "Restored key version: %s\n", result)
	return nil
}

Java

Para ejecutar este código, primero configura un entorno de desarrollo de Java y, luego, instala el SDK de Java para Cloud KMS.

import com.google.cloud.kms.v1.CryptoKeyVersion;
import com.google.cloud.kms.v1.CryptoKeyVersionName;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import java.io.IOException;

public class RestoreKeyVersion {

  public void restoreKeyVersion() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "us-east1";
    String keyRingId = "my-key-ring";
    String keyId = "my-key";
    String keyVersionId = "123";
    restoreKeyVersion(projectId, locationId, keyRingId, keyId, keyVersionId);
  }

  // Schedule destruction of the given key version.
  public void restoreKeyVersion(
      String projectId, String locationId, String keyRingId, String keyId, String keyVersionId)
      throws IOException {
    // Initialize client that will be used to send requests. This client only
    // needs to be created once, and can be reused for multiple requests. After
    // completing all of your requests, call the "close" method on the client to
    // safely clean up any remaining background resources.
    try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {
      // Build the key version name from the project, location, key ring, key,
      // and key version.
      CryptoKeyVersionName keyVersionName =
          CryptoKeyVersionName.of(projectId, locationId, keyRingId, keyId, keyVersionId);

      // Restore the key version.
      CryptoKeyVersion response = client.restoreCryptoKeyVersion(keyVersionName);
      System.out.printf("Restored key version: %s%n", response.getName());
    }
  }
}

Node.js

Para ejecutar este código, primero configura un entorno de desarrollo de Node.js y, luego, instala el SDK de Node.js para Cloud KMS.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-east1';
// const keyRingId = 'my-key-ring';
// const keyId = 'my-key';
// const versionId = '123';

// Imports the Cloud KMS library
const {KeyManagementServiceClient} = require('@google-cloud/kms');

// Instantiates a client
const client = new KeyManagementServiceClient();

// Build the key version name
const versionName = client.cryptoKeyVersionPath(
  projectId,
  locationId,
  keyRingId,
  keyId,
  versionId
);

async function restoreKeyVersion() {
  const [version] = await client.restoreCryptoKeyVersion({
    name: versionName,
  });

  console.log(`Restored key version: ${version.name}`);
  return version;
}

return restoreKeyVersion();

PHP

Para ejecutar este código, primero obtén información sobre cómo usar PHP en Google Cloud y, luego, instala el SDK de PHP para Cloud KMS.

use Google\Cloud\Kms\V1\Client\KeyManagementServiceClient;
use Google\Cloud\Kms\V1\RestoreCryptoKeyVersionRequest;

function restore_key_version(
    string $projectId = 'my-project',
    string $locationId = 'us-east1',
    string $keyRingId = 'my-key-ring',
    string $keyId = 'my-key',
    string $versionId = '123'
) {
    // Create the Cloud KMS client.
    $client = new KeyManagementServiceClient();

    // Build the key version name.
    $keyVersionName = $client->cryptoKeyVersionName($projectId, $locationId, $keyRingId, $keyId, $versionId);

    // Call the API.
    $restoreCryptoKeyVersionRequest = (new RestoreCryptoKeyVersionRequest())
        ->setName($keyVersionName);
    $restoredVersion = $client->restoreCryptoKeyVersion($restoreCryptoKeyVersionRequest);
    printf('Restored key version: %s' . PHP_EOL, $restoredVersion->getName());

    return $restoredVersion;
}

Python

Para ejecutar este código, primero configura un entorno de desarrollo de Python y, luego, instala el SDK de Python para Cloud KMS.

from google.cloud import kms


def restore_key_version(
    project_id: str, location_id: str, key_ring_id: str, key_id: str, version_id: str
) -> kms.CryptoKeyVersion:
    """
    Restore a key version scheduled for destruction.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        key_id (string): ID of the key to use (e.g. 'my-key').
        version_id (string): ID of the version to use (e.g. '1').

    Returns:
        CryptoKeyVersion: Restored Cloud KMS key version.

    """

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Build the key version name.
    key_version_name = client.crypto_key_version_path(
        project_id, location_id, key_ring_id, key_id, version_id
    )

    # Call the API.
    restored_version = client.restore_crypto_key_version(
        request={"name": key_version_name}
    )
    print(f"Restored key version: {restored_version.name}")
    return restored_version

Ruby

Para ejecutar este código, primero configura un entorno de desarrollo de Ruby y, luego, instala el SDK de Ruby para Cloud KMS.

# TODO(developer): uncomment these values before running the sample.
# project_id  = "my-project"
# location_id = "us-east1"
# key_ring_id = "my-key-ring"
# key_id      = "my-key"
# version_id  = "123"

# Require the library.
require "google/cloud/kms"

# Create the client.
client = Google::Cloud::Kms.key_management_service

# Build the key version name.
key_version_name = client.crypto_key_version_path project:            project_id,
                                                  location:           location_id,
                                                  key_ring:           key_ring_id,
                                                  crypto_key:         key_id,
                                                  crypto_key_version: version_id

# Call the API.
restored_version = client.restore_crypto_key_version name: key_version_name
puts "Restored key version: #{restored_version.name}"

API

En estos ejemplos, se usa curl como un cliente HTTP para demostrar el uso de la API. Para obtener más información sobre el control de acceso, consulta Accede a la API de Cloud KMS.

Para restablecer una versión de clave, llama al método CryptoKeyVersions.restore.

curl "https://cloudkms.googleapis.com/v1/projects/project-id/locations/location-id/keyRings/key-ring-id/cryptoKeys/crypto-key-id/cryptoKeyVersions/version-id:restore" \
    --request "POST" \
    --header "authorization: Bearer token"

Una vez que se completa la solicitud de restablecimiento, el estado de la versión de la clave se inhabilita. Debes habilitar la clave para poder usarla.

Permisos de IAM obligatorios

Para destruir una versión de clave, el emisor necesita el permiso cloudkms.cryptoKeyVersions.destroy de IAM en la clave, el llavero de claves o el proyecto, la carpeta o la organización.

Para restablecer una versión de clave, el emisor necesita el permiso cloudkms.cryptoKeyVersions.restore.

Ambos permisos se otorgan a la función de administrador de Cloud KMS (roles/cloudkms.admin).

Cronograma de eliminación

Cloud KMS se compromete a borrar el material de las claves del cliente de toda la infraestructura de Google dentro de los 45 días posteriores a la hora de destrucción programada. Esto incluye la eliminación de datos de los sistemas activos y las copias de seguridad del centro de datos. Los demás datos del cliente están sujetos al período de eliminación estándar de Google Cloud de 180 días.