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 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 accorder le 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 dans le dossier. Pour en savoir plus sur les autorisations requises pour créer chaque ressource, consultez la documentation spécifique au service. Toi vous pouvez trouver cette documentation en localisant le service dans les intégrations CMEK tableau et en consultant 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 dans 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éthode la même clé que celle utilisée pour chiffrer le disque. Si vous créez un instantané à l'aide de la méthode 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, Terraform ou l'API Cloud KMS, vous devez identifier la clé utilisée pour chiffrer le disque pour chiffrer l'instantané.

Pour en savoir plus sur l'utilisation de CMEK avec des instantanés, consultez la section Créer un instantané à partir d'un disque chiffré par 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 Demandez une nouvelle clé. Un message indique que votre clé a été ont bien été créés et sont prêts à être utilisés.
Pour terminer la création du disque, cliquez sur Créer.

Vous pouvez suivre une procédure similaire pour créer une instance de VM, une image et les ressources d'image système.

Terraform

L'exemple Terraform suivant crée un identifiant 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 = google_kms_key_handle.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 ressource.
KEY_HANDLE: ID à utiliser pour le handle de clé.
LOCATION: emplacement où vous souhaitez créer l'objet protégé ressource.
DISK_NAME : le nom du nouveau disque.
ZONE: zone de la ressource protégée. Cela doit doit correspondre à une zone de l'emplacement où vous créez la ressource. Pour Par exemple, si vous créez la ressource à l'emplacement us-central1, la zone pourrait être us-central1-a.

API

Demandez une nouvelle clé Cloud KMS en créant un 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 auquel les frais doivent être facturés associées à cette demande.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer le 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 auquel les frais doivent être facturés associées à cette demande.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer le ressource protégée.
- OPERATION_ID: identifiant de la requête de gestionnaire de clé à partir 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 complet de la ressource la clé créée par Autokey pour cette ressource. Vous pouvez utiliser cette l'ID de ressource de la même manière que vous l'utiliseriez pour toute autre ressource Cloud KMS.
Créez un disque chiffré à l'aide de la commande gcloud compute disks create , avec la commande Indicateur --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 le 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 utiliser la clé par défaut du bucket. Si vous souhaitez chiffrer un objet à l'aide d'un autre que la clé par défaut du bucket, vous pouvez créer une CMEK manuellement et 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 une 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 l'option Choisissez comment protéger les données des objets s'affiche.
Sous Choisissez comment protéger les données des objets, développez la section Données chiffrement, puis sélectionnez Clé Cloud KMS.
Dans le champ Type de clé, sélectionnez Cloud KMS avec Autokey, puis cliquez sur Demandez une nouvelle clé. Un message indique que votre clé a été ont bien été créés et sont prêts à être utilisés.
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      = google_kms_key_handle.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 ressource.
KEY_HANDLE: ID à utiliser pour le handle de clé.
LOCATION: emplacement où vous souhaitez créer l'objet protégé ressource.
BUCKET_NAME: nom du nouveau bucket.

API

Demandez une nouvelle clé Cloud KMS en créant un 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 auquel les frais doivent être facturés associées à cette demande.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer le 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 en avez besoin 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 auquel les frais doivent être facturés associées à cette demande.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer le ressource protégée.
- OPERATION_ID: identifiant de la requête de gestionnaire de clé à partir 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 complet de la ressource 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 l'utiliseriez pour toute autre ressource Cloud KMS.
Créer un bucket chiffré à l'aide de la méthode gcloud storage buckets create , avec la commande Indicateur --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. La le nom du bucket doit suivre exigences relatives aux noms 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 le 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. Marque assurez-vous que l'édition de BigQuery que vous utilisez est compatible avec avant d'essayer d'utiliser Autokey pour protéger aux ressources BigQuery. Pour en savoir plus sur BigQuery, consultez la page 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 tableaux temporaires ou des modèles de ML. 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 dans un ensemble de données à l'aide d'une clé autre que celle de l'ensemble de données par défaut, vous pouvez créer manuellement une clé CMEK et l'utiliser lorsque vous créez ressource.

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

Pour en savoir plus sur l'utilisation des CMEK avec BigQuery, consultez 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 de Autokey, assurez-vous de disposer des autorisations requises. Pour plus pour en savoir plus sur la création des 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'à vous accédez à 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 Demandez une nouvelle clé. Un message indique que votre clé a été ont bien été créés et sont prêts à être utilisés.
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" {
  project                     = "RESOURCE_PROJECT_ID"
  dataset_id                  = "DATASET_ID"
  friendly_name               = "DATASET_NAME"
  description                 = "DATASET_DESCRIPTION"
  location                    = "LOCATION"
  default_table_expiration_ms = 3600000

  default_encryption_configuration {
    kms_key_name = google_kms_key_handle.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 ressource.
LOCATION: emplacement où vous souhaitez créer l'objet protégé ressource.
DATASET_ID: ID à utiliser pour le nouvel ensemble de données.
DATASET_NAME: nom convivial du nouveau ensemble de données.
DATASET_DESCRIPTION: description du nouveau ensemble de données.

API

Demandez une nouvelle clé Cloud KMS en créant un 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 auquel les frais doivent être facturés associées à cette demande.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer le 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 en avez besoin 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 auquel les frais doivent être facturés associées à cette demande.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer le ressource protégée.
- OPERATION_ID: identifiant de la requête de gestionnaire de clé à partir 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 complet de la ressource 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 l'utiliseriez pour toute autre ressource Cloud KMS.
Créer un ensemble de données chiffré à l'aide de la méthode bq mk , avec la commande --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 le 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 des nouvelles tables de cet ensemble de données, en secondes.
- DATASET_DESCRIPTION: description du nouveau ensemble de données.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- DATASET_ID: ID de l'ensemble de données créer.
Pour en savoir plus sur l'outil bq, consultez la section Explorer l'outil de ligne de commande.

Utiliser Autokey avec des ressources Secret Manager

Autokey crée une clé unique pour protéger tous les secrets du projet et l'emplacement. Lors de la rotation de la clé, les nouveaux secrets ajoutés au projet utilisent le nouveau la version principale de la clé.

Secret Manager n'est compatible avec Cloud KMS Autokey que créer des 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" {
  project   = "RESOURCE_PROJECT_ID"
  secret_id = "SECRET_ID"

  replication {
    auto {
      customer_managed_encryption {
        kms_key_name = google_kms_key_handle.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 ressource.
SECRET_ID: ID à utiliser pour le nouveau secret.

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

API

Demandez une nouvelle clé Cloud KMS en créant un 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 auquel les frais doivent être facturés associées à cette demande.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer le 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 en avez besoin pour obtenir l'ID de ressource de la clé créée.

Si vous tentez de créer un handle de clé pour un secret dans le même projet et l'emplacement pour lesquels un identifiant de clé existe déjà, un message d'erreur s'affiche renvoie les détails de la poignée existante. 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 auquel les frais doivent être facturés associées à cette demande.
- RESOURCE_PROJECT_ID: ID de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.
- LOCATION: emplacement dans lequel vous souhaitez créer le ressource protégée.
- OPERATION_ID: identifiant de la requête de gestionnaire de clé à partir 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 complet de la ressource 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 l'utiliseriez pour toute autre ressource Cloud KMS.
Créez un secret chiffré avec réplication automatique à l'aide du Commande gcloud secrets create, avec l'indicateur --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 de projet de la ressource dans le dossier Autokey dans lequel vous souhaitez créer une ressource protégée.

Étape suivante

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