Chiffrer des disques avec des clés fournies par le client

Par défaut, Compute Engine chiffre toutes les données au repos, puis traite et gère ce chiffrement sans aucune action supplémentaire de votre part. Cependant, si vous souhaitez contrôler et gérer vous-même le chiffrement, vous pouvez fournir votre propre clé.

Dans ce cas, Compute Engine utilisera votre clé afin de protéger les clés générées par Google pour chiffrer et déchiffrer vos données. Seuls les utilisateurs qui fournissent la clé correcte peuvent utiliser les ressources protégées par une clé de chiffrement fournie par le client.

Google ne stocke pas vos clés sur ses serveurs et ne peut accéder à vos données protégées que si vous fournissez la clé appropriée. Par conséquent, si vous l'oubliez ou la perdez, il est impossible pour Google de la récupérer ou de récupérer les données chiffrées avec la clé perdue.

Lorsque vous supprimez un disque persistant, Google supprime les clés de chiffrement, ce qui rend les données irrécupérables. Ce processus est irréversible.

Avant de commencer

Spécifications

Chiffrement

Compute Engine utilise votre clé de chiffrement pour protéger les clés de chiffrement de Google via le standard AES-256.

Restrictions

L'utilisation de cette fonctionnalité comporte certaines limitations et restrictions :

Restrictions générales

Les clés de chiffrement fournies par le client sont disponibles dans les pays suivants :

  • Brésil
  • Inde

Restrictions techniques

  • Vous pouvez chiffrer les nouveaux disques persistants avec votre propre clé, mais pas les disques persistants existants.

  • Vous ne pouvez pas utiliser vos propres clés avec des disques SSD locaux, car ces disques ne persistent pas au-delà de la durée de vie d'une machine virtuelle. En outre, les disques SSD locaux sont déjà protégés par une clé de chiffrement éphémère que Google ne conserve pas.

  • Compute Engine ne stocke pas de clés de chiffrement avec les modèles d'instances. Vous ne pouvez donc pas utiliser vos propres clés pour chiffrer des disques dans un groupe d'instances géré.

Format de clé requis

C'est à vous de générer et de gérer votre clé. Elle doit être composée d'une chaîne de 256 bits codée selon le standard RFC 4648 base64 pour Compute Engine.

Voici un exemple de clé encodée en base64, générée avec la chaîne "Hello from Google Cloud Platform"

SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=

Elle peut être générée via le script suivant :

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

Encapsuler une clé RSA

Outre l'encodage de votre clé en base64, vous pouvez, en option, l'encapsuler à l'aide d'un certificat de clé publique RSA fourni par Google, l'encoder en base64, puis l'utiliser dans vos requêtes.

L'encapsulation RSA est un processus dans lequel vous utilisez une clé publique pour chiffrer vos données. Une fois ces données chiffrées avec la clé publique, elles ne peuvent être déchiffrées que par la clé privée correspondante. Dans ce cas, la clé privée est connue uniquement des services Google Cloud Platform. En encapsulant votre clé à l'aide du certificat RSA, vous vous assurez que seuls les services Google Cloud Platform peuvent la désencapsuler et l'utiliser pour protéger vos données.

Pour plus d'informations, consultez la page sur le chiffrement RSA.

Pour créer une clé encapsulée en RSA pour Compute Engine, vous devez :

  1. encapsuler votre clé à l'aide de la clé publique fournie dans un certificat géré par Compute Engine (veillez à effectuer l'encapsulation via le remplissage OAEP, et non via le remplissage PKCS #1 v1.5) ;
  2. encoder votre clé encapsulée en RSA via un encodage standard en base64.

Téléchargez le certificat public géré par Compute Engine à partir de :

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

Il y a plusieurs façons de générer et de stocker votre clé RSA. Utilisez une méthode qui vous est familière. Vous trouverez ci-dessous deux exemples d'encapsulation RSA que vous pouvez utiliser.

Exemple 1

Les instructions suivantes, qui permettent d'encapsuler une clé en RSA et de l'encoder, fonctionnent avec l'utilitaire de ligne de commande openssl.

  1. (Facultatif) Générez une clé aléatoire de 256 bits (32 octets). Si vous disposez déjà d'une clé que vous souhaitez utiliser, vous pouvez ignorer cette étape. Il existe de nombreuses manières de générer une clé. Celle qui suit n'est qu'un exemple :

    $ head -c 32 /dev/urandom | LC_CTYPE=C tr '\n' = > mykey.txt
    
  2. Téléchargez le certificat de clé publique :

    $  curl -s -O -L https://cloud-certs.storage.googleapis.com/google-cloud-csek-ingress.pem
  3. Extrayez la clé publique du certificat :

    $ openssl x509 -pubkey -noout -in google-cloud-csek-ingress.pem > pubkey.pem
    
  4. Encapsulez votre clé en RSA, en veillant à remplacer mykey.txt par votre propre fichier de clé.

    $ openssl rsautl -oaep -encrypt -pubin -inkey pubkey.pem -in mykey.txt -out rsawrappedkey.txt
    
  5. Encodez en base64 votre clé encapsulée en RSA.

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

Exemple 2

Voici un exemple de script Python, qui montre la génération d'une chaîne aléatoire de 256 bits (32 octets) et la création d'une clé encapsulée en RSA encodée en base64 à l'aide de la bibliothèque cryptography :


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)

Votre clé est maintenant prête à être utilisée.

Utiliser une clé encapsulée en RSA

À l'aide de l'outil de ligne de commande gcloud, vous pouvez générer une clé normale et une clé encapsulée en RSA de la même manière.

Si vous souhaitez utiliser une clé encapsulée en RSA, dans l'API, utilisez la propriété sha256 au lieu de rawKey.

Chiffrer des ressources avec l'outil de ligne de commande

Configuration

Les clés de chiffrement peuvent être utilisées via l'outil de ligne de commande gcloud.

Téléchargez et installez gcloud.

Fichier de clé

Lorsque vous utilisez l'outil de ligne de commande gcloud compute pour configurer vos clés, vous fournissez vos clés encodées dans un fichier qui les répertorie sous la forme d'une liste JSON. Un fichier de clé peut contenir plusieurs clés, ce qui vous permet de les gérer toutes en un seul endroit. Vous pouvez également créer un fichier par clé, pour les gérer séparément. Un fichier de clé ne peut être utilisé qu'avec l'outil gcloud. Lorsque vous utilisez l'API, vous devez indiquer la clé directement dans votre requête.

Chaque entrée de votre fichier de clé doit fournir :

  • L'URI complète de la ressource protégée par la clé
  • La clé correspondante
  • Le type de clé, raw ou rsa-encrypted

Lorsque vous utilisez le fichier de clé dans vos requêtes, l'outil recherche les ressources correspondantes et utilise les clés appropriées. Si aucune ressource correspondante n'est trouvée, la requête échoue.

Un fichier de clé ressemble à ceci (par exemple) :

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

Bonnes pratiques pour la gestion de vos fichiers de clé

Si vous utilisez un fichier de clé, limitez l'accès à votre fichier aux seules personnes qui en ont besoin. Assurez-vous de définir les autorisations appropriées et envisagez de chiffrer ces fichiers à l'aide d'outils supplémentaires :

Chiffrer un nouveau disque persistant avec vos propres clés

Vous pouvez chiffrer un nouveau disque persistant en fournissant une clé lors de la création de l'instance ou du disque.

Console

  1. Accédez à la page "Disques".

    Accéder à la page Disques

  2. Cliquez sur Nouveau disque et saisissez les propriétés du nouveau disque.
  3. Sous Chiffrement, sélectionnez Fourni par le client dans le menu déroulant.
  4. Dans la zone de texte, indiquez la clé de chiffrement du disque et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.

gcloud

Dans l'outil gcloud compute, chiffrez un disque à l'aide de l'indicateur --csek-key-file lors de la création de l'instance. Si vous utilisez une clé encapsulée en RSA, utilisez le composant gcloud beta :

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

Pour chiffrer un disque persistant autonome :

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

API

Dans l'API, chiffrez un disque à l'aide de la propriété diskEncryptionKey et envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA. Dans votre requête, indiquez l'une des propriétés suivantes :

  • rawKey si votre clé est uniquement codée en base64 ;
  • rsaEncryptedKey si votre clé est encapsulée en RSA et encodée en base64.

Par exemple, pour chiffrer un nouveau disque lors de la création de l'instance avec une clé encapsulée en 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
 }
],
...
}

De même, vous pouvez utiliser l’API pour créer un disque persistant autonome et le chiffrer avec votre propre clé :

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

Créer un instantané à partir d'un disque chiffré

Si vous créez un instantané à partir d'un disque chiffré, l'instantané doit également être chiffré. Pour chiffrer l'instantané, vous devez spécifier une clé. Vous ne pouvez pas convertir des disques chiffrés ou des instantanés chiffrés pour utiliser le chiffrement Compute Engine par défaut, sauf si vous créez une image disque entièrement nouvelle et un disque persistant.

Les instantanés des disques chiffrés sont toujours des instantanés complets, qui coûtent plus cher à stocker que les instantanés différentiels.

Pour créer un instantané de disque persistant à partir d'un disque chiffré, votre requête de création d'instantané doit inclure la clé de chiffrement que vous avez utilisée pour chiffrer le disque persistant.

Consultez les bonnes pratiques pour les instantanés de disque persistants avant de créer votre instantané.

Console

  1. Accédez à la page "Instantanés".

    Accéder à la page Instantanés

  2. Cliquez sur Nouvel instantané.
  3. Sous Disque source, choisissez le disque chiffré dont vous souhaitez créer un instantané.
  4. Dans la zone de texte, indiquez la clé de chiffrement du disque et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.
  5. Chiffrez le nouvel instantané en fournissant une clé de chiffrement supplémentaire dans la section Chiffrement.

API

Dans l'API, indiquez la propriété sourceDiskEncryptionKey pour accéder au disque persistant source. Vous pouvez également chiffrer le nouvel instantané à l'aide de la propriété snapshotEncryptionKey.

Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA.

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

La propriété sourceDiskEncryptionKey doit correspondre à la clé utilisée pour chiffrer le disque persistant. À défaut, la requête échouera.

La propriété facultative snapshotEncryptionKey vous permet d'indiquer une clé pour chiffrer l'instantané, de sorte que, si l'instantané est utilisé pour créer des disques persistants, une clé correspondante doit être indiquée. Cette clé doit suivre le même format que celui décrit ci-dessus. Vous pouvez également choisir de laisser cette propriété indéfinie. Ainsi, l’instantané pourra être utilisé pour créer des disques persistants sans nécessiter de clé.

Créer une image à partir d'un disque chiffré ou d'une image personnalisée chiffrée

Vous pouvez créer des images personnalisées à partir de disques persistants chiffrés ou copier des images chiffrées. Vous ne pouvez pas utiliser la console pour copier des images. Pour ce faire, utilisez l'outil de ligne de commande gcloud ou l'API.

Console

  1. Dans la console Google Cloud Platform, accédez à la page "Créer une image".
    Accéder à la page Créer une image
  2. Cliquez sur Nouvelle image.
  3. Sous Disque source, choisissez le disque chiffré dont vous souhaitez créer une image.
  4. Dans la zone de texte, indiquez la clé de chiffrement du disque et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.
  5. En option, vous pouvez également chiffrer la nouvelle image en indiquant une clé de chiffrement sous la section Chiffrement.

gcloud

Suivez les instructions de création d'une image et ajoutez l'indicateur --csek-key-file avec un chemin d'accès au fichier de clé de chiffrement de l'objet source chiffré. Si vous utilisez une clé encapsulée RSA, utilisez le composant gcloud beta :

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

Si vous souhaitez également chiffrer la nouvelle image avec votre clé, ajoutez la clé au fichier de clé, par exemple :

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

Votre requête de création d'API doit contenir la propriété de clé de chiffrement correspondant à votre objet source. Par exemple, incluez l’une des propriétés suivantes en fonction du type d’objet source :

  • Disque persistant : sourceDiskEncryptionKey
  • Image : sourceImageEncryptionKey

En fonction du type de clé, indiquez également la propriété rawKey ou rsaEncryptedKey. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA. L'exemple suivant montre la conversion d'un disque persistant chiffré et encapsulé en RSA en une image qui utilise la même clé de chiffrement.

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

La propriété facultative imageEncryptionKey vous permet de fournir une clé afin de chiffrer l'image. Lorsque l'image est utilisée dans la création de disques persistants, une clé correspondante doit alors être fournie. Cette clé doit suivre le même format que celui décrit ci-dessus. Vous pouvez également choisir de laisser cette propriété indéfinie. Ainsi, l'image pourra être utilisée pour créer des disques persistants sans nécessiter de clé.

Chiffrer une image importée

Vous pouvez chiffrer une nouvelle image lorsque vous importez manuellement une image personnalisée dans Compute Engine. Pour pouvoir importer une image, vous devez créer et compresser un fichier image de disque, puis importer ce fichier compressé dans Cloud Storage.

Importez l'image Compute Engine personnalisée à chiffrer. Spécifiez l'URI du fichier compressé, ainsi que le chemin d'accès à votre fichier de clé de chiffrement.

Console

  1. Accédez à la page "Images".

    Accéder à la page Images

  2. Cliquez sur Nouvelle image.
  3. Sous Type de source, choisissez Objet Cloud Storage.
  4. Sous Chiffrement, choisissez "Fourni par le client". Dans la zone de texte, saisissez la clé de chiffrement à utiliser pour chiffrer l'image.
  5. Dans la section Chemin d'accès à l'objet Cloud Storage, saisissez l'URI Cloud Storage.

gcloud

Utilisez la commande compute images create pour créer une image et renseignez l'indicateur --csek-key-file avec un fichier de clé de chiffrement. Si vous utilisez une clé encapsulée en RSA, utilisez le composant gcloud beta :

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

où :

  • [IMAGE_NAME] est le nom de la nouvelle image personnalisée.
  • [BUCKET_NAME] est le nom du bucket Cloud Storage contenant votre fichier image compressé.
  • [COMPRESSED_FILE] est le nom du fichier image compressé.
  • [KEY_FILE] est le chemin d'accès à un fichier de clé de chiffrement sur votre poste de travail local.

API

Pour chiffrer une nouvelle image créée à partir d'un fichier RAW, ajoutez la nouvelle propriété imageEncryptionKey à la demande de création d'image, suivie de rawKey ou de rsaEncryptedKey. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA.

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

Créer un disque persistant à partir d'une ressource chiffrée

Créer un disque à partir d'un instantané chiffré

Console

  1. Accédez à la page "Disques".

    Accéder à la page Disques

  2. Cliquez sur Nouveau disque.
  3. Sous Type de source, sélectionnez Instantané.
  4. Dans la zone de texte, indiquez la clé de chiffrement de l'instantané et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.

gcloud

Dans l'outil gcloud compute, indiquez la clé de chiffrement de l'instantané à l'aide de l'indicateur --csek-key-file lors de la création du disque. Si vous utilisez une clé encapsulée en RSA, utilisez le composant gcloud beta :

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

API

Pour utiliser un instantané chiffré, indiquez la propriété sourceSnapshotEncryptionKey dans votre requête, suivie de rawKey ou de rsaEncryptedKey. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA. Par exemple, sur un nouveau disque persistant autonome en utilisant un instantané chiffré :

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

Créer un disque à partir d'une image chiffrée

Console

  1. Accédez à la page "Disques".

    Accéder à la page Disques

  2. Cliquez sur Nouveau disque.
  3. Sous Type de source, sélectionnez Image.
  4. Dans la zone de texte, indiquez la clé de chiffrement de l'image et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.

gcloud

Dans l'outil gcloud compute, indiquez la clé de chiffrement de l'image à l'aide de l'indicateur --csek-key-file lors de la création du disque. Si vous utilisez une clé encapsulée en RSA, utilisez le composant gcloud beta :

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

API

Pour utiliser une image chiffrée, indiquez la propriété sourceImageEncryptionKey, suivie de rawKey ou de rsaEncryptedKey. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA.

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

Associer un disque chiffré à une nouvelle instance

Console

  1. Accédez à la page "Instances de VM".

    Accéder à la page Instances de VM

  2. Cliquez sur Nouvelle instance.
  3. Sous Démarrage, cliquez sur Modifier.
  4. Sélectionnez Disque existant.
  5. Choisissez un disque existant à associer à l'instance.
  6. Dans la zone de texte, indiquez la clé de chiffrement et sélectionnez Clé de chiffrement de clé si la clé a été encapsulée avec la clé publique RSA.
  7. Continuez le processus de création de l'instance.

gcloud

Pour créer une instance et lui associer un disque chiffré, créez un fichier de clé et saisissez la clé à l'aide de l'indicateur --csek-key-file lors de la création de l'instance. Si vous utilisez une clé encapsulée en RSA, utilisez le composant gcloud beta :

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

API

Créez une instance à l'aide de l'API Compute Engine et indiquez la propriété rawKey ou rsaEncryptedKey avec la spécification de disque. Envoyez une requête à l'API v1 pour obtenir une clé brute (non encapsulée en RSA) ou à l'API bêta pour obtenir une clé encapsulée en RSA.

Voici un extrait d'un exemple de spécification de disque :

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

Démarrer ou redémarrer des instances contenant des disques chiffrés

Pour vous informer en détail sur l'arrêt ou le démarrage d'une instance contenant des disques chiffrés, consultez la section Redémarrer une instance avec un disque chiffré.

Utiliser la ligne de commande pour créer des ressources mixtes

Si, dans une seule requête envoyée avec l'outil de ligne de commande gcloud, vous souhaitez créer un mélange de ressources chiffrées par le client et chiffrées par standard, vous pouvez utiliser dans la requête l'indicateur --csek-key-file avec un fichier de clé et l'indicateur --no-require-csek-key-create. Avec ces deux indicateurs, l'outil gcloud crée toutes les ressources chiffrées par le client qui sont explicitement définies dans votre fichier de clé, ainsi que toutes les ressources standards que vous spécifiez.

Par exemple, supposons qu'un fichier de clés contienne le code suivant :

[
  {
  "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, dans la même requête, vous souhaitez créer une instance avec un disque chiffré par le client via le fichier de clé et, en même temps, créer une instance avec un disque chiffré par standard, procédez comme suit :

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

En principe, il ne devrait pas être possible de créer example-disk-2 si vous venez de spécifier l'indicateur --csek-key-file, car le disque n'est pas explicitement défini dans le fichier de clé. En ajoutant --no-require-csek-key-create, les deux disques sont créés, l'un chiffré à l'aide du fichier de clés et l'autre à l'aide du chiffrement Google.

Supprimer la clé de chiffrement fournie par le client d'un disque persistant

Vous pouvez déchiffrer le contenu d'un disque chiffré par le client et créer un disque qui utilise le chiffrement Compute Engine par défaut.

  1. Créez une image du disque chiffré et spécifiez le chiffrement automatique pour la nouvelle image.
  2. Utilisez la nouvelle image pour créer un disque persistant.

Le nouveau disque persistant utilisera le chiffrement Compute Engine par défaut pour protéger son contenu. Tous les instantanés que vous créerez à partir de ce disque devront également utiliser le chiffrement par défaut.

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Documentation Compute Engine