Crear y gestionar listas de control de acceso (ACL)

Descripción general

En esta página se describe cómo controlar el acceso a los segmentos y objetos mediante listas de control de acceso (LCA). Las LCA son un mecanismo que puedes usar para definir quién tiene acceso a tus segmentos y objetos, así como el nivel de acceso que tienen.

Consulta la descripción general de las LCAs para obtener más información sobre si debes usar LCAs para controlar el acceso a tus recursos.

Roles obligatorios

Para obtener los permisos que necesitas para crear y gestionar ACLs, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Administrador de Storage (roles/storage.admin) en el segmento que contiene los objetos para los que quieres crear y gestionar ACLs.

Este rol predefinido contiene los permisos necesarios para crear y gestionar ACLs. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

  • storage.buckets.get
  • storage.buckets.list
    • Este permiso solo es necesario para usar la Google Cloud consola para realizar las tareas de esta página.
  • storage.buckets.setIamPolicy
  • storage.buckets.update
  • storage.objects.get
  • storage.objects.getIamPolicy
  • storage.objects.setIamPolicy
  • storage.objects.update

También puedes obtener estos permisos con roles personalizados.

Para obtener información sobre cómo conceder roles en los contenedores, consulta Usar IAM con contenedores.

Definir o modificar LCAs

Consola

  1. Ve al navegador de Cloud Storage en la Google Cloud consola.
    Ir al navegador de Cloud Storage

  2. En la lista de segmentos, haga clic en el nombre del segmento que contiene el objeto cuya lista de control de acceso quiere modificar.

  3. Haga clic en el nombre del objeto para el que quiera definir o modificar las listas de control de acceso.

  4. Haz clic en Editar acceso.

    Se abrirá un cuadro de diálogo de permisos con la LCA actual del objeto.

  5. Haz clic en Añadir entrada.

  6. Elige el tipo de entidad al que quieres dar permiso.

    Entity especifica el tipo de elemento que recibe el permiso (por ejemplo, un usuario o un grupo). Consulta Ámbitos de control de acceso para ver una lista de los valores admitidos de Entity.

  7. Introduce un valor en Nombre.

    Nombre: identifica un usuario, un grupo u otro tipo de entidad específicos. Consulta Ámbitos de control de acceso para ver una lista de los valores admitidos en Nombre.

    Los campos Entidad y Nombre definen a quién se aplica el permiso.

  8. Elige un valor en Acceso.

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

  9. Haz clic en Guardar.

Para saber cómo obtener información detallada sobre los errores de las operaciones de Cloud Storage en la consola, consulta la sección Solución de problemas. Google Cloud

Línea de comandos

Para añadir, modificar o quitar una concesión individual en un objeto, usa el comando objects update con la marca correspondiente:

gcloud storage objects update gs://BUCKET_NAME/OBJECT_NAME FLAG

Donde:

  • BUCKET_NAME es el nombre del segmento que contiene el objeto al que se aplica la modificación. Por ejemplo, example-travel-maps.

  • OBJECT_NAME es el nombre del objeto al que se aplica la modificación. Por ejemplo, paris.jpg.

  • FLAG es uno de los siguientes elementos:

    • --add-acl-grant, junto con la concesión que quieras añadir o modificar. Por ejemplo, --add-acl-grant=entity=user-jeffersonloveshiking@gmail.com,role=READER.

    • --remove-acl-grant, junto con la entidad a la que quiere quitar el acceso. Por ejemplo, --remove-acl-grant=user-jeffersonloveshiking@gmail.com.

Para sustituir todas las listas de control de acceso de un objeto, sigue estos pasos:

  1. Define las ACLs en un archivo con formato JSON o YAML.

    Por ejemplo, las siguientes listas de control de acceso conceden el permiso OWNER para el objeto paris.jpg a los propietarios del proyecto 867489160491 y al usuario jeffersonloveshiking@gmail.com, así como el permiso READER para paris.jpg a los miembros del grupo gs-announce:

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

  2. Usa el comando objects update con la marca --acl-file:

    gcloud storage objects update gs://BUCKET_NAME/OBJECT_NAME --acl-file=FILE_LOCATION

    Donde:

    • BUCKET_NAME es el nombre del segmento que contiene el objeto al que se aplican las ACLs. Por ejemplo, example-travel-maps.

    • OBJECT_NAME es el nombre del objeto al que se aplican las LCA. Por ejemplo, paris.jpg.

    • FILE_LOCATION es la ruta local al archivo que contiene las ACLs que has definido. Por ejemplo, Desktop/acls.json.

Bibliotecas de cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA a un objeto:

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::move(patched_acl).status();
  std::cout << "ACL entry for " << patched_acl->entity() << " in object "
            << patched_acl->object() << " in bucket " << patched_acl->bucket()
            << " is now " << *patched_acl << "\n";
}

En el siguiente ejemplo se elimina una LCA de un objeto:

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::move(original_metadata).status();

  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#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA a un objeto:


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 = "dev@iam.gserviceaccount.com")
    {
        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;
    }
}

En el siguiente ejemplo se elimina una LCA de un objeto:


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 = "dev@iam.gserviceaccount.com")
    {
        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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA a un objeto:

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: %w", 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: %w", err)
	}
	return nil
}

En el siguiente ejemplo se elimina una LCA de un objeto:

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: %w", err)
	}
	defer client.Close()

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

Java

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA a un objeto:


import com.google.cloud.storage.Acl;
import com.google.cloud.storage.Acl.Role;
import com.google.cloud.storage.Acl.User;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class AddBlobOwner {

  public static void addBlobOwner(
      String projectId, String bucketName, String userEmail, String blobName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // Email of the user you wish to add as a file owner
    // String userEmail = "someuser@domain.com"

    // The name of the blob/file that you wish to modify permissions on
    // String blobName = "your-blob-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Blob blob = storage.get(BlobId.of(bucketName, blobName));
    Acl newOwner = Acl.of(new User(userEmail), Role.OWNER);

    blob.createAcl(newOwner);
    System.out.println(
        "Added user "
            + userEmail
            + " as an owner on blob "
            + blobName
            + " in bucket "
            + bucketName);
  }
}

En el siguiente ejemplo se elimina una LCA de un objeto:


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

public class RemoveBlobOwner {

  public static void removeBlobOwner(
      String projectId, String bucketName, String userEmail, String blobName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // Email of the user you wish to remove as a file owner
    // String userEmail = "someuser@domain.com"

    // The name of the blob/file that you wish to modify permissions on
    // String blobName = "your-blob-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Blob blob = storage.get(BlobId.of(bucketName, blobName));
    User ownerToRemove = new User(userEmail);

    boolean success = blob.deleteAcl(ownerToRemove);
    if (success) {
      System.out.println(
          "Removed user "
              + userEmail
              + " as an owner on file "
              + blobName
              + " in bucket "
              + bucketName);
    } else {
      System.out.println("User " + userEmail + " was not found");
    }
  }
}

Node.js

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA a un objeto:

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

En el siguiente ejemplo se elimina una LCA de un objeto:

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade 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.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $entity The entity for which to update access controls.
 *        (e.g. 'user-example@domain.com')
 * @param string $role The permissions to add for the specified entity.
 *        (e.g. 'OWNER')
 */
function add_object_acl(string $bucketName, string $objectName, string $entity, string $role): void
{
    $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);
}

En el siguiente ejemplo se elimina una 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.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $entity The entity for which to update access controls.
 *        (e.g. 'user-example@domain.com')
 */
function delete_object_acl(string $bucketName, string $objectName, string $entity): void
{
    $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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA a un objeto:

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 = "name@example.com"

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

En el siguiente ejemplo se elimina una LCA de un objeto:

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 = "name@example.com"

    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(
        f"Removed user {user_email} from blob {blob_name} in bucket {bucket_name}."
    )

Ruby

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA a un objeto:

# 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}"

En el siguiente ejemplo se elimina una LCA de un objeto:

# 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}"

APIs REST

API JSON

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 insert. En el caso de un objeto, especifica la propiedad acl[] o el parámetro de consulta predefinedAcl en una solicitud patch o update.

Para ver la definición de la propiedad ACL del objeto, consulta el recurso ObjectAccessControls.

  1. Define las ACLs en un archivo JSON.

    Por ejemplo, si la LCA concede a los propietarios del proyecto 867489160491 y al usuario jeffersonloveshiking@gmail.com OWNER permiso, además de conceder a los miembros del grupo gs-announce READER permiso, podrías tener un archivo llamado acls.json con el siguiente contenido:

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

  2. Envía una solicitud patch con el archivo JSON y especifica el objeto en el que se van a definir las ACLs.

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

curl -X PATCH --data @acls.json -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg

API XML

En la API XML, las LCAs se gestionan en formato XML. Debes adjuntar un documento XML al cuerpo de las solicitudes para cambiar las LCAs de segmentos y objetos. Se devuelve un documento XML cuando obtienes las LCA de un segmento y de un objeto. El documento XML contiene las entradas de LCA de los objetos o los contenedores individuales.

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

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

Por ejemplo, el siguiente comando curl aplica una carga útil XML del documento acls.xml a un objeto llamado paris.jpg en el contenedor example-travel-maps:

curl -X PUT --data-binary @acls.xml \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.googleapis.com/example-travel-maps/paris.jpg?acl

Utiliza la siguiente sintaxis de LCA para el documento XML:

Elemento Descripción
AccessControlList Contenedor de elementos Entries y Owner.
Owner Contenedor de elementos DisplayName y ID. Este elemento no es obligatorio para los objetos, ya que siempre son propiedad del usuario que los ha subido. Este elemento se usa cuando se utiliza la sintaxis de LCA de Amazon S3 en un caso de migración.

Amazon Simple Storage Service™ y Amazon S3™ son marcas de Amazon.com, Inc. o sus filiales en Estados Unidos u otros países.
ID ID de Cloud Storage del propietario del segmento.
DisplayName No se ha implementado. El valor siempre es una cadena vacía.
Entries Contenedor para cero o más elementos Entry.
Entry Contenedor de elementos Scope y Permission. Un elemento Entry solo puede contener un elemento Scope y un elemento Permission.
Scope Contenedor de un elemento ID, EmailAddress o Domain que define el ámbito 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 Identificador del beneficiario cuando la entrada de permiso se especifica por ID.
EmailAddress Identificador de correo del beneficiario cuando la entrada de permiso se especifica por correo.
Domain Identificador de dominio del beneficiario cuando la entrada de permiso se especifica por dominio.
Name Elemento opcional que se puede especificar o que se puede añadir automáticamente si el ámbito es UserByEmail o GroupByEmail.
Permission El permiso concedido READ, WRITE o FULL_CONTROL.

Cuando trabajes con listas de control de acceso mediante la API XML, ten en cuenta lo siguiente:

  • Solo puedes usar el formato XML descrito anteriormente.

  • No puedes definir ámbitos duplicados.

    Puede tener muchas entradas en su archivo XML de LCA, pero no puede tener entradas con ámbitos duplicados. Por ejemplo, no puede tener dos entradas con el mismo elemento de ámbito jane@example.com.

En el siguiente ejemplo se muestran diferentes entradas de ACL de un segmento:

<?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="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>jeffersonloveshiking@gmail.com</EmailAddress>
        <Name>Jefferson</Name>
      </Scope>
      <Permission>FULL_CONTROL</Permission>
    </Entry>
    <Entry>
      <Scope type="AllUsers"/>
      <Permission>READ</Permission>
    </Entry>
    <Entry>
      <Scope type="AllAuthenticatedUsers"/>
      <Permission>READ</Permission>
    </Entry>
  </Entries>
</AccessControlList>

Definir el elemento Name en el XML de la LCA

Cuando recupera una lista de control de acceso de un contenedor o un objeto, puede que vea un elemento <Name> adicional añadido a algunas de sus entradas. Por ejemplo, puede que veas una entrada como la siguiente:

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

Estos elementos <Name> opcionales se rellenan en dos casos:

  1. Cuando las ACLs del segmento o del objeto incluyen <Name> como elemento.

    Cuando definas las LCA, puedes incluir el elemento <Name> en tus entradas de LCA. Puede proporcionar cualquier valor en el elemento <Name> y Cloud Storage recordará estos valores hasta que se elimine o se sustituya la LCA. Este método puede ser útil si usas identificadores que no son fáciles de identificar.

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

    Si usas alguno de estos ámbitos, pero no proporcionas un elemento <Name> , Cloud Storage comprueba si el usuario o el grupo de Google asociado a la dirección de correo tiene un perfil público de Google con un nombre público. Si es así, Cloud Storage rellena automáticamente el elemento <Name> con el nombre público.

Aplicar una LCA predefinida

En lugar de especificar toda la LCA de una entrada cada vez, como se muestra arriba, puedes usar una LCA predefinida, que aplicará automáticamente una serie de entradas personalizadas para un caso concreto. Puedes aplicar una lista de control de acceso predefinida a un contenedor o a un objeto mediante la CLI de Google Cloud, la API JSON o la API XML.

En objetos nuevos

Para aplicar una LCA predefinida a un objeto durante la subida del objeto, sigue estos pasos:

Consola

No puedes aplicar una ACL predefinida mediante la Google Cloud consola. Usa gcloud storage en su lugar.

Línea de comandos

Usa el comando gcloud storage cp con la marca --predefined-acl:

gcloud storage cp OBJECT gs://BUCKET_NAME --predefined-acl=PREDEFINED_ACL

Por ejemplo, para aplicar la LCA predefinida bucketOwnerRead al subir un objeto paris.jpg a un segmento example-travel-maps:

gcloud storage cp paris.jpg gs://example-travel-maps --predefined-acl=bucketOwnerRead

APIs REST

API JSON

Utilice el parámetro de cadena de consulta predefinedAcl en una solicitud insert para aplicar la lista de control de acceso predefinida.

Por ejemplo, para aplicar la LCA predefinida bucketOwnerRead al subir un objeto paris.jpg a un segmento example-travel-maps:

curl -X POST --data-binary @paris.jpg -H "Content-Type: image/jpeg" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
    "https://storage.googleapis.com/upload/storage/v1/b/example-travel-maps/o?name=paris.jpg&predefinedAcl=bucketOwnerRead"

API XML

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

Por ejemplo, para aplicar la LCA predefinida bucket-owner-read al subir un objeto paris.jpg a un segmento example-travel-maps:

curl -X PUT --upload-file paris.jpg -H "x-goog-acl: bucket-owner-read" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
    https://storage.googleapis.com/example-travel-maps/paris.jpg

En segmentos u objetos ya creados

También puedes aplicar una LCA predefinida a un segmento u objeto que ya tengas, lo que resulta útil si quieres cambiar de una LCA predefinida a otra o si quieres actualizar las LCA personalizadas a una LCA predefinida.

Consola

No puedes aplicar una ACL predefinida mediante la Google Cloud consola. Usa gcloud storage en su lugar.

Línea de comandos

Usa el comando objects update con la marca --predefined-acl:

gcloud storage objects update gs://BUCKET_NAME/OBJECT_NAME --predefined-acl=PREDEFINED_ACL_NAME

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

gcloud storage objects update gs://example-travel-maps/paris.jpg --predefined-acl=private

APIs REST

API JSON

Usa el parámetro de cadena de consulta predefinedAcl y especifica una propiedad acl vacía en una solicitud patch para aplicar la ACL predefinida.

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

curl -X PATCH --data '{"acl": []}'  -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)"  \
    https://storage.googleapis.com/storage/v1/b/example-travel-maps/o/paris.jpg?predefinedAcl=private

API XML

Utilice el encabezado x-goog-acl con el parámetro de cadena de consulta acl en una solicitud Put Object, pero no incluya ningún documento XML en la solicitud.

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

curl -X PUT -H "Content-Length: 0" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "x-goog-acl: private" \
    https://storage.googleapis.com/example-travel-maps/paris.jpg?acl

Definir LCAs de objetos predeterminadas

Para no tener que definir las LCA cada vez que crees un objeto, puedes definir una LCA de objeto predeterminada en un segmento. Después de hacerlo, todos los objetos nuevos que se añadan a ese segmento y que no tengan una ACL aplicada explícitamente tendrán la ACL predeterminada. Por ejemplo, puede especificar que solo un grupo de usuarios determinado tenga acceso a la mayoría de los objetos de un determinado contenedor. Puede cambiar la LCA de objeto predeterminada y, a continuación, añadir objetos al segmento. Estos objetos añadidos tienen automáticamente aplicada la LCA de objeto predeterminada que hayas especificado. Sin embargo, puedes asignar diferentes LCA a objetos específicos, en cuyo caso esos objetos no tendrán aplicada la LCA predeterminada.

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

Consola

No puedes definir LCA de objeto predeterminadas con la Google Cloud consola. Usa gcloud storage en su lugar.

Línea de comandos

  1. Usa el comando buckets describe con la marca --format para obtener la LCA de objeto predeterminada del segmento:

    gcloud storage buckets describe gs://BUCKET_NAME --format="default(default_acl)"

    Donde BUCKET_NAME es el nombre del cubo cuya LCA de objeto predeterminada quieres ver. Por ejemplo, my-bucket.

  2. Usa el comando buckets update con la marca que quieras para modificar la LCA de objeto predeterminada del segmento:

    gcloud storage buckets update gs://BUCKET_NAME FLAG

    Donde:

    • BUCKET_NAME es el nombre del contenedor cuya LCA de objeto predeterminada quieres modificar. Por ejemplo, my-bucket.

    • FLAG es uno de los siguientes elementos:

      • --add-default-object-acl-grant y una concesión que quieras añadir a la LCA de objeto predeterminada general del segmento.

      • --default-object-acl-file y la ruta a un archivo local que define una nueva LCA de objeto predeterminada para el segmento.

      • --predefined-default-object-acl y el nombre de una LCA de objeto predefinida con la que quieras sustituir la LCA de objeto predeterminada del segmento.

      • --remove-default-object-acl-grant y una entidad que quieras quitar de la LCA de objeto predeterminada general del segmento.

Bibliotecas de cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA de objeto predeterminada a un segmento:

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::move(default_object_acl).status();

  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 el siguiente ejemplo se elimina una LCA de objeto predeterminada de un segmento:

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#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se imprime la LCA de objeto predeterminada de un segmento:


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 añade una LCA de objeto predeterminada a un segmento:


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 = "dev@iam.gserviceaccount.com")
    {
        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 el siguiente ejemplo se elimina una LCA de objeto predeterminada de un segmento:


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

public class RemoveBucketDefaultOwnerSample
{
    public void RemoveBucketDefaultOwner(
        string bucketName = "your-unique-bucket-name",
        string userEmail = "user@iam.gserviceaccount.com")
    {
        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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA de objeto predeterminada a un segmento:

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: %w", err)
	}
	defer client.Close()

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

En el siguiente ejemplo se elimina una LCA de objeto predeterminada de un segmento:

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: %w", err)
	}
	defer client.Close()

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

Java

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA de objeto predeterminada a un segmento:


import com.google.cloud.storage.Acl;
import com.google.cloud.storage.Acl.Role;
import com.google.cloud.storage.Acl.User;
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class AddBucketDefaultOwner {

  public static void addBucketDefaultOwner(String bucketName, String userEmail) {

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The email of the user you wish to add as a default owner
    // String userEmail = "someuser@domain.com"

    Storage storage = StorageOptions.newBuilder().build().getService();
    Bucket bucket = storage.get(bucketName);
    Acl newDefaultOwner = Acl.of(new User(userEmail), Role.OWNER);

    bucket.createDefaultAcl(newDefaultOwner);
    System.out.println("Added user " + userEmail + " as an owner on " + bucketName);
  }
}

En el siguiente ejemplo se elimina una LCA de objeto predeterminada de un segmento:


import com.google.cloud.storage.Acl.User;
import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class RemoveBucketDefaultOwner {

  public static void removeBucketDefaultOwner(String bucketName, String userEmail) {

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The email of the user you wish to remove as a default owner
    // String userEmail = "someuser@domain.com"

    Storage storage = StorageOptions.newBuilder().build().getService();
    Bucket bucket = storage.get(bucketName);
    User userToRemove = new User(userEmail);

    boolean success = bucket.deleteDefaultAcl(userToRemove);
    if (success) {
      System.out.println("Removed user " + userEmail + " as an owner on " + bucketName);
    } else {
      System.out.println("User " + userEmail + " was not found");
    }
  }
}

Node.js

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA de objeto predeterminada a un segmento:

/**
 * 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 el siguiente ejemplo se elimina una LCA de objeto predeterminada de un segmento:

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA de objeto predeterminada a un segmento:

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.
 *        (e.g. 'my-bucket')
 * @param string $entity The entity for which to update access controls.
 *        (e.g. 'user-example@domain.com')
 * @param string $role The permissions to add for the specified entity.
 *        (e.g. 'OWNER')
 */
function add_bucket_default_acl(string $bucketName, string $entity, string $role): void
{
    $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 el siguiente ejemplo se elimina una LCA de objeto predeterminada de un segmento:

use Google\Cloud\Storage\StorageClient;

/**
 * Delete an entity from a bucket's default ACL.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $entity The entity for which to update access controls.
 *        (e.g. 'user-example@domain.com')
 */
function delete_bucket_default_acl(string $bucketName, string $entity): void
{
    $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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA de objeto predeterminada a un segmento:

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 = "name@example.com"

    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 el siguiente ejemplo se elimina una LCA de objeto predeterminada de un segmento:

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 = "name@example.com"

    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(
        f"Removed user {user_email} from the default acl of bucket {bucket_name}."
    )

Ruby

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se añade una LCA de objeto predeterminada a un segmento:

# 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 el siguiente ejemplo se elimina una LCA de objeto predeterminada de un segmento:

# 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}"

APIs REST

API JSON

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

    curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?projection=full

  2. Usa una solicitud patch para sustituir la LCA de objeto predeterminada. Por ejemplo, la siguiente solicitud sustituye la LCA de objeto predeterminada por la LCA especificada en defacls.json para un segmento example-travel-maps:

    curl -X PATCH --data @defacls.json -H "Content-Type: application/json" -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.googleapis.com/storage/v1/b/example-travel-maps

    Ejemplo de defacls.json:

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

API XML

  1. Recupera la LCA de objeto predeterminada con una solicitud GET acotada a tu segmento y al parámetro ?defaultObjectAcl. Por ejemplo:

    curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.googleapis.com/BUCKET_NAME?defaultObjectAcl

  2. Usa una solicitud PUT con el ámbito de tu segmento y el parámetro ?defaultObjectAcl para sustituir la LCA de objeto predeterminada por la LCA especificada en acls.xml. Por ejemplo:

    curl -X PUT --data-binary @acls.xml -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    http://storage.googleapis.com/BUCKET_NAME?defaultObjectAcl

    Ejemplo de acls.xml:

    <AccessControlList>
  <Entries>
    <Entry>
      <Permission>FULL_CONTROL</Permission>
      <Scope type="UserByEmail">
        <EmailAddress>jeffersonloveshiking@gmail.com</EmailAddress>
      </Scope>
    </Entry>
  </Entries>
</AccessControlList>

La sintaxis de las listas de control de acceso se explica en el artículo Definir listas de control de acceso. También puede especificar una LCA predefinida como LCA de objeto predeterminada.

Para definir una LCA predefinida como LCA de objeto predeterminada de un segmento, haz lo siguiente:

Consola

No puedes definir LCA de objeto predeterminadas con la Google Cloud consola. Usa gcloud storage en su lugar.

Línea de comandos

Usa el comando buckets update con la marca --predefined-default-object-acl:

gcloud storage buckets update gs://BUCKET_NAME --predefined-default-object-acl=PREDEFINED_ACL

Donde:

  • BUCKET_NAME es el nombre del contenedor cuya LCA de objeto predeterminada quieres modificar. Por ejemplo, my-bucket.

  • PREDEFINED_ACL es el nombre de una LCA predefinida válida. Por ejemplo, projectPrivate.

APIs REST

API JSON

Usa una solicitud PUT y el parámetro predefinedAcl.

Por ejemplo:

curl -X PUT -H "Content-Length: 0" -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    https://storage.googleapis.com/storage/v1/b/BUCKET_NAME?predefinedAcl=private

API XML

Usa una solicitud PUT con el ámbito de tu contenedor, 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 $(gcloud auth print-access-token)" \
    http://storage.googleapis.com/BUCKET_NAME?defaultObjectAcl

LCAs de objeto predeterminadas para los segmentos recién creados:

En los ejemplos siguientes se muestran las listas de control de acceso de objetos predeterminadas que se aplican automáticamente a los contenedores recién creados cuando no especifica sus propias listas de control de acceso de objetos predeterminadas como parte de la solicitud. Para comprobar si se han cambiado las LCA de objeto predeterminadas de tu segmento, compara las LCA de objeto predeterminadas actuales de tu segmento con los ejemplos que se muestran a continuación.

Consola

No puedes trabajar con las LCA de objeto predeterminadas mediante la consola Google Cloud . En su lugar, usa gcloud storage.

Línea de comandos

En el ejemplo siguiente, el ID de proyecto es "123412341234", pero el tuyo será diferente.

defaultObjectAcl:
– entity: project-owners-123412341234
  etag: CAE=
  kind: storage#objectAccessControl
  projectTeam:
    projectNumber: '123412341234'
    team: owners
  role: OWNER
– entity: project-editors-123412341234
  etag: CAE=
  kind: storage#objectAccessControl
  projectTeam:
    projectNumber: '123412341234'
    team: editors
  role: OWNER
– entity: project-viewers-123412341234
  etag: CAE=
  kind: storage#objectAccessControl
  projectTeam:
    projectNumber: '123412341234'
    team: viewers
  role: READER

APIs REST

API JSON

En el ejemplo siguiente, el ID de proyecto es "123412341234", pero 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 XML

En el ejemplo siguiente, los IDs de rol de proyecto empiezan por "00b4903a97..."; los IDs de tu 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 de un segmento recién creado es equivalente a la LCA projectPrivate predefinida.

Obtener LCAs

Para obtener la ACL de un recurso, sigue estos pasos:

Consola

  1. Ve al navegador de Cloud Storage en la Google Cloud consola.
    Ir al navegador de Cloud Storage

  2. Desplázate hasta el objeto cuya lista de control de acceso quieras ver.

  3. En el menú desplegable del objeto, selecciona Editar acceso.

    Debería aparecer un cuadro de diálogo con los permisos del objeto.

Para saber cómo obtener información detallada sobre los errores de las operaciones de Cloud Storage en la consola, consulta la sección Solución de problemas. Google Cloud

Línea de comandos

  1. Usa el comando objects describe con la marca --format para obtener la LCA de un objeto:

    gcloud storage objects describe gs://BUCKET_NAME/OBJECT_NAME --format="default(acl)"

    Donde:

    • BUCKET_NAME es el nombre del contenedor que contiene el objeto cuya ACL quieres ver. Por ejemplo, my-bucket.

    • OBJECT_NAME es el nombre del objeto cuya ACL quieres ver. Por ejemplo, paris.jpg.

Bibliotecas de cliente

C++

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se obtiene la LCA de un objeto:

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::move(items).status();
  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#

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se obtiene la LCA de un objeto:


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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se obtiene la LCA de un objeto:

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: %w", err)
	}
	defer client.Close()

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

Java

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se obtiene la LCA de un objeto:


import com.google.cloud.storage.Acl;
import com.google.cloud.storage.Blob;
import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.util.List;

public class PrintBlobAcl {

  public static void printBlobAcl(String bucketName, String blobName) {

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The name of the blob/file that you wish to view Acls of
    // String blobName = "your-blob-name";

    Storage storage = StorageOptions.newBuilder().build().getService();
    Blob blob = storage.get(BlobId.of(bucketName, blobName));
    List<Acl> blobAcls = blob.getAcl();

    for (Acl acl : blobAcls) {

      // This will give you the role.
      // See https://cloud.google.com/storage/docs/access-control/lists#permissions
      String role = acl.getRole().name();

      // This will give you the Entity type (i.e. User, Group, Project etc.)
      // See https://cloud.google.com/storage/docs/access-control/lists#scopes
      String entityType = acl.getEntity().getType().name();

      System.out.printf("%s: %s %n", role, entityType);
    }
  }
}

Node.js

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se obtiene la LCA de un objeto:

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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se obtiene la LCA de un 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.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 */
function get_object_acl(string $bucketName, string $objectName): void
{
    $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

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se obtiene la LCA de un objeto:

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(f"{entry['role']}: {entry['entity']}")

Ruby

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

Para autenticarte en Cloud Storage, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

En el siguiente ejemplo se obtiene la LCA de un objeto:

# 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

APIs REST

API JSON

  1. Asegúrate de que tienes permiso OWNER en el objeto.

  2. Recupera la LCA del objeto con una solicitud GET.

    La ACL del objeto se devuelve en formato JSON, adjunta al cuerpo de la respuesta.

Por ejemplo, para devolver la lista de control de acceso del objeto paris.jpg del segmento example-travel-maps, haz lo siguiente:

curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    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": "user-jeffersonloveshiking@gmail.com",
      "role": "OWNER",
      "email": "jeffersonloveshiking@gmail.com",
      ...
    },
    {
      ...
      "entity": "group-gs-announce@googlegroups.com",
      "role": "READER",
      "email": "gs-announce@googlegroups.com",
      ...
    }
    ],
  "owner": {
    "entity": "user-jeffersonloveshiking@gmail.com"
  },
  ...
}

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

API XML

  1. Asegúrate de que tienes permiso FULL_CONTROL en el segmento o el objeto.

  2. Para obtener la LCA de un cubo o un objeto, utilice el parámetro de cadena de consulta acl en una solicitud GET Object.

Las ACLs se describen en XML y se adjuntan al cuerpo de la respuesta.

Por ejemplo, para devolver la lista de control de acceso del objeto paris.jpg del segmento example-travel-maps, haz lo siguiente:

curl -X GET -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    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>jeffersonloveshiking@gmail.com</EmailAddress>
        <Name>Jefferson</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 JSON GET del recurso ObjectAccessControls para devolver una entrada de ACL específica.

Siguientes pasos