Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Détruire et restaurer des versions de clé

Cette page vous explique comment planifier 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 la rotation d'une clé, vous créez une version de clé.

La destruction d'une version de clé entraîne la suppression définitive du matériel de clé. Lorsque vous détruisez une version de clé, les 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 qui ont été 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.

La destruction des clés étant généralement irréversible, Cloud KMS ne vous permet pas de détruire immédiatement les versions de clé. À la place, vous planifiez la destruction d'une version de clé. La version de clé reste dans l'état "Destruction programmée" pendant une durée configurable. Pendant la période de destruction planifiée, vous pouvez restaurer une version de clé pour annuler sa destruction.

La durée par défaut de la programmation de la destruction est de 30 jours. Vous pouvez définir une durée de suppression planifiée personnalisée pour une clé lors de sa création. Votre organisation peut appliquer une durée minimale de destruction programmée en définissant la contrainte Durée de suppression planifiée minimale par clé dans vos règles d'administration 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, afin de vous assurer que la clé peut être détruite en toute sécurité. Selon vos règles d'administration, vous devrez peut-être désactiver une version de clé avant de pouvoir planifier sa destruction. Pour en savoir plus sur le contrôle de la destruction des versions de clé à l'aide de règles d'administration, consultez Contrôler la destruction des versions de clé.

Remarque : Dans certains cas, vous pouvez supprimer des trousseaux de clés, des clés et des versions de clés. La suppression d'une ressource la supprime des listes de ressources Cloud KMS. La destruction d'une version de clé supprime définitivement son matériel de clé sous-jacent. Lorsque vous supprimez un trousseau de clés, son nom peut être réutilisé, mais les noms des clés supprimées ne peuvent pas l'être. Cela garantit que l'identifiant de ressource d'une version de clé est unique et pointe toujours vers le matériel de clé d'origine pour cette version de clé, sauf s'il a été détruit. Vous pouvez stocker un nombre illimité de trousseaux de clés, de clés activées ou désactivées, et de versions de clés activées, désactivées ou détruites. Pour en savoir plus, consultez Tarifs et Quotas.

Dans la suite de ce document, la programmation de la destruction d'une clé 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 toujours nécessaire comporte des risques, y compris les suivants :

Panne 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 de données permanente : si vous détruisez une clé 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 crypto-détruites. Dans certains cas, la destruction d'une clé peut entraîner la suppression définitive des ressources chiffrées.
Problèmes de réglementation 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 d'enfreindre 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 :

Affichez les détails du suivi de l'utilisation de 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é.

Attention : Les détails du suivi de l'utilisation des clés peuvent être retardés ou incomplets. Familiarisez-vous avec les limites de ces données.
Activez les journaux pour tout service ou application susceptible d'utiliser la version de clé.
Activez les journaux sur le projet Cloud KMS qui contient la clé.
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 de la version de clé échoue.
Surveillez les journaux jusqu'à ce que vous soyez sûr qu'aucune application ni aucun service ne dépendent encore de 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 la destruction d'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, laissez la version de clé désactivée jusqu'à ce que ce processus se termine correctement.
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é peut encore être 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 de la 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

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

Accéder à Key Management
Cochez l'option située à côté de la version de clé dont vous souhaitez programmer la destruction.
Cliquez sur Détruire dans l'en-tête.
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 la 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, découvrez d'abord comment utiliser PHP sur Google Cloud et installez le SDK PHP Cloud KMS.

use Google\Cloud\Kms\V1\Client\KeyManagementServiceClient;
use Google\Cloud\Kms\V1\DestroyCryptoKeyVersionRequest;

function destroy_key_version(
    string $projectId = 'my-project',
    string $locationId = 'us-east1',
    string $keyRingId = 'my-key-ring',
    string $keyId = 'my-key',
    string $versionId = '123'
) {
    // Create the Cloud KMS client.
    $client = new KeyManagementServiceClient();

    // Build the key version name.
    $keyVersionName = $client->cryptoKeyVersionName($projectId, $locationId, $keyRingId, $keyId, $versionId);

    // Call the API.
    $destroyCryptoKeyVersionRequest = (new DestroyCryptoKeyVersionRequest())
        ->setName($keyVersionName);
    $destroyedVersion = $client->destroyCryptoKeyVersion($destroyCryptoKeyVersionRequest);
    printf('Destroyed key version: %s' . PHP_EOL, $destroyedVersion->getName());

    return $destroyedVersion;
}

Python

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"

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é, il est possible que votre organisation exige 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 demande de destruction, l'état de la version de clé passe à "Destruction programmée". Une fois que la durée de destruction programmée configurée de la clé est écoulée, l'état de la version de la 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 matériel de clé ne peut pas être récupéré par le client. Les données de clé peuvent rester dans les systèmes Google pendant 45 jours maximum à 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 la 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é

Pendant 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 demande de restauration.

Console

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

Accéder à Key Management
Cliquez sur le nom du trousseau de clés contenant la version de clé que vous souhaitez restaurer.
Cliquez sur la clé contenant la version de clé que vous souhaitez restaurer.
Cochez l'option située à côté de la version de clé que vous souhaitez restaurer.
Cliquez sur Restaurer dans l'en-tête.
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 la 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, découvrez d'abord comment utiliser PHP sur Google Cloud et installez le SDK PHP Cloud KMS.

use Google\Cloud\Kms\V1\Client\KeyManagementServiceClient;
use Google\Cloud\Kms\V1\RestoreCryptoKeyVersionRequest;

function restore_key_version(
    string $projectId = 'my-project',
    string $locationId = 'us-east1',
    string $keyRingId = 'my-key-ring',
    string $keyId = 'my-key',
    string $versionId = '123'
) {
    // Create the Cloud KMS client.
    $client = new KeyManagementServiceClient();

    // Build the key version name.
    $keyVersionName = $client->cryptoKeyVersionName($projectId, $locationId, $keyRingId, $keyId, $versionId);

    // Call the API.
    $restoreCryptoKeyVersionRequest = (new RestoreCryptoKeyVersionRequest())
        ->setName($keyVersionName);
    $restoredVersion = $client->restoreCryptoKeyVersion($restoreCryptoKeyVersionRequest);
    printf('Restored key version: %s' . PHP_EOL, $restoredVersion->getName());

    return $restoredVersion;
}

Python

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/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 demande de restauration terminée, l'état de la version de clé devient "désactivé". 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, 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 l'ensemble de l'infrastructure Google dans les 45 jours suivant la date de destruction programmée. Cela inclut la suppression des données des systèmes actifs et des sauvegardes des centres de données. Les autres données client sont soumises au Google Cloud délai de suppression standard de 180 jours.

Détruire et restaurer des versions de clé Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Comprendre les risques

Rôles requis

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

Détruire une version de clé

Console

gcloud

C#

Go

Java

Node.js

PHP

Python

Ruby

API

Détruire des clés externes

Restaurer une version de clé

Console

gcloud

C#

Go

Java

Node.js

PHP

Python

Ruby

API

Autorisations IAM requises

Calendrier de suppression

Détruire et restaurer des versions de clé