Laufwerke mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln verschlüsseln

In diesem Thema erfahren Sie, wie Sie Laufwerke mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln verschlüsseln.

Informationen zur Laufwerksverschlüsselung finden Sie unter Laufwerkverschlüsselung.

Informationen zum Verschlüsseln von Laufwerken mit vom Kunden verwalteten Verschlüsselungsschlüsseln (CMEK) finden Sie unter Ressourcen mit Cloud KMS-Schlüsseln schützen.

Wenn Sie CSEKs verwenden, stellen Sie Ihre eigenen Verschlüsselungsschlüssel bereit. Die Compute Engine verwendet Ihre Schlüssel, um die von Google generierten Schlüssel zu schützen, die zum Verschlüsseln und Entschlüsseln Ihrer Daten verwendet werden. Nur Nutzer, die den korrekten Schlüssel angeben können, haben die Möglichkeit, Ressourcen zu verwenden, die durch einen vom Kunden bereitgestellten Verschlüsselungsschlüssel (CSEK) gesichert werden.

Google speichert Ihre Schlüssel nicht auf seinen Servern und kann nicht auf Ihre gesicherten Daten zugreifen – es sei denn, Sie stellen den Schlüssel zur Verfügung. Sollten Sie Ihren Schlüssel also vergessen oder verlieren, kann Google ihn unter keinen Umständen wiederherstellen. Das gilt auch für die Daten, die mit dem verlorenen Schlüssel verschlüsselt wurden.

Wenn Sie einen nichtflüchtigen Speicher löschen, verwirft Google die Codierschlüssel und die Daten werden unwiederbringlich gelöscht. Dieser Vorgang kann nicht rückgängig gemacht werden.

Vorbereitung

• Informieren Sie sich über Laufwerke, Images und Snapshots von Laufwerken.
• Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud-Dienste und APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich so bei Compute Engine authentifizieren.
  

  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

  Wenn Sie die Python Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  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.

  Weitere Informationen unter Set up authentication for a local development environment.

  REST

  Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

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

  gcloud init

  Weitere Informationen finden Sie unter Für die Verwendung von REST authentifizieren in der Dokumentation zur Google Cloud-Authentifizierung.

Beschränkungen

Für CSEK gelten die folgenden Einschränkungen:

Allgemeine Einschränkungen

Die Verfügbarkeit der vom Kunden bereitgestellten Verschlüsselungsschlüssel hängt vom Standort Ihres Rechnungskontos und nicht vom Standort der Ressource ab.

Vom Kunden bereitgestellte Verschlüsselungsschlüssel sind nicht für Rechnungskonten in den folgenden Ländern verfügbar:

• Brasilien
• Indien

Technische Einschränkungen

• Sie können nur neue nichtflüchtige Speicher mit einem eigenen Schlüssel verschlüsseln. Vorhandene nichtflüchtige Speicher können nicht mit einem eigenen Schlüssel verschlüsselt werden.

• Sie können Ihre eigenen Schlüssel nicht mit lokalen SSDs verwenden, da die Schlüssel von der Google-Infrastruktur verwaltet und bei Beendigung der VM gelöscht werden.

• Compute Engine speichert mit Instanzvorlagen keine Verschlüsselungsschlüssel. Sie müssen Ihren eigenen Schlüssel also in KMS speichern, um Laufwerke in einer verwalteten Instanzgruppe zu verschlüsseln.

• Sie können keine Instanzen anhalten, an die CSEK-geschützte Laufwerke angehängt sind.

Spezifikationen

In diesem Abschnitt werden die Verschlüsselungsspezifikation und das Format von CSEK beschrieben.

Verschlüsselung

Compute Engine verwendet Ihren Verschlüsselungsschlüssel, um die Verschlüsselungsschlüssel von Google mit AES-256-Verschlüsselung zu schützen.

Erforderliches Schlüsselformat

Sie selbst generieren und verwalten Ihre Schlüssel. Sie müssen Compute Engine einen Schlüssel bereitstellen, der ein 256 Bit langer String und mit base64 (RFC 4648) codiert ist.

Das folgende Beispiel zeigt einen base64-codierten Schlüssel, der mit dem String "Hello from Google Cloud Platform" generiert wurde:

SGVsbG8gZnJvbSBHb29nbGUgQ2xvdWQgUGxhdGZvcm0=

Er kann auch mit dem folgenden Skript generiert werden:

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

RSA-Key-Wrapping

Sie haben zusätzlich zur base64-Codierung Ihres Schlüssels die Möglichkeit, Ihren Schlüssel mit einem von Google bereitgestellten RSA-Public-Key-Zertifikat zu verpacken. Anschließend können Sie ihn in base64 codieren und in Ihren Anfragen verwenden.

Beim RSA-Wrapping verwenden Sie einen öffentlichen Schlüssel für die Verschlüsselung Ihrer Daten. Nachdem diese Daten mit dem öffentlichen Schlüssel verschlüsselt wurden, können sie nur mit dem entsprechenden privaten Schlüssel entschlüsselt werden. In diesem Fall ist der private Schlüssel nur den Google Cloud-Diensten bekannt. Durch die Verpackung Ihres Schlüssels mit dem RSA-Zertifikat wird sichergestellt, dass Ihr Schlüssel nur von Google Cloud-Diensten entpackt und für den Schutz Ihrer Daten verwendet werden kann.

Mehr hierzu erfahren Sie unter RSA-Verschlüsselung.

So erstellen Sie einen mit RSA verpackten Schlüssel für Compute Engine:

1. Verpacken Sie Ihren Schlüssel mit dem öffentlichen Schlüssel, der in einem von Compute Engine verwalteten Zertifikat bereitgestellt wird. Achten Sie darauf, Ihren Schlüssel mit OAEP-Padding und nicht mit PKCS-#1-Padding (Version 1.5) zu verpacken.
2. Codieren Sie Ihren mit RSA verpackten Schlüssel mit standardmäßiger base64-Codierung.

Laden Sie das öffentliche und von Compute Engine gewartete Zertifikat hier herunter:

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

Es gibt zahlreiche Möglichkeiten, Ihren Schlüssel zu generieren und mit RSA zu verpacken. Entscheiden Sie sich für eine Methode, mit der Sie vertraut sind. Im Folgenden sehen Sie zwei Beispiele, wie Sie Ihren Schlüssel mit RSA verpacken können.

Beispiel 1

In der folgenden Anleitung wird das Befehlszeilendienstprogramm openssl verwendet, um einen Schlüssel mit RSA zu verpacken und zu verschlüsseln.

1. Optional: Generieren Sie einen zufälligen 256-Bit-Schlüssel (32 Byte). Wenn Sie bereits einen Schlüssel haben, den Sie verwenden möchten, können Sie diesen Schritt überspringen. Es gibt viele Möglichkeiten, einen Schlüssel zu generieren. Beispiel:

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

2. Laden Sie das Public-Key-Zertifikat herunter:

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

3. Extrahieren Sie den öffentlichen Schlüssel aus dem Zertifikat:

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

4. Verpacken Sie Ihren Schlüssel mit RSA und achten Sie dabei darauf, mykey.txt durch Ihre eigene Schlüsseldatei zu ersetzen.

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

5. Codieren Sie Ihren mit RSA verpackten Schlüssel in base64.

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

Beispiel 2

Mit dem folgenden Beispielskript in Python wird mithilfe der Kryptografie-Bibliothek ein zufälliger 256-Bit-String (32 Byte) generiert und ein base64-codierter, mit RSA verpackter Schlüssel erstellt:

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)

Ihr Schlüssel ist jetzt einsatzbereit.

Mit RSA verpackten Schlüssel verwenden

Mit dem Google Cloud CLI können Sie einen normalen und einen mit RSA verpackten Schlüssel auf dieselbe Weise angeben.

Wenn Sie einen mit RSA verpackten Schlüssel nutzen möchten, verwenden Sie in der API das Attribut sha256 statt rawKey.

Ressourcen mit CSEK mit dem Befehlszeilentool verschlüsseln

Einrichtung

Verschlüsselungsschlüssel können über das Google Cloud CLI verwendet werden.

Laden Sie gcloud herunter und installieren Sie es.

Schlüsseldatei

Wenn Sie Ihre Schlüssel mit dem Befehlszeilentool gcloud compute einrichten, stellen Sie codierte Schlüssel mit einer Schlüsseldatei bereit, die Ihre codierten Schlüssel als JSON-Liste enthält. Eine Schlüsseldatei kann mehrere Schlüssel enthalten. So haben Sie die Möglichkeit, mehrere Schlüssel zentral an einem Ort zu verwalten. Sie können aber auch einzelne Schlüsseldateien erstellen, um jeden Schlüssel separat zu handhaben. Eine Schlüsseldatei kann nur mit dem gcloud CLI verwendet werden. Wenn Sie REST verwenden, müssen Sie den Schlüssel direkt in Ihrer Anfrage angeben.

Jeder Eintrag in Ihrer Schlüsseldatei muss Folgendes enthalten:

• Den voll qualifizierten URI zu der Ressource, die durch den Schlüssel gesichert wird
• Den entsprechenden Schlüssel
• Den Typ des Schlüssels, entweder raw oder rsa-encrypted

Wenn Sie die Schlüsseldatei in Ihren Anfragen verwenden, sucht das Tool nach passenden Ressourcen und verwendet die entsprechenden Schlüssel. Wenn keine übereinstimmenden Ressourcen gefunden werden, schlägt die Anfrage fehl.

Ein Beispiel für eine Schlüsseldatei:

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

Best Practices zum Verwalten Ihrer Schlüsseldatei

Beim Verwenden einer Schlüsseldatei beschränken Sie den Zugriff auf Ihre Datei auf diejenigen Nutzer, die Zugriff benötigen. Achten Sie darauf, die Berechtigungen für diese Dateien einzurichten und ziehen Sie in Erwägung, diese Dateien mit weiteren Tools zu verschlüsseln:

• Unter Windows mit BitLocker oder Encrypting File System (EFS).
• Unter macOS mit FileVault 2
• Unter Linux mit Linux Unified Key Setup (LUKS) oder eCryptfs

Neuen nichtflüchtigen Speicher mit CSEK verschlüsseln

Sie können einen neuen nichtflüchtigen Speicher verschlüsseln, wenn Sie bei der Erstellung der VM oder des Laufwerks einen Schlüssel bereitstellen.

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%2F2.gy-118.workers.dev/%3A443%2Fhttps%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"
}

Snapshot von einem mit CSEK verschlüsselten Laufwerk erstellen

Wenn Sie von einem verschlüsselten Laufwerk einen Snapshot erstellen, muss auch der Snapshot verschlüsselt werden. Sie müssen einen Schlüssel angeben, um den Snapshot zu verschlüsseln. Sie können verschlüsselte Laufwerke oder verschlüsselte Snapshots nicht zur Verwendung mit der Compute Engine-Standardverschlüsselung konvertieren – es sei denn, Sie erstellen ein neues Laufwerk-Image und einen neuen nichtflüchtigen Speicher.

Snapshots von Laufwerken, die mit CSEK verschlüsselt wurden, sind immer vollständige Snapshots. Dies unterscheidet sich von Snapshots von Laufwerken, die mit vom Kunden verwalteten Verschlüsselungsschlüsseln (Customer-Managed Encryption Keys, CMEKs) verschlüsselt sind und inkrementell sind. Die Preise für Snapshots richten sich nach der Gesamtgröße des Snapshots. Ein vollständiger Snapshot kann also mehr kosten als ein inkrementeller Snapshot.

Um einen Snapshot einer persistenten Festplatte zu erstellen, muss Ihr Request für eine Snapshot-Erstellung den Verschlüsselungsschlüssel enthalten, den Sie verwendet haben, um die persistente Festplatte zu verschlüsseln.

Lesen Sie die Best Practices für Snapshots von nichtflüchtigem Speicher, bevor Sie den Snapshot erstellen.

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

Neues Image aus einem Laufwerk oder mit CSEK verschlüsselten benutzerdefinierten Image erstellen

Sie können benutzerdefinierte Images von verschlüsselten nichtflüchtigen Speichern erstellen oder verschlüsselte Images kopieren. Zum Kopieren von Images können Sie nicht die Konsole verwenden. Verwenden Sie das Google Cloud CLI oder REST, um Images zu kopieren.

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

Importiertes Image mit CSEK verschlüsseln

Sie können ein neues Image verschlüsseln, wenn Sie manuell ein benutzerdefiniertes Image in Compute Engine importieren. Vor dem Importieren eines Images müssen Sie eine Image-Datei des Laufwerks erstellen und komprimieren und diese komprimierte Datei in Cloud Storage hochladen.

Importieren Sie das benutzerdefinierte Compute Engine-Image, das Sie verschlüsseln möchten. Geben Sie den URI für die komprimierte Datei und einen Pfad zu Ihrer Verschlüsselungsschlüsseldatei an.

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

Nichtflüchtigen Speicher von einer mit CSEK verschlüsselten Ressource erstellen

Laufwerk aus einem mit CSEK verschlüsselten Snapshot erstellen

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

Laufwerk von einem Image erstellen, das mit CSEK verschlüsselt wurde

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

Mit CSEK verschlüsseltes Laufwerk an eine neue VM anhängen

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

VMs mit verschlüsselten CSEKs starten oder neu starten

Weitere Informationen zum Stoppen oder Starten einer VM mit verschlüsselten Laufwerken finden Sie unter VM mit einem verschlüsselten Laufwerk neu starten.

Mit der Befehlszeile gemischte Ressourcen erstellen

Wenn Sie mit dem Google Cloud CLI eine Mischung aus vom Kunden verschlüsselten und standardverschlüsselten Ressourcen in einer einzigen Anfrage erstellen möchten, können Sie das Flag --csek-key-file mit einer Schlüsseldatei und das Flag --no-require-csek-key-create in Ihrer Anfrage verwenden. Durch Angabe der beiden Flags werden mit dem gcloud CLI alle vom Kunden verschlüsselten Ressourcen, die in Ihrer Schlüsseldatei explizit definiert wurden, und ebenso alle von Ihnen angegebenen Standardressourcen erstellt.

Angenommen, eine Schlüsseldatei enthält Folgendes:

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

Wenn Sie in derselben Anfrage eine VM mit einem vom Kunden verschlüsselten Laufwerk mithilfe der Schlüsseldatei und gleichzeitig eine VM mit einem standardmäßig verschlüsselten Laufwerk erstellen möchten, können Sie so vorgehen:

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

Normalerweise wäre es nicht möglich, example-disk-2 zu erstellen, wenn Sie vorher nur das Flag --csek-key-file angegeben haben, weil das Laufwerk nicht explizit in der Schlüsseldatei definiert wurde. Durch Hinzufügen von --no-require-csek-key-create werden beide Laufwerke erstellt – ein mit der Schlüsseldatei verschlüsseltes Laufwerk und ein mit der Google-Verschlüsselung verschlüsseltes Laufwerk.

CSEK aus einem nichtflüchtigen Speicher entfernen

Sie können die Inhalte eines vom Kunden verschlüsselten Laufwerks entschlüsseln und ein neues Laufwerk erstellen, das stattdessen die Compute Engine-Standardverschlüsselung verwendet.

1. Erstellen Sie ein Image des verschlüsselten Laufwerks und legen Sie für das neue Image die automatische Verschlüsselung fest.
2. Verwenden Sie das neue Image, um einen neuen nichtflüchtigen Speicher zu erstellen.

Nachdem Sie den neuen nichtflüchtigen Speicher erstellt haben, werden die Inhalte des Laufwerks durch die Compute Engine-Standardverschlüsselung gesichert. Auch die Snapshots, die Sie von diesem Laufwerk erstellen, müssen die Standardverschlüsselung verwenden.