Diese Seite wurde von der Cloud Translation API übersetzt.

Schlüsselversionen löschen und wiederherstellen

Auf dieser Seite wird beschrieben, wie Sie eine Cloud Key Management Service-Schlüsselversion zum endgültigen Löschen planen. In Cloud KMS wird das kryptografische Schlüsselmaterial, das Sie zum Verschlüsseln, Entschlüsseln, Signieren und Überprü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.

Wenn Sie eine Schlüsselversion löschen, wird das Schlüsselmaterial endgültig gelöscht. Wenn Sie eine Schlüsselversion löschen, werden andere Details wie der Schlüsselname und die Schlüsselversionsnummer des Schlüssels nicht gelöscht. Nach dem Löschen eines Schlüssels können mit der Schlüsselversion verschlüsselte 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 das Löschen einer Schlüsselversion. Die Schlüsselversion bleibt für eine konfigurierbare Zeit im Status state. Während des geplanten Löschvorgangs können Sie eine Schlüsselversion wiederherstellen, um das Löschen abzubrechen.

Die standardmäßig geplante Löschdauer beträgt 24 Stunden. Sie können benutzerdefinierte Löschdauer für einen Schlüssel während der Schlüsselerstellung festlegen. Ihre Organisation kann eine minimale geplante Löschdauer erzwingen, indem Sie die Einschränkung Minimale geplante Dauer für das Löschen pro Schlüssel in Ihren Organisationsrichtlinien festlegen.

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. Wir empfehlen, Schlüsselversionen zu deaktivieren, bevor Sie sie zum Löschen planen. So sorgen Sie dafür, dass der Schlüssel sicher gelöscht werden kann. Je nach Ihren Organisationsrichtlinien müssen Sie eine Schlüsselversion möglicherweise deaktivieren, bevor Sie sie zum Löschen planen können. Weitere Informationen zum Steuern des Löschens von Schlüsselversionen mithilfe von Organisationsrichtlinien finden Sie unter Löschen von Schlüsselversionen steuern.

Im weiteren Verlauf dieses Themas wird das Planen eines Schlüssels zum Löschen als Löschen des Schlüssels bezeichnet, auch wenn das Löschen nicht sofort erfolgt.

Hinweise

Risiken verstehen

Das Löschen einer Schlüsselversion ist ein endgültiger Vorgang. Das Löschen einer noch benötigten Schlüsselversion birgt Risiken wie die folgenden:

Dienstausfall: Wenn Sie einen Schlüssel löschen, der zum Starten eines Containers oder einer Instanz erforderlich ist, sind Ihre Dienste oder Anwendungen möglicherweise nicht mehr verfügbar.
Permanenter Datenverlust: Wenn Sie einen Schlüssel löschen, der zum Verschlüsseln von Daten verwendet wurde, sind diese Daten nicht mehr verfügbar. Daten, die mit einem gelöschten Schlüssel verschlüsselt wurden, gelten als Crypto-shredded. In einigen Fällen kann das Löschen eines Schlüssels dazu führen, dass verschlüsselte Ressourcen dauerhaft gelöscht werden.
Rechtliche Probleme oder Compliance-Probleme: Wenn Sie einen Schlüssel löschen, der für den Zugriff auf Daten erforderlich ist, die einer Aufbewahrungsdauer unterliegen, bevor diese Aufbewahrungsdauer abgelaufen ist, verstoßen Sie möglicherweise gegen eine regulatorische oder Compliance-Anforderung.

Erforderliche Rollen

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

Möglicherweise können Sie 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 festzustellen, ob die Schlüsselversion verwendet wird:

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

Achtung :Die Details zum Tracking der Schlüsselnutzung können verzögert oder unvollständig sein. Machen Sie sich mit den Einschränkungen dieser Daten vertraut.
Aktivieren Sie Logs für alle Dienste oder Anwendungen, die die Schlüsselversion verwenden könnten.
Aktivieren Sie 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, die Schlüsselversion zu verwenden.
Prüfen Sie die Logs, bis Sie sicher sind, dass keine Anwendung oder kein Dienst mehr von der deaktivierten Schlüsselversion abhängig ist. Wenn Fehler auf einen fehlgeschlagenen Zugriff auf die Schlüsselversion hinweisen, konfigurieren Sie die Anwendung oder Ressource für die Verwendung einer anderen Schlüsselversion.

Wie lange Sie mit dem Monitoring von Logs vor dem Löschen einer Schlüsselversion verbringen, hängt vom Schlüsseltyp, seinem Nutzungsmuster und seiner Vertraulichkeitsstufe ab. Bevor Sie beispielsweise eine Schlüsselversion löschen, die in einem vierteljährlich ausgeführten Prozess verwendet wird, lassen Sie die Schlüsselversion deaktiviert, bis dieser Prozess erfolgreich abgeschlossen ist.
Überprüfen Sie die Nutzung des Schlüssels anhand aller anwendbaren Complianceanforderungen. Beispielsweise können die Schlüsselversion und die damit verschlüsselten Daten einer Aufbewahrungsdauer unterliegen.

Mit diesen Schritten können Sie feststellen, ob ein Schlüssel möglicherweise noch benötigt wird. Es kann jedoch nicht garantiert werden, dass eine Schlüsselversion nicht mehr benötigt wird. Ihre Organisation sollte Verfahren und Richtlinien implementieren, damit das Zerstörung von Schlüsselversionen keine negativen Auswirkungen hat.

Schlüsselversion löschen

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

Console

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

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

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 auf die neueste Version durchführen.

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

Ersetzen Sie Folgendes:

KEY_VERSION: Die Versionsnummer der Schlüsselversion, die Sie löschen möchten.
KEY_NAME: Der Name des Schlüssels, für den Sie eine Schlüsselversion löschen möchten.
KEY_RING: der Name des Schlüsselbunds, der den Schlüssel enthält.
LOCATION: der Cloud KMS-Speicherort 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 zum Löschen einer Schlüsselversion die Methode CryptoKeyVersions.destroy auf.

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, verlangt Ihre Organisation möglicherweise, dass Schlüsselversionen vor dem Löschen deaktiviert werden. Deaktivieren Sie die Schlüsselversion, bevor Sie sie löschen.

Wenn Sie die Anfrage zum Löschen senden, wird der Status der Schlüsselversion zum Löschen vorgemerkt. Nachdem die geplante Löschdauer des Schlüssels konfiguriert wurde, wird der Status der Schlüsselversion gelöscht. Das bedeutet, dass das logische Löschen des Schlüsselmaterials aus aktiven Systemen gestartet wurde und das Schlüsselmaterial vom Kunden nicht wiederhergestellt werden kann. Schlüsselmaterial kann nach dem geplanten Löschzeitpunkt bis zu 45 Tage in den Google-Systemen verbleiben.

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 dauerhaft entfernen möchten, können Sie die Schlüsselversion löschen. Nach Ablauf des Zeitraums für Löschen geplant 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 Version eines manuell verwalteten Schlüssels in Cloud KMS wird der Schlüssel im External Key Manager nicht geändert. Wir empfehlen, zuerst den Schlüssel oder die Schlüsselversion in Google Cloud zu löschen. Nachdem die Cloud EKM-Schlüsselversion gelöscht wurde, können Sie das Schlüsselmaterial im External Key Manager löschen.

Durch das Löschen einer koordinierten externen Schlüsselversion in Cloud KMS wird zuerst die Schlüsselversion in Google Cloud gelöscht. Anschließend wird eine Löschanfrage an den EKM gesendet, um das externe Schlüsselmaterial zu löschen.

Schlüsselversion wiederherstellen

Für den Zeitraum, in dem der Status einer Schlüsselversion zum Löschen geplant 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 auf die neueste Version durchfü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.

Eine Schlüsselversion kann durch Aufrufen der Methode CryptoKeyVersions.restore wiederhergestellt werden.

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 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, Kundenschlüsselmaterial innerhalb von 45 Tagen nach dem geplanten Löschzeitpunkt aus der gesamten Google-Infrastruktur zu löschen. Dazu gehört das Entfernen von Daten sowohl aus aktiven Systemen als auch aus Rechenzentrumssicherungen. Für andere Kundendaten gilt der standardmäßige Google Cloud-Löschzeitraum von 180 Tagen.