Applica o limita i tipi di crittografia per un bucket

Questo documento descrive come configurare i metodi di crittografia consentiti o limitati per i nuovi oggetti in un bucket Cloud Storage. Puoi configurare un bucket in modo da applicare o limitare l'utilizzo della crittografia standard (crittografia predefinita di Google), delle chiavi di crittografia gestite dal cliente (CMEK) o delle chiavi di crittografia fornite dal cliente (CSEK) per tutti i nuovi oggetti creati all'interno del bucket.

Ad esempio, per soddisfare i requisiti di conformità relativi alla gestione delle chiavi di crittografia, puoi richiedere che tutti i nuovi oggetti siano criptati con la crittografia standard o con CMEK e limitare l'utilizzo delle chiavi di crittografia fornite dal cliente.

Per saperne di più sui metodi di crittografia disponibili, consulta Opzioni di crittografia dei dati.

Cloud Storage applica la configurazione di crittografia per tutte le azioni che creano un nuovo oggetto, ad esempio il caricamento di un oggetto, la copia di un oggetto, la composizione di oggetti e il ripristino di un oggetto eliminato temporaneamente.

Prima di iniziare

Per ottenere le autorizzazioni necessarie per configurare l'applicazione della crittografia per un bucket, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) sul bucket. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per configurare l'applicazione della crittografia per un bucket. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per configurare l'applicazione della crittografia per un bucket sono necessarie le seguenti autorizzazioni:

• Imposta la configurazione durante la creazione di un nuovo bucket: storage.buckets.create
• Aggiorna la configurazione di un bucket esistente: storage.buckets.update
• Se utilizzi la console Google Cloud per eseguire i passaggi descritti in questa pagina:
  • storage.buckets.get
  • storage.buckets.list

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Crea un bucket che applica i tipi di crittografia

Puoi specificare i metodi di crittografia consentiti o limitati per gli oggetti in un bucket quando crei un nuovo bucket.

Se imposti una chiave Cloud KMS predefinita per il bucket, devi anche consentire la crittografia utilizzando CMEK o chiavi di crittografia fornite dal cliente.

Console

1. Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Fai clic su Crea.

3. Nella pagina Crea un bucket, inserisci le informazioni del bucket. Dopo ciascuno dei seguenti passaggi, fai clic su Continua per procedere con il passaggio successivo:

   1. Nella sezione Inizia, segui questi passaggi:

      • Inserisci un nome globalmente univoco che soddisfi i requisiti per i nomi dei bucket.

      • Per aggiungere un'etichetta del bucket, fai clic sulla freccia di espansione per espandere la sezione Etichette, fai clic su Aggiungi etichetta e specifica un key e un value per l'etichetta.

   2. Nella sezione Scegli dove archiviare i tuoi dati, segui questi passaggi:

      1. Seleziona un Tipo di località.

      2. Utilizza il menu a discesa del tipo di località per selezionare una località in cui verranno archiviati in modo permanente i dati degli oggetti all'interno del bucket.

         • Se selezioni il tipo di località a due regioni, puoi anche scegliere di attivare la replica turbo utilizzando la casella di controllo pertinente.

      3. Per configurare la replica tra bucket, seleziona Aggiungi una replica tra bucket mediante Storage Transfer Service e segui i passaggi:

         Configura la replica tra bucket

         1. Nel menu Bucket, seleziona un bucket.

         2. Nella sezione Impostazioni di replica, fai clic su Configura per configurare le impostazioni per il job di replica.

            Viene visualizzato il riquadro Configura replica tra bucket.

            • Per filtrare gli oggetti da replicare in base al prefisso del nome dell'oggetto, inserisci un prefisso con cui includere o escludere gli oggetti, quindi fai clic su Aggiungi un prefisso.
            • Per impostare una classe di archiviazione per gli oggetti replicati, seleziona una classe di archiviazione dal menu Classe di archiviazione. Se salti questo passaggio, gli oggetti replicati utilizzeranno per impostazione predefinita la classe di archiviazione del bucket di destinazione.
            • Fai clic su Fine.

   3. Nella sezione Scegli come archiviare i tuoi dati, segui questi passaggi:

      1. Seleziona una classe di archiviazione predefinita per il bucket o Autoclass per la gestione automatica della classe di archiviazione dei dati del bucket.

      2. Nella sezione Ottimizza l'archiviazione per workload con uso intensivo dei dati, segui questi passaggi:

         • Per abilitare lo spazio dei nomi gerarchico, seleziona Abilita uno spazio dei nomi gerarchico in questo bucket.

           Nota:lo spazio dei nomi gerarchico può essere abilitato solo durante la creazione del bucket. Non puoi modificare questa impostazione dopo aver creato il bucket.

         • Per attivare Rapid Cache, seleziona Attiva Rapid Cache e segui i passaggi:

           1. Per creare le cache, fai clic su Configura.

           2. Nella finestra di dialogo Configura impostazioni cache visualizzata, fai clic sulla freccia menu a discesa accanto alle regioni elencate e seleziona le zone in cui vuoi creare le cache.

           3. Fai clic su Fine.

           Nota: sono necessarie autorizzazioni aggiuntive per attivare Rapid Cache.

   4. Nella sezione Scegli come controllare l'accesso agli oggetti, segui questi passaggi:

      1. Seleziona se il bucket applica la prevenzione dell'accesso pubblico.

         Nota: se la prevenzione dell'accesso pubblico è già applicata dalla policy dell'organizzazione del progetto, la casella di controllo Impedisci accesso pubblico è bloccata.

      2. Seleziona Uniforme per abilitare l'accesso uniforme a livello di bucket nel bucket.

      3. Facoltativamente, configura il filtro IP per il bucket.

   5. Nella sezione Scegli come proteggere i dati degli oggetti, segui questi passaggi:

      • Seleziona una delle opzioni in Protezione dei dati che vuoi impostare per il bucket.

      • Per modificare il periodo di tempo per cui l'eliminazione temporanea conserva gli oggetti dopo l'eliminazione, seleziona la casella di controllo Policy di eliminazione temporanea, quindi seleziona l'opzione Imposta durata di conservazione personalizzata. Quindi, specifica per quanto tempo vuoi conservare gli oggetti eliminati.

        Per disattivare l'eliminazione temporanea, ad esempio se il bucket conterrà principalmente dati temporanei di breve durata, deseleziona la casella di controllo politica di cancellazione temporanea.

      • Per scegliere come criptare i dati degli oggetti, fai clic sulla freccia di espansione con l'etichetta Criptazione dei dati e segui questi passaggi:

        • Nella sezione Tipo di chiave di crittografia predefinito, seleziona la chiave di crittografia predefinita per il bucket. Se selezioni Chiave Cloud KMS, fornisci una chiave Cloud Key Management Service.
        • Nella sezione Regole di applicazione della crittografia, per Tipi di chiavi, seleziona quali tipi di crittografia consentire o limitare per i nuovi oggetti nel bucket.

4. Fai clic su Crea.

gcloud

1. Crea un file JSON che contenga le seguenti informazioni:

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

   Sostituisci quanto segue:

   • STANDARD_ENCRYPTION_RESTRICTION_MODE: indica se è consentita la crittografia standard (crittografia predefinita di Google) quando si creano oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare la crittografia standard.
     • FullyRestricted: i nuovi oggetti non possono utilizzare la crittografia standard.
   • CMEK_RESTRICTION_MODE: indica se la crittografia con CMEK è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare le CMEK.
     • FullyRestricted: i nuovi oggetti non possono utilizzare CMEK.
   • CSEK_RESTRICTION_MODE: indica se la crittografia con chiavi di crittografia fornite dal cliente è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare chiavi di crittografia fornite dal cliente.
     • FullyRestricted: i nuovi oggetti non possono utilizzare chiavi di crittografia fornite dal cliente.

   Devi consentire almeno un tipo di crittografia. Se ometti la configurazione dell'applicazione forzata per un tipo di crittografia specifico, questo tipo di crittografia è consentito per impostazione predefinita.

2. Utilizza il comando gcloud storage buckets create con il flag --encryption-enforcement-file:

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

   Sostituisci quanto segue:

   • BUCKET_NAME: il nome del bucket.
   • ENCRYPTION_ENFORCEMENT_FILE: il percorso del file JSON creato nel passaggio precedente.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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#

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C#.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Go.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

/**
 * 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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

API REST

API JSON

1. Avere gcloud CLI installato e inizializzato, che ti consente di generare un token di accesso per l'intestazione Authorization.

2. Crea un file JSON contenente le impostazioni del bucket. Per un elenco completo delle impostazioni, consulta la documentazione Bucket: inserisci. Le seguenti impostazioni definiscono solo il nome del bucket e la crittografia:

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

   Sostituisci quanto segue:

   • BUCKET_NAME: il nome del bucket.
   • STANDARD_ENCRYPTION_RESTRICTION_MODE: indica se è consentita la crittografia standard (crittografia predefinita di Google) quando si creano oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare la crittografia standard.
     • FullyRestricted: i nuovi oggetti non possono utilizzare la crittografia standard.
   • CMEK_RESTRICTION_MODE: indica se la crittografia con CMEK è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare le CMEK.
     • FullyRestricted: i nuovi oggetti non possono utilizzare CMEK.
   • CSEK_RESTRICTION_MODE: indica se la crittografia con chiavi di crittografia fornite dal cliente è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare chiavi di crittografia fornite dal cliente.
     • FullyRestricted: i nuovi oggetti non possono utilizzare chiavi di crittografia fornite dal cliente.

   Devi consentire almeno un tipo di crittografia. Se ometti la configurazione dell'applicazione forzata per un tipo di crittografia specifico, questo tipo di crittografia è consentito per impostazione predefinita.

3. Utilizza cURL per chiamare l'API JSON con una richiesta POST Bucket:

   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"

   Sostituisci quanto segue:

   • JSON_FILE_NAME: il percorso del file JSON creato nel passaggio precedente.
   • PROJECT_ID: l'ID o il numero del progetto per il tuo bucket.

API XML

1. Avere gcloud CLI installato e inizializzato, che ti consente di generare un token di accesso per l'intestazione Authorization.

2. Crea un file XML contenente le impostazioni per il bucket. Per un elenco completo delle impostazioni, consulta la documentazione XML: crea un bucket. Le seguenti impostazioni definiscono solo l'applicazione della crittografia:

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

   Sostituisci quanto segue:

   • STANDARD_ENCRYPTION_RESTRICTION_MODE: indica se è consentita la crittografia standard (crittografia predefinita di Google) quando si creano oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare la crittografia standard.
     • FullyRestricted: i nuovi oggetti non possono utilizzare la crittografia standard.
   • CMEK_RESTRICTION_MODE: indica se la crittografia con CMEK è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare le CMEK.
     • FullyRestricted: i nuovi oggetti non possono utilizzare CMEK.
   • CSEK_RESTRICTION_MODE: indica se la crittografia con chiavi di crittografia fornite dal cliente è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare chiavi di crittografia fornite dal cliente.
     • FullyRestricted: i nuovi oggetti non possono utilizzare chiavi di crittografia fornite dal cliente.

   Devi consentire almeno un tipo di crittografia. Se ometti la configurazione dell'applicazione forzata per un tipo di crittografia specifico, questo tipo di crittografia è consentito per impostazione predefinita.

3. Utilizza cURL per chiamare l'API XML con una richiesta PUT Bucket:

   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"

   Sostituisci quanto segue:

   • XML_FILE_NAME: il percorso del file XML creato nel passaggio precedente.
   • PROJECT_ID: l'ID o il numero del progetto per il tuo bucket.
   • BUCKET_NAME: il nome del bucket.

Aggiorna i tipi di crittografia consentiti per un bucket

Per aggiornare i metodi di crittografia consentiti per i nuovi oggetti in un bucket esistente, completa i seguenti passaggi.

Attenzione: l'aggiornamento della configurazione di applicazione della crittografia di un bucket non influisce sul tipo di crittografia degli oggetti già presenti nel bucket.

Se per il bucket è impostata una chiave KMS predefinita, non puoi limitare sia le CMEK sia le chiavi di crittografia fornite dal cliente, perché ciò impedirebbe la creazione di nuovi oggetti. Consenti CMEK o CSEK su un bucket di questo tipo o rimuovi la chiave Cloud KMS predefinita dal bucket.

Console

1. Nella console Google Cloud , vai alla pagina Bucket in Cloud Storage.
   

   Vai a Bucket

2. Nell'elenco dei bucket, fai clic sul nome del bucket.

3. Fai clic sulla scheda Configuration (Configurazione).

4. Nella sezione Protezione, fai clic su  Modifica crittografia.

5. Nella sezione Regole di applicazione della crittografia, per Tipi di chiavi, seleziona i tipi di crittografia da consentire o limitare per i nuovi oggetti nel bucket.

6. Fai clic su Salva.

gcloud

1. Crea un file JSON che contenga le seguenti informazioni:

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

   Sostituisci quanto segue:

   • STANDARD_ENCRYPTION_RESTRICTION_MODE: indica se è consentita la crittografia standard (crittografia predefinita di Google) quando si creano oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare la crittografia standard.
     • FullyRestricted: i nuovi oggetti non possono utilizzare la crittografia standard.
   • CMEK_RESTRICTION_MODE: indica se la crittografia con CMEK è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare le CMEK.
     • FullyRestricted: i nuovi oggetti non possono utilizzare CMEK.
   • CSEK_RESTRICTION_MODE: indica se la crittografia con chiavi di crittografia fornite dal cliente è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare chiavi di crittografia fornite dal cliente.
     • FullyRestricted: i nuovi oggetti non possono utilizzare chiavi di crittografia fornite dal cliente.

   Devi consentire almeno un tipo di crittografia. Se ometti un tipo di crittografia, viene mantenuta la configurazione esistente.

2. Utilizza il comando gcloud storage buckets update con il flag --encryption-enforcement-file:

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

   Sostituisci quanto segue:

   • BUCKET_NAME: il nome del bucket.
   • ENCRYPTION_ENFORCEMENT_FILE: il percorso del file JSON creato nel passaggio precedente.

   L'applicazione della configurazione aggiornata potrebbe richiedere fino a due minuti.

Librerie client

C++

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C++.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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#

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage C#.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Go.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Java.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Node.js.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

/**
 * 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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Python.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Storage Ruby.

Per eseguire l'autenticazione in Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configura l'autenticazione per le librerie client.

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

API REST

API JSON

1. Avere gcloud CLI installato e inizializzato, che ti consente di generare un token di accesso per l'intestazione Authorization.

2. Crea un file JSON che contenga le seguenti informazioni:

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

   Sostituisci quanto segue:

   • STANDARD_ENCRYPTION_RESTRICTION_MODE: indica se è consentita la crittografia standard (crittografia predefinita di Google) quando si creano oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare la crittografia standard.
     • FullyRestricted: i nuovi oggetti non possono utilizzare la crittografia standard.
   • CMEK_RESTRICTION_MODE: indica se la crittografia con CMEK è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare le CMEK.
     • FullyRestricted: i nuovi oggetti non possono utilizzare CMEK.
   • CSEK_RESTRICTION_MODE: indica se la crittografia con chiavi di crittografia fornite dal cliente è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare chiavi di crittografia fornite dal cliente.
     • FullyRestricted: i nuovi oggetti non possono utilizzare chiavi di crittografia fornite dal cliente.

   Devi consentire almeno un tipo di crittografia. Se ometti un tipo di crittografia, viene mantenuta la configurazione esistente.

3. Utilizza cURL per chiamare l'API JSON con una richiesta PATCH Bucket:

   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"

   Sostituisci quanto segue:

   • JSON_FILE_NAME: il percorso del file JSON creato nel passaggio precedente.
   • BUCKET_NAME: il nome del bucket.

   L'applicazione della configurazione aggiornata potrebbe richiedere fino a due minuti.

API XML

1. Avere gcloud CLI installato e inizializzato, che ti consente di generare un token di accesso per l'intestazione Authorization.

2. Crea un file XML contenente le impostazioni di crittografia per il bucket. Le seguenti impostazioni definiscono solo la configurazione dell'applicazione della crittografia.

   Attenzione: i contenuti del corpo della richiesta sostituiscono le impostazioni esistenti, quindi includi tutti i valori che vuoi applicare. Per un elenco completo delle impostazioni di crittografia, consulta gli elementi del corpo della richiesta EncryptionConfiguration.

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

   Sostituisci quanto segue:

   • STANDARD_ENCRYPTION_RESTRICTION_MODE: indica se è consentita la crittografia standard (crittografia predefinita di Google) quando si creano oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare la crittografia standard.
     • FullyRestricted: i nuovi oggetti non possono utilizzare la crittografia standard.
   • CMEK_RESTRICTION_MODE: indica se la crittografia con CMEK è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare le CMEK.
     • FullyRestricted: i nuovi oggetti non possono utilizzare CMEK.
   • CSEK_RESTRICTION_MODE: indica se la crittografia con chiavi di crittografia fornite dal cliente è consentita durante la creazione di oggetti in questo bucket. Sono supportati i seguenti valori:
     • NotRestricted: i nuovi oggetti possono utilizzare chiavi di crittografia fornite dal cliente.
     • FullyRestricted: i nuovi oggetti non possono utilizzare chiavi di crittografia fornite dal cliente.

   Devi consentire almeno un tipo di crittografia.

3. Utilizza cURL per chiamare l'API XML con una richiesta PUT Bucket con ambito ?encryptionConfig:

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

   Sostituisci quanto segue:

   • XML_FILE_NAME: il percorso del file XML creato nel passaggio precedente.
   • BUCKET_NAME: il nome del bucket.

   L'applicazione della configurazione aggiornata potrebbe richiedere fino a due minuti.

Visualizza le impostazioni di crittografia di un bucket

Per i passaggi per visualizzare i metodi di crittografia consentiti per un bucket, consulta Recupera i metadati del bucket.

Passaggi successivi

• Imposta una chiave Cloud KMS predefinita su un bucket.
• Scopri come utilizzare i vincoli personalizzati per applicare i tipi di crittografia.