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.

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

A fin de que los objetos individuales sean legibles para todos en la Internet pública, sigue estos pasos:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. Revisa la columna Control de acceso del depósito que contiene el objeto que quieres hacer público. Si la columna dice Detallado, continúa con el siguiente paso. Si la columna indica Uniforme, no puedes seguir los pasos a continuación para hacer que los objetos individuales en el depósito sean legibles de forma pública. En cambio, otorga legibilidad pública a todos los objetos del depósito o usa URL firmadas.

  3. Haz clic en el nombre del depósito que contiene el objeto que quieres hacer público y navega hasta el objeto si está en un subdirectorio.

  4. Haz clic en el menú de más acciones () asociado al objeto que deseas hacer público.

  5. Selecciona Editar permisos del menú desplegable. Si la opción no existe, es posible que tengas habilitado el control de acceso Uniforme. Consulta el paso 2 para obtener más información.

  6. En la superposición que aparece, haz clic en el botón + Agregar entrada.

  7. Para allUsers, agrega un permiso.

    • En Entidad, selecciona Pública.
    • En Nombre, selecciona allUsers.
    • En Acceso, selecciona Lector.
  8. Haz clic en Guardar.

Una vez compartido públicamente, aparece un ícono de vínculo en la columna de acceso público. Puedes hacer clic en este ícono para obtener la URL del objeto.

Consulta Solución de problemas para obtener información detallada sobre las operaciones fallidas en el navegador de Cloud Storage.

gsutil

Usa el comando gsutil acl ch:

gsutil acl ch -u AllUsers:R gs://BUCKET_NAME/OBJECT_NAME

Donde:

  • BUCKET_NAME es el nombre del depósito 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.

Si se ejecuta de forma correcta, la respuesta se parece al siguiente ejemplo:

Updated ACL on gs://my-bucket/pets/dog.png

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

  if (!updated) throw std::runtime_error(updated.status().message());
  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 para C#.

private void MakePublic(string bucketName, string objectName)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName);
    storageObject.Acl = 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);
}

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

// makePublic gives all users read access to an object.
func makePublic(w io.Writer, bucket, object string, entity storage.ACLEntity, role storage.ACLRole) 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()

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

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Set(ctx, entity, role); err != nil {
		return fmt.Errorf("ACLHandle.Set: %v", 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 para 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 para Node.js.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'File to make public, e.g. file.txt';

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

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

async function makePublic() {
  // Makes the file public
  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 para PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Make an object publically accessible.
 *
 * @param string $bucketName the name of your Cloud Storage bucket.
 * @param string $objectName the name of your Cloud Storage object.
 *
 * @return void
 */
function make_public($bucketName, $objectName)
{
    $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 para 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(
        "Blob {} is publicly accessible at {}".format(
            blob.name, blob.public_url
        )
    )

Ruby

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

# bucket_name = "Your Google Cloud Storage bucket name"
# file_name   = "Name of file in Google Cloud Storage to make public"

require "google/cloud/storage"

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

file.acl.public!

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

API de REST

API de JSON

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Crea un archivo .json que contenga la siguiente información:

    {
      "entity": "allUsers",
      "role": "READER"
    }
  3. Usa cURL para llamar a la API de JSON con una solicitud de LCA Insert:

    curl -X POST --data-binary @JSON_FILE_NAME.json \
      -H "Authorization: Bearer OAUTH2_TOKEN" \
      -H "Content-Type: application/json" \
      "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/o/OBJECT_NAME/acl"

    Donde:

    • JSON_FILE_NAME es el nombre del archivo que creaste en el paso 2.
    • OAUTH2_TOKEN es el token de acceso que creaste en el paso 1.
    • BUCKET_NAME es el nombre del depósito 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.

API de XML

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus credenciales de OAuth.
  2. Crea un archivo .xml que contenga la siguiente información:

    <AccessControlList>
      <Entries>
        <Entry>
          <Scope type="AllUsers"/>
          <Permission>READ</Permission>
        </Entry>
      </Entries>
    </AccessControlList>
  3. Usa cURL para llamar a la API de XML con una solicitud Set Object ACL:

    curl -X PUT --data-binary @XML_FILE_NAME.xml \
      -H "Authorization: Bearer OAUTH2_TOKEN" \
      "https://storage.googleapis.com/BUCKET_NAME/OBJECT_NAME?acl"

    Donde:

    • XML_FILE_NAME es el nombre del archivo que creaste en el paso 2.
    • OAUTH2_TOKEN es el token de acceso que creaste en el paso 1.
    • BUCKET_NAME es el nombre del depósito 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.

Haz que todos los objetos de un depósito se puedan leer de forma pública

A fin de que los objetos de un depósito sean legibles para todos en la Internet pública, sigue estos pasos:

Console

  1. Abre el navegador de Cloud Storage en Google Cloud Console.
    Abrir el navegador de Cloud Storage
  2. En la lista de depósitos, haz clic en el nombre del depósito que deseas hacer público.

  3. Selecciona la pestaña Permisos cerca de la parte superior de la página.

  4. Haz clic en el botón Agregar miembros.

    Aparece el cuadro de diálogo Agregar miembros.

  5. En el campo Miembros nuevos, ingresa allUsers.

  6. En el menú desplegable Seleccionar una función, selecciona el submenú Cloud Storage y haz clic en la opción Visualizador de objetos de almacenamiento.

  7. Haz clic en Guardar.

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 para obtener la URL del objeto.

Consulta Solución de problemas para obtener información detallada sobre las operaciones fallidas en el navegador de Cloud Storage.

gsutil

Usa el comando gsutil iam ch:

gsutil iam ch allUsers:objectViewer gs://BUCKET_NAME

En este comando, BUCKET_NAME es el nombre del depósito cuyos objetos quieres hacer públicos. Por ejemplo, my-bucket.

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) {
  StatusOr<google::cloud::IamPolicy> current_policy =
      client.GetBucketIamPolicy(bucket_name);

  if (!current_policy) {
    throw std::runtime_error(current_policy.status().message());
  }

  current_policy->bindings.AddMember("roles/storage.objectViewer",
                                     "allUsers");

  // Update the policy. Note the use of `gcs::IfMatchEtag` to implement
  // optimistic concurrency control.
  StatusOr<google::cloud::IamPolicy> updated_policy =
      client.SetBucketIamPolicy(bucket_name, *current_policy,
                                gcs::IfMatchEtag(current_policy->etag));

  if (!updated_policy) {
    throw std::runtime_error(current_policy.status().message());
  }

  auto role = updated_policy->bindings.find("roles/storage.objectViewer");
  if (role == updated_policy->bindings.end()) {
    std::cout << "Cannot find 'roles/storage.objectViewer' in the updated"
              << " policy. This can happen if another application updates"
              << " the IAM policy at the same time. Please retry the"
              << " operation.\n";
    return;
  }
  auto member = role->second.find("allUsers");
  if (member == role->second.end()) {
    std::cout << "'allUsers' is not a member of the"
              << " 'roles/storage.objectViewer' role in the updated"
              << " policy. This can happen if another application updates"
              << " the IAM policy at the same time. Please retry the"
              << " operation.\n";
    return;
  }
  std::cout << "IamPolicy successfully updated for bucket " << bucket_name
            << '\n';
}

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.newBuilder().setProjectId(projectId).build().getService();
    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 now publicly readable");
  }
}

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 set_bucket_public_iam(bucket_name, role, member):
    """Set a public IAM Policy to bucket"""
    # bucket_name = "your-bucket-name"
    # role = "IAM role, e.g. roles/storage.objectViewer"
    # member = "IAM identity, e.g. allUsers"

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

    policy = bucket.get_iam_policy(requested_policy_version=3)
    policy.bindings.append({"role": role, "members": {member}})

    bucket.set_iam_policy(policy)

    print("Bucket {} is now publicly readable".format(bucket.name))

API de REST

API de JSON

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Crea un archivo .json que contenga la siguiente información:

    {
      "bindings":[
        {
          "role": "roles/storage.objectViewer",
          "members":["allUsers"]
        }
      ]
    }
  3. Usa cURL para llamar a la API de JSON con una solicitud de depósito PUT:

    curl -X PUT --data-binary @JSON_FILE_NAME.json \
      -H "Authorization: Bearer OAUTH2_TOKEN" \
      -H "Content-Type: application/json" \
      "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"

    Donde:

    • JSON_FILE_NAME es el nombre del archivo que creaste en el paso 2.
    • OAUTH2_TOKEN es el token de acceso que creaste en el paso 1.
    • BUCKET_NAME es el nombre del depósito cuyos objetos quieres hacer públicos. Por ejemplo, my-bucket.

API de XML

La API de XML no admite que todos los objetos de un depósito se hagan legibles de forma pública. Usa gsutil o la API de JSON en su lugar.

Próximos pasos