Usa el almacenamiento birregional

Descripción general

En esta página, se describe cómo usar el almacenamiento birregional.

Roles obligatorios

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

Este rol predefinido contiene el permiso necesario para crear un bucket birregional. 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 birregional

Completa los siguientes pasos para crear un bucket birregional:

Console

  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, escribe la información de tu bucket. Para ir al paso siguiente, haz clic en Continuar.

    1. En Nombre de tu bucket, escribe un nombre que cumpla con los requisitos de nomenclatura de buckets.

    2. En Elige dónde almacenar tus datos, junto a Tipo de ubicación, selecciona Birregional. Opcional: Puedes combinar la función con la replicación turbo si seleccionas la casilla de verificación Agregar replicación turbo.

    3. En Ubicación, selecciona el Continente y las Regiones asociadas que deseas usar.

    4. En Elegir una clase de almacenamiento predeterminada para tus datos, selecciona una clase de almacenamiento para el bucket. La clase de almacenamiento predeterminada se asigna de forma predeterminada a todos los objetos subidos al bucket.

    5. En Elige cómo controlar el acceso a los objetos, selecciona las opciones de Prevención de acceso público y Control de acceso que deseas usar.

    6. En Elige cómo proteger los datos de los objetos, selecciona las herramientas de protección que deseas usar, como el control de versiones de objetos, una política de retención y un método de encriptación.

  4. Haz clic en Crear.

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

Línea de comandos

Usa el comando buckets create con las marcas --location y --placement:

gcloud storage buckets create gs://BUCKET_NAME --location=MULTI-REGION --placement=REGION_1,REGION_2

Aquí:

  • BUCKET_NAME es el nombre del bucket que crearás. Por ejemplo, my-bucket.

  • MULTI-REGION especifica el código multirregional asociado con las regiones subyacentes. Por ejemplo, cuando elijas las regiones ASIA-SOUTH1 (Bombay) y ASIA-SOUTH2 (Delhi), usa IN.

  • REGION_1 especifica la ubicación geográfica de una región para tu bucket. Por ejemplo, ASIA-EAST1.

  • REGION_2 especifica la ubicación geográfica de una segunda región para tu bucket. Por ejemplo, ASIA-SOUTHEAST1.

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

Creating gs://BUCKET_NAME/...

Para obtener una lista completa de las opciones disponibles cuando creas buckets con gcloud storage, 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 un entorno de desarrollo local. 

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& region_a, std::string const& region_b) {
  auto metadata = client.CreateBucket(
      bucket_name,
      gcs::BucketMetadata().set_custom_placement_config(
          gcs::BucketCustomPlacementConfig{{region_a, region_b}}));
  if (!metadata) throw std::move(metadata).status();

  std::cout << "Bucket " << metadata->name() << " created."
            << "\nFull Metadata: " << *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 un entorno de desarrollo local. 


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class CreateDualRegionBucketSample
{
    public Bucket CreateDualRegionBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string location = "your-location",
        string region1 = "your-region1-name",
        string region2 = "your-region2-name")
    {
        var client = StorageClient.Create();

        var bucket = new Bucket
        {
            Name = bucketName,
            Location = location,
            CustomPlacementConfig = new Bucket.CustomPlacementConfigData
            {
                DataLocations = new[] { region1, region2 }
            }
        };

        var storageBucket = client.CreateBucket(projectId, bucket);

        Console.WriteLine($"Created storage bucket {storageBucket.Name}" +
            $" in {storageBucket.Location}" +
            $" with location-type {storageBucket.LocationType} and" +
            $" dataLocations {string.Join(",", storageBucket.CustomPlacementConfig.DataLocations)}.");

        return storageBucket;
    }

}

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 un entorno de desarrollo local. 

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// createBucketDualRegion creates a new dual-region bucket in the project in the
// provided location and regions.
// See https://cloud.google.com/storage/docs/locations#location-dr for more information.
func createBucketDualRegion(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	location := "US"
	region1 := "US-EAST1"
	region2 := "US-WEST1"

	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()

	storageDualRegion := &storage.BucketAttrs{
		Location: location,
		CustomPlacementConfig: &storage.CustomPlacementConfig{
			DataLocations: []string{region1, region2},
		},
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageDualRegion); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %w", bucketName, err)
	}

	attrs, err := bucket.Attrs(ctx)
	if err != nil {
		return fmt.Errorf("Bucket(%q).Attrs: %w", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v", bucketName)
	fmt.Fprintf(w, " - location: %v", attrs.Location)
	fmt.Fprintf(w, " - locationType: %v", attrs.LocationType)
	fmt.Fprintf(w, " - customPlacementConfig.dataLocations: %v", attrs.CustomPlacementConfig.DataLocations)
	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 un entorno de desarrollo local. 


import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.BucketInfo.CustomPlacementConfig;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.util.Arrays;

public class CreateBucketDualRegion {

  public static void createBucketDualRegion(
      String projectId,
      String bucketName,
      String location,
      String firstRegion,
      String secondRegion) {
    // The ID of your GCP project.
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket.
    // String bucketName = "your-unique-bucket-name";

    // The location your dual regions will be located in.
    // String location = "US";

    // One of the regions the dual region bucket is to be created in.
    // String firstRegion = "US-EAST1";

    // The second region the dual region bucket is to be created in.
    // String secondRegion = "US-WEST1";

    // See this documentation for other valid locations and regions:
    // https://cloud.google.com/storage/docs/locations

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    CustomPlacementConfig config =
        CustomPlacementConfig.newBuilder()
            .setDataLocations(Arrays.asList(firstRegion, secondRegion))
            .build();

    BucketInfo bucketInfo =
        BucketInfo.newBuilder(bucketName)
            .setLocation(location)
            .setCustomPlacementConfig(config)
            .build();

    Bucket bucket = storage.create(bucketInfo);

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in location "
            + bucket.getLocation()
            + " with location type "
            + bucket.getLocationType()
            + " with Custom Placement Config "
            + bucket.getCustomPlacementConfig().toString());
  }
}

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 un entorno de desarrollo local. 

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The bucket's pair of regions. Case-insensitive.
// See this documentation for other valid locations:
// https://cloud.google.com/storage/docs/locations
// const location = 'US';
// const region1 = 'US-EAST1';
// const region2 = 'US-WEST1';

// 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 createDualRegionBucket() {
  // For regions supporting dual-regions see: https://cloud.google.com/storage/docs/locations
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    customPlacementConfig: {
      dataLocations: [region1, region2],
    },
  });

  console.log(`Created '${bucket.name}'`);
  console.log(`- location: '${bucket.metadata.location}'`);
  console.log(`- locationType: '${bucket.metadata.locationType}'`);
  console.log(
    `- customPlacementConfig: '${JSON.stringify(
      bucket.metadata.customPlacementConfig
    )}'`
  );
}

createDualRegionBucket().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 un entorno de desarrollo local. 

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')
 * @param string $location Location for the bucket's regions. Case-insensitive.
 *        (e.g. 'US')
 * @param string $region1 First region for the bucket's regions. Case-insensitive.
 *        (e.g. 'US-EAST1')
 * @param string $region2 Second region for the bucket's regions. Case-insensitive.
 *        (e.g. 'US-WEST1')
 */
function create_bucket_dual_region(string $bucketName, string $location, string $region1, string $region2): void
{
    $storage = new StorageClient();
    $bucket = $storage->createBucket($bucketName, [
        'location' => $location,
        'customPlacementConfig' => [
            'dataLocations' => [$region1, $region2],
        ],
    ]);

    $info = $bucket->info();

    printf("Created '%s':", $bucket->name());
    printf("- location: '%s'", $info['location']);
    printf("- locationType: '%s'", $info['locationType']);
    printf("- customPlacementConfig: '%s'" . PHP_EOL, print_r($info['customPlacementConfig'], true));
}

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 un entorno de desarrollo local. 

from google.cloud import storage


def create_bucket_dual_region(bucket_name, location, region_1, region_2):
    """Creates a Dual-Region Bucket with provided location and regions.."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"

    # The bucket's pair of regions. Case-insensitive.
    # See this documentation for other valid locations:
    # https://cloud.google.com/storage/docs/locations
    # region_1 = "US-EAST1"
    # region_2 = "US-WEST1"
    # location = "US"

    storage_client = storage.Client()
    bucket = storage_client.create_bucket(bucket_name, location=location, data_locations=[region_1, region_2])

    print(f"Created bucket {bucket_name}")
    print(f" - location: {bucket.location}")
    print(f" - location_type: {bucket.location_type}")
    print(f" - customPlacementConfig data_locations: {bucket.data_locations}")

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 un entorno de desarrollo local. 

# The ID of your GCS bucket
# bucket_name = "your-bucket-name"

# The bucket's pair of regions. Case-insensitive.
# See this documentation for other valid locations:
# https://cloud.google.com/storage/docs/locations
# region_1 = "US-EAST1"
# region_2 = "US-WEST1"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new
bucket  = storage.create_bucket bucket_name,
                                custom_placement_config: { data_locations: [region_1, region_2] }

puts "Bucket #{bucket.name} created:"
puts "- location: #{bucket.location}"
puts "- location_type: #{bucket.location_type}"
puts "- custom_placement_config:"
puts "  - data_locations: #{bucket.data_locations}"

API de REST

API de JSON

  1. Tener la gcloud CLI instalada e inicializadaa fin de generar un token de acceso para el encabezado Authorization.

    Como alternativa, puedes crear un token de acceso con OAuth 2.0 Playground y, luego, incluirlo en el encabezado Authorization.

  2. Crea un archivo JSON que contenga la configuración del bucket, que debe incluir un name y una location. 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": "MULTI-REGION",
  "customPlacementConfig": {
    "dataLocations": ["REGION_1", "REGION_2"]
    },
  "storageClass": "STORAGE_CLASS"
}

    Donde:

    • BUCKET_NAME es el nombre que quieres asignar a tu bucket, sujeto a los requisitos de nomenclatura. Por ejemplo, my-bucket.
    • MULTI-REGION especifica el código multirregional asociado con las regiones subyacentes. Por ejemplo, cuando elijas las regiones ASIA-SOUTH1 (Bombay) y ASIA-SOUTH2 (Delhi), usa IN.
    • REGION_1 y REGION_2 son las regiones en las que deseas almacenar los datos de objeto del bucket. Por ejemplo, ASIA-EAST1 y ASIA-SOUTHEAST1.
    • STORAGE_CLASS es la clase de almacenamiento 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_ID"

    Aquí:

    • JSON_FILE_NAME es el nombre del archivo JSON que creaste en el paso 2.
    • PROJECT_ID es el ID del proyecto al que se asociará tu bucket. Por ejemplo, my-project.

API de XML

  1. Tener la gcloud CLI instalada e inicializadaa fin de generar un token de acceso para el encabezado Authorization.

    Como alternativa, puedes crear un token de acceso con OAuth 2.0 Playground y, luego, incluirlo en el encabezado Authorization.

  2. Crea un archivo XML que contenga la siguiente información:

      <CreateBucketConfiguration>
     <LocationConstraint>MULTI-REGION</LocationConstraint>
        <CustomPlacementConfig>
           <DataLocations>
              <DataLocation>REGION_1</DataLocation>
              <DataLocation>REGION_2</DataLocation>
           </DataLocations>
        </CustomPlacementConfig>
     <StorageClass>STORAGE_CLASS</StorageClass>
  </CreateBucketConfiguration>

    Aquí:

    • MULTI-REGION especifica el código multirregional asociado con las regiones subyacentes. Por ejemplo, cuando elijas las regiones ASIA-SOUTH1 (Bombay) y ASIA-SOUTH2 (Delhi), usa IN.
    • REGION_1 y REGION_2 son las regiones en las que deseas almacenar los datos de objeto del bucket. Por ejemplo, ASIA-EAST1 y ASIA-SOUTHEAST1.

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

  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"

    Aquí:

    • 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 del bucket. Por ejemplo, my-bucket.

    Si la solicitud incluye regiones no compatibles, se muestra un mensaje de error. Si la solicitud fue exitosa, no se mostrará una respuesta.

¿Qué sigue?