Verschlüsselungstypen für einen Bucket erzwingen oder einschränken

In diesem Dokument wird beschrieben, wie Sie konfigurieren, welche Verschlüsselungsmethoden für neue Objekte in einem Cloud Storage-Bucket zulässig oder eingeschränkt sind. Sie können einen Bucket so konfigurieren, dass die Verwendung der Standardverschlüsselung (Google-Standardverschlüsselung), von Kunden verwalteter Verschlüsselungsschlüssel (Customer-Managed Encryption Keys, CMEK) oder von Kunden bereitgestellter Verschlüsselungsschlüssel (Customer-Supplied Encryption Keys, CSEK) für alle neuen Objekte, die im Bucket erstellt werden, erzwungen oder eingeschränkt wird.

So können Sie beispielsweise Ihre Complianceanforderungen in Bezug auf die Verwaltung von Verschlüsselungsschlüsseln erfüllen, indem Sie festlegen, dass alle neuen Objekte entweder mit der Standardverschlüsselung oder mit CMEK verschlüsselt werden müssen, und die Verwendung von vom Kunden bereitgestellten Verschlüsselungsschlüsseln einschränken.

Weitere Informationen zu den verfügbaren Verschlüsselungsmethoden finden Sie unter Datenverschlüsselungsoptionen.

Cloud Storage erzwingt die Verschlüsselungskonfiguration für alle Aktionen, die ein neues Objekt erstellen, z. B. das Hochladen eines Objekts, das Kopieren eines Objekts, das Zusammensetzen von Objekten und das Wiederherstellen eines vorläufig gelöschten Objekts.

Hinweis

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Storage Admin (roles/storage.admin) für den Bucket zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Konfigurieren der Verschlüsselungserzwingung für einen Bucket benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Konfigurieren der Verschlüsselungserzwingung für einen Bucket erforderlich sind. Maximieren Sie den Abschnitt Erforderliche Berechtigungen, um die notwendigen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um die Verschlüsselung für einen Bucket zu erzwingen:

  • Legen Sie die Konfiguration beim Erstellen eines neuen Buckets fest: storage.buckets.create
  • Konfiguration für einen vorhandenen Bucket aktualisieren: storage.buckets.update
  • Wenn Sie die Google Cloud Console verwenden, um die Schritte auf dieser Seite auszuführen:
    • storage.buckets.get
    • storage.buckets.list

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Bucket erstellen, in dem Verschlüsselungstypen erzwungen werden

Sie können die Verschlüsselungsmethoden angeben, die für die Objekte in einem Bucket zulässig oder eingeschränkt sind, wenn Sie einen neuen Bucket erstellen.

Wenn Sie einen standardmäßigen Cloud KMS-Schlüssel für den Bucket festlegen, müssen Sie auch die Verschlüsselung mit CMEKs oder vom Kunden bereitgestellten Verschlüsselungsschlüsseln zulassen.

Console

  1. Wechseln Sie in der Google Cloud Console unter „Cloud Storage“ zur Seite Buckets.

    Buckets aufrufen

  2. Klicken Sie auf Erstellen.

  3. Geben Sie auf der Seite Bucket erstellen die Bucket-Informationen ein. Klicken Sie nach jedem der folgenden Schritte auf Weiter, um mit dem nächsten Schritt fortzufahren:

    1. Führen Sie im Abschnitt Einstieg die folgenden Schritte aus:

      • Geben Sie einen global eindeutigen Namen ein, der den Anforderungen für Bucket-Namen entspricht.

      • So fügen Sie ein Bucket-Label hinzu: Klicken Sie auf den Erweiterungspfeil, um den Abschnitt Labels zu maximieren, klicken Sie auf Label hinzufügen und geben Sie key und value für Ihr Label an.

    2. Gehen Sie im Bereich Speicherort für Daten auswählen so vor:

      1. Standorttyp auswählen.

      2. Wählen Sie im Drop-down-Menü für den Standorttyp einen Speicherort aus, an dem die Objektdaten in Ihrem Bucket dauerhaft gespeichert werden sollen.

        • Wenn Sie den Standorttyp Dual-Region auswählen, können Sie auch die Turboreplikation aktivieren, indem Sie das entsprechende Kästchen anklicken.

      3. Wenn Sie die Bucket-übergreifende Replikation einrichten möchten, wählen Sie Bucket-übergreifende Replikation über Storage Transfer Service hinzufügen aus und führen Sie die folgenden Schritte aus:

        Bucket-übergreifende Replikation einrichten

        1. Wählen Sie im Menü Bucket einen Bucket aus.

        2. Klicken Sie im Bereich Replikationseinstellungen auf Konfigurieren, um die Einstellungen für den Replikationsjob zu konfigurieren.

          Der Bereich Bucket-übergreifende Replikation konfigurieren wird angezeigt.

          • Wenn Sie die zu replizierenden Objekte nach dem Objektnamenspräfix filtern möchten, geben Sie ein Präfix ein, mit dem Sie Objekte ein- oder ausschließen möchten, und klicken Sie dann auf Präfix hinzufügen.
          • Wenn Sie eine Speicherklasse für die replizierten Objekte festlegen möchten, wählen Sie im Menü Speicherklasse eine Speicherklasse aus. Wenn Sie diesen Schritt überspringen, wird für replizierte Objekte standardmäßig die Speicherklasse des Ziel-Buckets verwendet.
          • Klicken Sie auf Fertig.

    3. Gehen Sie im Bereich Speicherort für Daten auswählen so vor:

      1. Wählen Sie eine Standardspeicherklasse für den Bucket oder Autoclass für die automatische Speicherklassenverwaltung der Daten Ihres Buckets aus.

      2. Gehen Sie im Abschnitt Speicher für datenintensive Arbeitslasten optimieren so vor:

        • Wenn Sie den hierarchischen Namespace aktivieren möchten, wählen Sie Hierarchischen Namespace für diesen Bucket aktivieren aus.

        • Wenn Sie Rapid Cache aktivieren möchten, wählen Sie Rapid Cache aktivieren aus und folgen Sie der Anleitung:

          1. Klicken Sie auf Konfigurieren, um Caches zu erstellen.

          2. Klicken Sie im angezeigten Dialogfeld Cache-Einstellungen konfigurieren auf den Drop-down-Pfeil neben den aufgeführten Regionen und wählen Sie die Zonen aus, in denen Sie Caches erstellen möchten.

          3. Klicken Sie auf Fertig.

    4. Wählen Sie im Abschnitt Zugriff auf Objekte steuern aus, ob der Bucket Verhinderung des öffentlichen Zugriffs durchsetzt, und wählen Sie einheitlichen Zugriff auf Bucket-Ebene für die Objekte Ihres Buckets aus.

    5. Gehen Sie im Bereich Auswählen, wie Objektdaten geschützt werden so vor:

      • Wählen Sie unter Datenschutz die gewünschten Optionen für Ihren Bucket aus.

      • Wenn Sie ändern möchten, wie lange Objekte nach dem Löschen im Rahmen des vorläufigen Löschens aufbewahrt werden, aktivieren Sie das Kästchen Richtlinie für vorläufiges Löschen und wählen Sie dann die Option Benutzerdefinierte Aufbewahrungsdauer festlegen aus. Geben Sie an, wie lange Sie gelöschte Objekte aufbewahren möchten.

        Wenn Sie das vorläufige Löschen deaktivieren möchten, z. B. wenn der Bucket hauptsächlich kurzlebige, temporäre Daten enthält, deaktivieren Sie das Kästchen Richtlinie für das vorläufige Löschen.

      • Um auszuwählen, wie Ihre Objektdaten verschlüsselt werden, klicken Sie auf den -Erweiterungspfeil mit dem Label Datenverschlüsselung und gehen Sie so vor:

  4. Klicken Sie auf Erstellen.

gcloud

  1. Erstellen Sie eine JSON-Datei, die folgende Informationen enthält:

    {
  "gmekEnforcement": {"restrictionMode": "STANDARD_ENCRYPTION_RESTRICTION_MODE"},
  "cmekEnforcement": {"restrictionMode": "CMEK_RESTRICTION_MODE"},
  "csekEnforcement": {"restrictionMode": "CSEK_RESTRICTION_MODE"}
}

    Ersetzen Sie Folgendes:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit Standardverschlüsselung (Google-Standardverschlüsselung) beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können die Standardverschlüsselung verwenden.
      • FullyRestricted: Neue Objekte können nicht mit der Standardverschlüsselung verschlüsselt werden.
    • CMEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit CMEKs beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können CMEKs verwenden.
      • FullyRestricted: Neue Objekte können keine CMEKs verwenden.
    • CSEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Für neue Objekte können vom Kunden bereitgestellte Verschlüsselungsschlüssel verwendet werden.
      • FullyRestricted: Für neue Objekte können keine vom Kunden bereitgestellten Verschlüsselungsschlüssel verwendet werden.

    Sie müssen mindestens einen Verschlüsselungstyp zulassen. Wenn Sie die Erzwingungskonfiguration für einen bestimmten Verschlüsselungstyp weglassen, ist dieser Verschlüsselungstyp standardmäßig zulässig.

  2. Führen Sie den Befehl gcloud storage buckets create mit dem Flag --encryption-enforcement-file aus.

    gcloud storage buckets create gs://BUCKET_NAME \
  --encryption-enforcement-file=ENCRYPTION_ENFORCEMENT_FILE

    Ersetzen Sie Folgendes:

    • BUCKET_NAME: der Name des Buckets.
    • ENCRYPTION_ENFORCEMENT_FILE: der Pfad zur JSON-Datei, die Sie im vorherigen Schritt erstellt haben.

Clientbibliotheken

C++

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& project_id,
   std::string const& bucket_name) {
  auto create_bucket = [&](std::string const& name,
                           gcs::BucketEncryption encryption) {
    StatusOr<gcs::BucketMetadata> bucket = client.CreateBucketForProject(
        name, project_id, gcs::BucketMetadata().set_encryption(encryption));
    if (!bucket) throw std::move(bucket).status();
    return bucket;
  };

  // Example 1: Enforce GMEK Only
  gcs::BucketEncryption gmek_encryption;
  gmek_encryption.google_managed_encryption_enforcement_config
      .restriction_mode = "NotRestricted";
  gmek_encryption.customer_managed_encryption_enforcement_config
      .restriction_mode = "FullyRestricted";
  gmek_encryption.customer_supplied_encryption_enforcement_config
      .restriction_mode = "FullyRestricted";
  std::cout << "Bucket "
            << create_bucket("g-" + bucket_name, gmek_encryption)->name()
            << " created with GMEK-only enforcement policy.\n";

  // In GCS, a single project cannot create or delete buckets more often than
  // once every two seconds. We pause to avoid rate limiting.
  std::this_thread::sleep_for(std::chrono::seconds(2));

  // Example 2: Enforce CMEK Only
  gcs::BucketEncryption cmek_encryption;
  cmek_encryption.google_managed_encryption_enforcement_config
      .restriction_mode = "FullyRestricted";
  cmek_encryption.customer_managed_encryption_enforcement_config
      .restriction_mode = "NotRestricted";
  cmek_encryption.customer_supplied_encryption_enforcement_config
      .restriction_mode = "FullyRestricted";
  std::cout << "Bucket "
            << create_bucket("c-" + bucket_name, cmek_encryption)->name()
            << " created with CMEK-only enforcement policy.\n";

  // In GCS, a single project cannot create or delete buckets more often than
  // once every two seconds. We pause to avoid rate limiting.
  std::this_thread::sleep_for(std::chrono::seconds(2));

  // Example 3: Restrict CSEK (Ransomware Protection)
  gcs::BucketEncryption csek_encryption;
  csek_encryption.customer_supplied_encryption_enforcement_config
      .restriction_mode = "FullyRestricted";
  std::cout << "Bucket "
            << create_bucket("rc-" + bucket_name, csek_encryption)->name()
            << " created with a policy to restrict CSEK.\n";
}

C#

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class BucketSetEncryptionEnforcementConfigSample
{
    /// <summary>
    /// Set the encryption enforcement configuration for a bucket.
    /// </summary>
    /// <param name="bucketName">The name of the bucket.</param>
    /// <param name="kmsKeyName">
    /// The full resource name of the Cloud KMS key (CMEK). 
    /// Required if <paramref name="enforceCmek"/> is true.
    /// </param>
    /// <param name="enforceCmek">If true, enforces Customer-Managed Encryption Key.</param>
    /// <param name="enforceGmek">If true, enforces Google-Managed Encryption Key.</param>
    /// <param name="enforceCsek">If true, enforces Customer-Supplied Encryption Key.</param>
    public Bucket.EncryptionData SetBucketEncryptionEnforcementConfig(
        string bucketName = "your-unique-bucket-name",
        string kmsKeyName = null,
        bool enforceCmek = false,
        bool enforceGmek = false,
        bool enforceCsek = false)
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);

        if (bucket.Encryption == null)
        {
            bucket.Encryption = new Bucket.EncryptionData();
        }

        if (!string.IsNullOrEmpty(kmsKeyName))
        {
            bucket.Encryption.DefaultKmsKeyName = kmsKeyName;
            Console.WriteLine($"Default Key Set: {kmsKeyName}");
        }
        else
        {
            bucket.Encryption.DefaultKmsKeyName = null;
            Console.WriteLine("Default Key Set: None");
        }

        string cmek = (enforceGmek || enforceCsek) ? "FullyRestricted" : "NotRestricted";
        string gmek = (enforceCmek || enforceCsek) ? "FullyRestricted" : "NotRestricted";
        string csek = (enforceCmek || enforceGmek) ? "FullyRestricted" : "NotRestricted";

        string message = enforceCmek ? "CMEK-only enforcement policy"
            : enforceGmek ? "GMEK-only enforcement policy"
            : enforceCsek ? "CSEK-only enforcement policy"
            : "no encryption enforcement policy";

        bucket.Encryption.CustomerManagedEncryptionEnforcementConfig = new Bucket.EncryptionData.CustomerManagedEncryptionEnforcementConfigData { RestrictionMode = cmek };
        bucket.Encryption.CustomerSuppliedEncryptionEnforcementConfig = new Bucket.EncryptionData.CustomerSuppliedEncryptionEnforcementConfigData { RestrictionMode = csek };
        bucket.Encryption.GoogleManagedEncryptionEnforcementConfig = new Bucket.EncryptionData.GoogleManagedEncryptionEnforcementConfigData { RestrictionMode = gmek };

        if (message != null)
        {
            Console.WriteLine($"Bucket {bucketName} updated with {message}");
        }

        var updatedBucket = storage.UpdateBucket(bucket);
        return updatedBucket.Encryption;
    }
}

Go

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// setBucketEncryptionEnforcementConfig sets a bucket's encryption enforcement configuration.
func setBucketEncryptionEnforcementConfig(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, &storage.BucketAttrs{
		GoogleManagedEncryptionEnforcementConfig: &storage.EncryptionEnforcementConfig{
			RestrictionMode: storage.FullyRestricted,
		},
		CustomerManagedEncryptionEnforcementConfig: &storage.EncryptionEnforcementConfig{
			RestrictionMode: storage.NotRestricted,
		},
		CustomerSuppliedEncryptionEnforcementConfig: &storage.EncryptionEnforcementConfig{
			RestrictionMode: storage.FullyRestricted,
		},
	}); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Bucket %v encryption enforcement policies set.\n", bucketName)
	return nil
}

Java

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.BucketInfo.CustomerManagedEncryptionEnforcementConfig;
import com.google.cloud.storage.BucketInfo.CustomerSuppliedEncryptionEnforcementConfig;
import com.google.cloud.storage.BucketInfo.EncryptionEnforcementRestrictionMode;
import com.google.cloud.storage.BucketInfo.GoogleManagedEncryptionEnforcementConfig;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class SetBucketEncryptionEnforcementConfig {
  public static void setBucketEncryptionEnforcementConfig(String projectId, String bucketName)
      throws Exception {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    try (Storage storage =
        StorageOptions.newBuilder().setProjectId(projectId).build().getService()) {

      // Example 1: Enforce GMEK Only
      setGmekEnforcedPolicy(storage, "g-" + bucketName);

      // Example 2: Enforce CMEK Only
      setCmekEnforcedPolicy(storage, "c-" + bucketName);

      // Example 3: Restrict CSEK (Ransomware Protection)
      restrictCsekPolicy(storage, "rc-" + bucketName);
    }
  }

  public static void setGmekEnforcedPolicy(Storage storage, String bucketName) {
    GoogleManagedEncryptionEnforcementConfig gmekConfig =
        GoogleManagedEncryptionEnforcementConfig.of(
            EncryptionEnforcementRestrictionMode.NOT_RESTRICTED);
    CustomerManagedEncryptionEnforcementConfig cmekConfig =
        CustomerManagedEncryptionEnforcementConfig.of(
            EncryptionEnforcementRestrictionMode.FULLY_RESTRICTED);
    CustomerSuppliedEncryptionEnforcementConfig csekConfig =
        CustomerSuppliedEncryptionEnforcementConfig.of(
            EncryptionEnforcementRestrictionMode.FULLY_RESTRICTED);

    BucketInfo bucketInfo =
        BucketInfo.newBuilder(bucketName)
            .setGoogleManagedEncryptionEnforcementConfig(gmekConfig)
            .setCustomerManagedEncryptionEnforcementConfig(cmekConfig)
            .setCustomerSuppliedEncryptionEnforcementConfig(csekConfig)
            .build();

    Bucket bucket = storage.create(bucketInfo);
    System.out.println(
        "Bucket " + bucket.getName() + " created with GMEK-only enforcement policy.");
  }

  public static void setCmekEnforcedPolicy(Storage storage, String bucketName) {
    GoogleManagedEncryptionEnforcementConfig gmekConfig =
        GoogleManagedEncryptionEnforcementConfig.of(
            EncryptionEnforcementRestrictionMode.FULLY_RESTRICTED);
    CustomerManagedEncryptionEnforcementConfig cmekConfig =
        CustomerManagedEncryptionEnforcementConfig.of(
            EncryptionEnforcementRestrictionMode.NOT_RESTRICTED);
    CustomerSuppliedEncryptionEnforcementConfig csekConfig =
        CustomerSuppliedEncryptionEnforcementConfig.of(
            EncryptionEnforcementRestrictionMode.FULLY_RESTRICTED);

    BucketInfo bucketInfo =
        BucketInfo.newBuilder(bucketName)
            .setGoogleManagedEncryptionEnforcementConfig(gmekConfig)
            .setCustomerManagedEncryptionEnforcementConfig(cmekConfig)
            .setCustomerSuppliedEncryptionEnforcementConfig(csekConfig)
            .build();

    Bucket bucket = storage.create(bucketInfo);
    System.out.println(
        "Bucket " + bucket.getName() + " created with CMEK-only enforcement policy.");
  }

  public static void restrictCsekPolicy(Storage storage, String bucketName) {
    CustomerSuppliedEncryptionEnforcementConfig csekConfig =
        CustomerSuppliedEncryptionEnforcementConfig.of(
            EncryptionEnforcementRestrictionMode.FULLY_RESTRICTED);

    BucketInfo bucketInfo =
        BucketInfo.newBuilder(bucketName)
            .setCustomerSuppliedEncryptionEnforcementConfig(csekConfig)
            .build();

    Bucket bucket = storage.create(bucketInfo);
    System.out.println("Bucket " + bucket.getName() + " created with a policy to restrict CSEK.");
  }
}

Node.js

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of the KMS key to be used as the default
// const defaultKmsKeyName = 'my-key';

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

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

async function setBucketEncryptionEnforcementConfig() {
  const options = {
    encryption: {
      defaultKmsKeyName,
      googleManagedEncryptionEnforcementConfig: {
        restrictionMode: 'FullyRestricted',
      },
      customerSuppliedEncryptionEnforcementConfig: {
        restrictionMode: 'FullyRestricted',
      },
      customerManagedEncryptionEnforcementConfig: {
        restrictionMode: 'NotRestricted',
      },
    },
  };

  const [metadata] = await storage.bucket(bucketName).setMetadata(options);

  console.log(
    `Encryption enforcement configuration updated for bucket ${bucketName}.`
  );
  const enc = metadata.encryption;
  if (enc) {
    console.log(`Default KMS Key: ${enc.defaultKmsKeyName}`);

    const logEnforcement = (label, config) => {
      if (config) {
        console.log(`${label}:`);
        console.log(`  Mode: ${config.restrictionMode}`);
        console.log(`  Effective: ${config.effectiveTime}`);
      }
    };

    logEnforcement(
      'Google Managed (GMEK) Enforcement',
      enc.googleManagedEncryptionEnforcementConfig
    );
    logEnforcement(
      'Customer Managed (CMEK) Enforcement',
      enc.customerManagedEncryptionEnforcementConfig
    );
    logEnforcement(
      'Customer Supplied (CSEK) Enforcement',
      enc.customerSuppliedEncryptionEnforcementConfig
    );
  }
}

setBucketEncryptionEnforcementConfig().catch(console.error);

PHP

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

use Google\Cloud\Storage\StorageClient;

/**
 * Creates a bucket with specific encryption enforcement (e.g., CMEK-only).
 *
 * @param string $bucketName The ID of your GCS bucket (e.g. "my-bucket").
 * @param string $kmsKeyName The name of the KMS key to be used as the default (e.g. "projects/my-project/...").
 */
function set_bucket_encryption_enforcement_config(string $bucketName, string $kmsKeyName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    // This configuration enforces that all objects uploaded to the bucket
    // must use Customer Managed Encryption Keys (CMEK).
    $options = [
        'encryption' => [
            'defaultKmsKeyName' => $kmsKeyName,
            'googleManagedEncryptionEnforcementConfig' => [
                'restrictionMode' => 'FullyRestricted',
            ],
            'customerSuppliedEncryptionEnforcementConfig' => [
                'restrictionMode' => 'FullyRestricted',
            ],
            'customerManagedEncryptionEnforcementConfig' => [
                'restrictionMode' => 'NotRestricted',
            ],
        ],
    ];
    $storage->createBucket($bucketName, $options);

    printf('Bucket %s created with encryption enforcement configuration.' . PHP_EOL, $bucketName);
}

Python

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

from google.cloud import storage
from google.cloud.storage.bucket import EncryptionEnforcementConfig


def set_bucket_encryption_enforcement_config(bucket_name):
    """Creates a bucket with encryption enforcement configuration."""
    # The ID of your GCS bucket
    # bucket_name = "your-unique-bucket-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    # Setting restriction_mode to "FullyRestricted" for Google-managed encryption (GMEK)
    # means objects cannot be created using the default Google-managed keys.
    bucket.encryption.google_managed_encryption_enforcement_config = (
        EncryptionEnforcementConfig(restriction_mode="FullyRestricted")
    )

    # Setting restriction_mode to "NotRestricted" for Customer-managed encryption (CMEK)
    # ensures that objects ARE permitted to be created using Cloud KMS keys.
    bucket.encryption.customer_managed_encryption_enforcement_config = (
        EncryptionEnforcementConfig(restriction_mode="NotRestricted")
    )

    # Setting restriction_mode to "FullyRestricted" for Customer-supplied encryption (CSEK)
    # prevents objects from being created using raw, client-side provided keys.
    bucket.encryption.customer_supplied_encryption_enforcement_config = (
        EncryptionEnforcementConfig(restriction_mode="FullyRestricted")
    )

    bucket.create()

    print(f"Created bucket {bucket.name} with Encryption Enforcement Config.")

Ruby

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

def set_bucket_encryption_enforcement_config bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new

  customer_managed_config = { restriction_mode: "NotRestricted" }
  customer_supplied_config = { restriction_mode: "FullyRestricted" }
  google_managed_config = { restriction_mode: "FullyRestricted" }

  bucket = storage.create_bucket bucket_name do |b|
    b.customer_managed_encryption_enforcement_config = customer_managed_config
    b.customer_supplied_encryption_enforcement_config = customer_supplied_config
    b.google_managed_encryption_enforcement_config = google_managed_config
  end
  puts "Created bucket #{bucket.name} with Encryption Enforcement Config."
end

REST APIs

JSON-API

  1. Installieren und initialisieren Sie die gcloud CLI, um ein Zugriffstoken für den Authorization-Header zu generieren.

  2. Erstellen Sie eine JSON-Datei mit den Einstellungen für den Bucket. Eine vollständige Liste der Einstellungen finden Sie in der Dokumentation zu Buckets: Insert. Mit den folgenden Einstellungen werden nur der Bucket-Name und die Verschlüsselung definiert:

    {
  "name": "BUCKET_NAME",
  "encryption": {
    "googleManagedEncryptionEnforcementConfig": {
      "restrictionMode": "STANDARD_ENCRYPTION_RESTRICTION_MODE"
    },
    "customerManagedEncryptionEnforcementConfig": {
      "restrictionMode": "CMEK_RESTRICTION_MODE"
    },
    "customerSuppliedEncryptionEnforcementConfig": {
      "restrictionMode": "CSEK_RESTRICTION_MODE"
    }
  }
}

    Ersetzen Sie Folgendes:

    • BUCKET_NAME: Der Name des Buckets.
    • STANDARD_ENCRYPTION_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit Standardverschlüsselung (Google-Standardverschlüsselung) beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können die Standardverschlüsselung verwenden.
      • FullyRestricted: Neue Objekte können nicht mit der Standardverschlüsselung verschlüsselt werden.
    • CMEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit CMEKs beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können CMEKs verwenden.
      • FullyRestricted: Neue Objekte können keine CMEKs verwenden.
    • CSEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Für neue Objekte können vom Kunden bereitgestellte Verschlüsselungsschlüssel verwendet werden.
      • FullyRestricted: Für neue Objekte können keine vom Kunden bereitgestellten Verschlüsselungsschlüssel verwendet werden.

    Sie müssen mindestens einen Verschlüsselungstyp zulassen. Wenn Sie die Erzwingungskonfiguration für einen bestimmten Verschlüsselungstyp weglassen, ist dieser Verschlüsselungstyp standardmäßig zulässig.

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

    curl -X POST --data-binary @JSON_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b?project=PROJECT_ID"

    Ersetzen Sie Folgendes:

    • JSON_FILE_NAME: der Pfad zur JSON-Datei, die Sie im vorherigen Schritt erstellt haben.
    • PROJECT_ID: die ID oder Nummer des Projekts für Ihren Bucket.

XML API

  1. Installieren und initialisieren Sie die gcloud CLI, um ein Zugriffstoken für den Authorization-Header zu generieren.

  2. Erstellen Sie eine XML-Datei, die die Einstellungen für den Bucket enthält. Eine vollständige Liste der Einstellungen finden Sie in der Dokumentation XML: Bucket erstellen. Die folgenden Einstellungen definieren nur die Erzwingung der Verschlüsselung:

    <CreateBucketConfiguration>
  <EncryptionConfiguration>
    <GoogleManagedEncryptionEnforcement>
      <RestrictionMode>STANDARD_ENCRYPTION_RESTRICTION_MODE</RestrictionMode>
    </GoogleManagedEncryptionEnforcement>
    <CustomerManagedEncryptionEnforcement>
      <RestrictionMode>CMEK_RESTRICTION_MODE</RestrictionMode>
    </CustomerManagedEncryptionEnforcement>
    <CustomerSuppliedEncryptionEnforcement>
      <RestrictionMode>CSEK_RESTRICTION_MODE</RestrictionMode>
    </CustomerSuppliedEncryptionEnforcement>
  </EncryptionConfiguration>
</CreateBucketConfiguration>

    Ersetzen Sie Folgendes:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit Standardverschlüsselung (Google-Standardverschlüsselung) beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können die Standardverschlüsselung verwenden.
      • FullyRestricted: Neue Objekte können nicht mit der Standardverschlüsselung verschlüsselt werden.
    • CMEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit CMEKs beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können CMEKs verwenden.
      • FullyRestricted: Neue Objekte können keine CMEKs verwenden.
    • CSEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Für neue Objekte können vom Kunden bereitgestellte Verschlüsselungsschlüssel verwendet werden.
      • FullyRestricted: Für neue Objekte können keine vom Kunden bereitgestellten Verschlüsselungsschlüssel verwendet werden.

    Sie müssen mindestens einen Verschlüsselungstyp zulassen. Wenn Sie die Erzwingungskonfiguration für einen bestimmten Verschlüsselungstyp weglassen, ist dieser Verschlüsselungstyp standardmäßig zulässig.

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

    curl -X PUT --data-binary @XML_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "x-goog-project-id: PROJECT_ID" \
  "https://storage.googleapis.com/BUCKET_NAME"

    Ersetzen Sie Folgendes:

    • XML_FILE_NAME: der Pfad zur XML-Datei, die Sie im vorherigen Schritt erstellt haben.
    • PROJECT_ID: die ID oder Nummer des Projekts für Ihren Bucket.
    • BUCKET_NAME: der Name des Buckets.

Zulässige Verschlüsselungstypen für einen Bucket aktualisieren

So aktualisieren Sie die zulässigen Verschlüsselungsmethoden für neue Objekte in einem vorhandenen Bucket:

Wenn für den Bucket ein KMS-Standardschlüssel festgelegt ist, können Sie sowohl CMEK als auch vom Kunden bereitgestellte Verschlüsselungsschlüssel nicht einschränken, da dies die Erstellung neuer Objekte verhindern würde. Lassen Sie entweder CMEK oder CSEK für einen solchen Bucket zu oder entfernen Sie den Cloud KMS-Standardschlüssel aus dem Bucket.

Console

  1. Wechseln Sie in der Google Cloud Console unter „Cloud Storage“ zur Seite Buckets.

    Buckets aufrufen

  2. Klicken Sie in der Bucket-Liste auf den Namen des Buckets.

  3. Klicken Sie auf den Tab Konfiguration.

  4. Klicken Sie im Bereich Schutz auf  Verschlüsselung bearbeiten.

  5. Wählen Sie im Abschnitt Regeln für die Verschlüsselungserzwingung für Schlüsseltypen aus, welche Verschlüsselungstypen für neue Objekte im Bucket zulässig oder eingeschränkt sein sollen.

  6. Klicken Sie auf Speichern.

gcloud

  1. Erstellen Sie eine JSON-Datei, die folgende Informationen enthält:

    {
  "gmekEnforcement": {"restrictionMode": "STANDARD_ENCRYPTION_RESTRICTION_MODE"},
  "cmekEnforcement": {"restrictionMode": "CMEK_RESTRICTION_MODE"},
  "csekEnforcement": {"restrictionMode": "CSEK_RESTRICTION_MODE"}
}

    Ersetzen Sie Folgendes:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit Standardverschlüsselung (Google-Standardverschlüsselung) beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können die Standardverschlüsselung verwenden.
      • FullyRestricted: Neue Objekte können nicht mit der Standardverschlüsselung verschlüsselt werden.
    • CMEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit CMEKs beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können CMEKs verwenden.
      • FullyRestricted: Neue Objekte können keine CMEKs verwenden.
    • CSEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Für neue Objekte können vom Kunden bereitgestellte Verschlüsselungsschlüssel verwendet werden.
      • FullyRestricted: Für neue Objekte können keine vom Kunden bereitgestellten Verschlüsselungsschlüssel verwendet werden.

    Sie müssen mindestens einen Verschlüsselungstyp zulassen. Wenn Sie keinen Verschlüsselungstyp angeben, wird die vorhandene Konfiguration beibehalten.

  2. Führen Sie den Befehl gcloud storage buckets update mit dem Flag --encryption-enforcement-file aus.

    gcloud storage buckets update gs://BUCKET_NAME \
  --encryption-enforcement-file=ENCRYPTION_ENFORCEMENT_FILE

    Ersetzen Sie Folgendes:

    • BUCKET_NAME: der Name des Buckets.
    • ENCRYPTION_ENFORCEMENT_FILE: der Pfad zur JSON-Datei, die Sie im vorherigen Schritt erstellt haben.

    Es kann bis zu zwei Minuten dauern, bis die aktualisierte Konfiguration wirksam wird.

Clientbibliotheken

C++

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<gcs::BucketMetadata> original =
      client.GetBucketMetadata(bucket_name);

  gcs::BucketMetadata updated_metadata = *original;
  gcs::BucketEncryption encryption;
  if (original->has_encryption()) {
    encryption = original->encryption();
  }

  // 1. Update a specific type (e.g., change GMEK to FullyRestricted)
  encryption.google_managed_encryption_enforcement_config.restriction_mode =
      "FullyRestricted";
  // 2. Remove a specific type (e.g., remove CMEK enforcement)
  encryption.customer_managed_encryption_enforcement_config.restriction_mode =
      "NotRestricted";
  // For the update, need to specify all three configs, so keeping this same
  // as before
  encryption.customer_supplied_encryption_enforcement_config
      .restriction_mode = "FullyRestricted";

  updated_metadata.set_encryption(encryption);

  StatusOr<gcs::BucketMetadata> updated =
      client.PatchBucket(bucket_name, *original, updated_metadata);
  if (!updated) throw std::move(updated).status();

  std::cout << "Encryption enforcement policy updated for bucket "
            << updated->name() << "\n"
            << "GMEK is now fully restricted, and CMEK enforcement has been "
               "removed.\n";
}

C#

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class BucketUpdateEncryptionEnforcementConfigSample
{
    /// <summary>
    /// Updates the encryption enforcement configuration of the bucket.
    /// </summary>
    /// <param name="bucketName">The name of the bucket.</param>
    /// <param name="encryptionData">The encryption configuration for the bucket.</param>
    public Bucket.EncryptionData BucketUpdateEncryptionEnforcementConfig(string bucketName = "your-unique-bucket-name", Bucket.EncryptionData encryptionData = null)
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);

        if (bucket.Encryption is null
            || (bucket.Encryption.CustomerManagedEncryptionEnforcementConfig is null
                && bucket.Encryption.CustomerSuppliedEncryptionEnforcementConfig is null
                && bucket.Encryption.GoogleManagedEncryptionEnforcementConfig is null))
        {
            Console.WriteLine($"No Encryption Enforcement Configuration found for bucket {bucketName}");
            return bucket.Encryption;
        }

        bucket.Encryption = encryptionData;
        bucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"The Encryption Enforcement Configuration has been updated for the bucket {bucketName}");
        return bucket.Encryption;
    }
}

Go

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// updateBucketEncryptionEnforcementConfig updates a bucket's encryption enforcement configuration.
func updateBucketEncryptionEnforcementConfig(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	bucket := client.Bucket(bucketName)
	if _, err := bucket.Update(ctx, storage.BucketAttrsToUpdate{
		GoogleManagedEncryptionEnforcementConfig: &storage.EncryptionEnforcementConfig{
			RestrictionMode: storage.NotRestricted,
		},
		CustomerManagedEncryptionEnforcementConfig: &storage.EncryptionEnforcementConfig{
			RestrictionMode: storage.FullyRestricted,
		},
		CustomerSuppliedEncryptionEnforcementConfig: &storage.EncryptionEnforcementConfig{
			RestrictionMode: storage.FullyRestricted,
		},
	}); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Bucket %v encryption enforcement policies updated.\n", bucketName)
	return nil
}

Java

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo.CustomerManagedEncryptionEnforcementConfig;
import com.google.cloud.storage.BucketInfo.CustomerSuppliedEncryptionEnforcementConfig;
import com.google.cloud.storage.BucketInfo.EncryptionEnforcementRestrictionMode;
import com.google.cloud.storage.BucketInfo.GoogleManagedEncryptionEnforcementConfig;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class UpdateBucketEncryptionEnforcementConfig {
  public static void updateBucketEncryptionEnforcementConfig(String projectId, String bucketName)
      throws Exception {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket with CMEK and CSEK restricted
    // String bucketName = "your-unique-bucket-name";

    try (Storage storage =
        StorageOptions.newBuilder().setProjectId(projectId).build().getService()) {

      Bucket bucket = storage.get(bucketName);
      if (bucket == null) {
        System.out.println("Bucket " + bucketName + " not found.");
        return;
      }

      // 1. Update a specific type (e.g., change GMEK to FULLY_RESTRICTED)
      GoogleManagedEncryptionEnforcementConfig newGmekConfig =
          GoogleManagedEncryptionEnforcementConfig.of(
              EncryptionEnforcementRestrictionMode.FULLY_RESTRICTED);

      // 2. Remove a specific type (e.g., remove CMEK enforcement)
      CustomerManagedEncryptionEnforcementConfig newCmekConfig =
          CustomerManagedEncryptionEnforcementConfig.of(
              EncryptionEnforcementRestrictionMode.NOT_RESTRICTED);

      // For the update, need to specify all three configs, so keeping this same as before
      CustomerSuppliedEncryptionEnforcementConfig sameCsekConfig =
          CustomerSuppliedEncryptionEnforcementConfig.of(
              EncryptionEnforcementRestrictionMode.FULLY_RESTRICTED);

      bucket.toBuilder()
          .setGoogleManagedEncryptionEnforcementConfig(newGmekConfig)
          .setCustomerManagedEncryptionEnforcementConfig(newCmekConfig)
          .setCustomerSuppliedEncryptionEnforcementConfig(sameCsekConfig)
          .build()
          .update();

      System.out.println("Encryption enforcement policy updated for bucket " + bucketName);
      System.out.println("GMEK is now fully restricted, and CMEK enforcement has been removed.");
    }
  }
}

Node.js

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

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

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

async function updateBucketEncryptionEnforcementConfig() {
  const bucket = storage.bucket(bucketName);

  // Update a specific encryption type's restriction mode
  // This partial update preserves other existing encryption settings.
  const updateOptions = {
    encryption: {
      googleManagedEncryptionEnforcementConfig: {
        restrictionMode: 'FullyRestricted',
      },
    },
  };

  await bucket.setMetadata(updateOptions);
  console.log(
    `Google-managed encryption enforcement set to FullyRestricted for ${bucketName}.`
  );

  // Remove all encryption enforcement configurations altogether
  // Setting these values to null removes the policies from the bucket metadata.
  const clearOptions = {
    encryption: {
      defaultKmsKeyName: null,
      googleManagedEncryptionEnforcementConfig: null,
      customerSuppliedEncryptionEnforcementConfig: null,
      customerManagedEncryptionEnforcementConfig: null,
    },
  };

  await bucket.setMetadata(clearOptions);
  console.log(
    `All encryption enforcement configurations removed from bucket ${bucketName}.`
  );
}

updateBucketEncryptionEnforcementConfig().catch(console.error);

PHP

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

use Google\Cloud\Storage\StorageClient;

/**
 * Updates or removes encryption enforcement configurations from a bucket.
 *
 * @param string $bucketName The ID of your GCS bucket (e.g. "my-bucket").
 */
function update_bucket_encryption_enforcement_config(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    // Update a specific encryption type's restriction mode
    // This partial update preserves other existing encryption settings.
    $updateOptions = [
        'encryption' => [
            'googleManagedEncryptionEnforcementConfig' => [
                'restrictionMode' => 'FullyRestricted'
            ]
        ]
    ];
    $bucket->update($updateOptions);
    printf('Google-managed encryption enforcement set to FullyRestricted for %s.' . PHP_EOL, $bucketName);

    // Remove all encryption enforcement configurations altogether
    // Setting these values to null removes the policies from the bucket metadata.
    $clearOptions = [
        'encryption' => [
            'defaultKmsKeyName' => null,
            'googleManagedEncryptionEnforcementConfig' => null,
            'customerSuppliedEncryptionEnforcementConfig' => null,
            'customerManagedEncryptionEnforcementConfig' => null,
        ],
    ];

    $bucket->update($clearOptions);
    printf('All encryption enforcement configurations removed from bucket %s.' . PHP_EOL, $bucketName);
}

Python

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

from google.cloud import storage
from google.cloud.storage.bucket import EncryptionEnforcementConfig


def update_bucket_encryption_enforcement_config(bucket_name):
    """Updates the encryption enforcement policy for a bucket."""
    # The ID of your GCS bucket with GMEK and CSEK restricted
    # bucket_name = "your-unique-bucket-name"

    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)

    # Update a specific type (e.g., change GMEK to NotRestricted)
    bucket.encryption.google_managed_encryption_enforcement_config = (
        EncryptionEnforcementConfig(restriction_mode="NotRestricted")
    )

    # Update another type (e.g., change CMEK to FullyRestricted)
    bucket.encryption.customer_managed_encryption_enforcement_config = (
        EncryptionEnforcementConfig(restriction_mode="FullyRestricted")
    )

    # Keeping CSEK unchanged
    bucket.encryption.customer_supplied_encryption_enforcement_config = (
        EncryptionEnforcementConfig(restriction_mode="FullyRestricted")
    )

    bucket.patch()

    print(f"Encryption enforcement policy updated for bucket {bucket.name}.")

    gmek = bucket.encryption.google_managed_encryption_enforcement_config
    cmek = bucket.encryption.customer_managed_encryption_enforcement_config
    csek = bucket.encryption.customer_supplied_encryption_enforcement_config

    print(f"GMEK restriction mode: {gmek.restriction_mode if gmek else 'None'}")
    print(f"CMEK restriction mode: {cmek.restriction_mode if cmek else 'None'}")
    print(f"CSEK restriction mode: {csek.restriction_mode if csek else 'None'}")

Ruby

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

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Storage zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


def update_bucket_encryption_enforcement_config bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name
  # Update a specific type (e.g., change GMEK to NotRestricted)
  new_config =  { restriction_mode: "NotRestricted" }

  bucket.update do |b|
    b.google_managed_encryption_enforcement_config = new_config
  end
  puts "Updated google_managed_config to " \
       "#{bucket.google_managed_encryption_enforcement_config.restriction_mode} " \
       "for bucket #{bucket.name}."
end

REST APIs

JSON-API

  1. Installieren und initialisieren Sie die gcloud CLI, um ein Zugriffstoken für den Authorization-Header zu generieren.

  2. Erstellen Sie eine JSON-Datei, die folgende Informationen enthält:

    {
  "encryption": {
    "googleManagedEncryptionEnforcementConfig": {
      "restrictionMode": "STANDARD_ENCRYPTION_RESTRICTION_MODE"
    },
    "customerManagedEncryptionEnforcementConfig": {
      "restrictionMode": "CMEK_RESTRICTION_MODE"
    },
    "customerSuppliedEncryptionEnforcementConfig": {
      "restrictionMode": "CSEK_RESTRICTION_MODE"
    }
  }
}

    Ersetzen Sie Folgendes:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit Standardverschlüsselung (Google-Standardverschlüsselung) beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können die Standardverschlüsselung verwenden.
      • FullyRestricted: Neue Objekte können nicht mit der Standardverschlüsselung verschlüsselt werden.
    • CMEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit CMEKs beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können CMEKs verwenden.
      • FullyRestricted: Neue Objekte können keine CMEKs verwenden.
    • CSEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Für neue Objekte können vom Kunden bereitgestellte Verschlüsselungsschlüssel verwendet werden.
      • FullyRestricted: Für neue Objekte können keine vom Kunden bereitgestellten Verschlüsselungsschlüssel verwendet werden.

    Sie müssen mindestens einen Verschlüsselungstyp zulassen. Wenn Sie keinen Verschlüsselungstyp angeben, wird die vorhandene Konfiguration beibehalten.

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

    curl -X PATCH --data-binary @JSON_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?fields=encryption"

    Ersetzen Sie Folgendes:

    • JSON_FILE_NAME: der Pfad zur JSON-Datei, die Sie im vorherigen Schritt erstellt haben.
    • BUCKET_NAME: der Name des Buckets.

    Es kann bis zu zwei Minuten dauern, bis die aktualisierte Konfiguration wirksam wird.

XML API

  1. Installieren und initialisieren Sie die gcloud CLI, um ein Zugriffstoken für den Authorization-Header zu generieren.

  2. Erstellen Sie eine XML-Datei, die die Verschlüsselungseinstellungen für den Bucket enthält. Die folgenden Einstellungen definieren nur die Konfiguration für die Erzwingung der Verschlüsselung.

     
    <EncryptionConfiguration>
  <GoogleManagedEncryptionEnforcement>
    <RestrictionMode>STANDARD_ENCRYPTION_RESTRICTION_MODE</RestrictionMode>
  </GoogleManagedEncryptionEnforcement>
  <CustomerManagedEncryptionEnforcement>
    <RestrictionMode>CMEK_RESTRICTION_MODE</RestrictionMode>
  </CustomerManagedEncryptionEnforcement>
  <CustomerSuppliedEncryptionEnforcement>
    <RestrictionMode>CSEK_RESTRICTION_MODE</RestrictionMode>
  </CustomerSuppliedEncryptionEnforcement>
</EncryptionConfiguration>

    Ersetzen Sie Folgendes:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit Standardverschlüsselung (Google-Standardverschlüsselung) beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können die Standardverschlüsselung verwenden.
      • FullyRestricted: Neue Objekte können nicht mit der Standardverschlüsselung verschlüsselt werden.
    • CMEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit CMEKs beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Neue Objekte können CMEKs verwenden.
      • FullyRestricted: Neue Objekte können keine CMEKs verwenden.
    • CSEK_RESTRICTION_MODE: Gibt an, ob die Verschlüsselung mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln beim Erstellen von Objekten in diesem Bucket zulässig ist. Folgende Werte werden unterstützt:
      • NotRestricted: Für neue Objekte können vom Kunden bereitgestellte Verschlüsselungsschlüssel verwendet werden.
      • FullyRestricted: Für neue Objekte können keine vom Kunden bereitgestellten Verschlüsselungsschlüssel verwendet werden.

    Sie müssen mindestens einen Verschlüsselungstyp zulassen.

  3. Verwenden Sie cURL, um die XML API mit einer PUT-Bucket-Anfrage aufzurufen, die auf ?encryptionConfig beschränkt ist:

    curl -X PUT --data-binary @XML_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/BUCKET_NAME?encryptionConfig"

    Ersetzen Sie Folgendes:

    • XML_FILE_NAME: der Pfad zur XML-Datei, die Sie im vorherigen Schritt erstellt haben.
    • BUCKET_NAME: der Name des Buckets.

    Es kann bis zu zwei Minuten dauern, bis die aktualisierte Konfiguration wirksam wird.

Verschlüsselungseinstellungen für einen Bucket ansehen

Eine Anleitung dazu, wie Sie herausfinden, welche Verschlüsselungsmethoden für einen Bucket zulässig sind, finden Sie unter Bucket-Metadaten abrufen.

Nächste Schritte