Crea un bucket

Questa pagina mostra come creare un bucket Cloud Storage. Se non diversamente specificato nella richiesta, i bucket vengono creati nella US multi-regione con una classe di archiviazione predefinita di Standard Storage e hanno una durata di conservazione per l'eliminazione temporanea di sette giorni.

Se stai creando un bucket per la prima volta, consulta Scopri l'archiviazione di oggetti con la console Google Cloud o Scopri l'archiviazione di oggetti con Google Cloud CLI per una panoramica più completa delle attività che puoi eseguire con Cloud Storage.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare un bucket Cloud Storage, chiedi all'amministratore di concederti il ruolo IAM Storage Admin (roles/storage.admin) per il progetto.

Questo ruolo predefinito contiene l'autorizzazione necessaria per creare un bucket. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

  • storage.buckets.create
  • storage.buckets.enableObjectRetention (obbligatorio solo se abiliti le configurazioni di conservazione degli oggetti per il bucket)
  • storage.buckets.list (obbligatorio solo se crei un bucket utilizzando la console Google Cloud ).
  • resourcemanager.projects.get (obbligatorio solo se crei un bucket utilizzando la console Google Cloud )

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti. Per vedere quali ruoli sono associati a quali autorizzazioni, consulta Ruoli IAM per Cloud Storage.

Per istruzioni sulla concessione dei ruoli per i progetti, consulta Gestisci l'accesso ai progetti.

Creazione di un nuovo bucket

Per creare un bucket con impostazioni specifiche o configurazioni avanzate, completa i seguenti passaggi.

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 ogni passaggio successivo, fai clic su Continua per procedere con il passaggio successivo:

    1. Nella sezione Inizia, segui questi passaggi:

      • Inserisci un nome globalmente univoco che soddisfi i requisiti per i nomi dei bucket.

      • Per aggiungere un'etichetta del bucket, fai clic sulla freccia di espansione per espandere la sezione Etichette, 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 un Tipo di località.

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

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

      3. Per configurare la replica tra bucket, seleziona Aggiungi una replica tra bucket mediante Storage Transfer Service e segui i passaggi:

        Configura la replica tra bucket

        1. Nel menu Bucket, seleziona un bucket.

        2. Nella sezione Impostazioni di replica, fai clic su Configura per configurare le impostazioni per il job di replica.

          Viene visualizzato il riquadro Configura replica tra bucket.

          • Per filtrare gli oggetti da replicare in base al prefisso del nome dell'oggetto, inserisci un prefisso con cui vuoi includere o escludere gli oggetti, poi fai clic su Aggiungi un prefisso.
          • Per impostare una classe di archiviazione per gli oggetti replicati, seleziona una classe di archiviazione dal menu Classe di archiviazione. Se salti questo passaggio, gli oggetti replicati utilizzeranno per impostazione predefinita la classe di archiviazione del bucket di destinazione.
          • Fai clic su Fine.

    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.

        • Per attivare Rapid Cache, seleziona Attiva Rapid Cache e segui i passaggi:

          1. Per creare le cache, fai clic su Configura.

          2. Nella finestra di dialogo Configura impostazioni cache visualizzata, fai clic sulla freccia menu a discesa accanto alle regioni elencate e seleziona le zone in cui vuoi creare le cache.

          3. Fai clic su Fine.

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

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

      2. Seleziona un modello di controllo dell'accesso per gli oggetti del bucket. Ti consigliamo di selezionare Uniforme per abilitare l'accesso uniforme a livello di bucket sul bucket.

      3. Per configurare il filtro IP per il bucket, segui questi passaggi:

        1. Nella sezione Filtro IP, fai clic su  Configura.

        2. Per consentire l'accesso da indirizzi IP pubblici:

          1. Fai clic su Internet pubblico.

          2. Nel campo Intervalli IP consentiti, specifica uno o più intervalli di indirizzi IPv4 o intervalli CIDR IPv6 da consentire. Ad esempio, 192.0.2.0/24 o 2001:db8::/32.

            Per evitare di perdere l'accesso al bucket, includi il tuo indirizzo IP.

        3. Per consentire l'accesso dalle reti VPC:

          1. Fai clic su Reti VPC.

          2. Per ogni rete, segui questi passaggi:

            1. Fai clic su Aggiungi rete VPC.

            2. Nella sezione Nuova rete VPC, specifica le seguenti informazioni:

              • Nel campo ID progetto, inserisci l'ID progetto.
              • Nel campo Nome rete, inserisci il nome della rete.

              • Nel campo Intervalli IP consentiti, inserisci uno o più intervalli CIDR IPv4 o IPv6, ad esempio 192.0.2.0/24 o 2001:db8::/32.

                Per evitare di perdere l'accesso al bucket, includi il tuo indirizzo IP.

            3. Fai clic su Fine.

        4. Per consentire agli agenti di servizio Google Cloud attendibili e alle reti VPC di altre organizzazioni di ignorare la configurazione del filtro IP, procedi nel seguente modo:

          1. Fai clic su Impostazioni aggiuntive.

          2. Nella sezione Accesso del service agent Google Cloud, seleziona una delle seguenti opzioni:

            • Consenti l'accesso ai service agent: consente ai servizi Google Cloud come BigLake, Storage Insights, Vertex AI e BigQuery di ignorare la convalida del filtro IP quando devono accedere a questo bucket.
            • Nega l'accesso del service agent: applica le regole di filtro IP per i service agent Google Cloud .
          3. Nella sezione Accesso VPC tra organizzazioni, esegui una delle seguenti operazioni:
            • Per consentire l'accesso da reti VPC specificate situate in organizzazioni Google Cloud diverse, fai clic sul pulsante di attivazione/disattivazione per impostarlo sulla posizione Consenti.
            • Per bloccare l'accesso dalle reti VPC al di fuori della tua organizzazione Google Cloud , fai clic sul pulsante di attivazione/disattivazione per impostarlo sulla posizione Nega (stato predefinito).
        5. Fai clic su Rivedi e poi su Salva.

    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 per cui l'eliminazione temporanea conserva gli oggetti dopo l'eliminazione, seleziona la casella di controllo Policy di eliminazione temporanea, quindi 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:

  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

    Dove:

    • BUCKET_NAME è il nome che vuoi assegnare al bucket, soggetto ai requisiti di denominazione. Ad esempio my-bucket.

    • BUCKET_LOCATION è la località del tuo bucket. Ad esempio: US.

    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:

    Ad esempio:

    gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access
--soft-delete-duration=RETENTION_DURATION --encryption-enforcement-file=ENCRYPTION_ENFORCEMENT_FILE

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

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,
   std::string const& storage_class, std::string const& location) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.CreateBucket(bucket_name, gcs::BucketMetadata()
                                           .set_storage_class(storage_class)
                                           .set_location(location));
  if (!bucket_metadata) throw std::move(bucket_metadata).status();

  std::cout << "Bucket " << bucket_metadata->name() << " created."
            << "\nFull Metadata: " << *bucket_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 CreateRegionalBucketSample
{
    /// <summary>
    /// Creates a storage bucket with region.
    /// </summary>
    /// <param name="projectId">The ID of the project to create the buckets in.</param>
    /// <param name="location">The location of the bucket. Object data for objects in the bucket resides in 
    /// physical storage within this region. Defaults to US.</param>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="storageClass">The bucket's default storage class, used whenever no storageClass is specified
    /// for a newly-created object. This defines how objects in the bucket are stored
    /// and determines the SLA and the cost of storage. Values include MULTI_REGIONAL,
    /// REGIONAL, STANDARD, NEARLINE, COLDLINE, ARCHIVE, and DURABLE_REDUCED_AVAILABILITY.
    /// If this value is not specified when the bucket is created, it will default to
    /// STANDARD.</param>
    public Bucket CreateRegionalBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string location = "us-west1",
        string storageClass = "REGIONAL")
    {
        var storage = StorageClient.Create();
        Bucket bucket = new Bucket
        {
            Location = location,
            Name = bucketName,
            StorageClass = storageClass
        };
        var newlyCreatedBucket = storage.CreateBucket(projectId, bucket);
        Console.WriteLine($"Created {bucketName}.");
        return newlyCreatedBucket;
    }
}

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"
)

// createBucketClassLocation creates a new bucket in the project with Storage class and
// location.
func createBucketClassLocation(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()

	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINE",
		Location:     "asia",
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v\n", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	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.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class CreateBucketWithStorageClassAndLocation {
  public static void createBucketWithStorageClassAndLocation(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    // See this documentation for other valid locations:
    // http://g.co/cloud/storage/docs/bucket-locations#location-mr
    String location = "ASIA";

    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                .setStorageClass(storageClass)
                .setLocation(location)
                .build());

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in "
            + bucket.getLocation()
            + " with storage class "
            + bucket.getStorageClass());
  }
}

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';

// The name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

// The name of a location
// See this documentation for other valid locations:
// http://g.co/cloud/storage/docs/locations#location-mr
// const location = 'ASIA';

// 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 createBucketWithStorageClassAndLocation() {
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    [storageClass]: true,
  });

  console.log(
    `${bucket.name} created with ${storageClass} class in ${location}`
  );
}

createBucketWithStorageClassAndLocation().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 a custom default storage class and location.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function create_bucket_class_location(string $bucketName): void
{
    $storage = new StorageClient();
    $storageClass = 'COLDLINE';
    $location = 'ASIA';
    $bucket = $storage->createBucket($bucketName, [
        'storageClass' => $storageClass,
        'location' => $location,
    ]);

    $objects = $bucket->objects([
        'encryption' => [
            'defaultKmsKeyName' => null,
        ]
    ]);

    printf('Created bucket %s in %s with storage class %s', $bucketName, $storageClass, $location);
}

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_class_location(bucket_name):
    """
    Create a new bucket in the US region with the coldline storage
    class
    """
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "COLDLINE"
    new_bucket = storage_client.create_bucket(bucket, location="us")

    print(
        "Created bucket {} in {} with storage class {}".format(
            new_bucket.name, new_bucket.location, new_bucket.storage_class
        )
    )
    return new_bucket

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_class_location bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.create_bucket bucket_name,
                                  location:      "ASIA",
                                  storage_class: "COLDLINE"

  puts "Created bucket #{bucket.name} in #{bucket.location} with #{bucket.storage_class} class"
end

Rust

use google_cloud_storage::{client::StorageControl, model::Bucket};

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_storage_class("NEARLINE")
                .set_location("US-CENTRAL1"),
        )
        .send()
        .await?;
    println!("successfully created bucket {bucket:?}");
    Ok(())
}

Terraform

Puoi utilizzare una risorsa Terraform per creare un bucket di archiviazione.

# Create new storage bucket in the US multi-region
# with coldline storage
resource "random_id" "bucket_prefix" {
  byte_length = 8
}

resource "google_storage_bucket" "static" {
  name          = "${random_id.bucket_prefix.hex}-new-bucket"
  location      = "US"
  storage_class = "COLDLINE"

  uniform_bucket_level_access = true
}

API REST

API JSON

  1. Avere gcloud CLI installato e inizializzato, che ti 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 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",
  "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.

    • STORAGE_CLASS è la classe di archiviazione predefinita del bucket. Ad esempio: STANDARD.

  3. 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 che hai creato nel passaggio 2.
    • PROJECT_IDENTIFIER è l'ID o il numero del progetto a cui verrà associato il bucket. Ad esempio, my-project.

API XML

  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 XML contenente le impostazioni per il bucket. Consulta la documentazione XML: Create a bucket per un elenco completo delle impostazioni. Di seguito sono riportate le impostazioni comuni da includere:

    <CreateBucketConfiguration>
  <StorageClass>STORAGE_CLASS</StorageClass>
  <LocationConstraint>BUCKET_LOCATION</LocationConstraint>
</CreateBucketConfiguration>

    Dove:

    • STORAGE_CLASS è la classe di archiviazione predefinita del bucket. Ad esempio: STANDARD.

    • BUCKET_LOCATION è la località in cui vuoi archiviare i dati degli oggetti del bucket. Ad esempio US.

  3. Utilizza cURL per chiamare l'API XML:

    curl -X PUT --data-binary @XML_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "x-goog-project-id: PROJECT_ID" \
  "https://storage.googleapis.com/BUCKET_NAME"

    Dove:

    • XML_FILE_NAME è il nome del file XML che hai creato nel passaggio 2.
    • PROJECT_ID è l'ID del progetto a cui verrà associato il bucket. Ad esempio, my-project.
    • BUCKET_NAME è il nome che vuoi assegnare al bucket, soggetto ai requisiti di denominazione. Ad esempio my-bucket.

    Se la richiesta è andata a buon fine, non viene restituita alcuna risposta.

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

Prova Cloud Storage senza costi