Crie um contentor

Consola

1. Na Google Cloud consola, aceda à página Recipientes do Cloud Storage.
   

   Aceda a Recipientes

2. Clique em add_box Criar.
3. Na página Criar um depósito, introduza as informações do depósito. Após cada um dos passos seguintes, clique em Continuar para avançar para o passo seguinte:

   1. Na secção Começar, faça o seguinte:

      • Introduza um nome globalmente exclusivo que cumpra os requisitos do nome do contentor.

      • Para adicionar uma etiqueta de grupo, clique na seta de expansão expand_more para expandir a secção Etiquetas, clique em add_box Adicionar etiqueta e especifique um key e um value para a sua etiqueta.

   2. Na secção Escolha onde quer armazenar os seus dados, faça o seguinte:

      1. Selecione um Tipo de localização.

      2. Use o menu pendente do tipo de localização para selecionar uma Localização onde os dados de objetos no seu contentor vão ser armazenados permanentemente.

         • Se selecionar o tipo de localização dupla região, também pode optar por ativar a replicação turbo através da caixa de verificação relevante.

      3. Para configurar a replicação entre contentores, selecione Adicionar replicação entre contentores através do Serviço de transferência de armazenamento e siga os passos:

         Configure a replicação entre contentores

         1. No menu Recipiente, selecione um recipiente.

         2. Na secção Definições de replicação, clique em Configurar para configurar as definições da tarefa de replicação.

            É apresentado o painel Configurar replicação entre contentores.

            • Para filtrar objetos a replicar por prefixo do nome do objeto, introduza um prefixo com o qual quer incluir ou excluir objetos e, de seguida, clique em add Adicionar um prefixo.
            • Para definir uma classe de armazenamento para os objetos replicados, selecione uma classe de armazenamento no menu Classe de armazenamento. Se ignorar este passo, os objetos replicados usam a classe de armazenamento do contentor de destino por predefinição.
            • Clique em Concluído.

   3. Na secção Escolha como armazenar os seus dados, faça o seguinte:

      1. Selecione uma classe de armazenamento predefinida para o contentor ou o Autoclass para a gestão automática da classe de armazenamento dos dados do contentor.

      2. Na secção Otimize o armazenamento para cargas de trabalho com grande volume de dados, faça o seguinte:

         1. Para ativar o espaço de nomes hierárquico, selecione Ativar espaço de nomes hierárquico neste contentor.

         2. Para ativar a cache em qualquer lugar, selecione Ativar cache em qualquer lugar e siga os passos:

            1. Para criar caches, clique em Configurar.

            2. Na caixa de diálogo Configurar definições de cache apresentada, clique na seta de menu pendente junto às regiões apresentadas e selecione as zonas onde quer criar caches.

            3. Clique em Concluído.

   4. Na secção Escolha como controlar o acesso aos objetos, selecione se o seu contentor aplica a prevenção de acesso público e selecione um modelo de controlo de acesso para os objetos do contentor.

   5. Na secção Escolha como proteger os dados de objetos, faça o seguinte:

      • Selecione qualquer uma das opções em Proteção de dados que queira definir para o seu contentor.

      • Para ativar a eliminação temporária, clique na seta de expansão expand_more com a etiqueta Política de eliminação temporária e especifique o número de dias que quer reter objetos após a eliminação.

      • Para escolher como os dados de objetos vão ser encriptados, clique na seta de expansão expand_more com a etiqueta Encriptação de dados e selecione um método de encriptação de dados.

4. Clique em Criar.

Para saber como obter informações detalhadas sobre erros relativos a operações do Cloud Storage falhadas na Google Cloud consola, consulte a secção Resolução de problemas.

Linha de comandos

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. No seu ambiente de programação, execute o comando gcloud storage buckets create:

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

   Onde:

   • BUCKET_NAME é o nome que quer dar ao seu contentor, sujeito aos requisitos de nomenclatura. Por exemplo, my-bucket.

   • BUCKET_LOCATION é a localização do seu contentor. Por exemplo, US.

   Se o pedido for bem-sucedido, o comando devolve a seguinte mensagem:

   Creating gs://BUCKET_NAME/...

   Defina as seguintes flags para ter maior controlo sobre a criação do seu contentor:

   • --project: especifique o ID do projeto ou o número do projeto ao qual o seu contentor vai ser associado. Por exemplo, my-project.
   • --default-storage-class: especifique a classe de armazenamento predefinida do seu contentor. Por exemplo, STANDARD.
   • --uniform-bucket-level-access: ative o acesso uniforme ao nível do contentor para o seu contentor.
   • --soft-delete-duration: especifique uma duração de retenção de eliminação temporária, que é o número de dias durante os quais quer reter objetos após a respetiva eliminação. Por exemplo, 10d.

   Por exemplo:

   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
   

   Para uma lista completa das opções de criação de contentores, use a CLI gcloud. Consulte as opções buckets create.

Bibliotecas cliente

C++

Para mais informações, consulte a documentação de referência da API C++ do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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#

Para mais informações, consulte a documentação de referência da API C# do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para mais informações, consulte a documentação de referência da API Go do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para mais informações, consulte a documentação de referência da API Java do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para mais informações, consulte a documentação de referência da API Node.js do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para mais informações, consulte a documentação de referência da API PHP do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para mais informações, consulte a documentação de referência da API Python do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Para mais informações, consulte a documentação de referência da API Ruby do Cloud Storage.

Para se autenticar no Cloud Storage, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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

Pode usar um recurso do Terraform para criar um contentor de armazenamento.

# 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
}

APIs REST

API JSON

1. Ter a CLI gcloud instalada e inicializada, o que lhe permite gerar um token de acesso para o cabeçalho Authorization.

2. Crie um ficheiro JSON que contenha as definições do contentor, que tem de incluir um name para o contentor. Consulte a documentação Buckets:Insert para ver uma lista completa das definições. Seguem-se as definições comuns a incluir:

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

   Onde:

   • BUCKET_NAME é o nome que quer dar ao seu contentor, sujeito aos requisitos de nomenclatura. Por exemplo, my-bucket.

   • BUCKET_LOCATION é a localização onde quer armazenar os dados de objetos do seu contentor. Por exemplo, US.

   • STORAGE_CLASS é a classe de armazenamento predefinida do seu contentor. Por exemplo, STANDARD.

3. Use cURL para chamar a 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./storage/v1/b?project=PROJECT_IDENTIFIER"

   Onde:

   • JSON_FILE_NAME é o nome do ficheiro JSON que criou no passo 2.
   • PROJECT_IDENTIFIER é o ID ou o número do projeto ao qual o seu contentor vai ser associado. Por exemplo, my-project.

API XML

1. Ter a CLI gcloud instalada e inicializada, o que lhe permite gerar um token de acesso para o cabeçalho Authorization.

2. Crie um ficheiro XML que contenha as definições do contentor. Consulte a documentação XML: crie um contentor para ver uma lista completa das definições. Seguem-se as definições comuns a incluir:

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

   Onde:

   • STORAGE_CLASS é a classe de armazenamento predefinida do seu contentor. Por exemplo, STANDARD.

   • BUCKET_LOCATION é a localização onde quer armazenar os dados de objetos do seu contentor. Por exemplo, US.

3. Use cURL para chamar a 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./BUCKET_NAME"

   Onde:

   • XML_FILE_NAME é o nome do ficheiro XML que criou no passo 2.
   • PROJECT_ID é o ID do projeto ao qual o seu contentor vai ser associado. Por exemplo, my-project.
   • BUCKET_NAME é o nome que quer dar ao seu contentor, sujeito aos requisitos de nomenclatura. Por exemplo, my-bucket.

   Se o pedido for bem-sucedido, não é devolvida nenhuma resposta.