Cette page a été traduite par l'API Cloud Translation.

Créer des ressources protégées à l'aide de Cloud KMS Autokey

Cette page explique comment créer des ressources protégées à l'aide de clés créées par Cloud KMS Autokey pour le chiffrement. Pour en savoir plus sur Autokey, consultez la présentation d'Autokey.

Avant de commencer

Pour obtenir les autorisations nécessaires pour utiliser Autokey afin de créer des ressources protégées, demandez à votre administrateur de vous attribuer le rôle IAM Utilisateur Cloud KMS Autokey (roles/cloudkms.autokeyUser) sur le dossier ou le projet. 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.

Vous devez également disposer des autorisations de création de ressources dans le dossier Autokey ou sur un projet de ressources au sein du dossier. Pour en savoir plus sur les autorisations requises pour créer chaque ressource, consultez la documentation spécifique au service. Pour accéder à cette documentation, localisez le service dans le tableau des intégrations CMEK et cliquez sur le lien correspondant au type de ressource que vous souhaitez créer.

Utiliser Autokey avec des ressources Compute Engine

Autokey crée une clé pour chaque disque, image et image système au même emplacement que la ressource en cours de création.

Autokey ne crée pas de clés pour les instantanés. Les instantanés doivent utiliser la même clé que celle utilisée pour chiffrer le disque. Si vous créez un instantané à l'aide de la console Google Cloud, la clé de chiffrement utilisée par le disque est automatiquement appliquée à l'instantané. Si vous créez un instantané à l'aide de gcloud CLI, de Terraform ou de l'API Cloud KMS, vous devez identifier la clé utilisée pour chiffrer le disque, puis vous servir de cette clé pour chiffrer l'instantané.

Pour en savoir plus sur l'utilisation de CMEK avec des instantanés, consultez la page Créer un instantané à partir d'un disque chiffré avec une CMEK.

Créer une ressource Compute Engine protégée

Console

Pour créer un disque, procédez comme suit:

Dans la console Google Cloud, accédez à la page Disques.
Accéder à la page Disques
Cliquez sur Créer un disque et saisissez les propriétés du nouveau disque.
Sous Chiffrement, sélectionnez Clé Cloud KMS.
Dans le champ Type de clé, sélectionnez Cloud KMS avec Autokey, puis cliquez sur Demander une nouvelle clé. Un message s'affiche lorsque votre clé a bien été créée et qu'elle est prête à être utilisée.
Pour terminer la création du disque, cliquez sur Créer.

Vous pouvez suivre un processus similaire pour créer des ressources protégées d'instance de VM, d'image et d'image système.

Terraform

L'exemple Terraform suivant crée un poigné de clé et utilise la clé renvoyée pour protéger une nouvelle ressource de disque persistant:

resource "google_kms_key_handle" "my_key_handle" {
  provider               = google-beta
  project                = "RESOURCE_PROJECT_ID"
  name                   = "KEY_HANDLE"
  location               = "LOCATION"
  resource_type_selector = "compute.googleapis.com/Disk"
}

resource "google_compute_disk" "persistent_disk" {
  project = "RESOURCE_PROJECT_ID"
  name    = "DISK_NAME"
  type    = "pd-ssd"
  zone    = "ZONE"
  size    = 30
  physical_block_size_bytes = 4096
  disk_encryption_key {
    kms_key_self_link = my_key_handle.kms_key
  }
}

Remplacez les éléments suivants :

RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
KEY_HANDLE: ID à utiliser pour le handle de clé.
LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
DISK_NAME : le nom du nouveau disque.
ZONE: zone de la ressource protégée. Il doit s'agir d'une zone située dans l'emplacement où vous créez la ressource. Par exemple, si vous créez la ressource à l'emplacement us-central1, la zone peut être us-central1-a.

API

Demandez une nouvelle clé Cloud KMS en créant un objet KeyHandle:
```
curl -H "Content-Type: application/json" \
    -H "X-Goog-User-Project: USER_PROJECT" \
    -H "Authorization: Bearer TOKEN" \
    -X POST https://cloudkms.googleapis.com/v1/projects/RESOURCE_PROJECT_ID/locations/LOCATION/keyHandles \
    -d '{"resource_type_selector": "RESOURCE_TYPE"}'
```
Remplacez les éléments suivants :
- USER_PROJECT: projet à facturer pour les frais associés à cette requête.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
- RESOURCE_TYPE: type de ressource que vous souhaitez créer (par exemple, compute.googleapis.com/Disk).
Le résultat ressemble à ce qui suit :
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.CreateKeyHandleMetadata"
  }
}
```
Notez la valeur OPERATION_ID indiquée dans le résultat. Vous avez besoin de cette valeur pour obtenir l'ID de ressource de la clé créée.
Recherchez la clé Cloud KMS associée au handle de clé:
```
curl -H "X-Goog-User-Project: USER_PROJECT" \
    -H "Authorization: Bearer TOKEN" \
    -X GET https://cloudkms.googleapis.com/v1/projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID
```
Remplacez les éléments suivants :
- USER_PROJECT: projet à facturer pour les frais associés à cette requête.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
- OPERATION_ID: identifiant de l'opération de requête de gestion des clés issue du résultat de l'étape précédente.
Le résultat ressemble à ce qui suit :
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.KeyHandle",
    "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/keyHandles/KEY_HANDLE",
    "kmsKey": "projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/autokey/cryptoKeys/KEY_NAME",
    "resourceTypeSelector": "RESOURCE_TYPE"
  }
}
```
La valeur de l'élément kmsKey dans le résultat correspond à l'ID de ressource complet de la clé créée par Autokey pour cette ressource. Vous pouvez utiliser cet ID de ressource de la même manière que l'ID de ressource d'une autre ressource Cloud KMS.
Créez un disque chiffré à l'aide de la commande gcloud compute disks create, avec l'option --kms-key:
```
gcloud compute disks create DISK_NAME \
  --kms-key projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/autokey/cryptoKeys/KEY_NAME
```
Remplacez les éléments suivants :
- DISK_NAME : le nom du nouveau disque.
- KEY_PROJECT_ID: ID du projet de clé.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource.
- KEY_NAME: nom de la clé renvoyée dans le résultat de l'étape précédente.

Utiliser Autokey avec des ressources Cloud Storage

Autokey crée une clé au même emplacement que le bucket. La clé créée par Autokey est définie comme clé par défaut du bucket.

Autokey ne crée pas de clés pour les objets. Par défaut, les objets créés dans un bucket utilisent la clé par défaut du bucket. Si vous souhaitez chiffrer un objet à l'aide d'une clé autre que la clé par défaut du bucket, vous pouvez créer manuellement une clé CMEK et l'utiliser lors de la création de l'objet.

Si vous souhaitez modifier la clé par défaut attribuée à un bucket, vous pouvez utiliser n'importe quelle clé CMEK existante, y compris les clés créées par Autokey.

Créer une ressource Cloud Storage protégée

Console

Dans la console Google Cloud, accédez à la page Créer un bucket.
Accéder à la page "Créer un bucket"
Suivez les instructions pour créer un bucket jusqu'à ce que vous accédiez à l'étape Choisir comment protéger les données d'objet.
Sous Choisissez comment protéger les données d'objet, développez la section Chiffrement des données, puis sélectionnez Clé Cloud KMS.
Dans le champ Type de clé, sélectionnez Cloud KMS avec Autokey, puis cliquez sur Demander une nouvelle clé. Un message s'affiche lorsque votre clé a bien été créée et qu'elle est prête à être utilisée.
Pour terminer la création du bucket, cliquez sur Créer.

Terraform

L'exemple Terraform suivant crée un identifiant de clé et utilise la clé renvoyée pour protéger un nouveau bucket de stockage:

resource "google_kms_key_handle" "my_key_handle" {
  provider               = google-beta
  project                = "RESOURCE_PROJECT_ID"
  name                   = "KEY_HANDLE"
  location               = "LOCATION"
  resource_type_selector = "storage.googleapis.com/Bucket"
}

resource "google_storage_bucket" "simple_bucket_name" {
  name                        = "BUCKET_NAME"
  location                    = "LOCATION"
  force_destroy               = true
  project                     = "RESOURCE_PROJECT_ID"
  uniform_bucket_level_access = true
  encryption {
    default_kms_key_name      = my_key_handle.kms_key
  }
}

Remplacez les éléments suivants :

RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
KEY_HANDLE: ID à utiliser pour le handle de clé.
LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
BUCKET_NAME: nom du nouveau bucket.

API

Demandez une nouvelle clé Cloud KMS en créant un objet KeyHandle:
```
curl -H "Content-Type: application/json" \
    -H "X-Goog-User-Project: USER_PROJECT" \
    -H "Authorization: Bearer TOKEN" \
    -X POST https://cloudkms.googleapis.com/v1/projects/RESOURCE_PROJECT_ID/locations/LOCATION/keyHandles \
    -d '{"resource_type_selector": "RESOURCE_TYPE"}'
```
Remplacez les éléments suivants :
- USER_PROJECT: projet à facturer pour les frais associés à cette requête.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
- RESOURCE_TYPE: type de ressource que vous souhaitez créer (par exemple, storage.googleapis.com/Bucket).
Le résultat ressemble à ce qui suit :
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.CreateKeyHandleMetadata"
  }
}
```
Notez la valeur OPERATION_ID indiquée dans le résultat. Vous avez besoin de cette valeur pour obtenir l'ID de ressource de la clé créée.
Recherchez la clé Cloud KMS associée au handle de clé:
```
curl -H "X-Goog-User-Project: USER_PROJECT" \
    -H "Authorization: Bearer TOKEN" \
    -X GET https://cloudkms.googleapis.com/v1/projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID
```
Remplacez les éléments suivants :
- USER_PROJECT: projet à facturer pour les frais associés à cette requête.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
- OPERATION_ID: identifiant de l'opération de requête de gestion des clés issue du résultat de l'étape précédente.
Le résultat ressemble à ce qui suit :
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.KeyHandle",
    "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/keyHandles/KEY_HANDLE",
    "kmsKey": "projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/autokey/cryptoKeys/KEY_NAME",
    "resourceTypeSelector": "RESOURCE_TYPE"
  }
}
```
La valeur de l'élément kmsKey dans le résultat correspond à l'ID de ressource complet de la clé créée par Autokey pour cette ressource. Vous pouvez utiliser cet ID de ressource de la même manière que vous le feriez pour toute autre ressource Cloud KMS.
Créez un bucket chiffré à l'aide de la commande gcloud storage buckets create, avec l'option --default-encryption-key:
```
gcloud storage buckets create gs://BUCKET_NAME \
    --location=LOCATION \
    --default-encryption-key=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/autokey/cryptoKeys/KEY_NAME
```
Remplacez les éléments suivants :
- BUCKET_NAME: nom du nouveau bucket. Le nom du bucket doit respecter les exigences de dénomination des buckets.
- LOCATION: emplacement dans lequel vous souhaitez créer le bucket.
- KEY_PROJECT_ID: ID du projet de clé.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource.
- KEY_NAME: nom de la clé renvoyée dans le résultat de l'étape précédente.

Utiliser Autokey avec des ressources BigQuery

Cloud KMS est disponible dans plusieurs éditions de BigQuery. Assurez-vous que l'édition de BigQuery que vous utilisez est compatible avec Cloud KMS avant d'essayer de protéger vos ressources BigQuery à l'aide d'Autokey. Pour en savoir plus sur les éditions BigQuery, consultez Comprendre les éditions BigQuery.

Pour chaque nouvel ensemble de données, Autokey crée une clé au même emplacement que la ressource elle-même, qui devient la clé par défaut de l'ensemble de données.

Autokey ne crée pas de clés pour les tables, les requêtes, les tables temporaires ou les modèles. Par défaut, ces ressources sont protégées par la clé par défaut de l'ensemble de données. Si vous souhaitez protéger une ressource d'un ensemble de données à l'aide d'une clé autre que la clé par défaut de l'ensemble de données, vous pouvez créer manuellement une clé CMEK et l'utiliser lors de la création de la ressource.

Pour les requêtes et les tables temporaires qui ne font pas partie d'un ensemble de données, utilisez les clés par défaut du projet. Utilisez une clé de projet par défaut différente pour chaque emplacement du projet contenant des ressources BigQuery. Pour en savoir plus sur l'utilisation des clés par défaut du projet, consultez la section Définir une clé par défaut du projet.

Pour en savoir plus sur l'utilisation de CMEK avec BigQuery, consultez la page Clés Cloud KMS gérées par le client.

Créer une ressource BigQuery protégée

Console

Avant d'essayer de créer un ensemble de données BigQuery à l'aide d'Autokey, assurez-vous de disposer des autorisations requises. Pour en savoir plus sur la création d'ensembles de données, consultez la page Créer des ensembles de données.

Dans la console Google Cloud, accédez à la page BigQuery.
Accéder à BigQuery
Suivez les instructions pour créer un ensemble de données jusqu'à accéder à Options avancées > Chiffrement.
Sous Chiffrement, sélectionnez Clé Cloud KMS.
Dans le champ Type de clé, sélectionnez Cloud KMS avec Autokey, puis cliquez sur Demander une nouvelle clé. Un message s'affiche lorsque votre clé a bien été créée et qu'elle est prête à être utilisée.
Pour terminer la création de l'ensemble de données, cliquez sur Créer l'ensemble de données.

Terraform

L'exemple Terraform suivant crée un identifiant de clé et utilise la clé renvoyée pour protéger un nouvel ensemble de données:

resource "google_kms_key_handle" "my_key_handle" {
  provider               = google-beta
  project                = "RESOURCE_PROJECT_ID"
  name                   = "test-key-handle"
  location               = "LOCATION"
  resource_type_selector = "bigquery.googleapis.com/Dataset"
}

resource "google_bigquery_dataset" "dataset" {
  dataset_id                  = "DATASET_ID"
  friendly_name               = "DATASET_NAME"
  description                 = "DATASET_DESCRIPTION"
  location                    = "LOCATION"
  default_table_expiration_ms = 3600000

  default_encryption_configuration {
    kms_key_name = my_key_handle.kms_key
  }
}

Remplacez les éléments suivants :

RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
DATASET_ID: ID à utiliser pour le nouvel ensemble de données.
DATASET_NAME: nom convivial du nouvel ensemble de données.
DATASET_DESCRIPTION: description du nouvel ensemble de données.

API

Demandez une nouvelle clé Cloud KMS en créant un objet KeyHandle:
```
curl -H "Content-Type: application/json" \
    -H "X-Goog-User-Project: USER_PROJECT" \
    -H "Authorization: Bearer TOKEN" \
    -X POST https://cloudkms.googleapis.com/v1/projects/RESOURCE_PROJECT_ID/locations/LOCATION/keyHandles \
    -d '{"resource_type_selector": "RESOURCE_TYPE"}'
```
Remplacez les éléments suivants :
- USER_PROJECT: projet à facturer pour les frais associés à cette requête.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
- RESOURCE_TYPE: type de ressource que vous souhaitez créer (par exemple, bigquery.googleapis.com/Dataset).
Le résultat ressemble à ce qui suit :
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.CreateKeyHandleMetadata"
  }
}
```
Notez la valeur OPERATION_ID indiquée dans le résultat. Vous avez besoin de cette valeur pour obtenir l'ID de ressource de la clé créée.
Recherchez la clé Cloud KMS associée au handle de clé:
```
curl -H "X-Goog-User-Project: USER_PROJECT" \
    -H "Authorization: Bearer TOKEN" \
    -X GET https://cloudkms.googleapis.com/v1/projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID
```
Remplacez les éléments suivants :
- USER_PROJECT: projet à facturer pour les frais associés à cette requête.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
- OPERATION_ID: identifiant de l'opération de requête de gestion des clés issue du résultat de l'étape précédente.
Le résultat ressemble à ce qui suit :
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.KeyHandle",
    "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/keyHandles/KEY_HANDLE",
    "kmsKey": "projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/autokey/cryptoKeys/KEY_NAME",
    "resourceTypeSelector": "RESOURCE_TYPE"
  }
}
```
La valeur de l'élément kmsKey dans le résultat correspond à l'ID de ressource complet de la clé créée par Autokey pour cette ressource. Vous pouvez utiliser cet ID de ressource de la même manière que vous le feriez pour toute autre ressource Cloud KMS.
Créez un ensemble de données chiffré à l'aide de la commande bq mk, avec l'option --destination_kms_key.
```
bq --location=LOCATION mk \
    --dataset \
    --default_kms_key=projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/autokey/cryptoKeys/KEY_NAME \
    --default_table_expiration=TABLE_EXPIRATION \
    --description="DATASET_DESCRIPTION" \
    RESOURCE_PROJECT_ID:DATASET_ID
```
Remplacez les éléments suivants :
- LOCATION: emplacement dans lequel vous souhaitez créer l'ensemble de données.
- KEY_PROJECT_ID: ID du projet de clé.
- KEY_NAME: nom de la clé renvoyée dans le résultat de l'étape précédente.
- TABLE_EXPIRATION: durée de vie par défaut en secondes des nouvelles tables de cet ensemble de données.
- DATASET_DESCRIPTION: description du nouvel ensemble de données.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- DATASET_ID: ID de l'ensemble de données que vous créez.
Pour en savoir plus sur l'outil bq, consultez la page Explorer l'outil de ligne de commande bq.

Utiliser Autokey avec des ressources Secret Manager

Autokey crée une clé unique pour protéger tous les secrets du même projet et du même emplacement. Lors de la rotation de la clé, les nouveaux secrets ajoutés au projet utilisent la nouvelle version principale de la clé.

Secret Manager n'est compatible avec Cloud KMS Autokey que lors de la création de ressources à l'aide de Terraform ou de l'API REST.

Créer une ressource Secret Manager protégée

Terraform

L'exemple Terraform suivant crée un identifiant de clé et utilise la clé renvoyée pour protéger un nouveau secret grâce à la réplication automatique:

resource "google_kms_key_handle" "my_key_handle" {
  provider               = google-beta
  project                = "RESOURCE_PROJECT_ID"
  name                   = "test-key-handle"
  location               = "global"
  resource_type_selector = "secretmanager.googleapis.com/Secret"
}

resource "google_secret_manager_secret" "my_secret" {
  secret_id = "SECRET_ID"

  replication {
    auto {
      customer_managed_encryption {
        kms_key_name = my_key_handle.kms_key
      }
    }
  }
}

Remplacez les éléments suivants :

RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
SECRET_ID: ID à utiliser pour le nouveau secret.

Si vous tentez de créer un handle de clé pour un secret dans le projet et l'emplacement pour lesquels un handle de clé existe déjà, un message d'erreur renvoie les détails du handle de clé existant. Dans ce cas, assurez-vous qu'un seul bloc crée le handle de clé. Vous pouvez réutiliser le gestionnaire de clé à l'aide de son ID (KEY_HANDLE) pour créer d'autres secrets devant partager la clé.

API

Demandez une nouvelle clé Cloud KMS en créant un objet KeyHandle:
```
curl -H "Content-Type: application/json" \
    -H "X-Goog-User-Project: USER_PROJECT" \
    -H "Authorization: Bearer TOKEN" \
    -X POST https://cloudkms.googleapis.com/v1/projects/RESOURCE_PROJECT_ID/locations/LOCATION/keyHandles \
    -d '{"resource_type_selector": "RESOURCE_TYPE"}'
```
Remplacez les éléments suivants :
- USER_PROJECT: projet à facturer pour les frais associés à cette requête.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
- RESOURCE_TYPE: type de ressource que vous souhaitez créer (par exemple, secretmanager.googleapis.com/Secret).
Le résultat ressemble à ce qui suit :
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.CreateKeyHandleMetadata"
  }
}
```
Notez la valeur OPERATION_ID indiquée dans le résultat. Vous avez besoin de cette valeur pour obtenir l'ID de ressource de la clé créée.

Si vous essayez de créer un handle de clé pour un secret dans le projet et l'emplacement pour lesquels un handle de clé existe déjà, un message d'erreur renvoie les détails du handle de clé existant. Dans ce cas, ignorez l'étape suivante et utilisez l'ID de ressource de la clé dans le champ existingKmsKey pour protéger votre nouveau secret.
Recherchez la clé Cloud KMS associée au handle de clé:
```
curl -H "X-Goog-User-Project: USER_PROJECT" \
    -H "Authorization: Bearer TOKEN" \
    -X GET https://cloudkms.googleapis.com/v1/projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID
```
Remplacez les éléments suivants :
- USER_PROJECT: projet à facturer pour les frais associés à cette requête.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer la ressource protégée.
- OPERATION_ID: identifiant de l'opération de requête de gestion des clés issue du résultat de l'étape précédente.
Le résultat ressemble à ce qui suit :
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.KeyHandle",
    "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/keyHandles/KEY_HANDLE",
    "kmsKey": "projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/autokey/cryptoKeys/KEY_NAME",
    "resourceTypeSelector": "RESOURCE_TYPE"
  }
}
```
La valeur de l'élément kmsKey dans le résultat correspond à l'ID de ressource complet de la clé créée par Autokey pour cette ressource. Vous pouvez utiliser cet ID de ressource de la même manière que vous le feriez pour toute autre ressource Cloud KMS.
Créez un secret chiffré avec réplication automatique à l'aide de la commande gcloud secrets create, avec l'option --kms-key-name.
```
gcloud secrets create "SECRET_ID" \
    --replication-policy "automatic" \
    --kms-key-name "projects/KEY_PROJECT_ID/locations/global/keyRings/autokey/cryptoKeys/KEY_NAME" \
    --project "RESOURCE_PROJECT_ID"
```
Remplacez les éléments suivants :
- SECRET_ID: ID à utiliser pour le nouveau secret.
- KEY_PROJECT_ID: ID du projet de clé.
- KEY_NAME: nom de la clé renvoyée dans le résultat de l'étape précédente.
- RESOURCE_PROJECT_ID: ID du projet de ressources dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.

Étapes suivantes

Découvrez quand utiliser Autokey.
En savoir plus sur le fonctionnement d'Autokey