Crie contentores com o espaço de nomes hierárquico ativado

Esta página descreve como criar contentores com o espaço de nomes hierárquico ativado.

Funções necessárias

Para receber a autorização de que precisa para criar um contentor com o espaço de nomes hierárquico ativado, peça ao seu administrador para lhe conceder a função de administrador de armazenamento (roles/storage.admin) do IAM no projeto. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Esta função predefinida contém a autorização storage.buckets.create , que é necessária para criar um contentor com o espaço de nomes hierárquico ativado.

Também pode obter esta autorização com funções personalizadas ou outras funções predefinidas.

Crie um contentor com o espaço de nomes hierárquico ativado

Consola

  1. Na Google Cloud consola, aceda à página Recipientes do Cloud Storage.

    Aceda a Recipientes

  2. Clique em Criar.
  3. Na página Criar um depósito, introduza as informações do depósito. Após cada um dos passos seguintes, clique em Continuar para avançar para o passo seguinte:

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

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

      1. Selecione um Tipo de localização.

      2. Use o menu pendente do tipo de localização para selecionar uma Localização onde os dados de objetos no seu contentor vão ser armazenados permanentemente.

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

      1. Selecione uma classe de armazenamento predefinida para o contentor ou o Autoclass para a gestão automática da classe de armazenamento dos dados do contentor.

      2. Na secção Otimize o armazenamento para cargas de trabalho com grande volume de dados, faça o seguinte:

        1. Para ativar o espaço de nomes hierárquico, selecione Ativar espaço de nomes hierárquico neste contentor.

        2. Na secção Escolha como controlar o acesso aos objetos, selecione se o seu contentor aplica a prevenção de acesso público e selecione um modelo de controlo de acesso para os objetos do contentor.

        3. Na secção Escolha como proteger os dados de objetos, faça o seguinte:

          • Selecione qualquer uma das opções em Proteção de dados que queira definir para o seu contentor.

          • Para ativar a eliminação temporária, clique na seta de expansão com a etiqueta Política de eliminação temporária e especifique o número de dias que quer reter objetos após a eliminação.

          • Para escolher como os dados de objetos vão ser encriptados, clique na seta de expansão com a etiqueta Encriptação de dados e selecione um método de encriptação de dados.

      3. Clique em Criar.

      Para saber como obter informações detalhadas sobre erros relativos a operações do Cloud Storage falhadas na Google Cloud consola, consulte a secção Resolução de problemas.

Linha de comandos

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. No seu ambiente de programação, execute o comando gcloud storage buckets create:

    gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION --uniform-bucket-level-access --enable-hierarchical-namespace

    Onde:

    • BUCKET_NAME é o nome que quer dar ao seu contentor, sujeito aos requisitos de nomenclatura. Por exemplo, my-bucket.
    • BUCKET_LOCATION é a localização do seu contentor. Por exemplo, us-east1.
    • --uniform-bucket-level-access: ative o acesso uniforme ao nível do contentor para o contentor.
    • --enable-hierarchical-namespace: ative o espaço de nomes hierárquico para o contentor. Não pode ativar o espaço de nomes hierárquico num contentor existente.

    Se o pedido for bem-sucedido, o comando devolve a seguinte mensagem:

    Creating gs://BUCKET_NAME/...

    Defina as seguintes flags para ter maior controlo sobre a criação do seu contentor:

    • --project: especifique o ID do projeto ou o número do projeto ao qual o seu contentor vai ser associado. Por exemplo, my-project.
    • --default-storage-class: especifique a classe de armazenamento predefinida do seu contentor. Por exemplo, STANDARD.

      • Para ver uma lista completa das opções de criação de contentores através da CLI gcloud, consulte as buckets create opções.

    Por exemplo:

    gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access

    3. Bibliotecas cliente

    C++

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

    Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  auto metadata = client.CreateBucket(
      bucket_name,
      gcs::BucketMetadata()
          .set_hierarchical_namespace(gcs::BucketHierarchicalNamespace{true})
          .set_iam_configuration(gcs::BucketIamConfiguration{
              gcs::UniformBucketLevelAccess{true, {}}, absl::nullopt}));
  if (!metadata) throw std::move(metadata).status();

  std::cout << "Bucket " << metadata->name() << " created."
            << "\nFull Metadata: " << *metadata << "\n";
}

    C#

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

    Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

public class CreateBucketWithHierarchicalNamespaceEnabledSample
{
    public Bucket CreateBucketWithHierarchicalNamespace(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.CreateBucket(projectId,
            new Bucket
            {
                Name = bucketName,
                IamConfiguration = new Bucket.IamConfigurationData
                {
                    UniformBucketLevelAccess = new Bucket.IamConfigurationData.UniformBucketLevelAccessData { Enabled = true }
                },
                HierarchicalNamespace = new Bucket.HierarchicalNamespaceData { Enabled = true }
            });
        Console.WriteLine($"Created {bucketName} with Hierarchical Namespace enabled.");
        return bucket;
    }
}

    Go

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

    Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

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

// createBucketHierarchicalNamespace creates a new bucket with hierarchical
// namespace features enabled.
func createBucketHierarchicalNamespace(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()

	attrs := &storage.BucketAttrs{
		HierarchicalNamespace: &storage.HierarchicalNamespace{
			Enabled: true,
		},
		// Hierarchical namespace buckets must use uniform bucket-level access.
		UniformBucketLevelAccess: storage.UniformBucketLevelAccess{
			Enabled: true,
		},
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, attrs); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v with hierarchical namespace enabled\n", bucketName)
	return nil
}

    Java

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

    Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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.HierarchicalNamespace;
import com.google.cloud.storage.BucketInfo.IamConfiguration;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public final class CreateHierarchicalNamespaceBucket {

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

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";
    StorageOptions storageOptions = StorageOptions.newBuilder().setProjectId(projectId).build();
    try (Storage storage = storageOptions.getService()) {

      BucketInfo bucketInfo =
          BucketInfo.newBuilder(bucketName)
              .setIamConfiguration(
                  // Hierarchical namespace buckets must use uniform bucket-level access.
                  IamConfiguration.newBuilder().setIsUniformBucketLevelAccessEnabled(true).build())
              .setHierarchicalNamespace(HierarchicalNamespace.newBuilder().setEnabled(true).build())
              .build();

      Bucket bucket = storage.create(bucketInfo);

      System.out.printf(
          "Created bucket %s with Hierarchical Namespace enabled.%n", bucket.getName());
    }
  }
}

    Node.js

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

    Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see https://cloud.google.com/docs/authentication/production or https://googleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storage();

async function createBucketWithHierarchicalNamespace() {
  const [bucket] = await storage.createBucket(bucketName, {
    iamConfiguration: {
      uniformBucketLevelAccess: {
        enabled: true,
      },
    },
    hierarchicalNamespace: {
      enabled: true,
    },
  });

  console.log(
    `Created '${bucket.name}' with hierarchical namespace enabled.`
  );
}

createBucketWithHierarchicalNamespace().catch(console.error);

    PHP

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

    Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    use Google\Cloud\Storage\StorageClient;

/**
 * Create a new bucket with Hierarchical Namespace enabled.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function create_bucket_hierarchical_namespace(string $bucketName): void
{
    $storage = new StorageClient();
    $bucket = $storage->createBucket($bucketName, [
        'hierarchicalNamespace' => ['enabled' => true],
        'iamConfiguration' => ['uniformBucketLevelAccess' => ['enabled' => true]]
    ]);

    printf('Created bucket %s with Hierarchical Namespace enabled.', $bucket->name());
}

    Python

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

    Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    from google.cloud import storage


def create_bucket_hierarchical_namespace(bucket_name):
    """Creates a bucket with hierarchical namespace enabled."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    bucket.iam_configuration.uniform_bucket_level_access_enabled = True
    bucket.hierarchical_namespace_enabled = True
    bucket.create()

    print(f"Created bucket {bucket_name} with hierarchical namespace enabled.")

    Ruby

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

    Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new

  hierarchical_namespace = Google::Apis::StorageV1::Bucket::HierarchicalNamespace.new enabled: true

  storage.create_bucket bucket_name do |b|
    b.uniform_bucket_level_access = true
    b.hierarchical_namespace = hierarchical_namespace
  end

  puts "Created bucket #{bucket_name} with Hierarchical Namespace enabled."
end

    APIs REST

    API JSON

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

    2. Crie um ficheiro JSON que contenha as definições do contentor, que tem de incluir um name para o contentor. Consulte a documentação Buckets: Insert para ver uma lista completa de definições. Seguem-se as definições comuns a incluir:
      3. {
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS",
  "hierarchicalNamespace": {
    "enabled": "BOOLEAN"
  },
  "iamConfiguration": {
    "uniformBucketLevelAccess": {
      "enabled": true
  },
},
}

      Onde:

    3. uniformBucketLevelAccess.enabled está definido como TRUE para ativar o acesso uniforme ao nível do contentor para o seu contentor.
    4. Use cURL para chamar a API JSON: 
      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_IDENTIFIER"

      Onde:

      • JSON_FILE_NAME é o nome do ficheiro JSON que contém as definições do contentor.
      • PROJECT_IDENTIFIER é o ID ou o número do projeto ao qual o seu contentor vai ser associado. Por exemplo, my-project.

O que se segue?

Experimente

Se está a usar o Google Cloud pela primeira vez, crie uma conta para avaliar o desempenho do Cloud Storage em cenários reais. Os novos clientes também recebem 300 USD em créditos gratuitos para executar, testar e implementar cargas de trabalho.

Experimentar o Cloud Storage gratuitamente