Creazione di bucket

Questa pagina mostra come creare bucket di Cloud Storage. Se non diversamente specificato nella richiesta, i bucket vengono creati in US più regioni con una classe di archiviazione predefinita Standard Storage e hanno una durata di conservazione di 7 giorni per l'eliminazione temporanea.

Ruoli obbligatori

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

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

Autorizzazioni obbligatorie

storage.buckets.create
storage.buckets.enableObjectRetention (richiesto solo se si abilitano le configurazioni di conservazione degli oggetti per il bucket)
storage.buckets.list (richiesto solo se si crea un bucket utilizzando la console Google Cloud)
resourcemanager.projects.get (richiesto solo se si crea un bucket utilizzando la console Google Cloud)

Potresti essere in grado di ottenere queste autorizzazioni anche con i ruoli personalizzati o altri ruoli predefiniti. Per sapere quali ruoli sono associati a quali autorizzazioni, consulta Ruoli IAM per Cloud Storage.

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

Creazione di un nuovo bucket

Console

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

Vai a Bucket
Fai clic su + Crea.
Nella pagina Crea un bucket, inserisci le informazioni del bucket. Per andare al passaggio successivo, fai clic su Continua.
- In Assegna un nome al bucket, inserisci un nome che soddisfi i requisiti per i nomi dei bucket.
- Per Scegli dove archiviare i tuoi dati, seleziona un tipo di località e una località in cui verranno archiviati definitivamente i dati del bucket.
- In Scegli una classe di archiviazione per i tuoi dati, seleziona una classe di archiviazione predefinita per il bucket oppure Autoclass per la gestione automatica della classe di archiviazione dei dati del bucket.
  Nota:il riquadro Stima del costo mensile nel riquadro di destra stima i costi mensili del bucket in base alla classe di archiviazione e alla località selezionate, nonché alle dimensioni e alle operazioni previste per i dati.
- Per Scegli come controllare l'accesso agli oggetti, scegli se il bucket deve applicare o meno la prevenzione dell'accesso pubblico e seleziona un modello di controllo dell'accesso per gli oggetti del bucket.
  Nota: se la prevenzione dell'accesso pubblico è già applicata dal criterio dell'organizzazione del progetto, l'opzione di attivazione/disattivazione Impedisci l'accesso pubblico è bloccata.
- Per Scegli come proteggere i dati degli oggetti, se vuoi configura Strumenti di protezione e seleziona un metodo di crittografia dei dati.
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

Nella console Google Cloud, attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.
Nel tuo 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 bucket. Ad esempio: us-east1.
Se la richiesta ha esito positivo, il comando restituisce il seguente messaggio:
```
Creating gs://BUCKET_NAME/...
```
Imposta i flag seguenti per avere un maggiore controllo sulla creazione del bucket:
- --project: specifica l'ID o il numero del progetto a cui sarà associato il bucket. Ad esempio, my-project.
- --default-storage-class: specifica la classe di archiviazione predefinita del tuo bucket. Ad esempio: STANDARD.
- --soft-delete-duration: specifica la durata di conservazione per l'eliminazione temporanea del tuo bucket. Ad esempio: 2w1d.
- --uniform-bucket-level-access: abilita 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
```

Librerie client

C++

Per maggiori informazioni, consulta la documentazione di riferimento dell'API C++ di Cloud Storage.

Per eseguire l'autenticazione in Cloud Storage, configura Credenziali predefinite dell'applicazione. Per maggiori 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 maggiori informazioni, consulta la documentazione di riferimento dell'API C# di Cloud Storage.


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 maggiori informazioni, consulta la documentazione di riferimento dell'API Go di Cloud Storage.

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 maggiori informazioni, consulta la documentazione di riferimento dell'API Java di Cloud Storage.

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

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

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 maggiori informazioni, consulta la documentazione di riferimento dell'API Python di Cloud Storage.

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 maggiori informazioni, consulta la documentazione di riferimento dell'API Ruby di Cloud Storage.

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

Assicurati che gcloud CLI sia installato e inizializzato per generare un token di accesso per l'intestazione Authorization.

In alternativa, puoi creare un token di accesso utilizzando OAuth 2.0 Playground e includerlo nell'intestazione Authorization.
Crea un file JSON contenente le impostazioni per il bucket, che deve includere un valore name per il bucket. Consulta la documentazione relativa a Buckets:Insert per un elenco completo delle impostazioni. Di seguito sono riportate le impostazioni più 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-EAST1.
STORAGE_CLASS è la classe di archiviazione predefinita del tuo bucket. Ad esempio: STANDARD.

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 sarà associato il tuo bucket. Ad esempio, my-project.

API XML

Assicurati che gcloud CLI sia installato e inizializzato per generare un token di accesso per l'intestazione Authorization.

In alternativa, puoi creare un token di accesso utilizzando OAuth 2.0 Playground e includerlo nell'intestazione Authorization.
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 più comuni da includere:

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

Dove:

BUCKET_LOCATION è la località in cui vuoi archiviare i dati degli oggetti del bucket. Ad esempio: US-EAST1.
STORAGE_CLASS è la classe di archiviazione predefinita del tuo bucket. Ad esempio: STANDARD.

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.

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 gratis