Détruire et restaurer des versions de clé

Cette page vous explique comment programmer la destruction définitive d'une version de clé Cloud Key Management Service. Dans Cloud KMS, le matériel de clé cryptographique que vous utilisez pour chiffrer, déchiffrer, signer et valider les données est stocké dans une version de clé. Une clé comporte zéro ou plusieurs versions de clé. Lorsque vous effectuez une rotation de clé, vous créez une nouvelle version de clé.

La destruction d'une version de clé signifie que le matériel de clé est définitivement supprimé. Lorsque vous détruisez une version de clé, d'autres détails tels que le nom de la clé et le numéro de version de la clé ne sont pas supprimés. Une fois qu'une clé est détruite, les données chiffrées avec la version de clé ne peuvent plus être déchiffrées.

La seule exception est la réimportation de clé, qui vous permet de restaurer une clé précédemment importée en fournissant le même matériel de clé d'origine.

Étant donné que la destruction de clé est généralement irréversible, Cloud KMS ne vous permet pas de détruire immédiatement les versions de clé. Au lieu de cela, vous programmez la destruction d'une version de clé. La version de clé reste à l'état "Destruction programmée" state pendant une durée configurable. Pendant la durée de destruction programmée, vous pouvez restaurer une version de clé pour annuler sa destruction.

La durée de destruction programmée par défaut est de 30 jours. Vous pouvez définir une durée de destruction programmée personnalisée pour une clé lors de sa création. Votre organisation peut appliquer une durée de destruction programmée minimale en définissant la contrainte Durée minimale de destruction programmée par clé dans ses règles d'administration.

Vous pouvez également gérer l'accès à la clé à l'aide d'Identity and Access Management (IAM). Les opérations IAM sont cohérentes en quelques secondes. Pour en savoir plus, consultez la page Utiliser Cloud IAM.

Vous pouvez également désactiver temporairement une version de clé. Nous vous recommandons de désactiver les versions de clé avant de les programmer pour destruction dans le cadre de vos procédures visant à garantir que la clé peut être détruite en toute sécurité. En fonction des règles d'administration de votre organisation, vous devrez peut-être désactiver une version de clé avant de pouvoir programmer sa destruction. Pour en savoir plus sur le contrôle de la destruction des versions de clé à l'aide des règles d'administration, consultez la page Contrôler la destruction d'une version de clé.

Dans le reste de ce document, la programmation d'une clé pour destruction est appelée destruction de la clé, même si la destruction n'est pas immédiate.

Avant de commencer

Comprendre les risques

La destruction d'une version de clé est une opération permanente. La destruction d'une version de clé qui est encore nécessaire présente des risques, y compris les suivants :

  • Interruption de service : si vous détruisez une clé requise pour démarrer un conteneur ou une instance, vos services ou applications peuvent devenir indisponibles.

  • Perte définitive de données : si vous détruisez une clé qui a été utilisée pour chiffrer des données, ces données deviennent indisponibles. Les données chiffrées avec une clé qui a été détruite sont considérées comme déchiquetées par chiffrement. Dans certains cas, la destruction d'une clé peut entraîner la suppression définitive des ressources chiffrées.

  • Problèmes réglementaires ou de conformité : si vous détruisez une clé requise pour accéder à des données soumises à une période de conservation avant la fin de cette période, vous risquez de ne pas respecter une exigence réglementaire ou de conformité.

Rôles requis

Pour obtenir les autorisations nécessaires pour détruire et restaurer des versions de clé, demandez à votre administrateur de vous accorder le rôle IAM Administrateur Cloud KMS (roles/cloudkms.admin) sur la clé. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises avec des rôles personnalisés ou d'autres rôles prédéfinis.

Vérifier si la version de clé est utilisée

Avant de détruire une version de clé, procédez comme suit pour vérifier si elle est utilisée :

  1. Affichez les détails du suivi de l'utilisation des clés pour la clé. Si des ressources sont protégées par la version de clé que vous souhaitez détruire, rechiffrez-les avec une autre version de clé.

  2. Activez les journaux pour tout service ou application susceptible d'utiliser la version de clé.

  3. Activez les journaux sur le projet Cloud KMS contenant la clé.

  4. Désactivez la version de clé. La désactivation de la version de clé empêche son utilisation. Lorsque la version de clé est désactivée, toute tentative d'utilisation échoue.

  5. Surveillez les journaux jusqu'à ce que vous soyez sûr qu'aucune application ou aucun service ne repose plus sur la version de clé que vous avez désactivée. Si des erreurs indiquent un échec d'accès à la version de clé, configurez l'application ou la ressource pour qu'elle utilise une autre version de clé.

    La durée de surveillance des journaux avant de détruire une version de clé dépend du type de clé, de son modèle d'utilisation et de son niveau de sensibilité. Par exemple, avant de détruire une version de clé utilisée dans un processus qui s'exécute tous les trimestres, désactivez-la jusqu'à ce que le processus se termine correctement.

  6. Vérifiez l'utilisation de la clé par rapport aux exigences de conformité applicables. Par exemple, la version de clé et les données chiffrées avec celle-ci peuvent être soumises à des périodes de conservation des données.

Ces étapes vous aident à déterminer si une clé est encore nécessaire. Toutefois, elles ne peuvent pas garantir qu'une version de clé n'est plus nécessaire. Votre organisation doit mettre en œuvre des procédures et des consignes pour s'assurer que la destruction d'une version de clé n'aura pas d'effets négatifs.

Détruire une version de clé

Vous pouvez détruire une version de clé activée ou désactivée.

Console

  1. Dans la Google Cloud console, accédez à la page Gestion des clés.

    Accéder à Key Management

  2. Cochez l'option située à côté de la version de clé dont vous souhaitez programmer la destruction.

  3. Cliquez sur Détruire dans l'en-tête.

  4. Dans l'invite de confirmation, saisissez le nom de la clé, puis cliquez sur Programmer la destruction.

gcloud

Pour utiliser Cloud KMS sur la ligne de commande, commencez par installer ou mettre à jour la dernière version de Google Cloud CLI.

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

Remplacez les éléments suivants :

  • KEY_VERSION: numéro de la version de clé que vous souhaitez détruire.
  • KEY_NAME: nom de la clé contenant la version de clé que vous souhaitez détruire.
  • KEY_RING: nom du trousseau de clés contenant la version de clé que vous souhaitez détruire.
  • LOCATION: emplacement du trousseau de clés contenant la version de clé que vous souhaitez détruire.

Pour en savoir plus sur toutes les options et valeurs possibles, exécutez la commande avec l'option --help.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C#, puis installez le SDK Cloud KMS pour 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

Pour exécuter ce code, commencez par configurer un environnement de développement Go, puis installez le SDK Cloud KMS pour 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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Cloud KMS pour Java.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js, puis installez le SDK Cloud KMS pour Node.js.

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

Pour exécuter ce code, commencez par en apprendre plus sur l'utilisation de PHP sur Google Cloud et installez le SDK Cloud KMS pour PHP.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python, puis installez le SDK Cloud KMS pour Python.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Ruby, puis installez le SDK Cloud KMS pour 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

Ces exemples utilisent curl comme client HTTP pour démontrer l'utilisation de l'API. Pour en savoir plus sur le contrôle des accès, consultez la page Accéder à l'API Cloud KMS.

Détruisez une version de clé en appelant la 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"

Remplacez les éléments suivants :

  • PROJECT_ID: identifiant du projet contenant la version de clé que vous souhaitez détruire.
  • LOCATION: emplacement du trousseau de clés contenant la version de clé que vous souhaitez détruire.
  • KEY_RING: nom du trousseau de clés contenant la version de clé que vous souhaitez détruire.
  • KEY_NAME: nom de la clé contenant la version de clé que vous souhaitez détruire.
  • KEY_VERSION: numéro de la version de clé que vous souhaitez détruire.

Si vous ne parvenez pas à détruire une version de clé, votre organisation peut exiger que les versions de clé soient désactivées avant leur destruction. Essayez de désactiver la version de clé avant de la détruire.

Lorsque vous envoyez la requête de destruction, l'état de la version de clé devient "Destruction programmée". Une fois la durée de destruction programmée configurée pour la clé écoulée, l'état de la version de clé devient "Détruite", ce qui signifie que la suppression logique du matériel de clé des systèmes actifs a commencé et que le client ne peut plus récupérer le matériel de clé. Le matériel de clé peut rester dans les systèmes Google jusqu'à 45 jours à compter de l' heure de destruction programmée.

Pour recevoir une alerte lorsque la destruction d'une version de clé est programmée, consultez la page Utiliser Cloud Monitoring avec Cloud KMS.

Les versions de clé détruites ne sont pas des ressources facturées.

Détruire des clés externes

Pour supprimer définitivement l'association entre une clé Cloud EKM et une clé externe, vous pouvez détruire la version de clé. Une fois la période Destruction programmée écoulée, la clé est détruite. Une fois la version de clé détruite, vous ne pouvez plus chiffrer, ni déchiffrer des données chiffrées avec la version de clé Cloud EKM.

La destruction d'une version de clé gérée manuellement dans Cloud KMS ne modifie pas la clé dans le gestionnaire de clés externe. Nous vous recommandons de commencer par détruire la clé ou la version de clé dans Google Cloud. Une fois la version de clé Cloud EKM détruite, vous pouvez détruire le matériel de clé dans le gestionnaire de clés externe.

La destruction d'une version de clé externe coordonnée dans Cloud KMS détruit d'abord la version de clé dans Google Cloud, puis envoie une requête de destruction à l'EKM pour détruire le matériel de clé externe.

Restaurer une version de clé

Durant la période où l'état d'une version de clé est "Destruction programmée", vous pouvez restaurer la version de clé en envoyant une requête de restauration.

Console

  1. Dans la Google Cloud console, accédez à la page Gestion des clés.

    Accéder à Key Management

  2. Cliquez sur le nom du trousseau de clés contenant la version de clé que vous souhaitez restaurer.

  3. Cliquez sur la clé contenant la version de clé que vous souhaitez restaurer.

  4. Cochez l'option située à côté de la version de clé que vous souhaitez restaurer.

  5. Cliquez sur Restaurer dans l'en-tête.

  6. Dans l'invite de confirmation, cliquez sur Restaurer.

gcloud

Pour utiliser Cloud KMS sur la ligne de commande, commencez par installer ou mettre à jour la dernière version de Google Cloud CLI.

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

Remplacez les éléments suivants :

  • KEY_VERSION: numéro de la version de clé que vous souhaitez restaurer.
  • KEY_NAME: nom de la clé contenant la version de clé que vous souhaitez restaurer.
  • KEY_RING: nom du trousseau de clés contenant la version de clé que vous souhaitez restaurer.
  • LOCATION: emplacement du trousseau de clés contenant la version de clé que vous souhaitez restaurer.

Pour en savoir plus sur toutes les options et valeurs possibles, exécutez la commande avec l'option --help.

C#

Pour exécuter ce code, commencez par configurer un environnement de développement C#, puis installez le SDK Cloud KMS pour 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

Pour exécuter ce code, commencez par configurer un environnement de développement Go, puis installez le SDK Cloud KMS pour 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

Pour exécuter ce code, commencez par configurer un environnement de développement Java et installez le SDK Cloud KMS pour Java.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Node.js, puis installez le SDK Cloud KMS pour Node.js.

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

Pour exécuter ce code, commencez par en apprendre plus sur l'utilisation de PHP sur Google Cloud et installez le SDK Cloud KMS pour PHP.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Python, puis installez le SDK Cloud KMS pour Python.

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

Pour exécuter ce code, commencez par configurer un environnement de développement Ruby, puis installez le SDK Cloud KMS pour 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

Ces exemples utilisent curl comme client HTTP pour démontrer l'utilisation de l'API. Pour en savoir plus sur le contrôle des accès, consultez la page Accéder à l'API Cloud KMS.

Restaurez une version de clé en appelant la 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"

Remplacez les éléments suivants :

  • PROJECT_ID: identifiant du projet contenant la version de clé que vous souhaitez restaurer.
  • LOCATION: emplacement du trousseau de clés contenant la version de clé que vous souhaitez restaurer.
  • KEY_RING: nom du trousseau de clés contenant la version de clé que vous souhaitez restaurer.
  • KEY_NAME: nom de la clé contenant la version de clé que vous souhaitez restaurer.
  • KEY_VERSION: numéro de la version de clé que vous souhaitez restaurer.

Une fois la requête de restauration terminée, l'état de la version de clé devient "Désactivée". Vous devez activer la clé avant de pouvoir l'utiliser.

Autorisations IAM requises

Pour détruire une version de clé, l'appelant doit disposer de l'autorisation IAM cloudkms.cryptoKeyVersions.destroy sur la clé, le trousseau de clés, ou sur le projet, le dossier ou l'organisation.

Pour restaurer une version de clé, l'appelant doit disposer de l'autorisation cloudkms.cryptoKeyVersions.restore.

Ces deux autorisations sont accordées au rôle d'administrateur Cloud KMS (roles/cloudkms.admin).

Calendrier de suppression

Cloud KMS s'engage à supprimer le matériel de clé client de toute l'infrastructure Google dans les 45 jours suivant l'heure de destruction programmée. Cela inclut la suppression des données des systèmes actifs et des sauvegardes du centre de données. Les autres données client sont soumises au calendrier de suppression standard Google Cloud de 180 jours.