Destruir e restaurar versões de chave

Nesta página, mostramos como programar uma versão de chave do Cloud Key Management Service para destruição permanente. No Cloud KMS, o material da chave criptográfica usado para criptografar, descriptografar, assinar e verificar dados é armazenado em uma versão da chave. Uma chave tem zero ou mais versões. Ao alternar uma chave, você cria uma nova versão dela.

Destruir uma versão de chave significa que o material da chave é excluído permanentemente. Quando você destrói uma versão de chave, outros detalhes, como o nome e o número da versão da chave, não são excluídos. Depois que uma chave é destruída, os dados criptografados com a versão da chave não podem ser descriptografados.

A única exceção é a reimportação de chave, que permite restaurar uma chave importada anteriormente fornecendo o mesmo material de chave original.

Como a destruição de chaves geralmente é irreversível, o Cloud KMS não permite que você destrua versões de chave imediatamente. Em vez disso, você programa a destruição de uma versão de chave. A versão da chave permanece no estado programado para destruição por um tempo configurável. Durante o período programado para destruição, é possível restaurar uma versão de chave para cancelar a destruição.

A duração padrão programada para destruição é de 30 dias. É possível definir uma duração personalizada para a destruição de uma chave durante a criação dela. Sua organização pode aplicar uma duração mínima programada para destruição definindo a restrição Duração mínima programada de destruição por chave nas políticas da organização.

Também é possível gerenciar o acesso à chave usando o gerenciamento de identidade e acesso (IAM). As operações do IAM são consistentes em segundos. Para mais informações, consulte Como usar o IAM.

Cuidado: a destruição de uma chave é uma operação permanente que pode causar perda irrecuperável de dados. Entenda os riscos antes de destruir uma versão de chave.

Também é possível desativar temporariamente uma versão de chave. Recomendamos desativar as versões de chave antes de programá-las para destruição como parte dos procedimentos para garantir que a chave possa ser destruída com segurança. Dependendo das políticas da sua organização, talvez seja necessário desativar uma versão de chave antes de programá-la para destruição. Para mais informações sobre como controlar a destruição de versões de chaves usando políticas da organização, consulte Controlar a destruição de versões de chaves.

Observação : é possível excluir keyrings, chaves e versões de chave em algumas circunstâncias. A exclusão de um recurso o remove das listas de recursos do Cloud KMS. A destruição de uma versão de chave exclui permanentemente o material de chave subjacente. Quando você exclui um keyring, o nome dele fica disponível para reutilização, mas os nomes das chaves excluídas não podem ser reutilizados. Isso garante que o identificador de recurso de uma versão de chave seja exclusivo e sempre aponte para o material da chave original dessa versão, a menos que tenha sido destruído. É possível armazenar um número ilimitado de keyrings, chaves ativadas ou desativadas e versões de chave ativadas, desativadas ou destruídas. Para mais informações, consulte Preços e Cotas.

No restante deste documento, a programação de uma chave para destruição é chamada de destruição da chave, mesmo que a destruição não seja imediata.

Antes de começar

Entenda os riscos

A destruição de uma versão de chave é uma operação permanente. Destruir uma versão de chave que ainda é necessária tem riscos, incluindo os seguintes:

• Interrupção do serviço: se você destruir uma chave necessária para iniciar um contêiner ou uma instância, seus serviços ou aplicativos poderão ficar indisponíveis.

• Perda permanente de dados: se você destruir uma chave usada para criptografar dados, eles ficarão indisponíveis. Os dados criptografados com uma chave que foi destruída são considerados criptografados. Em alguns casos, destruir uma chave pode fazer com que os recursos criptografados sejam excluídos permanentemente.

• Problemas regulatórios ou de compliance: se você destruir uma chave necessária para acessar dados sujeitos a um período de armazenamento antes que esse período seja concluído, talvez você viole um requisito regulatório ou de compliance.

Funções exigidas

Para receber as permissões necessárias para destruir e restaurar versões de chave, peça ao administrador para conceder a você o papel do IAM de Administrador do Cloud KMS (roles/cloudkms.admin) na chave. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias usando papéis personalizados ou outros papéis predefinidos.

Verificar se a versão da chave está em uso

Antes de destruir uma versão de chave, siga estas etapas para conferir se ela está em uso:

1. Veja os detalhes de rastreamento de uso da chave. Se algum recurso estiver protegido pela versão da chave que você quer destruir, criptografe-o novamente com outra versão da chave.

   Atenção: os detalhes de rastreamento do uso de chaves podem estar atrasados ou incompletos. Conheça as limitações desses dados.

2. Ative os registros de qualquer serviço ou aplicativo que possa estar usando a versão da chave.

3. Ative os registros no projeto do Cloud KMS que contém a chave.

4. Desative a versão da chave. Desativar a versão da chave impede que ela seja usada. Com a versão da chave desativada, qualquer tentativa de usá-la falha.

5. Monitore os registros até ter certeza de que nenhum aplicativo ou serviço ainda depende da versão da chave que você desativou. Se algum erro indicar falha no acesso à versão da chave, configure o aplicativo ou recurso para usar outra versão.

   O tempo que você passa monitorando os registros antes de destruir uma versão de chave depende do tipo de chave, do padrão de uso e do nível de sensibilidade. Por exemplo, antes de destruir uma versão de chave usada em um processo trimestral, mantenha-a desativada até que o processo seja concluído.

6. Verifique o uso da chave em relação aos requisitos de compliance aplicáveis. Por exemplo, a versão da chave e os dados criptografados com ela podem estar sujeitos a períodos de retenção de dados.

Essas etapas ajudam a identificar se uma chave ainda é necessária, mas não garantem que uma versão de chave não seja mais necessária. Sua organização precisa implementar procedimentos e diretrizes para garantir que a destruição da versão da chave não cause efeitos negativos.

Aviso: é sua responsabilidade garantir que uma versão de chave seja segura para destruição. O Google não é responsável por interrupções, perda de dados ou problemas de compliance resultantes da destruição de uma versão de chave.

Destruir uma versão de chave

É possível destruir uma versão de chave ativada ou desativada.

Atenção: o material da chave não é destruído imediatamente. Em vez disso, a versão da chave permanece programada para destruição pelo período configurado. Após esse período, o material da chave é destruído automaticamente. Não há como cancelar esse recurso de segurança.

Se você decidir que não quer que a destruição ocorra, poderá restaurar a versão da chave. No entanto, após a duração programada para destruição, ela não é reversível. Não é possível descriptografar os dados criptografados com essa versão da chave.

Console

1. No console do Google Cloud , acesse a página Gerenciamento de chaves.

   Vá para Gerenciamento de chaves

2. Marque a caixa ao lado da versão da chave que você quer programar para destruição.

3. Clique em Destruir no cabeçalho.

4. No prompt de confirmação, insira o nome da chave e clique em Programar destruição.

gcloud

Para usar o Cloud KMS na linha de comando, primeiro instale ou faça upgrade para a versão mais recente da Google Cloud CLI.

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

Substitua:

• KEY_VERSION: o número da versão da chave que você quer destruir.
• KEY_NAME: o nome da chave que contém a versão da chave que você quer destruir.
• KEY_RING: o nome do keyring que contém a versão da chave que você quer destruir.
• LOCATION: o local do keyring que contém a versão da chave que você quer destruir.

Para informações sobre todas as sinalizações e valores possíveis, execute o comando com a sinalização --help.

C#

Para executar esse código, primeiro configure um ambiente de desenvolvimento C# e instale o SDK do Cloud KMS para C#.

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 executar esse código, primeiro configure um ambiente de desenvolvimento Go e instale o SDK do Cloud KMS para Go.

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 executar esse código, primeiro configure um ambiente de desenvolvimento Java e instale o SDK do Cloud KMS para Java.

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 executar esse código, primeiro configure um ambiente de desenvolvimento do Node.js e instale o SDK do Cloud KMS para Node.js.

//
// 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 executar esse código, primeiro saiba como usar o PHP no Google Cloud e instale o SDK do PHP do 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 executar esse código, primeiro configure um ambiente de desenvolvimento Python e instale o SDK do Cloud KMS para Python.

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 executar esse código, primeiro configure um ambiente de desenvolvimento Ruby e instale o SDK do Cloud KMS para Ruby.

# 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

Estes exemplos usam curl como um cliente HTTP para demonstrar o uso da API. Para mais informações sobre controle de acesso, consulte Como acessar a API Cloud KMS.

Destrua uma versão de chave chamando o 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"

Substitua:

• PROJECT_ID: o identificador do projeto que contém a versão da chave que você quer destruir.
• LOCATION: o local do keyring que contém a versão da chave que você quer destruir.
• KEY_RING: o nome do keyring que contém a versão da chave que você quer destruir.
• KEY_NAME: o nome da chave que contém a versão da chave que você quer destruir.
• KEY_VERSION: o número da versão da chave que você quer destruir.

Se não for possível destruir uma versão de chave, talvez sua organização exija que as versões de chave sejam desativadas antes da destruição. Tente desativar a versão da chave antes de destruí-la.

Quando você envia a solicitação de destruição, o estado da versão da chave é alterado para programada para destruição. Depois que a duração programada para destruição configurada da chave tiver passado, o estado da versão da chave será destruído, o que significa que a exclusão lógica do material da chave dos sistemas ativos foi iniciada e o material da chave não pode ser recuperado pelo cliente. O material da chave pode permanecer nos sistemas do Google por até 45 dias a partir do horário de destruição programado.

Para receber um alerta quando uma versão de chave estiver programada para destruição, consulte Como usar o Cloud Monitoring com o Cloud KMS.

Versões de chave destruídas não são recursos faturados.

Observação : destruir todas as versões de chave ativas não muda a programação de rotação da chave, se houver uma configurada. Se você quiser interromper a criação automática de novas versões de chave, também será necessário desativar a rotação automática na chave. Se você não desativar a rotação automática, novas versões de chave continuarão sendo criadas de acordo com a programação.

Como destruir chaves externas

Para remover permanentemente a associação entre uma chave do Cloud EKM e uma chave externa, destrua a versão da chave. Depois que o período Programado para destruição passar, a chave será destruída. Depois que a versão da chave for destruída, não será possível mais criptografar nem descriptografar dados criptografados com a versão de chave do Cloud EKM.

Atenção: não é possível recriar uma versão de chave do Cloud EKM que tenha sido destruída, mesmo que você use o mesmo URI ou caminho de chave externa.

Destruir uma versão de chave gerenciada manualmente no Cloud KMS não modifica a chave no gerenciador de chaves externo. Recomendamos primeiro destruir a chave ou a versão da chave em Google Cloud. Depois que a versão da chave do Cloud EKM for destruída, será possível destruir o material da chave no gerenciador de chaves externo.

A destruição de uma versão de chave externa coordenada no Cloud KMS primeiro destrói a versão da chave no Google Cloude, em seguida, envia uma solicitação de destruição ao EKM para destruir o material da chave externa.

Restaurar uma versão de chave

Durante o período em que o estado de uma versão de chave está programado para destruição, é possível restaurar a versão de chave enviando uma solicitação de restauração.

Console

1. No console do Google Cloud , acesse a página Gerenciamento de chaves.

   Vá para Gerenciamento de chaves

2. Clique no nome do keyring que contém a versão da chave que você quer restaurar.

3. Clique na chave que contém a versão que você quer restaurar.

4. Marque a caixa ao lado da versão da chave que você quer restaurar.

5. Clique em Restaurar no cabeçalho.

6. No prompt de confirmação, clique em Restaurar.

gcloud

Para usar o Cloud KMS na linha de comando, primeiro instale ou faça upgrade para a versão mais recente da Google Cloud CLI.

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

Substitua:

• KEY_VERSION: o número da versão da chave que você quer restaurar.
• KEY_NAME: o nome da chave que contém a versão que você quer restaurar.
• KEY_RING: o nome do keyring que contém a versão da chave que você quer restaurar.
• LOCATION: o local do keyring que contém a versão da chave que você quer restaurar.

Para informações sobre todas as sinalizações e valores possíveis, execute o comando com a sinalização --help.

C#

Para executar esse código, primeiro configure um ambiente de desenvolvimento C# e instale o SDK do Cloud KMS para C#.

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 executar esse código, primeiro configure um ambiente de desenvolvimento Go e instale o SDK do Cloud KMS para Go.

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 executar esse código, primeiro configure um ambiente de desenvolvimento Java e instale o SDK do Cloud KMS para Java.

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 executar esse código, primeiro configure um ambiente de desenvolvimento do Node.js e instale o SDK do Cloud KMS para Node.js.

//
// 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 executar esse código, primeiro saiba como usar o PHP no Google Cloud e instale o SDK do PHP do 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 executar esse código, primeiro configure um ambiente de desenvolvimento Python e instale o SDK do Cloud KMS para Python.

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 executar esse código, primeiro configure um ambiente de desenvolvimento Ruby e instale o SDK do Cloud KMS para Ruby.

# 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

Estes exemplos usam curl como um cliente HTTP para demonstrar o uso da API. Para mais informações sobre controle de acesso, consulte Como acessar a API Cloud KMS.

Restaure uma versão de chave chamando o método CryptoKeyVersions.restore.

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

Substitua:

• PROJECT_ID: o identificador do projeto que contém a versão da chave que você quer restaurar.
• LOCATION: o local do keyring que contém a versão da chave que você quer restaurar.
• KEY_RING: o nome do keyring que contém a versão da chave que você quer restaurar.
• KEY_NAME: o nome da chave que contém a versão que você quer restaurar.
• KEY_VERSION: o número da versão da chave que você quer restaurar.

Depois que a solicitação de restauração é concluída, o estado da versão da chave é desativado. É necessário ativar a chave antes de usá-la.

Permissões do IAM obrigatórias

Para destruir uma versão de chave, o autor da chamada precisa da permissão do IAM cloudkms.cryptoKeyVersions.destroy na chave, no keyring ou no projeto, na pasta ou na organização.

Para restaurar uma versão de chave, o autor da chamada precisa da permissão cloudkms.cryptoKeyVersions.restore.

Ambas as permissões são concedidas ao papel de administrador do Cloud KMS (roles/cloudkms.admin).

Linha do tempo de exclusão

O Cloud KMS se compromete a excluir o material da chave do cliente de toda a infraestrutura do Google em até 45 dias após o horário de destruição programado. Isso inclui a remoção de dados de sistemas ativos e de backups de data centers. Outros dados do cliente estão sujeitos ao cronograma de exclusão padrão doGoogle Cloud de 180 dias.