En este instructivo, se describe cómo configurar un bucket de Cloud Storage a fin de alojar un sitio web estático para un dominio que poseas. Las páginas web estáticas pueden incluir tecnologías del lado del cliente, como HTML, CSS y JavaScript. No pueden incluir contenido dinámico como secuencias de comandos del lado del servidor como PHP.

Dado que Cloud Storage no admite dominios personalizados con HTTPS por sí solo, en este instructivo, se usa Cloud Storage con el balanceo de cargas de HTTP(S) para entregar contenido desde un dominio personalizado a través de HTTPS. Si deseas ver las opciones para entregar contenido de un dominio personalizado a través de HTTPS, consulta el tema de solución de problemas relacionado. También puedes usar Cloud Storage para entregar contenido de dominio personalizado a través de HTTP, que no requiere un balanceador de cargas.

Si buscas ejemplos y sugerencias sobre páginas web estáticas, incluido cómo alojar elementos estáticos para un sitio web dinámico, consulta la página de sitios web estáticos.

== Objetivos ==En este instructivo, se muestra cómo hacer lo siguiente:

- Crear un bucket

- Subir y compartir los archivos de tu sitio

- Configurar un balanceador de cargas y un certificado SSL

- Conectar tu balanceador de cargas a tu bucket

- Apuntar tu dominio a tu balanceador de cargas con un registro

A

- Probar el sitio web

== Costos ==

En este instructivo, se usan los siguientes componentes facturables de Google Cloud:

Consulta la sugerencia Supervisa tus cargos a fin de obtener detalles sobre los cargos que se pueden aplicar cuando alojas un sitio web estático.

== Antes de comenzar ==

- Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

Ir al selector de proyectos

Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

En la página del selector de proyectos de Google Cloud Console, selecciona o crea un proyecto de Google Cloud.

Ir al selector de proyectos

Asegúrate de que la facturación esté habilitada para tu proyecto de Cloud. Obtén información sobre cómo verificar si la facturación está habilitada en un proyecto.

- Debes tener un dominio que poseas o administres. Si no tienes un dominio existente, existen muchos servicios a través de los cuales puedes registrar un nuevo dominio, como Google Domains y Cloud Domains.

En este instructivo, se usa el dominio

example.com.

- Debes tener algunos archivos del sitio web que desees entregar. Este instructivo es de mayor utilidad si tienes al menos una página de índice (

index.html) y una página 404 (

404.html).

- Debes tener las siguientes funciones de administración de identidades y accesos: administrador de objetos de almacenamiento y administrador de redes.

- Si deseas que tu bucket de Cloud Storage tenga el mismo nombre que tu dominio, debes verificar que eres propietario o administrador del dominio que usarás (opcional). Asegúrate de verificar el dominio de nivel superior, como

example.com, y no un subdominio, como

www.example.com. Si compraste tu dominio a través de Google Domains, la verificación es automática.

== Cree un bucket ==

Siga estos pasos para crear un bucket:

 Console 

- En Google Cloud Console, ve a la página

Navegadorde Cloud Storage.

- Haga clic en

Crear bucket.

- En la página

Crear un bucket, ingresa la información de tu bucket. Para ir al paso siguiente, haz clic en Continuar.

- En

Asigna un nombre a tu bucket, ingresa un nombre que cumpla con los requisitos de nomenclatura de buckets.

- En

Elige dónde almacenar tus datos, selecciona un Tipo de ubicacióny una Ubicaciónen la que se almacenarán de forma permanente los datos del bucket.

- 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. Nota:El panel Estimación de costo mensualen el panel derecho calcula los costos mensuales del bucket en función de la clase y ubicación de almacenamiento seleccionadas, así como las operaciones y el tamaño de los datos esperados.

- En

Elige cómo controlar el acceso a los objetos, selecciona si tu bucket aplica o no la prevención del acceso público y selecciona un modelo de Control de accesopara 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, el botón de activación Impedir el acceso públicose bloquea.

- En

Elige cómo proteger los datos de objetos, configura herramientas de protecciónsi lo deseas y selecciona un método de encriptación de datos.

- Haga clic en

Crear.

Para aprender a obtener información detallada sobre errores en las operaciones fallidas en el navegador de Cloud Storage, consulta Solución de problemas.

 Línea de comandos 

Usa el comando

gsutil mb:

gsutil mb gs

BUCKET_NAME

Donde:

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

BUCKET_NAME

my-bucket.

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

Creating gs

BUCKET_NAME

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

-p: Especifica el ID o el número del proyecto con el que se asociará el bucket. Por ejemplo,

my-project.

-c: Especifica la clase de almacenamiento predeterminada de tu bucket. Por ejemplo,

NEARLINE.

-l: Especifica la ubicación de tu bucket. Por ejemplo,

US-EAST1.

-b: especifica la configuración de acceso uniforme a nivel de bucket para tu bucket. Por ejemplo,

ON.

Para obtener una lista completa de opciones para la creación de buckets de gsutil, consulta las opciones de mb.

Por ejemplo:

gsutil mb -p

PROJECT_ID-c STORAGE_CLASS-l BUCKET_LOCATION-b on gs BUCKET_NAME

 Muestras de código 

 C++ 

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

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 bucket_metadata = client.CreateBucket(bucket_name, gcs::BucketMetadata() .set_storage_class(storage_class) .set_location(location if (!bucket_metadata) { throw std::runtime_error(bucket_metadata.statusmessage } 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 para C#.

using Google.Apis.Storage.v1.Data; using Google.Cloud.Storage.V1; using System; public class CreateRegionalBucketSample {Creates a storage bucket with region.The ID of the project to create the buckets inparam>The location of the bucket. Object data for objects in the bucket resides inphysical storage within this region. Defaults to USparam>The name of the bucket to createparam>The bucket's default storage class, used whenever no storageClass is specifiedfor a newly-created object. This defines how objects in the bucket are storedand 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 toSTANDARDparam> 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.WriteLineCreated {bucketName return newlyCreatedBucket; } }

 Go 

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

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: %v", err) } defer client.Close() ctx, cancel := context.WithTimeout(ctx, time.Second*10) 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: %v", 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 para Java.

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.newBuildersetProjectId(projectId).buildgetService // See the StorageClass documentation for other valid storage classes: // httpsgoogleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html StorageClass storageClass = StorageClass.COLDLINE; // See this documentation for other valid locations: // httpg.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 para Node.js.

 * 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: // httpsgoogleapis.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: // httpg.co/cloud/storage/docs/locations#location-mr // const location = 'ASIA'; // Imports the Google Cloud client library const {Storage} = requiregoogle-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 httpscloud.google.com/docs/authentication/production or httpsgoogleapis.dev/nodejs/storage/latest/Storage.html const storage = new Storage async function createBucketWithStorageClassAndLocation() { // For default values see: httpscloud.google.com/storage/docs/locations and // httpscloud.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}` ); } createBucketWithStorageClassAndLocationcatch(console.error);

 PHP 

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

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. */ function create_bucket_class_location($bucketName) { // $bucketName = 'my-bucket'; $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 para Python.

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 para Ruby.

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 "google_storage_bucket" "static" { name = "new-bucket" location = "US" storage_class = "COLDLINE" uniform_bucket_level_access = true }

 API de REST 

 API de JSON 

- Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

- Crea un archivo .json que contenga la configuración del bucket, que debe incluir un

namepara 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 }, } }

Aquí:

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

BUCKET_NAME

my-bucket.

es la ubicación en la que deseas almacenar los datos de objeto de tu bucket. Por ejemplo,

BUCKET_LOCATION

US-EAST1.

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

STORAGE_CLASS

NEARLINE.

cURLpara llamar a la API de JSON:

curl -X POST --data-binary @

JSON_FILE_NAME.json \ -H "Authorization: Bearer OAUTH2_TOKEN" \ -H "Content-Type: application/json" \ "httpsstorage.googleapis.com/storage/v1/b?project= PROJECT_IDENTIFIER"

Donde:

es el nombre del archivo JSON que creaste en el paso 2.

JSON_FILE_NAME

es el token de acceso que generaste en el paso 1.

OAUTH2_TOKEN

es el ID o el número del proyecto al que se asociará el bucket. Por ejemplo,

PROJECT_IDENTIFIER

my-project.

 API de XML 

- Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

- Crea un archivo .xml que contenga la siguiente información:

 

BUCKET_LOCATION  STORAGE_CLASS 

Donde:

es la ubicación en la que deseas almacenar los datos de objeto de tu bucket. Por ejemplo,

BUCKET_LOCATION

US-EAST1.

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

STORAGE_CLASS

NEARLINE.

cURLpara llamar a la API de XML:

curl -X PUT --data-binary @

XML_FILE_NAME.xml \ -H "Authorization: Bearer OAUTH2_TOKEN" \ -H "x-goog-project-id: PROJECT_ID" \ "httpsstorage.googleapis.com/ BUCKET_NAME"

Donde:

es el nombre del archivo XML que creaste en el paso 2.

XML_FILE_NAME

es el token de acceso que generaste en el paso 1.

OAUTH2_TOKEN

es el ID del proyecto al que se asociará tu bucket. Por ejemplo,

PROJECT_ID

my-project.

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

BUCKET_NAME

my-bucket.

== Sube los archivos de tu sitio ==

Para agregar los archivos que deseas que tu sitio web entregue al bucket, haz lo siguiente:

 Console 

- En Google Cloud Console, ve a la página

Navegadorde Cloud Storage.

En la lista de buckets, haz clic en el nombre del bucket que creaste.

Se abrirá la página

Detalles del bucketcon la pestaña Objetosseleccionada.

Haz clic en el botón

Subir archivos.

En el cuadro de diálogo de archivo, navega al archivo deseado y selecciónalo.

Una vez completada la carga, deberías ver el nombre y la información del archivo en el bucket.

Para aprender a obtener información detallada sobre errores en las operaciones fallidas en el navegador de Cloud Storage, consulta Solución de problemas.

 gsutil 

Usa el comando

gsutil cp para copiar archivos a tu bucket. Por ejemplo, para copiar el archivo

index.html de su ubicación actual

Desktop al bucket

my-static-assets, ejecuta el siguiente comando:

gsutil cp Desktop/index.html gsmy-static-assets

Si no hay errores, el comando mostrará lo siguiente:

Copying fileDesktop/index.html [Content-Type=text/html Uploading gsmy-static-assets/index.html: 0 B/2.58 KiB Uploading gsmy-static-assets/index.html: 2.58 KiB/2.58 KiB

 Ejemplos de código 

 C++ 

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

En el siguiente ejemplo, se sube un objeto de un archivo:

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; gcs::Client client, std::string const& file_name, std::string const& bucket_name, std::string const& object_name) { // Note that the client library automatically computes a hash on the // client-side to verify data integrity during transmission. StatusOr metadata = client.UploadFile( file_name, bucket_name, object_name, gcs::IfGenerationMatch(0 if (!metadata) throw std::runtime_error(metadata.statusmessage std::cout << "Uploaded " << file_name << " to object " << metadata->name() << " in bucket " << metadata->bucket() << "\nFull metadata: " << *metadata << "\n"; }

En el siguiente ejemplo, se sube un objeto de la memoria:

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; gcs::Client client, std::string const& bucket_name, std::string const& object_name) { std::string const text = "Lorem ipsum dolor sit amet"; std::vector v(100, text); gcs::ObjectWriteStream stream = client.WriteObject(bucket_name, object_name); std::copy(v.begin v.end std::ostream_iterator(stream stream.Close StatusOr metadata = std::move(stream).metadata if (!metadata) throw std::runtime_error(metadata.statusmessage std::cout << "Successfully wrote to object " << metadata->name() << " its size is: " << metadata->size() << "\nFull metadata: " << *metadata << "\n"; }

 C# 

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

En el siguiente ejemplo, se sube un objeto de un archivo:

using Google.Cloud.Storage.V1; using System; using System.IO; public class UploadFileSample { public void UploadFile( string bucketName = "your-unique-bucket-name", string localPath = "my-local-path/my-file-name", string objectName = "my-file-name") { var storage = StorageClient.Create using var fileStream = File.OpenRead(localPath); storage.UploadObject(bucketName, objectName, null, fileStream); Console.WriteLineUploaded {objectName } }

En el siguiente ejemplo, se sube un objeto de la memoria:

using Google.Cloud.Storage.V1; using System; using System.IO; using System.Text; public class UploadObjectFromMemorySample { public void UploadObjectFromMemory( string bucketName = "unique-bucket-name", string objectName = "file-name", string contents = "Hello world { var storage = StorageClient.Create byte[] byteArray = Encoding.UTF8.GetBytes(contents); MemoryStream stream = new MemoryStream(byteArray); storage.UploadObject(bucketName, objectName, "application/octet-stream" , stream); Console.WriteLine {objectName} uploaded to bucket {bucketName} with contents: {contents } }

 Go 

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

En el siguiente ejemplo, se sube un objeto de un archivo:

import ( "context" "fmt" "io" "os" "time" "cloud.google.com/go/storage" ) // uploadFile uploads an object. func uploadFile(w io.Writer, bucket, object string) error { // bucket := "bucket-name" // object := "object-name" ctx := context.Background() client, err := storage.NewClient(ctx) if err != nil { return fmt.Errorf("storage.NewClient: %v", err) } defer client.Close() // Open local file. f, err := os.Open("notes.txt") if err != nil { return fmt.Errorf("os.Open: %v", err) } defer f.Close() ctx, cancel := context.WithTimeout(ctx, time.Second*50) defer cancel() o := client.Bucket(bucket).Object(object) // Optional: set a generation-match precondition to avoid potential race // conditions and data corruptions. The request to upload is aborted if the // object's generation number does not match your precondition. // For an object that does not yet exist, set the DoesNotExist precondition. o = o.If(storage.Conditions{DoesNotExist: true}) // If the live object already exists in your bucket, set instead a // generation-match precondition using the live object's generation number. // attrs, err := o.Attrs(ctx) // if err != nil { // return fmt.Errorf("object.Attrs: %v", err) // } // o = o.If(storage.Conditions{GenerationMatch: attrs.Generation}) // Upload an object with storage.Writer. wc := o.NewWriter(ctx) if _, err = io.Copy(wc, f); err != nil { return fmt.Errorf("io.Copy: %v", err) } if err := wc.Close err != nil { return fmt.Errorf("Writer.Close: %v", err) } fmt.Fprintf(w, "Blob %v uploaded.\n", object) return nil }

En el siguiente ejemplo, se sube un objeto de la memoria:

import ( "bytes" "context" "fmt" "io" "time" "cloud.google.com/go/storage" ) // streamFileUpload uploads an object via a stream. func streamFileUpload(w io.Writer, bucket, object string) error { // bucket := "bucket-name" // object := "object-name" ctx := context.Background() client, err := storage.NewClient(ctx) if err != nil { return fmt.Errorf("storage.NewClient: %v", err) } defer client.Close() b := []byte("Hello world buf := bytes.NewBuffer(b) ctx, cancel := context.WithTimeout(ctx, time.Second*50) defer cancel() // Upload an object with storage.Writer. wc := client.Bucket(bucket).Object(object).NewWriter(ctx) wc.ChunkSize = 0 // note retries are not supported for chunk size 0. if _, err = io.Copy(wc, buf); err != nil { return fmt.Errorf("io.Copy: %v", err) } // Data can continue to be added to the file until the writer is closed. if err := wc.Close err != nil { return fmt.Errorf("Writer.Close: %v", err) } fmt.Fprintf(w, "%v uploaded to %v.\n", object, bucket) return nil }

 Java 

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

En el siguiente ejemplo, se sube un objeto de un archivo:

import com.google.cloud.storage.BlobId; import com.google.cloud.storage.BlobInfo; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Paths; public class UploadObject { public static void uploadObject( String projectId, String bucketName, String objectName, String filePath) throws IOException { // The ID of your GCP project // String projectId = "your-project-id"; // The ID of your GCS bucket // String bucketName = "your-unique-bucket-name"; // The ID of your GCS object // String objectName = "your-object-name"; // The path to your file to upload // String filePath = "path/to/your/file" Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetService BlobId blobId = BlobId.of(bucketName, objectName); BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build storage.create(blobInfo, Files.readAllBytes(Paths.get(filePath System.out.println( "File " + filePath + " uploaded to bucket " + bucketName + " as " + objectName); } }

En el siguiente ejemplo, se sube un objeto de la memoria:

import com.google.cloud.storage.BlobId; import com.google.cloud.storage.BlobInfo; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions; import java.io.ByteArrayInputStream; import java.io.IOException; import java.nio.charset.StandardCharsets; public class UploadObjectFromMemory { public static void uploadObjectFromMemory( String projectId, String bucketName, String objectName, String contents) throws IOException { // The ID of your GCP project // String projectId = "your-project-id"; // The ID of your GCS bucket // String bucketName = "your-unique-bucket-name"; // The ID of your GCS object // String objectName = "your-object-name"; // The string of contents you wish to upload // String contents = "Hello world Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetService BlobId blobId = BlobId.of(bucketName, objectName); BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build byte[] content = contents.getBytes(StandardCharsets.UTF_8); storage.createFrom(blobInfo, new ByteArrayInputStream(content System.out.println( "Object " + objectName + " uploaded to bucket " + bucketName + " with contents " + contents); } }

 Node.js 

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

En el siguiente ejemplo, se sube un objeto de un archivo:

 * TODO(developer): Uncomment the following lines before running the sample. */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name'; // The path to your file to upload // const filePath = 'path/to/your/file'; // The new ID for your GCS file // const destFileName = 'your-new-file-name'; // Imports the Google Cloud client library const {Storage} = requiregoogle-cloud/storage // Creates a client const storage = new Storage async function uploadFile() { await storage.bucket(bucketName).upload(filePath, { destination: destFileName,console.logfilePath} uploaded to ${bucketName } uploadFilecatch(console.error);

En el siguiente ejemplo, se sube un objeto de la memoria:

 * TODO(developer): Uncomment the following lines before running the sample. */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name'; // The contents that you want to upload // const contents = 'these are my contents'; // The new ID for your GCS file // const destFileName = 'your-new-file-name'; // Imports the Google Cloud Node.js client library const {Storage} = requiregoogle-cloud/storage // Creates a client const storage = new Storage async function uploadFromMemory() { await storage.bucket(bucketName).file(destFileName).save(contents); console.log( destFileName} with contents ${contents} uploaded to ${bucketName ); } uploadFromMemorycatch(console.error);

 PHP 

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

En el siguiente ejemplo, se sube un objeto de un archivo:

use Google\Cloud\Storage\StorageClient;* Upload a file. * * @param string $bucketName The name of your Cloud Storage bucket. * @param string $objectName The name of your Cloud Storage object. * @param string $source The path to the file to upload. */ function upload_object($bucketName, $objectName, $source) { // $bucketName = 'my-bucket'; // $objectName = 'my-object'; // $source = '/path/to/your/file'; $storage = new StorageClient $file = fopen($source, 'r $bucket = $storage->bucket($bucketName); $object = $bucket->upload($file, [ 'name' => $objectNameprintf('Uploaded %s to gss/%s' . PHP_EOL, basename($source), $bucketName, $objectName); }

En el siguiente ejemplo, se sube un objeto de la memoria:

use Google\Cloud\Storage\StorageClient;* Upload an object from memory buffer. * * @param string $bucketName The name of your Cloud Storage bucket. * @param string $objectName The name of your Cloud Storage object. * @param string $contents The contents to upload to the file. */ function upload_object_from_memory( string $bucketName, string $objectName, string $contents ): void { // $bucketName = 'my-bucket'; // $objectName = 'my-object'; // $contents = 'these are my contents'; $storage = new StorageClient $stream = fopen('datatext/plain,' . $contents, 'r $bucket = $storage->bucket($bucketName); $bucket->upload($stream, [ 'name' => $objectName,printf('Uploaded %s to gss/%s' . PHP_EOL, $contents, $bucketName, $objectName); }

 Python 

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

En el siguiente ejemplo, se sube un objeto de un archivo:

from google.cloud import storage def upload_blob(bucket_name, source_file_name, destination_blob_name): Uploads a file to the bucket # The ID of your GCS bucket # bucket_name = "your-bucket-name" # The path to your file to upload # source_file_name = "local/path/to/file" # The ID of your GCS object # destination_blob_name = "storage-object-name" storage_client = storage.Client() bucket = storage_client.bucket(bucket_name) blob = bucket.blob(destination_blob_name) blob.upload_from_filename(source_file_name) print( f"File {source_file_name} uploaded to {destination_blob_name )

En el siguiente ejemplo, se sube un objeto de la memoria:

from google.cloud import storage def upload_blob_from_memory(bucket_name, contents, destination_blob_name): Uploads a file to the bucket # The ID of your GCS bucket # bucket_name = "your-bucket-name" # The contents to upload to the file # contents = "these are my contents" # The ID of your GCS object # destination_blob_name = "storage-object-name" storage_client = storage.Client() bucket = storage_client.bucket(bucket_name) blob = bucket.blob(destination_blob_name) blob.upload_from_string(contents) print( f"{destination_blob_name} with contents {contents} uploaded to {bucket_name )

 Ruby 

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

En el siguiente ejemplo, se sube un objeto de un archivo:

def upload_file bucket_name:, local_file_path:, file_name: nil # The ID of your GCS bucket # bucket_name = "your-unique-bucket-name" # The path to your file to upload # local_file_path = "/local/path/to/file.txt" # The ID of your GCS object # file_name = "your-file-name" require "google/cloud/storage" storage = Google::Cloud::Storage.new bucket = storage.bucket bucket_name, skip_lookup: true file = bucket.create_file local_file_path, file_name puts "Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_name}" end

En el siguiente ejemplo, se sube un objeto de la memoria:

# The ID of your GCS bucket # bucket_name = "your-unique-bucket-name" # The ID of your GCS object # file_name = "your-file-name" # The contents to upload to your file # file_content = "Hello, world!" require "google/cloud/storage" storage = Google::Cloud::Storage.new bucket = storage.bucket bucket_name, skip_lookup: true file = bucket.create_file StringIO.new(file_content), file_name puts "Uploaded file #{file.name} to bucket #{bucket_name} with content: #{file_content}"

 API de REST 

 API de JSON 

- Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

Usa

cURLpara llamar a la API de JSON con una solicitud de objeto

POST. Para el archivo

index.htmlsubido a un bucket llamado

my-static-assets, usa el siguiente comando:

curl -X POST --data-binary @index.html \ -H "Content-Type: text/html" \ -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \ "httpsstorage.googleapis.com/upload/storage/v1/b/my-static-assets/o?uploadType=media&name=index.html"

 API de XML 

- Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

Usa

cURLpara llamar a la API de XML con una solicitud de objeto

PUT. Para el archivo

index.htmlsubido a un bucket llamado

my-static-assets, usa el siguiente comando:

curl -X PUT --data-binary @index.html \ -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \ -H "Content-Type: text/html" \ "httpsstorage.googleapis.com/my-static-assets/index.html"

== Comparte tus archivos ==

Sigue estos pasos a fin de que todos los objetos de tu bucket sean legibles para todos en la Internet pública:

 Console 

- En Google Cloud Console, ve a la página

Navegadorde Cloud Storage.

En la lista de buckets, haz clic en el nombre del bucket que deseas hacer público.

Selecciona la pestaña

Permisoscerca de la parte superior de la página.

Haz clic en el botón

+ Agregar.

Aparecerá el cuadro de diálogo

Agregar principales.

En el campo

Principales nuevas, ingresa

allUsers.

En el menú desplegable

Seleccionar un rol, selecciona el submenú Cloud Storagey haz clic en la opción Visualizador de objetos de almacenamiento.

Haz clic en

Guardar.

Haz clic en

Permitir acceso público.

Una vez que se comparte de forma pública, aparece un ícono de

**vínculo** para cada objeto en la columna de *acceso público*. Puedes hacer clic en este ícono a fin de obtener la URL del objeto.

Para aprender a obtener información detallada sobre errores en las operaciones fallidas en el navegador de Cloud Storage, consulta Solución de problemas.

 gsutil 

Usa el comando

gsutil iam ch:

gsutil iam ch allUsers:objectViewer gsmy-static-assets

 Muestras de código 

 C++ 

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

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; gcs::Client client, std::string const& bucket_name) { auto current_policy = client.GetNativeBucketIamPolicy( bucket_name, gcs::RequestedPolicyVersion(3 if (!current_policy) { throw std::runtime_error(current_policy.statusmessage } current_policy->set_version(3); current_policy->bindingsemplace_back( gcs::NativeIamBinding("roles/storage.objectViewer", {"allUsers auto updated = client.SetNativeBucketIamPolicy(bucket_name, *current_policy); if (!updated) throw std::runtime_error(updated.statusmessage std::cout << "Policy successfully updated: " << *updated << "\n"; }

 Go 

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

import ( "context" "fmt" "io" "cloud.google.com/go/iam" "cloud.google.com/go/storage" iampb "google.golang.org/genproto/googleapis/iam/v1" ) // setBucketPublicIAM makes all objects in a bucketreadable. func setBucketPublicIAM(w io.Writer, bucketName string) error { // bucketName := "bucket-name" ctx := context.Background() client, err := storage.NewClient(ctx) if err != nil { return fmt.Errorf("storage.NewClient: %v", err) } defer client.Close() policy, err := client.Bucket(bucketName).IAMV3Policy(ctx) if err != nil { return fmt.Errorf("Bucket(%q).IAMV3Policy: %v", bucketName, err) } role := "roles/storage.objectViewer" policy.Bindings = append(policy.Bindings, &iampb.Binding{ Role: role, Members: []string{iam.AllUsers}, }) if err := client.Bucket(bucketName).IAMV3SetPolicy(ctx, policy); err != nil { return fmt.Errorf("Bucket(%q).IAMSetPolicy: %v", bucketName, err) } fmt.Fprintf(w, "Bucket %v is nowreadable\n", bucketName) return nil }

 Java 

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

import com.google.cloud.Identity; import com.google.cloud.Policy; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions; import com.google.cloud.storage.StorageRoles; public class MakeBucketPublic { public static void makeBucketPublic(String projectId, String bucketName) { // The ID of your GCP project // String projectId = "your-project-id"; // The ID of your GCS bucket // String bucketName = "your-unique-bucket-name"; Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetService Policy originalPolicy = storage.getIamPolicy(bucketName); storage.setIamPolicy( bucketName, originalPolicy .toBuilder() .addIdentity(StorageRoles.objectViewer Identity.allUsers // All users can view .build System.out.println("Bucket " + bucketName + " is nowreadable } }

 Node.js 

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

 * TODO(developer): Uncomment the following lines before running the sample. */ // The ID of your GCS bucket // const bucketName = 'your-unique-bucket-name'; // Imports the Google Cloud client library const {Storage} = requiregoogle-cloud/storage // Creates a client const storage = new Storage async function makeBucketPublic() { await storage.bucket(bucketName).makePublic console.log(`Bucket ${bucketName} is nowreadable } makeBucketPubliccatch(console.error);

 Python 

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

from typing import List from google.cloud import storage def set_bucket_public_iam( bucket_name: str = "your-bucket-name", members: List[str] = ["allUsers ): Set a public IAM Policy to bucket # bucket_name = "your-bucket-name" storage_client = storage.Client() bucket = storage_client.bucket(bucket_name) policy = bucket.get_iam_policy(requested_policy_version=3) policy.bindings.append( {"role": "roles/storage.objectViewer", "members": members} ) bucket.set_iam_policy(policy) print(f"Bucket {bucket.name} is nowreadable")

 Ruby 

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

def set_bucket_public_iam bucket_name: # The ID of your GCS bucket # bucket_name = "your-unique-bucket-name" require "google/cloud/storage" storage = Google::Cloud::Storage.new bucket = storage.bucket bucket_name bucket.policy do |p| p.add "roles/storage.objectViewer", "allUsers" end puts "Bucket #{bucket_name} is nowreadable" end

 API de REST 

 API de JSON 

- Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

Crea un archivo JSON que contenga la siguiente información:

{ "bindings { "role": "roles/storage.objectViewer", "membersallUsers"] } ] }

Usa

cURLpara llamar a la API de JSON con una solicitud de bucket

PUT:

curl -X PUT --data-binary @

JSON_FILE_NAME\ -H "Authorization: Bearer OAUTH2_TOKEN" \ -H "Content-Type: application/json" \ "httpsstorage.googleapis.com/storage/v1/b/ BUCKET_NAME/iam"

Aquí:

es la ruta de acceso del archivo JSON que creaste en el paso 2.

JSON_FILE_NAME

es el token de acceso que creaste en el paso 1.

OAUTH2_TOKEN

es el nombre del bucket cuyos objetos quieres hacer públicos. Por ejemplo,

BUCKET_NAME

my-static-assets

 API de XML 

La API de XML no admite que todos los objetos de un bucket se hagan legibles de forma pública. Usa gsutil o la API de JSON en su lugar, o establece LCA para cada objeto individual.

Para que los objetos individuales de tu bucket sean de acceso público, debes cambiar el modo de

**Control de acceso** de tu bucket a **Detallado En general, hacer que todos los archivos de un bucket sean de acceso público es más fácil y rápido.

Los visitantes reciben un código de respuesta

http 403 cuando solicitan la URL de un archivo que no es público o que no existe. Consulta la siguiente sección para obtener información sobre cómo agregar una página de error que use un código de respuesta

http 404.

== Recomendado: Asigna páginas especializadas ==

Puedes asignar un sufijo de página de índice, controlado por la propiedad

MainPageSuffix, y una página de error personalizada, controlada por la propiedad

NotFoundPage. La asignación es opcional, pero, sin una página de índice, no se entrega nada cuando los usuarios acceden a tu sitio de nivel superior, por ejemplo,

httpswww.example.com. Para obtener más información sobre las propiedades

MainPageSuffix y

NotFoundPage, consulta Páginas especializadas.

En el siguiente ejemplo,

MainPageSuffix se configura como

index.html y

NotFoundPage como

404.html:

 Console 

- En Google Cloud Console, ve a la página

Navegadorde Cloud Storage.

En la lista de bucket s, encuentra el bucket que creaste.

Haz clic en el menú

Ampliado del bucket(

) asociado al bucket y selecciona

Editar configuración del sitio web.

En el cuadro de diálogo de configuración del sitio web, especifica la página principal y la página de error.

Haz clic en

Guardar.

Para aprender a obtener información detallada sobre errores en las operaciones fallidas en el navegador de Cloud Storage, consulta Solución de problemas.

 gsutil 

Usa el comando

gsutil web set para establecer la propiedad

MainPageSuffix con la marca

-m, además de

NotFoundPage con la marca

-e:

gsutil web set -m index.html -e 404.html gsmy-static-assets

Si se ejecuta correctamente, el comando mostrará lo siguiente:

Setting website config on gsmy-static-assets

 Muestras de código 

 C++ 

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

namespace gcs = ::google::cloud::storage; using ::google::cloud::StatusOr; gcs::Client client, std::string const& bucket_name, std::string const& main_page_suffix, std::string const& not_found_page) { StatusOr original = client.GetBucketMetadata(bucket_name); if (!original) throw std::runtime_error(original.statusmessage StatusOr patched_metadata = client.PatchBucket( bucket_name, gcs::BucketMetadataPatchBuilderSetWebsite( gcs::BucketWebsite{main_page_suffix, not_found_page gcs::IfMetagenerationMatch(original->metageneration if (!patched_metadata) { throw std::runtime_error(patched_metadata.statusmessage } if (!patched_metadata->has_website { std::cout << "Static website configuration is not set for bucket " << patched_metadata->name() << "\n"; return; } std::cout << "Static website configuration successfully set for bucket " << patched_metadata->name() << "\nNew main page suffix is: " << patched_metadata->websitemain_page_suffix << "\nNew not found page is: " << patched_metadata->websitenot_found_page << "\n"; }

 C# 

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

using Google.Apis.Storage.v1.Data; using Google.Cloud.Storage.V1; using System; public class BucketWebsiteConfigurationSample { public Bucket BucketWebsiteConfiguration( string bucketName = "your-bucket-name", string mainPageSuffix = "index.html", string notFoundPage = "404.html") { var storage = StorageClient.Create var bucket = storage.GetBucket(bucketName); if (bucket.Website == null) { bucket.Website = new Bucket.WebsiteData } bucket.Website.MainPageSuffix = mainPageSuffix; bucket.Website.NotFoundPage = notFoundPage; bucket = storage.UpdateBucket(bucket); Console.WriteLineStatic website bucket {bucketName} is set up to use {mainPageSuffix} as the index page and {notFoundPage} as the 404 not found page return bucket; } }

 Go 

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

import ( "context" "fmt" "io" "time" "cloud.google.com/go/storage" ) // setBucketWebsiteInfo sets website configuration on a bucket. func setBucketWebsiteInfo(w io.Writer, bucketName, indexPage, notFoundPage string) error { // bucketName := "www.example.com" // indexPage := "index.html" // notFoundPage := "404.html" ctx := context.Background() client, err := storage.NewClient(ctx) if err != nil { return fmt.Errorf("storage.NewClient: %v", err) } defer client.Close() ctx, cancel := context.WithTimeout(ctx, time.Second*10) defer cancel() bucket := client.Bucket(bucketName) bucketAttrsToUpdate := storage.BucketAttrsToUpdate{ Website: &storage.BucketWebsite{ MainPageSuffix: indexPage, NotFoundPage: notFoundPage, }, } if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil { return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err) } fmt.Fprintf(w, "Static website bucket %v is set up to use %v as the index page and %v as the 404 page\n", bucketName, indexPage, notFoundPage) return nil }

 Java 

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

import com.google.cloud.storage.Bucket; import com.google.cloud.storage.Storage; import com.google.cloud.storage.StorageOptions; public class SetBucketWebsiteInfo { public static void setBucketWesbiteInfo( String projectId, String bucketName, String indexPage, String notFoundPage) { // The ID of your GCP project // String projectId = "your-project-id"; // The ID of your static website bucket // String bucketName = "www.example.com"; // The index page for a static website bucket // String indexPage = "index.html"; // The 404 page for a static website bucket // String notFoundPage = "404.html"; Storage storage = StorageOptions.newBuildersetProjectId(projectId).buildgetService Bucket bucket = storage.get(bucketName); bucket.toBuildersetIndexPage(indexPage).setNotFoundPage(notFoundPage).buildupdate System.out.println( "Static website bucket " + bucketName + " is set up to use " + indexPage + " as the index page and " + notFoundPage + " as the 404 page } }

 Node.js 

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

 * 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 the main page // const mainPageSuffix = 'httpexample.com'; // The Name of a 404 page // const notFoundPage = 'httpexample.com/404.html'; // Imports the Google Cloud client library const {Storage} = requiregoogle-cloud/storage // Creates a client const storage = new Storage async function addBucketWebsiteConfiguration() { await storage.bucket(bucketName).setMetadata({ website: { mainPageSuffix, notFoundPage, },console.log( `Static website bucket ${bucketName} is set up to use ${mainPageSuffix} as the index page and ${notFoundPage} as the 404 page` ); } addBucketWebsiteConfigurationcatch(console.error);

 PHP 

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

use Google\Cloud\Storage\StorageClient;* Update the given bucket's website configuration. * * @param string $bucketName The name of your Cloud Storage bucket. * @param string $indexPageObject the name of an object in the bucket to use as * an index page for a static website bucket. * @param string $notFoundPageObject the name of an object in the bucket to use * as the 404 Not Found page. */ function define_bucket_website_configuration($bucketName, $indexPageObject, $notFoundPageObject) { // $bucketName = 'my-bucket'; // $indexPageObject = 'index.html'; // $notFoundPageObject = '404.html'; $storage = new StorageClient $bucket = $storage->bucket($bucketName); $bucket->update([ 'website' => [ 'mainPageSuffix' => $indexPageObject, 'notFoundPage' => $notFoundPageObject ]printf( 'Static website bucket %s is set up to use %s as the index page and %s as the 404 page $bucketName, $indexPageObject, $notFoundPageObject ); }

 Python 

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

from google.cloud import storage def define_bucket_website_configuration(bucket_name, main_page_suffix, not_found_page): Configure website-related properties of bucket # bucket_name = "your-bucket-name" # main_page_suffix = "index.html" # not_found_page = "404.html" storage_client = storage.Client() bucket = storage_client.get_bucket(bucket_name) bucket.configure_website(main_page_suffix, not_found_page) bucket.patch() print( "Static website bucket {} is set up to use {} as the index page and {} as the 404 page".format( bucket.name, main_page_suffix, not_found_page ) ) return bucket

 Ruby 

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

def define_bucket_website_configuration bucket_name:, main_page_suffix:, not_found_page: # The ID of your static website bucket # bucket_name = "www.example.com" # The index page for a static website bucket # main_page_suffix = "index.html" # The 404 page for a static website bucket # not_found_page = "404.html" require "google/cloud/storage" storage = Google::Cloud::Storage.new bucket = storage.bucket bucket_name bucket.update do |b| b.website_main = main_page_suffix b.website_404 = not_found_page end puts "Static website bucket #{bucket_name} is set up to use #{main_page_suffix} as the index page and " \ not_found_page} as the 404 page" end

 API de REST 

 API de JSON 

- Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

Crea un archivo JSON que establezca las propiedades

mainPageSuffixy

notFoundPageen un objeto

websiteen las páginas deseadas:

{ "website "mainPageSuffix": "index.html", "notFoundPage": "404.html" } }

Usa

cURLpara llamar a la API de JSON con una solicitud de bucket

PATCH. Para el bucket

my-static-assets:

curl -X PATCH --data-binary @web-config.json \ -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \ -H "Content-Type: application/json" \ "httpsstorage.googleapis.com/storage/v1/b/my-static-assets"

 API de XML 

- Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth. Para obtener instrucciones, consulta Autenticación de la API.

Crea un archivo XML que establezca los elementos

MainPageSuffixy

NotFoundPagede un elemento

WebsiteConfigurationen las páginas deseadas:

 index.html 404.html 

Usa

cURLpara llamar a la API de XML con una solicitud de bucket

PUTy un parámetro de string de consulta

websiteConfig. Para my-static-assets:

curl -X PUT --data-binary @web-config.xml \ -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \ httpsstorage.googleapis.com/my-static-assets?websiteConfig

== Configura el balanceador de cargas y el certificado SSL ==

Cloud Storage no admite dominios personalizados con HTTPS por sí solo, por lo que también debes configurar un certificado SSL adjunto a un balanceador de cargas HTTPS para entregar tu sitio web mediante HTTPS. En esta sección, se muestra cómo agregar tu bucket al backend de un balanceador de cargas y cómo agregar un certificado SSL administrado por Google nuevo al frontend del balanceador de cargas.

- Ve a la página Balanceo de cargas en Google Cloud Console.

Ir a la página Balanceo de cargas

- En

Balanceo de cargas de HTTP(S), haz clic en Iniciar configuración.

- Seleccione

De Internet a mis VM o servicios sin servidores.

- Selecciona

Balanceador de cargas de HTTP(S) global.

Haga clic en

Continuar.

Aparecerá la ventana de configuración de tu balanceador de cargas.

Antes de continuar con la configuración, asígnale un

Nombreal balanceador de cargas, como

example-lb.

 Configure el backend 

- Haga clic en

Configuración de backend.

- En el menú desplegable

Servicios y buckets de backend, haz clic en Crear un bucket de backend.

- Elige un

nombre de bucket de backend, como

example-bucket. El nombre que elijas puede ser diferente del nombre del bucket que creaste antes.

- Haz clic en

Explorar, que se encuentra en el campo Bucket de Cloud Storage.

- Selecciona el bucket

my-static-assetsque creaste antes y haz clic en

Seleccionar.

- Si deseas usar Cloud CDN, selecciona la casilla de verificación para

Habilitar Cloud CDNy configura Cloud CDN como desees (opcional). Ten en cuenta que Cloud CDN puede generar costos adicionales.

- Haga clic en

Crear.

 Configura reglas de enrutamiento 

Las reglas de enrutamiento son los componentes del mapa de URL de un balanceador de cargas de HTTP(S) externo. Para este instructivo, debes omitir esta parte de la configuración del balanceador de cargas, ya que se configura de forma automática para usar el backend que acabas de configurar.

 Configure el frontend 

En esta sección, se muestra cómo configurar el protocolo HTTPS y crear un certificado SSL. También puedes seleccionar un certificado existente o subir un certificado SSL autoadministrado.

- Haga clic en

Configuración de frontend.

- Proporciona un

Nombrea tu configuración de frontend (opcional).

- Para

Protocolo, selecciona HTTPS (incluye HTTP/2).

- En

Nivel de servicio de red, selecciona Premium.

- Para

Versión de la IP, selecciona IPv4. Si prefieres IPv6, consulta Terminación de IPv6 para obtener información adicional.

Para el campo

Dirección IP:

- En el menú desplegable, haz clic en

Crear dirección IP.

- En la ventana emergente

Reservar una nueva dirección IP estática, ingresa un nombre, como

example-ippara el

Nombrede la dirección IP.

- Haga clic en

Reservar.

En

Puerto, selecciona 443.

En el menú desplegable del campo

Certificado, selecciona Crear un certificado nuevo. El formulario de creación de certificado aparecerá en un panel. Configura lo siguiente:

- Asigna un

Nombrea tu certificado, como

example-ssl.

- Para

Crear modo, selecciona Crear un certificado administrado por Google.

- Para

Dominios, ingresa el nombre del sitio web, como

www.example.com. Si deseas entregar el contenido a través de dominios adicionales, como el dominio raíz

example.com, presiona

Intropara agregarlos en líneas adicionales. Cada certificado tiene un límite de 100 dominios.

Haga clic en

Crear.

(Opcional) Si deseas que Google Cloud configure de forma automática un balanceador de cargas HTTP parcial para redireccionar el tráfico HTTP, selecciona la casilla de verificación junto a

Habilitar el redireccionamiento de HTTP a HTTPS.

Haga clic en

Listo.

 Revisa la configuración 

- Haga clic en

Revisar y finalizar.

- Revisa el

Frontend, las Reglas de enrutamientoy el Backend.

- Haga clic en

Crear.

Es posible que debas esperar unos minutos para que se cree el balanceador de cargas.

== Conecta tu dominio al balanceador de cargas ==

Después de crear el balanceador de cargas, haz clic en el nombre de tu balanceador de cargas:

example-lb. Toma nota de la dirección IP asociada con el balanceador de cargas: por ejemplo,

30.90.80.100. Para apuntar tu dominio al balanceador de cargas, crea un registro

A mediante tu servicio de registro de dominio. Si agregaste varios dominios a tu certificado SSL, debes agregar un registro

A para cada uno, que apunte a la dirección IP del balanceador de cargas. Por ejemplo, a fin de crear registros

A para

www.example.com y

example.com:

NAME TYPE DATA www A 30.90.80.100 @ A 30.90.80.100

Si usas Google Domains, consulta la página de ayuda de Google Domains para obtener más información.

== Recomendado: Supervisa el estado del certificado SSL ==

Es posible que Google Cloud demore entre 60 y 90 minutos en aprovisionar el certificado y hacer que el sitio esté disponible a través del balanceador de cargas. Para supervisar el estado de tu certificado, haz lo siguiente:

 Console 

- Ve a la página Balanceo de cargas en Google Cloud Console.

Ir a la página Balanceo de cargas

- Haz clic en el nombre de tu balanceador de cargas:

example-lb.

- Haz clic en el nombre del certificado SSL asociado con el balanceador de cargas:

example-ssl.

- Las filas

Estadoy Estado del dominiomuestran el estado del certificado. Ambas deben estar activas a fin de que el certificado sea válido para tu sitio web.

 gcloud 

Para verificar el estado del certificado, ejecuta el siguiente comando:

gcloud beta compute ssl-certificates describe

CERTIFICATE_NAME\ --global \ --format="get(name,managed.status)"

Para verificar el estado del dominio, ejecuta el siguiente comando:

gcloud beta compute ssl-certificates describe

CERTIFICATE_NAME\ --global \ --format="get(managed.domainStatus)"

Para obtener más información sobre el estado de los certificados, consulta Solución de problemas de certificados SSL.

== Pruebe el sitio web ==

Una vez que el certificado SSL esté activo, verifica que el contenido se entregue desde el bucket, para ello visita

httpswww.example.com/test.html, en el que

test.html es un objeto almacenado en el bucket que estás usando como backend. Si configuras la propiedad

MainPageSuffix,

httpswww.example.coma

index.html.

== Limpia ==

Una vez que completes el instructivo, puedes limpiar los recursos que creaste para que dejen de usar la cuota y generar cargos. En las siguientes secciones, se describe cómo borrar o desactivar estos recursos.

 Borra el proyecto 

La manera más fácil de eliminar la facturación es borrar el proyecto que creaste para el instructivo.

Para borrar el proyecto, haz lo siguiente:

- En la consola de Cloud, ve a la página

Administrar recursos.

Ir a Administrar recursos

- En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en

Borrar.

- En el diálogo, escribe el ID del proyecto y, luego, haz clic en

Cerrarpara borrar el proyecto.

 Borra el balanceador de cargas y el bucket 

Si no deseas borrar todo el proyecto, borra el balanceador de cargas y el bucket que creaste para el instructivo:

- Ve a la página Balanceo de cargas en Google Cloud Console.

Ir a la página Balanceo de cargas

- Selecciona la casilla de verificación junto a

example-lb.

- Haz clic en

Borrar.

- Selecciona la casilla de verificación junto a los recursos que deseas borrar y el balanceador de cargas, como el bucket

my-static-assetso el certificado SSL

example-ssl(opcional).

- Haz clic en

Borrar balanceador de cargaso Borrar el balanceador de cargas y los recursos seleccionados.

 Libera una dirección IP reservada 

Para borrar la dirección IP reservada que usaste en el instructivo, sigue estos pasos:

En Cloud Console, ve a la página

Direcciones IP externas.

Ir a Direcciones IP externas

Selecciona las casillas de verificación junto a

example-ip.

Haz clic en

Liberar dirección estática.

En la ventana de confirmación, haz clic en

Borrar.

== ¿Qué sigue? ==

- Obtén información sobre cómo entregar tu sitio web estático mediante HTTP.

- Consulta ejemplos y sugerencias sobre cómo usar buckets para alojar un sitio web estático.

- Visita la sección de solución de problemas para alojar un sitio web estático.

- Obtén información sobre el hosting de activos estáticos para un sitio web dinámico.

- Obtén más información sobre otras soluciones de entrega web de Google Cloud.

- Prueba otros instructivos de Google Cloud que usan Cloud Storage.

== 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