Crie um contentor

Esta página mostra como criar um contentor do Cloud Storage. Salvo indicação em contrário no seu pedido, os contentores são criados na USmultirregião com uma classe de armazenamento predefinida de armazenamento padrão e têm uma duração de retenção de eliminação temporária de sete dias.

Funções necessárias

Para receber as autorizações necessárias para criar um contentor do Cloud Storage, peça ao administrador para lhe conceder a função de administrador do armazenamento (roles/storage.admin) do IAM para o projeto.

Esta função predefinida contém a autorização necessária para criar um contentor. Para ver as autorizações exatas necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

  • storage.buckets.create
  • storage.buckets.enableObjectRetention (apenas necessário se ativar as configurações de retenção de objetos para o contentor)
  • storage.buckets.list (só é necessário se criar um contentor através da consola.) Google Cloud
  • resourcemanager.projects.get (apenas necessário se criar um contentor através da consola) Google Cloud

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas. Para ver que funções estão associadas a que autorizações, consulte o artigo Funções de IAM para o Cloud Storage.

Para obter instruções sobre como conceder funções para projetos, consulte o artigo Gerir o acesso a projetos.

Crie um novo contentor

Se estiver a criar um contentor pela primeira vez, consulte o artigo Descubra o armazenamento de objetos com a Google Cloud consola ou Descubra o armazenamento de objetos com a ferramenta Google Cloud CLI.

Para criar um contentor com definições específicas ou configurações avançadas, conclua os seguintes passos:

Consola

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

    Aceda a Recipientes

  2. Clique em 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 contentor, clique na seta de expansão para expandir a secção Etiquetas, clique em Adicionar etiqueta e especifique um key e um value para a 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.

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

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

        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.

    5. Clique em Continuar.

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

    7. 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 quer definir para o seu contentor.

      • Para ativar a eliminação temporária, clique na seta de expansão 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 do expansor 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 bucket. 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.

    3. 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.googleapis.com/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.googleapis.com/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.

O que se segue?

Experimente

Se está a usar o Google Cloud pela primeira vez, crie uma conta para avaliar o desempenho do Cloud Storage em cenários reais. Os novos clientes também recebem 300 USD em créditos gratuitos para executar, testar e implementar cargas de trabalho.

Experimentar o Cloud Storage gratuitamente