Crear un segmento

En esta página se explica cómo crear un segmento de Cloud Storage. Si no se especifica lo contrario en tu solicitud, los segmentos se crean en la USubicación multirregional con la clase de almacenamiento Standard Storage de forma predeterminada y tienen un periodo de conservación de eliminación suave de siete días.

Roles obligatorios

Para obtener los permisos necesarios para crear un segmento de Cloud Storage, pide a tu administrador que te conceda el rol de administrador de Storage (roles/storage.admin) de gestión de identidades y accesos en el proyecto.

Este rol predefinido contiene el permiso necesario para crear un segmento. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

  • storage.buckets.create
  • storage.buckets.enableObjectRetention (solo es necesario si se van a habilitar las configuraciones de retención de objetos del segmento)
  • storage.buckets.list (solo es necesario si se crea un contenedor mediante la Google Cloud consola).
  • resourcemanager.projects.get (solo es necesario si se crea un contenedor con la Google Cloud consola)

También puedes obtener estos permisos con roles personalizados u otros roles predefinidos. Para ver qué roles están asociados a qué permisos, consulta Roles de gestión de identidades y accesos de Cloud Storage.

Para obtener instrucciones sobre cómo asignar roles a proyectos, consulta Gestionar el acceso a proyectos.

Crear un nuevo segmento

Si es la primera vez que creas un segmento, consulta Descubrir el almacenamiento de objetos con la Google Cloud consola o Descubrir el almacenamiento de objetos con la herramienta de línea de comandos de Google Cloud.

Para crear un contenedor con ajustes específicos o configuraciones avanzadas, sigue estos pasos:

Consola

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

    Ir a Contenedores

  2. Haz clic en Crear.

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

    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 para desplegar la sección Etiquetas, haz clic en 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 permanentemente los datos de los objetos de tu segmento.

      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, haga 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, introduzca un prefijo con el que quiera incluir o excluir objetos y, a continuación, haga clic en 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 quieres almacenar tus 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.

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

        .

        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 que se muestran y selecciona las zonas en las que quieras crear cachés.

        3. Haz clic en Listo.

    5. Haz clic en Continuar.

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

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

      • Seleccione cualquiera de las opciones de Protección de datos que quiera definir para su contenedor.

      • Para habilitar la eliminación lógica, haga clic en la flecha del desplegable Política de eliminación lógica y especifique el número de días que quiere conservar los objetos después de eliminarlos.

      • Para elegir cómo se cifrarán los datos de los objetos, haga clic en la flecha del desplegable 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 segmento:

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

    3. 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.googleapis.com/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: Crear un contenedor 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.googleapis.com/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.

Siguientes pasos

Pruébalo

Si es la primera vez que utilizas Google Cloud, crea una cuenta para evaluar el rendimiento de Cloud Storage en situaciones reales. Los nuevos clientes también reciben 300 USD en crédito gratuito para ejecutar, probar y desplegar cargas de trabajo.

Probar Cloud Storage gratis