Creare bucket

Questa pagina mostra come creare bucket Cloud Storage. Se non diversamente specificato nella richiesta, i bucket vengono creati nella regione US multiregionale con una classe di archiviazione predefinita Standard Storage e hanno una durata di conservazione di eliminazione soft di sette giorni.

Ruoli obbligatori

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

Questo ruolo predefinito contiene l'autorizzazione richiesta per creare un bucket. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

  • storage.buckets.create
  • storage.buckets.enableObjectRetention (obbligatorio solo se attivo le configurazioni di conservazione degli oggetti per il bucket)
  • storage.buckets.list (richiesto solo se crei un bucket utilizzando la console Google Cloud)
  • resourcemanager.projects.get (richiesto 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 la sezione Ruoli IAM per Cloud Storage.

Per istruzioni su come concedere i ruoli per i progetti, consulta Gestire l'accesso ai progetti.

Creazione di un nuovo bucket

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

Per creare 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 del bucket. Dopo ciascuno dei seguenti passaggi, fai clic su Continua per passare al passaggio successivo:

    1. Nella sezione Inizia:

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

      • 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 e poi seleziona Attiva uno spazio dei nomi gerarchico in questo 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 definitivamente 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, espandi la sezione Configura la replica tra bucket e segui i passaggi:

        Configurare la replica tra bucket

        1. Seleziona la casella di controllo accanto ad Aggiungi una replica tra bucket mediante Storage Transfer Service.
        2. Nel menu Bucket di destinazione, seleziona un bucket di destinazione.

        3. 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, quindi 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 una classe di archiviazione per i tuoi dati, seleziona una classe di archiviazione predefinita per il bucket o Autoclass per la gestione automatica della classe di archiviazione dei dati del bucket.

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

    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 scegliere la modalità di crittografia dei dati degli oggetti, fai clic sulla freccia di espansione etichettata Crittografia dei dati e seleziona un metodo di 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

    Dove:

    • BUCKET_NAME è il nome che vuoi assegnare al bucket, rispettando il requisito di denominazione. Ad esempio, my-bucket.

    • BUCKET_LOCATION è la posizione del tuo bucket. Ad esempio: us-east1.

    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 tuo 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.
    • --uniform-bucket-level-access: attiva l'accesso uniforme a livello di bucket per il 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

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

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

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

// 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 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 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 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_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 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_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

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 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",
  "iamConfiguration": {
    "uniformBucketLevelAccess": {
      "enabled": true
    },
  }
}

    Dove:

    • BUCKET_NAME è il nome che vuoi assegnare al tuo 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.

  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 installato e inizializzatogcloud CLI, che 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 relativa a XML: crea un 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 posizione in cui vuoi archiviare i dati sugli oggetti del bucket. Ad esempio, US-EAST1.

  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 tuo bucket, rispettando i requisiti di denominazione. Ad esempio, my-bucket.

    Se la richiesta ha esito positivo, 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 gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Prova Cloud Storage gratuitamente