Crea y administra Listas de control de acceso (LCA)

Ir a los conceptos

En esta página, se describe cómo controlar el acceso a depósitos y objetos con Listas de control de acceso (LCA). Las LCA son un mecanismo que puedes usar para determinar quién tiene acceso a tus buckets y objetos y qué nivel de acceso tienen.

Para obtener información sobre otras formas de controlar el acceso a los buckets y objetos, consulta la Descripción general del control de acceso.

Antes de comenzar

¿Deberías usar LCA?

En la mayoría de los casos, la administración de identidades y accesos (IAM) es el método recomendado para controlar el acceso a tus recursos, ya que proporciona control de acceso de nivel empresarial en todo Google Cloud y permite que los permisos asignados a recursos superiores, como proyectos, se hereden mediante recursos secundarios, como buckets y objetos. Consulta Usa permisos de IAM a fin de obtener guías para trabajar con IAM en Cloud Storage.

Es más probable que debas usar las LCA si necesitas personalizar el acceso a objetos individuales dentro de un bucket, porque los permisos de IAM se aplican a todos los objetos dentro de un bucket. Sin embargo, deberías usar IAM para cualquier acceso que sea común a todos los objetos de un bucket, ya que reduce la cantidad de tareas de administración detallada que debes llevar a cabo.

Precaución: Se pueden otorgar permisos con LCA o políticas de IAM: un usuario solo necesita permiso de una de estas para poder acceder a un objeto o bucket. En general, los permisos que otorgan las políticas de IAM no aparecen en las LCA y viceversa. La única excepción son las LCA aplicadas directamente a un bucket y ciertas políticas de IAM a nivel del bucket, como se describe en la relación entre IAM y las LCA.

¿Necesitas establecer una LCA?

Según el permiso que quieres que tenga un bucket o un objeto, quizás no necesites establecer una LCA. Los bucket s y objetos se crean con LCA predeterminadas que quizás ya contengan el permiso que quieres que tenga el objeto o bucket.

Usa la guía siguiente para decidir si necesitas establecer una LCA.

En depósitos:

Console

Los buckets nuevos se crean con la LCA project-private predefinida. Si es necesario un permiso diferente para tu bucket, establece una LCA.

gsutil

Los buckets nuevos se agregan como project-private. Si es necesario un permiso diferente para tu bucket, establece una LCA.

API de JSON

De forma predeterminada, los nuevos buckets se agregan como project-private. Si es necesario un permiso diferente para tu bucket, establece una LCA.

API de XML

Los buckets nuevos se agregan como project-private. Si tu bucket necesita un permiso diferente, establece una LCA.

Como se muestra arriba, cada depósito tiene una LCA de objeto predeterminada que se aplica a todos los objetos subidos en ese depósito que no tienen una LCA predefinida o (si usas la API de JSON) una LCA especificada en la solicitud. Obtén más información en LCA de objeto predeterminado.

En objetos:

Console

Los objetos subidos tienen la misma LCA que el objeto del depósito y el usuario que carga se agrega como propietario de la LCA. Si tu objeto necesita un permiso diferente, establece una LCA.

gsutil

Los objetos nuevos se agregan con la LCA de objeto predeterminada al bucket. Cuando copias un objeto ya almacenado en la nube, puedes anular este comportamiento con la opción -p.

API de JSON

Por configuración predeterminada, los objetos nuevos se agregan con la LCA de objeto predeterminada del bucket.

API de XML

Los objetos nuevos se agregan con la LCA de objeto predeterminada al bucket.

¿Qué interfaz deberías usar?

En los siguientes ejemplos, se muestra cómo configurar el control de acceso con Google Cloud Console, la herramienta de línea de comandos de gsutil, las bibliotecas cliente de Cloud Storage y las API de XML y JSON. Consulta los siguientes lineamientos para elegir cuál utilizar:

• Si es la primera vez que usas el control de acceso y solo deseas modificar las LCA de objetos individuales, utiliza Cloud Console.

• Si eres nuevo en el control de acceso y solo deseas modificar las LCA para buckets y objetos, usa gsutil.

• Si tienes experiencia con una de las bibliotecas cliente de Cloud Storage, úsala para administrar tus LCA.

• Si especificas LCA con una API, debes tener experiencia previa en la generación de solicitudes HTTP. Puedes usar tu herramienta o aplicación favorita para enviar solicitudes HTTP. En los ejemplos, usamos la herramienta cURL. Visita OAuth 2.0 Playground para obtener tokens de autorización que puedes usar en los ejemplos de cURL.

Establece las LCA

La herramienta o API que usas para establecer y obtener las LCA determina la sintaxis de LCA que usas. Las sintaxis de LCA tienen aspectos diferentes, pero contienen la misma información de LCA: entradas que otorgan permisos a alcances.

Console

Nota: No puedes usar Cloud Console para configurar las LCA de los buckets; solo puedes usarlo a fin de configurar las de objetos individuales.

1. En Cloud Console, ve al navegador de Cloud Storage.
   Ir al navegador de Cloud Storage

2. Navega hasta el objeto cuya LCA deseas modificar.

3. Selecciona Editar permisos en el menú más acciones () asociado al objeto.

   Deberías ver un diálogo de permiso con el siguiente aspecto:

   En esta captura de pantalla, se muestra una LCA con cuatro entradas:

   • En la primera entrada, todos los propietarios de un proyecto específico (uno cuyo número de proyecto es 867489140601) reciben el acceso y permiso de “Propietario” para este objeto.
   • En la segunda entrada, todos los editores de un proyecto específico (uno cuyo número de proyecto es 867489140601) también reciben el acceso y permiso de “Propietario” para este objeto.
   • En la tercera entrada, todos los lectores de un proyecto específico (uno cuyo número de proyecto es 867489140601) reciben el acceso o permiso de “Lector” para este objeto.
   • En la cuarta entrada, el usuario que subió el objeto recibe el acceso o permiso de “Propietario” para el objeto. Los usuarios que cargan objetos siempre son considerados “Propietarios” y no pueden quitarse este permiso.

4. Haz clic en Add item (Agregar elemento).

5. Elige el tipo de Entity (Entidad) a la que quieres darle permiso.

   Entidad especifica el tipo de entidad que obtiene el permiso (por ejemplo, un usuario o un grupo). Consulta los Alcances de control de acceso a fin de obtener una lista de los valores admitidos para Entidad.

6. Ingresa un valor en Name (Nombre).

   Nombre identifica a un usuario, grupo o algún otro tipo de entidad específica. Consulta los Alcances de control de acceso a fin de obtener una lista de los valores admitidos para Nombre.

   Juntos, Entidad y Nombre definen a quién se le aplica el permiso.

7. Elige un valor en Access (Acceso).

   Acceso define el permiso que quieres establecer en el objeto. Consulta los Permisos de control de acceso a fin de obtener una lista de los valores admitidos para Acceso.

8. 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 gsutil acl para especificar las LCA:

• Para especificar otorgamientos individuales, ingresa la siguiente información:

  gsutil acl ch -u USER_EMAIL:PERMISSION gs://BUCKET_NAME

• Para especificar LCA estándares, ingresa esta información:

  gsutil acl set CANNED_ACL_NAME gs://BUCKET_NAME

• Para especificar LCA en el formato de JSON, ingresa esta información:

  gsutil acl set JSON_FILE gs://BUCKET_NAME

  donde JSON_FILE contiene las LCA especificadas en formato de JSON.

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++.

En el ejemplo siguiente, se agrega una LCA a un bucket:

Ver en GitHubComentarios

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& entity) {
  StatusOr<gcs::BucketAccessControl> patched_acl =
      client.PatchBucketAcl(bucket_name, entity,
                            gcs::BucketAccessControlPatchBuilder().set_role(
                                gcs::BucketAccessControl::ROLE_OWNER()));

  if (!patched_acl) throw std::runtime_error(patched_acl.status().message());
  std::cout << "ACL entry for " << patched_acl->entity() << " in bucket "
            << patched_acl->bucket() << " is now " << *patched_acl << "\n";
}

En el siguiente ejemplo, se agrega una LCA a un objeto:

Ver en GitHubComentarios

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& entity) {
  StatusOr<gcs::ObjectAccessControl> patched_acl =
      client.CreateObjectAcl(bucket_name, object_name, entity,
                             gcs::ObjectAccessControl::ROLE_OWNER());

  if (!patched_acl) throw std::runtime_error(patched_acl.status().message());
  std::cout << "ACL entry for " << patched_acl->entity() << " in object "
            << patched_acl->object() << " in bucket " << patched_acl->bucket()
            << " is now " << *patched_acl << "\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 ejemplo siguiente, se agrega una LCA a un bucket:

Ver en GitHubComentarios

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

public class AddBucketOwnerSample
{
    public Bucket AddBucketOwner(
        string bucketName = "your-unique-bucket-name",
        string userEmail = "[e-mail]")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });

        bucket.Acl ??= new List<BucketAccessControl>();

        bucket.Acl.Add(new BucketAccessControl
        {
            Bucket = bucketName,
            Entity = $"user-{userEmail}",
            Role = "OWNER",
        });
        var updatedBucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Added user { userEmail } as an owner on bucket { bucketName }.");
        return updatedBucket;
    }
}

En el siguiente ejemplo, se agrega una LCA a un objeto:

Ver en GitHubComentarios

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

public class AddFileOwnerSample
{
    public Google.Apis.Storage.v1.Data.Object AddFileOwner(
        string bucketName = "your-unique-bucket-name",
        string objectName = "my-file-name",
        string userEmail = "[e-mail]")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions
        {
            Projection = Projection.Full
        });

        storageObject.Acl.Add(new ObjectAccessControl
        {
            Bucket = bucketName,
            Entity = $"user-{userEmail}",
            Role = "OWNER",
        });
        var updatedObject = storage.UpdateObject(storageObject);
        Console.WriteLine($"Added user { userEmail} as an owner on file { objectName}.");
        return updatedObject;
    }
}

Go

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

En el ejemplo siguiente, se agrega una LCA a un bucket:

Ver en GitHubComentarios

import (
	"context"
	"fmt"

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

// addBucketOwner adds ACL to the specified bucket.
func addBucketOwner(bucket string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// entity := storage.AllUsers
	role := storage.RoleOwner

	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).ACL()
	if err := acl.Set(ctx, entity, role); err != nil {
		return fmt.Errorf("ACLHandle.Set: %v", err)
	}
	return nil
}

En el siguiente ejemplo, se agrega una LCA a un objeto:

Ver en GitHubComentarios

import (
	"context"
	"fmt"

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

// addFileOwner adds ACL to the specified object.
func addFileOwner(bucket, object string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// object := "object-name"
	// entity := storage.AllUsers
	role := storage.RoleOwner

	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Set(ctx, entity, role); err != nil {
		return fmt.Errorf("ACLHandle.Set: %v", err)
	}
	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 ejemplo siguiente, se agrega una LCA a un bucket:

Ver en GitHubComentarios

Acl acl = storage.createAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));

En el siguiente ejemplo, se agrega una LCA a un objeto:

Ver en GitHubComentarios

BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
Acl acl = storage.createAcl(blobId, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));

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 ejemplo siguiente, se agrega una LCA a un bucket:

Ver en GitHubComentarios

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

// The email address of the user to add
// const userEmail = 'user-email-to-add';

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

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

async function addBucketOwner() {
  // Makes the user an owner of the bucket. You can use addAllUsers(),
  // addDomain(), addProject(), addGroup(), and addAllAuthenticatedUsers()
  // to grant access to different types of entities. You can also use "readers"
  // and "writers" to grant different roles.
  await storage.bucket(bucketName).acl.owners.addUser(userEmail);

  console.log(`Added user ${userEmail} as an owner on bucket ${bucketName}.`);
}

addBucketOwner().catch(console.error);

En el siguiente ejemplo, se agrega una LCA a un objeto:

Ver en GitHubComentarios

/**
 * 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 file to access
// const fileName = 'file.txt';

// The email address of the user to add
// const userEmail = 'user-email-to-add';

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

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

async function addFileOwner() {
  await storage
    .bucket(bucketName)
    .file(fileName)
    .acl.owners.addUser(userEmail);

  console.log(`Added user ${userEmail} as an owner on file ${fileName}.`);
}

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

En el ejemplo siguiente, se agrega una LCA a un bucket:

Ver en GitHubComentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Add an entity and role to a bucket's ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $entity The entity for which to update access controls.
 * @param string $role The permissions to add for the specified entity.
 */
function add_bucket_acl($bucketName, $entity, $role)
{
    // $bucketName = 'my-bucket';
    // $entity = '[e-mail]';
    // $role = 'OWNER';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->acl();
    $acl->add($entity, $role);
    printf('Added %s (%s) to gs://%s ACL' . PHP_EOL, $entity, $role, $bucketName);
}

En el siguiente ejemplo, se agrega una LCA a un objeto:

Ver en GitHubComentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Add an entity and role to an object's ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $entity The entity for which to update access controls.
 * @param string $role The permissions to add for the specified entity.
 */
function add_object_acl($bucketName, $objectName, $entity, $role)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $entity = '[e-mail]';
    // $role = 'OWNER';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    $acl->add($entity, $role);
    printf('Added %s (%s) to gs://%s/%s ACL' . PHP_EOL, $entity, $role, $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 ejemplo siguiente, se agrega una LCA a un bucket:

Ver en GitHubComentarios

from google.cloud import storage

def add_bucket_owner(bucket_name, user_email):
    """Adds a user as an owner on the given bucket."""
    # bucket_name = "your-bucket-name"
    # user_email = "[e-mail]"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)

    # Reload fetches the current ACL from Cloud Storage.
    bucket.acl.reload()

    # You can also use `group()`, `domain()`, `all_authenticated()` and `all()`
    # to grant access to different types of entities.
    # You can also use `grant_read()` or `grant_write()` to grant different
    # roles.
    bucket.acl.user(user_email).grant_owner()
    bucket.acl.save()

    print(
        "Added user {} as an owner on bucket {}.".format(
            user_email, bucket_name
        )
    )

En el siguiente ejemplo, se agrega una LCA a un objeto:

Ver en GitHubComentarios

from google.cloud import storage

def add_blob_owner(bucket_name, blob_name, user_email):
    """Adds a user as an owner on the given blob."""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"
    # user_email = "[e-mail]"

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

    # Reload fetches the current ACL from Cloud Storage.
    blob.acl.reload()

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # grant access to different types of entities. You can also use
    # `grant_read` or `grant_write` to grant different roles.
    blob.acl.user(user_email).grant_owner()
    blob.acl.save()

    print(
        "Added user {} as an owner on blob {} in bucket {}.".format(
            user_email, blob_name, 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 ejemplo siguiente, se agrega una LCA a un bucket:

Ver en GitHubComentarios

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.acl.add_owner email

puts "Added OWNER permission for #{email} to #{bucket_name}"

En el siguiente ejemplo, se agrega una LCA a un objeto:

Ver en GitHubComentarios

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# file_name   = "Name of a file in the Storage bucket"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

file.acl.add_owner email

puts "Added OWNER permission for #{email} to #{file_name}"

API de JSON

Cuando creas un bucket, puedes especificar la propiedad acl[] en una solicitud de inserción. Para un bucket existente, especifica la propiedad acl[] en una solicitud de parche o de actualización.

Cuando creas un objeto, puedes especificar la propiedad acl[] en el cuerpo de la solicitud o el parámetro de consulta predefinedAcl en una solicitud de inserción. Para un objeto existente, especifica la propiedad acl[] o el parámetro de consulta predefinedAcl en una solicitud de parche o de actualización.

Para ver las definiciones de las propiedades de la LCA del bucket y del objeto, consulta los respectivos recursos BucketAccessControls y ObjectAccessControls.

El siguiente ejemplo, se muestran entradas diferentes de LCA de bucket.

"acl": [
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/project-owners-123412341234",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/project-owners-123412341234",
"bucket": "example-bucket",
"entity": "project-owners-123412341234",
"role": "OWNER",
"projectTeam": {
       "projectNumber": "123412341234",
       "team": "owners"
},
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/project-editors-123412341234",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/project-editors-123412341234",
"bucket": "example-bucket",
"entity": "project-editors-123412341234",
"role": "OWNER",
"projectTeam": {
     "projectNumber": "123412341234",
     "team": "editors"
},
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/project-viewers-123412341234",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/project-viewers-123412341234",
"bucket": "example-bucket",
"entity": "project-viewers-123412341234",
"role": "READER",
"projectTeam": {
     "projectNumber": "123412341234",
     "team": "viewers"
},
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/[e-mail]",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/[e-mail]",
"bucket": "example-bucket",
"entity": "[e-mail]",
"role": "READER",
"email": "[e-mail]",
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/[e-mail]",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/[e-mail]",
"bucket": "example-bucket",
"entity": "[e-mail]",
"role": "READER",
"email": "[e-mail]",
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/allUsers",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/allUsers",
"bucket": "example-bucket",
"entity": "allUsers",
"role": "READER",
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/allAuthenticatedUsers",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/allAuthenticatedUsers",
"bucket": "example-bucket",
"entity": "allAuthenticatedUsers",
"role": "READER",
"etag": "CDk="
}
]

API de XML

En la API de XML, trabajas con LCA en formato XML. Debes adjuntar un documento XML al cuerpo de las solicitudes para cambiar las LCA del bucket y del objeto. Se muestra un documento XML cuando obtienes las LCA del bucket y del objeto. El documento XML contiene entradas de LCA del objeto o bucket individual.

• Después de crear un bucket con una solicitud de bucket PUT, usa una segunda solicitud de bucket PUT con el parámetro ?acl para cambiar la LCA.

• Después de subir un objeto con una solicitud de objeto PUT, cambia la LCA con otra solicitud PUT con el parámetro ?acl o el encabezado de solicitud x-googl-acl.

Usa la siguiente sintaxis de LCA para la API de XML.

Elemento	Descripción
AccessControlList	Contenedor para elementos Entries y Owner
Owner	Contenedor para elementos DisplayName y ID Este elemento no es necesario para los objetos, ya que un objeto siempre es propiedad el usuario que lo subió. Este elemento se usa cuando empleas la sintaxis de la LCA de Amazon S3 en una situación de migración. Amazon Simple Storage Service^™ y Amazon S3^™ son marcas registradas de Amazon.com, Inc. o sus afiliados en Estados Unidos y otros países.
ID	ID de Google Cloud Storage del propietario del bucket.
DisplayName	No implementado por el momento. El valor es siempre una string vacía.
Entries	Contenedor para cero o más elementos Entry
Entry	Contenedor para elementos Scope y Permission. Un Entry debe contener solo un Scope y un elemento Permission.
Scope	Contenedor para un elemento ID, EmailAddress o Domain con el que se define el alcance de la LCA. Este elemento debe tener un atributo type que contenga uno de los siguientes valores: UserByID, UserByEmail, GroupByID, GroupByEmail, GroupByDomain, AllUsers o AllAuthenticatedUsers.
ID	Un identificador para el beneficiario cuando con el ID se especifica la entrada de permiso.
EmailAddress	El identificador de correo electrónico para el beneficiario cuando la entrada de permiso la especifica el correo electrónico.
Domain	El identificador de dominio para el beneficiario cuando con el dominio se especifica la entrada de permiso.
Name	Elemento opcional que se puede especificar o que se puede agregar de forma automática si el alcance es UserByEmail o GroupByEmail.
Permission	El permiso otorgado READ, WRITE o FULL_CONTROL.

Cuando trabajas con LCA, usa la API de XML de la siguiente manera:

• Solo puedes usar el formato XML que se describió antes.

• No puedes establecer alcances duplicados.

  Puedes tener muchas entradas en tu XML de la LCA, pero no puedes tener entradas con alcances duplicados. Por ejemplo, no puedes tener dos entradas con el mismo elemento de alcance de [e-mail].

En el siguiente ejemplo, se muestran diferentes entradas de LCA de bucket:

<?xml version="1.0" encoding="UTF-8"?>
<AccessControlList>
<Owner>
    <ID>00b4903a9721...</ID>
</Owner>
<Entries>
    <Entry>
      <Scope type="GroupById">
        <ID>00b4903a9722...</ID>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type="GroupById">
        <ID>00b4903a9723...</ID>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type="GroupById">
        <ID>00b4903a9724...</ID>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="GroupByDomain">
        <Domain>example.com</Domain>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="GroupByEmail">
        <EmailAddress>[e-mail]</EmailAddress>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="UserByEmail">
        <EmailAddress>[e-mail]</EmailAddress>
        <Name>jane</Name>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="AllUsers"/>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="AllAuthenticatedUsers"/>
      <Permission>READ</Permission>
    </Entry>
</Entries>
</AccessControlList>

Establece el elemento Nombre en el XML de la LCA

Cuando recuperas una LCA de un objeto o bucket, podrías observar un elemento <Name> adicional adjunto a algunas de tus entradas. Por ejemplo, quizás veas una entrada con el siguiente aspecto:

<Entry>
    <Scope type="UserByEmail">
      <EmailAddress>[e-mail]</EmailAddress>
      <Name>Jane</Name>
    </Scope>
    <Permission>FULL_CONTROL</Permission>
</Entry>

Estos elementos opcionales <Name> se propagan en las siguientes dos circunstancias:

1. Cuando las LCA de objeto o bucket incluyen <Name> como elemento

   Cuando estableces las LCA, puedes elegir incluir el elemento <Name> con tus entradas de LCA. Puedes proporcionar cualquier valor en el elemento <Name>; Cloud Storage recuerda estos valores hasta que se quita o reemplaza la LCA. Este método puede ser útil si usas identificadores que no son fáciles de identificar, como los ID de Google Cloud Storage.

2. Cuando un alcance UserByEmail o GroupByEmail contiene un perfil público de Google.

   Si usas uno de estos alcances, pero no proporcionas un elemento <Name>, Cloud Storage verifica si el usuario o Grupo de Google asociado con la dirección de correo electrónico tiene un perfil público de Google con un nombre público. Si es así, con Cloud Storage se propaga de forma automática el elemento <Name> con el nombre público.

Aplica una LCA predefinida

En vez de especificar la LCA en su totalidad de a una entrada a la vez como se muestra arriba, puedes usar una LCA predefinida. Esta se aplicará de forma automática a un número de entradas personalizadas en una situación específica. Puedes aplicar una LCA predefinida a un bucket o un objeto con gsutil, la API de JSON o la API de XML.

En objetos nuevos

Para aplicar una LCA predefinida a un objeto mientras se sube, haz lo siguiente:

Console

No puedes aplicar una LCA predefinida con Cloud Console. En su lugar, usa gsutil.

gsutil

Use la opción -a con el comando gsutil cp para aplicar la LCA predefinida:

gsutil cp -a PREDEFINED_ACL OBJECT gs://BUCKET_NAME

Por ejemplo, para aplicar la LCA predefinida bucket-owner-read cuando se sube un objeto paris.jpg a un bucket example-travel-maps, haz lo siguiente:

gsutil cp -a bucket-owner-read paris.jpg gs://example-travel-maps

API de JSON

Usa el parámetro predefinedAcl de string de consulta en una solicitud de inserción para aplicar la LCA predefinida.

Por ejemplo, para aplicar la LCA predefinida bucketOwnerRead cuando se sube un objeto paris.jpg a un bucket example-travel-maps, haz lo siguiente:

curl -X POST --data-binary @paris.jpg -H "Content-Type: image/jpeg" 

     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"  

     "https://storage.googleapis.com/upload/storage/v1/b/example-travel-maps/o?name=paris.jpg&predefinedAcl=bucketOwnerRead"

La solicitud se ve como el siguiente ejemplo:

POST /upload/storage/v1/b/example-travel-maps/o?name=paris.jpg&amppredefinedAcl=bucketOwnerRead HTTP/1.1
Host: www.googleapis.com
Content-Type: image/jpeg
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
Content-Length: 12345
Date: Fri, 10 Oct 2014 00:02:38 GMT

API de XML

Usa el encabezado x-goog-acl en una solicitud Put de objeto para aplicar la LCA predefinida.

Por ejemplo, para aplicar la LCA predefinida bucket-owner-read cuando se sube un objeto paris.jpg a un bucket example-travel-maps, haz lo siguiente:

curl -X PUT --upload-file paris.jpg -H "x-goog-acl: bucket-owner-read" 

     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"  

     https://storage.googleapis.com/example-travel-maps/paris.jpg

La solicitud se ve como el siguiente ejemplo:

PUT /paris.jpg HTTP/1.1
Host: example-travel-maps.storage.googleapis.com
Date: Thu, 09 Oct 2014 23:06:08 GMT
Content-Length: 12345
Content-Type: image/jpg
x-goog-acl: bucket-owner-read
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
 
12345 bytes in entity body

En objetos o depósitos existentes

También puedes aplicar una LCA predefinida en un objeto o bucket existente, que es útil si deseas cambiar de una LCA predefinida a otra, o si deseas actualizar una LCA personalizada a una predefinida.

Console

No puedes aplicar una LCA predefinida con Cloud Console. En su lugar, usa gsutil.

gsutil

Use el comando gsutil acl set para aplicar la LCA predefinida:

gsutil acl set PREDEFINED_ACL gs://BUCKET_NAME/OBJECT_NAME

Por ejemplo, para aplicar la LCA predefinida private al objeto paris.jpg en el bucket example-travel-maps, haz lo siguiente:

gsutil acl set private gs://example-travel-maps/paris.jpg

API de JSON

Usa el parámetro de string de consulta predefinedAcl y especifica una propiedad vacía acl en una solicitud de parche para aplicar la LCA predefinida.

Por ejemplo, para aplicar la LCA predefinida private al objeto paris.jpg en el bucket example-travel-maps, haz lo siguiente:

curl -X PATCH --data '{"acl": []}'  -H "Content-Type: application/json" 

     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"  

     https://storage.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg?predefinedAcl=private

La solicitud se ve como el siguiente ejemplo:

PATCH /storage/v1/b/example-travel-maps/o/paris.jpg?predefinedAcl=private HTTP/1.1
Host: www.googleapis.com
Content-Type: application/json
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
Content-Length: 11
Date: Fri, 10 Oct 2014 18:57:59 GMT

API de XML

Usa el encabezado x-goog-acl con el parámetro de string de consulta acl en una solicitud Put de objeto, pero no incluyas un documento XML en ella.

Por ejemplo, para aplicar la LCA predefinida private al objeto paris.jpg en el bucket example-travel-maps, haz lo siguiente:

curl -X PUT -H "Content-Length: 0" 

    -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" 

    -H "x-goog-acl: private" https://storage.googleapis.com/example-travel-maps/paris.jpg?acl

La solicitud se ve como el siguiente ejemplo:

PUT /paris.jpg?acl HTTP/1.1
Host: example-travel-maps.storage.googleapis.com
Date: Thu, 09 Oct 2014 23:14:59 GMT
Content-Length: 0
x-goog-acl: private
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
 
empty entity body

Establece LCA de objeto predeterminada

Para evitar establecer LCA cada vez que creas un objeto nuevo, puedes determinar una LCA de objeto predeterminada en un bucket. Una vez que haces esto, se le aplicará la LCA predeterminada a cada objeto nuevo agregado a ese bucket que no tenga una aplicada de forma explícita. Por ejemplo, quizás desees especificar que solo un determinado grupo de usuarios tenga acceso a la mayoría de los objetos en un bucket determinado. Puedes cambiar la LCA de objeto predeterminada y, luego, agregar objetos al bucket. A estos objetos agregados se les aplica de forma automática la LCA de objeto predeterminada que especificaste; sin embargo, puedes proporcionar diferentes LCA a objetos específicos, en cuyo caso no se les aplicará la LCA predeterminada.

Importante: Si cambias la LCA de objeto predeterminada de un bucket, es posible que el cambio demore en propagarse y que los objetos nuevos creados en el bucket obtengan la LCA de objeto predeterminada anterior durante un corto período (consulta la Coherencia). Para garantizar que los objetos nuevos creados en el bucket obtengan la LCA de objeto predeterminada actualizada, debes esperar un mínimo de 30 segundos entre el cambio de la LCA de objeto predeterminada y la creación de objetos nuevos.

Para ver y cambiar la LCA de objeto predeterminada de un bucket, haz lo siguiente:

Console

No puedes establecer LCA de objeto predeterminadas con Cloud Console. En su lugar, usa gsutil.

gsutil

1. Usa gsutil defacl para recuperar la LCA de objeto predeterminada:

   gsutil defacl get gs://BUCKET_NAME

2. Usa gsutil defacl ch o gsutil defacl set para modificar la LCA de objeto predeterminada.

   Por ejemplo, con el siguiente comando, se agrega [e-mail] a la LCA de objeto predeterminada de un bucket example-travel-maps:

   gsutil defacl ch -u [e-mail]:READER gs://example-travel-maps

   También puedes especificar la LCA de objeto predeterminada desde un archivo. Para obtener más información, consulta la ayuda de gsutil defacl.

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++.

En el siguiente ejemplo, se agrega una LCA de objeto predeterminada a un bucket:

Ver en GitHubComentarios

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& entity, std::string const& role) {
  StatusOr<gcs::ObjectAccessControl> default_object_acl =
      client.CreateDefaultObjectAcl(bucket_name, entity, role);

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

  std::cout << "Role " << default_object_acl->role()
            << " will be granted default to " << default_object_acl->entity()
            << " on any new object created on bucket "
            << default_object_acl->bucket() << "\n"
            << "Full attributes: " << *default_object_acl << "\n";
}

En la siguiente tabla, se borra una LCA de objeto predeterminada de un bucket:

Ver en GitHubComentarios

namespace gcs = ::google::cloud::storage;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& entity) {
  google::cloud::Status status =
      client.DeleteDefaultObjectAcl(bucket_name, entity);

  if (!status.ok()) throw std::runtime_error(status.message());
  std::cout << "Deleted ACL entry for " << entity << " in bucket "
            << bucket_name << "\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 imprime la LCA del objeto predeterminado de un bucket:

Ver en GitHubComentarios

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

public class PrintBucketDefaultAclSample
{
    public IEnumerable<ObjectAccessControl> PrintBucketDefaultAcl(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });

        foreach (var acl in bucket.DefaultObjectAcl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }

        return bucket.DefaultObjectAcl;
    }
}

En el siguiente ejemplo, se agrega una LCA de objeto predeterminada a un bucket:

Ver en GitHubComentarios

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

public class AddBucketDefaultOwnerSample
{
    public Bucket AddBucketDefaultOwner(
        string bucketName = "your-unique-bucket-name",
        string userEmail = "[e-mail]")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });

        bucket.DefaultObjectAcl.Add(new ObjectAccessControl
        {
            Bucket = bucketName,
            Entity = $"user-{userEmail}",
            Role = "OWNER",
        });
        var updatedBucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Added user {userEmail} as a default owner on bucket {bucketName}.");
        return updatedBucket;
    }
}

En la siguiente tabla, se borra una LCA de objeto predeterminada de un bucket:

Ver en GitHubComentarios

using Google.Cloud.Storage.V1;
using System;
using System.Linq;

public class RemoveBucketDefaultOwnerSample
{
    public void RemoveBucketDefaultOwner(
        string bucketName = "your-unique-bucket-name",
        string userEmail = "[e-mail]")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });
        if (bucket.DefaultObjectAcl == null)
        {
            Console.WriteLine("No default owner to remove");
        }
        else
        {
            bucket.DefaultObjectAcl = bucket.DefaultObjectAcl.Where(acl => !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")).ToList();
            var updatedBucket = storage.UpdateBucket(bucket);
            Console.WriteLine($"Removed user {userEmail} from bucket {bucketName}.");
        }
    }
}

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 agrega una LCA de objeto predeterminada a un bucket:

Ver en GitHubComentarios

import (
	"context"
	"fmt"

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

// addBucketDefaultOwner adds default ACL to the specified bucket.
func addBucketDefaultOwner(bucket string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// entity := storage.AllUsers
	role := storage.RoleOwner

	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).DefaultObjectACL()
	if err := acl.Set(ctx, entity, role); err != nil {
		return fmt.Errorf("ACLHandle.Set: %v", err)
	}
	return nil
}

En la siguiente tabla, se borra una LCA de objeto predeterminada de un bucket:

Ver en GitHubComentarios

import (
	"context"
	"fmt"

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

// deleteDefaultBucketACL removes default ACL from a bucket.
func removeBucketDefaultOwner(bucket string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// entity := storage.AllUsers
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).DefaultObjectACL()
	if err := acl.Delete(ctx, entity); err != nil {
		return fmt.Errorf("ACLHandle.Delete: %v", err)
	}
	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 agrega una LCA de objeto predeterminada a un bucket:

Ver en GitHubComentarios

Acl acl =
    storage.createDefaultAcl(bucketName, Acl.of(User.ofAllAuthenticatedUsers(), Role.READER));

En la siguiente tabla, se borra una LCA de objeto predeterminada de un bucket:

Ver en GitHubComentarios

boolean deleted = storage.deleteDefaultAcl(bucketName, User.ofAllAuthenticatedUsers());
if (deleted) {
  // the acl entry was deleted
} else {
  // the acl entry was not found
}

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 agrega una LCA de objeto predeterminada a un bucket:

Ver en GitHubComentarios

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

// The email address of the user to add
// const userEmail = 'user-email-to-add';

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

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

async function addBucketDefaultOwner() {
  // Makes the user an owner in the default ACL of the bucket. You can use
  // addAllUsers(), addDomain(), addProject(), addGroup(), and
  // addAllAuthenticatedUsers() to grant access to different types of entities.
  // You can also use "readers" and "writers" to grant different roles.
  await storage.bucket(bucketName).acl.default.owners.addUser(userEmail);

  console.log(`Added user ${userEmail} as an owner on bucket ${bucketName}.`);
}

addBucketDefaultOwner().catch(console.error);

En la siguiente tabla, se borra una LCA de objeto predeterminada de un bucket:

Ver en GitHubComentarios

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

// The email address of the user to remove
// const userEmail = 'user-email-to-remove';

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

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

async function removeBucketDefaultOwner() {
  // Removes the user from the access control list of the bucket. You can use
  // deleteAllUsers(), deleteDomain(), deleteProject(), deleteGroup(), and
  // deleteAllAuthenticatedUsers() to remove access for different types of entities.
  await storage.bucket(bucketName).acl.default.owners.deleteUser(userEmail);

  console.log(`Removed user ${userEmail} from bucket ${bucketName}.`);
}

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

En el siguiente ejemplo, se agrega una LCA de objeto predeterminada a un bucket:

Ver en GitHubComentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Add an entity and role to a bucket's default ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $entity The entity for which to update access controls.
 * @param string $role The permissions to add for the specified entity.
 */
function add_bucket_default_acl($bucketName, $entity, $role)
{
    // $bucketName = 'my-bucket';
    // $entity = '[e-mail]';
    // $role = 'OWNER';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->defaultAcl();
    $acl->add($entity, $role);
    printf('Added %s (%s) to gs://%s default ACL' . PHP_EOL, $entity, $role, $bucketName);
}

En la siguiente tabla, se borra una LCA de objeto predeterminada de un bucket:

Ver en GitHubComentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from a bucket's default ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $entity The entity for which to update access controls.
 */
function delete_bucket_default_acl($bucketName, $entity)
{
    // $bucketName = 'my-bucket';
    // $entity = '[e-mail]';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->defaultAcl();
    $acl->delete($entity);
    printf('Deleted %s from gs://%s default ACL' . PHP_EOL, $entity, $bucketName);
}

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 agrega una LCA de objeto predeterminada a un bucket:

Ver en GitHubComentarios

from google.cloud import storage

def add_bucket_default_owner(bucket_name, user_email):
    """Adds a user as an owner in the given bucket's default object access
    control list."""
    # bucket_name = "your-bucket-name"
    # user_email = "[e-mail]"

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

    # Reload fetches the current ACL from Cloud Storage.
    bucket.acl.reload()

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # grant access to different types of entities. You can also use
    # `grant_read` or `grant_write` to grant different roles.
    bucket.default_object_acl.user(user_email).grant_owner()
    bucket.default_object_acl.save()

    print(
        "Added user {} as an owner in the default acl on bucket {}.".format(
            user_email, bucket_name
        )
    )

En la siguiente tabla, se borra una LCA de objeto predeterminada de un bucket:

Ver en GitHubComentarios

from google.cloud import storage

def remove_bucket_default_owner(bucket_name, user_email):
    """Removes a user from the access control list of the given bucket's
    default object access control list."""
    # bucket_name = "your-bucket-name"
    # user_email = "[e-mail]"

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

    # Reload fetches the current ACL from Cloud Storage.
    bucket.acl.reload()

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # remove access for different types of entities.
    bucket.default_object_acl.user(user_email).revoke_read()
    bucket.default_object_acl.user(user_email).revoke_write()
    bucket.default_object_acl.user(user_email).revoke_owner()
    bucket.default_object_acl.save()

    print(
        "Removed user {} from the default acl of bucket {}.".format(
            user_email, 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 agrega una LCA de objeto predeterminada a un bucket:

Ver en GitHubComentarios

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.default_acl.add_owner email

puts "Added default OWNER permission for #{email} to #{bucket_name}"

En la siguiente tabla, se borra una LCA de objeto predeterminada de un bucket:

Ver en GitHubComentarios

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.default_acl.delete email

puts "Removed default ACL permissions for #{email} from #{bucket_name}"

API de JSON

1. Recupera la LCA de objeto predeterminada con una solicitud GET. Por ejemplo:

   curl -X GET -H "Authorization: Bearer OAUTH2_TOKEN" 
   
   https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?projection=full

2. Usa una solicitud de parche para reemplazar la LCA de objeto predeterminada. Por ejemplo, con la siguiente solicitud, se reemplaza la LCA de objeto predeterminada por la LCA especificada en defacls.json para un bucket example-travel-maps:

   curl -X PATCH --data @defacls.json -H "Content-Type: application/json" -H "Authorization: Bearer OAUTH2_TOKEN" 
   
   https://storage.googleapis.com/storage/v1/b/example-travel-maps

   El siguiente es un ejemplo de defacls.json:

   {
   "defaultObjectAcl": [
   {
   "email": "[e-mail]",
   "entity": "[e-mail]",
   "role": "READER"
   }
   ]
   }
   

API de XML

1. Recupera la LCA de objeto predeterminada con una solicitud GET con el alcance acotado a tu bucket y el parámetro ?defaultObjectAcl. Por ejemplo:

   curl -X GET -H "Authorization: Bearer OAUTH2_TOKEN" 
   
   https://storage.googleapis.com/BUCKET_NAME?defaultObjectAcl

2. Usa una solicitud PUT con el alcance acotado a tu bucket y el parámetro ?defaultObjectAcl para reemplazar la LCA de objeto predeterminada por la LCA especificada en acls.xml. Por ejemplo:

   curl -X PUT --data-binary @acls.xml -H "Authorization: Bearer OAUTH2_TOKEN" 
   
   http://storage.googleapis.com/BUCKET_NAME?defaultObjectAcl

   Un ejemplo de acls.xml:

   <AccessControlList>
   <Entries>
   <Entry>
   <Permission>FULL_CONTROL</Permission>
   <Scope type="GroupByEmail">
   <EmailAddress>[e-mail]</EmailAddress>
   </Scope>
   </Entry>
   </Entries>
   </AccessControlList>

La sintaxis de las LCA se describen en Establece LCA. También puedes especificar una LCA predefinida como la LCA de objeto predeterminada.

Para establecer la LCA de objeto predeterminada de un bucket como una LCA predefinida, haz lo siguiente:

Console

No puedes establecer LCA de objeto predeterminadas con Cloud Console. En su lugar, usa gsutil.

gsutil

Usa el comando gsutil defacl con el nombre de la LCA predefinida.

Por ejemplo, para establecer la LCA de objeto predeterminada como project-private en el bucket example-travel-maps, haz lo siguiente:

gsutil defacl set project-private gs://example-travel-maps

API de JSON

Usa una solicitud PUT y el parámetro predefinedAcl.

Un ejemplo es el siguiente:

curl -X PUT -H "Content-Length: 0" -H "Authorization: Bearer OAUTH2_TOKEN" 

https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?predefinedAcl=private

API de XML

Usa una solicitud PUT con el alcance acotado a tu bucket, el parámetro ?defaultObjectAcl y el encabezado x-goog-acl.

Un ejemplo es el siguiente:

curl -X PUT -H "x-goog-acl: project-private" -H "Content-Length: 0" -H "Authorization: Bearer OAUTH2_TOKEN" 

http://storage.googleapis.com/BUCKET_NAME?defaultObjectAcl

LCA de objeto predeterminadas para un bucket recién creado

A continuación, se muestran las LCA de objeto predeterminadas para un bucket recién creado. Compáralas con las LCA de objeto predeterminadas de tu bucket para ver si las LCA de objeto predeterminadas se modificaron.

Console

No puedes trabajar con LCA de objeto predeterminadas en Cloud Console. En su lugar, usa gsutil.

gsutil

En el ejemplo siguiente, el ID del proyecto es “123412341234”; el tuyo será diferente.

[
{
"entity": "project-owners-123412341234",
"projectTeam": {
  "projectNumber": "123412341234",
  "team": "owners"
},
"role": "OWNER"
},
{
"entity": "project-editors-123412341234",
"projectTeam": {
  "projectNumber": "123412341234",
  "team": "editors"
},
"role": "OWNER"
},
{
"entity": "project-viewers-123412341234",
"projectTeam": {
  "projectNumber": "123412341234",
  "team": "viewers"
},
"role": "READER"
}
]

API de JSON

En el ejemplo siguiente, el ID del proyecto es “123412341234”; el tuyo será diferente.

defaultObjectAcl": [
{
"kind": "storage#objectAccessControl",
"entity": "project-owners-123412341234",
"role": "OWNER",
"projectTeam": {
"projectNumber": "123412341234",
"team": "owners"
}
},
{
"kind": "storage#objectAccessControl",
"entity": "project-editors-123412341234",
"role": "OWNER",
"projectTeam": {
"projectNumber": "123412341234",
"team": "editors"
}
},
{
"kind": "storage#objectAccessControl",
"entity": "project-viewers-123412341234",
"role": "READER",
"projectTeam": {
"projectNumber": "123412341234",
"team": "viewers"
}
}
]

API de XML

En el siguiente ejemplo, los ID de función del proyecto comienzan con “00b4903a97…”; tus ID de proyecto serán diferentes.

<?xml version='1.0' encoding='UTF-8'?>
<AccessControlList>
<Entries>
<Entry>
  <Scope type='GroupById'>
    <ID>00b4903a9721...</ID>
  </Scope>
  <Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
  <Scope type='GroupById'>
    <ID>00b4903a9722...</ID>
  </Scope>
  <Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
  <Scope type='GroupById'>
    <ID>00b4903a9723...</ID>
  </Scope>
  <Permission>READ</Permission>
</Entry>
</Entries>
</AccessControlList>

Ten en cuenta que la LCA de objeto predeterminada para un bucket recién creado es equivalente a la LCA projectPrivate predefinida.

Recupera las LCA

Para obtener la LCA de un objeto o bucket existente, haz lo siguiente:

Console

Nota: No puedes usar Cloud Console para obtener LCA en buckets; solo puede usarse a fin de obtenerlas en objetos individuales.

1. En Cloud Console, ve al navegador de Cloud Storage.
   Ir al navegador de Cloud Storage

2. Navega al objeto cuya LCA deseas ver.

3. Elige Editar permisos en el menú desplegable del objeto.

   Deberías ver un diálogo con los permisos 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 gsutil acl get para mostrar la LCA de un objeto.

Por ejemplo, para mostrar la LCA del objeto paris.jpg en el bucket example-travel-maps, haz lo siguiente:

gsutil acl get gs://example-travel-maps/paris.jpg

Respuesta de ejemplo:

[
{
    "entity": "project-owners-123412341234",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "owners"
    },
    "role": "OWNER"
},
{
    "entity": "project-editors-123412341234",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "editors"
    },
    "role": "OWNER"
},
{
    "entity": "project-viewers-123412341234",
    "projectTeam": {
      "projectNumber": "123412341234",
      "team": "viewers"
    },
    "role": "READER"
},
{
    "email": "[e-mail]",
    "entity": "[e-mail]",
    "role": "READER"
},
{
    "email": "[e-mail]",
    "entity": "[e-mail]",
    "role": "READER"
},
{
    "entity": "allUsers",
    "role": "READER"
},
{
    "entity": "allAuthenticatedUsers",
    "role": "READER"
}
]

Para mostrar la LCA de un depósito, haz lo siguiente:

gsutil acl get gs://BUCKET_NAME

Cuando gsutil muestra las LCA de los depósitos y objetos con gsutil acl get, tienen el mismo formato JSON que puedes usar para establecer las LCA. Las LCA en formato JSON usan los nombres de propiedad de la API de JSON, como entity y role.

Consulta la sintaxis de la API de JSON para obtener más información sobre cómo interpretar el resultado o ejecutar gsutil help acls.

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++.

En el ejemplo siguiente, se obtiene una LCA de bucket:

Ver en GitHubComentarios

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<std::vector<gcs::BucketAccessControl>> items =
      client.ListBucketAcl(bucket_name);

  if (!items) throw std::runtime_error(items.status().message());
  std::cout << "ACLs for bucket=" << bucket_name << "\n";
  for (gcs::BucketAccessControl const& acl : *items) {
    std::cout << acl.role() << ":" << acl.entity() << "\n";
  }
}

En el siguiente ejemplo, se obtiene una LCA de objeto:

Ver en GitHubComentarios

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& object_name) {
  StatusOr<std::vector<gcs::ObjectAccessControl>> items =
      client.ListObjectAcl(bucket_name, object_name);

  if (!items) throw std::runtime_error(items.status().message());
  std::cout << "ACLs for object=" << object_name << " in bucket "
            << bucket_name << "\n";
  for (gcs::ObjectAccessControl const& acl : *items) {
    std::cout << acl.role() << ":" << acl.entity() << "\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 ejemplo siguiente, se obtiene una LCA de bucket:

Ver en GitHubComentarios

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

public class PrintBucketAclSample
{
    public IEnumerable<BucketAccessControl> PrintBucketAcl(string bucketName = "your-unique-bucket-name")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });

        foreach (var acl in bucket.Acl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }

        return bucket.Acl;
    }
}

En el siguiente ejemplo, se obtiene una LCA de objeto:

Ver en GitHubComentarios

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

public class PrintFileAclSample
{
    public IEnumerable<ObjectAccessControl> PrintObjectAcl(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions
        {
            Projection = Projection.Full
        });

        foreach (var acl in storageObject.Acl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }

        return storageObject.Acl;
    }
}

Go

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

En el ejemplo siguiente, se obtiene una LCA de bucket:

Ver en GitHubComentarios

import (
	"context"
	"fmt"
	"io"

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

// printBucketACL lists bucket ACL.
func printBucketACL(w io.Writer, bucket string) error {
	// bucket := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	rules, err := client.Bucket(bucket).ACL().List(ctx)
	if err != nil {
		return fmt.Errorf("ACLHandle.List: %v", err)
	}
	for _, rule := range rules {
		fmt.Fprintf(w, "ACL rule: %v\n", rule)
	}
	return nil
}

En el siguiente ejemplo, se obtiene una LCA de objeto:

Ver en GitHubComentarios

import (
	"context"
	"fmt"
	"io"

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

// printFileACL lists ACL of the specified object.
func printFileACL(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()

	rules, err := client.Bucket(bucket).Object(object).ACL().List(ctx)
	if err != nil {
		return fmt.Errorf("ACLHandle.List: %v", err)
	}
	for _, rule := range rules {
		fmt.Fprintf(w, "ACL rule: %v\n", rule)
	}
	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 ejemplo siguiente, se obtiene una LCA de bucket:

Ver en GitHubComentarios

Acl acl = storage.getAcl(bucketName, User.ofAllAuthenticatedUsers());

En el siguiente ejemplo, se obtiene una LCA de objeto:

Ver en GitHubComentarios

BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
Acl acl = storage.getAcl(blobId, User.ofAllAuthenticatedUsers());

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 ejemplo siguiente, se obtiene una LCA de bucket:

Ver en GitHubComentarios

/**
 * 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} = require('@google-cloud/storage');

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

async function printBucketAcl() {
  // Gets the ACL for the bucket
  const [acls] = await storage.bucket(bucketName).acl.get();

  acls.forEach(acl => {
    console.log(`${acl.role}: ${acl.entity}`);
  });
}
printBucketAcl().catch(console.error);

En el siguiente ejemplo, se obtiene una LCA de objeto:

Ver en GitHubComentarios

/**
 * 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 printFileAcl() {
  // Gets the ACL for the file
  const [acls] = await storage.bucket(bucketName).file(fileName).acl.get();

  acls.forEach(acl => {
    console.log(`${acl.role}: ${acl.entity}`);
  });
}

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

En el ejemplo siguiente, se obtiene una LCA de bucket:

Ver en GitHubComentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Print all entities and roles for a bucket's ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 */
function get_bucket_acl($bucketName)
{
    // $bucketName = 'my-bucket';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->acl();
    foreach ($acl->get() as $item) {
        printf('%s: %s' . PHP_EOL, $item['entity'], $item['role']);
    }
}

En el siguiente ejemplo, se obtiene una LCA de objeto:

Ver en GitHubComentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Print all entities and roles for an object's ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 */
function get_object_acl($bucketName, $objectName)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    foreach ($acl->get() as $item) {
        printf('%s: %s' . PHP_EOL, $item['entity'], $item['role']);
    }
}

Python

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

En el ejemplo siguiente, se obtiene una LCA de bucket:

Ver en GitHubComentarios

from google.cloud import storage

def print_bucket_acl(bucket_name):
    """Prints out a bucket's access control list."""

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

    for entry in bucket.acl:
        print("{}: {}".format(entry["role"], entry["entity"]))

En el siguiente ejemplo, se obtiene una LCA de objeto:

Ver en GitHubComentarios

from google.cloud import storage

def print_blob_acl(bucket_name, blob_name):
    """Prints out a blob's access control list."""

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

    for entry in blob.acl:
        print("{}: {}".format(entry["role"], entry["entity"]))

Ruby

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

En el ejemplo siguiente, se obtiene una LCA de bucket:

Ver en GitHubComentarios

# 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

puts "ACL for #{bucket_name}:"

bucket.acl.owners.each do |owner|
  puts "OWNER #{owner}"
end

bucket.acl.writers.each do |writer|
  puts "WRITER #{writer}"
end

bucket.acl.readers.each do |reader|
  puts "READER #{reader}"
end

En el siguiente ejemplo, se obtiene una LCA de objeto:

Ver en GitHubComentarios

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# file_name   = "Name of a file in the Storage bucket"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

puts "ACL for #{file_name} in #{bucket_name}:"

file.acl.owners.each do |owner|
  puts "OWNER #{owner}"
end

file.acl.readers.each do |reader|
  puts "READER #{reader}"
end

API de JSON

1. Asegúrate de tener permiso OWNER en el objeto o bucket.

2. Recupera la LCA de un objeto o bucket con una solicitud GET.

   La LCA de objeto se muestra en el formato JSON adjunta al cuerpo de la respuesta.

Por ejemplo, para mostrar la LCA del objeto paris.jpg en el bucket example-travel-maps, haz lo siguiente:

curl -X GET -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" 

 https://storage.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg?projection=full

Deberías ver una respuesta similar a esta:

{
"kind": "storage#object",
"id": "example-travel-maps/paris.jpg/1412805837131000",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg",
"name": "paris.jpg",
"bucket": "example-travel-maps",
...
"acl": [
{
...
"entity": "project-owners-867489160491",
"role": "OWNER",
"projectTeam": {
    "projectNumber": "867489160491",
    "team": "owners"
},
...
},
{
...
"entity": "[e-mail]",
"role": "OWNER",
"email": "[e-mail]",
...
},
{
...
"entity": "[e-mail]",
"role": "READER",
"email": "[e-mail]",
...
}
],
"owner": {
"entity": "[e-mail]"
},
...
}

También puedes usar el método GET de recurso objectAccessControls para mostrar entradas individuales de la LCA de un objeto.

API de XML

1. Asegúrate de tener permiso FULL_CONTROL en el objeto o bucket.

2. Recupera la LCA del objeto o bucket con el parámetro de string de consulta acl en una solicitud GET de objeto.

Las LCA se describen en XML, adjuntas al cuerpo de la respuesta.

Por ejemplo, para mostrar la LCA del objeto paris.jpg en el bucket example-travel-maps, haz lo siguiente:

curl -X GET -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" 

 https://storage.googleapis.com/example-travel-maps/paris.jpg?acl

Deberías ver una respuesta similar a esta:

<?xml version="1.0" encoding="UTF-8"?>
<AccessControlList>
<Owner>
<ID>84fac329bceSAMPLE777d5d22b8SAMPLE77d85ac2SAMPLE2dfcf7c4adf34da46</ID>
<Name>Owner Name</Name>
</Owner>
<Entries>
<Entry>
  <Scope type="UserById">
    <ID>84fac329bceSAMPLE777d5d22b8SAMPLE77d85ac2SAMPLE2dfcf7c4adf34da46</ID>
    <Name>Name</Name>
  </Scope>
  <Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
  <Scope type="UserByEmail">
    <EmailAddress>[e-mail]</EmailAddress>
    <Name>Jane</Name>
  </Scope>
  <Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
  <Scope type="GroupByEmail">
    <EmailAddress>[e-mail]</EmailAddress>
  </Scope>
  <Permission>READ</Permission>
</Entry>
</Entries>
</AccessControlList>

También puedes usar el método JSON GET del recurso ObjectAccessControls para mostrar una entrada específica de la LCA.

Precaución: Las LCA funcionan de forma independiente de los permisos de IAM. Puedes usar estos dos métodos de control de acceso para personalizar tus permisos. Sin embargo, si otorgas acceso a tus depósitos y objetos mediante permisos de IAM, estos no aparecerán en las LCA de objetos o depósitos individuales (excepto las funciones legacyBucket).

Cambia las LCA

Para cambiar la LCA de un objeto o bucket existente, haz lo siguiente:

Console

Nota: No puedes usar Cloud Console para cambiar las LCA de los buckets; solo puedes usarlo a fin de modificar las de objetos individuales.

1. En Cloud Console, ve al navegador de Cloud Storage.
   Ir al navegador de Cloud Storage

2. Navega al objeto cuya LCA deseas modificar.

3. Elige Editar permisos en el menú desplegable del objeto.

   Deberías ver un diálogo con los permisos del objeto.

En el siguiente ejemplo, se muestra cómo otorgar el permiso OWNER al usuario [e-mail] y el permiso READER a los miembros del grupo gs-announce para el objeto paris.jpg:

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

1. Define las LCA en un archivo.

2. Pasa el archivo de LCA a gsutil acl set y especifica el objeto para activar las LCA.

Por ejemplo, para aplicar las LCA desde el archivo acls.txt de un objeto llamado paris.jpg en el bucket example-travel-maps, haz lo siguiente:

gsutil acl set acl.txt gs://example-travel-maps/paris.jpg

El contenido de acl.txt se muestra a continuación. Estas LCA otorgan a los propietarios del proyecto 867489160491 y al usuario [e-mail] el permiso OWNER para el objeto paris.jpg, y otorgan a los miembros del grupo gs-announce el permiso READER:

[
{
"entity": "project-owners-867489160491",
"role": "OWNER",
"projectTeam": {
    "projectNumber": "867489160491",
    "team": "owners"
},
},
{
"entity": "[e-mail]",
"email": "[e-mail]",
"role": "OWNER"
},
{
"entity": "[e-mail]",
"email": "[e-mail]",
"role": "READER"
}
]

También puedes establecer la misma LCA para este objeto con otorgamientos individuales. Por ejemplo, para otorgar el acceso READER al usuario [e-mail], usa lo siguiente:

gsutil acl ch -u [e-mail]:READ gs://example-travel-maps/paris.jpg

.

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++.

En el ejemplo siguiente, se quita la LCA de un bucket:

Ver en GitHubComentarios

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& entity) {
  StatusOr<gcs::BucketMetadata> original_metadata =
      client.GetBucketMetadata(bucket_name, gcs::Projection::Full());

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

  std::vector<gcs::BucketAccessControl> original_acl =
      original_metadata->acl();
  auto it = std::find_if(original_acl.begin(), original_acl.end(),
                         [entity](gcs::BucketAccessControl const& entry) {
                           return entry.entity() == entity &&
                                  entry.role() ==
                                      gcs::BucketAccessControl::ROLE_OWNER();
                         });

  if (it == original_acl.end()) {
    std::cout << "Could not find entity " << entity
              << " with role OWNER in bucket " << bucket_name << "\n";
    return;
  }

  gcs::BucketAccessControl owner = *it;
  google::cloud::Status status =
      client.DeleteBucketAcl(bucket_name, owner.entity());

  if (!status.ok()) throw std::runtime_error(status.message());
  std::cout << "Deleted ACL entry for " << owner.entity() << " in bucket "
            << bucket_name << "\n";
}

En el siguiente ejemplo, se quita la LCA de un objeto:

Ver en GitHubComentarios

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& entity) {
  StatusOr<gcs::ObjectMetadata> original_metadata = client.GetObjectMetadata(
      bucket_name, object_name, gcs::Projection::Full());

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

  std::vector<gcs::ObjectAccessControl> original_acl =
      original_metadata->acl();
  auto it = std::find_if(original_acl.begin(), original_acl.end(),
                         [entity](gcs::ObjectAccessControl const& entry) {
                           return entry.entity() == entity &&
                                  entry.role() ==
                                      gcs::ObjectAccessControl::ROLE_OWNER();
                         });

  if (it == original_acl.end()) {
    std::cout << "Could not find entity " << entity << " for file "
              << object_name << " with role OWNER in bucket " << bucket_name
              << "\n";
    return;
  }

  gcs::ObjectAccessControl owner = *it;
  google::cloud::Status status =
      client.DeleteObjectAcl(bucket_name, object_name, owner.entity());

  if (!status.ok()) throw std::runtime_error(status.message());
  std::cout << "Deleted ACL entry for " << owner.entity() << " for file "
            << object_name << " in bucket " << bucket_name << "\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 ejemplo siguiente, se quita la LCA de un bucket:

Ver en GitHubComentarios

using Google.Cloud.Storage.V1;
using System;
using System.Linq;

public class RemoveBucketOwnerSample
{
    public void RemoveBucketOwner(
        string bucketName = "your-unique-bucket-name",
        string userEmail = "[e-mail]")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName, new GetBucketOptions { Projection = Projection.Full });
        if (bucket.Acl == null)
        {
            Console.WriteLine("No owner to remove");
        }
        else
        {
            bucket.Acl = bucket.Acl.Where(acl => !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")).ToList();
            var updatedBucket = storage.UpdateBucket(bucket);
            Console.WriteLine($"Removed user {userEmail} from bucket {bucketName}.");
        }
    }
}

En el siguiente ejemplo, se quita la LCA de un objeto:

Ver en GitHubComentarios

using Google.Cloud.Storage.V1;
using System;
using System.Linq;

public class RemoveFileOwnerSample
{
    public void RemoveFileOwner(
        string bucketName = "your-unique-bucket-name",
        string objectName = "your-object-name",
        string userEmail = "[e-mail]")
    {
        var storage = StorageClient.Create();
        var storageObject = storage.GetObject(bucketName, objectName, new GetObjectOptions { Projection = Projection.Full });
        if (storageObject.Acl == null)
        {
            Console.WriteLine("No owner to remove");
        }
        else
        {
            storageObject.Acl = storageObject.Acl.Where((acl) => !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")).ToList();
            var updatedObject = storage.UpdateObject(storageObject);
            Console.WriteLine($"Removed user {userEmail} from file {objectName}.");
        }
    }
}

Go

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

En el ejemplo siguiente, se quita la LCA de un bucket:

Ver en GitHubComentarios

import (
	"context"
	"fmt"

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

// removeBucketOwner removes ACL from a bucket.
func removeBucketOwner(bucket string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// entity := storage.AllUsers
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).ACL()
	if err := acl.Delete(ctx, entity); err != nil {
		return fmt.Errorf("ACLHandle.Delete: %v", err)
	}
	return nil
}

En el siguiente ejemplo, se quita la LCA de un objeto:

Ver en GitHubComentarios

import (
	"context"
	"fmt"

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

// removeFileOwner removes default ACL from the given object.
func removeFileOwner(bucket, object string, entity storage.ACLEntity) error {
	// bucket := "bucket-name"
	// object := "object-name"
	// entity := storage.AllUsers
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Delete(ctx, entity); err != nil {
		return fmt.Errorf("ACLHandle.Delete: %v", err)
	}
	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 ejemplo siguiente, se quita la LCA de un bucket:

Ver en GitHubComentarios

boolean deleted = storage.deleteAcl(bucketName, User.ofAllAuthenticatedUsers());
if (deleted) {
  // the acl entry was deleted
} else {
  // the acl entry was not found
}

En el siguiente ejemplo, se quita la LCA de un objeto:

Ver en GitHubComentarios

BlobId blobId = BlobId.of(bucketName, blobName, blobGeneration);
boolean deleted = storage.deleteAcl(blobId, User.ofAllAuthenticatedUsers());
if (deleted) {
  // the acl entry was deleted
} else {
  // the acl entry was not found
}

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 ejemplo siguiente, se quita la LCA de un bucket:

Ver en GitHubComentarios

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

// The email address of the user to remove
// const userEmail = 'user-email-to-remove';

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

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

async function removeBucketOwner() {
  // Removes the user from the access control list of the bucket. You can use
  // deleteAllUsers(), deleteDomain(), deleteProject(), deleteGroup(), and
  // deleteAllAuthenticatedUsers() to remove access for different types of entities.
  await storage.bucket(bucketName).acl.owners.deleteUser(userEmail);

  console.log(`Removed user ${userEmail} from bucket ${bucketName}.`);
}

removeBucketOwner().catch(console.error);

En el siguiente ejemplo, se quita la LCA de un objeto:

Ver en GitHubComentarios

/**
 * 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';

// The email address of the user to remove
// const userEmail = 'user-email-to-remove';

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

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

async function removeFileOwner() {
  // Removes the user from the access control list of the file. You can use
  // deleteAllUsers(), deleteDomain(), deleteProject(), deleteGroup(), and
  // deleteAllAuthenticatedUsers() to remove access for different types of entities.
  await storage
    .bucket(bucketName)
    .file(fileName)
    .acl.owners.deleteUser(userEmail);

  console.log(`Removed user ${userEmail} from file ${fileName}.`);
}

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

En el ejemplo siguiente, se quita la LCA de un bucket:

Ver en GitHubComentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from a bucket's default ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $entity The entity for which to update access controls.
 */
function delete_bucket_acl($bucketName, $entity)
{
    // $bucketName = 'my-bucket';
    // $entity = '[e-mail]';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->acl();
    $acl->delete($entity);
    printf('Deleted %s from gs://%s ACL' . PHP_EOL, $entity, $bucketName);
}

En el siguiente ejemplo, se quita la LCA de un objeto:

Ver en GitHubComentarios

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from an object's ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $entity The entity for which to update access controls.
 */
function delete_object_acl($bucketName, $objectName, $entity)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $entity = '[e-mail]';

    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    $acl->delete($entity);
    printf('Deleted %s from gs://%s/%s ACL' . PHP_EOL, $entity, $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 ejemplo siguiente, se quita la LCA de un bucket:

Ver en GitHubComentarios

from google.cloud import storage

def remove_bucket_owner(bucket_name, user_email):
    """Removes a user from the access control list of the given bucket."""
    # bucket_name = "your-bucket-name"
    # user_email = "[e-mail]"

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

    # Reload fetches the current ACL from Cloud Storage.
    bucket.acl.reload()

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # remove access for different types of entities.
    bucket.acl.user(user_email).revoke_read()
    bucket.acl.user(user_email).revoke_write()
    bucket.acl.user(user_email).revoke_owner()
    bucket.acl.save()

    print("Removed user {} from bucket {}.".format(user_email, bucket_name))

En el siguiente ejemplo, se quita la LCA de un objeto:

Ver en GitHubComentarios

from google.cloud import storage

def remove_blob_owner(bucket_name, blob_name, user_email):
    """Removes a user from the access control list of the given blob in the
    given bucket."""
    # bucket_name = "your-bucket-name"
    # blob_name = "your-object-name"
    # user_email = "[e-mail]"

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

    # You can also use `group`, `domain`, `all_authenticated` and `all` to
    # remove access for different types of entities.
    blob.acl.user(user_email).revoke_read()
    blob.acl.user(user_email).revoke_write()
    blob.acl.user(user_email).revoke_owner()
    blob.acl.save()

    print(
        "Removed user {} from blob {} in bucket {}.".format(
            user_email, blob_name, 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 ejemplo siguiente, se quita la LCA de un bucket:

Ver en GitHubComentarios

# project_id  = "Your Google Cloud project ID"
# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.acl.delete email

puts "Removed ACL permissions for #{email} from #{bucket_name}"

En el siguiente ejemplo, se quita la LCA de un objeto:

Ver en GitHubComentarios

# The ID of your GCS bucket
# bucket_name = "your-unique-bucket-name"
# file_name   = "Name of a file in the Storage bucket"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

file.acl.delete email

puts "Removed ACL permissions for #{email} from #{file_name}"

API de JSON

1. Define las LCA en un archivo de JSON.

2. Envía una solicitud de parche con el archivo JSON y especifica el objeto en el que establecerás las LCA.

Por ejemplo, con el siguiente comando cURL, se aplica una carga útil de JSON del documento acls.json a un objeto llamado paris.jpg en el bucket example-travel-maps:

curl -X PATCH --data @acls.json -H "Content-Type: application/json" 

 -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" 

 https://storage.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg

Si con la LCA se otorga a los propietarios del proyecto 867489160491 y al usuario [e-mail] el permiso OWNER, además de otorgar a los miembros del grupo gs-announce el permiso READER, la solicitud se parecerá al siguiente ejemplo:

PATCH /storage/v1/b/example-travel-maps/o/paris.jpg HTTP/1.1
Host: www.googleapis.com
Content-Type: application/json
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
Content-Length: 597
Date: Wed, 08 Oct 2014 22:37:58 GMT
{
"acl": [
{
"entity": "project-owners-867489160491",
"role": "OWNER",
"projectTeam": {
    "projectNumber": "867489160491",
    "team": "owners"
},
{
"entity": "[e-mail]",
"role": "OWNER",
"email": "[e-mail]"
},
{
"entity": "[e-mail]",
"role": "READER",
"email": "[e-mail]"
}
]
}

API de XML

1. Define las LCA en un documento XML.

2. Envía una solicitud PUT Object con el parámetro de string de consulta acl y el documento XML correspondiente.

Con el siguiente comando cURL, se aplica una carga útil de XML desde el documento acls.xml hasta un objeto llamado paris.jpg en el bucket example-travel-maps:

curl -X PUT --data-binary @acls.xml 

 -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" 

 https://storage.googleapis.com/example-travel-maps/paris.jpg?acl

Si la LCA otorga al usuario [e-mail] el permiso FULL_CONTROL y a los miembros del grupo gs-announce el permiso READ, la solicitud se parecerá al siguiente ejemplo:

PUT /paris.jpg?acl HTTP/1.1
Host: example-travel-maps.storage.googleapis.com
Date: Sat, 20 Feb 2010 08:31:08 GMT
Content-Length: 589
Content-Type=application/xml
Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg
 
<?xml version='1.0' encoding='utf-8'?>
<AccessControlList>
<Owner>
<ID>84fac329bceSAMPLE777d5d22b8SAMPLE77d85ac2SAMPLE2dfcf7c4adf34da46</ID>
</Owner>
<Entries>
<Entry>
<Permission>FULL_CONTROL</Permission>
<Scope type="UserById">
  <ID>84fac329bceSAMPLE777d5d22b8SAMPLE77d85ac2SAMPLE2dfcf7c4adf34da46</ID>
</Scope>
</Entry>
<Entry>
<Scope type="UserByEmail">
  <EmailAddress>[e-mail]</EmailAddress>
  <Name>Jane</Name>
</Scope>
<Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
<Scope type="GroupByEmail">
  <EmailAddress>[e-mail]</EmailAddress>
</Scope>
<Permission>READ</Permission>
</Entry>
</Entries>
</AccessControlList>

Próximos pasos

• Obtén más información sobre las Listas de control de acceso (LCA).
• Para aprender a simplificar el control de acceso, consulta Usa el acceso uniforme a nivel de bucket .