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 vérifier que les données sont stockées dans une version de clé. Une clé ne comporte aucune ou plusieurs versions de clé. La rotation d'une clé crée une autre clé version.

La destruction d'une version de clé signifie que le matériel de clé est définitivement supprimé. Lorsque vous détruissez une version de clé, d'autres informations telles que le nom et le numéro de version de la clé ne sont pas supprimées. Après la destruction d'une clé, les données chiffrées ne peuvent pas être déchiffrées.

La destruction d'une clé étant irréversible, Cloud KMS ne vous permet pas et détruire immédiatement les versions de clé. À la place, vous planifiez une version de clé pour de destruction. La version de clé reste à l'état de destruction programmée pendant une durée configurable. Pendant la durée de destruction programmée, vous pouvez restaurer une version de clé pour annuler sa destruction.

Par défaut, la destruction programmée est de 30 jours. Vous pouvez définir un durée personnalisée de destruction programmée d'une clé pendant la durée de la clé création. Votre organisation peut appliquer une durée minimale de destruction programmée en définissant la valeur de destruction minimale ; de durée planifiée par clé dans vos 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.

Attention :La destruction d'une clé est une opération permanente qui peut entraîner des problèmes la perte de données. Assurez-vous de comprendre les risques avant de détruire une version de clé.

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 afin de vous assurer qu'elles peuvent être détruites en toute sécurité. Selon les règles de votre organisation, vous devrez peut-être désactiver une version de clé avant de pouvoir la programmer pour destruction. Pour en savoir plus sur contrôle de la destruction des versions de clé à l'aide de règles d'administration, consultez la section Contrôler Destruction de la version de clé.

Remarque: Les trousseaux de clés, les clés et les versions de clé ne peuvent pas être supprimés. Cela permet de s'assurer identifiant de ressource d'un la version de clé est unique et pointe toujours vers le matériel de clé d'origine pour cette version, sauf si a été détruite. Vous pouvez stocker un nombre illimité de trousseaux de clés, ainsi que de clés activées ou désactivées, et des versions de clé activées, désactivées ou détruites. Pour en savoir plus, consultez Tarifs et Quotas.

Dans la suite de ce document, on parle de programmation de la destruction d'une clé comme la 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 définitive. Détruire une version de clé est nécessaire présente des risques, y compris les suivants:

• Interruption de service: si vous détruisez une clé nécessaire au démarrage d'un conteneur vos services ou applications peuvent devenir indisponibles.

• Perte de données permanente: si vous détruisez une clé utilisée pour chiffrer des données, que les données deviennent indisponibles. Données chiffrées à l'aide d'une clé qui a été détruit est considéré comme déchiffré de cryptomonnaie. 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 la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises via 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 voir si la version de clé est utilisée:

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

   Attention :Les informations sur le suivi de l'utilisation des clés peuvent être retardées ou incomplètes. Familiarisez-vous avec les limites de ces données.

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

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

4. Désactivez la version de clé. Désactiver la clé empêche l'utilisation de la version de clé. Avec l'attribut version de clé désactivée. Toute tentative d'utilisation de cette version échouera.

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

   Le temps passé à surveiller les journaux avant de détruire dépend du type de clé, du modèle d'utilisation niveau de sensibilité. Par exemple, avant de détruire une version de clé utilisée dans un processus trimestriel, laissez la version de clé désactivée jusqu'à s'exécute correctement.

6. Vérifiez que l'utilisation de la clé respecte les exigences de conformité applicables. Par exemple, la version de clé et les données chiffrées qui y sont associées peuvent être soumises à leur durée de conservation.

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

Avertissement :Il est de votre responsabilité de vous assurer qu'une version de clé est à détruire en toute sécurité. Google décline toute responsabilité en cas d'indisponibilité, de perte de données ou de non-respect des règles résultant de la destruction d'une version de clé.

Détruire une version de clé

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

Attention: Le matériel de la clé n'est pas immédiatement détruit. La clé la destruction de la version configurée reste programmée pour la durée de la destruction. À l'issue de cette période, le matériel de clé est automatiquement détruites. Il est impossible de contourner ce système de sécurité.

Si vous décidez que vous ne souhaitez plus détruire la version de clé, vous pouvez la restaurer. Cependant, après la configuration la durée de la destruction, celle-ci est irréversible. Toutes les données chiffrées avec cette version de clé ne peut pas être déchiffrée.

Console

1. Dans la console Google Cloud, accédez à 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 version de la clé que vous souhaitez détruire.
• KEY_NAME: nom de la clé pour laquelle vous souhaitez détruire une clé. version.
• KEY_RING : nom du trousseau de clés contenant la clé.
• LOCATION: emplacement Cloud KMS du trousseau de clés

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, puis 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 méthode 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"

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

Lorsque vous envoyez la demande de destruction, l'état de la version de clé devient dont la destruction est programmée. Une fois la durée de destruction programmée de la clé écoulée, l'état de la version de clé devient "Destroyed" (Détruite), ce qui signifie que la suppression logique du matériel de clé des systèmes actifs a commencé et que le matériel de clé ne peut plus être récupéré par le client. Clé le contenu concerné peut rester dans les systèmes Google pendant 45 jours au maximum 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.

Remarque :La destruction de toutes les versions de clé actives ne modifie pas la rotation de la clé programmation, le cas échéant. Si vous souhaitez interrompre la création automatique de nouvelles versions de clé, vous devez également désactiver la rotation automatique sur la clé. Si vous ne désactivez pas l'option rotation, de nouvelles versions de clé continuent d'être créées comme prévu.

Détruire des clés externes

Pour supprimer définitivement l'association entre une clé Cloud EKM et un vous pouvez la détruire. Une fois la période de 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.

Attention :Vous ne pouvez pas recréer une version de clé Cloud EKM qui a été détruit, même si vous utilisez le même URI de clé externe ou le même chemin d'accès à la clé.

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é dans Google Cloud. Une fois la version de la clé Cloud EKM détruite, vous pouvez détruire le matériel de clé dans le gestionnaire de clés externe.

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

Restaurer une version de clé

Pendant la période où la destruction de l'état d'une version de clé est programmée, vous pouvez restaurer la version de clé en envoyant une demande de restauration.

Console

1. Accédez à la page Gestion des clés dans la console Google Cloud.

   Accéder à la page Gestion des clés

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

3. Cliquez sur la clé dont vous souhaitez restaurer la version.

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 Installez la dernière version de Google Cloud CLI.

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

Remplacez key-version par la version de la clé à restaurer. Remplacez key par le nom de la clé. Remplacez key-ring par le nom du trousseau de clés où se trouve la clé. Remplacez location par l'emplacement Cloud KMS du trousseau de clés.

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, puis 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 méthode 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"

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

Autorisations IAM requises

Pour détruire une version de clé, l'appelant a besoin du cloudkms.cryptoKeyVersions.destroy sur la clé, le trousseau de clés, ou 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 tous les services infrastructure 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 des centres de données. Autre client sont soumises à la norme Calendrier de suppression de Google Cloud sur 180 jours.