Appliquer ou restreindre les types de chiffrement pour un bucket

Ce document explique comment configurer les méthodes de chiffrement autorisées ou restreintes pour les nouveaux objets d'un bucket Cloud Storage. Vous pouvez configurer un bucket pour appliquer ou limiter l'utilisation du chiffrement standard (chiffrement par défaut de Google), des clés de chiffrement gérées par le client (CMEK) ou des clés de chiffrement fournies par le client (CSEK) pour tous les nouveaux objets créés dans le bucket.

Par exemple, pour répondre à vos exigences de conformité concernant la gestion des clés de chiffrement, vous pouvez exiger que tous les nouveaux objets soient chiffrés avec le chiffrement standard ou une CMEK, et limiter l'utilisation des clés de chiffrement fournies par le client.

Pour en savoir plus sur les méthodes de chiffrement disponibles, consultez Options de chiffrement des données.

Cloud Storage applique la configuration de chiffrement à toutes les actions qui créent un objet, comme l'importation, la copie ou la composition d'un objet, ou la restauration d'un objet supprimé de façon réversible.

Avant de commencer

Pour obtenir les autorisations nécessaires pour configurer l'application du chiffrement pour un bucket, demandez à votre administrateur de vous accorder le rôle IAM Administrateur Storage (roles/storage.admin) sur le bucket. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient les autorisations requises pour configurer l'application du chiffrement pour un bucket. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour configurer l'application du chiffrement pour un bucket :

  • Définissez la configuration lorsque vous créez un bucket : storage.buckets.create
  • Mettez à jour la configuration d'un bucket existant : storage.buckets.update
  • Si vous utilisez la console Google Cloud pour effectuer les étapes décrites sur cette page :
    • storage.buckets.get
    • storage.buckets.list

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer un bucket qui applique des types de chiffrement

Vous pouvez spécifier les méthodes de chiffrement autorisées ou restreintes pour les objets d'un bucket lorsque vous créez un bucket.

Si vous définissez une clé Cloud KMS par défaut pour le bucket, vous devez également autoriser le chiffrement à l'aide de clés CMEK ou de clés de chiffrement fournies par le client.

Console

  1. Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.

    Accéder à la page Buckets

  2. Cliquez sur  Créer.

  3. Sur la page Créer un bucket, saisissez les informations concernant votre bucket. Après chacune des étapes suivantes, cliquez sur Continuer pour passer à la suivante :

    1. Dans la section Premiers pas, procédez comme suit :

      • Saisissez un nom unique qui répond aux exigences relatives aux noms des buckets.

      • Pour ajouter une étiquette de bucket, cliquez sur la flèche de développement  pour développer la section Étiquettes, puis sur Ajouter une étiquette et spécifiez un élément key et value pour votre étiquette.

    2. Dans la section Choisir où stocker vos données, procédez comme suit :

      1. Sélectionnez un type d'emplacement.

      2. Utilisez le menu déroulant du type d'emplacement pour sélectionner un emplacement où les données d'objets de votre bucket seront stockées de manière permanente.

        • Si vous sélectionnez le type d'emplacement birégional, vous pouvez également choisir d'activer la réplication turbo à l'aide de la case à cocher correspondante.

      3. Pour configurer la réplication entre buckets, sélectionnez Ajouter une réplication entre buckets via le service de transfert de stockage et suivez les étapes :

        Configurer la réplication entre buckets

        1. Dans le menu Bucket, sélectionnez un bucket.

        2. Dans la section Paramètres de réplication, cliquez sur Configurer pour configurer les paramètres du job de réplication.

          Le volet Configurer la réplication entre buckets s'affiche.

          • Pour filtrer les objets à répliquer en fonction du préfixe de leur nom, saisissez le préfixe avec lequel vous souhaitez inclure ou exclure des objets, puis cliquez sur Ajouter un préfixe.
          • Pour définir une classe de stockage pour les objets répliqués, sélectionnez-en une dans le menu Classe de stockage. Si vous ignorez cette étape, les objets répliqués utiliseront la classe de stockage par défaut du bucket de destination.
          • Cliquez sur OK.

    3. Dans la section Choisir comment stocker vos données, procédez comme suit :

      1. Sélectionnez une classe de stockage par défaut pour le bucket ou bien classe automatique pour gérer automatiquement les classes de stockage des données de votre bucket.

      2. Dans la section Optimiser l'espace de stockage pour les charges de travail utilisant beaucoup de données, procédez comme suit :

        • Pour activer l'espace de noms hiérarchique, sélectionnez Activer l'espace de noms hiérarchique sur ce bucket.

        • Pour activer Rapid Cache, sélectionnez Activer Rapid Cache et suivez les étapes :

          1. Pour créer des caches, cliquez sur Configurer.

          2. Dans la boîte de dialogue Configurer les paramètres du cache qui s'affiche, cliquez sur la flèche du menu déroulant à côté de la liste des régions, puis sélectionnez les zones dans lesquelles vous souhaitez créer des caches.

          3. Cliquez sur OK.

    4. Dans la section Choisir comment contrôler l'accès aux objets, indiquez si votre bucket applique ou non la protection contre l'accès public, et sélectionnez un accès uniforme au niveau du bucket pour les objets de votre bucket.

    5. Dans la section Choisissez comment protéger les données des objets, procédez comme suit :

      • Sous Protection des données, sélectionnez les options que vous souhaitez définir pour votre bucket.

      • Pour modifier la durée pendant laquelle la suppression réversible conserve les objets après leur suppression, cochez la case Règle de suppression réversible, puis sélectionnez l'option Définir une durée de conservation personnalisée. Spécifiez ensuite la durée de conservation des objets supprimés.

        Pour désactiver la suppression réversible, par exemple si le bucket contient principalement des données temporaires éphémères, décochez la case Règle de suppression réversible.

      • Pour choisir comment chiffrer vos données d'objet, cliquez sur la flèche de développement  intitulée Chiffrement des données, puis procédez comme suit :

  4. Cliquez sur Créer.

gcloud

  1. Créez un fichier JSON contenant les informations suivantes :

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

    Remplacez les éléments suivants :

    • STANDARD_ENCRYPTION_RESTRICTION_MODE : indique si le chiffrement à l'aide du chiffrement standard (chiffrement par défaut de Google) est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser le chiffrement standard.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser le chiffrement standard.
    • CMEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de CMEK est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des CMEK.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés CMEK.
    • CSEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de clés de chiffrement fournies par le client est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des clés de chiffrement fournies par le client.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés de chiffrement fournies par le client.

    Vous devez autoriser au moins un type de chiffrement. Si vous omettez la configuration de l'application pour un type de chiffrement spécifique, ce type de chiffrement est autorisé par défaut.

  2. Exécutez la commande gcloud storage buckets create avec l'option --encryption-enforcement-file :

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

    Remplacez les éléments suivants :

    • BUCKET_NAME : nom du bucket.
    • ENCRYPTION_ENFORCEMENT_FILE : chemin d'accès au fichier JSON que vous avez créé à l'étape précédente.

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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#

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage C#.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 


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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Go.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Java.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 


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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Node.js.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage PHP.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Python.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Ruby.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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. Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.

  2. Créez un fichier JSON contenant les paramètres du bucket. Pour obtenir la liste complète des paramètres, consultez la documentation Buckets: Insert. Les paramètres suivants ne définissent que le nom du bucket et le chiffrement :

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

    Remplacez les éléments suivants :

    • BUCKET_NAME : nom du bucket.
    • STANDARD_ENCRYPTION_RESTRICTION_MODE : indique si le chiffrement à l'aide du chiffrement standard (chiffrement par défaut de Google) est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser le chiffrement standard.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser le chiffrement standard.
    • CMEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de CMEK est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des CMEK.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés CMEK.
    • CSEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de clés de chiffrement fournies par le client est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des clés de chiffrement fournies par le client.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés de chiffrement fournies par le client.

    Vous devez autoriser au moins un type de chiffrement. Si vous omettez la configuration de l'application pour un type de chiffrement spécifique, ce type de chiffrement est autorisé par défaut.

  3. Utilisez cURL pour appeler l'API JSON avec une requête de bucket POST :

    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"

    Remplacez les éléments suivants :

    • JSON_FILE_NAME : chemin d'accès au fichier JSON que vous avez créé à l'étape précédente.
    • PROJECT_ID : ID ou numéro du projet pour votre bucket.

API XML

  1. Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.

  2. Créez un fichier XML contenant les paramètres du bucket. Pour obtenir la liste complète des paramètres, consultez la documentation XML : Créer un bucket. Les paramètres suivants ne définissent que l'application du chiffrement :

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

    Remplacez les éléments suivants :

    • STANDARD_ENCRYPTION_RESTRICTION_MODE : indique si le chiffrement à l'aide du chiffrement standard (chiffrement par défaut de Google) est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser le chiffrement standard.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser le chiffrement standard.
    • CMEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de CMEK est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des CMEK.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés CMEK.
    • CSEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de clés de chiffrement fournies par le client est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des clés de chiffrement fournies par le client.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés de chiffrement fournies par le client.

    Vous devez autoriser au moins un type de chiffrement. Si vous omettez la configuration de l'application pour un type de chiffrement spécifique, ce type de chiffrement est autorisé par défaut.

  3. Utilisez cURL pour appeler l'API XML avec une requête de bucket PUT :

    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"

    Remplacez les éléments suivants :

    • XML_FILE_NAME : chemin d'accès au fichier XML que vous avez créé à l'étape précédente.
    • PROJECT_ID : ID ou numéro du projet pour votre bucket.
    • BUCKET_NAME : nom du bucket.

Modifier les types de chiffrement autorisés pour un bucket

Pour mettre à jour les méthodes de chiffrement autorisées pour les nouveaux objets d'un bucket existant, procédez comme suit.

Si une clé KMS par défaut est définie pour le bucket, vous ne pouvez pas restreindre à la fois les clés de chiffrement fournies par le client et les clés CMEK, car cela empêcherait la création de nouveaux objets. Autorisez CMEK ou CSEK sur un tel bucket, ou supprimez la clé Cloud KMS par défaut du bucket.

Console

  1. Dans la console Google Cloud , accédez à la page Buckets de Cloud Storage.

    Accéder à la page "Buckets"

  2. Dans la liste des buckets, cliquez sur le nom du bucket.

  3. Cliquez sur l'onglet Configuration.

  4. Dans la section Protection, cliquez sur  Modifier le chiffrement.

  5. Dans la section Règles d'application du chiffrement, sous Types de clés, sélectionnez les types de chiffrement à autoriser ou à restreindre pour les nouveaux objets du bucket.

  6. Cliquez sur Enregistrer.

gcloud

  1. Créez un fichier JSON contenant les informations suivantes :

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

    Remplacez les éléments suivants :

    • STANDARD_ENCRYPTION_RESTRICTION_MODE : indique si le chiffrement à l'aide du chiffrement standard (chiffrement par défaut de Google) est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser le chiffrement standard.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser le chiffrement standard.
    • CMEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de CMEK est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des CMEK.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés CMEK.
    • CSEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de clés de chiffrement fournies par le client est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des clés de chiffrement fournies par le client.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés de chiffrement fournies par le client.

    Vous devez autoriser au moins un type de chiffrement. Si vous omettez un type de chiffrement, la configuration existante est conservée.

  2. Exécutez la commande gcloud storage buckets update avec l'option --encryption-enforcement-file :

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

    Remplacez les éléments suivants :

    • BUCKET_NAME : nom du bucket.
    • ENCRYPTION_ENFORCEMENT_FILE : chemin d'accès au fichier JSON que vous avez créé à l'étape précédente.

    L'application de la configuration mise à jour peut prendre jusqu'à deux minutes.

Bibliothèques clientes

C++

Pour en savoir plus, consultez la documentation de référence de l'API Cloud Storage en langage C++.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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#

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage C#.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 


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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Go.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Java.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 


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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Node.js.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage PHP.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Python.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 

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

Pour en savoir plus, consultez la documentation de référence des API Cloud Storage en langage Ruby.

Pour vous authentifier auprès de Cloud Storage, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour les bibliothèques clientes. 


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. Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.

  2. Créez un fichier JSON contenant les informations suivantes :

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

    Remplacez les éléments suivants :

    • STANDARD_ENCRYPTION_RESTRICTION_MODE : indique si le chiffrement à l'aide du chiffrement standard (chiffrement par défaut de Google) est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser le chiffrement standard.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser le chiffrement standard.
    • CMEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de CMEK est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des CMEK.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés CMEK.
    • CSEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de clés de chiffrement fournies par le client est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des clés de chiffrement fournies par le client.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés de chiffrement fournies par le client.

    Vous devez autoriser au moins un type de chiffrement. Si vous omettez un type de chiffrement, la configuration existante est conservée.

  3. Utilisez cURL pour appeler l'API JSON avec une requête de bucket PATCH :

    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"

    Remplacez les éléments suivants :

    • JSON_FILE_NAME : chemin d'accès au fichier JSON que vous avez créé à l'étape précédente.
    • BUCKET_NAME : nom du bucket.

    L'application de la configuration mise à jour peut prendre jusqu'à deux minutes.

API XML

  1. Vous devez installer et initialiser la gcloud CLI afin de générer un jeton d'accès pour l'en-tête Authorization.

  2. Créez un fichier XML contenant les paramètres de chiffrement du bucket. Les paramètres suivants ne définissent que la configuration de l'application du chiffrement.

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

    Remplacez les éléments suivants :

    • STANDARD_ENCRYPTION_RESTRICTION_MODE : indique si le chiffrement à l'aide du chiffrement standard (chiffrement par défaut de Google) est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser le chiffrement standard.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser le chiffrement standard.
    • CMEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de CMEK est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des CMEK.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés CMEK.
    • CSEK_RESTRICTION_MODE : indique si le chiffrement à l'aide de clés de chiffrement fournies par le client est autorisé lors de la création d'objets dans ce bucket. Les valeurs suivantes sont acceptées :
      • NotRestricted : les nouveaux objets peuvent utiliser des clés de chiffrement fournies par le client.
      • FullyRestricted : les nouveaux objets ne peuvent pas utiliser de clés de chiffrement fournies par le client.

    Vous devez autoriser au moins un type de chiffrement.

  3. Utilisez cURL pour appeler l'API XML avec une requête PUT Bucket limitée à ?encryptionConfig :

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

    Remplacez les éléments suivants :

    • XML_FILE_NAME : chemin d'accès au fichier XML que vous avez créé à l'étape précédente.
    • BUCKET_NAME : nom du bucket.

    L'application de la configuration mise à jour peut prendre jusqu'à deux minutes.

Afficher les paramètres de chiffrement d'un bucket

Pour savoir comment afficher les méthodes de chiffrement autorisées pour un bucket, consultez Obtenir les métadonnées d'un bucket.

Étapes suivantes