Creare bucket

Questa pagina mostra come creare bucket Cloud Storage. In caso contrario altrimenti specificati nella richiesta, i bucket vengono creati US (più regioni) con una classe di archiviazione predefinita Standard Storage con una durata di conservazione dell'eliminazione temporanea 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 vedere con esattezza le autorizzazioni necessarie, espandi la sezione Sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

  • storage.buckets.create
  • storage.buckets.enableObjectRetention (richiesto solo se l'abilitazione delle configurazioni di conservazione degli oggetti per il bucket)
  • storage.buckets.list (richiesto solo se la creazione di un utilizzando la console Google Cloud)
  • resourcemanager.projects.get (richiesto solo se la creazione di un 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 i 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 strumento Google Cloud CLI.

Per creare bucket con impostazioni specifiche o configurazioni avanzate, completa segui questi passaggi:

Console

  1. Nella console Google Cloud, vai alla pagina Bucket di Cloud Storage.

    Vai a Bucket

  2. Fai clic su Crea.

  3. Nella pagina Crea un bucket, inserisci le informazioni del bucket. Dopo il giorno in ciascuno dei passaggi successivi, fai clic su Continua per procedere con passaggio:

    1. Nella sezione Inizia, segui questi passaggi:

      • Inserisci un nome globalmente univoco che soddisfi i requisiti 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 carichi di lavoro orientati ai file e con uso intensivo di 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 Configura la replica tra bucket e segui questi passaggi:

        Configura 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, seleziona indipendentemente dal fatto che il bucket applichi 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, procedi nel seguente modo: seguenti:

      • In Protezione dei dati, seleziona una delle opzioni che vuoi da impostare per il bucket.

      • Per scegliere il modo in cui i dati dell'oggetto verranno criptati, fai clic sull'icona Freccia di espansione con l'etichetta Crittografia dei dati e seleziona una Metodo di crittografia dei dati.

  4. Fai clic su Crea.

Scopri come ottenere informazioni dettagliate sugli errori di Cloud Storage non riusciti nella console Google Cloud, vedi 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 Comando gcloud storage buckets create:

    gcloud storage buckets create gs://BUCKET_NAME --location=BUCKET_LOCATION

    Dove:

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

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

    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 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: abilita l'accesso uniforme a livello di bucket per il tuo 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 la gcloud CLI, consulta le opzioni buckets create.

Librerie client

C++

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

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare 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,
   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 ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


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 ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare 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.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 ulteriori informazioni, consulta API Cloud Storage Node.js documentazione di riferimento.

Per autenticarti a Cloud Storage, configura le credenziali predefinite dell'applicazione. Per ulteriori 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';

// 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 su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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

Per eseguire l'autenticazione su Cloud Storage, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

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 ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

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 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, 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 per includere:

    {
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS",
  "iamConfiguration": {
    "uniformBucketLevelAccess": {
      "enabled": true
    },
  }
}

    Dove:

    • BUCKET_NAME è il nome che vuoi assegnare del bucket, in base ai requisiti di denominazione. Ad esempio, my-bucket.

    • BUCKET_LOCATION è la località in cui vuoi archiviare i dati dell'oggetto del tuo bucket. Ad esempio: US-EAST1.

    • STORAGE_CLASS è l'impostazione predefinita classe di archiviazione del tuo 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 installato e inizializzato, che consente generi 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 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 del bucket, in base ai requisiti di denominazione. Ad esempio, my-bucket.

    Se la richiesta ha esito positivo, non viene restituita una 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