Crie um contentor

Consola

1. Na Trusted 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 contentor, 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 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. 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 expand_more 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 expand_more 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 Trusted Cloud consola, consulte a secção Resolução de problemas.

Linha de comandos

1. In the Trusted Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Trusted 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, U-FRANCE-EAST1.

   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.

Antes de executar exemplos de código, defina a variável GOOGLE_CLOUD_UNIVERSE_DOMAIN environment como s3nsapis.fr.

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.

Antes de executar exemplos de código, defina a variável GOOGLE_CLOUD_UNIVERSE_DOMAIN environment como s3nsapis.fr.

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.

Antes de executar exemplos de código, defina a variável GOOGLE_CLOUD_UNIVERSE_DOMAIN environment como s3nsapis.fr.

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.

Antes de executar exemplos de código, defina a variável GOOGLE_CLOUD_UNIVERSE_DOMAIN environment como s3nsapis.fr.

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.

Antes de executar exemplos de código, defina a variável GOOGLE_CLOUD_UNIVERSE_DOMAIN environment como s3nsapis.fr.

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

Antes de executar exemplos de código, defina a variável GOOGLE_CLOUD_UNIVERSE_DOMAIN environment como s3nsapis.fr.

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.

Antes de executar exemplos de código, defina a variável GOOGLE_CLOUD_UNIVERSE_DOMAIN environment como s3nsapis.fr.

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.

Antes de executar exemplos de código, defina a variável GOOGLE_CLOUD_UNIVERSE_DOMAIN environment como s3nsapis.fr.

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, U-FRANCE-EAST1.

   • 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.s3nsapis.fr/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, U-FRANCE-EAST1.

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.s3nsapis.fr/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.