Criptografar discos com chaves de criptografia fornecidas pelo cliente

Por padrão, o Google Compute Engine criptografa todos os dados em repouso. O Compute Engine executa e gerencia essa criptografia para você sem que você precise executar nenhuma ação adicional. Contudo, se você quiser controlar e gerenciar a criptografia por conta própria, será possível fornecer suas próprias chaves de criptografia.

Se você fornecê-las, o Compute Engine usará sua chave 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.

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

Especificações

Criptografia

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

Restrições

Há algumas restrições e limitações no uso desse recurso:

Restrições gerais

As chaves de criptografia fornecidas pelo cliente não estão disponíveis 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 suas próprias chaves com SSDs locais porque eles não permanecem além da duração de uma máquina virtual. Os SSDs locais já estão protegidos com uma chave de criptografia efêmera que o Google não retém.

  • Como o Compute Engine não armazena chaves de criptografia com modelos de instância, não é possível usar as próprias chaves para criptografar discos em um grupo de instâncias gerenciadas.

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, em seguida, usá-la em suas 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 somente pelos serviços do Google Cloud Platform. Ao incorporar sua chave usando o certificado RSA, você garante que somente os serviços do Google Cloud Platform possam desincorporar sua chave e utilizá-la para proteger seus dados.

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

Para criar uma chave incorporada por RSA para o Compute Engine, você precisa:

  1. incorporar sua chave usando a chave pública fornecida em um certificado gerenciado pelo Compute Engine. Para fazer isso, use o preenchimento OAEP, 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 formas de gerar uma chave. O método a seguir é apenas um 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, certificando-se 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 sua 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:

compute/encryption/generate_wrapped_rsa_key.py 

import argparse
import base64
import os

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

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

def get_google_public_cert_key():
    r = requests.get(GOOGLE_PUBLIC_CERT_URL)
    r.raise_for_status()

    # Load the certificate.
    certificate = x509.load_pem_x509_certificate(
        r.text.encode('utf-8'), default_backend())

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

    return public_key

def wrap_rsa_key(public_key, private_key_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.
    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):
    # 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)

    print('Base-64 encoded private key: {}'.format(
        base64.b64encode(customer_key_bytes).decode('utf-8')))
    print('Wrapped RSA key: {}'.format(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 ferramenta de linha de comando gcloud, é 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 a ferramenta de linha de comando

Configuração

As chaves de criptografia podem ser usadas por meio da ferramenta de linha de comando gcloud.

Faça o download da gcloud e instale a ferramenta.

Arquivo de chave

Ao usar a ferramenta de linha de comando gcloud compute para definir suas chaves, você fornece chaves codificadas usando um arquivo de chave que contém suas chaves codificadas como uma lista JSON. Um arquivo de chave pode conter várias chaves, permitindo gerenciar várias 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 gcloud. Ao usar a API, é necessário fornecer a chave diretamente em sua solicitação.

Cada entrada em seu arquivo de chave tem que conter:

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

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

Um arquivo de chave tem a seguinte aparência:

[
  {
  "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 seu arquivo de chave

Se você usa um arquivo de chave, é necessário restringir o acesso a ele somente para os que precisam dele. Defina as permissões apropriadas nesses arquivos e pense em criptografá-los com outras ferramentas:

Criptografar um novo disco permanente com suas próprias chaves

É possível criptografar um novo disco permanente fornecendo uma chave durante a criação de uma instância ou disco.

Console

  1. Vá para a página "Discos".

    Ir para a página "Discos"

  2. Clique em Novo disco e insira as propriedades do novo disco.
  3. Em Criptografia, selecione Fornecida pelo cliente no menu suspenso.
  4. Forneça a chave de criptografia para o disco na caixa de texto e selecione Chave incorporada se a chave tiver sido incorporada com a chave RSA pública.

gcloud

Na ferramenta gcloud compute, criptografe um disco usando o sinalizador --csek-key-file durante a criação da instância. Se você estiver usando uma chave incorporada por RSA, use o componente gcloud beta.

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

Para criptografar um disco permanente independente:

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

API

Na API, criptografe um disco usando a propriedade diskEncryptionKey e faça a solicitação de uma chave bruta (não incorporada por RSA) à API v1 ou de uma chave incorporada por RSA à API Beta. Forneça uma das seguintes propriedades em sua solicitação:

  • rawKey: se a chave for codificada apenas em base64
  • rsaEncryptedKey: se a chave for incorporada por RSA e codificada em base64

Por exemplo, para criptografar um novo disco durante a criação de uma instância com uma chave incorporada com RSA:

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

{
"machineType": "zones/us-central1-a/machineTypes/n1-standard-1",
"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
 }
],
...
}

Também é possível usar a API para criar um novo disco permanente independente e criptografá-lo com sua própria chave:

POST https://www.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 de um disco criptografado

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 criptografados ou snapshots criptografados para usar a criptografia padrão do Compute Engine a menos que você crie uma imagem de disco completamente nova e um novo disco permanente.

Os snapshots de discos criptografados sempre são completos, com armazenamento mais caro do que os snapshots incrementais.

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.

Console

  1. Vá para a página "Snapshots".

    Ir para a página "Snapshots"

  2. Clique em Novo snapshot.
  3. Em Disco de origem, escolha o disco criptografado para criar o snapshot.
  4. Forneça a chave de criptografia para o disco na caixa de texto e selecione Chave incorporada se a chave tiver sido incorporada com a chave RSA pública.
  5. Criptografe o novo snapshot fornecendo uma chave de criptografia extra na seção Criptografia.

API

Na API, forneça a propriedade sourceDiskEncryptionKey para acessar o disco permanente de origem. Também é possível criptografar opcionalmente o novo snapshot usando a propriedade snapshotEncryptionKey.

Faça a solicitação de uma chave bruta (não incorporada por RSA) para a API v1, ou de uma chave incorporada por RSA para a API Beta.

POST https://www.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"
}

A propriedade sourceDiskEncryptionKey tem que corresponder à chave usada para criptografar o disco permanente. Caso contrário, a solicitação falhará.

A propriedade opcional snapshotEncryptionKey permite fornecer uma chave para criptografar o snapshot, assim, se o snapshot for usado para criar novos discos permanentes, uma chave correspondente precisará ser fornecida. A chave precisa seguir o mesmo formato descrito acima. Também é possível optar por deixar essa propriedade indefinida e o snapshot poderá ser usado para criar novos discos permanentes sem precisar de uma chave.

Como criar uma nova imagem a partir de um disco criptografado ou imagem personalizada criptografada

É possível criar imagens personalizadas a partir de discos permanentes criptografados ou copiar imagens criptografadas. Não é possível usar o console para copiar imagens. Use a ferramenta de linha de comando gcloud ou a API para copiar imagens.

Console

  1. No Console do Google Cloud Platform, acesse a página "Criar uma imagem".
    Acessar a página "Criar uma imagem"
  2. Clique em Nova imagem.
  3. Em Disco de origem, escolha o disco criptografado cuja imagem quer criar.
  4. Forneça a chave de criptografia para o disco na caixa de texto e selecione Chave incorporada se a chave tiver sido incorporada com a chave RSA pública.
  5. Como opção, é possível criptografar a nova imagem fornecendo uma chave de criptografia adicional na seção Criptografia.

gcloud

Siga as instruções para criar uma imagem e adicione a sinalização --csek-key-file com um caminho para o arquivo de chave de criptografia do objeto de origem criptografado. Use o componente gcloud beta se estiver usando uma chave incorporada por RSA.

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

Se quiser criptografar a nova imagem com sua chave também, adicione-a ao arquivo de chave, por exemplo:

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

API

A solicitação de criação de API precisa conter a propriedade da chave de criptografia do objeto de origem. Por exemplo, inclua uma das seguintes propriedades, dependendo do tipo de objeto de origem:

  • Disco permanente: sourceDiskEncryptionKey
  • Imagem: sourceImageEncryptionKey

Inclua também as propriedades rawKey ou rsaEncryptedKey, dependendo do tipo de chave. Faça uma solicitação de uma chave bruta (não incorporada por RSA) para a API v1, ou de uma chave incorporada por RSA para a API Beta. O exemplo a seguir converte um disco permanente criptografado e RSA em uma imagem que usa a mesma chave de criptografia.

POST https://www.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"
}

A propriedade imageEncryptionKey opcional permite fornecer uma chave para criptografar a imagem, assim, quando a imagem for usada para criar novos discos permanentes, será preciso fornecer uma chave correspondente. A chave precisa seguir o mesmo formato descrito acima. Também é possível optar por deixar essa propriedade indefinida e a imagem poderá ser usada para criar novos discos permanentes sem precisar de uma chave.

Criptografar uma imagem importada

É 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 compactado para o Google Cloud Storage.

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

Console

  1. Vá para a página "Imagens".

    Ir para a página "Imagens"

  2. Clique em Nova imagem.
  3. Em Tipo de origem, selecione Objeto do Cloud Storage.
  4. Em Criptografia, selecione "Fornecida pelo cliente" e forneça a chave de criptografia para criptografar a imagem na caixa de texto.
  5. Insira o URI do Cloud Storage na seção caminho do objeto do Cloud Storage.

gcloud

Use o comando compute images create para criar uma nova imagem e especificar o sinalizador --csek-key-file com um arquivo de chave de criptografia. Se você estiver usando uma chave incorporada por RSA, use o componente gcloud beta:

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

onde:

  • [IMAGE_NAME] é um nome para a nova imagem personalizada;
  • [BUCKET_NAME] é o nome do intervalo do Cloud Storage que contém seu arquivo de imagem compactado;
  • [COMPRESSED_FILE] é o nome do arquivo de imagem compactado;
  • [KEY_FILE] é o caminho para uma chave de criptografia na sua estação de trabalho local.

API

Para criptografar uma nova imagem criada a partir de um arquivo RAW, adicione a nova propriedade imageEncryptionKey à solicitação de criação de imagem seguida de rawKey ou rsaEncryptedKey. Faça a solicitação de uma chave bruta (não incorporada por RSA) para a API v1, ou de uma chave incorporada por RSA para a API Beta.

POST https://www.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=="
  }
}

Como criar um disco permanente a partir de um recurso criptografado

Como criar um disco a partir de um snapshot criptografado

Console

  1. Vá para a página "Discos".

    Ir para a página "Discos"

  2. Clique em Novo disco.
  3. Em Tipo de origem, selecione Snapshot.
  4. Forneça a chave de criptografia para o snapshot na caixa de texto e selecione Chave incorporada se a chave tiver sido incorporada com a chave RSA pública.

gcloud

Na ferramenta gcloud compute, forneça a chave de criptografia para o snapshot usando o sinalizador --csek-key-file ao criar o disco. Se estiver usando uma chave incorporada por RSA, use o componente gcloud beta.

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

API

Para usar um snapshot criptografado, forneça a sourceSnapshotEncryptionKey em sua solicitação, seguida de rawKey ou rsaEncryptedKey. Faça a solicitação de uma chave bruta (não incorporada por RSA) para a API v1 ou de uma chave incorporada por RSA para a API Beta. Por exemplo, para um novo disco permanente independente que utiliza um snapshot criptografado:

POST https://www.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=="
  }
}

Como criar um disco a partir de uma imagem criptografada

Console

  1. Vá para a página "Discos".

    Ir para a página "Discos"

  2. Clique em Novo disco.
  3. Em Tipo de origem, selecione Imagem.
  4. Forneça a chave de criptografia para a imagem na caixa de texto e selecione Chave incorporada se a chave tiver sido incorporada com a chave RSA pública.

gcloud

Na ferramenta gcloud compute, forneça a chave de criptografia para a imagem usando o sinalizador --csek-key-file ao criar o disco. Se você estiver usando uma chave incorporada por RSA, use o componente gcloud beta:

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

API

Para usar uma imagem criptografada, forneça a sourceImageEncryptionKey, seguida de rawKey ou rsaEncryptedKey. Faça a solicitação de uma chave bruta (não incorporada por RSA) para a API v1 ou de uma chave incorporada por RSA para a API Beta.

POST https://www.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 a uma nova instância

Console

  1. Acesse a página "Instâncias de VMs".

    Ir para a página "Instâncias de VMs"

  2. Clique em Nova instância.
  3. Em Inicialização, clique em Alterar.
  4. Selecione Disco existente.
  5. Escolha um disco existente para anexar à instância.
  6. Forneça a chave de criptografia na caixa de texto e selecione Chave incorporada se a chave tiver sido incorporada com a chave RSA pública.
  7. Continue com o processo de criação de instâncias.

gcloud

Para criar uma instância e anexar um disco criptografado, gere um arquivo de chave e forneça a chave usando a sinalização --csek-key-file durante a criação. Se você estiver usando uma chave incorporada por RSA, use o componente gcloud beta:

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

API

Crie uma instância usando a API Compute Engine e forneça rawKey ou rsaEncryptedKey com a especificação do disco. Faça a solicitação de uma chave bruta (não incorporada por RSA) para a API v1 ou de uma chave incorporada por RSA para a API Beta.

Veja um snippet de um exemplo de especificação de disco:

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

Como iniciar ou reiniciar instâncias que têm discos criptografados

Para ver detalhes sobre como interromper ou iniciar uma instância que tenha discos criptografados, leia este artigo.

Como usar a linha de comando para criar recursos mistos

Se quiser criar uma combinação de recursos criptografados pelo cliente e com criptografia padrão em uma única solicitação com a ferramenta de linha de comando gcloud, use o sinalizador --csek-key-file com um arquivo de chave e o sinalizador --no-require-csek-key-create em sua solicitação. Fornecendo os dois sinalizadores, a ferramenta gcloud cria quaisquer recursos criptografados pelo cliente que estejam explicitamente definidos em seu arquivo de chave e também cria quaisquer 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 instância com um disco criptografado pelo cliente usando o arquivo de chave e, ao mesmo tempo, criar uma instância 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. A adicionar --no-require-csek-key-create, os dois discos serão criados, um criptografado com o arquivo de chave, e o outro com as criptografias do Google.

Como remover sua chave de criptografia fornecida pelo cliente de um disco permanente

É possível 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.

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Esta página
Comentários sobre a documentação
Documentação do Compute Engine
Comentários sobre o produto