Distruggi e ripristina le versioni della chiave

Questa pagina mostra come pianificare l'eliminazione definitiva di una versione della chiave Cloud Key Management Service. In Cloud KMS, il materiale della chiave di crittografia che utilizzi per criptare, decriptare, firmare e verificare i dati viene archiviato in una versione della chiave. Una chiave ha zero o più versioni. Quando ruoti una chiave, crei una nuova versione della chiave.

La distruzione di una versione della chiave comporta l'eliminazione definitiva del materiale della chiave. Quando distruggi una versione della chiave, gli altri dettagli, come il nome della chiave e il numero di versione della chiave, non vengono eliminati. Dopo l'eliminazione di una chiave, i dati criptati con la versione della chiave non possono essere decriptati.

L'unica eccezione è la reimportazione della chiave, che consente di ripristinare una chiave importata in precedenza fornendo lo stesso materiale della chiave originale.

Poiché la distruzione delle chiavi è generalmente irreversibile, Cloud KMS non consente di distruggere immediatamente le versioni delle chiavi. Puoi invece pianificare l'eliminazione di una versione della chiave. La versione della chiave rimane nello stato pianificata per l'eliminazione per un periodo di tempo configurabile. Durante il periodo di pianificazione per la distruzione, puoi ripristinare una versione della chiave per annullarne la distruzione.

La durata predefinita della pianificazione per la distruzione è di 30 giorni. Puoi impostare una durata personalizzata per la distruzione pianificata di una chiave durante la creazione della chiave. La tua organizzazione può applicare una durata minima della pianificazione per l'eliminazione impostando il vincolo Durata pianificata minima dell'eliminazione per chiave nelle policy dell'organizzazione.

Puoi anche gestire l'accesso alla chiave utilizzando Identity and Access Management (IAM). Le operazioni IAM sono coerenti entro pochi secondi. Per saperne di più, consulta Utilizzo di IAM.

Puoi anche disattivare temporaneamente una versione della chiave. Ti consigliamo di disattivare le versioni delle chiavi prima di pianificarne l'eliminazione nell'ambito delle procedure per garantire che la chiave possa essere eliminata in sicurezza. A seconda delle policy dell'organizzazione, potrebbe essere necessario disattivare una versione della chiave prima di poterla pianificare per la distruzione. Per saperne di più sul controllo della distruzione delle versioni delle chiavi utilizzando le policy dell'organizzazione, consulta Controlla la distruzione delle versioni delle chiavi.

Nel resto di questo documento, la pianificazione della distruzione di una chiave viene definita distruzione della chiave, anche se la distruzione non è immediata.

Prima di iniziare

Comprendi i rischi

La distruzione di una versione della chiave è un'operazione permanente. La distruzione di una versione della chiave ancora necessaria comporta rischi, tra cui:

  • Interruzione del servizio: se elimini una chiave necessaria per avviare un container o un'istanza, i tuoi servizi o le tue applicazioni potrebbero non essere disponibili.

  • Perdita permanente dei dati: se distruggi una chiave utilizzata per criptare i dati, questi non saranno più disponibili. I dati criptati con una chiave che è stata distrutta sono considerati crypto-shredded. In alcuni casi, la distruzione di una chiave può causare l'eliminazione definitiva delle risorse criptate.

  • Problemi normativi o di conformità: se distruggi una chiave necessaria per accedere ai dati soggetti a un periodo di conservazione prima che questo sia terminato, potresti violare un requisito normativo o di conformità.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per distruggere e ripristinare le versioni delle chiavi, chiedi all'amministratore di concederti il ruolo IAM Cloud KMS Admin (roles/cloudkms.admin) sulla chiave. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Controlla se la versione della chiave è in uso

Prima di eliminare una versione della chiave, completa i seguenti passaggi per verificare se la versione della chiave è in uso:

  1. Visualizza i dettagli del monitoraggio dell'utilizzo delle chiavi per la chiave. Se alcune risorse sono protette dalla versione della chiave che vuoi distruggere, criptale nuovamente con un'altra versione della chiave.

  2. Attiva i log per qualsiasi servizio o applicazione che potrebbe utilizzare la versione della chiave.

  3. Attiva i log nel progetto Cloud KMS che contiene la chiave.

  4. Disattiva la versione della chiave. La disattivazione della versione della chiave ne impedisce l'utilizzo. Con la versione della chiave disabilitata, qualsiasi tentativo di utilizzarla non va a buon fine.

  5. Monitora i log finché non hai la certezza che nessuna applicazione o servizio si basi ancora sulla versione della chiave che hai disattivato. Se gli errori indicano un accesso non riuscito alla versione della chiave, configura l'applicazione o la risorsa in modo che utilizzi un'altra versione della chiave.

    Il periodo di tempo che dedichi al monitoraggio dei log prima di eliminare una versione della chiave dipende dal tipo di chiave, dal suo modello di utilizzo e dal suo livello di sensibilità. Ad esempio, prima di eliminare una versione della chiave utilizzata in un processo eseguito ogni tre mesi, mantieni la versione della chiave disabilitata fino al completamento del processo.

  6. Controlla l'utilizzo della chiave rispetto ai requisiti di conformità applicabili. Ad esempio, la versione della chiave e i dati criptati con questa potrebbero essere soggetti a periodi di conservazione dei dati.

Questi passaggi ti aiutano a identificare se una chiave potrebbe essere ancora necessaria, ma non possono garantire che una versione della chiave non sia più necessaria. La tua organizzazione deve implementare procedure e linee guida per garantire che la distruzione delle versioni delle chiavi non causi effetti negativi.

Distruzione della versione di una chiave

Puoi eliminare una versione della chiave abilitata o disabilitata.

Console

  1. Nella console Google Cloud , vai alla pagina Gestione chiavi.

    Vai a Gestione chiavi

  2. Seleziona la casella accanto alla versione della chiave per cui vuoi pianificare l'eliminazione.

  3. Fai clic su Elimina nell'intestazione.

  4. Nel prompt di conferma, inserisci il nome della chiave e fai clic su Pianifica eliminazione.

gcloud

Per utilizzare Cloud KMS dalla riga di comando, innanzitutto installa o esegui l'upgrade all'ultima versione di Google Cloud CLI.

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

Sostituisci quanto segue:

  • KEY_VERSION: il numero della versione della chiave che vuoi distruggere.
  • KEY_NAME: il nome della chiave che contiene la versione della chiave che vuoi distruggere.
  • KEY_RING: il nome delle chiavi automatizzate che contiene la versione della chiave che vuoi eliminare.
  • LOCATION: la località delle chiavi automatizzate che contengono la versione della chiave che vuoi distruggere.

Per informazioni su tutti i flag e i valori possibili, esegui il comando con il flag --help.

C#

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo C# e installa l'SDK Cloud KMS 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

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo Go e installa l'SDK Cloud KMS 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

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo Java e installa l'SDK Java di 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

Per eseguire questo codice, devi prima configurare un ambiente di sviluppo Node.js e installare l'SDK Node.js di 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

Per eseguire questo codice, scopri innanzitutto come utilizzare PHP su Google Cloud e installa l'SDK PHP di 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

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo Python e installa l'SDK Python di 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

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo Ruby e installa l'SDK Cloud KMS per 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

Questi esempi utilizzano curl come client HTTP per dimostrare l'utilizzo dell'API. Per saperne di più sul controllo dell'accesso, consulta Accesso all'API Cloud KMS.

Elimina una versione della chiave chiamando il metodo 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"

Sostituisci quanto segue:

  • PROJECT_ID: l'identificatore del progetto che contiene la versione della chiave che vuoi distruggere.
  • LOCATION: la località delle chiavi automatizzate che contengono la versione della chiave che vuoi distruggere.
  • KEY_RING: il nome delle chiavi automatizzate che contiene la versione della chiave che vuoi eliminare.
  • KEY_NAME: il nome della chiave che contiene la versione della chiave che vuoi distruggere.
  • KEY_VERSION: il numero della versione della chiave che vuoi distruggere.

Se non riesci a eliminare una versione della chiave, la tua organizzazione potrebbe richiedere che le versioni delle chiavi vengano disattivate prima dell'eliminazione. Prova a disabilitare la versione della chiave prima di eliminarla.

Quando invii la richiesta di eliminazione, lo stato della versione della chiave diventa Pianificata per l'eliminazione. Una volta trascorso il periodo di tempo configurato per la pianificazione dell'eliminazione della chiave, lo stato della versione della chiave diventa "Eliminata", il che significa che è iniziata l'eliminazione logica del materiale della chiave dai sistemi attivi e il materiale della chiave non può essere recuperato dal cliente. Il materiale delle chiavi può rimanere nei sistemi Google per un massimo di 45 giorni dalla data di distruzione pianificata.

Per ricevere un avviso quando è pianificata l'eliminazione di una versione della chiave, consulta Utilizzo di Cloud Monitoring con Cloud KMS.

Le versioni delle chiavi eliminate non sono risorse fatturate.

Distruzione delle chiavi esterne

Per rimuovere definitivamente l'associazione tra una chiave Cloud EKM e una chiave esterna, puoi eliminare la versione della chiave. Una volta trascorso il periodo Pianificata per l'eliminazione, la chiave viene eliminata. Dopo l'eliminazione della versione della chiave, non puoi più criptare i dati o decriptare i dati criptati con la versione della chiave Cloud EKM.

La distruzione di una versione della chiave gestita manualmente in Cloud KMS non modifica la chiave nel gestore di chiavi esterno. Ti consigliamo di distruggere prima la chiave o la versione della chiave in Google Cloud. Dopo l'eliminazione della versione della chiave Cloud EKM, puoi eliminare il materiale della chiave nel gestore di chiavi esterno.

La distruzione di una versione della chiave esterna coordinata in Cloud KMS distrugge prima la versione della chiave in Google Cloud, quindi invia una richiesta di distruzione all'EKM per distruggere il materiale della chiave esterna.

Ripristina una versione della chiave

Durante il periodo in cui lo stato di una versione della chiave è pianificato per l'eliminazione, puoi ripristinare la versione della chiave inviando una richiesta di ripristino.

Console

  1. Nella console Google Cloud , vai alla pagina Gestione chiavi.

    Vai a Gestione chiavi

  2. Fai clic sul nome delle chiavi automatizzate contenenti la versione della chiave che vuoi ripristinare.

  3. Fai clic sulla chiave che contiene la versione della chiave che vuoi ripristinare.

  4. Seleziona la casella accanto alla versione della chiave che vuoi ripristinare.

  5. Fai clic su Ripristina nell'intestazione.

  6. Nel prompt di conferma, fai clic su Ripristina.

gcloud

Per utilizzare Cloud KMS dalla riga di comando, innanzitutto installa o esegui l'upgrade all'ultima versione di Google Cloud CLI.

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

Sostituisci quanto segue:

  • KEY_VERSION: il numero della versione della chiave che vuoi ripristinare.
  • KEY_NAME: il nome della chiave che contiene la versione della chiave che vuoi ripristinare.
  • KEY_RING: il nome della chiave automatizzata che contiene la versione della chiave che vuoi ripristinare.
  • LOCATION: la località delle chiavi automatizzate che contengono la versione della chiave che vuoi ripristinare.

Per informazioni su tutti i flag e i valori possibili, esegui il comando con il flag --help.

C#

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo C# e installa l'SDK Cloud KMS 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

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo Go e installa l'SDK Cloud KMS 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

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo Java e installa l'SDK Java di 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

Per eseguire questo codice, devi prima configurare un ambiente di sviluppo Node.js e installare l'SDK Node.js di 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

Per eseguire questo codice, scopri innanzitutto come utilizzare PHP su Google Cloud e installa l'SDK PHP di 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

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo Python e installa l'SDK Python di 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

Per eseguire questo codice, innanzitutto configura un ambiente di sviluppo Ruby e installa l'SDK Cloud KMS per 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

Questi esempi utilizzano curl come client HTTP per dimostrare l'utilizzo dell'API. Per saperne di più sul controllo dell'accesso, consulta Accesso all'API Cloud KMS.

Ripristina una versione della chiave chiamando il metodo 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"

Sostituisci quanto segue:

  • PROJECT_ID: l'identificatore del progetto che contiene la versione della chiave che vuoi ripristinare.
  • LOCATION: la località delle chiavi automatizzate che contengono la versione della chiave che vuoi ripristinare.
  • KEY_RING: il nome delle chiavi automatizzate che contiene la versione della chiave che vuoi ripristinare.
  • KEY_NAME: il nome della chiave che contiene la versione della chiave che vuoi ripristinare.
  • KEY_VERSION: il numero della versione della chiave che vuoi ripristinare.

Al termine della richiesta di ripristino, lo stato della versione della chiave diventa disabilitato. Devi abilitare la chiave prima di poterla utilizzare.

Autorizzazioni IAM obbligatorie

Per distruggere una versione della chiave, il chiamante deve disporre dell'autorizzazione IAM cloudkms.cryptoKeyVersions.destroy per la chiave, l'anello di chiavi o il progetto, la cartella o l'organizzazione.

Per ripristinare una versione della chiave, il chiamante deve disporre dell'autorizzazione cloudkms.cryptoKeyVersions.restore.

Entrambe queste autorizzazioni vengono concesse al ruolo Cloud KMS Admin (roles/cloudkms.admin).

Tempistiche di eliminazione

Cloud KMS si impegna a eliminare il materiale delle chiavi dei clienti da tutta l'infrastruttura Google entro 45 giorni dall'ora di distruzione pianificata. Ciò include la rimozione dei dati sia dai sistemi attivi sia dai backup dei data center. Altri dati dei clienti sono soggetti alla Google Cloud cronologia di eliminazione standard di 180 giorni.