Creare bucket con uno spazio dei nomi gerarchico abilitato

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

Crea un bucket

Questa sezione descrive come creare un bucket con il nome di spazio dei nomi gerarchico attivato.

Ruoli richiesti

Per ottenere le autorizzazioni necessarie per creare un bucket , chiedi all'amministratore di concederti il ruolo Amministratore archiviazione (roles/storage.admin) per il bucket.

Il ruolo contiene l'autorizzazione storage.buckets.create, obbligatoria per creare un bucket .

Potresti anche ottenere questa autorizzazione con altri ruoli personalizzati o ruoli predefiniti. Per sapere quali ruoli sono associati a quali autorizzazioni, consulta la sezione Ruoli IAM per Cloud Storage.

Per istruzioni su come concedere i ruoli ai bucket, consulta Utilizzare IAM con i bucket.

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 e fai clic su Continua:
1. Nella sezione Inizia:
1. Inserisci un nome univoco globale per il bucket che soddisfi i requisiti per i nomi dei bucket.
2. Per attivare lo spazio dei nomi gerarchico, fai clic sulla freccia di espansione per espandere la sezione Ottimizza per i workload orientati ai file e con uso intensivo dei dati, poi seleziona Abilita uno spazio dei nomi gerarchico in questo bucket.

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

3. (Facoltativo) Per aggiungere un'etichetta del bucket, fai clic sulla freccia di espansione per espandere la sezione Etichette, poi fai clic su Aggiungi etichetta e specifica un key e un value per l'etichetta.
2. Nella sezione Scegli dove archiviare i tuoi dati, segui questi passaggi:
1. Seleziona Regione come Tipo di località.
2. Nell'elenco Posizione, seleziona una regione in cui i dati del bucket verranno archiviati in modo permanente.
3. Nella sezione Scegli una classe di archiviazione per i tuoi dati, seleziona Imposta una classe predefinita per il bucket.

   Nota: il riquadro Stima del costo mensile nel riquadro a destra stima i costi mensili del bucket in base alla classe di archiviazione e alla località selezionate, nonché alle dimensioni e alle operazioni dei dati previste.

4. Nella sezione Scegli come controllare l'accesso agli oggetti, seleziona se il bucket deve o meno applicare la prevenzione dell'accesso pubblico e, per Controllo dell'accesso, scegli Uniforme.

   Nota: se la prevenzione dell'accesso pubblico è già applicata dal criterio dell'organizzazione del progetto, il pulsante di attivazione/disattivazione Impedisci accesso pubblico è bloccato.

5. Nella sezione Scegli come proteggere i dati degli oggetti, segui questi passaggi:
   1. Facoltativo: seleziona un metodo di protezione dei dati, ad esempio la configurazione di un criterio di eliminazione temporanea personalizzato, controllo delle versioni degli oggetti o un criterio di conservazione.
   2. Per selezionare un metodo di crittografia dei dati, fai clic sulla freccia di espansione contrassegnata come Crittografia dei dati.
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 la sezione 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, rispettando i requisiti di denominazione. Ad esempio, my-bucket.
   • BUCKET_LOCATION è la posizione del 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 in un bucket è obbligatoria per la creazione di un bucket con uno spazio dei nomi gerarchico abilitato.
   • --enable-hierarchical-namespace: abilita lo spazio dei nomi gerarchico per il bucket. Non puoi attivare 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 buckets create options.

   Ad esempio:

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

Librerie client

C++

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

Per autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 autenticarti a Cloud Storage, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta 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 installato e inizializzatogcloud CLI, che consente di generare un token di accesso per l'intestazione Authorization.

2. Crea un file JSON contenente le impostazioni per il bucket, che deve includere un name per il bucket. Consulta la documentazione di 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, rispettando i requisiti di denominazione. Ad esempio: my-bucket.
• BUCKET_LOCATION è la posizione in cui vuoi archiviare i dati sugli oggetti del bucket. Ad esempio: US-EAST1.
• STORAGE_CLASS è la classe di archiviazione predefinita del bucket. Ad esempio: STANDARD.
• hierarchicalNamespace.enabled sia impostato su TRUE per attivare lo spazio dei nomi gerarchico per il bucket. Non puoi attivare lo spazio dei nomi gerarchico in un bucket esistente.
3. uniformBucketLevelAccess.enabled sia impostato su TRUE per attivare l'accesso uniforme a livello di bucket per il bucket.
   
   Nota: l'abilitazione dell'accesso uniforme a livello di bucket in un bucket è obbligatoria per la creazione di un bucket con uno 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

• Ottieni informazioni sui metadati di un bucket.
• Ottieni informazioni sul layout dello spazio di archiviazione di un bucket.
• Informazioni sulle cartelle.
• Creare e gestire le cartelle.
• Rinominare le cartelle.
• 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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova Cloud Storage gratuitamente