Haz públicos los datos

En esta página, se muestra cómo hacer que los objetos que posees sean legibles para todos en la Internet pública. Para obtener más información sobre cómo acceder a los datos que se hicieron públicos, consulta Accede a datos públicos.

Cuando un objeto se comparte de forma pública, cualquier usuario que conozca el URI del objeto puede acceder a él mientras sea público.

Roles obligatorios

Para obtener los permisos necesarios para que los objetos sean legibles de forma pública, pídele a tu administrador que te otorgue los siguientes roles:

Para que los objetos individuales sean legibles de forma pública: administrador de objetos de Storage (roles/storage.objectAdmin)
- Si planeas usar la consola de Google Cloud, necesitarás el rol de administrador de Storage (roles/storage.admin) en lugar del rol de administrador de objetos de Storage.
Para que todos los objetos de un bucket sean legibles de forma pública: administrador de Storage (roles/storage.admin) o propietario de buckets heredados de Storage (roles/storage.legacyBucketOwner)

Estos roles contienen los permisos necesarios para hacer públicos los objetos. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

storage.buckets.get
storage.buckets.getIamPolicy
storage.buckets.setIamPolicy
storage.buckets.update
storage.objects.get
storage.objects.getIamPolicy
storage.objects.setIamPolicy
storage.objects.update

Los siguientes permisos solo son necesarios para usar la consola de Google Cloud para realizar la tarea en esta página:

storage.buckets.list
storage.objects.list

También puedes obtener estos permisos con otros roles predefinidos o roles personalizados.

Para obtener instrucciones para otorgar roles a los buckets, consulta Usa IAM con buckets.

Haz que los objetos individuales se puedan leer de forma pública

Para que los objetos individuales sean legibles para todos en la Internet pública, otorga a la principal allUsers el rol de READER:

Console

En la consola de Google Cloud, ve a la página Buckets de Cloud Storage.
Ir a Buckets
Haz clic en el nombre del bucket que contiene el objeto que quieres hacer público y navega hasta el objeto si está en un subdirectorio.
Haz clic en el nombre del objeto.
Haz clic en acceso de edición.
En la superposición que aparece, haz clic en el botón Agregar entrada.
Para allUsers, agrega un permiso.
- En Entidad, selecciona Pública.
- En Nombre, selecciona allUsers.
- En Acceso, selecciona Lector.
Haz clic en Guardar.

Una vez que se otorgue el acceso público, Copiar URL aparecerá en la columna de acceso público. Puedes hacer clic en este botón para obtener la URL pública del objeto.

Para obtener información sobre 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

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.
En tu entorno de desarrollo, ejecuta el comando objects update con la marca --add-acl-grant:
```
gcloud storage objects update gs://BUCKET_NAME/OBJECT_NAME --add-acl-grant=entity=AllUsers,role=READER
```
Aquí:
- BUCKET_NAME es el nombre del bucket que contiene el objeto que quieres hacer público. Por ejemplo, my-bucket
- OBJECT_NAME es el nombre del objeto que quieres hacer público. Por ejemplo, pets/dog.png

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& object_name) {
  StatusOr<gcs::ObjectMetadata> updated = client.PatchObject(
      bucket_name, object_name, gcs::ObjectMetadataPatchBuilder(),
      gcs::PredefinedAcl::PublicRead());

  if (!updated) throw std::move(updated).status();
  std::cout << "Object updated. The full metadata after the update is: "
            << *updated << "\n";
}

C#

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


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

public class MakePublicSample
{
    public string MakePublic(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName);
        storageObject.Acl ??= new List<ObjectAccessControl>();
        storage.UpdateObject(storageObject, new UpdateObjectOptions { PredefinedAcl = PredefinedObjectAcl.PublicRead });
        Console.WriteLine(objectName + " is now public and can be fetched from " + storageObject.MediaLink);

        return storageObject.MediaLink;
    }
}

Go

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

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

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

// makePublic gives all users read access to an object.
func makePublic(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: %w", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Set(ctx, storage.AllUsers, storage.RoleReader); err != nil {
		return fmt.Errorf("ACLHandle.Set: %w", err)
	}
	fmt.Fprintf(w, "Blob %v is now publicly accessible.\n", object)
	return nil
}

Java

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

import com.google.cloud.storage.Acl;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class MakeObjectPublic {
  public static void makeObjectPublic(String projectId, String bucketName, String objectName) {
    // String projectId = "your-project-id";
    // String bucketName = "your-bucket-name";
    // String objectName = "your-object-name";
    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    storage.createAcl(blobId, Acl.of(Acl.User.ofAllUsers(), Acl.Role.READER));

    System.out.println(
        "Object " + objectName + " in bucket " + bucketName + " was made publicly readable");
  }
}

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage 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 ID of your GCS file
// const fileName = 'your-file-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function makePublic() {
  await storage.bucket(bucketName).file(fileName).makePublic();

  console.log(`gs://${bucketName}/${fileName} is now public.`);
}

makePublic().catch(console.error);

PHP

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

use Google\Cloud\Storage\StorageClient;

/**
 * Make an object publically accessible.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 */
function make_public(string $bucketName, string $objectName): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $object->update(['acl' => []], ['predefinedAcl' => 'PUBLICREAD']);
    printf('gs://%s/%s is now public' . PHP_EOL, $bucketName, $objectName);
}

Python

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

from google.cloud import storage


def make_blob_public(bucket_name, blob_name):
    """Makes a blob publicly accessible."""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)

    blob.make_public()

    print(
        f"Blob {blob.name} is publicly accessible at {blob.public_url}"
    )

Ruby

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

def make_public bucket_name:, file_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The ID of your GCS object to make public
  # file_name = "your-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name, skip_lookup: true
  file    = bucket.file file_name

  file.acl.public!

  puts "#{file.name} is publicly accessible at #{file.public_url}"
end

API de REST

API de JSON

Tener la gcloud CLI instalada e inicializada a 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.
Crea un archivo JSON que contenga la siguiente información:
```
{
  "entity": "allUsers",
  "role": "READER"
}
```
Usa cURL para llamar a la API de JSON con una solicitud de LCA Insert:
```
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/BUCKET_NAME/o/OBJECT_NAME/acl"
```
Aquí:
- JSON_FILE_NAME es la ruta de acceso del archivo que creaste en el paso 2.
- BUCKET_NAME es el nombre del bucket que contiene el objeto que quieres hacer público. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre con codificación URL del objeto que deseas hacer público. Por ejemplo, pets/dog.png, codificado en URL como pets%2Fdog.png.

API de XML

Tener la gcloud CLI instalada e inicializada a 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.

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

<AccessControlList>
  <Entries>
    <Entry>
      <Scope type="AllUsers"/>
      <Permission>READ</Permission>
    </Entry>
  </Entries>
</AccessControlList>

Usa cURL para llamar a la API de XML con una solicitud Set Object ACL:
```
curl -X PUT --data-binary @XML_FILE_NAME \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME?acl"
```
Aquí:
- XML_FILE_NAME es la ruta de acceso del archivo que creaste en el paso 2.
- BUCKET_NAME es el nombre del bucket que contiene el objeto que quieres hacer público. Por ejemplo, my-bucket.
- OBJECT_NAME es el nombre con codificación URL del objeto que deseas hacer público. Por ejemplo, pets/dog.png, codificado en URL como pets%2Fdog.png.

Haz que todos los objetos de un bucket se puedan leer de forma pública

Para que todos los objetos de un bucket sean legibles para todos en la Internet pública, otorga a la principal allUsers el rol de visualizador de objetos de Storage (roles/storage.objectViewer):