Crea un bucket

En esta página, se muestra cómo crear un bucket de Cloud Storage. Si no se especifica lo contrario en tu solicitud, los buckets se crean en elUS multirregión con una clase de almacenamiento predeterminada de Standard Storage y tiene una duración de borrar de forma no definitiva de siete días de retención.

Nota: El nombre de un bucket son los metadatos no editables. Si necesitas designar un nombre específico, debe especificarse en la creación del bucket.

Roles requeridos

Nota: En el siguiente contenido, se describen los roles y permisos de IAM necesarios para crear un bucket con la configuración básica. Si deseas configurar la replicación entre buckets como parte de la creación de tu bucket, necesitarás roles y permisos adicionales. Consulta la sección Antes de comenzar en la guía del usuario de la replicación entre bucket para obtener información sobre los roles y permisos necesarios.

Para obtener los permisos necesarios que te permitan crear un bucket de Cloud Storage, pídele a tu administrador que te otorgue el rol de IAM de administrador de almacenamiento (roles/storage.admin) para el proyecto.

Este rol predefinido contiene el permiso necesario para crear un bucket. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

• storage.buckets.create
• storage.buckets.enableObjectRetention (solo es necesaria si habilitas las configuraciones de retención de objetos para el bucket)
• storage.buckets.list (solo es necesario si se crea un bucket con la consola de Google Cloud ).
• resourcemanager.projects.get (solo es necesario si se crea un bucket con la consola de Google Cloud )

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos. Para ver qué roles están asociados con qué permisos, consulta Roles de IAM para Cloud Storage.

Si deseas obtener instrucciones para otorgar roles a proyectos, consulta Administra el acceso a los proyectos.

Crea un bucket nuevo

Si es la primera vez que creas un bucket, consulta Descubre el almacenamiento de objetos con la consola de Google Cloud o Descubre el almacenamiento de objetos con Google Cloud CLI Cloud.

Para crear un bucket con parámetros de configuración específicos o avanzados, completa los siguientes pasos:

Console

Nota: Cuando creas un bucket con la consola de Google Cloud , solo debes configurar un nombre único a nivel global para el bucket. Todos los demás pasos son opcionales o tienen parámetros de configuración predeterminados.

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

   Ir a Buckets

2. Haz clic en 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 para expandir la sección Etiquetas, haz clic en 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. Para configurar la replicación bucket buckets, selecciona Agregar replicación entre bucket a través del Servicio de transferencia de almacenamiento y sigue estos pasos:

         Configura la replicación entre bucket

         1. En el menú Bucket, selecciona un bucket.

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

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

            • Para filtrar los objetos que se replicarán por prefijo de nombre de objeto, ingresa un prefijo con el que quieras incluir o excluir objetos y, luego, haz clic en Agregar un prefijo.
            • Para establecer una clase de almacenamiento para los objetos replicados, selecciona una clase de almacenamiento en el menú Clase de almacenamiento. Si omites este paso, los objetos replicados usarán la clase de almacenamiento del bucket de destino de forma predeterminada.
            • Haz clic en Listo.

   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.

         Nota: No puedes habilitar el espacio de nombres jerárquico en un bucket existente.

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

         Nota: Se requieren permisos adicionales para habilitar la función Anywhere Cache. Para obtener más información, consulta Permisos necesarios.

         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.

      Nota: Si la política de la organización de tu proyecto ya aplica la prevención del acceso público, la casilla de verificación Impedir el acceso público se bloquea.

   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 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 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 Google Cloud consola, consulta Solución de problemas.

Línea de comandos

Nota: Cloud Shell aprovisiona una máquina virtual temporal. Si deseas subir objetos a Cloud Storage o descargar objetos de Cloud Storage, usa un entorno de desarrollo local.

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

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

     Nota: Cuando crees una región doble configurable, debes establecer la marca --location como el código de ubicación asociado con las regiones subyacentes y debes usar la marca --placement con un par de regiones válido. Por ejemplo, --location=ASIA --placement=ASIA-EAST1,ASIA-SOUTHEAST1.

   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

Nota: Puedes encontrar otras opciones para crear un bucket nuevo en la referencia de la API de JSON para bucket.insert

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.

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.

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.

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.

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.

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

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.

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.

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, US

     Nota: Cuando creas una región doble configurable, debes establecer el parámetro location como el código de ubicación asociado con las regiones subyacentes y también debes incluir un parámetro customPlacementConfig.

   • 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.googleapis.com/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, US

     Nota: Cuando crees una región doble configurable, debes establecer el elemento <LocationConstraint> para que sea el código de ubicación asociado con las regiones subyacentes y también debes incluir un elemento <CustomPlacementConfig>.

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

¿Qué sigue?

• Crea una lista de depósitos en el proyecto.
• Obtén más información de los metadatos asociados a un bucket.
• Mueve o cambia el nombre de un depósito.
• Borra un depósito.
• Sube un objeto a tu bucket.
• Crea y configura buckets de forma declarativa con Kubernetes Config Connector, que te permite describir recursos de Google Cloud con las herramientas, las APIs y las configuraciones de Kubernetes. Para obtener más información, consulta la documentación de la API de Config Connector.

Pruébalo tú mismo

Si es la primera vez que usas Google Cloud, crea una cuenta para evaluar el rendimiento de Cloud Storage en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

Probar Cloud Storage gratis