Criptografar discos com chaves fornecidas pelo cliente

Neste tópico, fornecemos informações sobre como criptografar discos com chaves de criptografia fornecidas pelo cliente.

Para mais informações sobre a criptografia de disco, consulte Sobre a criptografia de disco.

Para informações sobre como criptografar discos com chaves de criptografia gerenciadas pelo cliente (CMEK), consulte Proteger recursos usando chaves do Cloud KMS.

Usar CSEKs significa que você fornece suas próprias chaves de criptografia, e o Compute Engine usa suas chaves para proteger as chaves geradas pelo Google usadas para criptografar e descriptografar seus dados. Somente os usuários que possam fornecer a chave correta poderão usar os recursos protegidos por uma chave de criptografia fornecida pelo cliente (CSEK).

O Google não armazena suas chaves nos servidores dele e não pode acessar seus dados protegidos, a menos que você forneça a chave. Isso também significa que, se você esquecer ou perder a chave, o Google não poderá recuperá-la ou recuperar quaisquer dados criptografados com ela.

Quando você exclui um disco permanente, o Google descarta as chaves de código, tornando os dados irrecuperáveis. Esse processo é irreversível.

Antes de começar

• Leia sobre discos, imagens e snapshots de disco permanente.
• Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar códigos ou amostras de um ambiente de desenvolvimento local, autentique-se no Compute Engine da seguinte maneira.
  

  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. Install the Google Cloud CLI, then initialize it by running the following command:

     gcloud init

  2. Set a default region and zone.

  Python

  Para usar os exemplos Python desta página em um ambiente de desenvolvimento local, instale e inicialize o gcloud CLI e e configure o Application Default Credentials com suas credenciais de usuário.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. 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.

  Confira mais informações em Set up authentication for a local development environment.

  REST

  Para usar as amostras da API REST nesta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para gcloud CLI.

  Install the Google Cloud CLI, then initialize it by running the following command:

  gcloud init

  Para mais informações, consulte Autenticar para usar REST na documentação de autenticação do Google Cloud.

Restrições

Para a CSEK, as seguintes restrições se aplicam:

Restrições gerais

A disponibilidade das chaves de criptografia fornecidas pelo cliente depende da localização da conta de faturamento, não da localização do recurso.

As chaves de criptografia fornecidas pelo cliente não estão disponíveis para contas de faturamento que estão nos seguintes países:

• Brasil
• Índia

Restrições técnicas

• É possível apenas criptografar novos discos permanentes com sua própria chave. Não é possível criptografar os discos permanentes atuais com ela.

• Não é possível usar as próprias chaves com SSDs locais porque eles não permanecem além da duração de uma VM. Os SSDs locais já estão protegidos com uma chave de criptografia efêmera que o Google não retém.

• O Compute Engine não armazena chaves de criptografia com modelos de instância. Portanto, você precisa armazenar suas próprias chaves no KMS para criptografar discos em um grupo de instâncias gerenciadas.

• Não é possível suspender instâncias com discos protegidos por CSEK anexados.

Especificações

Nesta seção, você verá a especificação da criptografia e o formato da CSEK.

Encryption

O Compute Engine usa sua chave de criptografia para proteger as chaves do Google com a criptografia AES-256.

Formato de chave exigido

Você é responsável por gerar e gerenciar sua chave. É necessário fornecer uma chave que seja uma string de 256 bits codificada em base64 padrão do RFC 4648 para o Compute Engine.

O exemplo a seguir é de uma chave codificada em base64, gerada com a string "Olá do Google Cloud Platform".

SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=

Ela pode ser gerada com o seguinte script:

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

Incorporação de chaves por RSA

Além de codificar sua chave em Base64, você tem a opção de incorporá-la usando o certificado de chave pública RSA fornecido pelo Google, codificá-la em Base64 e usá-la nas solicitações.

A incorporação por RSA é um processo em que você usa uma chave pública para criptografar seus dados. Depois que os dados tiverem sido criptografados com a chave pública, eles só poderão ser descriptografados com a respectiva chave privada. Nesse caso, a chave privada é conhecida apenas pelos serviços do Google Cloud. Ao encapsular a chave usando o certificado RSA, você garante que somente os serviços do Google Cloud Platform possam desencapsular a chave e utilizá-la para proteger os dados.

Para mais informações, consulte a Criptografia RSA.

Para criar uma chave incorporada por RSA para o Compute Engine, faça o seguinte:

1. Incorporar a chave usando a chave pública fornecida em um certificado gerenciado pelo Compute Engine. Para fazer isso, use o preenchimento OAEP, e não o PKCS #1 v1.5.
2. codificar sua chave incorporada com RSA usando a codificação base64 padrão.

Faça o download do certificado público mantido pelo Compute Engine de:

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

Há muitas formas de gerar sua chave e incorporá-la por RSA. Use um método com o qual esteja acostumado. A seguir, há dois exemplos de incorporação por RSA que você pode usar.

Exemplo 1

As instruções a seguir usam o utilitário de linha de comando openssl para incorporar por RSA e codificar uma chave.

1. (Opcional): gere uma chave aleatória de 256 bits (32 bytes). Se você já tiver uma chave para usar, ignore esta etapa. Há muitas maneiras de gerar uma chave. Exemplo:

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

2. Faça o download do certificado de chave pública:

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

3. Extraia a chave pública do certificado:

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

4. Incorpore sua chave por RSA. Não deixe de substituir mykey.txt por seu próprio arquivo de chave.

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

5. Codifique a chave incorporada por RSA em Base64.

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

Exemplo 2

O exemplo a seguir consiste em um script Python que gera uma string aleatória de 256 bits (32 bytes) e cria uma chave incorporada por RSA codificada em base64 usando a biblioteca de criptografia:

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)

Agora sua chave está pronta para usar!

Use uma chave incorporada por RSA

Com a Google Cloud CLI, é possível fornecer uma chave normal e uma incorporada por RSA da mesma maneira.

Na API, use a propriedade sha256 em vez de rawKey se quiser utilizar a chave incorporada por RSA.

Como criptografar recursos com CSEK usando a ferramenta de linha de comando

Configuração

É possível usar as chaves de criptografia usando a Google Cloud CLI.

Fazer download e instalar a gcloud

Arquivo de chave

Ao usar a ferramenta de linha de comando gcloud compute para definir as chaves, você fornece chaves codificadas por meio de um arquivo. Nele, as chaves codificadas são armazenadas como uma lista JSON. Um arquivo de chave pode conter várias chaves, permitindo gerenciar muitas delas em um único lugar. Como alternativa, é possível criar arquivos de chave única para lidar com cada chave separadamente. Um arquivo de chave só pode ser usado com a ferramenta CLI gcloud. Ao usar a REST, é necessário fornecer a chave diretamente na solicitação.

Cada entrada no arquivo de chave tem que conter o seguinte:

• o URI totalmente qualificado para o recurso que a chave protege;
• a chave correspondente;
• O tipo de chave, que é raw ou rsa-encrypted

Ao usar o arquivo de chave nas solicitações, a ferramenta procura recursos correspondentes e usa as respectivas chaves. Se nenhum recurso correspondente for encontrado, a solicitação falhará.

Veja um exemplo de arquivo de chave:

[
  {
  "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áticas recomendadas para gerenciar o arquivo de chave

Se você usar um arquivo de chave, restrinja o acesso a ele apenas às pessoas necessárias. Defina as permissões apropriadas nesses arquivos e os criptografe com outras ferramentas:

• No Windows, use o BitLocker ou o Encrypting File System (EFS).
• No macOS, pense em usar o FileVault 2.
• No Linux, use o Linux Unified Key Setup (LUKS) ou o eCryptfs (páginas em inglês).

Criptografar um novo disco permanente com a CSEK

É possível criptografar um novo disco permanente fornecendo uma chave durante a criação de uma VM ou 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"
}

Criar um snapshot a partir de um disco criptografado com a CSEK

Se você criar um snapshot a partir de um disco criptografado, o snapshot também precisa ser criptografado. É necessário especificar uma chave para criptografar um snapshot. Não é possível converter discos ou snapshots criptografados para usar a criptografia padrão do Compute Engine a menos que você crie uma nova imagem de disco e um novo disco permanente.

Os snapshots de discos criptografados com a CSEK são sempre completos. Isso é diferente dos snapshots de discos criptografados com chaves de criptografia gerenciadas pelo cliente (CMEK, na sigla em inglês), que são incrementais. Os snapshots são cobrados com base no tamanho total deles. Portanto, um snapshot completo pode custar mais do que um snapshot incremental.

Para criar um snapshot de disco permanente a partir de um disco criptografado, sua solicitação de criação de snapshot precisa fornecer a chave de criptografia que você usou para criptografar o disco permanente.

Consulte as Práticas recomendadas para snapshots de disco permanente antes de criar o snapshot.

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

Criar uma nova imagem a partir de um disco ou uma imagem personalizada criptografada com CSEK

É possível criar imagens personalizadas a partir de discos permanentes criptografados ou copiar imagens criptografadas. Não use o console para copiar imagens. Use a CLI do Google Cloud ou a REST para copiar imagens.

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

Criptografar uma imagem importada com CSEK

É possível criptografar uma nova imagem ao importar manualmente uma imagem personalizada para o Compute Engine. Antes de importar uma imagem, é necessário criar e compactar um arquivo de imagem de disco e fazer upload desse arquivo para o Cloud Storage.

Importe a imagem personalizada do Compute Engine que você quer criptografar. Especifique o URI do arquivo compactado e também um caminho para seu arquivo de chave de criptografia.

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

Criar um disco permanente a partir de um recurso criptografado com a CSEK

Criar um disco a partir de um snapshot criptografado com 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=="
  }
}

Criar um disco a partir de uma imagem criptografada com 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"
}

Como anexar um disco criptografado com a CSEK a uma nova VM

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="
  }
 }
]

Como iniciar ou reiniciar VMs que têm discos criptografados com CSEK

Para detalhes sobre como interromper ou iniciar uma VM que tenha discos criptografados, leia Como reiniciar uma VM com um disco criptografado.

Uso da linha de comando para criar recursos mistos

Se quiser criar uma combinação de recursos criptografados pelo cliente e de criptografia padrão em uma única solicitação com a Google Cloud CLI, use a sinalização --csek-key-file com um arquivo de chave e a sinalização --no-require-csek-key-create na solicitação. Ao fornecer ambas as sinalizações, a CLI gcloud cria todos os recursos criptografados pelo cliente que são definidos explicitamente no arquivo de chave e também os recursos padrão que você especificar.

Por exemplo, imagine que um arquivo de chave contém os seguintes itens:

[
  {
  "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"
  }
]

Para criar uma VM com um disco criptografado pelo cliente usando o arquivo de chave e, ao mesmo tempo, gerar uma VM com um disco criptografado padrão na mesma solicitação, siga estas etapas:

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

Em geral, não é possível criar example-disk-2 especificando apenas a sinalização --csek-key-file, porque o disco não está explicitamente definido no arquivo de chave. Ao adicionar --no-require-csek-key-create, os dois discos são criados: um criptografado por meio do arquivo de chave, e o outro por meio da criptografia do Google.

Remover a CSEK de um disco permanente

Você pode descriptografar o conteúdo de um disco pelo cliente e criar um novo disco que utilize a criptografia padrão do Compute Engine.

1. Crie uma imagem do disco criptografado e especifique a criptografia automática nela.
2. Use a nova imagem para criar um novo disco permanente.

Depois de criar o novo disco permanente, ele usa a criptografia padrão do Compute Engine para proteger o conteúdo do disco. Todos os snapshots criados com base nesse disco também precisarão usar a criptografia padrão.