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 del bucket. Dopo ogni passaggio seguente, fai clic su Continua per passare al passaggio successivo:

   1. Nella sezione Inizia, segui questi passaggi:

      • Inserisci un nome univoco globale che soddisfi i requisiti per i nomi dei 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 doppia regione, 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:

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

            Nota:non puoi abilitare lo spazio dei nomi gerarchico in un bucket esistente.

         2. Nella sezione Scegli come controllare l'accesso agli oggetti, seleziona se il bucket applica o meno la prevenzione dell'accesso pubblico e seleziona l'accesso uniforme a livello di bucket per gli oggetti del bucket.

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

         3. 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 Criterio di eliminazione temporanea e poi seleziona l'opzione Imposta durata di conservazione personalizzata. Poi, 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 Policy di eliminazione temporanea.

            • Per scegliere come criptare i dati degli oggetti, fai clic sulla freccia di espansione con l'etichetta Crittografia dei dati e seleziona un metodo di crittografia dei dati.

      3. 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: attiva 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 riesce, 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 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, {}}, absl::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

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 relativa a Buckets: Insert 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 posizione in cui vuoi archiviare i dati degli oggetti del bucket. Ad esempio: US-EAST1.
• STORAGE_CLASS è la classe di archiviazione predefinita del 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 bucket.
   
   Nota: l'abilitazione dell'accesso uniforme a livello di bucket è obbligatoria per creare un bucket con lo spazio dei nomi gerarchico abilitato.
4. Utilizza cURL per chiamare l'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"

   Dove:

   • JSON_FILE_NAME è il nome del file JSON contenente 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.
• Recupera i metadati di un bucket.
• Ottieni il layout di archiviazione di un bucket.
• Elenca ed elimina 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 workload.

Prova Cloud Storage senza costi