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

Par défaut, Compute Engine chiffre toutes les données au repos. Le service traite et gère ce chiffrement sans intervention 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 devez donc stocker vos propres clés dans le service de gestion des clés pour chiffrer les 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 encodé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 n'est connue que des services Google Cloud. En encapsulant votre clé à l'aide du certificat RSA, vous vous assurez que seuls les services Google Cloud 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 une clé et de l'encapsuler en 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

Dans l'outil de ligne de commande gcloud, la génération d'une clé normale et d'une clé encapsulée en RSA s'effectue de la même manière.

Dans l'API, utilisez la propriété sha256 au lieu de rawKey si vous souhaitez avoir recours à une clé encapsulée en RSA.

Chiffrer des ressources avec l'outil de ligne de commande

Prérequis

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 configurez vos clés à l'aide de l'outil de ligne de commande gcloud compute, vous fournissez les clés encodées par le biais d'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 toutes les gérer 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://compute.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks/example-disk",
      "key": "acXTX3rxrKAFTF0tYVLvydU1riRZTvUNC4g5I11NY-c=",
      "key-type": "raw"
      },
      {
      "uri": "https://compute.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. Dans Google Cloud Console, accédez à la page Disques.

    Accéder à la page "Disques"

  2. Cliquez sur Créer un disque et saisissez les propriétés du nouveau disque.
  3. Sous Chiffrement, sélectionnez Clé fournie par le client.
  4. Dans la zone de texte, indiquez la clé de chiffrement du disque et sélectionnez Clé encapsulée si la clé a été encapsulée avec la clé RSA publique.

gcloud

Dans l'outil gcloud compute, vous pouvez chiffrer un disque à l'aide de l'option --csek-key-file lors de la création d'une 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 encodé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, exécutez le script suivant :

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

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 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 incrémentiels.

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 disques persistants avant de créer votre instantané.

Console

  1. Dans Google Cloud Console, accédez à la page Instantanés.

    Accéder à la page "Instantanés"

  2. Cliquez sur Créer un 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é encapsulée si la clé a été encapsulée avec la clé RSA publique.
  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://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"
    }
    

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

La propriété facultative snapshotEncryptionKey vous permet de spécifier une clé pour chiffrer l'instantané. Ainsi, si l'instantané est utilisé pour créer des disques persistants, une clé correspondante doit ê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é non définie. Ainsi, l'instantané pourra servir à 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. Utilisez l'outil de ligne de commande gcloud ou l'API pour copier des images.

Console

  1. Dans Google Cloud Console, accédez à la page Images.

    Accéder à la page "Images"

  2. Cliquez sur Créer une image.
  3. Sous Disque source, choisissez le disque chiffré dont vous souhaitez créer une image.
  4. Sous Chiffrement, sélectionnez une solution de gestion des clés de chiffrement.
  5. Si la clé a été encapsulée avec la clé RSA publique, sélectionnez Clé encapsulée.

gcloud

Suivez les instructions de création d'une image et ajoutez l'option --csek-key-file avec un chemin d'accès au fichier de clé de chiffrement utilisé pour l'objet source chiffré. Utilisez le composant gcloud beta si vous vous servez d'une clé encapsulée en RSA :

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://compute.googleapis.com/compute/v1/projects/myproject/zones/us-central1-a/disks/source-disk",
      "key": "acX3RqzxrKAFTF0tYVLvydU1riRZTvUNC4g5I11NY-c=",
      "key-type": "raw"
      },
      {
      "uri": "https://compute.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é, incluez é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://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"
    }
    

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é non définie. Ainsi, l'image pourra servir à 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. Dans Google Cloud Console, accédez à la page Images.

    Accéder à la page "Images"

  2. Cliquez sur Create image (Créer une image).
  3. Sous Source, choisissez Fichier Cloud Storage.
  4. Sous Fichier Cloud Storage, saisissez l'URI Cloud Storage.
  5. Sous Chiffrement, choisissez Clé gérée par le client puis, dans la zone de texte, saisissez la clé de chiffrement à utiliser pour chiffrer l'image.

gcloud

Exécutez la commande compute images create pour créer une image en spécifiant un fichier de clé de chiffrement pour l'option --csek-key-file. 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 requête de création d'image. Ajoutez ensuite 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.

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

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

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

Console

  1. Dans Google Cloud Console, accédez à la page Disques.

    Accéder à la page Disques

  2. Cliquez sur Créer un disque.
  3. Sous Type de source, sélectionnez Instantané.
  4. Sous Chiffrement, sélectionnez une solution de gestion des clés de chiffrement.
  5. Si la clé a été encapsulée avec la clé RSA publique, sélectionnez Clé encapsulée.

gcloud

Dans l'outil gcloud compute, fournissez la clé de chiffrement de l'instantané à l'aide de l'option --csek-key-file lorsque vous créez le 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. Ajoutez ensuite 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. Par exemple, sur un nouveau disque persistant autonome à l'aide d'un instantané chiffré :

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

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

Console

  1. Dans Google Cloud Console, accédez à la page Disques.

    Accéder à la page Disques

  2. Cliquez sur Créer un disque.
  3. Sous Type de source, sélectionnez Image.
  4. Sous Chiffrement, sélectionnez une solution de gestion des clés de chiffrement.
  5. Si la clé a été encapsulée avec la clé RSA publique, sélectionnez Clé encapsulée.

gcloud

Dans l'outil gcloud compute, fournissez la clé de chiffrement de l'image à l'aide de l'option --csek-key-file lorsque vous créez le 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. Ajoutez ensuite 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.

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

Associer un disque chiffré à une nouvelle instance

Console

  1. Dans Google Cloud Console, accédez à la page Instances de VM.

    Accéder à la page Instances de VM

  2. Cliquez sur Créer une 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é encapsulée si la clé a été encapsulée avec la clé RSA publique.
  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 fournissez la clé à l'aide de l'option --csek-key-file lorsque vous créez 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 en savoir plus sur l'arrêt ou le démarrage d'une instance comportant des disques chiffrés, consultez les informations sur le redémarrage d'une instance contenant des disques chiffrés.

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

Si vous souhaitez effectuer une seule et même requête via l'outil de ligne de commande gcloud pour créer un mélange de ressources chiffrées par le client et de ressources chiffrées de manière standard, vous pouvez utiliser l'option --csek-key-file associée à un fichier de clé ainsi que l'option --no-require-csek-key-create dans votre requête. Lorsque vous fournissez ces deux options, 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é contienne le code suivant :

    [
      {
      "uri": "https://compute.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é de manière 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'option --csek-key-file, car le disque n'est pas explicitement défini dans le fichier de clé. Lorsque vous ajoutez --no-require-csek-key-create, les deux disques sont créés, l'un étant chiffré à l'aide du fichier de clé et l'autre par le biais 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.