Encriptar discos con claves de encriptado proporcionadas por el cliente

En este documento se explica cómo encriptar discos con claves de encriptado proporcionadas por el cliente.

Para obtener información sobre el cifrado de disco, consulta el artículo Acerca del cifrado de disco.

Para obtener información sobre cómo cifrar discos con claves de cifrado gestionadas por el cliente (CMEK), consulta el artículo Proteger recursos con claves de Cloud KMS.

Si usas CSEKs, proporcionas tus propias claves de cifrado y Compute Engine las usa para proteger las Google-owned and Google-managed encryption keys que se utilizan para cifrar y descifrar tus datos. Solo los usuarios que puedan proporcionar la clave correcta podrán usar los recursos protegidos por una clave de encriptado proporcionada por el cliente (CSEK).

Google no almacena tus claves en sus servidores y no puede acceder a tus datos protegidos a menos que proporciones la clave. Esto también significa que, si olvidas o pierdes tu clave, Google no podrá recuperarla ni recuperar los datos cifrados con ella.

Cuando eliminas un volumen de disco persistente, Google descarta las claves de cifrado, por lo que los datos no se pueden recuperar. Este proceso es irreversible,

Antes de empezar

• Consulta información sobre los discos, las imágenes y las capturas de disco.
• Si aún no lo has hecho, configura la autenticación. La autenticación verifica tu identidad para acceder a Google Cloud servicios y APIs. Para ejecutar código o ejemplos desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

  Select the tab for how you plan to use the samples on this page:

  Console

  When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

  gcloud

  1. Instala Google Cloud CLI. Después de la instalación, inicializa la CLI de Google Cloud ejecutando el siguiente comando:

     gcloud init

     Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  2. Set a default region and zone.

  Python

  Para usar las Python muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

  Instala Google Cloud CLI.

  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  If you're using a local shell, then create local authentication credentials for your user account:

  gcloud auth application-default login

  You don't need to do this if you're using Cloud Shell.

  If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

  Para obtener más información, consulta Set up authentication for a local development environment.

  REST

  Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.

  Instala Google Cloud CLI.

  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

  Para obtener más información, consulta el artículo Autenticarse para usar REST de la documentación sobre autenticación de Google Cloud .

Restricciones

En el caso de las CSEK, se aplican las siguientes restricciones:

Restricciones generales

La disponibilidad de las claves de cifrado proporcionadas por el cliente depende de la ubicación de tu cuenta de facturación, no de la ubicación del recurso.

Las claves de cifrado proporcionadas por el cliente no están disponibles para las cuentas de facturación de los siguientes países:

• Brasil
• India

Restricciones técnicas

• Con tu propia clave solo puedes encriptar discos persistentes nuevos. Los discos persistentes anteriores no se pueden encriptar con tu clave.

• No puedes usar tus propias claves con discos SSD locales porque estos usan Google-owned and Google-managed encryption keys. Las claves se eliminan cuando se termina la VM.

• Compute Engine no almacena claves de cifrado con plantillas de instancia, por lo que debes almacenar tus propias claves en KMS para cifrar discos en un grupo de instancias gestionado.

• No puedes suspender instancias que tengan discos protegidos con CSEK vinculados.

Especificaciones

En esta sección se describe la especificación del cifrado y el formato de las CSEK.

Cifrado

Compute Engine usa tu clave de cifrado para proteger las claves de cifrado de Google con el cifrado AES-256.

Formato de clave obligatorio

Tú eres quien debe generar y gestionar tu clave. Debes proporcionar a Compute Engine una clave que sea una cadena de 256 bits codificada en Base64 estándar RFC 4648.

A continuación, se muestra un ejemplo de una clave codificada en base64, generada con la cadena "Hello from Google Cloud Platform".

SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=

Se puede generar con la siguiente secuencia de comandos:

read -sp "String:" ; \
    [[ ${#REPLY} == 32 ]] && \
        echo "$(echo -n "$REPLY" | base64)" || \
        (>&2 echo -e "\nERROR:Wrong Size"; false)

Encapsulado de claves RSA

Además de codificar tu clave en base64, puedes envolverla con un certificado de clave pública RSA proporcionado por Google, codificar la clave en base64 y, a continuación, usarla en tus solicitudes.

El encapsulado RSA es un proceso en el que se usa una clave pública para cifrar los datos. Una vez que los datos se han cifrado con la clave pública, solo se pueden descifrar con la clave privada correspondiente. En este caso, la clave privada solo la conocen los Google Cloud servicios. Al envolver tu clave con el certificado RSA, te aseguras de que solo los servicios de Google Cloud puedan desenvolverla y usarla para proteger tus datos.

Para obtener más información, consulta Cifrado RSA.

Para crear una clave envuelta en RSA para Compute Engine, sigue estos pasos:

1. Encapsula tu clave con la clave pública proporcionada en un certificado que gestiona Compute Engine. Asegúrate de encapsular la clave con el relleno OAEP, no con el relleno PKCS #1 v1.5.
2. Codifica tu clave envuelta en RSA con la codificación base64 estándar.

Descarga el certificado público que mantiene Compute Engine desde:

https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem

Hay muchas formas de generar y envolver con RSA tu clave. Utiliza el método que te resulte más familiar. A continuación, se muestran dos ejemplos de envoltorio RSA de tu clave que puedes usar.

Ejemplo 1

En las siguientes instrucciones se usa la utilidad de línea de comandos openssl para envolver y codificar una clave con RSA.

1. Opcional: Genera una clave aleatoria de 256 bits (32 bytes). Si ya tienes una clave que quieres usar, puedes saltarte este paso. Hay muchas formas de generar una clave. Por ejemplo:

   $ head -c 32 /dev/urandom | LC_CTYPE=C tr '\n' = > mykey.txt
   

2. Descarga el certificado de clave pública:

   $  curl -s -O -L https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem

3. Extrae la clave pública del certificado:

   $ openssl x509 -pubkey -noout -in google-cloud-csek-ingress.pem > pubkey.pem
   

4. Envuelve tu clave con RSA. Sustituye mykey.txt por tu propio archivo de clave.

   $ openssl rsautl -oaep -encrypt -pubin -inkey pubkey.pem -in mykey.txt -out rsawrappedkey.txt
   

5. Codifica tu clave envuelta en RSA en base64.

   $ openssl enc -base64 -in rsawrappedkey.txt | tr -d '\n' | sed -e '$a\' > rsawrapencodedkey.txt
   

Ejemplo 2

A continuación, se muestra un ejemplo de secuencia de comandos de Python que genera una cadena aleatoria de 256 bits (32 bytes) y crea una clave envuelta en RSA codificada en base64 mediante la biblioteca cryptography:

import argparse
import base64
import os
from typing import Optional

from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
import requests


GOOGLE_PUBLIC_CERT_URL = (
    "https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem"
)


def get_google_public_cert_key() -> RSAPublicKey:
    """
    Downloads the Google public certificate.

    Returns:
        RSAPublicKey object with the Google public certificate.
    """
    r = requests.get(GOOGLE_PUBLIC_CERT_URL)
    r.raise_for_status()

    # Load the certificate.
    certificate = x509.load_pem_x509_certificate(r.content, default_backend())

    # Get the certicate's public key.
    public_key = certificate.public_key()

    return public_key


def wrap_rsa_key(public_key: RSAPublicKey, private_key_bytes: bytes) -> bytes:
    """
    Use the Google public key to encrypt the customer private key.

    This means that only the Google private key is capable of decrypting
    the customer private key.

    Args:
        public_key: The public key to use for encrypting.
        private_key_bytes: The private key to be encrypted.

    Returns:
        private_key_bytes encrypted using the public_key. Encoded using
        base64.
    """
    wrapped_key = public_key.encrypt(
        private_key_bytes,
        padding.OAEP(
            mgf=padding.MGF1(algorithm=hashes.SHA1()),
            algorithm=hashes.SHA1(),
            label=None,
        ),
    )
    encoded_wrapped_key = base64.b64encode(wrapped_key)
    return encoded_wrapped_key


def main(key_file: Optional[str]) -> None:
    """
    This script will encrypt a private key with Google public key.

    Args:
        key_file: path to a file containing your private key. If not
            provided, a new key will be generated (256 bit).
    """
    # Generate a new 256-bit private key if no key is specified.
    if not key_file:
        customer_key_bytes = os.urandom(32)
    else:
        with open(key_file, "rb") as f:
            customer_key_bytes = f.read()

    google_public_key = get_google_public_cert_key()
    wrapped_rsa_key = wrap_rsa_key(google_public_key, customer_key_bytes)

    b64_key = base64.b64encode(customer_key_bytes).decode("utf-8")

    print(f"Base-64 encoded private key: {b64_key}")
    print(f"Wrapped RSA key: {wrapped_rsa_key.decode('utf-8')}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    parser.add_argument("--key_file", help="File containing your binary private key.")

    args = parser.parse_args()

    main(args.key_file)

Tu llave ya está lista para usarse.

Usar una clave encapsulada con RSA

Con la CLI de Google Cloud, puedes proporcionar una clave normal y una clave envuelta en RSA de la misma forma.

En la API, usa la propiedad sha256 en lugar de rawKey si quieres usar una clave encapsulada con RSA.

Cifrar recursos con CSEK mediante la herramienta de línea de comandos

Configuración

Las claves de cifrado se pueden usar a través de Google Cloud CLI.

Descarga e instala gcloud.

Archivo de claves

Cuando usas la herramienta de línea de comandos gcloud compute para definir tus claves, proporcionas claves codificadas mediante un archivo de claves que contiene tus claves codificadas como una lista JSON. Un archivo de claves puede contener varias claves, lo que te permite gestionar muchas claves en un solo lugar. También puedes crear archivos de claves individuales para gestionar cada clave por separado. Un archivo de claves solo se puede usar con la CLI de gcloud. Cuando se usa REST, la clave debe proporcionarse directamente en la solicitud.

Cada entrada de su archivo de claves debe proporcionar lo siguiente:

• El URI completo del recurso que protege la clave
• La clave correspondiente
• El tipo de clave, ya sea raw o rsa-encrypted

Cuando usas el archivo de claves en tus solicitudes, la herramienta busca recursos coincidentes y usa las claves correspondientes. Si no se encuentran recursos que coincidan, la solicitud falla.

Un archivo de claves de ejemplo tiene este aspecto:

[
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks/example-disk",
  "key": "acXTX3rxrKAFTF0tYVLvydU1riRZTvUNC4g5I11NY+c=",
  "key-type": "raw"
  },
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/global/snapshots/my-private-snapshot",
  "key": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA==",
  "key-type": "rsa-encrypted"
  }
]

Prácticas recomendadas para gestionar el archivo de claves

Si usas un archivo de claves, restringe el acceso a tu archivo solo a las personas que lo necesiten. Asegúrate de definir los permisos adecuados en estos archivos y considera la posibilidad de cifrarlos con herramientas adicionales:

• En Windows, puedes usar BitLocker o Sistema de archivos de cifrado (EFS).
• En macOS, te recomendamos que uses FileVault 2.
• En Linux, puedes usar Linux Unified Key Setup (LUKS) o eCryptfs.

Encriptar un disco persistente nuevo con CSEK

Puedes encriptar un disco persistente nuevo proporcionando una clave durante la creación de la VM o del disco.

gcloud (beta) compute instances create example-instance --csek-key-file example-file.json

gcloud (beta) compute disks create example-disk --csek-key-file example-file.json

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/instances

{
"machineType": "zones/us-central1-a/machineTypes/e2-standard-2",
"disks": [
 {
  "type": "PERSISTENT",
  "diskEncryptionKey": {
    "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
  "initializeParams": {
   "sourceImage": "projects/debian-cloud/global/images/debian-9-stretch-v20170619"
  },
  "boot": true
 }
],
...
}

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/
us-central1-a/disks?sourceImage=https%3A%2F%2Fwww.googleapis.com%2Fcompute%2F
alpha%2Fprojects%2Fdebian-cloud%2Fglobal%2Fimages%2Fdebian-9-stretch-v20170619

{
 "name": "new-encrypted-disk-key",
 "diskEncryptionKey": {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
 "type": "zones/us-central1-a/diskTypes/pd-standard"
}

Crear una captura a partir de un disco cifrado con CSEK

Si creas una captura a partir de un disco cifrado, la captura también debe estar cifrada. Debes especificar una clave para cifrar la instantánea. No puedes convertir discos ni capturas cifrados para que usen el cifrado predeterminado de Compute Engine, a menos que crees una nueva imagen de disco y un nuevo disco persistente.

Las capturas de discos cifrados con CSEK siempre son completas. Esto es diferente de las instantáneas de discos cifrados con claves de cifrado gestionadas por el cliente (CMEK), que son incrementales. El precio de las capturas se basa en su tamaño total, por lo que una captura completa puede costar más que una incremental.

Para crear una captura de disco persistente a partir de un disco cifrado, tu solicitud de creación de la captura debe proporcionar la clave de cifrado que usaste para cifrar el disco persistente.

Consulta las prácticas recomendadas para hacer capturas de discos persistentes antes de crear tu captura.

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks/example-disk/createSnapshot

{
 "snapshotEncryptionKey":  {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
 },
  "sourceDiskEncryptionKey": {
   "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
 "name": "snapshot-encrypted-disk"
}

Crear una imagen a partir de un disco o una imagen personalizada cifrados con CSEK

Puedes crear imágenes personalizadas a partir de discos persistentes cifrados o copiar imágenes cifradas. No puedes usar la consola para copiar imágenes. Usa la CLI de Google Cloud o REST para copiar imágenes.

gcloud (beta) compute images create .... --csek-key-file example-file.json

[
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks/source-disk",
  "key": "acX3RqzxrKAFTF0tYVLvydU1riRZTvUNC4g5I11NY-c=",
  "key-type": "raw"
  },
  {
  "uri": "https://www.googleapis.com/compute/v1/projects/myproject/global/snapshots/the-new-image",
  "key": "TF0t-cSfl7CT7xRF1LTbAgi7U6XXUNC4zU_dNgx0nQc=",
  "key-type": "raw"
  }
]

POST https://compute.googleapis.com/compute/beta/projects/myproject/global/images

{
 "name": "image-encrypted-disk",
 "sourceDiskEncryptionKey": {
    "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  }
 "imageEncryptionKey": {
    "rsaEncryptedKey":  "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
    },
 "sourceDisk": "projects/myproject/zones/us-central1-a/disks/source-disks"
}

Cifrar una imagen importada con CSEK

Puedes cifrar una imagen nueva cuando importes manualmente una imagen personalizada a Compute Engine. Antes de importar una imagen, debes crear y comprimir un archivo de imagen de disco y subir ese archivo comprimido a Cloud Storage.

Importa la imagen personalizada de Compute Engine que quieras cifrar. Especifica el URI del archivo comprimido y la ruta del archivo de clave de cifrado.

gcloud (beta) compute images create [IMAGE_NAME] \
    --source-uri gs://[BUCKET_NAME]/[COMPRESSED_FILE] \
    --csek-key-file [KEY_FILE]

POST https://compute.googleapis.com/compute/beta/projects/myproject/global/images

{
"rawDisk": {
 "source": "http://storage.googleapis.com/example-image/example-image.tar.gz"
},
"name": "new-encrypted-image",
"sourceType": "RAW",
"imageEncryptionKey": {
  "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  }
}

Crear un disco persistente a partir de un recurso cifrado con CSEK

Crear un disco a partir de una captura cifrada con CSEK

gcloud (beta) compute disks create ... --source-snapshot example-snapshot --csek-key-file example-file.json

POST https://compute.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks

{
"name": "disk-from-encrypted-snapshot",
"sourceSnapshot": "global/snapshots/encrypted-snapshot",
"sourceSnapshotEncryptionKey": {
  "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  }
}

Crear un disco a partir de una imagen cifrada con CSEK

gcloud (beta) compute disks create ... --image example-image --csek-key-file example-file.json

POST https://compute.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks

{
"name": "disk-from-encrypted-image",
"sourceImageEncryptionKey": {
  "rsaEncryptedKey": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA=="
  },
"sourceImage": "global/images/encrypted-image"
}

Asociar un disco encriptado con CSEK a una VM nueva

gcloud (beta) compute instances create example-instance \
    --disk name=example-disk,boot=yes \
    --csek-key-file example-file.json

"disks": [
{
  "deviceName": "encrypted-disk",
  "source": "projects/myproject/zones/us-central1-f/disks/encrypted-disk",
  "diskEncryptionKey": {
    "rawKey": "SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0="
  }
 }
]

Iniciar o reiniciar VMs que tengan discos encriptados con CSEK

Para obtener información sobre cómo detener o iniciar una VM que tenga discos cifrados, consulta el artículo Reiniciar una VM con un disco cifrado.

Usar la línea de comandos para crear recursos mixtos

Si quieres crear una combinación de recursos cifrados por el cliente y cifrados estándar en una sola solicitud con Google Cloud CLI, puedes usar la marca --csek-key-file con un archivo de claves y la marca --no-require-csek-key-create en tu solicitud. Si proporcionas ambas marcas, la CLI de gcloud creará los recursos cifrados por el cliente que se definan explícitamente en tu archivo de claves, así como los recursos estándar que especifiques.

Por ejemplo, supongamos que un archivo de claves contiene lo siguiente:

[
  {
  "uri": "https://www.googleapis.com/compute/beta/projects/myproject/zones/us-central1-a/disks/example-disk",
  "key": "ieCx/NcW06PcT7Ep1X6LUTc/hLvUDYyzSZPPVCVPTVEohpeHASqC8uw5TzyO9U+Fka9JFHz0mBibXUInrC/jEk014kCK/NPjYgEMOyssZ4ZINPKxlUh2zn1bV+MCaTICrdmuSBTWlUUiFoDD6PYznLwh8ZNdaheCeZ8ewEXgFQ8V+sDroLaN3Xs3MDTXQEMMoNUXMCZEIpg9Vtp9x2oeQ5lAbtt7bYAAHf5l+gJWw3sUfs0/Glw5fpdjT8Uggrr+RMZezGrltJEF293rvTIjWOEB3z5OHyHwQkvdrPDFcTqsLfh+8Hr8g+mf+7zVPEC8nEbqpdl3GPv3A7AwpFp7MA==",
  "key-type": "rsa-encrypted"
  }
]

Si quieres crear una VM con un disco cifrado por el cliente usando el archivo de claves y, al mismo tiempo, crear una VM con un disco cifrado estándar en la misma solicitud, puedes hacerlo de la siguiente manera:

gcloud beta compute instances create example-disk example-disk-2 \
    --csek-key-file mykeyfile.json --no-require-csek-key-create

Normalmente, no sería posible crear example-disk-2 si especificaras la marca --csek-key-file porque el disco no está definido explícitamente en el archivo de claves. Al añadir el --no-require-csek-key-create, se crean ambos discos. Uno se cifra con el archivo de claves y el otro conGoogle-owned and managed keys.

Quitar tu CSEK de un disco persistente

Puedes descifrar el contenido de un disco cifrado por el cliente y crear un disco nuevo que use Google-owned and managed keys .

1. Crea una imagen del disco cifrado y especifica el cifrado automático para la nueva imagen.
2. Usa la imagen nueva para crear un disco persistente.

Una vez que hayas creado el nuevo disco persistente, Compute Engine usará Google-owned and managed keys para proteger el contenido del disco. Las capturas que crees a partir de ese disco también deben usar Google-owned and managed keys