Crea y administra Listas de control de acceso (LCA)

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 depósitos y objetos y qué nivel de acceso tienen. Para obtener más información sobre las LCA, consulta la Descripción general de las LCA.

Para obtener información sobre otras formas de controlar el acceso a los depósitos 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, Cloud Identity and Access Management (Cloud 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 Platform y permite que recursos secundarios, como depósitos y objetos, hereden permisos otorgados a recursos superiores, como son los proyectos. Consulta Usa permisos de Cloud IAM como guía para trabajar con Cloud IAM en Cloud Storage.

Es probable que quieras usar las LCA si necesitas personalizar el acceso a objetos individuales dentro de un depósito, ya que los permisos de Cloud IAM se aplican a todos los objetos dentro de un depósito. Sin embargo, deberías usar Cloud IAM para cualquier acceso que sea común a todos los objetos en un depósito, ya que reduce la cantidad de administración detallada que debes llevar a cabo.

¿Necesitas establecer una LCA?

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

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

En depósitos:

Console

Los depósitos nuevos se crean con la LCA project-private predefinida. Si tu depósito necesita un permiso diferente, establece una LCA.

gsutil

Los depósitos nuevos se agregan como project-private. Si tu depósito necesita un permiso diferente, establece una LCA.

API de JSON

Por configuración predeterminada, los depósitos nuevos se agregan como project-private. Si tu depósito necesita un permiso diferente, establece una LCA.

API de XML

Los depósitos nuevos se agregan como project-private. Si tu depósito 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 depósito. Cuando copias un objeto que ya está 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 depósito.

API de XML

Los objetos nuevos se agregan con la LCA de objeto predeterminada al depósito.

¿Qué interfaz deberías usar?

Los ejemplos de abajo muestran cómo configurar el control de acceso con Google Cloud Platform Console, la herramienta de línea de comandos de gsutil y las bibliotecas cliente de Cloud Storage y las API de XML y JSON. Usa los lineamientos siguientes para elegir cuál usar:

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

  • Si eres nuevo en el control de acceso y solo deseas modificar las LCA para depósitos 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. Puedes obtener tokens de autorización para usar en los ejemplos de cURL en OAuth 2.0 Playground.

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 lucen diferentes, pero contienen la misma información de LCA: entradas que otorgan permisos a alcances.

Console

  1. Dirígete al navegador de Cloud Storage en GCP Console.
    Ir al navegador de Cloud Storage

  2. Navega al objeto cuya LCA deseas modificar.

  3. Elige Edit Permissions (Editar permisos) en el menú desplegable del objeto.

    Deberías ver un diálogo de permiso que luce de la manera siguiente:

    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 o 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 o 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 Alcances de control de acceso para obtener una lista de los valores compatibles con Entidad.

  6. Ingresa un valor en Name (Nombre).

    Nombre identifica a un usuario, grupo o algún otro tipo de entidad específica. Consulta Alcances de control de acceso para obtener una lista de los valores compatibles con 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 Permisos de control de acceso para obtener una lista de los valores compatibles con Acceso.

  8. Haz clic en Save (Guardar).

gsutil

Usa gsutil acl para especificar las LCA:

  • Para especificar otorgamientos individuales, ingresa esta 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.

Ejemplos de código

C++

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

En el ejemplo siguiente, se agrega una LCA a un depósito:

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string entity,
   std::string role) {
  StatusOr<gcs::BucketAccessControl> bucket_acl =
      client.CreateBucketAcl(bucket_name, entity, role);
  if (!bucket_acl.ok()) {
    std::cerr << "Failure getting bucket ACL for entity " << entity
              << " in bucket " << bucket_name
              << ", status=" << bucket_acl.status() << std::endl;
    return;
  }
  std::cout << "Role " << bucket_acl->role() << " granted to "
            << bucket_acl->entity() << " on bucket " << bucket_acl->bucket()
            << "\n"
            << "Full attributes: " << *bucket_acl << std::endl;
}

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

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string object_name,
   std::string entity, std::string role) {
  StatusOr<gcs::ObjectAccessControl> object_acl =
      client.CreateObjectAcl(bucket_name, object_name, entity, role);
  if (!object_acl.ok()) {
    std::cerr << "Error creating object ACL entry for entity " << entity
              << " in object " << object_name << " and bucket " << bucket_name
              << ", status=" << object_acl.status() << std::endl;
    return;
  }
  std::cout << "Role " << object_acl->role() << " granted to "
            << object_acl->entity() << " on " << object_acl->object()
            << "\nFull attributes: " << *object_acl << std::endl;
}

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 depósito:

private void AddBucketOwner(string bucketName, string userEmail)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (null == bucket.Acl)
    {
        bucket.Acl = new List<BucketAccessControl>();
    }
    bucket.Acl.Add(new BucketAccessControl()
    {
        Bucket = bucketName,
        Entity = $"user-{userEmail}",
        Role = "OWNER",
    });
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

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

private void AddObjectOwner(string bucketName, string objectName,
    string userEmail)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName,
        new GetObjectOptions() { Projection = Projection.Full });
    if (null == storageObject.Acl)
    {
        storageObject.Acl = new List<ObjectAccessControl>();
    }
    storageObject.Acl.Add(new ObjectAccessControl()
    {
        Bucket = bucketName,
        Entity = $"user-{userEmail}",
        Role = "OWNER",
    });
    var updatedObject = storage.UpdateObject(storageObject, new UpdateObjectOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = storageObject.Metageneration,
    });
}

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 depósito:

func addBucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).ACL()
	if err := acl.Set(ctx, storage.AllAuthenticatedUsers, storage.RoleReader); err != nil {
		return err
	}
	return nil
}

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

func addObjectACL(client *storage.Client, bucket, object string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Set(ctx, storage.AllAuthenticatedUsers, storage.RoleReader); err != nil {
		return 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 depósito:

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

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

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 depósito:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const userEmail = 'Email of user to add, e.g. developer@company.com';

// 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}.`);

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

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'Name of file to access, e.g. file.txt';
// const userEmail = 'Email of user to add, e.g. developer@company.com';

// Makes the user an owner of the file. 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)
  .file(filename)
  .acl.owners.addUser(userEmail);

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

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 depósito:

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 to update access controls for.
 * @param string $role The permissions to add for the specified entity. May
 *        be one of 'OWNER', 'READER', or 'WRITER'.
 * @param array $options
 *
 * @return void
 */
function add_bucket_acl($bucketName, $entity, $role, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->acl();
    $acl->add($entity, $role, $options);
    printf('Added %s (%s) to gs://%s ACL' . PHP_EOL, $entity, $role, $bucketName);
}

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

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 to update access controls for.
 * @param string $role The permissions to add for the specified entity. May
 *        be one of 'OWNER', 'READER', or 'WRITER'.
 * @param array $options
 *
 * @return void
 */
function add_object_acl($bucketName, $objectName, $entity, $role, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    $acl->add($entity, $role, $options);
    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 depósito:

def add_bucket_owner(bucket_name, user_email):
    """Adds a user as an owner on the given bucket."""
    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 ejemplo siguiente, se agrega una LCA a un objeto:

def add_blob_owner(bucket_name, blob_name, user_email):
    """Adds a user as an owner on the given blob."""
    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 depósito:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.acl.add_owner email

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

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

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage 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 project_id: project_id
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 depósito, puedes especificar la propiedad acl[] en una solicitud de inserción. Para un depósito 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 obtener definiciones de las propiedades de LCA del depósito y del objeto, consulta los recursos BucketAccessControls y ObjectAccessControls, de forma respectiva.

El ejemplo siguiente, se muestran entradas diferentes de LCA de depósito.

"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/group-gs-announce@googlegroups.com",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/group-gs-announce@googlegroups.com",
"bucket": "example-bucket",
"entity": "group-gs-announce@googlegroups.com",
"role": "READER",
"email": "gs-announce@googlegroups.com",
"etag": "CDk="
},
{
"kind": "storage#bucketAccessControl",
"id": "example-bucket/user-jane@gmail.com",
"selfLink": "https://www.googleapis.com/storage/v1/b/example-bucket/acl/user-jane@gmail.com",
"bucket": "example-bucket",
"entity": "user-jane@gmail.com",
"role": "READER",
"email": "jane@gmail.com",
"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 depósito y del objeto. Se muestra un documento XML cuando obtienes las LCA del depósito y del objeto. El documento XML contiene entradas de LCA del objeto o depósito individual.

  • Luego de crear un depósito con una solicitud de depósito PUT, usa una segunda solicitud de depósito PUT con el parámetro ?acl para cambiar la LCA del depósito.

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

Usa la sintaxis de LCA siguiente para la API de XML. Ten en cuenta que el esquema de formato de sintaxis compacta RELAX NG describe los requisitos de formato exactos del XML de la LCA de Google.

Elemento Descripción
AccessControlList Contenedor de elementos Owner y Entries.
Owner Contenedor de elementos ID y DisplayName. 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 usas la sintaxis de la LCA de Amazon S3 en una situación de migración.

Amazon Simple Storage Service™ y Amazon S3™ son maras registradas de Amazon.com, Inc. o sus afiliados en Estados Unidos y otros países.
ID ID de Google Cloud Storage del propietario del depósito.
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 de elementos Permission y Scope. Una Entry debe contener solo un Scope y un elemento de Permission.
Scope Contenedor para un ID, EmailAddress o elemento de Domain que define el alcance de la LCA. Este elemento debe tener el atributo type que contiene uno de los valores siguientes: UserByID, UserByEmail, GroupByID, GroupByEmail, GroupByDomain, AllUsers o AllAuthenticatedUsers.
ID Un identificador para el beneficiario cuando la entrada de permiso la especifica el ID.
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 la entrada de permiso la especifica el dominio.
Name Elemento opcional que puede especificarse 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:

  • Solo puedes usar el formato XML descripto arriba.
  • 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 alcance de elemento de jane@example.com.

En el ejemplo siguiente, se muestran diferentes entradas de LCA de depósito.

<?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>gs-announce@googlegroups.com</EmailAddress>
      </Scope>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="UserByEmail">
        <EmailAddress>jane@gmail.com</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 XML de la LCA

Cuando recuperas una LCA de un depósito o un objeto, quizás veas un elemento <Name> adicional anexado a alguna de tus entradas. Por ejemplo, quizás veas una entrada que luce de la manera siguiente:

<Entry>
    <Scope type="UserByEmail">
      <EmailAddress>jane@gmail.com</EmailAddress>
      <Name>Jane</Name>
    </Scope>
    <Permission>FULL_CONTROL</Permission>
</Entry>

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

  1. Cuando la LCA del depósito o del objeto incluye <Name> como un elemento.

    Cuando estableces tus LCA, puedes elegir incluir el elemento <Name> con tus entradas de LCA. Puedes proporcionar cualquier valor en el elemento <Name> y Cloud Storage recuerda estos valores hasta que se quita o se 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 alguno de estos niveles sin proporcionar el elemento <Name>, Cloud Storage verifica si el usuario o el grupo de Google asociado con la dirección de correo electrónico tienen un perfil público de Google con un nombre público. Si es así, Cloud Storage propaga de manera 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 depósito 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 GCP Console. En su lugar, usa gsutil.

gsutil

Usa 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 mientras se sube un objeto paris.jpg a un depósito example-travel-maps:

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

API de JSON

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

Por ejemplo, para aplicar la LCA predefinida bucketOwnerRead mientras se sube un objeto paris.jpg a un depósito example-travel-maps:

curl -X POST --data-binary @paris.jpg -H "Content-Type: image/jpeg" 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
"https://www.googleapis.com/upload/storage/v1/b/example-travel-maps/o?name=paris.jpg&predefinedAcl=bucketOwnerRead"

La solicitud se ve como el ejemplo siguiente:

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 de objeto Put para aplicar la LCA predefinida.

Por ejemplo, para aplicar la LCA predefinida bucket-owner-read mientras se sube un objeto paris.jpg a un depósito example-travel-maps:

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 ejemplo siguiente:

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 depósito 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 GCP Console. En su lugar, usa gsutil.

gsutil

Usa 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 depósito example-travel-maps:

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 acl vacía en una solicitud de parche para aplicar la LCA predefinida.

Por ejemplo, para aplicar la LCA predefinida private al objeto paris.jpg en el depósito example-travel-maps:

curl -X PATCH --data '{"acl": []}'  -H "Content-Type: application/json" 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
https://www.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg?predefinedAcl=private

La solicitud se ve como el ejemplo siguiente:

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 de objeto Put, pero no incluyas un documento XML en tu solicitud.

Por ejemplo, para aplicar la LCA predefinida private al objeto paris.jpg en el depósito example-travel-maps:

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 ejemplo siguiente:

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 depósito. Una vez que haces esto, se le aplicará la LCA predeterminada a cada objeto nuevo agregado a ese depósito 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 depósito determinado. Puedes cambiar la LCA de objeto predeterminada y, luego, agregar objetos al depósito. La LCA de objeto predeterminada que especificas se aplica de forma automática a estos objetos agregados. Sin embargo, puedes otorgar diferentes LCA a objetos específicos, caso en el que esos objetos no tengan aplicada la LCA predeterminada.

Para ver y cambiar la LCA de objeto predeterminada de un depósito, haz lo siguiente:

Console

No puedes establecer LCA de objeto predeterminada con GCP 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 comando siguiente, se agrega jane@gmail.com a la lista de LCA de objeto predeterminada de un depósito example-travel-maps:

    gsutil defacl ch -u jane@gmail.com: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 guía de ayuda de gsutil defacl.

Ejemplos de código

C++

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

En la muestra siguiente, se agrega una LCA de objeto predeterminada a un depósito:

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string entity,
   std::string role) {
  StatusOr<gcs::ObjectAccessControl> default_object_acl =
      client.CreateDefaultObjectAcl(bucket_name, entity, role);
  if (!default_object_acl.ok()) {
    std::cerr << "Failure getting default object ACL for entity " << entity
              << " in bucket " << bucket_name
              << ", status=" << default_object_acl.status() << std::endl;
    return;
  }
  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 << std::endl;
}

En la tabla siguiente, se borra una LCA de objeto predeterminada de un depósito:

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string entity) {
  StatusOr<void> status = client.DeleteDefaultObjectAcl(bucket_name, entity);
  if (!status.ok()) {
    std::cerr << "Failure deleting default object ACL for entity " << entity
              << " in bucket " << bucket_name
              << ", status=" << status.status() << std::endl;
    return;
  }
  std::cout << "Deleted ACL entry for " << entity << " in bucket "
            << bucket_name << std::endl;
}

C#

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

En la muestra siguiente, se agrega una LCA de objeto predeterminada a un depósito:

private void AddBucketDefaultOwner(string bucketName, string userEmail)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (null == bucket.Acl)
    {
        bucket.Acl = new List<BucketAccessControl>();
    }
    if (null == bucket.DefaultObjectAcl)
    {
        bucket.DefaultObjectAcl = new List<ObjectAccessControl>();
    }
    bucket.DefaultObjectAcl.Add(new ObjectAccessControl()
    {
        Bucket = bucketName,
        Entity = $"user-{userEmail}",
        Role = "OWNER",
    });
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

En la tabla siguiente, se borra una LCA de objeto predeterminada de un depósito:

private void RemoveBucketDefaultOwner(string bucketName, string userEmail)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (null == bucket.DefaultObjectAcl)
        return;
    if (null == bucket.Acl)
    {
        bucket.Acl = new List<BucketAccessControl>();
    }
    bucket.DefaultObjectAcl = bucket.DefaultObjectAcl.Where((acl) =>
         !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")
        ).ToList();
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

Go

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

En la muestra siguiente, se agrega una LCA de objeto predeterminada a un depósito:

func addDefaultBucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).DefaultObjectACL()
	if err := acl.Set(ctx, storage.AllAuthenticatedUsers, storage.RoleReader); err != nil {
		return err
	}
	return nil
}

En la tabla siguiente, se borra una LCA de objeto predeterminada de un depósito:

func deleteDefaultBucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).DefaultObjectACL()
	if err := acl.Delete(ctx, storage.AllAuthenticatedUsers); err != nil {
		return 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 la muestra siguiente, se agrega una LCA de objeto predeterminada a un depósito:

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

En la tabla siguiente, se borra una LCA de objeto predeterminada de un depósito:

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 la muestra siguiente, se agrega una LCA de objeto predeterminada a un depósito:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const userEmail = 'Email of user to add, e.g. developer@company.com';

// 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}.`);

En la tabla siguiente, se borra una LCA de objeto predeterminada de un depósito:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const userEmail = 'Email of user to remove, e.g. developer@company.com';

// 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}.`);

PHP

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

En la muestra siguiente, se agrega una LCA de objeto predeterminada a un depósito:

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 to update access controls for.
 * @param string $role The permissions to add for the specified entity. May
 *        be one of 'OWNER', 'READER', or 'WRITER'.
 * @param array $options
 *
 * @return void
 */
function add_bucket_default_acl($bucketName, $entity, $role, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->defaultAcl();
    $acl->add($entity, $role, $options);
    printf('Added %s (%s) to gs://%s default ACL' . PHP_EOL, $entity, $role, $bucketName);
}

En la tabla siguiente, se borra una LCA de objeto predeterminada de un depósito:

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 name of the entity to remove from the ACL.
 * @param array $options
 *
 * @return void
 */
function delete_bucket_default_acl($bucketName, $entity, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->defaultAcl();
    $acl->delete($entity, $options);
    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 la muestra siguiente, se agrega una LCA de objeto predeterminada a un depósito:

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."""
    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 tabla siguiente, se borra una LCA de objeto predeterminada de un depósito:

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."""
    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 la muestra siguiente, se agrega una LCA de objeto predeterminada a un depósito:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.default_acl.add_owner email

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

En la tabla siguiente, se borra una LCA de objeto predeterminada de un depósito:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id
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://www.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 solicitud siguiente, se reemplaza la LCA de objeto predeterminada con una LCA especificada en defacls.json de un depósito example-travel-maps:

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

    Un ejemplo de defacls.json:

    {
    "defaultObjectAcl": [
    {
    "email": "jane@gmail.com",
    "entity": "user-jane@gmail.com",
    "role": "READER"
    }
    ]
    }

API de XML

  1. Recupera la LCA de objeto predeterminada con una solicitud GET acotada a tu depósito 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 acotada a tu depósito con el parámetro ?defaultObjectAcl a fin de reemplazar la LCA de objeto predeterminada con 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>travel-companions@googlegroups.com</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 una LCA de objeto predeterminada de un depósito en una LCA predefinida:

Console

No puedes establecer LCA de objeto predeterminada con GCP 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 en project-private del depósito example-travel-maps:

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

API de JSON

Usa una solicitud PUT y el parámetro predefinedAcl.

Por ejemplo:

curl -X PUT -H "Content-Length: 0" -H "Authorization: Bearer [OAUTH2_TOKEN]" 
https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]?predefinedAcl=private

API de XML

Usa una solicitud PUT acotada a tu depósito con el parámetro ?defaultObjectAcl y el encabezado x-goog-acl.

Por ejemplo:

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 depósito recién creado:

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

Console

No puedes trabajar con las LCA de objeto predeterminadas con GCP 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 ejemplo siguiente, 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 depósito recién creado es equivalente a la LCA projectPrivate predefinida.

Recupera las LCA

Para obtener la LCA de un objeto o depósito existente, haz lo siguiente:

Console

  1. Dirígete al navegador de Cloud Storage en GCP Console.
    Ir al navegador de Cloud Storage

  2. Navega al objeto cuya LCA deseas modificar.

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

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

gsutil

Usa gsutil acl get para mostrar la LCA de un objeto.

Por ejemplo, para mostrar la LCA del objeto paris.jpg en el depósito example-travel-maps:

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": "gs-announce@googlegroups.com",
    "entity": "group-gs-announce@googlegroups.com",
    "role": "READER"
},
{
    "email": "jane@gmail.com",
    "entity": "user-jane@gmail.com",
    "role": "READER"
},
{
    "entity": "allUsers",
    "role": "READER"
},
{
    "entity": "allAuthenticatedUsers",
    "role": "READER"
}
]

Para mostrar la LCA de un depósito:

gsutil acl get gs://[BUCKET_NAME]

Cuando gsutil muestra las LCA de depósitos y objetos con gsutil acl get, se encuentran en el mismo formato de JSON que puedes usar para establecer LCA. Las LCA en formato de 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.

Ejemplos de código

C++

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

En el ejemplo siguiente, se obtiene una LCA de depósito:

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name) {
  StatusOr<std::vector<gcs::BucketAccessControl>> items =
      client.ListBucketAcl(bucket_name);
  if (!items.ok()) {
    std::cerr << "Error getting ACL entries for bucket " << bucket_name
              << ", status=" << items.status() << std::endl;
    return;
  }
  std::cout << "ACLs for bucket=" << bucket_name << std::endl;
  for (gcs::BucketAccessControl const& acl : *items) {
    std::cout << acl.role() << ":" << acl.entity() << std::endl;
  }
}

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

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string object_name,
   std::string entity) {
  StatusOr<gcs::ObjectAccessControl> acl =
      client.GetObjectAcl(bucket_name, object_name, entity);
  if (!acl.ok()) {
    std::cerr << "Error getting object ACL entry for entity " << entity
              << " in object " << object_name << " and bucket " << bucket_name
              << ", status=" << acl.status() << std::endl;
    return;
  }
  std::cout << "ACL entry for " << acl->entity() << " in object "
            << acl->object() << " in bucket " << acl->bucket() << " is "
            << *acl << std::endl;
}

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 depósito:

private void PrintBucketAcl(string bucketName)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (bucket.Acl != null)
        foreach (var acl in bucket.Acl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }
}

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

private void PrintObjectAcl(string bucketName, string objectName)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName,
        new GetObjectOptions() { Projection = Projection.Full });
    if (storageObject.Acl != null)
    {
        foreach (var acl in storageObject.Acl)
        {
            Console.WriteLine($"{acl.Role}:{acl.Entity}");
        }
    }
}

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 depósito:

func bucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

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

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

func objectACL(client *storage.Client, bucket, object string) error {
	ctx := context.Background()

	rules, err := client.Bucket(bucket).Object(object).ACL().List(ctx)
	if err != nil {
		return err
	}
	for _, rule := range rules {
		fmt.Printf("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 depósito:

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

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

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 depósito:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

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

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

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

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

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

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

// 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}`);
});

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 depósito:

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.
 *
 * @return Google\Cloud\Storage\Acl the ACL for the Cloud Storage bucket.
 */
function get_bucket_acl($bucketName)
{
    $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 ejemplo siguiente, se obtiene una LCA de objeto:

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.
 *
 * @return void
 */
function get_object_acl($bucketName, $objectName)
{
    $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 depósito:

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

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 depósito:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id
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 ejemplo siguiente, se obtiene una LCA de objeto:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage 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 project_id: project_id
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 depósito.

  2. Recupera la LCA de un objeto o depósito con una solicitud GET.

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

Por ejemplo, para mostrar la LCA del objeto paris.jpg en el depósito example-travel-maps:

curl -X GET -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" 
https://www.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg?projection=full

Deberías ver una respuesta similar a la siguiente:

{
"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": "user-jane@gmail.com",
"role": "OWNER",
"email": "jane@gmail.com",
...
},
{
...
"entity": "group-gs-announce@googlegroups.com",
"role": "READER",
"email": "gs-announce@googlegroups.com",
...
}
],
"owner": {
"entity": "user-jane@gmail.com"
},
...
}

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

API de XML

  1. Asegúrate de tener permiso FULL_CONTROL en el objeto o depósito.

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

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

Por ejemplo, para mostrar la LCA del objeto paris.jpg en el depósito example-travel-maps:

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 la siguiente:

<?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>jane@gmail.com</EmailAddress>
    <Name>Jane</Name>
  </Scope>
  <Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
  <Scope type="GroupByEmail">
    <EmailAddress>gs-announce@googlegroups.com</EmailAddress>
  </Scope>
  <Permission>READ</Permission>
</Entry>
</Entries>
</AccessControlList>

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

Cambia las LCA

Para cambiar la LCA de un objeto o depósito existente, haz lo siguiente:

Console

  1. Dirígete al navegador de Cloud Storage en GCP Console.
    Ir al navegador de Cloud Storage

  2. Navega al objeto cuya LCA deseas modificar.

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

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

En el ejemplo siguiente, se muestra cómo otorgar al usuario jane@gmail.com el permiso OWNER y, a los miembros del grupo gs-announce, el permiso READER en el objeto paris.jpg:

Establece una LCA en el objeto paris.jpg.

gsutil

  1. Define las LCA en un archivo.

  2. Pasa el archivo de LCA a gsutil acl set y especifica el objeto en el que establecerás las LCA.

Por ejemplo, para aplicar las LCA desde el archivo acls.txt en un objeto llamado paris.jpg en el depósito example-travel-maps:

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

A continuación, se muestran los contenidos de acl.txt. Estas LCA otorgan a los propietarios del proyecto 867489160491, junto con el usuario jane@gmail.com, el permiso OWNER para el objeto paris.jpg y otorgan a los miembros del grupo gs-announce el permiso READER en este objeto:

[
{
"entity": "project-owners-867489160491",
"role": "OWNER",
"projectTeam": {
    "projectNumber": "867489160491",
    "team": "owners"
},
},
{
"entity": "user-jane@gmail.com",
"email": "jane@gmail.com",
"role": "OWNER"
},
{
"entity": "group-gs-announce@googlegroups.com",
"email": "gs-announce@googlegroups.com",
"role": "READER"
}
]

También puedes establecer la misma LCA para este objeto con otorgamientos individuales. Por ejemplo, para otorgar al usuario jane@gmail.com acceso de READER, usa esta información:

gsutil acl ch -u jane@gmail.com:READ gs://example-travel-maps/paris.jpg
.

Ejemplos de código

C++

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

En el ejemplo siguiente, se quita la LCA de un depósito:

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string entity) {
  StatusOr<void> status = client.DeleteBucketAcl(bucket_name, entity);
  if (!status.ok()) {
    std::cerr << "Failure deleting ACL for entity " << entity << " in bucket "
              << bucket_name << ", status=" << status.status() << std::endl;
    return;
  }
  std::cout << "Deleted ACL entry for " << entity << " in bucket "
            << bucket_name << std::endl;
}

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

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string object_name,
   std::string entity) {
  StatusOr<void> status =
      client.DeleteObjectAcl(bucket_name, object_name, entity);
  if (!status.ok()) {
    std::cerr << "Error deleting object ACL entry for entity " << entity
              << " in object " << object_name << " and bucket " << bucket_name
              << ", status=" << status.status() << std::endl;
    return;
  }
  std::cout << "Deleted ACL entry for " << entity << " in object "
            << object_name << " in bucket " << bucket_name << std::endl;
}

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 depósito:

private void RemoveBucketOwner(string bucketName, string userEmail)
{
    var storage = StorageClient.Create();
    var bucket = storage.GetBucket(bucketName, new GetBucketOptions()
    {
        Projection = Projection.Full
    });
    if (null == bucket.Acl)
        return;
    bucket.Acl = bucket.Acl.Where((acl) =>
        !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")
        ).ToList();
    var updatedBucket = storage.UpdateBucket(bucket, new UpdateBucketOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = bucket.Metageneration,
    });
}

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

private void RemoveObjectOwner(string bucketName, string objectName,
    string userEmail)
{
    var storage = StorageClient.Create();
    var storageObject = storage.GetObject(bucketName, objectName,
        new GetObjectOptions() { Projection = Projection.Full });
    if (null == storageObject.Acl)
        return;
    storageObject.Acl = storageObject.Acl.Where((acl) =>
        !(acl.Entity == $"user-{userEmail}" && acl.Role == "OWNER")
        ).ToList();
    var updatedObject = storage.UpdateObject(storageObject, new UpdateObjectOptions()
    {
        // Avoid race conditions.
        IfMetagenerationMatch = storageObject.Metageneration,
    });
}

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 depósito:

func deleteBucketACL(client *storage.Client, bucket string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).ACL()
	if err := acl.Delete(ctx, storage.AllAuthenticatedUsers); err != nil {
		return err
	}
	return nil
}

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

func deleteObjectACL(client *storage.Client, bucket, object string) error {
	ctx := context.Background()

	acl := client.Bucket(bucket).Object(object).ACL()
	if err := acl.Delete(ctx, storage.AllAuthenticatedUsers); err != nil {
		return 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 depósito:

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

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

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 depósito:

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

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

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const userEmail = 'Email of user to remove, e.g. developer@company.com';

// 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}.`);

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

async function removeFileOwner(bucketName, filename, userEmail) {
  // Imports the Google Cloud client library
  const {Storage} = require('@google-cloud/storage');

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

  /**
   * TODO(developer): Uncomment the following line before running the sample.
   */
  // const bucketName = 'Name of a bucket, e.g. my-bucket';
  // const filename = 'Name of file to access, e.g. file.txt';
  // const userEmail = 'Email of user to remove, e.g. developer@company.com';

  // 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}.`);

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 depósito:

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 name of the entity to remove from the ACL.
 * @param array $options
 *
 * @return void
 */
function delete_bucket_acl($bucketName, $entity, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $acl = $bucket->acl();
    $acl->delete($entity, $options);
    printf('Deleted %s from gs://%s ACL' . PHP_EOL, $entity, $bucketName);
}

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

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 to update access controls for.
 * @param array $options
 *
 * @return void
 */
function delete_object_acl($bucketName, $objectName, $entity, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $acl = $object->acl();
    $acl->delete($entity, $options);
    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 depósito:

def remove_bucket_owner(bucket_name, user_email):
    """Removes a user from the access control list of the given bucket."""
    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 ejemplo siguiente, se quita la LCA de un objeto:

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."""
    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 depósito:

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage bucket name"
# email       = "Google Cloud Storage ACL Entity email"

require "google/cloud/storage"

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

bucket.acl.delete email

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

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

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Your Google Cloud Storage 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 project_id: project_id
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 de JSON y especifica el objeto en el que establecerás las LCA.

Por ejemplo, el comando cURL siguiente aplica una carga útil de JSON desde el documento acls.json hacia un objeto llamado paris.jpg en el depósito example-travel-maps:

curl -X PATCH --data @acls.json -H "Content-Type: application/json" 
-H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg"
https://www.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg

Si la LCA otorga a los propietarios del proyecto 867489160491 y al usuario jane@gmail.com permiso OWNER y, a los miembros del grupo gs-announce el permiso READER, la solicitud se verá de la manera siguiente:

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": "user-jane@gmail.com",
"role": "OWNER",
"email": "jane@gmail.com"
},
{
"entity": "group-gs-announce@googlegroups.com",
"role": "READER",
"email": "gs-announce@googlegroups.com"
}
]
}

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.

Por ejemplo, el comando cURL siguiente aplica una carga útil de XML del documento acls.xml a un objeto llamado paris.jpg en el depósito 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 jane@gmail.com el permiso FULL_CONTROL y, a los miembros del grupo gs-announce el permiso READ, la solicitud se verá de la manera siguiente:

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>jane@gmail.com</EmailAddress>
  <Name>Jane</Name>
</Scope>
<Permission>FULL_CONTROL</Permission>
</Entry>
<Entry>
<Scope type="GroupByEmail">
  <EmailAddress>gs-announce@googlegroups.com</EmailAddress>
</Scope>
<Permission>READ</Permission>
</Entry>
</Entries>
</AccessControlList>

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.