Creare bucket con uno spazio dei nomi gerarchico abilitato

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

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) nel 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:

    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.

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

        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 attivare l'eliminazione temporanea, fai clic sulla freccia di espansione etichettata Criterio di eliminazione temporanea e specifica il numero di giorni per cui vuoi conservare gli oggetti dopo l'eliminazione.

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

    3. 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 Configurare 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 Configurare 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 Configurare 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 Configurare 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 Configurare 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 Configurare 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 Configurare 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 Configurare 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 Bucket: Inserisci per un elenco completo delle impostazioni. Di seguito sono riportate le impostazioni comuni da includere:
      3. {
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS",
  "hierarchicalNamespace": {
    "enabled": "BOOLEAN"
  },
  "iamConfiguration": {
    "uniformBucketLevelAccess": {
      "enabled": true
  },
},
}

      Dove:

    3. uniformBucketLevelAccess.enabled è impostato su TRUE per abilitare l'accesso uniforme a livello di bucket per il bucket.
    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

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 per l'esecuzione, il test e il deployment di workload senza costi aggiuntivi.

Prova Cloud Storage gratuitamente