Elimina e ripristina le versioni delle chiavi

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 che i dati siano archiviati in una versione della chiave. Una chiave ha zero o più versioni della chiave. Quando ruoti una chiave, ne crei una nuova completamente gestita.

L'eliminazione della versione di una chiave significa che il materiale della chiave viene eliminato definitivamente. Quando elimini la versione di una chiave, altri dettagli come il nome e la chiave numero di versione non vengano eliminati. Dopo l'eliminazione di una chiave, i dati criptati con la versione della chiave non possono essere decriptati.

Poiché l'eliminazione delle chiavi è irreversibile, Cloud KMS non ti consente eliminare immediatamente le versioni delle chiavi. ma pianifichi una versione della chiave la distruzione di massa. La versione della chiave rimane nello stato pianificata per l'eliminazione per un periodo di tempo configurabile. Durante la durata pianificata per l'eliminazione, puoi ripristinare la versione di una chiave per annullarne l'eliminazione.

La durata predefinita per l'eliminazione pianificata è di 30 giorni. Puoi impostare un pianificazione personalizzata per la durata dell'eliminazione di una chiave durante la chiave del linguaggio naturale. La tua organizzazione può applicare una durata minima pianificata per l'eliminazione impostando il campo Numero minimo di eliminazione di durata pianificata per chiave nei criteri dell'organizzazione.

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

Attenzione: l'eliminazione di una chiave è un'operazione permanente che può causare il recupero e la perdita di dati. Assicurati di comprendere i rischi prima di l'eliminazione di una versione della chiave.

Puoi anche disabilitare temporaneamente una versione della chiave. Me è consigliabile disabilitare le versioni delle chiavi prima di pianificarne l'eliminazione delle tue procedure per garantire che la chiave possa essere eliminata in modo sicuro. A seconda dei criteri dell'organizzazione, potrebbe essere necessario disabilitare una chiave prima di poterne pianificare l'eliminazione. Per ulteriori informazioni su come controllare l'eliminazione delle versioni delle chiavi utilizzando i criteri dell'organizzazione, consulta Controllare l'eliminazione delle versioni delle chiavi.

Nota: Impossibile eliminare keyring, chiavi e versioni delle chiavi. Ciò garantisce che identificatore di risorsa di un è univoca e punta sempre al materiale originale della chiave per quella versione, a meno che non è stata distrutta. Puoi memorizzare un numero illimitato di keyring, chiavi attive o disattivate e versioni delle chiavi attive, disattivate o eliminate. Per ulteriori informazioni, consulta Prezzi e Quote.

Nel resto del documento, la pianificazione dell'eliminazione di una chiave è definita come come la distruzione della chiave, anche se la distruzione non è immediata.

Prima di iniziare

Comprendere i rischi

L'eliminazione della versione di una chiave è un'operazione permanente. Eliminazione di una versione della chiave di rete presenta alcuni rischi, tra cui:

• Interruzione del servizio: se elimini una chiave necessaria per avviare un container o istanza, i tuoi servizi o le tue applicazioni potrebbero non essere più 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 distrutta sono considerati crypto-shredded. In alcuni casi, l'eliminazione 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 precedente a tale conservazione periodo di tempo completato, potresti aver violato una requisito.

Ruoli obbligatori

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

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

Controlla se la versione della chiave è in uso

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

1. Visualizza i dettagli di monitoraggio dell'utilizzo della chiave relativi alla chiave. Se le risorse sono protette dalla versione della chiave che vuoi eliminare, criptarli nuovamente con un'altra versione della chiave.

   Attenzione: i dettagli di monitoraggio dell'utilizzo delle chiavi possono essere ritardati o incompleti. Acquisisci familiarità con le limitazioni di questi dati.

2. Attiva i log per qualsiasi servizio o applicazione che potrebbe utilizzare la chiave completamente gestita.

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

4. Disattiva la versione della chiave. Disattivazione della chiave impedisce l'utilizzo della versione della chiave. Con versione della chiave disabilitata. Eventuali tentativi di utilizzo della versione della chiave non andranno a buon fine.

5. Monitora i log fino a quando non avrai la certezza che ancora nessuna applicazione o servizio si basa sulla versione della chiave che hai disabilitato. Se sono presenti errori che indicano un errore alla versione della chiave, configura l'applicazione o la risorsa da utilizzare un'altra versione della chiave.

   Il tempo che impieghi per monitorare i log prima di distruggere 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 che viene eseguito trimestralmente, mantieni disabilitata la versione della chiave fino a quando processo completato correttamente.

6. Verifica l'utilizzo della chiave in base a eventuali 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 capire se una chiave potrebbe essere ancora necessaria. ma non è possibile garantire che una versione della chiave non sia più necessaria. La tua organizzazione dovrebbe implementare procedure e linee guida per garantire che la versione della chiave l'eliminazione non causerà effetti negativi.

Avviso: è tua responsabilità assicurarti che la versione della chiave sia sicuro da distruggere. Google non è responsabile di interruzioni, perdita di dati o problemi di conformità derivanti dall'eliminazione di una versione della chiave.

Distruzione della versione di una chiave

Puoi eliminare una versione della chiave abilitata o disabilitata.

Attenzione: il materiale delle chiavi non viene distrutto immediatamente. Invece, la chiave l'eliminazione della versione rimane pianificata per la versione pianificata configurata e la durata dell'eliminazione. Al termine di questo periodo, il materiale chiave automaticamente eliminati. Non c'è modo di ignorare questo fallback di sicurezza.

Se decidi di non procedere con l'eliminazione, puoi ripristinare la versione della chiave. Tuttavia, una volta configurato il traffico e la durata dell'eliminazione è irreversibile. I dati criptati con questa versione della chiave non possono essere decriptati.

Console

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

   Vai a Gestione delle chiavi

2. Seleziona la casella accanto alla versione della chiave per cui vuoi pianificare la migrazione la distruzione di massa.

3. Fai clic su Elimina nell'intestazione.

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

gcloud

Per utilizzare Cloud KMS nella riga di comando, devi prima Installa o esegui l'upgrade alla versione più recente 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 per la quale vuoi distruggere una versione.
• KEY_RING: il nome del keyring che contiene la chiave.
• LOCATION: la località Cloud KMS del keyring.

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

C#

Per eseguire questo codice, per prima cosa configura un ambiente di sviluppo C# e installare 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, devi prima configurare 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, per prima cosa configura un ambiente di sviluppo Java e installare 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, configura prima un ambiente di sviluppo Python e installare l'SDK per 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, prima configura un ambiente di sviluppo Ruby e installa l'SDK Ruby di 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

In questi esempi viene utilizzato curl come client HTTP per dimostrare l'uso dell'API. Per ulteriori informazioni sul controllo dell'accesso, vedi Accesso all'API Cloud KMS.

Elimina la versione di una 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"

Se non sei in grado di eliminare la versione di una chiave, la tua organizzazione potrebbe richiedere che: delle versioni della chiave possono essere disabilitate prima dell'eliminazione. Prova a disabilitare la versione della chiave prima di distruggerla.

Quando invii la richiesta di eliminazione, lo stato della versione della chiave diventa pianificata per l'eliminazione. Dopo aver configurato la chiave per la durata pianificata per l'eliminazione, passata, lo stato della versione della chiave viene eliminato, dell'eliminazione logica del materiale della chiave e il materiale della chiave non può essere recuperato dal cliente. Legenda materiale può rimanere nei sistemi Google per un massimo di 45 giorni dal e la data e l'ora pianificate per l'eliminazione.

Per ricevere un avviso quando è pianificata l'eliminazione di una versione della chiave, consulta Utilizzare il monitoraggio cloud con Cloud KMS.

Le versioni della chiave eliminata non vengono fatturate.

Nota: l'eliminazione di tutte le versioni della chiave attiva non cambia la rotazione della chiave pianificazione, se ne è stata configurata una. Se vuoi interrompere la creazione automatica delle nuove versioni della chiave, devi anche disabilitare la funzione rotazione sulla chiave. Se non disattivi l'impostazione automatica le nuove versioni delle chiavi vengono create secondo la pianificazione.

Eliminazione delle chiavi esterne

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

Attenzione: non puoi ricreare una versione della chiave Cloud EKM che è stata distrutta, anche se utilizzi lo stesso URI o percorso della chiave esterno.

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

Eliminazione di una versione di una chiave esterna coordinata in Cloud KMS elimina la versione della chiave in Google Cloud, quindi invia un'eliminazione all'EKM di eliminare il materiale della chiave esterna.

Ripristina una versione della chiave

Nel periodo in cui è pianificata l'eliminazione dello stato di una versione della chiave, puoi ripristinare la versione della chiave inviando una richiesta di ripristino.

Console

1. Vai alla pagina Gestione delle chiavi nella console Google Cloud.

   Vai alla pagina Gestione chiavi

2. Fai clic sul nome del keyring che contiene la chiave di cui hai specificato la versione verrà ripristinato.

3. Fai clic sulla chiave di cui vuoi ripristinare la versione.

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

5. Fai clic su Ripristina nell'intestazione.

6. Nella richiesta di conferma, fai clic su Ripristina.

gcloud

Per utilizzare Cloud KMS nella riga di comando, devi prima Installa o esegui l'upgrade alla versione più recente di Google Cloud CLI.

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

Sostituisci key-version con la versione della chiave da ripristinare. Sostituisci key con il nome della chiave. Sostituisci key-ring con il nome del keyring in cui si trova la chiave. Sostituisci location con la località di Cloud KMS per il keyring.

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

C#

Per eseguire questo codice, per prima cosa configura un ambiente di sviluppo C# e installare 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, devi prima configurare 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, per prima cosa configura un ambiente di sviluppo Java e installare 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, configura prima un ambiente di sviluppo Python e installare l'SDK per 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, prima configura un ambiente di sviluppo Ruby e installa l'SDK Ruby di 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

In questi esempi viene utilizzato curl come client HTTP per dimostrare l'uso dell'API. Per ulteriori informazioni sul controllo dell'accesso, vedi Accesso all'API Cloud KMS.

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

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

Autorizzazioni IAM richieste

Per eliminare la versione di una chiave, il chiamante deve avere cloudkms.cryptoKeyVersions.destroy autorizzazione IAM sulla chiave, al keyring oppure al progetto, alla cartella o all'organizzazione.

Per ripristinare la versione di una chiave, il chiamante deve avere Autorizzazione cloudkms.cryptoKeyVersions.restore.

Entrambe queste autorizzazioni sono concesse al ruolo Amministratore Cloud KMS (roles/cloudkms.admin).

Tempistiche di eliminazione

Cloud KMS si impegna a eliminare il materiale delle chiavi del cliente da tutti i servizi Google dell'infrastruttura entro 45 giorni dal momento dell'eliminazione pianificata. Sono inclusi dei dati sia dai sistemi attivi sia dai backup dei data center. Gli altri dati dei clienti sono soggetti alle tempistiche di eliminazione di Google Cloud standard di 180 giorni.