Aplicar ou restringir os tipos de criptografia de um bucket

Neste documento, descrevemos como configurar quais métodos de criptografia são permitidos ou restritos para novos objetos em um bucket do Cloud Storage. É possível configurar um bucket para aplicar ou restringir o uso de criptografia padrão (criptografia padrão do Google), chaves de criptografia gerenciadas pelo cliente (CMEK) ou chaves de criptografia fornecidas pelo cliente (CSEK) para novos objetos criados no bucket.

Por exemplo, para ajudar a atender aos requisitos de conformidade sobre o gerenciamento de chaves de criptografia, é possível exigir que todos os novos objetos sejam criptografados com criptografia padrão ou CMEK e restringir o uso de chaves de criptografia fornecidas pelo cliente.

Para mais informações sobre os métodos de criptografia disponíveis, consulte Opções de criptografia de dados.

O Cloud Storage aplica a configuração de criptografia a todas as ações que criam um novo objeto, como fazer upload, copiar, compor e restaurar um objeto excluído de maneira reversível.

Antes de começar

Para receber as permissões necessárias para configurar a aplicação da criptografia em um bucket, peça ao administrador para conceder a você o papel do IAM de Administrador do Storage (roles/storage.admin) no bucket. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para configurar a aplicação de criptografia em um bucket. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para configurar a aplicação da criptografia em um bucket:

  • Defina a configuração ao criar um novo bucket: storage.buckets.create
  • Atualize a configuração de um bucket: storage.buckets.update
  • Se você usa o console do Google Cloud para realizar as etapas desta página:
    • storage.buckets.get
    • storage.buckets.list

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Criar um bucket que aplique tipos de criptografia

É possível especificar os métodos de criptografia permitidos ou restritos para os objetos em um bucket ao criar um novo bucket.

Se você definir uma chave padrão do Cloud KMS para o bucket, também será necessário permitir a criptografia usando CMEKs ou chaves de criptografia fornecidas pelo cliente.

Console

  1. No console do Google Cloud , acesse a página Buckets do Cloud Storage.

    Acesse Buckets

  2. Clique em Criar.

  3. Na página Criar um bucket, insira as informações do seu bucket. Após cada uma das etapas a seguir, clique em Continuar para prosseguir para a próxima etapa:

    1. Na seção Começar, faça o seguinte:

      • Insira um nome globalmente exclusivo que atenda aos requisitos de nome de bucket.

      • Para adicionar um rótulo de bucket, clique na seta de expansão para abrir a seção Rótulos, clique em Adicionar rótulo e especifique um key e um value para o rótulo.

    2. Na seção Escolha onde armazenar seus dados, faça o seguinte:

      1. Selecione um tipo de local.

      2. Use o menu suspenso do tipo de local para selecionar um Local em que os dados de objetos no bucket serão armazenados permanentemente.

      3. Para configurar a replicação entre buckets, selecione Adicionar replicação entre buckets usando o Serviço de transferência do Cloud Storage e siga as etapas:

        Configurar a replicação entre buckets

        1. No menu Bucket, selecione um bucket.

        2. Na seção Configurações de replicação, clique em Configurar para definir as configurações do job de replicação.

          O painel Configurar a replicação entre buckets é exibido.

          • Para filtrar objetos a serem replicados por prefixo de nome de objeto, digite um prefixo com que você quer incluir ou excluir objetos e clique em Adicionar um prefixo.
          • Para definir uma classe de armazenamento para os objetos replicados, selecione uma classe de armazenamento no menu Classe de armazenamento. Se você pular esta etapa, os objetos replicados vão usar a classe de armazenamento do bucket de destino por padrão.
          • Clique em Concluído.

    3. Na seção Escolha como armazenar seus dados, faça o seguinte:

      1. Selecione uma classe de armazenamento padrão para o bucket ou Classe automática para gerenciamento automático da classe de armazenamento dos dados do bucket.

      2. Na seção Otimizar o armazenamento para cargas de trabalho com uso intensivo de dados, faça o seguinte:

        • Para ativar o namespace hierárquico, selecione Ativar namespace hierárquico neste bucket.

        • Para ativar o Rapid Cache, selecione Ativar Rapid Cache e siga as etapas:

          1. Para criar caches, clique em Configurar.

          2. Na caixa de diálogo Definir configurações de cache que aparece, clique na seta suspensa ao lado das regiões listadas e selecione as zonas em que você quer criar caches.

          3. Clique em Concluído.

    4. Na seção Escolha como controlar o acesso a objetos, faça o seguinte:

      1. Selecione se o bucket aplica a prevenção de acesso público.

      2. Selecione Uniforme para ativar o acesso uniforme no nível do bucket.

      3. Se quiser, configure a filtragem de IP para o bucket.

    5. Na seção Escolha como proteger os dados do objeto, faça o seguinte:

      • Selecione qualquer uma das opções em Proteção de dados que você quer definir para o bucket.

      • Para mudar o tempo que a exclusão reversível retém os objetos após a exclusão, marque a caixa de seleção Política de exclusão reversível e selecione a opção Definir duração de retenção personalizada. Em seguida, especifique por quanto tempo você quer reter os objetos excluídos.

        Para desativar a exclusão reversível, por exemplo, se o bucket contiver principalmente dados temporários de curta duração, desmarque a caixa de seleção Política de exclusão reversível.

      • Para escolher como criptografar os dados do objeto, clique na seta de expansão identificada como Criptografia de dados e faça o seguinte:

  4. Clique em Criar.

gcloud

  1. Crie um arquivo JSON com as informações a seguir:

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

    Substitua:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: se a criptografia padrão (criptografia padrão do Google) é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar a criptografia padrão.
      • FullyRestricted: novos objetos não podem usar a criptografia padrão.
    • CMEK_RESTRICTION_MODE: se a criptografia usando CMEKs é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar CMEKs.
      • FullyRestricted: novos objetos não podem usar CMEKs.
    • CSEK_RESTRICTION_MODE: se a criptografia usando chaves de criptografia fornecidas pelo cliente é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar chaves de criptografia fornecidas pelo cliente.
      • FullyRestricted: novos objetos não podem usar chaves de criptografia fornecidas pelo cliente.

    É necessário permitir pelo menos um tipo de criptografia. Se você omitir a configuração de aplicação para um tipo de criptografia específico, esse tipo será permitido por padrão.

  2. Use o comando gcloud storage buckets create com a flag --encryption-enforcement-file:

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

    Substitua:

    • BUCKET_NAME: o nome do bucket
    • ENCRYPTION_ENFORCEMENT_FILE: o caminho para o arquivo JSON que você criou na etapa anterior.

Bibliotecas de cliente

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage C++.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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#

Para mais informações, consulte a documentação de referência da API Cloud Storage C#.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 


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

Para mais informações, consulte a documentação de referência da API Cloud Storage Go.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

Para mais informações, consulte a documentação de referência da API Cloud Storage Java.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 


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

Para mais informações, consulte a documentação de referência da API Cloud Storage Node.js.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

Para mais informações, consulte a documentação de referência da API Cloud Storage PHP.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

Para mais informações, consulte a documentação de referência da API Cloud Storage Python.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

Para mais informações, consulte a documentação de referência da API Cloud Storage Ruby.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

APIs REST

API JSON

  1. Ter a CLI gcloud instalada e inicializada, o que permite gerar um token de acesso para o cabeçalho Authorization.

  2. Crie um arquivo JSON com as configurações do bucket. Para uma lista completa de configurações, consulte a documentação Buckets: Insert. As configurações a seguir definem apenas o nome do bucket e a criptografia:

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

    Substitua:

    • BUCKET_NAME: o nome do bucket.
    • STANDARD_ENCRYPTION_RESTRICTION_MODE: se a criptografia padrão (criptografia padrão do Google) é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar a criptografia padrão.
      • FullyRestricted: novos objetos não podem usar a criptografia padrão.
    • CMEK_RESTRICTION_MODE: se a criptografia usando CMEKs é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar CMEKs.
      • FullyRestricted: novos objetos não podem usar CMEKs.
    • CSEK_RESTRICTION_MODE: se a criptografia usando chaves de criptografia fornecidas pelo cliente é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar chaves de criptografia fornecidas pelo cliente.
      • FullyRestricted: novos objetos não podem usar chaves de criptografia fornecidas pelo cliente.

    É necessário permitir pelo menos um tipo de criptografia. Se você omitir a configuração de aplicação para um tipo de criptografia específico, esse tipo será permitido por padrão.

  3. Use cURL para chamar a API JSON com uma solicitação 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"

    Substitua:

    • JSON_FILE_NAME: o caminho para o arquivo JSON que você criou na etapa anterior.
    • PROJECT_ID: o ID ou o número do projeto do bucket.

API XML

  1. Ter a CLI gcloud instalada e inicializada, o que permite gerar um token de acesso para o cabeçalho Authorization.

  2. Crie um arquivo XML com as configurações do bucket. Para uma lista completa de configurações, consulte a documentação XML: criar um bucket. As configurações a seguir definem apenas a aplicação da criptografia:

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

    Substitua:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: se a criptografia padrão (criptografia padrão do Google) é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar a criptografia padrão.
      • FullyRestricted: novos objetos não podem usar a criptografia padrão.
    • CMEK_RESTRICTION_MODE: se a criptografia usando CMEKs é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar CMEKs.
      • FullyRestricted: novos objetos não podem usar CMEKs.
    • CSEK_RESTRICTION_MODE: se a criptografia usando chaves de criptografia fornecidas pelo cliente é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar chaves de criptografia fornecidas pelo cliente.
      • FullyRestricted: novos objetos não podem usar chaves de criptografia fornecidas pelo cliente.

    É necessário permitir pelo menos um tipo de criptografia. Se você omitir a configuração de aplicação para um tipo de criptografia específico, esse tipo será permitido por padrão.

  3. Use cURL para chamar a API XML com uma solicitação 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"

    Substitua:

    • XML_FILE_NAME: o caminho para o arquivo XML que você criou na etapa anterior.
    • PROJECT_ID: o ID ou o número do projeto do bucket.
    • BUCKET_NAME: o nome do bucket

Atualizar os tipos de criptografia permitidos para um bucket

Para atualizar os métodos de criptografia permitidos para novos objetos em um bucket, siga estas etapas.

Se o bucket tiver uma chave KMS padrão definida, não será possível restringir as CMEKs e as chaves de criptografia fornecidas pelo cliente, porque isso impediria a criação de novos objetos. Permita CMEK ou CSEK em um bucket como esse ou remova a chave padrão do Cloud KMS do bucket.

Console

  1. No console do Google Cloud , acesse a página Buckets do Cloud Storage.

    Acessar buckets

  2. Na lista de buckets, clique no nome do bucket.

  3. Clique na guia Configuração.

  4. Na seção Proteção, clique em  Editar criptografia.

  5. Na seção Regras de aplicação de criptografia, em Tipos de chave, selecione quais tipos de criptografia permitir ou restringir para novos objetos no bucket.

  6. Clique em Salvar.

gcloud

  1. Crie um arquivo JSON com as informações a seguir:

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

    Substitua:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: se a criptografia padrão (criptografia padrão do Google) é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar a criptografia padrão.
      • FullyRestricted: novos objetos não podem usar a criptografia padrão.
    • CMEK_RESTRICTION_MODE: se a criptografia usando CMEKs é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar CMEKs.
      • FullyRestricted: novos objetos não podem usar CMEKs.
    • CSEK_RESTRICTION_MODE: se a criptografia usando chaves de criptografia fornecidas pelo cliente é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar chaves de criptografia fornecidas pelo cliente.
      • FullyRestricted: novos objetos não podem usar chaves de criptografia fornecidas pelo cliente.

    É necessário permitir pelo menos um tipo de criptografia. Se você omitir um tipo de criptografia, a configuração atual será mantida.

  2. Use o comando gcloud storage buckets update com a flag --encryption-enforcement-file:

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

    Substitua:

    • BUCKET_NAME: o nome do bucket
    • ENCRYPTION_ENFORCEMENT_FILE: o caminho para o arquivo JSON que você criou na etapa anterior.

    Pode levar até dois minutos para que a configuração atualizada entre em vigor.

Bibliotecas de cliente

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage C++.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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#

Para mais informações, consulte a documentação de referência da API Cloud Storage C#.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 


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

Para mais informações, consulte a documentação de referência da API Cloud Storage Go.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

Para mais informações, consulte a documentação de referência da API Cloud Storage Java.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 


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

Para mais informações, consulte a documentação de referência da API Cloud Storage Node.js.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

Para mais informações, consulte a documentação de referência da API Cloud Storage PHP.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

Para mais informações, consulte a documentação de referência da API Cloud Storage Python.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 

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

Para mais informações, consulte a documentação de referência da API Cloud Storage Ruby.

Para se autenticar no Cloud Storage, configure o Application Default Credentials. Saiba mais em Configurar a autenticação para bibliotecas de cliente. 


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

APIs REST

API JSON

  1. Ter a CLI gcloud instalada e inicializada, o que permite gerar um token de acesso para o cabeçalho Authorization.

  2. Crie um arquivo JSON com as informações a seguir:

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

    Substitua:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: se a criptografia padrão (criptografia padrão do Google) é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar a criptografia padrão.
      • FullyRestricted: novos objetos não podem usar a criptografia padrão.
    • CMEK_RESTRICTION_MODE: se a criptografia usando CMEKs é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar CMEKs.
      • FullyRestricted: novos objetos não podem usar CMEKs.
    • CSEK_RESTRICTION_MODE: se a criptografia usando chaves de criptografia fornecidas pelo cliente é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar chaves de criptografia fornecidas pelo cliente.
      • FullyRestricted: novos objetos não podem usar chaves de criptografia fornecidas pelo cliente.

    É necessário permitir pelo menos um tipo de criptografia. Se você omitir um tipo de criptografia, a configuração atual será mantida.

  3. Use cURL para chamar a API JSON com uma solicitação 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"

    Substitua:

    • JSON_FILE_NAME: o caminho para o arquivo JSON que você criou na etapa anterior.
    • BUCKET_NAME: o nome do bucket

    Pode levar até dois minutos para que a configuração atualizada entre em vigor.

API XML

  1. Ter a CLI gcloud instalada e inicializada, o que permite gerar um token de acesso para o cabeçalho Authorization.

  2. Crie um arquivo XML que contenha as configurações de criptografia do bucket. As configurações a seguir definem apenas a configuração de aplicação da criptografia.

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

    Substitua:

    • STANDARD_ENCRYPTION_RESTRICTION_MODE: se a criptografia padrão (criptografia padrão do Google) é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar a criptografia padrão.
      • FullyRestricted: novos objetos não podem usar a criptografia padrão.
    • CMEK_RESTRICTION_MODE: se a criptografia usando CMEKs é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar CMEKs.
      • FullyRestricted: novos objetos não podem usar CMEKs.
    • CSEK_RESTRICTION_MODE: se a criptografia usando chaves de criptografia fornecidas pelo cliente é permitida ao criar objetos neste bucket. Os valores a seguir são aceitos:
      • NotRestricted: novos objetos podem usar chaves de criptografia fornecidas pelo cliente.
      • FullyRestricted: novos objetos não podem usar chaves de criptografia fornecidas pelo cliente.

    É necessário permitir pelo menos um tipo de criptografia.

  3. Use cURL para chamar a API XML com uma solicitação do bucket PUT com o escopo definido como ?encryptionConfig:

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

    Substitua:

    • XML_FILE_NAME: o caminho para o arquivo XML que você criou na etapa anterior.
    • BUCKET_NAME: o nome do bucket

    Pode levar até dois minutos para que a configuração atualizada entre em vigor.

Ver as configurações de criptografia de um bucket

Para ver quais métodos de criptografia são permitidos para um bucket, consulte Acessar metadados do bucket.

A seguir