Diese Seite wurde von der Cloud Translation API übersetzt.

Schlüsselversionen löschen und wiederherstellen

Auf dieser Seite erfahren Sie, wie Sie eine Schlüsselversion des Cloud Key Management Service dauerhaft planen Zerstörung. In Cloud KMS wird das kryptografische Schlüsselmaterial, das Sie zum Verschlüsseln, Entschlüsseln, Signieren und Prüfen von Daten verwenden, in einer Schlüsselversion gespeichert. Ein Schlüssel hat keine oder mehr Schlüsselversionen. Wenn Sie einen Schlüssel rotieren, erstellen Sie eine neue Schlüsselversion.

Das Löschen einer Schlüsselversion bedeutet, dass das Schlüsselmaterial dauerhaft gelöscht wird. Wenn Sie eine Schlüsselversion löschen, werden andere Details wie der Schlüsselname und der Schlüssel gelöscht Versionsnummern nicht gelöscht werden. Nachdem ein Schlüssel gelöscht wurde, können die mit der Schlüsselversion verschlüsselten Daten nicht mehr entschlüsselt werden.

Da das Löschen von Schlüsseln nicht rückgängig gemacht werden kann, können Sie Schlüsselversionen in Cloud KMS nicht sofort löschen. Stattdessen planen Sie eine Schlüsselversion für Zerstörung. Die Schlüsselversion verbleibt für eine konfigurierbare Zeit im Status „Löschen geplant“. Während des Zeitraums, in dem die Schlüsselversion zum Löschen vorgemerkt ist, können Sie sie wiederherstellen, um das Löschen zu stornieren.

Standardmäßig ist eine Dauer von 30 Tagen für das Löschen geplant. Sie können beim Erstellen eines Schlüssels eine benutzerdefinierte Dauer für den Status „Zum Löschen vorgemerkt“ festlegen. Ihre Organisation kann eine Mindestdauer für das Löschen vorgemerkt, indem Sie die Mindestanzahl für das Löschen Beschränkung der geplanten Dauer pro Schlüssel in Ihren Organisationsrichtlinien.

Sie können den Zugriff auf den Schlüssel auch mithilfe von Identity and Access Management (IAM) verwalten. IAM-Vorgänge sind innerhalb von Sekunden konsistent. Weitere Informationen finden Sie unter IAM verwenden.

Sie können auch eine Schlüsselversion vorübergehend deaktivieren. Mi. empfehlen, Schlüsselversionen zu deaktivieren, bevor Sie sie zum Löschen vormerken: wie Sie dafür sorgen, dass der Schlüssel sicher zerstört werden kann. Je nach den Richtlinien Ihrer Organisation müssen Sie eine Schlüsselversion möglicherweise deaktivieren, bevor Sie sie zum Löschen vormerken können. Weitere Informationen zum Löschen von Schlüsselversionen mithilfe von Organisationsrichtlinien finden Sie unter Löschen der Schlüsselversion kontrollieren.

Im weiteren Verlauf dieses Dokuments wird auf das Vorbereiten des Löschens eines Schlüssels weil der Schlüssel gelöscht wird, auch wenn er nicht sofort gelöscht wird.

Hinweis

Risiken verstehen

Das Löschen einer Schlüsselversion ist ein endgültiger Vorgang. Das Löschen einer Schlüsselversion, die noch benötigt wird, birgt Risiken, darunter:

Dienstausfall: Wenn Sie einen Schlüssel löschen, der zum Starten eines Containers erforderlich ist oder Instanz, können Ihre Dienste oder Anwendungen nicht mehr verfügbar sein.
Dauerhafter Datenverlust: Wenn Sie einen Schlüssel löschen, der zum Verschlüsseln von Daten verwendet wurde, dass die Daten nicht mehr verfügbar sind. Daten, die mit einem Schlüssel verschlüsselt wurden, der gelöscht wird, gilt als kryptografisch geschreddert. In einigen Fällen kann das Zerstören eines Schlüssels dazu führen, dass verschlüsselte Ressourcen dauerhaft gelöscht werden.
Gesetzliche oder behördliche Anforderungen: Wenn Sie einen Schlüssel vernichten, der für den Zugriff auf Daten erforderlich ist, die einer Aufbewahrungsfrist unterliegen, bevor diese Frist abgelaufen ist, verstoßen Sie möglicherweise gegen eine gesetzliche oder behördliche Anforderung.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Cloud KMS Admin (roles/cloudkms.admin) für den Schlüssel zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Löschen und Wiederherstellen von Schlüsselversionen benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Prüfen, ob die Schlüsselversion verwendet wird

Bevor Sie eine Schlüsselversion löschen, führen Sie die folgenden Schritte aus, um zu prüfen, ob die Schlüsselversion verwendet wird:

Details zum Tracking der Schlüsselnutzung für den Schlüssel ansehen Wenn Ressourcen durch die Schlüsselversion geschützt sind, die Sie löschen möchten, mit einer anderen Schlüsselversion neu verschlüsseln.

Achtung :Die Tracking-Details der Schlüsselnutzung können verzögert oder unvollständig sein. Machen Sie sich mit den Einschränkungen dieser Daten vertraut.
Aktivieren Sie Protokolle für alle Dienste oder Anwendungen, die die Schlüsselversion verwenden könnten.
Aktivieren Sie die Logs für das Cloud KMS-Projekt, das den Schlüssel enthält.
Deaktivieren Sie die Schlüsselversion. Wenn Sie die Schlüsselversion deaktivieren, kann sie nicht mehr verwendet werden. Wenn die Schlüsselversion deaktiviert ist, schlagen alle Versuche fehl, sie zu verwenden.
Überwachen Sie die Logs, bis Sie sicher sind, dass keine Anwendung oder kein Dienst mehr verfügbar ist. hängt von der deaktivierten Schlüsselversion ab. Wenn Fehler darauf hinweisen, dass ein Fehler aufgetreten ist Zugriff auf die Schlüsselversion und die zu verwendende Anwendung oder Ressource konfigurieren eine andere Schlüsselversion.

Wie lange Sie Logs überwachen, bevor Sie eine Schlüsselversion zerstören, hängt vom Schlüsseltyp, seinem Nutzungsmuster und seinem Vertraulichkeitsgrad ab. Bevor Sie beispielsweise eine Schlüsselversion löschen, die verwendet wird, in einem Prozess, der vierteljährlich ausgeführt wird, lassen Sie die Schlüsselversion bis dahin deaktiviert. abgeschlossen wird.
Prüfen Sie, ob die Verwendung des Schlüssels den anwendbaren Compliance-Anforderungen entspricht. Für die Schlüsselversion und die damit verschlüsselten Daten können beispielsweise die Aufbewahrungsdauer von Daten.

Anhand dieser Schritte können Sie feststellen, ob ein Schlüssel möglicherweise noch benötigt wird. Allerdings können sie nicht garantieren, dass eine Schlüsselversion nicht mehr benötigt wird. Meine Organisation Verfahren und Richtlinien implementieren, die sicherstellen, dass die Schlüsselversion Zerstörung keine negativen Auswirkungen hat.

Schlüsselversion löschen

Sie können eine aktivierte oder deaktivierte Schlüsselversion löschen.

Console

Wechseln Sie in der Google Cloud Console zur Seite Key Management (Schlüsselverwaltung) an.

Key Management aufrufen
Klicken Sie das Kästchen neben der Schlüsselversion an, deren Löschen Sie planen möchten.
Klicken Sie im Header auf Löschen.
Geben Sie in der Bestätigungsaufforderung den Schlüsselnamen ein und klicken Sie auf Löschung planen.

gcloud

Um Cloud KMS in der Befehlszeile zu verwenden, Installieren Sie die Google Cloud CLI oder führen Sie ein Upgrade auf die neueste Version durch.

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

Ersetzen Sie Folgendes:

KEY_VERSION: Versionsnummer der gewünschten Schlüsselversion zu zerstören.
KEY_NAME: der Name des Schlüssels, für den Sie einen Schlüssel löschen möchten Version.
KEY_RING: der Name des Schlüsselbunds, der den Schlüssel enthält
LOCATION: der Cloud KMS-Standort des Schlüsselbunds.

Wenn Sie Informationen zu allen Flags und möglichen Werten erhalten möchten, führen Sie den Befehl mit dem Flag --help aus.

C#

Um diesen Code auszuführen, müssen Sie zuerst eine C#-Entwicklungsumgebung einrichten und das Cloud KMS C# SDK installieren.


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

Um diesen Code auszuführen, müssen Sie zuerst eine Go-Entwicklungsumgebung einrichten und das Cloud KMS Go SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Java-Entwicklungsumgebung einrichten und das Cloud KMS Java SDK installieren.

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

Um diesen Code auszuführen, richten Sie zuerst eine Node.js-Entwicklungsumgebung ein und installieren Sie das Cloud KMS Node.js SDK.

//
// 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

Um diesen Code auszuführen, müssen Sie zuerst PHP in Google Cloud verwenden lernen und das Cloud KMS PHP SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Python-Entwicklungsumgebung einrichten und das Cloud KMS Python SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Ruby-Entwicklungsumgebung einrichten und das Cloud KMS Ruby SDK installieren.

# 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 diesen Beispielen wird curl als HTTP-Client verwendet, um die Verwendung der API zu demonstrieren. Weitere Informationen zur Zugriffssteuerung finden Sie unter Auf die Cloud KMS API zugreifen.

Rufen Sie die Methode CryptoKeyVersions.destroy auf, um eine Schlüsselversion zu löschen.

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"

Wenn Sie eine Schlüsselversion nicht löschen können, erfordert Ihre Organisation möglicherweise, dass Schlüsselversionen vor dem Löschen deaktiviert werden. Versuchen Sie, die Schlüsselversion zu deaktivieren, bevor Sie sie löschen.

Wenn Sie die Löschanfrage senden, wird der Status der Schlüsselversion in „Zum Löschen vorgemerkt“ geändert. Nach Ablauf der konfigurierten Dauer, nach der der Schlüssel zum Löschen vorgemerkt wird, ändert sich der Status der Schlüsselversion in „Gelöscht“. Das bedeutet, dass das logische Löschen des Schlüsselmaterials aus aktiven Systemen begonnen hat und das Schlüsselmaterial vom Kunden nicht wiederhergestellt werden kann. Schlüssel Inhalte können bis zu 45 Tage ab dem zum geplanten Löschen vorgemerkt.

Wie Sie eine Benachrichtigung erhalten, wenn eine Schlüsselversion zum Löschen geplant ist, erfahren Sie unter Cloud Monitoring mit Cloud KMS verwenden.

Gelöschte Schlüsselversionen werden nicht in Rechnung gestellt.

Externe Schlüssel löschen

Wenn Sie die Verknüpfung zwischen einem Cloud EKM-Schlüssel und einem externen Schlüssel endgültig entfernen möchten, können Sie die Schlüsselversion löschen. Nach Ablauf des Zeitraums Geplantes Löschen wird der Schlüssel gelöscht. Nachdem die Schlüsselversion gelöscht wurde, können Sie keine Daten mehr verschlüsseln oder Daten entschlüsseln, die mit der Cloud EKM-Schlüsselversion verschlüsselt wurden.

Durch das Löschen einer manuell verwalteten Schlüsselversion in Cloud KMS ändert sich nichts Schlüssel im External Key Manager. Wir empfehlen, zuerst den Schlüssel oder Schlüsselversion in Google Cloud. Nachdem die Cloud EKM-Schlüsselversion gelöscht wurde, können Sie das Schlüsselmaterial im externen Schlüsselverwaltungssystem löschen.

Zuerst eine koordinierte externe Schlüsselversion in Cloud KMS löschen Zerstört die Schlüsselversion in Google Cloud und sendet dann ein Löschen Anfrage an den EKM zum Löschen des externen Schlüsselmaterials.

Schlüsselversion wiederherstellen

Wenn der Zustand einer Schlüsselversion „Zum Löschen vorgemerkt“ ist, können Sie die Schlüsselversion wiederherstellen, indem Sie eine Wiederherstellungsanfrage senden.

Console

Rufen Sie in der Google Cloud Console die Seite Schlüsselverwaltung auf.

Zur Seite „Schlüsselverwaltung“
Klicken Sie auf den Namen des Schlüsselbunds mit dem Schlüssel, dessen Schlüsselversion Sie wiederherstellen möchten.
Klicken Sie auf den Schlüssel, dessen Schlüsselversion Sie wiederherstellen möchten.
Klicken Sie auf das Kästchen neben der Schlüsselversion, die Sie wiederherstellen möchten.
Klicken Sie im Header auf Wiederherstellen.
Klicken Sie in der Bestätigungsaufforderung auf Wiederherstellen.

gcloud

Wenn Sie Cloud KMS in der Befehlszeile verwenden möchten, müssen Sie zuerst die neueste Version der Google Cloud CLI installieren oder ein Upgrade ausführen.

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

Ersetzen Sie key-version durch die Version des Schlüssels, die wiederhergestellt werden soll. Ersetzen Sie key durch den Namen des Schlüssels. Ersetzen Sie key-ring durch den Namen des Schlüsselbunds, in dem sich der Schlüssel befindet. Ersetzen Sie location durch den Cloud KMS-Standort für den Schlüsselbund.

Wenn Sie Informationen zu allen Flags und möglichen Werten erhalten möchten, führen Sie den Befehl mit dem Flag --help aus.

C#

Um diesen Code auszuführen, müssen Sie zuerst eine C#-Entwicklungsumgebung einrichten und das Cloud KMS C# SDK installieren.


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

Um diesen Code auszuführen, müssen Sie zuerst eine Go-Entwicklungsumgebung einrichten und das Cloud KMS Go SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Java-Entwicklungsumgebung einrichten und das Cloud KMS Java SDK installieren.

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

Um diesen Code auszuführen, richten Sie zuerst eine Node.js-Entwicklungsumgebung ein und installieren Sie das Cloud KMS Node.js SDK.

//
// 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

Um diesen Code auszuführen, müssen Sie zuerst PHP in Google Cloud verwenden lernen und das Cloud KMS PHP SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Python-Entwicklungsumgebung einrichten und das Cloud KMS Python SDK installieren.

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

Um diesen Code auszuführen, müssen Sie zuerst eine Ruby-Entwicklungsumgebung einrichten und das Cloud KMS Ruby SDK installieren.

# 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 diesen Beispielen wird curl als HTTP-Client verwendet, um die Verwendung der API zu demonstrieren. Weitere Informationen zur Zugriffssteuerung finden Sie unter Auf die Cloud KMS API zugreifen.

Rufen Sie die Methode CryptoKeyVersions.restore auf, um eine Schlüsselversion wiederherzustellen.

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"

Nach Abschluss der Wiederherstellungsanfrage wird der Status der Schlüsselversion zu deaktiviert. Sie müssen den Schlüssel aktivieren, damit er verwendet werden kann.

Erforderliche IAM-Berechtigungen

Zum Löschen einer Schlüsselversion benötigt der Aufrufer die IAM-Berechtigung cloudkms.cryptoKeyVersions.destroy für den Schlüssel, den Schlüsselbund oder das Projekt, den Ordner oder die Organisation.

Zum Wiederherstellen einer Schlüsselversion benötigt der Aufrufer die Berechtigung cloudkms.cryptoKeyVersions.restore.

Beide Berechtigungen werden der Cloud KMS-Administratorrolle (roles/cloudkms.admin) gewährt.

Löschzeitachse

Cloud KMS verpflichtet sich, das Schlüsselmaterial von Kunden innerhalb von 45 Tagen nach dem geplanten Zeitpunkt der Vernichtung aus der gesamten Google-Infrastruktur zu löschen. Dazu gehören Daten aus aktiven Systemen und Back-ups der Rechenzentren zu entfernen. Anderer Kunde unterliegen dem Standard Zeitplan für die Löschung von Google Cloud von 180 Tagen.