Crea un bucket

Console

1. En la consola de Trusted Cloud , ve a la página Buckets de Cloud Storage.
   

   Ir a Buckets

2. Haz clic en add_box Crear.

3. En la página Crear un bucket, ingresa la información de tu bucket. Después de cada uno de los siguientes pasos, haz clic en Continuar para avanzar al siguiente paso:

   1. En la sección Primeros pasos, haz lo siguiente:

      • Ingresa un nombre único a nivel global que cumpla con los requisitos de nombre de los buckets.

      • Para agregar una etiqueta de bucket, haz clic en la flecha desplegable expand_more para expandir la sección Etiquetas, haz clic en add_box Agrega etiqueta y especifica una key y un value para tu etiqueta.

   2. En la sección Eligir dónde almacenar tus datos, haz lo siguiente:

      1. Selecciona un tipo de ubicación

      2. Usa el menú desplegable del tipo de ubicación para seleccionar una Ubicación en la que se almacenarán de forma permanente los datos de objetos de tu bucket.

         • Si seleccionas el tipo de ubicación birregional, también puedes habilitar la replicación turbo con la casilla de verificación correspondiente.

   3. En la sección Elige cómo almacenar tus datos, haz lo siguiente:

      1. Selecciona una clase de almacenamiento predeterminada para el bucket o Autoclass para la administración automática de clases de almacenamiento de los datos de tu bucket.

   4. En la sección Optimiza el almacenamiento para cargas de trabajo con uso intensivo de datos, haz lo siguiente:

      1. Para habilitar el espacio de nombres jerárquico, selecciona Habilita el espacio de nombres jerárquico en este bucket.

      2. Para habilitar Anywhere Cache, selecciona Habilitar Anywhere Cache.

         1. Para crear cachés, haz clic en Configurar.

         2. En el cuadro de diálogo Configurar parámetros de configuración de la caché que aparece, haz clic en la flecha desplegable junto a las regiones enumeradas y selecciona las zonas en las que deseas crear cachés.

         3. Haz clic en Listo.

   5. Haz clic en Continuar.

   6. En la sección Elige cómo controlar el acceso a los objetos, selecciona si tu bucket aplica o no la prevención del acceso público y elige un modelo de control de acceso para los objetos del bucket.

   7. En la sección Elige cómo proteger los datos de objetos, haz lo siguiente:

      • Selecciona cualquiera de las opciones de Protección de datos que desees configurar para tu bucket.

      • Para habilitar la eliminación no definitiva, haz clic en la flecha del expansor expand_more etiquetada como Política de eliminación no definitiva y especifica la cantidad de días que deseas retener los objetos después de la eliminación.

      • Para elegir cómo se encriptarán los datos de tus objetos, haz clic en la flecha desplegable expand_more etiquetada como Encriptación de datos y selecciona un método de encriptación de datos.

4. Haz clic en Crear.

Para obtener información sobre cómo ver detalles de errores acerca de operaciones fallidas de Cloud Storage en la Trusted Cloud consola, consulta Solución de problemas.

Línea 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. En tu entorno de desarrollo, ejecuta el comando gcloud storage buckets create:

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

   Aquí:

   • BUCKET_NAME es el nombre que quieres asignar a tu bucket, sujeto a los requisitos de nomenclatura. Por ejemplo, my-bucket.

   • BUCKET_LOCATION es la ubicación de tu bucket. Por ejemplo, U-FRANCE-EAST1.

   Si la solicitud se realiza correctamente, el comando mostrará el siguiente mensaje:

   Creating gs://BUCKET_NAME/...

   Configura las siguientes marcas para tener un mayor control sobre la creación de tu bucket:

   • --project: Especifica el ID o el número del proyecto con el que se asociará el bucket. Por ejemplo, my-project
   • --default-storage-class: Especifica la clase de almacenamiento predeterminada de tu bucket. Por ejemplo, STANDARD.
   • --uniform-bucket-level-access: Habilita el acceso uniforme a nivel de bucket para el bucket.
   • --soft-delete-duration: Especifica una duración de retención de borrar de forma no definitiva, que es la cantidad de días que deseas retener los objetos después de que se borren. Por ejemplo, 10d.

   Por ejemplo:

   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 obtener una lista completa de las opciones de creación de buckets con gcloud CLI, consulta Opciones de buckets create.

Bibliotecas cliente

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C++.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Antes de ejecutar muestras de código, configura la variable de entorno GOOGLE_CLOUD_UNIVERSE_DOMAIN 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#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage C#.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Antes de ejecutar muestras de código, configura la variable de entorno GOOGLE_CLOUD_UNIVERSE_DOMAIN 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Go.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Antes de ejecutar muestras de código, configura la variable de entorno GOOGLE_CLOUD_UNIVERSE_DOMAIN 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Java.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Antes de ejecutar muestras de código, configura la variable de entorno GOOGLE_CLOUD_UNIVERSE_DOMAIN 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Node.js.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Antes de ejecutar muestras de código, configura la variable de entorno GOOGLE_CLOUD_UNIVERSE_DOMAIN 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage PHP.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Antes de ejecutar muestras de código, configura la variable de entorno GOOGLE_CLOUD_UNIVERSE_DOMAIN 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Python.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Antes de ejecutar muestras de código, configura la variable de entorno GOOGLE_CLOUD_UNIVERSE_DOMAIN 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

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage Ruby.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para bibliotecas cliente.

Antes de ejecutar muestras de código, configura la variable de entorno GOOGLE_CLOUD_UNIVERSE_DOMAIN 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

Puedes usar un recurso de Terraform para crear un bucket de almacenamiento.

# 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 de REST

API de JSON

1. Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization.

2. Crea un archivo JSON que contenga la configuración del bucket, que debe incluir un name para el bucket. Consulta la documentación de Buckets:Insert para obtener una lista completa de opciones de configuración. A continuación, se indican las opciones de configuración comunes que puedes incluir:

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

   Donde:

   • BUCKET_NAME es el nombre que quieres asignar a tu bucket, sujeto a los requisitos de nomenclatura. Por ejemplo, my-bucket.

   • BUCKET_LOCATION es la ubicación en la que deseas almacenar los datos de objeto de tu bucket. Por ejemplo, U-FRANCE-EAST1

   • STORAGE_CLASS es la clase de almacenamiento predeterminada de tu bucket. Por ejemplo, STANDARD.

3. Usa cURL para llamar a la API de 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"

   Donde:

   • JSON_FILE_NAME es el nombre del archivo JSON que creaste en el paso 2.
   • PROJECT_IDENTIFIER es el ID o el número del proyecto al que se asociará el bucket. Por ejemplo, my-project.

API de XML

1. Tener la gcloud CLI instalada e inicializada, lo que te permite generar un token de acceso para el encabezado Authorization.

2. Crea un archivo XML que contenga la configuración del bucket. Consulta la documentación de XML: Crea un bucket para obtener una lista completa de parámetros de configuración. A continuación, se indican las opciones de configuración comunes que puedes incluir:

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

   Donde:

   • STORAGE_CLASS es la clase de almacenamiento predeterminada de tu bucket. Por ejemplo, STANDARD.

   • BUCKET_LOCATION es la ubicación en la que deseas almacenar los datos de objeto de tu bucket. Por ejemplo, U-FRANCE-EAST1

3. Usa cURL para llamar a la API de 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"

   Donde:

   • XML_FILE_NAME es el nombre del archivo XML que creaste en el paso 2.
   • PROJECT_ID es el ID del proyecto al que se asociará tu bucket. Por ejemplo, my-project
   • BUCKET_NAME es el nombre que quieres asignar a tu bucket, sujeto a los requisitos de nomenclatura. Por ejemplo, my-bucket.

   Si la solicitud fue exitosa, no se mostrará una respuesta.