Vom Kunden verwaltete Verschlüsselungsschlüssel verwenden

Auf dieser Seite erfahren Sie, wie Sie einen Cloud Key Management Service-Verschlüsselungsschlüssel mit Cloud Storage verwenden. Sie erhalten Informationen über die ersten Schritte mit dieser Funktion, die Verwendung von Standardschlüsseln für Buckets und das Hinzufügen von Schlüsseln zu einzelnen Objekten. Der Cloud KMS-Verschlüsselungsschlüssel ist ein vom Kunden verwalteter Verschlüsselungsschlüssel, der von Cloud KMS erstellt und von Ihnen verwaltet wird. Weitere Informationen zu dieser Funktion, einschließlich der Länder, in denen sie zur Verfügung steht, finden Sie in der Dokumentation zu vom Kunden verwalteten Verschlüsselungsschlüsseln. Weitere Verschlüsselungsoptionen in Cloud Storage finden Sie unter Datenverschlüsselungsoptionen.

Vorbereitung

Gehen Sie vor der Verwendung dieser Funktion in Cloud Storage so vor:

  1. Aktivieren Sie die Cloud KMS API für das Projekt, in dem Ihre Verschlüsselungsschlüssel gespeichert werden.

    API aktivieren

  2. Sie benötigen ausreichende Berechtigungen für das Projekt, in dem Ihre Verschlüsselungsschlüssel gespeichert werden:

    • Wenn Sie der Inhaber des Projekts sind, in dem Ihre Schlüssel gespeichert werden, haben Sie wahrscheinlich die erforderliche Berechtigung.

    • Wenn Sie neue Verschlüsselungsschlüssel und -schlüsselbunde erstellen möchten, benötigen Sie die Berechtigungen cloudkms.keyRings.create und cloudkms.cryptoKey.create.

    • Unabhängig davon, ob Sie neue oder vorhandene Schlüsselbunde und Schlüssel verwenden möchten, benötigen Sie die Berechtigung cloudkms.cryptoKey.setIamPolicy für die Schlüssel, die Sie für die Verschlüsselung verwenden.

      Mit dieser Berechtigung können Sie Cloud Storage-Dienstkonten Zugriff auf Cloud KMS-Schlüssel gewähren.

    • Die oben genannten Berechtigungen sind in der Rolle roles/cloudkms.admin enthalten.

      Unter IAM mit Cloud KMS verwenden wird beschrieben, wie Sie diese oder andere Cloud KMS-Rollen erhalten.

  3. Achten Sie auf ausreichende Berechtigungen, um mit Objekten in Ihrem Cloud Storage-Bucket zu arbeiten:

    • Wenn Sie der Inhaber des Projekts sind, zu dem der Bucket gehört, haben Sie wahrscheinlich die erforderliche Berechtigung.

    • Wenn Sie IAM verwenden, benötigen Sie die storage.objects.create-Berechtigung zum Schreiben von Objekten in den Bucket und die storage.objects.get-Berechtigung zum Lesen von Objekten aus dem Bucket. Unter IAM-Berechtigungen verwenden wird beschrieben, wie Sie eine Rolle wie roles/storage.objectAdmin erhalten, die diese Berechtigungen enthält.

    • Wenn Sie ACLs verwenden, benötigen Sie die Bucket-bezogene WRITER-Berechtigung, um Objekte in den Bucket zu schreiben, und die objektbezogene READER-Berechtigung, um Objekte aus dem Bucket zu lesen. Weitere Informationen dazu finden Sie unter ACLs festlegen.

  4. Sie benötigen einen Cloud KMS-Schlüsselbund und mindestens einen Schlüssel innerhalb des Schlüsselbunds.

  5. Rufen Sie die E-Mail-Adresse des Dienstkontos ab, das mit dem Projekt verknüpft ist, in dem sich Ihr Cloud Storage-Bucket befindet.

Cloud KMS-Schlüssel einem Dienstkonto zuweisen

Sie müssen Ihrem Cloud Storage-Dienstkonto die Berechtigung zur Verwendung Ihres Cloud KMS-Schlüssels erteilen, um vom Kunden verwaltete Verschlüsselungsschlüssel zu verwenden.

Console

  1. Öffnen Sie den Browser für Cloud Key Management Service-Schlüssel in der Google Cloud Platform Console.
    Zum Browser für Cloud KMS-Schlüssel
  2. Klicken Sie auf den Namen des Schlüsselbunds, der den gewünschten Schlüssel enthält.

  3. Klicken Sie das Kästchen für den gewünschten Schlüssel an.

    Der Tab Berechtigungen im rechten Fensterbereich wird verfügbar.

  4. Geben Sie im Dialogfeld Mitglieder hinzufügen die E-Mail-Adresse des Cloud Storage-Dienstkontos ein, dem Sie Zugriff gewähren möchten.

  5. Wählen Sie im Drop-down-Menü Rolle auswählen die Option Cloud KMS CryptoKey-Verschlüsseler/Entschlüsseler aus.

  6. Klicken Sie auf Hinzufügen.

gsutil

Verwenden Sie den Befehl gsutil kms authorize, um dem mit Ihrem Bucket verknüpften Dienstkonto die Berechtigung zum Verschlüsseln und Entschlüsseln von Objekten mithilfe Ihres Cloud KMS-Schlüssels zu erteilen:

gsutil kms authorize -p [PROJECT_STORING_OBJECTS] -k [KEY_RESOURCE]

Dabei gilt:

  • [PROJECT_STORING_OBJECTS] ist die ID für das Projekt, das die Objekte enthält, die Sie verschlüsseln oder entschlüsseln möchten. Beispiel: my-pet-project.
  • [KEY_RESOURCE] ist Ihre Cloud KMS-Schlüsselressource. Beispiel: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

Wenn Sie die erteilte Berechtigung entfernen möchten, müssen Sie entweder das gcloud-Befehlszeilentool oder die Google Cloud Platform Console verwenden.

Codebeispiele

C#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

        public static void AddMemberToCryptoKeyPolicy(string projectId, string locationId,
            string keyRingId, string cryptoKeyId, string role, string member)
        {
            KeyManagementServiceClient client = KeyManagementServiceClient.Create();
            CryptoKeyName cryptoKeyName =
                new CryptoKeyName(projectId, locationId, keyRingId, cryptoKeyId);

            Policy policy = client.GetIamPolicy(KeyNameOneof.From(cryptoKeyName));
            policy.Bindings.Add(new Binding
            {
                Role = role,
                Members = { member }
            });

            Policy updateResult = client.SetIamPolicy(KeyNameOneof.From(cryptoKeyName), policy);

            foreach (Binding bindingResult in updateResult.Bindings)
            {
                Console.WriteLine($"Role: {bindingResult.Role}");
                foreach (string memberResult in bindingResult.Members)
                {
                    Console.WriteLine($"  Member: {memberResult}");
                }
            }
        }

Go

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/iam"
	cloudkms "cloud.google.com/go/kms/apiv1"
	kmspb "google.golang.org/genproto/googleapis/cloud/kms/v1"
)

// addMemberRingPolicy adds a new member to a specified IAM role for the key ring.
func addMemberRingPolicy(w io.Writer, keyRingName, member string, role iam.RoleName) error {
	// keyRingName := "projects/PROJECT_ID/locations/global/keyRings/RING_ID"
	// member := "user@gmail.com"
	// role := iam.Viewer
	ctx := context.Background()
	client, err := cloudkms.NewKeyManagementClient(ctx)
	if err != nil {
		return fmt.Errorf("cloudkms.NewKeyManagementClient: %v", err)
	}

	// Get the KeyRing.
	keyRingObj, err := client.GetKeyRing(ctx, &kmspb.GetKeyRingRequest{Name: keyRingName})
	if err != nil {
		return fmt.Errorf("GetKeyRing: %v", err)
	}
	// Get IAM Policy.
	handle := client.KeyRingIAM(keyRingObj)
	policy, err := handle.Policy(ctx)
	if err != nil {
		return fmt.Errorf("Policy: %v", err)
	}
	// Add Member.
	policy.Add(member, role)
	if err = handle.SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("SetPolicy: %v", err)
	}
	fmt.Fprintf(w, "Added member %s to keyring policy.", member)
	return nil
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.


/**
 * Adds the given member to the given key, with the given role.
 *
 * @param projectId The id of the project.
 * @param locationId The location id of the key.
 * @param keyRingId The id of the keyring.
 * @param cryptoKeyId The id of the crypto key.
 * @param member The member to add. Must be in the proper format, eg:
 *
 * allUsers user:$userEmail serviceAccount:$serviceAccountEmail
 *
 * See https://g.co/cloud/kms/docs/reference/rest/v1/Policy#binding for more details.
 * @param role Must be in one of the following formats: roles/[role]
 * organizations/[organizationId]/roles/[role] projects/[projectId]/roles/[role]
 *
 * See https://g.co/cloud/iam/docs/understanding-roles for available values for [role].
 */
public static Policy addMemberToCryptoKeyPolicy(
    String projectId, String locationId, String keyRingId, String cryptoKeyId, String member,
    String role)
    throws IOException {

  // Create the Cloud KMS client.
  try (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {

    // The resource name of the cryptoKey version
    String keyName = CryptoKeyName.format(projectId, locationId, keyRingId, cryptoKeyId);

    // Get the current IAM policy
    Policy iamPolicy = client.getIamPolicy(keyName);

    // Create a new binding with the selected role and member
    Binding newBinding = Binding.newBuilder()
        .setRole(role)
        .addMembers(member)
        .build();

    // Create a new IAM policy containing the existing settings plus the new binding.
    Policy newPolicy = Policy.newBuilder()
        .mergeFrom(iamPolicy)
        .addBindings(newBinding)
        .build();

    // Set the new IAM Policy.
    Policy policyResult = client.setIamPolicy(keyName, newPolicy);

    return policyResult;
  }
}

Node.js

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

async function addMemberToCryptoKeyPolicy(
  projectId = 'your-project-id', // Your GCP Project Id
  keyRingId = 'my-key-ring', // Name of the crypto key's key ring
  cryptoKeyId = 'my-key', // Name of the crypto key
  member = 'user:dev@example.com', // Member to add to the crypto key
  role = 'roles/viewer' // Role to give the member
) {
  // Import the library and create a client
  const kms = require('@google-cloud/kms');
  const client = new kms.KeyManagementServiceClient();

  // The location of the crypto key's key ring
  const locationId = 'global';

  // Get the full path to the crypto key
  const resource = client.cryptoKeyPath(
    projectId,
    locationId,
    keyRingId,
    cryptoKeyId
  );

  // Gets the IAM policy of a crypto key
  const [result] = await client.getIamPolicy({resource});
  let policy = Object.assign({bindings: []}, result);
  const index = policy.bindings.findIndex(binding => binding.role === role);

  // Add the role/member combo to the policy
  const members = [];
  const binding = Object.assign({role, members}, policy.bindings[index]);
  if (index === -1) {
    policy.bindings.push(binding);
  }
  if (!binding.members.includes(member)) {
    binding.members.push(member);
  }

  // Adds the member/role combo to the policy of the crypto key
  [policy] = await client.setIamPolicy({resource, policy});
  console.log(
    `${member}/${role} combo added to policy for crypto key ${cryptoKeyId}.`
  );
  if (policy.bindings) {
    policy.bindings.forEach(binding => {
      if (binding.members && binding.members.length) {
        console.log(`${binding.role}:`);
        binding.members.forEach(member => {
          console.log(`  ${member}`);
        });
      }
    });
  } else {
    console.log(`Policy for crypto key ${cryptoKeyId} is empty.`);
  }
}

PHP

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

use Google\Cloud\Kms\V1\KeyManagementServiceClient;
use Google\Cloud\Iam\V1\Binding;

/** Uncomment and populate these variables in your code */
// $projectId = 'The Google project ID';
// $locationId = 'The location ID of the crypto key. Can be "global", "us-west1", etc.';
// $keyRingId = 'The KMS key ring ID';
// $cryptoKeyId = 'The KMS key ID';
// $member = 'Must be in the format "user:$userEmail" or "serviceAccount:$serviceAccountEmail"';
// $role = 'Must be in the format "roles/$role", "organizations/$organizationId/roles/$role", or "projects/$projectId/roles/$role"';

$kms = new KeyManagementServiceClient();

// The resource name of the CryptoKey.
$cryptoKeyName = $kms->cryptoKeyName($projectId, $locationId, $keyRingId, $cryptoKeyId);

// Get the current IAM policy and add the new account to it.
$policy = $kms->getIamPolicy($cryptoKeyName);
$bindings = $policy->getBindings();
$bindings[] = new Binding([
    'members' => [$member],
    'role' => $role,
]);
$policy->setBindings($bindings);

// Set the new IAM Policy.
$kms->setIamPolicy($cryptoKeyName, $policy);

printf('Member %s added to policy for cryptoKey %s in keyRing %s' . PHP_EOL, $member, $cryptoKeyId, $keyRingId);

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

def add_member_to_crypto_key_policy(
        project_id, location_id, key_ring_id, crypto_key_id, member, role):
    """Adds a member with a given role to the Identity and Access Management
    (IAM) policy for a given CryptoKey associated with a KeyRing."""

    from google.cloud import kms_v1

    # Creates an API client for the KMS API.
    client = kms_v1.KeyManagementServiceClient()

    # The resource name of the CryptoKey.
    resource = client.crypto_key_path_path(project_id, location_id,
                                           key_ring_id, crypto_key_id)
    # Get the current IAM policy.
    policy = client.get_iam_policy(resource)

    # Add member
    policy.bindings.add(
        role=role,
        members=[member])

    # Update the IAM Policy.
    client.set_iam_policy(resource, policy)

    # Print results
    print('Member {} added with role {} to policy for CryptoKey {} \
           in KeyRing {}'.format(member, role, crypto_key_id, key_ring_id))

Ruby

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

# project_id  = "Your Google Cloud project ID"
# location_id = "The location of the key ring"
# key_ring_id = "The ID of the key ring"
# member      = "Member to add to the key ring policy"
# role        = "Role assignment for new member"

require "google/cloud/kms/v1"
CloudKMS = Google::Cloud::Kms::V1

# Initialize the client
client = CloudKMS::KeyManagementServiceClient.new

# The key ring to use
key_ring =
  CloudKMS::KeyManagementServiceClient.key_ring_path project_id, location_id, key_ring_id

# Get the current IAM policy
policy = client.get_iam_policy key_ring

# Add new member to current bindings
policy.bindings ||= []
policy.bindings << Google::Iam::V1::Binding.new(members: [member], role: role)

# Update IAM policy
client.set_iam_policy key_ring, policy

puts "Member #{member} added to policy for " +
     "key ring #{key_ring_id}"

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

    {
      "policy": {
        "bindings": {
          "role": "roles/cloudkms.cryptoKeyEncrypterDecrypter",
          "members": "[SERVICE_ACCOUNT_EMAIL_ADDRESS]"
        },
      }
    }

    Dabei ist [SERVICE_ACCOUNT_EMAIL_ADDRESS] die mit Ihrem Dienstkonto verknüpfte E-Mail-Adresse. Beispiel: service-7550275089395@my-pet-project.iam.gserviceaccount.com.

  3. Verwenden Sie cURL, um die Cloud KMS API mit einer POST setIamPolicy-Anfrage aufzurufen:

    curl -X POST --data-binary @[JSON_FILE_NAME].json \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    -H "Content-Type: application/json" \
    "https://cloudkms.googleapis.com/v1/[KEY_RESOURCE]:setIamPolicy"

    Dabei gilt:

    • [JSON_FILE_NAME] ist der Name der Datei, die Sie in Schritt 2 erstellt haben.
    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [KEY_RESOURCE] ist Ihre Cloud KMS-Schlüsselressource. Beispiel: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

XML API

Die XML API kann nicht verwendet werden, um Cloud KMS einem Dienstkonto zuzuweisen. Verwenden Sie stattdessen eines der anderen Cloud Storage-Tools, z. B. gsutil.

Standardverschlüsselungsschlüssel verwenden

Standardschlüssel für einen Bucket hinzufügen oder ändern

So können Sie den Cloud KMS-Standardschlüssel einfügen oder ändern, wenn Objekte in einen Bucket geschrieben werden:

Console

  1. Öffnen Sie in der Google Cloud Platform Console den Cloud Storage-Browser.
    Zum Cloud Storage-Browser
  2. Klicken Sie in der Liste der Buckets auf den gewünschten Bucket.

  3. Klicken Sie oben auf der Seite auf Bucket bearbeiten.

  4. Klicken Sie auf der Seite "Bucket bearbeiten" auf Erweiterte Einstellungen anzeigen.

  5. Wenn der Bucket derzeit keinen Cloud KMS-Schlüssel verwendet, wählen Sie das Optionsfeld Vom Kunden verwalteter Schlüssel aus.

  6. Wählen Sie im Drop-down-Menü für die vom Kunden verwalteten Schlüssel einen der verfügbaren Schlüssel aus.

  7. Klicken Sie auf Speichern.

gsutil

Führen Sie folgenden gsutil kms encryption-Befehl aus:

gsutil kms encryption -k [KEY_RESOURCE] gs://[BUCKET_NAME]

Dabei gilt:

  • [KEY_RESOURCE] ist Ihre Cloud KMS-Schlüsselressource. Beispiel: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.
  • [BUCKET_NAME] ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

Wenn der Vorgang erfolgreich war, sieht die Antwort so aus:

Authorized service account [SERVICE_ACCOUNT_NAME] to use key:
[KEY_RESOURCE]

Codebeispiele

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string key_name) {
  StatusOr<gcs::BucketMetadata> updated_metadata = client.PatchBucket(
      bucket_name, gcs::BucketMetadataPatchBuilder().SetEncryption(
                       gcs::BucketEncryption{key_name}));

  if (!updated_metadata) {
    throw std::runtime_error(updated_metadata.status().message());
  }

  if (!updated_metadata->has_encryption()) {
    std::cerr << "The change to set the encryption attribute on bucket "
              << updated_metadata->name()
              << " was sucessful, but the encryption is not set."
              << "This is unexpected, maybe a concurrent change?\n";
    return;
  }

  std::cout << "Successfully set default KMS key on bucket  "
            << updated_metadata->name() << " to "
            << updated_metadata->encryption().default_kms_key_name << "."
            << "\nFull metadata: " << *updated_metadata << "\n";
}

C#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

private void AddBucketDefaultKmsKey(string bucketName,
    string keyLocation, string kmsKeyRing, string kmsKeyName)
{
    string KeyPrefix = $"projects/{s_projectId}/locations/{keyLocation}";
    string FullKeyringName = $"{KeyPrefix}/keyRings/{kmsKeyRing}";
    string FullKeyName = $"{FullKeyringName}/cryptoKeys/{kmsKeyName}";
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    bucket.Encryption = new Bucket.EncryptionData
    {
        DefaultKmsKeyName = FullKeyName
    };
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

Go

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

bucket := c.Bucket(bucketName)
bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
	Encryption: &storage.BucketEncryption{DefaultKMSKeyName: keyName},
}
if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
	return err
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.

// Instantiate a Google Cloud Storage client
Storage storage = StorageOptions.getDefaultInstance().getService();

// The name of the existing bucket to set a default KMS key for, e.g. "my-bucket"
// String bucketName = "my-bucket"

// The name of the KMS-key to use as a default
// Key names are provided in the following format:
// 'projects/<PROJECT>/locations/<LOCATION>/keyRings/<RING_NAME>/cryptoKeys/<KEY_NAME>'
// String kmsKeyName = ""

BucketInfo bucketInfo =
    BucketInfo.newBuilder(bucketName).setDefaultKmsKeyName(kmsKeyName).build();

Bucket bucket = storage.update(bucketInfo);

System.out.println("Default KMS Key Name: " + bucket.getDefaultKmsKeyName());

Node.js

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const defaultKmsKeyName = 'KMS key resource id, e.g. my-key';

// Enables a default KMS key for the bucket
await storage.bucket(bucketName).setMetadata({
  encryption: {
    defaultKmsKeyName,
  },
});

console.log(
  `Default KMS key for ${bucketName} was set to ${defaultKmsKeyName}.`
);

PHP

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

use Google\Cloud\Storage\StorageClient;

/**
 * Enable a bucket's requesterpays metadata.
 *
 * @param string $projectId Your Google Cloud project ID.
 * @param string $bucketName Name of your Google Cloud Storage bucket.
 * @param string $kmsKeyName KMS key ID to use as the default KMS key.
 *
 * @return void
 */
function enable_default_kms_key($projectId, $bucketName, $kmsKeyName)
{
    $storage = new StorageClient([
        'projectId' => $projectId
    ]);
    $bucket = $storage->bucket($bucketName);
    $bucket->update([
        'encryption' => [
            'defaultKmsKeyName' => $kmsKeyName
        ]
    ]);
    printf('Default KMS key for %s was set to %s' . PHP_EOL,
        $bucketName,
        $bucket->info()['encryption']['defaultKmsKeyName']);
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

"""Sets a bucket's default KMS key."""
storage_client = storage.Client()
bucket = storage_client.get_bucket(bucket_name)
bucket.default_kms_key_name = kms_key_name
bucket.patch()

print('Set default KMS key for bucket {} to {}.'.format(
    bucket.name,
    bucket.default_kms_key_name))

Ruby

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

# project_id      = "Your Google Cloud project ID"
# bucket_name     = "Name of your Google Cloud Storage bucket"
# default_kms_key = "KMS key resource id"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id
bucket  = storage.bucket bucket_name

bucket.default_kms_key = default_kms_key

puts "Default KMS key for #{bucket.name} was set to #{bucket.default_kms_key}"

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

    {
      "encryption": {
        "defaultKmsKeyName": "[KEY_RESOURCE]"
      }
    }

    Dabei ist [KEY_RESOURCE] Ihre Cloud KMS-Schlüsselressource. Beispiel: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

  3. Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen:

    curl -X PATCH --data-binary @[JSON_FILE_NAME].json \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    -H "Content-Type: application/json" \
    "https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]?fields=encryption"

    Dabei gilt:

    • [JSON_FILE_NAME] ist die Datei, die Sie in Schritt 2 erstellt haben.
    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [BUCKET_NAME] ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

XML API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine XML-Datei, die die folgenden Informationen enthält:

    <EncryptionConfiguration>
      <DefaultKmsKeyName>[KEY_RESOURCE]</DefaultKmsKeyName>
    </EncryptionConfiguration>

    Dabei ist [KEY_RESOURCE] Ihre Cloud KMS-Schlüsselressource. Beispiel: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

  3. Verwenden Sie cURL, um die XML API mit einer PUT-Bucket-Anfrage und dem Abfragestringparameter encryption aufzurufen.

    curl -X PUT --data-binary @[XML_FILE_NAME].xml \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    "https://storage.googleapis.com/[BUCKET_NAME]?encryptionConfig"

    Dabei gilt:

    • [XML_FILE_NAME] ist die Datei, die Sie in Schritt 2 erstellt haben.
    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [BUCKET_NAME] ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

Standardschlüssel für einen Bucket anzeigen lassen

So lassen Sie den Cloud KMS-Schlüssel anzeigen, der derzeit als Standard für Ihren Bucket festgelegt ist:

Console

  1. Öffnen Sie in der Google Cloud Platform Console den Cloud Storage-Browser.
    Zum Cloud Storage-Browser
  2. Klicken Sie in der Liste der Buckets auf den gewünschten Bucket.

  3. Klicken Sie auf der Bucket-Detailseite auf den Tab Übersicht.

  4. Der aktuelle Standardschlüssel für Ihren Bucket wird im Feld Verschlüsselungsschlüssel angezeigt.

gsutil

Führen Sie folgenden gsutil kms encryption-Befehl aus:

gsutil kms encryption gs://[BUCKET_NAME]

Dabei ist [BUCKET_NAME] der Name des Buckets, dessen Schlüssel Sie aufrufen möchten. Beispiel: my-bucket.

Wenn der Vorgang erfolgreich war, sieht die Antwort so aus:

Default encryption key for gs://[BUCKET_NAME]:
[KEY_RESOURCE]

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Verwenden Sie cURL, um die JSON API mit einer GET-Bucket-Anfrage aufzurufen, die den gewünschten fields enthält:

    curl -X GET -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    "https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]?fields=encryption"

    Dabei gilt:

    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [BUCKET_NAME] ist der Name des Buckets, dessen Schlüssel Sie aufrufen möchten. Beispiel: my-bucket.

    Die Antwort sieht in etwa so aus:

    {
      "encryption" : {
         "defaultKmsKeyName": "[KEY_RESOURCE]"
       },
    }

XML API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Verwenden Sie cURL, um die XML API mit einer GET-Bucket-Anfrage aufzurufen, die den gewünschten encryption-Abfrageparameter enthält:

    curl -X GET -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    "https://storage.googleapis.com/[BUCKET_NAME]?encryptionConfig"

    Dabei gilt:

    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [BUCKET_NAME] ist der Name des Buckets, dessen Schlüssel Sie aufrufen möchten. Beispiel: my-bucket.

    Die Antwort sieht in etwa so aus:

    <EncryptionConfiguration>
      <DefaultKmsKeyName>[KEY_RESOURCE]</DefaultKmsKeyName>
    </EncryptionConfiguration>

Standardschlüssel aus einem Bucket entfernen

So entfernen Sie Cloud KMS-Standardschlüssel aus einem Bucket:

Console

  1. Öffnen Sie in der Google Cloud Platform Console den Cloud Storage-Browser.
    Zum Cloud Storage-Browser
  2. Klicken Sie in der Liste der Buckets auf den gewünschten Bucket.

  3. Klicken Sie oben auf der Seite auf Bucket bearbeiten.

  4. Klicken Sie auf der Seite "Bucket bearbeiten" auf Erweiterte Einstellungen anzeigen.

  5. Wählen Sie das Optionsfeld Von Google verwalteter Schlüssel aus.

  6. Klicken Sie auf Speichern.

gsutil

Führen Sie folgenden gsutil kms encryption-Befehl aus:

gsutil kms encryption -d gs://[BUCKET_NAME]

Dabei ist [BUCKET_NAME] der Name des entsprechenden Buckets. Beispiel: my-bucket.

Wenn der Vorgang erfolgreich war, sieht die Antwort so aus:

Clearing default encryption key for gs://[BUCKET_NAME]...

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine JSON-Datei, die die folgenden Informationen enthält:

    {
      "encryption": {
        "defaultKmsKeyName": null
      }
    }
  3. Verwenden Sie cURL, um die JSON API mit einer PATCH-Bucket-Anfrage aufzurufen:

    curl -X PATCH --data-binary @[JSON_FILE_NAME].json \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    -H "Content-Type: application/json" \
    "https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]?fields=encryption"

    Dabei gilt:

    • [JSON_FILE_NAME] ist die Datei, die Sie in Schritt 2 erstellt haben.
    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [BUCKET_NAME] ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

XML API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Erstellen Sie eine XML-Datei, die die folgenden Informationen enthält:

    <EncryptionConfiguration></EncryptionConfiguration>
  3. Verwenden Sie cURL, um die XML API mit einer PUT-Bucket-Anfrage und dem Abfragestringparameter encryption aufzurufen.

    curl -X PUT --data-binary @[XML_FILE_NAME].xml \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    "https://storage.googleapis.com/[BUCKET_NAME]?encryptionConfig"

    Dabei gilt:

    • [XML_FILE_NAME] ist die Datei, die Sie in Schritt 2 erstellt haben.
    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [BUCKET_NAME] ist der Name des entsprechenden Buckets. Beispiel: my-bucket.

Objekte mit einem Cloud KMS-Schlüssel verschlüsseln

Sie können einzelne Objekte mit einem Cloud KMS-Schlüssel verschlüsseln. Dies ist nützlich, wenn Sie für den Bucket einen anderen Schlüssel als den Standardschlüssel verwenden möchten oder wenn für den Bucket kein Standardschlüssel festgelegt ist.

Console

Sie können die GCP Console nicht zum Verschlüsseln einzelner Objekte verwenden. Verwenden Sie stattdessen "gsutil" oder die Clientbibliotheken.

gsutil

  1. Fügen Sie im Abschnitt [GSUtil] Ihrer .boto-Konfigurationsdatei die folgende Option hinzu:

    encryption_key = [KEY_RESOURCE]

    Dabei ist [KEY_RESOURCE] Ihre Cloud KMS-Schlüsselressource. Beispiel: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

  2. Schreiben Sie wie gewohnt ein Objekt in den Bucket, zum Beispiel mit gsutil cp oder gsutil rewrite.

Codebeispiele

C++

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C++ API.

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string object_name,
   std::string kms_key_name) {
  gcs::ObjectWriteStream stream = client.WriteObject(
      bucket_name, object_name, gcs::KmsKeyName(kms_key_name));

  // Line numbers start at 1.
  for (int lineno = 1; lineno <= 10; ++lineno) {
    stream << lineno << ": placeholder text for CMEK example.\n";
  }

  stream.Close();

  StatusOr<gcs::ObjectMetadata> metadata = std::move(stream).metadata();

  if (!metadata) {
    throw std::runtime_error(metadata.status().message());
  }

  std::cout << "Successfully wrote to object " << metadata->name()
            << " its size is: " << metadata->size()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage C# API.

        private void UploadEncryptedFileWithKmsKey(string bucketName,
            string keyLocation, string kmsKeyRing, string kmsKeyName,
            string localPath, string objectName = null)
        {
            string KeyPrefix = $"projects/{s_projectId}/locations/{keyLocation}";
            string FullKeyringName = $"{KeyPrefix}/keyRings/{kmsKeyRing}";
            string FullKeyName = $"{FullKeyringName}/cryptoKeys/{kmsKeyName}";

            var storage = StorageClient.Create();
            using (var f = File.OpenRead(localPath))
            {
                objectName = objectName ?? Path.GetFileName(localPath);
                storage.UploadObject(bucketName, objectName, null, f,
                    new UploadObjectOptions()
                    {
                        KmsKeyName = FullKeyName
                    });
                Console.WriteLine($"Uploaded {objectName}.");
            }
        }

Go

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Go API.

obj := client.Bucket(bucket).Object(object)
// Encrypt the object's contents
wc := obj.NewWriter(ctx)
wc.KMSKeyName = keyName
if _, err := wc.Write([]byte("top secret")); err != nil {
	return err
}
if err := wc.Close(); err != nil {
	return err
}

Java

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Java API.

byte[] data = "Hello, World!".getBytes(UTF_8);

// The name of the existing bucket to set a default KMS key for, e.g. "my-bucket"
// String bucketName = "my-bucket"

// The name of the KMS-key to use as a default
// Key names are provided in the following format:
// 'projects/<PROJECT>/locations/<LOCATION>/keyRings/<RING_NAME>/cryptoKeys/<KEY_NAME>'
// String kmsKeyName = ""

BlobId blobId = BlobId.of(bucketName, blobName);
BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
Blob blob = storage.create(blobInfo, data, BlobTargetOption.kmsKeyName(kmsKeyName));

Node.js

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Node.js API.

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'Local file to upload, e.g. ./local/path/to/file.txt';
// const kmsKeyName = 'KMS key resource id, e.g. my-key';

// Uploads a local file to the bucket with the kms key
await storage.bucket(bucketName).upload(filename, {
  kmsKeyName,
});

console.log(`${filename} uploaded to ${bucketName} using ${kmsKeyName}.`);

PHP

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage PHP API.

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file using KMS encryption.
 *
 * @param string $projectId Your Google Cloud project ID.
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of the object.
 * @param string $source the path to the file to upload.
 * @param string $kmsKeyName KMS key ID used to encrypt objects server side.
 *
 * @return Psr\Http\Message\StreamInterface
 */
function upload_with_kms_key($projectId, $bucketName, $objectName, $source, $kmsKeyName)
{
    $storage = new StorageClient([
        'projectId' => $projectId,
    ]);
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName,
        'destinationKmsKeyName' => $kmsKeyName,
    ]);
    printf('Uploaded %s to gs://%s/%s using encryption key %s' . PHP_EOL,
        basename($source),
        $bucketName,
        $objectName,
        $kmsKeyName);
}

Python

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Python API.

"""Uploads a file to the bucket, encrypting it with the given KMS key."""
storage_client = storage.Client()
bucket = storage_client.get_bucket(bucket_name)
blob = bucket.blob(destination_blob_name, kms_key_name=kms_key_name)
blob.upload_from_filename(source_file_name)

print('File {} uploaded to {} with encryption key {}.'.format(
    source_file_name,
    destination_blob_name,
    kms_key_name))

Ruby

Weitere Informationen finden Sie in der Referenzdokumentation zur Cloud Storage Ruby API.

# project_id        = "Your Google Cloud project ID"
# bucket_name       = "Your Google Cloud Storage bucket name"
# local_file_path   = "Path to local file to upload"
# storage_file_path = "Path to store the file in Google Cloud Storage"
# kms_key           = "KMS key resource id"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id

bucket = storage.bucket bucket_name

file = bucket.create_file local_file_path, storage_file_path,
                          kms_key: kms_key

puts "Uploaded #{file.name} and encrypted service side using #{file.kms_key}"

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Fügen Sie die Daten des Objekts in den Anfragetext ein.

  3. Verwenden Sie cURL, um die JSON API mit einer POST-Objektanfrage aufzurufen:

    curl -X POST --data-binary @[OBJECT] \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    -H "Content-Type: [OBJECT_CONTENT_TYPE]" \
    "https://www.googleapis.com/upload/storage/v1/b/[BUCKET_NAME]/o?uploadType=media&name=[OBJECT_NAME]&kmsKeyName=[KEY_RESOURCE]"

    Dabei gilt:

    • [OBJECT] ist der Pfad zum Objekt, das Sie hochladen. Beispiel: Desktop/dog.png.
    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [OBJECT_CONTENT_TYPE] ist der Inhaltstyp des Objekts. Zum Beispiel image/png.
    • [BUCKET_NAME] ist der Name des Buckets, in den Sie das Objekt hochladen. Zum Beispiel my-bucket.
    • [OBJECT_NAME] ist der Name des Objekts, das Sie hochladen. Beispiel: pets/dog.png.
    • [KEY_RESOURCE] ist die Cloud KMS-Schlüsselressource. Beispiel: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

XML API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Fügen Sie die Daten des Objekts in den Anfragetext ein.

  3. Verwenden Sie cURL, um die XML API mit einer PUT-Objektanfrage aufzurufen:

    curl -X PUT --data-binary @[OBJECT] \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    -H "Content-Type: [OBJECT_CONTENT_TYPE]" \
    -H "x-goog-encryption-kms-key-name: [KEY_RESOURCE]" \
    "https://storage.googleapis.com/[BUCKET_NAME]/[OBJECT_NAME]"

    Dabei gilt:

    • [OBJECT] ist der Pfad zum Objekt, das Sie hochladen. Beispiel: Desktop/dog.png.
    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [OBJECT_CONTENT_TYPE] ist der Inhaltstyp des Objekts. Zum Beispiel image/png.
    • [BUCKET_NAME] ist der Name des Buckets, in den Sie das Objekt hochladen. Zum Beispiel my-bucket.
    • [OBJECT_NAME] ist der Name des Objekts, das Sie hochladen. Beispiel: pets/dog.png.
    • [KEY_RESOURCE] ist Ihre Cloud KMS-Schlüsselressource. Beispiel: projects/my-pet-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key.

Schlüssel identifizieren, der zum Verschlüsseln eines Objekts verwendet wurde

So ermitteln Sie den Namen eines Cloud KMS-Schlüssels, der zum Verschlüsseln eines Objekts verwendet wurde:

Console

  1. Öffnen Sie in der Google Cloud Platform Console den Cloud Storage-Browser.
    Zum Cloud Storage-Browser
  2. Rufen Sie im entsprechenden Bucket das gewünschte Objekt auf.

  3. Bewegen Sie den Mauszeiger in der Spalte Verschlüsselung auf den Eintrag für das gewünschte Objekt.

    Der Name des Schlüssels wird im folgenden Format angezeigt:

    [LOCATION]/[KEY_RING_NAME]/[KEY_NAME]/[KEY_VERSION]

gsutil

Führen Sie folgenden gsutil stat-Befehl aus:

gsutil stat gs://[BUCKET_NAME]/[OBJECT_NAME]

Dabei gilt:

  • [BUCKET_NAME] ist der Name des Buckets, der das verschlüsselte Objekt enthält. Beispiel: my-bucket.
  • [OBJECT_NAME] ist der Name des verschlüsselten Objekts. Beispiel: pets/dog.png.

Wenn der Vorgang erfolgreich war, enthält die Antwort den Schlüsselnamen:

gs://[BUCKET_NAME]/[OBJECT_NAME]:
...
KMS key: [KEY_RESOURCE]
...

REST APIs

JSON API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Verwenden Sie cURL, um die JSON API mit einer GET-Objektanfrage aufzurufen:

    curl -X GET \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    "https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]/o/[OBJECT_NAME]?fields=kmsKeyName"

    Dabei gilt:

    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [BUCKET_NAME] ist der Name des Buckets, der das verschlüsselte Objekt enthält. Beispiel: my-bucket.
    • [OBJECT_NAME] ist der Name des verschlüsselten Objekts. Beispiel: pets/dog.png.

XML API

  1. Rufen Sie ein Zugriffstoken für die Autorisierung aus dem OAuth 2.0 Playground ab. Konfigurieren Sie den Playground so, dass Ihre eigenen OAuth-Anmeldedaten verwendet werden.
  2. Verwenden Sie cURL, um die XML API mit einer GET-Objektanfrage aufzurufen:

    curl -X GET \
    -H "Authorization: Bearer [OAUTH2_TOKEN]" \
    "https://storage.googleapis.com/[BUCKET_NAME]/[OBJECT_NAME]?encryption"

    Dabei gilt:

    • [OAUTH2_TOKEN] ist das Zugriffstoken, das Sie in Schritt 1 generiert haben.
    • [BUCKET_NAME] ist der Name des Buckets, der das verschlüsselte Objekt enthält. Beispiel: my-bucket.
    • [OBJECT_NAME] ist der Name des verschlüsselten Objekts. Beispiel: pets/dog.png.

Objekte entschlüsseln

Das Entschlüsseln eines Objekts, das mit einem vom Kunden verwalteten Verschlüsselungsschlüssel verschlüsselt wurde, erfolgt automatisch, solange das entsprechende Dienstkonto Zugriff auf den Schlüssel hat. Weitere Informationen finden Sie unter Dienstkonten mit vom Kunden verwalteten Verschlüsselungsschlüsseln.

Weitere Informationen