Crear un segmento

Consola

1. En la Google Cloud consola, ve a la página Segmentos de Cloud Storage.
   

   Ir a Contenedores

2. Haz clic en add_box Crear.
3. En la página Crear un segmento, introduce la información del segmento. Después de cada uno de los pasos siguientes, haga clic en Continuar para pasar al siguiente:

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

      • Introduce un nombre único a nivel global que cumpla los requisitos de nombres de segmentos.

      • Para añadir una etiqueta de contenedor, haz clic en la flecha de expansión expand_more para desplegar la sección Etiquetas, haz clic en add_box Añadir etiqueta y especifica un key y un value para la etiqueta.

   2. En la sección Elige dónde quieres almacenar los 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 donde se almacenarán de forma permanente los datos de los objetos de tu segmento.

         • Si selecciona el tipo de ubicación de dos regiones, también puede habilitar la replicación turbo marcando la casilla correspondiente.

      3. Para configurar la replicación entre contenedores, seleccione Añadir replicación entre contenedores mediante el Servicio de transferencia de Storage y siga estos pasos:

         Configurar la replicación entre segmentos

         1. En el menú Contenedor, selecciona un contenedor.

         2. En la sección Configuración de la replicación, haz clic en Configurar para configurar los ajustes del trabajo de replicación.

            Aparecerá el panel Configurar la replicación entre contenedores.

            • Para filtrar los objetos que se van a replicar por prefijo de nombre de objeto, introduce un prefijo con el que quieras incluir o excluir objetos y, a continuación, haz clic en add Añadir prefijo.
            • Para definir una clase de almacenamiento para los objetos replicados, selecciona una clase de almacenamiento en el menú Clase de almacenamiento. Si te saltas este paso, los objetos replicados usarán la clase de almacenamiento del segmento de destino de forma predeterminada.
            • Haz clic en Listo.

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

      1. Selecciona una clase de almacenamiento predeterminada para el segmento o Autoclass para gestionar automáticamente la clase de almacenamiento de los datos del segmento.

      2. En la sección Optimizar el almacenamiento para cargas de trabajo con gran cantidad de datos, haga lo siguiente:

         1. Para habilitar el espacio de nombres jerárquico, selecciona Habilitar espacio de nombres jerárquico en este segmento.

         2. Para habilitar Caché en cualquier lugar, selecciona Habilitar caché en cualquier lugar y sigue estos pasos:

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

            2. En el cuadro de diálogo Configurar ajustes de caché que aparece, haz clic en la flecha desplegable situada junto a las regiones de la lista y selecciona las zonas en las que quieras crear cachés.

            3. Haz clic en Listo.

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

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

      • Selecciona cualquiera de las opciones de Protección de datos que quieras configurar para tu contenedor.

      • Para habilitar la eliminación no definitiva, haz clic en expand_more flecha de expansión etiquetada como Política de eliminación no definitiva y especifica el número de días que quieras conservar los objetos después de la eliminación.

      • Para elegir cómo se cifrarán los datos de los objetos, haga clic en la flecha de expansión expand_more Cifrado de datos y seleccione un método de cifrado de datos.

4. Haz clic en Crear.

Para saber cómo obtener información detallada sobre los errores de las operaciones de Cloud Storage en la consola, consulta la sección Solución de problemas. Google Cloud

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

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

   Donde:

   • BUCKET_NAME es el nombre que quieres dar al segmento, que está sujeto a los requisitos de nomenclatura. Por ejemplo, my-bucket.

   • BUCKET_LOCATION es la ubicación de tu segmento. Por ejemplo, US.

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

   Creating gs://BUCKET_NAME/...

   Define las siguientes marcas para tener más control sobre la creación de tu contenedor:

   • --project: especifica el ID o el número del proyecto al que se asociará tu cubo. Por ejemplo, my-project.
   • --default-storage-class: especifica la clase de almacenamiento predeterminada de tu segmento. Por ejemplo, STANDARD.
   • --uniform-bucket-level-access: habilita el acceso uniforme a nivel de segmento en tu segmento.
   • --soft-delete-duration: especifica la duración de la retención de la eliminación no definitiva, que es el número de días que quieres conservar los objetos después de que se eliminen. 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 ver una lista completa de las opciones de creación de segmentos, usa la CLI de gcloud. Consulta las opciones de buckets create.

Bibliotecas de cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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 obtener más información, consulta la documentación de referencia de la API C# de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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 obtener más información, consulta la documentación de referencia de la API Go de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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 obtener más información, consulta la documentación de referencia de la API Java de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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 obtener más información, consulta la documentación de referencia de la API Node.js de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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 obtener más información, consulta la documentación de referencia de la API PHP de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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 obtener más información, consulta la documentación de referencia de la API Python de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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 obtener más información, consulta la documentación de referencia de la API Ruby de Cloud Storage.

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación 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

Puedes usar un recurso de Terraform para crear un segmento 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
}

APIs REST

API JSON

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

2. Crea un archivo JSON que contenga los ajustes del segmento, que debe incluir un name para el segmento. Consulta la documentación de Buckets:Insert para ver la lista completa de ajustes. Estos son los ajustes habituales que puedes incluir:

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

   Donde:

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

   • BUCKET_LOCATION es la ubicación en la que quieres almacenar los datos de los objetos de tu segmento. Por ejemplo, US.

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

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

   Donde:

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

API XML

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

2. Crea un archivo XML que contenga los ajustes del segmento. Consulta la documentación sobre XML: Create a bucket para ver una lista completa de ajustes. A continuación se indican algunos ajustes habituales que puedes incluir:

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

   Donde:

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

   • BUCKET_LOCATION es la ubicación en la que quieres almacenar los datos de los objetos de tu segmento. Por ejemplo, US.

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

   Donde:

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

   Si la solicitud se ha realizado correctamente, no se devuelve ninguna respuesta.