Crea bucket con lo spazio dei nomi gerarchico abilitato

Questa pagina descrive come creare bucket con lo spazio dei nomi gerarchico abilitato.

Ruoli obbligatori

Per ottenere l'autorizzazione necessaria per creare un bucket con lo spazio dei nomi gerarchico abilitato, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) sul progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene l'autorizzazione storage.buckets.create, necessaria per creare un bucket con lo spazio dei nomi gerarchico abilitato.

Potresti anche ottenere questa autorizzazione con ruoli personalizzati o altri ruoli predefiniti.

Crea un bucket con lo spazio dei nomi gerarchico abilitato

Console

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

   Vai a Bucket

2. Fai clic su Crea.

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

   1. Nella sezione Inizia, segui questi passaggi:

      • Inserisci un nome univoco globale che soddisfi i requisiti per il nome del bucket.

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

      1. Seleziona un Tipo di località.

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

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

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

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

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

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

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

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

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

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

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

      3. (Facoltativo) Configura il filtro IP per il bucket.

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

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

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

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

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

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

4. Fai clic su Crea.

Per scoprire come ottenere informazioni dettagliate sugli errori relativi alle operazioni di Cloud Storage non riuscite nella console Google Cloud , consulta Risoluzione dei problemi.

Riga di comando

1. Nella console Google Cloud , attiva Cloud Shell.

   Attiva Cloud Shell

   Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

2. Nell'ambiente di sviluppo, esegui il comando gcloud storage buckets create:

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

   Dove:

   • BUCKET_NAME è il nome che vuoi assegnare al bucket, soggetto ai requisiti di denominazione. Ad esempio, my-bucket.
   • BUCKET_LOCATION è la posizione del tuo bucket. Ad esempio: us-east1.
   • --uniform-bucket-level-access: abilita l'accesso uniforme a livello di bucket per il bucket.
     
     Nota: l'abilitazione dell'accesso uniforme a livello di bucket è obbligatoria per creare un bucket con lo spazio dei nomi gerarchico abilitato.
   • --enable-hierarchical-namespace: abilita lo spazio dei nomi gerarchico per il bucket. Non puoi abilitare lo spazio dei nomi gerarchico in un bucket esistente.

   Se la richiesta ha esito positivo, il comando restituisce il seguente messaggio:

   Creating gs://BUCKET_NAME/...

   Imposta i seguenti flag per avere un maggiore controllo sulla creazione del bucket:

   • --project: specifica l'ID progetto o il numero di progetto a cui verrà associato il bucket. Ad esempio, my-project.
   • --default-storage-class: specifica la classe di archiviazione predefinita del bucket. Ad esempio: STANDARD. Per gestire automaticamente le classi di archiviazione degli oggetti, utilizza il flag --enable-autoclass. Per saperne di più, consulta Autoclass.

   Per un elenco completo delle opzioni per la creazione di bucket utilizzando Google Cloud CLI, consulta le opzioni di buckets create.

   Ad esempio:

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

Librerie client

C++

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

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

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

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

C#

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

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

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

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

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

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

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

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

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

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

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

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.BucketInfo.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

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

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

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

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

// Creates a client
// 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

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

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

use Google\Cloud\Storage\StorageClient;

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

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

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

from google.cloud import storage


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

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

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

def 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

Rust

use google_cloud_storage::{
    client::StorageControl,
    model::Bucket,
    model::bucket::iam_config::UniformBucketLevelAccess,
    model::bucket::{HierarchicalNamespace, IamConfig},
};

pub async fn sample(
    client: &StorageControl,
    project_id: &str,
    bucket_id: &str,
) -> anyhow::Result<()> {
    let bucket = client
        .create_bucket()
        .set_parent("projects/_")
        .set_bucket_id(bucket_id)
        .set_bucket(
            Bucket::new()
                .set_project(format!("projects/{project_id}"))
                .set_hierarchical_namespace(HierarchicalNamespace::new().set_enabled(true))
                .set_iam_config(IamConfig::new().set_uniform_bucket_level_access(
                    UniformBucketLevelAccess::new().set_enabled(true),
                )),
        )
        .send()
        .await?;
    println!("successfully created bucket {bucket:?}");
    Ok(())
}

API REST

API JSON

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

2. Crea un file JSON contenente le impostazioni del bucket, che deve includere un name per il bucket. Consulta la documentazione Bucket: inserisci per un elenco completo delle impostazioni. Di seguito sono riportate le impostazioni comuni da includere:

{
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS",
  "hierarchicalNamespace": {
    "enabled": "BOOLEAN"
  },
  "iamConfiguration": {
    "uniformBucketLevelAccess": {
      "enabled": true
  },
},
}

Dove:

• BUCKET_NAME è il nome che vuoi assegnare al bucket, soggetto ai requisiti di denominazione. Ad esempio: my-bucket.
• BUCKET_LOCATION è la località in cui vuoi archiviare i dati degli oggetti del bucket. Ad esempio: US-EAST1.
• STORAGE_CLASS è la classe di archiviazione predefinita del tuo bucket. Ad esempio: STANDARD.
• hierarchicalNamespace.enabled è impostato su TRUE per abilitare lo spazio dei nomi gerarchico per il bucket. Non puoi abilitare lo spazio dei nomi gerarchico in un bucket esistente.
3. uniformBucketLevelAccess.enabled è impostato su TRUE per abilitare l'accesso uniforme a livello di bucket per il tuo bucket.
   
   Nota: l'abilitazione dell'accesso uniforme a livello di bucket è obbligatoria per creare un bucket con lo spazio dei nomi gerarchico abilitato.
4. cURL

   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"

   Dove:

   • JSON_FILE_NAME è il nome del file JSON che contiene le impostazioni del bucket.
   • PROJECT_IDENTIFIER è l'ID o il numero del progetto a cui verrà associato il bucket. Ad esempio, my-project.

Passaggi successivi

• Informazioni sulle cartelle.
• Creare e gestire cartelle.
• Recuperare i metadati di un bucket.
• Ottieni il layout di archiviazione di un bucket.
• Elencare ed eliminare i bucket.

Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni di Cloud Storage in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova Cloud Storage senza costi