Détruire et restaurer des versions de clé

Cette page vous explique comment programmer une version de clé Cloud Key Management Service de façon permanente de destruction. 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étruisez une version de clé, d'autres informations telles que le nom et le nom de la clé le numéro de version ne sont pas supprimés. 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é conserve l'état "Destruction programmée" pour une durée configurable. Pendant la période 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 avant de détruire une version de clé.

Vous pouvez également désactiver temporairement une version de clé. Mer recommandent de désactiver les versions de clé avant de programmer leur destruction une partie de vos procédures pour vous assurer que la clé peut être détruite en toute sécurité. En fonction de vos règles d'administration, vous devrez peut-être désactiver une clé avant de pouvoir programmer sa 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.

La 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 permanente. Détruire une version de clé est nécessaire présente des risques, y compris les suivants:

• Une 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 de ressources chiffrées.

• Problèmes réglementaires ou de conformité: si vous détruisez une clé requise pour accéder aux données soumises à une durée de conservation avant celle-ci est terminée, cela signifie peut-être que vous enfreignez une règle cette exigence.

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 section Gérer les accès.

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. Activer les journaux pour tous les services ou applications susceptibles d'utiliser la clé version.

3. Activez les journaux sur le projet Cloud KMS contenant 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 des échecs l'accès à la version de clé, configurer l'application ou la ressource à utiliser une autre version de clé.

   Le temps que vous passez à 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 directives pour s'assurer que la version clé la destruction n'a 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 n'est pas responsable en cas d'indisponibilité, de perte de données ou problèmes de conformité 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 voulez pas que la destruction se produise, vous pouvez restaurer la version de clé. 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 Installez la dernière version de Google Cloud CLI ou passez à la dernière version.

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é souhaitée de 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 que la clé est configurée dont la destruction est programmée a est transmis, l'état de la version de clé est détruit. suppression logique du matériel de clé de l'état actif systèmes a commencé et le matériel de clé ne peut pas ê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.

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 que la version de clé Cloud EKM est 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 demande de restauration terminée, l'état de la version de clé devient est 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 Google 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.