Esta página foi traduzida pela API Cloud Translation.

Destrua e restaure versões de chaves

Esta página mostra como agendar uma versão de chave do Serviço de gestão de chaves na nuvem para destruição permanente. No Cloud KMS, o material da chave criptográfica que usa para encriptar, desencriptar, assinar e validar dados é armazenado numa versão da chave. Uma chave tem zero ou mais versões da chave. Quando roda uma chave, cria uma nova versão da chave.

A destruição de uma versão da chave significa que o material da chave é eliminado permanentemente. Quando destrói uma versão da chave, outros detalhes, como o nome da chave e o número da versão da chave, não são eliminados. Depois de uma chave ser destruída, não é possível desencriptar os dados que foram encriptados com a versão da chave.

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

Uma vez que a destruição de chaves é geralmente irreversível, o Cloud KMS não permite destruir versões de chaves imediatamente. Em alternativa, agende uma versão da chave para destruição. A versão da chave permanece no estado agendada para destruição durante um período configurável. Durante o período agendado para destruição, pode restaurar uma versão da chave para cancelar a respetiva destruição.

A duração predefinida agendada para destruição é de 30 dias. Pode definir uma duração agendada personalizada para a destruição de uma chave durante a criação da chave. A sua organização pode aplicar uma duração mínima agendada para destruição definindo a restrição Duração agendada mínima para destruição por chave nas políticas da organização.

Também pode gerir o acesso à chave através da gestão de identidade e de acesso (IAM). As operações de IAM são consistentes no espaço de segundos. Para mais informações, consulte Usar o IAM.

Também pode desativar temporariamente uma versão da chave. Recomendamos que desative as versões das chaves antes de agendar a respetiva destruição como parte dos seus procedimentos para garantir que a chave pode ser destruída em segurança. Consoante as políticas da sua organização, pode ter de desativar uma versão da chave antes de a poder agendar para destruição. Para mais informações sobre como controlar a destruição de versões de chaves através de políticas da organização, consulte o artigo Controle a destruição de versões de chaves.

No resto deste documento, o agendamento de uma chave para destruição é referido como destruição da chave, mesmo que a destruição não seja imediata.

Antes de começar

Compreenda os riscos

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

Interrupção do serviço: se destruir uma chave necessária para iniciar um contentor ou uma instância, os seus serviços ou aplicações podem ficar indisponíveis.
Perda de dados permanente: se destruir uma chave que foi usada para encriptar dados, esses dados ficam indisponíveis. Os dados encriptados com uma chave que foi destruída são considerados destruídos criptograficamente. Em alguns casos, a destruição de uma chave pode fazer com que os recursos encriptados sejam eliminados permanentemente.
Problemas regulamentares ou de conformidade: se destruir uma chave necessária para aceder a dados sujeitos a um período de retenção antes de esse período de retenção estar concluído, pode estar em violação de um requisito regulamentar ou de conformidade.

Funções necessárias

Para obter as autorizações de que precisa para destruir e restaurar versões de chaves, peça ao seu administrador para lhe conceder a função administrador do Cloud KMS (roles/cloudkms.admin) da IAM na chave. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Verifique se a versão da chave está em utilização

Antes de destruir uma versão da chave, conclua os seguintes passos para ver se a versão da chave está em utilização:

Veja os detalhes do acompanhamento da utilização de chaves para a chave. Se algum recurso estiver protegido pela versão da chave que quer destruir, encripte-o novamente com outra versão da chave.

Atenção: os detalhes de acompanhamento da utilização das chaves podem estar atrasados ou incompletos. Familiarize-se com as limitações destes dados.
Ative os registos para qualquer serviço ou aplicação que possa estar a usar a versão da chave.
Ative os registos no projeto do Cloud KMS que contém a chave.
Desative a versão da chave. A desativação da versão da chave impede a utilização da versão da chave. Com a versão da chave desativada, todas as tentativas de usar a versão da chave falham.
Monitorize os registos até ter a certeza de que nenhuma aplicação ou serviço continua a depender da versão da chave que desativou. Se existirem erros que indiquem falhas no acesso à versão da chave, configure a aplicação ou o recurso para usar outra versão da chave.

O período de tempo que dedica à monitorização dos registos antes de destruir uma versão da chave depende do tipo de chave, do respetivo padrão de utilização e do respetivo nível de sensibilidade. Por exemplo, antes de destruir uma versão de chave usada num processo executado trimestralmente, mantenha a versão de chave desativada até que esse processo seja concluído com êxito.
Verifique a utilização da chave em relação a quaisquer requisitos de conformidade aplicáveis. Por exemplo, a versão da chave e os dados encriptados com a mesma podem estar sujeitos a períodos de retenção de dados.

Estes passos ajudam a identificar se ainda é necessária uma chave. No entanto, não garantem que uma versão da chave já não seja necessária. A sua organização deve implementar procedimentos e diretrizes para garantir que a destruição da versão da chave não causa efeitos negativos.

Destrua uma versão de chave

Pode destruir uma versão da chave ativada ou desativada.

Consola

Na Google Cloud consola, aceda à página Gestão de chaves.

Aceda à gestão de chaves
Selecione a caixa junto à versão da chave que quer agendar para destruição.
Clique em Destruir no cabeçalho.
No comando de confirmação, introduza o nome da chave e, de seguida, clique em Agendar destruição.

gcloud

Para usar o Cloud KMS na linha de comandos, primeiro instale ou atualize para a versão mais recente da CLI do Google Cloud.

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

Substitua o seguinte:

KEY_VERSION: o número da versão da versão principal que quer destruir.
KEY_NAME: o nome da chave para a qual quer destruir uma versão da chave.
KEY_RING: o nome do conjunto de chaves que contém a chave.
LOCATION: a localização do Cloud KMS do conjunto de chaves.

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

C#

Para executar este código, primeiro configure um ambiente de desenvolvimento C# e instale o SDK C# do 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 executar este código, primeiro configure um ambiente de desenvolvimento Go e instale o SDK Go do 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 executar este código, primeiro configure um ambiente de desenvolvimento Java e instale o SDK Java do 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 executar este código, primeiro configure um ambiente de desenvolvimento do Node.js e instale o SDK do Node.js do 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 executar este código, saiba primeiro como usar o PHP no Google Cloud e instale o SDK 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 este código, primeiro configure um ambiente de desenvolvimento Python e instale o SDK Python do 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 executar este código, primeiro configure um ambiente de desenvolvimento Ruby e instale o SDK Ruby do 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

Estes exemplos usam o curl como cliente HTTP para demonstrar a utilização da API. Para mais informações sobre o controlo de acesso, consulte o artigo Aceder à 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"

Se não conseguir destruir uma versão de chave, a sua organização pode exigir que as versões de chave sejam desativadas antes da destruição. Experimente desativar a versão da chave antes de a destruir.

Quando envia o pedido de destruição, o estado da versão da chave passa a ser agendado para destruição. Após a duração agendada para destruição configurada da chave ter expirado, o estado da versão da chave passa a destruído, o que significa que a eliminação lógica do material da chave dos sistemas ativos foi iniciada e o cliente não pode recuperar o material da chave. O material essencial pode permanecer nos sistemas Google durante um máximo de 45 dias a partir da hora de destruição agendada.

Para receber um alerta quando uma versão de chave estiver agendada para destruição, consulte o artigo Usar o Cloud Monitoring com o Cloud KMS.

As versões de chaves destruídas não são recursos faturados.

Destruição de chaves externas

Para remover permanentemente a associação entre uma chave do EKM da nuvem e uma chave externa, pode destruir a versão da chave. Após o período Agendado para destruição, a chave é destruída. Após a destruição da versão da chave, já não pode encriptar dados nem desencriptar dados que foram encriptados com a versão da chave do Cloud EKM.

A destruição de uma versão de chave gerida manualmente no Cloud KMS não modifica a chave no gestor de chaves externo. Recomendamos que destrua primeiro a chave ou a versão da chave em Google Cloud. Depois de a versão da chave do Cloud EKM ser destruída, pode destruir o material da chave no gestor de chaves externo.

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

Restaure uma versão da chave

Durante o período em que o estado de uma versão da chave está agendado para destruição, pode restaurar a versão da chave enviando um pedido de restauro.

Consola

Aceda à página Gestão de chaves na Google Cloud consola.

Aceda à página de gestão de chaves
Clique no nome do conjunto de chaves que contém a chave cuja versão vai restaurar.
Clique na chave cuja versão quer restaurar.
Selecione a caixa junto à versão da chave que quer restaurar.
Clique em Restaurar no cabeçalho.
Na mensagem de confirmação, clique em Restaurar.

gcloud

Para usar o Cloud KMS na linha de comandos, primeiro instale ou atualize para a versão mais recente da CLI do Google Cloud.

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

Substitua key-version pela versão da chave a restaurar. Substitua key pelo nome da chave. Substitua key-ring pelo nome do conjunto de chaves onde a chave está localizada. Substitua location pela localização do Cloud KMS do conjunto de chaves.

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

C#

Para executar este código, primeiro configure um ambiente de desenvolvimento C# e instale o SDK C# do 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 executar este código, primeiro configure um ambiente de desenvolvimento Go e instale o SDK Go do 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 executar este código, primeiro configure um ambiente de desenvolvimento Java e instale o SDK Java do 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 executar este código, primeiro configure um ambiente de desenvolvimento do Node.js e instale o SDK do Node.js do 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 executar este código, saiba primeiro como usar o PHP no Google Cloud e instale o SDK 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 este código, primeiro configure um ambiente de desenvolvimento Python e instale o SDK Python do 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 executar este código, primeiro configure um ambiente de desenvolvimento Ruby e instale o SDK Ruby do 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

Estes exemplos usam o curl como cliente HTTP para demonstrar a utilização da API. Para mais informações sobre o controlo de acesso, consulte o artigo Aceder à API Cloud KMS.

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

Após a conclusão do pedido de restauro, o estado da versão da chave fica desativado. Tem de ativar a chave antes de a poder usar.

Autorizações de IAM necessárias

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

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

Ambas as autorizações são concedidas à função de administrador do Cloud KMS (roles/cloudkms.admin).

Linha cronológica de eliminação

O Cloud KMS compromete-se a eliminar o material das chaves do cliente de toda a infraestrutura da Google no prazo de 45 dias após a hora de destruição agendada. Isto inclui a remoção de dados dos sistemas ativos e das cópias de segurança dos centros de dados. Os outros dados do cliente estão sujeitos à linha cronológica de eliminação do Google Cloud padrão de 180 dias.

Destrua e restaure versões de chaves Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Compreenda os riscos

Funções necessárias

Verifique se a versão da chave está em utilização

Destrua uma versão de chave

Consola

gcloud

C#

Go

Java

Node.js

PHP

Python

Ruby

API

Destruição de chaves externas

Restaure uma versão da chave

Consola

gcloud

C#

Go

Java

Node.js

PHP

Python

Ruby

API

Autorizações de IAM necessárias

Linha cronológica de eliminação

Destrua e restaure versões de chaves