Questa pagina è stata tradotta dall'API Cloud Translation.

Creare risorse protette utilizzando Cloud KMS Autokey

Questa pagina mostra come creare risorse protette utilizzando le chiavi create Cloud KMS Autokey per la crittografia. Per ulteriori informazioni Autokey, consulta la Panoramica di Autokey.

Prima di iniziare

Prima di poter creare risorse protette utilizzando Autokey, devi completa i seguenti passaggi per prepararti:

Se non hai già un progetto di risorse all'interno di Autokey , devi creare crea un progetto per contenere le risorse che prevedi di creare.
Per ottenere le autorizzazioni necessarie per utilizzare Autokey per creare file protetti , chiedi all'amministratore di concederti Ruolo IAM Cloud KMS Autokey User (roles/cloudkms.autokeyUser) nella cartella o nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite la ruoli o altri ruoli predefiniti ruoli.
Devi disporre anche delle autorizzazioni per la creazione di risorse nella cartella Autokey o su un progetto di risorse all'interno della cartella. Per ulteriori informazioni sui autorizzazioni necessarie per creare ogni risorsa, consulta le autorizzazioni documentazione. Puoi trovare questa documentazione individuando il servizio in la CMEK di integrazione e visitando il link per il tipo di risorsa che vuoi creare.

Utilizzo di Autokey con le risorse Compute Engine

Autokey crea una nuova chiave per ogni disco, immagine e immagine macchina in nella stessa località della risorsa che viene creata.

Autokey non crea nuove chiavi per gli snapshot. Gli snapshot devono utilizzare la stessa chiave utilizzata per criptare il disco. Se crei uno snapshot utilizzando nella console Google Cloud, la chiave di crittografia utilizzata dal disco viene automaticamente applicati allo snapshot. Se crei uno snapshot utilizzando gcloud CLI, Terraform o API Cloud KMS, devi identificare la chiave utilizzata per criptare il disco e e usare quella chiave per criptare lo snapshot.

Per saperne di più sull'utilizzo di CMEK con gli snapshot, vedi Creare uno snapshot da un disco criptato con CMEK.

Crea una risorsa Compute Engine protetta

Console

Per creare un disco, completa questi passaggi:

Nella console Google Cloud, vai alla pagina Dischi.
Vai a dischi
Fai clic su Crea disco e inserisci le proprietà del nuovo disco.
In Crittografia, seleziona Chiave Cloud KMS.
In Tipo di chiave, seleziona Cloud KMS con Autokey e fai clic su Richiedi una nuova chiave. Un messaggio indica quando la chiave è stata creato correttamente ed è pronto per l'uso.
Per completare la creazione del disco, fai clic su Crea.

Puoi seguire una procedura simile per creare istanze VM, immagini e immagini macchina.

Terraform

Il seguente esempio di Terraform crea un handle della chiave e utilizza la chiave restituita per proteggere una nuova risorsa del disco permanente:

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
  }
}

Sostituisci quanto segue:

RESOURCE_PROJECT_ID: l'ID del progetto della risorsa all'interno della cartella Autokey in cui vuoi creare un'immagine risorsa.
KEY_HANDLE: un ID da utilizzare per l'handle della chiave.
LOCATION: la località in cui vuoi creare l'elemento risorsa.
DISK_NAME: il nome del nuovo disco.
ZONE: la zona della risorsa protetta. Deve una zona all'interno della località in cui stai creando la risorsa. Per Ad esempio, se crei la risorsa nella località us-central1, la zona potrebbe essere us-central1-a.

API

Richiedi una nuova chiave Cloud KMS creando 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"}'
```
Sostituisci quanto segue:
- USER_PROJECT: il progetto a cui verranno addebitati gli addebiti associati a questa richiesta.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- LOCATION: la posizione in cui vuoi creare risorsa protetta.
- RESOURCE_TYPE: il tipo di risorsa che vuoi creare, ad esempio compute.googleapis.com/Disk.
L'output è simile al seguente:
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.CreateKeyHandleMetadata"
  }
}
```
Prendi nota del valore OPERATION_ID dell'output. È necessario questo valore per ottenere l'ID risorsa della chiave creata.
Trova la chiave Cloud KMS associata all'handle della chiave:
```
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
```
Sostituisci quanto segue:
- USER_PROJECT: il progetto a cui verranno addebitati gli addebiti associati a questa richiesta.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- LOCATION: la posizione in cui vuoi creare risorsa protetta.
- OPERATION_ID: l'identificatore della richiesta di handle della chiave dall'output del passaggio precedente.
L'output è simile al seguente:
```
{
  "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"
  }
}
```
Il valore dell'elemento kmsKey nell'output è l'ID risorsa completo di la chiave creata da Autokey per questa risorsa. Puoi utilizzare questo nello stesso modo in cui useresti l'ID risorsa per qualsiasi Risorsa Cloud KMS.
Crea un disco criptato utilizzando il gcloud compute disks create utilizzando il comando kubectl, Flag --kms-key:
```
gcloud compute disks create DISK_NAME \
  --kms-key projects/KEY_PROJECT_ID/locations/LOCATION/keyRings/autokey/cryptoKeys/KEY_NAME
```
Sostituisci quanto segue:
- DISK_NAME: il nome del nuovo disco.
- KEY_PROJECT_ID: l'ID del progetto chiave.
- LOCATION: la posizione in cui vuoi creare risorsa.
- KEY_NAME: il nome della chiave restituita nell'output da al passaggio precedente.

Utilizzo di Autokey con le risorse Cloud Storage

Autokey crea una nuova chiave nella stessa località del bucket. La chiave creata da Autokey è assegnata come chiave predefinita del bucket.

Autokey non crea chiavi per gli oggetti. Per impostazione predefinita, gli oggetti creati la chiave predefinita del bucket. Se vuoi criptare un oggetto utilizzando una diversa da quella predefinita del bucket, puoi creare manualmente una CMEK e utilizzare chiave durante la creazione dell'oggetto.

Se vuoi modificare la chiave predefinita assegnata a un bucket, puoi utilizzare qualsiasi una CMEK esistente, incluse le chiavi create da Autokey.

crea una risorsa Cloud Storage protetta

Console

Nella console Google Cloud, vai alla pagina Crea un bucket.
Vai a Crea un bucket
Segui le istruzioni per creare un nuovo bucket. fino a Scegli come proteggere i dati degli oggetti.
In Scegli come proteggere i dati degli oggetti, espandi la sezione Dati crittografia e seleziona Chiave Cloud KMS.
In Tipo di chiave, seleziona Cloud KMS con Autokey e fai clic su Richiedi una nuova chiave. Un messaggio indica quando la chiave è stata creato correttamente ed è pronto per l'uso.
Per completare la creazione del bucket, fai clic su Crea.

Terraform

Il seguente esempio di Terraform crea un handle della chiave e utilizza la chiave restituita per proteggere un nuovo bucket di archiviazione:

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
  }
}

Sostituisci quanto segue:

RESOURCE_PROJECT_ID: l'ID del progetto della risorsa all'interno della cartella Autokey in cui vuoi creare un'immagine risorsa.
KEY_HANDLE: un ID da utilizzare per l'handle della chiave.
LOCATION: la località in cui vuoi creare l'elemento risorsa.
BUCKET_NAME: il nome del nuovo bucket.

API

Richiedi una nuova chiave Cloud KMS creando 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"}'
```
Sostituisci quanto segue:
- USER_PROJECT: il progetto a cui verranno addebitati gli addebiti associati a questa richiesta.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- LOCATION: la posizione in cui vuoi creare risorsa protetta.
- RESOURCE_TYPE: il tipo di risorsa che vuoi creare, ad esempio storage.googleapis.com/Bucket.
L'output è simile al seguente:
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.CreateKeyHandleMetadata"
  }
}
```
Prendi nota del valore OPERATION_ID dell'output. Ti serve per ottenere l'ID risorsa della chiave creata.
Trova la chiave Cloud KMS associata all'handle della chiave:
```
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
```
Sostituisci quanto segue:
- USER_PROJECT: il progetto a cui verranno addebitati gli addebiti associati a questa richiesta.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- LOCATION: la posizione in cui vuoi creare risorsa protetta.
- OPERATION_ID: l'identificatore della richiesta di handle della chiave dall'output del passaggio precedente.
L'output è simile al seguente:
```
{
  "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"
  }
}
```
Il valore dell'elemento kmsKey nell'output è l'ID risorsa completo della chiave creata da Autokey per questa risorsa. Puoi utilizzare la modalità questo ID risorsa nello stesso modo in cui useresti l'ID risorsa per di un'altra risorsa Cloud KMS.
Crea un bucket criptato utilizzando gcloud storage buckets create utilizzando il comando kubectl, Flag --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
```
Sostituisci quanto segue:
- BUCKET_NAME: il nome del nuovo bucket. La il nome del bucket deve seguire le requisiti di denominazione dei bucket.
- LOCATION: la posizione in cui vuoi creare di sincronizzare la directory di una VM con un bucket.
- KEY_PROJECT_ID: l'ID del progetto chiave.
- LOCATION: la posizione in cui vuoi creare risorsa.
- KEY_NAME: il nome della chiave restituita nell'output da al passaggio precedente.

Utilizzo di Autokey con le risorse BigQuery

Cloud KMS è disponibile in diverse versioni di BigQuery. Marca che la versione di BigQuery che stai utilizzando sia compatibile Cloud KMS prima di provare a utilizzare Autokey per proteggere di risorse BigQuery. Per ulteriori informazioni su BigQuery consulta Informazioni sulle versioni di BigQuery.

Per ogni nuovo set di dati, Autokey crea una nuova chiave nella stessa posizione come risorsa, che diventa la chiave predefinita del set di dati.

Autokey non crea chiavi per tabelle, query, tabelle temporanee o di machine learning. Per impostazione predefinita, queste risorse sono protette dalla chiave predefinita del set di dati. Se Vuoi proteggere una risorsa in un set di dati utilizzando una chiave diversa dal set di dati. chiave predefinita, puoi creare manualmente una CMEK e utilizzarla durante la creazione risorsa.

Per le query e le tabelle temporanee che non si trovano all'interno di un set di dati, utilizza predefinite. Usa una chiave predefinita di progetto diversa per ogni località nel che contiene risorse BigQuery. Per ulteriori informazioni utilizzando le chiavi predefinite del progetto, Imposta una chiave predefinita del progetto.

Per saperne di più sull'utilizzo di CMEK con BigQuery, vedi Chiavi Cloud KMS gestite dal cliente.

crea una risorsa BigQuery protetta

Console

Prima di tentare di creare un set di dati BigQuery utilizzando Autokey, assicurati di disporre delle autorizzazioni necessarie. Per maggiori informazioni per informazioni sulla creazione di set di dati, consulta Creare set di dati.

Nella console Google Cloud, vai alla pagina BigQuery.
Vai a BigQuery
Segui le istruzioni per creare un set di dati fino a quando vai a Opzioni avanzate > Crittografia.
In Crittografia, seleziona Chiave Cloud KMS.
In Tipo di chiave, seleziona Cloud KMS con Autokey e fai clic su Richiedi una nuova chiave. Un messaggio indica quando la chiave è stata creato correttamente ed è pronto per l'uso.
Per completare la creazione del set di dati, fai clic su Crea set di dati.

Terraform

Il seguente esempio di Terraform crea un handle della chiave e utilizza la chiave restituita per proteggere un nuovo set di dati:

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
  }
}

Sostituisci quanto segue:

RESOURCE_PROJECT_ID: l'ID del progetto della risorsa all'interno della cartella Autokey in cui vuoi creare un'immagine risorsa.
LOCATION: la località in cui vuoi creare l'elemento risorsa.
DATASET_ID: l'ID da utilizzare per il nuovo set di dati.
DATASET_NAME: un nome semplice per il nuovo del set di dati.
DATASET_DESCRIPTION: una descrizione della nuova del set di dati.

API

Richiedi una nuova chiave Cloud KMS creando 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"}'
```
Sostituisci quanto segue:
- USER_PROJECT: il progetto a cui verranno addebitati gli addebiti associati a questa richiesta.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- LOCATION: la posizione in cui vuoi creare risorsa protetta.
- RESOURCE_TYPE: il tipo di risorsa che vuoi creare, ad esempio bigquery.googleapis.com/Dataset.
L'output è simile al seguente:
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.CreateKeyHandleMetadata"
  }
}
```
Prendi nota del valore OPERATION_ID dell'output. Ti serve per ottenere l'ID risorsa della chiave creata.
Trova la chiave Cloud KMS associata all'handle della chiave:
```
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
```
Sostituisci quanto segue:
- USER_PROJECT: il progetto a cui verranno addebitati gli addebiti associati a questa richiesta.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- LOCATION: la posizione in cui vuoi creare risorsa protetta.
- OPERATION_ID: l'identificatore della richiesta di handle della chiave dall'output del passaggio precedente.
L'output è simile al seguente:
```
{
  "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"
  }
}
```
Il valore dell'elemento kmsKey nell'output è l'ID risorsa completo della chiave creata da Autokey per questa risorsa. Puoi utilizzare la modalità questo ID risorsa nello stesso modo in cui useresti l'ID risorsa per di un'altra risorsa Cloud KMS.
Crea un set di dati criptato utilizzando bq mk utilizzando il comando kubectl, Flag --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
```
Sostituisci quanto segue:
- LOCATION: la posizione in cui vuoi creare del set di dati.
- KEY_PROJECT_ID: l'ID del progetto chiave.
- KEY_NAME: il nome della chiave restituita nell'output da al passaggio precedente.
- TABLE_EXPIRATION: la durata predefinita dei nuovi in questo set di dati, in secondi.
- DATASET_DESCRIPTION: una descrizione della nuova del set di dati.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- DATASET_ID: l'ID del set di dati che stai in fase di creazione.
Per ulteriori informazioni sullo strumento bq, consulta Esplora il bq a riga di comando.

Utilizzo di Autokey con le risorse di Secret Manager

Autokey crea un'unica chiave per proteggere tutti i secret nello stesso progetto e la località. Quando la chiave ruota, i nuovi secret aggiunti al progetto utilizzano la nuova una versione primaria della chiave.

Secret Manager è compatibile con Cloud KMS Autokey solo quando e la creazione di risorse usando Terraform o l'API REST.

Crea una risorsa di Secret Manager protetta

Terraform

Il seguente esempio di Terraform crea un handle della chiave e utilizza la chiave restituita per proteggere un nuovo secret con replica automatica:

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
      }
    }
  }
}

Sostituisci quanto segue:

RESOURCE_PROJECT_ID: l'ID del progetto della risorsa all'interno della cartella Autokey in cui vuoi creare un'immagine risorsa.
SECRET_ID: l'ID da utilizzare per il nuovo secret.

Se provi a creare un handle di chiave per un secret nello stesso progetto posizione per la quale esiste già un handle della chiave, un messaggio di errore restituisce dettagli dell'handle della chiave esistente. In questo caso, assicurati di usare avere un blocco che crea l'handle della chiave. Puoi riutilizzare l'handle della chiave utilizzando e l'ID (KEY_HANDLE) per creare secret aggiuntivi che dovrebbero condividere la chiave.

API

Richiedi una nuova chiave Cloud KMS creando 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"}'
```
Sostituisci quanto segue:
- USER_PROJECT: il progetto a cui verranno addebitati gli addebiti associati a questa richiesta.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- LOCATION: la posizione in cui vuoi creare risorsa protetta.
- RESOURCE_TYPE: il tipo di risorsa che vuoi creare, ad esempio secretmanager.googleapis.com/Secret.
L'output è simile al seguente:
```
{
  "name": "projects/RESOURCE_PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.kms.v1.CreateKeyHandleMetadata"
  }
}
```
Prendi nota del valore OPERATION_ID dell'output. Ti serve per ottenere l'ID risorsa della chiave creata.

Se tenti di creare un handle della chiave per un secret nello stesso progetto e la posizione per cui esiste già un handle della chiave, viene visualizzato un messaggio di errore restituisce i dettagli dell'handle della chiave esistente. In questo caso, salta al passaggio successivo e utilizza l'ID risorsa della chiave nel campo existingKmsKey per proteggere il tuo nuovo secret.
Trova la chiave Cloud KMS associata all'handle della chiave:
```
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
```
Sostituisci quanto segue:
- USER_PROJECT: il progetto a cui verranno addebitati gli addebiti associati a questa richiesta.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.
- LOCATION: la posizione in cui vuoi creare risorsa protetta.
- OPERATION_ID: l'identificatore della richiesta di handle della chiave dall'output del passaggio precedente.
L'output è simile al seguente:
```
{
  "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"
  }
}
```
Il valore dell'elemento kmsKey nell'output è l'ID risorsa completo della chiave creata da Autokey per questa risorsa. Puoi utilizzare la modalità questo ID risorsa nello stesso modo in cui useresti l'ID risorsa per di un'altra risorsa Cloud KMS.
Crea un secret criptato con replica automatica utilizzando il metodo Comando gcloud secrets create, con il flag --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"
```
Sostituisci quanto segue:
- SECRET_ID: l'ID da utilizzare per il nuovo secret.
- KEY_PROJECT_ID: l'ID del progetto chiave.
- KEY_NAME: il nome della chiave restituita nell'output da al passaggio precedente.
- RESOURCE_PROJECT_ID: l'ID progetto della risorsa progetto all'interno della cartella Autokey in cui vuoi creare una risorsa protetta.

Passaggi successivi

Scopri di più su quando utilizzare Autokey.
Scopri di più su come funziona Autokey.