Creare e gestire bucket con spazio dei nomi gerarchico abilitato

Questa pagina descrive come creare, elencare ed eliminare i bucket con spazio dei nomi gerarchico abilitato.

Crea un bucket

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

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 e fai clic su Continua:
    1. Nella sezione Inizia, segui questi passaggi:
      1. Inserisci un nome di bucket univoco a livello globale che soddisfi le requisiti per i nomi dei bucket.
      2. Per attivare lo spazio dei nomi gerarchico (anteprima), fai clic sulla freccia di espansione per espandere la sezione Ottimizza per carichi di lavoro orientati ai file e con uso intensivo di dati, quindi 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 Località, seleziona una regione in cui verranno archiviati definitivamente i dati del bucket.
    3. Nella sezione Scegli una classe di archiviazione per i tuoi dati, seleziona una classe di archiviazione predefinita per il bucket o seleziona Autoclass per la gestione automatica della classe di archiviazione dei dati del bucket.

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

    4. Nella sezione Scegli come controllare l'accesso agli oggetti, scegli se il tuo bucket applica la prevenzione dell'accesso pubblico e In 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, del controllo delle versioni degli oggetti o di un criterio di conservazione.
      2. Per selezionare un metodo di crittografia dei dati: fai clic sull'espansione a forma di freccia 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 alpha storage buckets create:

    gcloud alpha 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 a 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.
    • --enable-hierarchical-namespace: attiva lo spazio dei nomi gerarchico per lo di sincronizzare la directory di una VM con un 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 o il numero di progetto a cui sarà associato il bucket. Ad esempio, my-project.
    • --default-storage-class: specifica lo spazio di archiviazione predefinito del bucket. Ad esempio: STANDARD.

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

    Ad esempio:

    gcloud alpha 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 ulteriori informazioni, consulta API Cloud Storage C++ documentazione di riferimento.

Per autenticarti a Cloud Storage, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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";
}

Go

Per ulteriori informazioni, consulta API Cloud Storage Go documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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 ulteriori informazioni, consulta API Cloud Storage Java documentazione di riferimento.

Per autenticarti a Cloud Storage, configura le credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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 ulteriori informazioni, consulta API Cloud Storage Node.js documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * 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 ulteriori informazioni, consulta la documentazione di riferimento dell'API Cloud Storage PHP.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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 ulteriori informazioni, consulta API Cloud Storage Python documentazione di riferimento.

Per autenticarti a Cloud Storage, configura le credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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 ulteriori informazioni, consulta API Cloud Storage Ruby documentazione di riferimento.

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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 inizializzato l'interfaccia a riga di comando gcloud, 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:
    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 tuo bucket.
  4. Utilizza cURL per chiamare il metodo 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 che contiene le impostazioni del bucket.
    • PROJECT_IDENTIFIER è l'ID o il numero del progetto a cui sarà associato il bucket. Ad esempio, my-project.

Il layout di archiviazione di un bucket descrive il modo in cui gli oggetti sono disposti all'interno di un bucket, in un o uno spazio dei nomi gerarchico. Per istruzioni sulla visualizzazione di un di archiviazione del bucket, consulta Ottenere il layout di archiviazione di un bucket.

Per elencare tutti i bucket, indipendentemente dal loro layout di archiviazione, segui le istruzioni dettagliate in Elenca i bucket.

Puoi eliminare un bucket con spazio dei nomi gerarchico abilitato nello stesso modo di qualsiasi altro bucket. Ai fini dell'eliminazione, se un bucket è abilitato con lo spazio dei nomi gerarchico contiene solo cartelle vuote e nessun oggetto o cartelle gestite, il bucket è considerato vuoto. Per istruzioni su come eliminare i bucket, consulta Eliminare i bucket.

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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova Cloud Storage gratuitamente